| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | /* Socket module */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | This module provides an interface to Berkeley socket IPC. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | Limitations: | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | - Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  |   portable manner, though AF_PACKET and AF_NETLINK are supported under Linux. | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | - No read/write operations (use sendall/recv or makefile instead). | 
					
						
							|  |  |  | - Additional restrictions apply on some non-Unix platforms (compensated | 
					
						
							|  |  |  |   for by socket.py). | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-03-16 15:43:47 +00:00
										 |  |  | Module interface: | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-03-16 15:43:47 +00:00
										 |  |  | - socket.error: exception raised for socket specific errors | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | - socket.gaierror: exception raised for getaddrinfo/getnameinfo errors, | 
					
						
							|  |  |  | 	a subclass of socket.error | 
					
						
							|  |  |  | - socket.herror: exception raised for gethostby* errors, | 
					
						
							|  |  |  | 	a subclass of socket.error | 
					
						
							| 
									
										
										
										
											2002-09-03 19:10:18 +00:00
										 |  |  | - socket.fromfd(fd, family, type[, proto]) --> new socket object (created | 
					
						
							|  |  |  |         from an existing file descriptor) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd') | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...]) | 
					
						
							| 
									
										
										
										
											1995-03-16 15:43:47 +00:00
										 |  |  | - socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com') | 
					
						
							| 
									
										
										
										
											1996-12-19 16:42:52 +00:00
										 |  |  | - socket.getprotobyname(protocolname) --> protocol number | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | - socket.getservbyname(servicename[, protocolname]) --> port number | 
					
						
							|  |  |  | - socket.getservbyport(portnumber[, protocolname]) --> service name | 
					
						
							| 
									
										
										
										
											2002-09-03 19:10:18 +00:00
										 |  |  | - socket.socket([family[, type [, proto]]]) --> new socket object | 
					
						
							| 
									
										
										
										
											2004-08-09 04:51:41 +00:00
										 |  |  | - socket.socketpair([family[, type [, proto]]]) --> (socket, socket) | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | - socket.ntohs(16 bit value) --> new int object | 
					
						
							|  |  |  | - socket.ntohl(32 bit value) --> new int object | 
					
						
							|  |  |  | - socket.htons(16 bit value) --> new int object | 
					
						
							|  |  |  | - socket.htonl(32 bit value) --> new int object | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | - socket.getaddrinfo(host, port [, family, socktype, proto, flags]) | 
					
						
							|  |  |  | 	--> List of (family, socktype, proto, canonname, sockaddr) | 
					
						
							|  |  |  | - socket.getnameinfo(sockaddr, flags) --> (host, port) | 
					
						
							| 
									
										
										
										
											1995-03-16 15:43:47 +00:00
										 |  |  | - socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h> | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | - socket.has_ipv6: boolean value indicating if IPv6 is supported | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | - socket.inet_aton(IP address) -> 32-bit packed IP representation | 
					
						
							|  |  |  | - socket.inet_ntoa(packed IP) -> IP address string | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | - socket.getdefaulttimeout() -> None | float | 
					
						
							|  |  |  | - socket.setdefaulttimeout(None | float) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | - an Internet socket address is a pair (hostname, port) | 
					
						
							|  |  |  |   where hostname can be anything recognized by gethostbyname() | 
					
						
							|  |  |  |   (including the dd.dd.dd.dd notation) and port is in host byte order | 
					
						
							|  |  |  | - where a hostname is returned, the dd.dd.dd.dd notation is used | 
					
						
							| 
									
										
										
										
											1995-03-16 15:43:47 +00:00
										 |  |  | - a UNIX domain socket address is a string specifying the pathname | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | - an AF_PACKET socket address is a tuple containing a string | 
					
						
							|  |  |  |   specifying the ethernet interface and an integer specifying | 
					
						
							|  |  |  |   the Ethernet protocol number to be received. For example: | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  |   ("eth0",0x1234).  Optional 3rd,4th,5th elements in the tuple | 
					
						
							| 
									
										
										
										
											2004-07-10 23:39:35 +00:00
										 |  |  |   specify packet-type and ha-type/addr. | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | Local naming conventions: | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | - names starting with sock_ are socket object methods | 
					
						
							|  |  |  | - names starting with socket_ are module-level functions | 
					
						
							|  |  |  | - names starting with PySocket are exported through socketmodule.h | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | #ifdef __APPLE__
 | 
					
						
							|  |  |  |   /*
 | 
					
						
							|  |  |  |    * inet_aton is not available on OSX 10.3, yet we want to use a binary | 
					
						
							|  |  |  |    * that was build on 10.4 or later to work on that release, weak linking | 
					
						
							|  |  |  |    * comes to the rescue. | 
					
						
							|  |  |  |    */ | 
					
						
							|  |  |  | # pragma weak inet_aton
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | #include "Python.h"
 | 
					
						
							| 
									
										
										
										
											2006-03-17 19:17:34 +00:00
										 |  |  | #include "structmember.h"
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | #undef MAX
 | 
					
						
							|  |  |  | #define MAX(x, y) ((x) < (y) ? (y) : (x))
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | /* Socket object documentation */ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(sock_doc, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | "socket([family[, type[, proto]]]) -> socket object\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Open a socket of the given type.  The family argument specifies the\n\ | 
					
						
							|  |  |  | address family; it defaults to AF_INET.  The type argument specifies\n\ | 
					
						
							|  |  |  | whether this is a stream (SOCK_STREAM, this is the default)\n\ | 
					
						
							|  |  |  | or datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\n\ | 
					
						
							|  |  |  | specifying the default protocol.  Keyword arguments are accepted.\n\ | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | A socket object represents one endpoint of a network connection.\n\ | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Methods of socket objects (keyword arguments not allowed):\n\ | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | accept() -- accept a connection, returning new socket and client address\n\ | 
					
						
							|  |  |  | bind(addr) -- bind the socket to a local address\n\ | 
					
						
							|  |  |  | close() -- close the socket\n\ | 
					
						
							|  |  |  | connect(addr) -- connect the socket to a remote address\n\ | 
					
						
							|  |  |  | connect_ex(addr) -- connect, return an error code instead of an exception\n\ | 
					
						
							|  |  |  | dup() -- return a new socket object identical to the current one [*]\n\ | 
					
						
							|  |  |  | fileno() -- return underlying file descriptor\n\ | 
					
						
							|  |  |  | getpeername() -- return remote address [*]\n\ | 
					
						
							|  |  |  | getsockname() -- return local address\n\ | 
					
						
							|  |  |  | getsockopt(level, optname[, buflen]) -- get socket options\n\ | 
					
						
							|  |  |  | gettimeout() -- return timeout or None\n\ | 
					
						
							|  |  |  | listen(n) -- start listening for incoming connections\n\ | 
					
						
							|  |  |  | makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\ | 
					
						
							|  |  |  | recv(buflen[, flags]) -- receive data\n\ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\ | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | recvfrom_into(buffer[, nbytes, [, flags])\n\ | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  |   -- receive data and sender\'s address (into a buffer)\n\ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sendall(data[, flags]) -- send all data\n\ | 
					
						
							|  |  |  | send(data[, flags]) -- send data, may not send all of it\n\ | 
					
						
							|  |  |  | sendto(data[, flags], addr) -- send data to a given address\n\ | 
					
						
							|  |  |  | setblocking(0 | 1) -- set or clear the blocking I/O flag\n\ | 
					
						
							|  |  |  | setsockopt(level, optname, value) -- set socket options\n\ | 
					
						
							|  |  |  | settimeout(None | float) -- set or clear the timeout\n\ | 
					
						
							|  |  |  | shutdown(how) -- shut down traffic in one or both directions\n\ | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  |  [*] not available on all platforms!"); | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-10-20 14:01:56 +00:00
										 |  |  | /* XXX This is a terrible mess of platform-dependent preprocessor hacks.
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  |    I hope some day someone can clean this up please... */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-09-15 22:01:40 +00:00
										 |  |  | /* Hacks for gethostbyname_r().  On some non-Linux platforms, the configure
 | 
					
						
							|  |  |  |    script doesn't get this right, so we hardcode some platform checks below. | 
					
						
							|  |  |  |    On the other hand, not all Linux versions agree, so there the settings | 
					
						
							|  |  |  |    computed by the configure script are needed! */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #ifndef linux
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # undef HAVE_GETHOSTBYNAME_R_3_ARG
 | 
					
						
							|  |  |  | # undef HAVE_GETHOSTBYNAME_R_5_ARG
 | 
					
						
							|  |  |  | # undef HAVE_GETHOSTBYNAME_R_6_ARG
 | 
					
						
							| 
									
										
										
										
											1999-09-15 22:01:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:24:33 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-04-13 04:07:32 +00:00
										 |  |  | #ifndef WITH_THREAD
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # undef HAVE_GETHOSTBYNAME_R
 | 
					
						
							| 
									
										
										
										
											1999-04-13 04:07:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:24:33 +00:00
										 |  |  | #ifdef HAVE_GETHOSTBYNAME_R
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # if defined(_AIX) || defined(__osf__)
 | 
					
						
							|  |  |  | #  define HAVE_GETHOSTBYNAME_R_3_ARG
 | 
					
						
							|  |  |  | # elif defined(__sun) || defined(__sgi)
 | 
					
						
							|  |  |  | #  define HAVE_GETHOSTBYNAME_R_5_ARG
 | 
					
						
							|  |  |  | # elif defined(linux)
 | 
					
						
							| 
									
										
										
										
											1999-09-15 22:01:40 +00:00
										 |  |  | /* Rely on the configure script */ | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # else
 | 
					
						
							|  |  |  | #  undef HAVE_GETHOSTBYNAME_R
 | 
					
						
							|  |  |  | # endif
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:24:33 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | #if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
 | 
					
						
							|  |  |  |     !defined(MS_WINDOWS) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # define USE_GETHOSTBYNAME_LOCK
 | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2005-09-24 14:58:47 +00:00
										 |  |  | /* To use __FreeBSD_version */ | 
					
						
							|  |  |  | #ifdef HAVE_SYS_PARAM_H
 | 
					
						
							|  |  |  | #include <sys/param.h>
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | /* On systems on which getaddrinfo() is believed to not be thread-safe,
 | 
					
						
							| 
									
										
										
										
											2003-05-09 08:03:44 +00:00
										 |  |  |    (this includes the getaddrinfo emulation) protect access with a lock. */ | 
					
						
							| 
									
										
										
										
											2005-09-24 14:58:47 +00:00
										 |  |  | #if defined(WITH_THREAD) && (defined(__APPLE__) || \
 | 
					
						
							|  |  |  |     (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \ | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  |     defined(__OpenBSD__) || defined(__NetBSD__) || \ | 
					
						
							|  |  |  |     defined(__VMS) || !defined(HAVE_GETADDRINFO)) | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | #define USE_GETADDRINFO_LOCK
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #ifdef USE_GETADDRINFO_LOCK
 | 
					
						
							|  |  |  | #define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
 | 
					
						
							|  |  |  | #define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
 | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | #define ACQUIRE_GETADDRINFO_LOCK
 | 
					
						
							|  |  |  | #define RELEASE_GETADDRINFO_LOCK
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # include "pythread.h"
 | 
					
						
							| 
									
										
										
										
											1998-04-09 20:56:35 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #if defined(PYCC_VACPP)
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # include <types.h>
 | 
					
						
							|  |  |  | # include <io.h>
 | 
					
						
							|  |  |  | # include <sys/ioctl.h>
 | 
					
						
							|  |  |  | # include <utils.h>
 | 
					
						
							|  |  |  | # include <ctype.h>
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-12-06 12:57:26 +00:00
										 |  |  | #if defined(__VMS)
 | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #  include <ioctl.h>
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #if defined(PYOS_OS2)
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # define  INCL_DOS
 | 
					
						
							|  |  |  | # define  INCL_DOSERRORS
 | 
					
						
							|  |  |  | # define  INCL_NOPMAPI
 | 
					
						
							|  |  |  | # include <os2.h>
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-07-17 16:58:48 +00:00
										 |  |  | #if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
 | 
					
						
							| 
									
										
										
										
											2002-09-19 08:03:21 +00:00
										 |  |  | /* make sure that the reentrant (gethostbyaddr_r etc)
 | 
					
						
							|  |  |  |    functions are declared correctly if compiling with | 
					
						
							|  |  |  |    MIPSPro 7.x in ANSI C mode (default) */ | 
					
						
							| 
									
										
										
										
											2003-07-17 16:58:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | /* XXX Using _SGIAPI is the wrong thing,
 | 
					
						
							| 
									
										
										
										
											2003-07-17 16:58:48 +00:00
										 |  |  |    but I don't know what the right thing is. */ | 
					
						
							| 
									
										
										
										
											2004-09-13 17:48:41 +00:00
										 |  |  | #undef _SGIAPI /* to avoid warning */
 | 
					
						
							| 
									
										
										
										
											2002-09-19 08:03:21 +00:00
										 |  |  | #define _SGIAPI 1
 | 
					
						
							| 
									
										
										
										
											2003-07-17 16:58:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-09-13 17:48:41 +00:00
										 |  |  | #undef _XOPEN_SOURCE
 | 
					
						
							|  |  |  | #include <sys/socket.h>
 | 
					
						
							|  |  |  | #include <sys/types.h>
 | 
					
						
							|  |  |  | #include <netinet/in.h>
 | 
					
						
							|  |  |  | #ifdef _SS_ALIGNSIZE
 | 
					
						
							|  |  |  | #define HAVE_GETADDRINFO 1
 | 
					
						
							|  |  |  | #define HAVE_GETNAMEINFO 1
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-07-17 16:58:48 +00:00
										 |  |  | #define HAVE_INET_PTON
 | 
					
						
							|  |  |  | #include <netdb.h>
 | 
					
						
							| 
									
										
										
										
											2002-09-19 08:03:21 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | /* Irix 6.5 fails to define this variable at all. This is needed
 | 
					
						
							|  |  |  |    for both GCC and SGI's compiler. I'd say that the SGI headers | 
					
						
							| 
									
										
										
										
											2006-02-20 09:42:33 +00:00
										 |  |  |    are just busted. Same thing for Solaris. */ | 
					
						
							|  |  |  | #if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
 | 
					
						
							| 
									
										
										
										
											2003-10-04 08:00:49 +00:00
										 |  |  | #define INET_ADDRSTRLEN 16
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | /* Generic includes */ | 
					
						
							| 
									
										
										
										
											2006-06-10 12:23:46 +00:00
										 |  |  | #ifdef HAVE_SYS_TYPES_H
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #include <sys/types.h>
 | 
					
						
							| 
									
										
										
										
											2006-06-10 12:23:46 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:47:07 +00:00
										 |  |  | /* Generic socket object definitions and includes */ | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | #define PySocket_BUILDING_SOCKET
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:44:52 +00:00
										 |  |  | #include "socketmodule.h"
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Addressing includes */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-28 20:15:15 +00:00
										 |  |  | #ifndef MS_WINDOWS
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Non-MS WINDOWS includes */ | 
					
						
							|  |  |  | # include <netdb.h>
 | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-09-15 22:01:40 +00:00
										 |  |  | /* Headers needed for inet_ntoa() and inet_addr() */ | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # ifdef __BEOS__
 | 
					
						
							|  |  |  | #  include <net/netdb.h>
 | 
					
						
							|  |  |  | # elif defined(PYOS_OS2) && defined(PYCC_VACPP)
 | 
					
						
							|  |  |  | #  include <netdb.h>
 | 
					
						
							| 
									
										
										
										
											2001-11-05 02:45:59 +00:00
										 |  |  | typedef size_t socklen_t; | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # else
 | 
					
						
							|  |  |  | #   include <arpa/inet.h>
 | 
					
						
							|  |  |  | # endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | # ifndef RISCOS
 | 
					
						
							|  |  |  | #  include <fcntl.h>
 | 
					
						
							|  |  |  | # else
 | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #  include <sys/ioctl.h>
 | 
					
						
							|  |  |  | #  include <socklib.h>
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | #  define NO_DUP
 | 
					
						
							| 
									
										
										
										
											2001-10-24 20:42:55 +00:00
										 |  |  | int h_errno; /* not used */ | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #  define INET_ADDRSTRLEN 16
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # endif
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1993-04-07 14:06:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | /* MS_WINDOWS includes */ | 
					
						
							| 
									
										
										
										
											2006-06-10 12:23:46 +00:00
										 |  |  | # ifdef HAVE_FCNTL_H
 | 
					
						
							|  |  |  | #  include <fcntl.h>
 | 
					
						
							|  |  |  | # endif
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-02-10 16:50:21 +00:00
										 |  |  | #include <stddef.h>
 | 
					
						
							| 
									
										
										
										
											2001-06-24 21:28:42 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifndef offsetof
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | # define offsetof(type, member)	((size_t)(&((type *)0)->member))
 | 
					
						
							| 
									
										
										
										
											2001-06-24 21:28:42 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-11-02 19:55:21 +00:00
										 |  |  | #ifndef O_NONBLOCK
 | 
					
						
							|  |  |  | # define O_NONBLOCK O_NDELAY
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-09-07 17:48:26 +00:00
										 |  |  | /* include Python's addrinfo.h unless it causes trouble */ | 
					
						
							|  |  |  | #if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
 | 
					
						
							|  |  |  |   /* Do not include addinfo.h on some newer IRIX versions.
 | 
					
						
							|  |  |  |    * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21, | 
					
						
							|  |  |  |    * for example, but not by 6.5.10. | 
					
						
							|  |  |  |    */ | 
					
						
							| 
									
										
										
										
											2006-06-10 12:23:46 +00:00
										 |  |  | #elif defined(_MSC_VER) && _MSC_VER>1201
 | 
					
						
							| 
									
										
										
										
											2004-09-07 17:48:26 +00:00
										 |  |  |   /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
 | 
					
						
							|  |  |  |    * EAI_* constants are defined in (the already included) ws2tcpip.h. | 
					
						
							|  |  |  |    */ | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | #  include "addrinfo.h"
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-08-03 08:52:46 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | #ifndef HAVE_INET_PTON
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | int inet_pton(int af, const char *src, void *dst); | 
					
						
							| 
									
										
										
										
											2001-07-21 09:42:15 +00:00
										 |  |  | const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-03 10:02:29 +00:00
										 |  |  | #ifdef __APPLE__
 | 
					
						
							|  |  |  | /* On OS X, getaddrinfo returns no error indication of lookup
 | 
					
						
							|  |  |  |    failure, so we must use the emulation instead of the libinfo | 
					
						
							|  |  |  |    implementation. Unfortunately, performing an autoconf test | 
					
						
							|  |  |  |    for this bug would require DNS access for the machine performing | 
					
						
							|  |  |  |    the configuration, which is not acceptable. Therefore, we | 
					
						
							|  |  |  |    determine the bug just by checking for __APPLE__. If this bug | 
					
						
							|  |  |  |    gets ever fixed, perhaps checking for sys/version.h would be | 
					
						
							|  |  |  |    appropriate, which is 10/0 on the system with the bug. */ | 
					
						
							| 
									
										
										
										
											2002-07-02 14:40:42 +00:00
										 |  |  | #ifndef HAVE_GETNAMEINFO
 | 
					
						
							|  |  |  | /* This bug seems to be fixed in Jaguar. Ths easiest way I could
 | 
					
						
							|  |  |  |    Find to check for Jaguar is that it has getnameinfo(), which | 
					
						
							|  |  |  |    older releases don't have */ | 
					
						
							| 
									
										
										
										
											2001-08-03 10:02:29 +00:00
										 |  |  | #undef HAVE_GETADDRINFO
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifdef HAVE_INET_ATON
 | 
					
						
							|  |  |  | #define USE_INET_ATON_WEAKLINK
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-02 14:40:42 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-03 10:02:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-06-23 16:30:13 +00:00
										 |  |  | /* I know this is a bad practice, but it is the easiest... */ | 
					
						
							| 
									
										
										
										
											2001-08-03 10:02:29 +00:00
										 |  |  | #if !defined(HAVE_GETADDRINFO)
 | 
					
						
							| 
									
										
										
										
											2003-05-01 05:20:46 +00:00
										 |  |  | /* avoid clashes with the C library definition of the symbol. */ | 
					
						
							|  |  |  | #define getaddrinfo fake_getaddrinfo
 | 
					
						
							|  |  |  | #define gai_strerror fake_gai_strerror
 | 
					
						
							|  |  |  | #define freeaddrinfo fake_freeaddrinfo
 | 
					
						
							| 
									
										
										
										
											2001-06-23 16:30:13 +00:00
										 |  |  | #include "getaddrinfo.c"
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-03 10:02:29 +00:00
										 |  |  | #if !defined(HAVE_GETNAMEINFO)
 | 
					
						
							| 
									
										
										
										
											2003-05-01 05:20:46 +00:00
										 |  |  | #define getnameinfo fake_getnameinfo
 | 
					
						
							| 
									
										
										
										
											2001-06-23 16:30:13 +00:00
										 |  |  | #include "getnameinfo.c"
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #if defined(MS_WINDOWS) || defined(__BEOS__)
 | 
					
						
							|  |  |  | /* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */ | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | /* seem to be a few differences in the API */ | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | #define SOCKETCLOSE closesocket
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | #define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #ifdef MS_WIN32
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | #define EAFNOSUPPORT WSAEAFNOSUPPORT
 | 
					
						
							|  |  |  | #define snprintf _snprintf
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-03-03 03:03:52 +00:00
										 |  |  | #if defined(PYOS_OS2) && !defined(PYCC_GCC)
 | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | #define SOCKETCLOSE soclose
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | #ifndef SOCKETCLOSE
 | 
					
						
							|  |  |  | #define SOCKETCLOSE close
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)
 | 
					
						
							|  |  |  | #define USE_BLUETOOTH 1
 | 
					
						
							|  |  |  | #if defined(__FreeBSD__)
 | 
					
						
							|  |  |  | #define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
 | 
					
						
							|  |  |  | #define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
 | 
					
						
							|  |  |  | #define sockaddr_l2 sockaddr_l2cap
 | 
					
						
							|  |  |  | #define sockaddr_rc sockaddr_rfcomm
 | 
					
						
							|  |  |  | #define _BT_SOCKADDR_MEMB(s, proto) &((s)->sock_addr)
 | 
					
						
							|  |  |  | #define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
 | 
					
						
							|  |  |  | #define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
 | 
					
						
							| 
									
										
										
										
											2006-07-28 11:27:27 +00:00
										 |  |  | #elif defined(__NetBSD__)
 | 
					
						
							|  |  |  | #define sockaddr_l2 sockaddr_bt
 | 
					
						
							|  |  |  | #define sockaddr_rc sockaddr_bt
 | 
					
						
							|  |  |  | #define sockaddr_sco sockaddr_bt
 | 
					
						
							|  |  |  | #define _BT_SOCKADDR_MEMB(s, proto) &((s)->sock_addr)
 | 
					
						
							|  |  |  | #define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
 | 
					
						
							|  |  |  | #define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
 | 
					
						
							|  |  |  | #define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2004-02-16 05:35:28 +00:00
										 |  |  | #define _BT_SOCKADDR_MEMB(s, proto) (&((s)->sock_addr).bt_##proto)
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
 | 
					
						
							|  |  |  | #define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
 | 
					
						
							|  |  |  | #define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | /* TCP/IP Services for VMS uses a maximum send/recv buffer length */ | 
					
						
							|  |  |  | #define SEGMENT_SIZE (32 * 1024 -1)
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-05-03 10:12:45 +00:00
										 |  |  | /*
 | 
					
						
							|  |  |  |  * Constants for getnameinfo() | 
					
						
							|  |  |  |  */ | 
					
						
							|  |  |  | #if !defined(NI_MAXHOST)
 | 
					
						
							|  |  |  | #define NI_MAXHOST 1025
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #if !defined(NI_MAXSERV)
 | 
					
						
							|  |  |  | #define NI_MAXSERV 32
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | /* XXX There's a problem here: *static* functions are not supposed to have
 | 
					
						
							|  |  |  |    a Py prefix (or use CapitalizedWords).  Later... */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Global variable holding the exception type for errors detected
 | 
					
						
							|  |  |  |    by this module (but not argument type or memory errors, etc.). */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | static PyObject *socket_error; | 
					
						
							|  |  |  | static PyObject *socket_herror; | 
					
						
							|  |  |  | static PyObject *socket_gaierror; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | static PyObject *socket_timeout; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #ifdef RISCOS
 | 
					
						
							|  |  |  | /* Global variable which is !=0 if Python is running in a RISC OS taskwindow */ | 
					
						
							|  |  |  | static int taskwindow; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-17 04:13:21 +00:00
										 |  |  | /* A forward reference to the socket type object.
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  |    The sock_type variable contains pointers to various functions, | 
					
						
							|  |  |  |    some of which call new_sockobject(), which uses sock_type, so | 
					
						
							| 
									
										
										
										
											2002-02-17 04:13:21 +00:00
										 |  |  |    there has to be a circular reference. */ | 
					
						
							| 
									
										
										
										
											2002-07-17 16:30:39 +00:00
										 |  |  | static PyTypeObject sock_type; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  | #if defined(HAVE_POLL_H)
 | 
					
						
							|  |  |  | #include <poll.h>
 | 
					
						
							|  |  |  | #elif defined(HAVE_SYS_POLL_H)
 | 
					
						
							|  |  |  | #include <sys/poll.h>
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-02-11 09:27:05 +00:00
										 |  |  | #ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
 | 
					
						
							|  |  |  | /* Platform can select file descriptors beyond FD_SETSIZE */ | 
					
						
							|  |  |  | #define IS_SELECTABLE(s) 1
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  | #elif defined(HAVE_POLL)
 | 
					
						
							|  |  |  | /* Instead of select(), we'll use poll() since poll() works on any fd. */ | 
					
						
							|  |  |  | #define IS_SELECTABLE(s) 1
 | 
					
						
							|  |  |  | /* Can we call select() with this socket without a buffer overrun? */ | 
					
						
							| 
									
										
										
										
											2006-02-11 09:27:05 +00:00
										 |  |  | #else
 | 
					
						
							|  |  |  | /* POSIX says selecting file descriptors beyond FD_SETSIZE
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  |    has undefined behaviour.  If there's no timeout left, we don't have to | 
					
						
							|  |  |  |    call select, so it's a safe, little white lie. */ | 
					
						
							|  |  |  | #define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
 | 
					
						
							| 
									
										
										
										
											2006-02-11 09:27:05 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject* | 
					
						
							|  |  |  | select_error(void) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	PyErr_SetString(socket_error, "unable to select on socket"); | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Convenience function to raise an error according to errno
 | 
					
						
							|  |  |  |    and return a NULL pointer from a function. */ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | set_error(void) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1996-06-26 18:22:49 +00:00
										 |  |  | #ifdef MS_WINDOWS
 | 
					
						
							| 
									
										
										
										
											2000-07-24 01:45:11 +00:00
										 |  |  | 	int err_no = WSAGetLastError(); | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	static struct { | 
					
						
							|  |  |  | 		int no; | 
					
						
							|  |  |  | 		const char *msg; | 
					
						
							|  |  |  | 	} *msgp, msgs[] = { | 
					
						
							|  |  |  | 		{WSAEINTR, "Interrupted system call"}, | 
					
						
							|  |  |  | 		{WSAEBADF, "Bad file descriptor"}, | 
					
						
							|  |  |  | 		{WSAEACCES, "Permission denied"}, | 
					
						
							|  |  |  | 		{WSAEFAULT, "Bad address"}, | 
					
						
							|  |  |  | 		{WSAEINVAL, "Invalid argument"}, | 
					
						
							|  |  |  | 		{WSAEMFILE, "Too many open files"}, | 
					
						
							|  |  |  | 		{WSAEWOULDBLOCK, | 
					
						
							|  |  |  | 		  "The socket operation could not complete " | 
					
						
							|  |  |  | 		  "without blocking"}, | 
					
						
							|  |  |  | 		{WSAEINPROGRESS, "Operation now in progress"}, | 
					
						
							|  |  |  | 		{WSAEALREADY, "Operation already in progress"}, | 
					
						
							|  |  |  | 		{WSAENOTSOCK, "Socket operation on non-socket"}, | 
					
						
							|  |  |  | 		{WSAEDESTADDRREQ, "Destination address required"}, | 
					
						
							|  |  |  | 		{WSAEMSGSIZE, "Message too long"}, | 
					
						
							|  |  |  | 		{WSAEPROTOTYPE, "Protocol wrong type for socket"}, | 
					
						
							|  |  |  | 		{WSAENOPROTOOPT, "Protocol not available"}, | 
					
						
							|  |  |  | 		{WSAEPROTONOSUPPORT, "Protocol not supported"}, | 
					
						
							|  |  |  | 		{WSAESOCKTNOSUPPORT, "Socket type not supported"}, | 
					
						
							|  |  |  | 		{WSAEOPNOTSUPP, "Operation not supported"}, | 
					
						
							|  |  |  | 		{WSAEPFNOSUPPORT, "Protocol family not supported"}, | 
					
						
							|  |  |  | 		{WSAEAFNOSUPPORT, "Address family not supported"}, | 
					
						
							|  |  |  | 		{WSAEADDRINUSE, "Address already in use"}, | 
					
						
							|  |  |  | 		{WSAEADDRNOTAVAIL, "Can't assign requested address"}, | 
					
						
							|  |  |  | 		{WSAENETDOWN, "Network is down"}, | 
					
						
							|  |  |  | 		{WSAENETUNREACH, "Network is unreachable"}, | 
					
						
							|  |  |  | 		{WSAENETRESET, "Network dropped connection on reset"}, | 
					
						
							|  |  |  | 		{WSAECONNABORTED, "Software caused connection abort"}, | 
					
						
							|  |  |  | 		{WSAECONNRESET, "Connection reset by peer"}, | 
					
						
							|  |  |  | 		{WSAENOBUFS, "No buffer space available"}, | 
					
						
							|  |  |  | 		{WSAEISCONN, "Socket is already connected"}, | 
					
						
							|  |  |  | 		{WSAENOTCONN, "Socket is not connected"}, | 
					
						
							|  |  |  | 		{WSAESHUTDOWN, "Can't send after socket shutdown"}, | 
					
						
							|  |  |  | 		{WSAETOOMANYREFS, "Too many references: can't splice"}, | 
					
						
							|  |  |  | 		{WSAETIMEDOUT, "Operation timed out"}, | 
					
						
							|  |  |  | 		{WSAECONNREFUSED, "Connection refused"}, | 
					
						
							|  |  |  | 		{WSAELOOP, "Too many levels of symbolic links"}, | 
					
						
							|  |  |  | 		{WSAENAMETOOLONG, "File name too long"}, | 
					
						
							|  |  |  | 		{WSAEHOSTDOWN, "Host is down"}, | 
					
						
							|  |  |  | 		{WSAEHOSTUNREACH, "No route to host"}, | 
					
						
							|  |  |  | 		{WSAENOTEMPTY, "Directory not empty"}, | 
					
						
							|  |  |  | 		{WSAEPROCLIM, "Too many processes"}, | 
					
						
							|  |  |  | 		{WSAEUSERS, "Too many users"}, | 
					
						
							|  |  |  | 		{WSAEDQUOT, "Disc quota exceeded"}, | 
					
						
							|  |  |  | 		{WSAESTALE, "Stale NFS file handle"}, | 
					
						
							|  |  |  | 		{WSAEREMOTE, "Too many levels of remote in path"}, | 
					
						
							|  |  |  | 		{WSASYSNOTREADY, "Network subsystem is unvailable"}, | 
					
						
							|  |  |  | 		{WSAVERNOTSUPPORTED, "WinSock version is not supported"}, | 
					
						
							|  |  |  | 		{WSANOTINITIALISED, | 
					
						
							|  |  |  | 		  "Successful WSAStartup() not yet performed"}, | 
					
						
							|  |  |  | 		{WSAEDISCON, "Graceful shutdown in progress"}, | 
					
						
							|  |  |  | 		/* Resolver errors */ | 
					
						
							|  |  |  | 		{WSAHOST_NOT_FOUND, "No such host is known"}, | 
					
						
							|  |  |  | 		{WSATRY_AGAIN, "Host not found, or server failed"}, | 
					
						
							|  |  |  | 		{WSANO_RECOVERY, "Unexpected server error encountered"}, | 
					
						
							|  |  |  | 		{WSANO_DATA, "Valid name without requested data"}, | 
					
						
							|  |  |  | 		{WSANO_ADDRESS, "No address, look for MX record"}, | 
					
						
							|  |  |  | 		{0, NULL} | 
					
						
							|  |  |  | 	}; | 
					
						
							| 
									
										
										
										
											2000-07-24 01:45:11 +00:00
										 |  |  | 	if (err_no) { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		PyObject *v; | 
					
						
							| 
									
										
										
										
											2000-07-24 01:45:11 +00:00
										 |  |  | 		const char *msg = "winsock error"; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-24 01:45:11 +00:00
										 |  |  | 		for (msgp = msgs; msgp->msg; msgp++) { | 
					
						
							|  |  |  | 			if (err_no == msgp->no) { | 
					
						
							|  |  |  | 				msg = msgp->msg; | 
					
						
							|  |  |  | 				break; | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		v = Py_BuildValue("(is)", err_no, msg); | 
					
						
							| 
									
										
										
										
											1994-09-29 09:50:09 +00:00
										 |  |  | 		if (v != NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetObject(socket_error, v); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 			Py_DECREF(v); | 
					
						
							| 
									
										
										
										
											1994-09-29 09:50:09 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-03-03 03:03:52 +00:00
										 |  |  | #if defined(PYOS_OS2) && !defined(PYCC_GCC)
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	if (sock_errno() != NO_ERROR) { | 
					
						
							|  |  |  | 		APIRET rc; | 
					
						
							|  |  |  | 		ULONG  msglen; | 
					
						
							|  |  |  | 		char outbuf[100]; | 
					
						
							|  |  |  | 		int myerrorcode = sock_errno(); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		/* Retrieve socket-related error message from MPTN.MSG file */ | 
					
						
							|  |  |  | 		rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf), | 
					
						
							|  |  |  | 				   myerrorcode - SOCBASEERR + 26, | 
					
						
							|  |  |  | 				   "mptn.msg", | 
					
						
							|  |  |  | 				   &msglen); | 
					
						
							|  |  |  | 		if (rc == NO_ERROR) { | 
					
						
							|  |  |  | 			PyObject *v; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 			/* OS/2 doesn't guarantee a terminator */ | 
					
						
							|  |  |  | 			outbuf[msglen] = '\0'; | 
					
						
							|  |  |  | 			if (strlen(outbuf) > 0) { | 
					
						
							|  |  |  | 				/* If non-empty msg, trim CRLF */ | 
					
						
							|  |  |  | 				char *lastc = &outbuf[ strlen(outbuf)-1 ]; | 
					
						
							| 
									
										
										
										
											2005-12-19 06:05:18 +00:00
										 |  |  | 				while (lastc > outbuf && | 
					
						
							|  |  |  | 				       isspace(Py_CHARMASK(*lastc))) { | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 					/* Trim trailing whitespace (CRLF) */ | 
					
						
							|  |  |  | 					*lastc-- = '\0'; | 
					
						
							|  |  |  | 				} | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 			v = Py_BuildValue("(is)", myerrorcode, outbuf); | 
					
						
							|  |  |  | 			if (v != NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 				PyErr_SetObject(socket_error, v); | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 				Py_DECREF(v); | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #if defined(RISCOS)
 | 
					
						
							|  |  |  | 	if (_inet_error.errnum != NULL) { | 
					
						
							|  |  |  | 		PyObject *v; | 
					
						
							|  |  |  | 		v = Py_BuildValue("(is)", errno, _inet_err()); | 
					
						
							|  |  |  | 		if (v != NULL) { | 
					
						
							|  |  |  | 			PyErr_SetObject(socket_error, v); | 
					
						
							|  |  |  | 			Py_DECREF(v); | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	return PyErr_SetFromErrno(socket_error); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | set_herror(int h_error) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	PyObject *v; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #ifdef HAVE_HSTRERROR
 | 
					
						
							|  |  |  | 	v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error)); | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	v = Py_BuildValue("(is)", h_error, "host not found"); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	if (v != NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetObject(socket_herror, v); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		Py_DECREF(v); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | set_gaierror(int error) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	PyObject *v; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-03-01 08:31:07 +00:00
										 |  |  | #ifdef EAI_SYSTEM
 | 
					
						
							|  |  |  | 	/* EAI_SYSTEM is not available on Windows XP. */ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (error == EAI_SYSTEM) | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		return set_error(); | 
					
						
							| 
									
										
										
										
											2002-03-01 08:31:07 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-15 17:14:33 +00:00
										 |  |  | #ifdef HAVE_GAI_STRERROR
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	v = Py_BuildValue("(is)", error, gai_strerror(error)); | 
					
						
							| 
									
										
										
										
											2001-08-15 17:14:33 +00:00
										 |  |  | #else
 | 
					
						
							|  |  |  | 	v = Py_BuildValue("(is)", error, "getaddrinfo failed"); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (v != NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetObject(socket_gaierror, v); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		Py_DECREF(v); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | /* Function to send in segments */ | 
					
						
							|  |  |  | static int | 
					
						
							|  |  |  | sendsegmented(int sock_fd, char *buf, int len, int flags) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	int n = 0; | 
					
						
							|  |  |  | 	int remaining = len; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	while (remaining > 0) { | 
					
						
							|  |  |  | 		unsigned int segment; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining); | 
					
						
							|  |  |  | 		n = send(sock_fd, buf, segment, flags); | 
					
						
							|  |  |  | 		if (n < 0) { | 
					
						
							|  |  |  | 			return n; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		remaining -= segment; | 
					
						
							|  |  |  | 		buf += segment; | 
					
						
							|  |  |  | 	} /* end while */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	return len; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | /* Function to perform the setting of socket blocking mode
 | 
					
						
							|  |  |  |    internally. block = (1 | 0). */ | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | static int | 
					
						
							|  |  |  | internal_setblocking(PySocketSockObject *s, int block) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | #ifndef RISCOS
 | 
					
						
							|  |  |  | #ifndef MS_WINDOWS
 | 
					
						
							|  |  |  | 	int delay_flag; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | #ifdef __BEOS__
 | 
					
						
							|  |  |  | 	block = !block; | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK, | 
					
						
							|  |  |  | 		   (void *)(&block), sizeof(int)); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | #else
 | 
					
						
							|  |  |  | #ifndef RISCOS
 | 
					
						
							|  |  |  | #ifndef MS_WINDOWS
 | 
					
						
							|  |  |  | #if defined(PYOS_OS2) && !defined(PYCC_GCC)
 | 
					
						
							|  |  |  | 	block = !block; | 
					
						
							|  |  |  | 	ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block)); | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #elif defined(__VMS)
 | 
					
						
							|  |  |  | 	block = !block; | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | 	ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block); | 
					
						
							|  |  |  | #else  /* !PYOS_OS2 && !__VMS */
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	delay_flag = fcntl(s->sock_fd, F_GETFL, 0); | 
					
						
							|  |  |  | 	if (block) | 
					
						
							| 
									
										
										
										
											2002-11-02 19:55:21 +00:00
										 |  |  | 		delay_flag &= (~O_NONBLOCK); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	else | 
					
						
							| 
									
										
										
										
											2002-11-02 19:55:21 +00:00
										 |  |  | 		delay_flag |= O_NONBLOCK; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	fcntl(s->sock_fd, F_SETFL, delay_flag); | 
					
						
							|  |  |  | #endif /* !PYOS_OS2 */
 | 
					
						
							|  |  |  | #else /* MS_WINDOWS */
 | 
					
						
							|  |  |  | 	block = !block; | 
					
						
							|  |  |  | 	ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block); | 
					
						
							|  |  |  | #endif /* MS_WINDOWS */
 | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #else /* RISCOS */
 | 
					
						
							|  |  |  | 	block = !block; | 
					
						
							|  |  |  | 	socketioctl(s->sock_fd, FIONBIO, (u_long*)&block); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | #endif /* RISCOS */
 | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #endif /* __BEOS__ */
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Since these don't return anything */ | 
					
						
							|  |  |  | 	return 1; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  | /* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
 | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  |    The argument writing indicates the direction. | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  |    This does not raise an exception; we'll let our caller do that | 
					
						
							|  |  |  |    after they've reacquired the interpreter lock. | 
					
						
							|  |  |  |    Returns 1 on timeout, 0 otherwise. */ | 
					
						
							|  |  |  | static int | 
					
						
							| 
									
										
										
										
											2002-06-07 01:42:47 +00:00
										 |  |  | internal_select(PySocketSockObject *s, int writing) | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int n; | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-19 12:44:59 +00:00
										 |  |  | 	/* Nothing to do unless we're in timeout mode (not non-blocking) */ | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	if (s->sock_timeout <= 0.0) | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		return 0; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-19 12:44:59 +00:00
										 |  |  | 	/* Guard against closed socket */ | 
					
						
							|  |  |  | 	if (s->sock_fd < 0) | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		return 0; | 
					
						
							| 
									
										
										
										
											2002-07-19 12:44:59 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  | 	/* Prefer poll, if available, since you can poll() any fd
 | 
					
						
							|  |  |  | 	 * which can't be done with select(). */ | 
					
						
							|  |  |  | #ifdef HAVE_POLL
 | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct pollfd pollfd; | 
					
						
							|  |  |  | 		int timeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-07-11 02:04:09 +00:00
										 |  |  | 		pollfd.fd = s->sock_fd; | 
					
						
							|  |  |  | 		pollfd.events = writing ? POLLOUT : POLLIN; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		/* s->sock_timeout is in seconds, timeout in ms */ | 
					
						
							|  |  |  | 		timeout = (int)(s->sock_timeout * 1000 + 0.5);  | 
					
						
							|  |  |  | 		n = poll(&pollfd, 1, timeout); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		/* Construct the arguments to select */ | 
					
						
							|  |  |  | 		fd_set fds; | 
					
						
							|  |  |  | 		struct timeval tv; | 
					
						
							|  |  |  | 		tv.tv_sec = (int)s->sock_timeout; | 
					
						
							|  |  |  | 		tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6); | 
					
						
							|  |  |  | 		FD_ZERO(&fds); | 
					
						
							|  |  |  | 		FD_SET(s->sock_fd, &fds); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		/* See if the socket is ready */ | 
					
						
							|  |  |  | 		if (writing) | 
					
						
							|  |  |  | 			n = select(s->sock_fd+1, NULL, &fds, NULL, &tv); | 
					
						
							|  |  |  | 		else | 
					
						
							|  |  |  | 			n = select(s->sock_fd+1, &fds, NULL, NULL, &tv); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (n == 0) | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	return 0; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | /* Initialize a new socket object. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-18 22:38:44 +00:00
										 |  |  | static double defaulttimeout = -1.0; /* Default timeout for new sockets */ | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-23 06:31:15 +00:00
										 |  |  | PyMODINIT_FUNC | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | init_sockobject(PySocketSockObject *s, | 
					
						
							|  |  |  | 		SOCKET_T fd, int family, int type, int proto) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | #ifdef RISCOS
 | 
					
						
							|  |  |  | 	int block = 1; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	s->sock_fd = fd; | 
					
						
							|  |  |  | 	s->sock_family = family; | 
					
						
							|  |  |  | 	s->sock_type = type; | 
					
						
							|  |  |  | 	s->sock_proto = proto; | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | 	s->sock_timeout = defaulttimeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	s->errorhandler = &set_error; | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (defaulttimeout >= 0.0) | 
					
						
							|  |  |  | 		internal_setblocking(s, 0); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | #ifdef RISCOS
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	if (taskwindow) | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 		socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Create a new socket object.
 | 
					
						
							|  |  |  |    This just creates the object and initializes it. | 
					
						
							|  |  |  |    If the creation fails, return NULL and set an exception (implicit | 
					
						
							|  |  |  |    in NEWOBJ()). */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PySocketSockObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | new_sockobject(SOCKET_T fd, int family, int type, int proto) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	PySocketSockObject *s; | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	s = (PySocketSockObject *) | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyType_GenericNew(&sock_type, NULL, NULL); | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	if (s != NULL) | 
					
						
							|  |  |  | 		init_sockobject(s, fd, family, type, proto); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	return s; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | /* Lock to allow python interpreter to continue, but only allow one
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  |    thread to be in gethostbyname or getaddrinfo */ | 
					
						
							|  |  |  | #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
 | 
					
						
							|  |  |  | PyThread_type_lock netdb_lock; | 
					
						
							| 
									
										
										
										
											1998-04-09 20:56:35 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Convert a string specifying a host name or one of a few symbolic
 | 
					
						
							|  |  |  |    names to a numeric IP address.  This usually calls gethostbyname() | 
					
						
							|  |  |  |    to do the work; the names "" and "<broadcast>" are special. | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  |    Return the length (IPv4 should be 4 bytes), or negative if | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  |    an error occurred; then an exception is raised. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | static int | 
					
						
							| 
									
										
										
										
											2002-07-28 16:10:31 +00:00
										 |  |  | setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	struct addrinfo hints, *res; | 
					
						
							|  |  |  | 	int error; | 
					
						
							| 
									
										
										
										
											2003-05-02 15:40:46 +00:00
										 |  |  | 	int d1, d2, d3, d4; | 
					
						
							|  |  |  | 	char ch; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-12-05 23:43:35 +00:00
										 |  |  | 	memset((void *) addr_ret, '\0', sizeof(*addr_ret)); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	if (name[0] == '\0') { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		int siz; | 
					
						
							|  |  |  | 		memset(&hints, 0, sizeof(hints)); | 
					
						
							|  |  |  | 		hints.ai_family = af; | 
					
						
							|  |  |  | 		hints.ai_socktype = SOCK_DGRAM;	/*dummy*/ | 
					
						
							|  |  |  | 		hints.ai_flags = AI_PASSIVE; | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 		Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 		ACQUIRE_GETADDRINFO_LOCK | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		error = getaddrinfo(NULL, "0", &hints, &res); | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 		Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 		/* We assume that those thread-unsafe getaddrinfo() versions
 | 
					
						
							|  |  |  | 		   *are* safe regarding their return value, ie. that a | 
					
						
							|  |  |  | 		   subsequent call to getaddrinfo() does not destroy the | 
					
						
							|  |  |  | 		   outcome of the first call. */ | 
					
						
							|  |  |  | 		RELEASE_GETADDRINFO_LOCK | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			return -1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		switch (res->ai_family) { | 
					
						
							|  |  |  | 		case AF_INET: | 
					
						
							|  |  |  | 			siz = 4; | 
					
						
							|  |  |  | 			break; | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		case AF_INET6: | 
					
						
							|  |  |  | 			siz = 16; | 
					
						
							|  |  |  | 			break; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 		default: | 
					
						
							|  |  |  | 			freeaddrinfo(res); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 				"unsupported address family"); | 
					
						
							|  |  |  | 			return -1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		if (res->ai_next) { | 
					
						
							| 
									
										
										
										
											2001-11-07 08:31:03 +00:00
										 |  |  | 			freeaddrinfo(res); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 				"wildcard resolved to multiple address"); | 
					
						
							|  |  |  | 			return -1; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2002-07-28 16:10:31 +00:00
										 |  |  | 		if (res->ai_addrlen < addr_ret_size) | 
					
						
							|  |  |  | 			addr_ret_size = res->ai_addrlen; | 
					
						
							|  |  |  | 		memcpy(addr_ret, res->ai_addr, addr_ret_size); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		freeaddrinfo(res); | 
					
						
							|  |  |  | 		return siz; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		struct sockaddr_in *sin; | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | 		if (af != AF_INET && af != AF_UNSPEC) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 				"address family mismatched"); | 
					
						
							|  |  |  | 			return -1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		sin = (struct sockaddr_in *)addr_ret; | 
					
						
							|  |  |  | 		memset((void *) sin, '\0', sizeof(*sin)); | 
					
						
							|  |  |  | 		sin->sin_family = AF_INET; | 
					
						
							|  |  |  | #ifdef HAVE_SOCKADDR_SA_LEN
 | 
					
						
							|  |  |  | 		sin->sin_len = sizeof(*sin); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 		sin->sin_addr.s_addr = INADDR_BROADCAST; | 
					
						
							|  |  |  | 		return sizeof(sin->sin_addr); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2003-05-02 15:40:46 +00:00
										 |  |  | 	if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 && | 
					
						
							|  |  |  | 	    0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 && | 
					
						
							|  |  |  | 	    0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) { | 
					
						
							|  |  |  | 		struct sockaddr_in *sin; | 
					
						
							|  |  |  | 		sin = (struct sockaddr_in *)addr_ret; | 
					
						
							|  |  |  | 		sin->sin_addr.s_addr = htonl( | 
					
						
							|  |  |  | 			((long) d1 << 24) | ((long) d2 << 16) | | 
					
						
							|  |  |  | 			((long) d3 << 8) | ((long) d4 << 0)); | 
					
						
							|  |  |  | 		sin->sin_family = AF_INET; | 
					
						
							|  |  |  | #ifdef HAVE_SOCKADDR_SA_LEN
 | 
					
						
							|  |  |  | 		sin->sin_len = sizeof(*sin); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 		return 4; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	memset(&hints, 0, sizeof(hints)); | 
					
						
							|  |  |  | 	hints.ai_family = af; | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	ACQUIRE_GETADDRINFO_LOCK | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	error = getaddrinfo(name, NULL, &hints, &res); | 
					
						
							| 
									
										
										
										
											2001-10-25 09:04:03 +00:00
										 |  |  | #if defined(__digital__) && defined(__unix__)
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	if (error == EAI_NONAME && af == AF_UNSPEC) { | 
					
						
							|  |  |  | 		/* On Tru64 V5.1, numeric-to-addr conversion fails
 | 
					
						
							|  |  |  | 		   if no address family is given. Assume IPv4 for now.*/ | 
					
						
							|  |  |  | 		hints.ai_family = AF_INET; | 
					
						
							|  |  |  | 		error = getaddrinfo(name, NULL, &hints, &res); | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-10-25 09:04:03 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-07-28 16:10:31 +00:00
										 |  |  | 	if (res->ai_addrlen < addr_ret_size) | 
					
						
							|  |  |  | 		addr_ret_size = res->ai_addrlen; | 
					
						
							|  |  |  | 	memcpy((char *) addr_ret, res->ai_addr, addr_ret_size); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	freeaddrinfo(res); | 
					
						
							|  |  |  | 	switch (addr_ret->sa_family) { | 
					
						
							|  |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 		return 4; | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 		return 16; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	default: | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "unknown address family"); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return -1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Create a string object representing an IP address.
 | 
					
						
							|  |  |  |    This is always a string of the form 'dd.dd.dd.dd' (with variable | 
					
						
							|  |  |  |    size numbers). */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | makeipaddr(struct sockaddr *addr, int addrlen) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	char buf[NI_MAXHOST]; | 
					
						
							|  |  |  | 	int error; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0, | 
					
						
							|  |  |  | 		NI_NUMERICHOST); | 
					
						
							|  |  |  | 	if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyString_FromString(buf); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | #ifdef USE_BLUETOOTH
 | 
					
						
							|  |  |  | /* Convert a string representation of a Bluetooth address into a numeric
 | 
					
						
							|  |  |  |    address.  Returns the length (6), or raises an exception and returns -1 if | 
					
						
							|  |  |  |    an error occurred. */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static int | 
					
						
							|  |  |  | setbdaddr(char *name, bdaddr_t *bdaddr) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	unsigned int b0, b1, b2, b3, b4, b5; | 
					
						
							|  |  |  | 	char ch; | 
					
						
							|  |  |  | 	int n; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	n = sscanf(name, "%X:%X:%X:%X:%X:%X%c", | 
					
						
							|  |  |  | 		   &b5, &b4, &b3, &b2, &b1, &b0, &ch); | 
					
						
							|  |  |  | 	if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) { | 
					
						
							|  |  |  | 		bdaddr->b[0] = b0; | 
					
						
							|  |  |  | 		bdaddr->b[1] = b1; | 
					
						
							|  |  |  | 		bdaddr->b[2] = b2; | 
					
						
							|  |  |  | 		bdaddr->b[3] = b3; | 
					
						
							|  |  |  | 		bdaddr->b[4] = b4; | 
					
						
							|  |  |  | 		bdaddr->b[5] = b5; | 
					
						
							|  |  |  | 		return 6; | 
					
						
							|  |  |  | 	} else { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_error, "bad bluetooth address"); | 
					
						
							|  |  |  | 		return -1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* Create a string representation of the Bluetooth address.  This is always a
 | 
					
						
							|  |  |  |    string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal | 
					
						
							|  |  |  |    value (zero padded if necessary). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | makebdaddr(bdaddr_t *bdaddr) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	char buf[(6 * 2) + 5 + 1]; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", | 
					
						
							|  |  |  | 		bdaddr->b[5], bdaddr->b[4], bdaddr->b[3], | 
					
						
							|  |  |  | 		bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]); | 
					
						
							|  |  |  | 	return PyString_FromString(buf); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Create an object representing the given socket address,
 | 
					
						
							|  |  |  |    suitable for passing it back to bind(), connect() etc. | 
					
						
							|  |  |  |    The family field of the sockaddr structure is inspected | 
					
						
							|  |  |  |    to determine what kind of address it really is. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | /*ARGSUSED*/ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1992-08-05 19:00:45 +00:00
										 |  |  | 	if (addrlen == 0) { | 
					
						
							|  |  |  | 		/* No address -- may be recvfrom() from known socket */ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		Py_INCREF(Py_None); | 
					
						
							|  |  |  | 		return Py_None; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:00:45 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #ifdef __BEOS__
 | 
					
						
							| 
									
										
										
										
											2000-04-25 21:34:53 +00:00
										 |  |  | 	/* XXX: BeOS version of accept() doesn't set family correctly */ | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | 	addr->sa_family = AF_INET; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	switch (addr->sa_family) { | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		struct sockaddr_in *a; | 
					
						
							|  |  |  | 		PyObject *addrobj = makeipaddr(addr, sizeof(*a)); | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		PyObject *ret = NULL; | 
					
						
							|  |  |  | 		if (addrobj) { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			a = (struct sockaddr_in *)addr; | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 			ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port)); | 
					
						
							|  |  |  | 			Py_DECREF(addrobj); | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											1993-02-05 09:46:15 +00:00
										 |  |  | 		return ret; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-04-04 07:13:49 +00:00
										 |  |  | #if defined(AF_UNIX)
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	case AF_UNIX: | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		struct sockaddr_un *a = (struct sockaddr_un *) addr; | 
					
						
							| 
									
										
										
										
											2006-04-19 11:50:27 +00:00
										 |  |  | #ifdef linux
 | 
					
						
							|  |  |  | 		if (a->sun_path[0] == 0) {  /* Linux abstract namespace */ | 
					
						
							|  |  |  | 			addrlen -= (sizeof(*a) - sizeof(a->sun_path)); | 
					
						
							|  |  |  | 			return PyString_FromStringAndSize(a->sun_path, | 
					
						
							|  |  |  | 							  addrlen); | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		else | 
					
						
							|  |  |  | #endif /* linux */
 | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			/* regular NULL-terminated string */ | 
					
						
							|  |  |  | 			return PyString_FromString(a->sun_path); | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif /* AF_UNIX */
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | #if defined(AF_NETLINK)
 | 
					
						
							|  |  |  |        case AF_NETLINK: | 
					
						
							|  |  |  |        { | 
					
						
							|  |  |  |                struct sockaddr_nl *a = (struct sockaddr_nl *) addr; | 
					
						
							| 
									
										
										
										
											2006-01-15 07:49:20 +00:00
										 |  |  |                return Py_BuildValue("II", a->nl_pid, a->nl_groups); | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  |        } | 
					
						
							|  |  |  | #endif /* AF_NETLINK */
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct sockaddr_in6 *a; | 
					
						
							|  |  |  | 		PyObject *addrobj = makeipaddr(addr, sizeof(*a)); | 
					
						
							|  |  |  | 		PyObject *ret = NULL; | 
					
						
							|  |  |  | 		if (addrobj) { | 
					
						
							|  |  |  | 			a = (struct sockaddr_in6 *)addr; | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 			ret = Py_BuildValue("Oiii", | 
					
						
							|  |  |  | 					    addrobj, | 
					
						
							|  |  |  | 					    ntohs(a->sin6_port), | 
					
						
							|  |  |  | 					    a->sin6_flowinfo, | 
					
						
							|  |  |  | 					    a->sin6_scope_id); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			Py_DECREF(addrobj); | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		return ret; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | #ifdef USE_BLUETOOTH
 | 
					
						
							|  |  |  | 	case AF_BLUETOOTH: | 
					
						
							|  |  |  | 		switch (proto) { | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		case BTPROTO_L2CAP: | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr; | 
					
						
							|  |  |  | 			PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr)); | 
					
						
							|  |  |  | 			PyObject *ret = NULL; | 
					
						
							|  |  |  | 			if (addrobj) { | 
					
						
							|  |  |  | 				ret = Py_BuildValue("Oi", | 
					
						
							|  |  |  | 						    addrobj, | 
					
						
							|  |  |  | 						    _BT_L2_MEMB(a, psm)); | 
					
						
							|  |  |  | 				Py_DECREF(addrobj); | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 			return ret; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		case BTPROTO_RFCOMM: | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			struct sockaddr_rc *a = (struct sockaddr_rc *) addr; | 
					
						
							|  |  |  | 			PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr)); | 
					
						
							|  |  |  | 			PyObject *ret = NULL; | 
					
						
							|  |  |  | 			if (addrobj) { | 
					
						
							|  |  |  | 				ret = Py_BuildValue("Oi", | 
					
						
							|  |  |  | 						    addrobj, | 
					
						
							|  |  |  | 						    _BT_RC_MEMB(a, channel)); | 
					
						
							|  |  |  | 				Py_DECREF(addrobj); | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 			return ret; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #if !defined(__FreeBSD__)
 | 
					
						
							|  |  |  | 		case BTPROTO_SCO: | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			struct sockaddr_sco *a = (struct sockaddr_sco *) addr; | 
					
						
							|  |  |  | 			return makebdaddr(&_BT_SCO_MEMB(a, bdaddr)); | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-10 20:29:40 +00:00
										 |  |  | #ifdef HAVE_NETPACKET_PACKET_H
 | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 	case AF_PACKET: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct sockaddr_ll *a = (struct sockaddr_ll *)addr; | 
					
						
							|  |  |  | 		char *ifname = ""; | 
					
						
							|  |  |  | 		struct ifreq ifr; | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 		/* need to look up interface name give index */ | 
					
						
							|  |  |  | 		if (a->sll_ifindex) { | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 			ifr.ifr_ifindex = a->sll_ifindex; | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 			if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0) | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 				ifname = ifr.ifr_name; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 		return Py_BuildValue("shbhs#", | 
					
						
							|  |  |  | 				     ifname, | 
					
						
							|  |  |  | 				     ntohs(a->sll_protocol), | 
					
						
							|  |  |  | 				     a->sll_pkttype, | 
					
						
							|  |  |  | 				     a->sll_hatype, | 
					
						
							|  |  |  | 				     a->sll_addr, | 
					
						
							|  |  |  | 				     a->sll_halen); | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	/* More cases here... */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	default: | 
					
						
							| 
									
										
										
										
											1997-05-07 17:41:48 +00:00
										 |  |  | 		/* If we don't know the address family, don't raise an
 | 
					
						
							|  |  |  | 		   exception -- return it as a tuple. */ | 
					
						
							|  |  |  | 		return Py_BuildValue("is#", | 
					
						
							|  |  |  | 				     addr->sa_family, | 
					
						
							|  |  |  | 				     addr->sa_data, | 
					
						
							|  |  |  | 				     sizeof(addr->sa_data)); | 
					
						
							| 
									
										
										
										
											1992-08-05 19:00:45 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Parse a socket address argument according to the socket object's
 | 
					
						
							|  |  |  |    address family.  Return 1 if the address was in the proper format, | 
					
						
							|  |  |  |    0 of not.  The address is returned through addr_ret, its length | 
					
						
							|  |  |  |    through len_ret. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | static int | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | getsockaddrarg(PySocketSockObject *s, PyObject *args, | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 	       struct sockaddr **addr_ret, int *len_ret) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	switch (s->sock_family) { | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-04-04 07:13:49 +00:00
										 |  |  | #if defined(AF_UNIX)
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	case AF_UNIX: | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		struct sockaddr_un* addr; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 		char *path; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		int len; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 		addr = (struct sockaddr_un*)&(s->sock_addr).un; | 
					
						
							| 
									
										
										
										
											1998-10-08 02:25:24 +00:00
										 |  |  | 		if (!PyArg_Parse(args, "t#", &path, &len)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 			return 0; | 
					
						
							| 
									
										
										
										
											2006-04-19 11:50:27 +00:00
										 |  |  | #ifdef linux
 | 
					
						
							|  |  |  | 		if (len > 0 && path[0] == 0) { | 
					
						
							|  |  |  | 			/* Linux abstract namespace extension */ | 
					
						
							|  |  |  | 			if (len > sizeof addr->sun_path) { | 
					
						
							|  |  |  | 				PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 						"AF_UNIX path too long"); | 
					
						
							|  |  |  | 				return 0; | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		else | 
					
						
							|  |  |  | #endif /* linux */
 | 
					
						
							|  |  |  |                 { | 
					
						
							|  |  |  | 			/* regular NULL-terminated string */ | 
					
						
							|  |  |  | 			if (len >= sizeof addr->sun_path) { | 
					
						
							|  |  |  | 				PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 						"AF_UNIX path too long"); | 
					
						
							|  |  |  | 				return 0; | 
					
						
							|  |  |  | 			} | 
					
						
							|  |  |  | 			addr->sun_path[len] = 0; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		addr->sun_family = s->sock_family; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		memcpy(addr->sun_path, path, len); | 
					
						
							|  |  |  | 		*addr_ret = (struct sockaddr *) addr; | 
					
						
							| 
									
										
										
										
											2004-04-11 12:03:57 +00:00
										 |  |  | #if defined(PYOS_OS2)
 | 
					
						
							|  |  |  | 		*len_ret = sizeof(*addr); | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1996-06-11 18:36:33 +00:00
										 |  |  | 		*len_ret = len + sizeof(*addr) - sizeof(addr->sun_path); | 
					
						
							| 
									
										
										
										
											2004-04-11 12:03:57 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #endif /* AF_UNIX */
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | #if defined(AF_NETLINK)
 | 
					
						
							|  |  |  | 	case AF_NETLINK: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct sockaddr_nl* addr; | 
					
						
							|  |  |  | 		int pid, groups; | 
					
						
							|  |  |  | 		addr = (struct sockaddr_nl *)&(s->sock_addr).nl; | 
					
						
							|  |  |  | 		if (!PyTuple_Check(args)) { | 
					
						
							|  |  |  | 			PyErr_Format( | 
					
						
							|  |  |  | 				PyExc_TypeError, | 
					
						
							|  |  |  | 				"getsockaddrarg: " | 
					
						
							|  |  |  | 				"AF_NETLINK address must be tuple, not %.500s", | 
					
						
							|  |  |  | 				args->ob_type->tp_name); | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups)) | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 		addr->nl_family = AF_NETLINK; | 
					
						
							|  |  |  | 		addr->nl_pid = pid; | 
					
						
							|  |  |  | 		addr->nl_groups = groups; | 
					
						
							|  |  |  | 		*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 		*len_ret = sizeof(*addr); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		struct sockaddr_in* addr; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 		char *host; | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  | 		int port, result; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  |  		addr=(struct sockaddr_in*)&(s->sock_addr).in; | 
					
						
							| 
									
										
										
										
											2000-12-01 13:13:11 +00:00
										 |  |  | 		if (!PyTuple_Check(args)) { | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 			PyErr_Format( | 
					
						
							|  |  |  | 				PyExc_TypeError, | 
					
						
							|  |  |  | 				"getsockaddrarg: " | 
					
						
							|  |  |  | 				"AF_INET address must be tuple, not %.500s", | 
					
						
							|  |  |  | 				args->ob_type->tp_name); | 
					
						
							| 
									
										
										
										
											2000-12-01 13:13:11 +00:00
										 |  |  | 			return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		if (!PyArg_ParseTuple(args, "eti:getsockaddrarg", | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 				      "idna", &host, &port)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 			return 0; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  |                 result = setipaddr(host, (struct sockaddr *)addr, | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  |                                    sizeof(*addr),  AF_INET); | 
					
						
							|  |  |  |                 PyMem_Free(host); | 
					
						
							|  |  |  |                 if (result < 0) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 			return 0; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		addr->sin_family = AF_INET; | 
					
						
							| 
									
										
										
										
											1997-04-09 19:24:53 +00:00
										 |  |  | 		addr->sin_port = htons((short)port); | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 		*len_ret = sizeof *addr; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct sockaddr_in6* addr; | 
					
						
							|  |  |  | 		char *host; | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  | 		int port, flowinfo, scope_id, result; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  |  		addr = (struct sockaddr_in6*)&(s->sock_addr).in6; | 
					
						
							|  |  |  | 		flowinfo = scope_id = 0; | 
					
						
							| 
									
										
										
										
											2006-04-25 15:08:10 +00:00
										 |  |  | 		if (!PyTuple_Check(args)) { | 
					
						
							|  |  |  | 			PyErr_Format( | 
					
						
							|  |  |  | 				PyExc_TypeError, | 
					
						
							|  |  |  | 				"getsockaddrarg: " | 
					
						
							|  |  |  | 				"AF_INET6 address must be tuple, not %.500s", | 
					
						
							|  |  |  | 				args->ob_type->tp_name); | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		if (!PyArg_ParseTuple(args, "eti|ii", | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 				      "idna", &host, &port, &flowinfo, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 				      &scope_id)) { | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  |                 result = setipaddr(host, (struct sockaddr *)addr, | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  |                                    sizeof(*addr), AF_INET6); | 
					
						
							|  |  |  |                 PyMem_Free(host); | 
					
						
							|  |  |  |                 if (result < 0) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			return 0; | 
					
						
							|  |  |  | 		addr->sin6_family = s->sock_family; | 
					
						
							|  |  |  | 		addr->sin6_port = htons((short)port); | 
					
						
							|  |  |  | 		addr->sin6_flowinfo = flowinfo; | 
					
						
							|  |  |  | 		addr->sin6_scope_id = scope_id; | 
					
						
							|  |  |  | 		*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 		*len_ret = sizeof *addr; | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #ifdef USE_BLUETOOTH
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 	case AF_BLUETOOTH: | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 		switch (s->sock_proto) { | 
					
						
							|  |  |  | 		case BTPROTO_L2CAP: | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 		{ | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			struct sockaddr_l2 *addr = (struct sockaddr_l2 *) _BT_SOCKADDR_MEMB(s, l2); | 
					
						
							|  |  |  | 			char *straddr; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 			_BT_L2_MEMB(addr, family) = AF_BLUETOOTH; | 
					
						
							|  |  |  | 			if (!PyArg_ParseTuple(args, "si", &straddr, | 
					
						
							|  |  |  | 					      &_BT_L2_MEMB(addr, psm))) { | 
					
						
							|  |  |  | 				PyErr_SetString(socket_error, "getsockaddrarg: " | 
					
						
							|  |  |  | 						"wrong format"); | 
					
						
							|  |  |  | 				return 0; | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 			} | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0) | 
					
						
							|  |  |  | 				return 0; | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 			*len_ret = sizeof *addr; | 
					
						
							|  |  |  | 			return 1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		case BTPROTO_RFCOMM: | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			struct sockaddr_rc *addr = (struct sockaddr_rc *) _BT_SOCKADDR_MEMB(s, rc); | 
					
						
							|  |  |  | 			char *straddr; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 			_BT_RC_MEMB(addr, family) = AF_BLUETOOTH; | 
					
						
							|  |  |  | 			if (!PyArg_ParseTuple(args, "si", &straddr, | 
					
						
							|  |  |  | 					      &_BT_RC_MEMB(addr, channel))) { | 
					
						
							|  |  |  | 				PyErr_SetString(socket_error, "getsockaddrarg: " | 
					
						
							|  |  |  | 						"wrong format"); | 
					
						
							|  |  |  | 				return 0; | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 			} | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0) | 
					
						
							|  |  |  | 				return 0; | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 			*len_ret = sizeof *addr; | 
					
						
							|  |  |  | 			return 1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | #if !defined(__FreeBSD__)
 | 
					
						
							|  |  |  | 		case BTPROTO_SCO: | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			struct sockaddr_sco *addr = (struct sockaddr_sco *) _BT_SOCKADDR_MEMB(s, sco); | 
					
						
							|  |  |  | 			char *straddr; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 			_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH; | 
					
						
							|  |  |  | 			straddr = PyString_AsString(args); | 
					
						
							|  |  |  | 			if (straddr == NULL) { | 
					
						
							|  |  |  | 				PyErr_SetString(socket_error, "getsockaddrarg: " | 
					
						
							|  |  |  | 						"wrong format"); | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 				return 0; | 
					
						
							|  |  |  | 			} | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0) | 
					
						
							|  |  |  | 				return 0; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 			*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 			*len_ret = sizeof *addr; | 
					
						
							|  |  |  | 			return 1; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 		default: | 
					
						
							|  |  |  | 			PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol"); | 
					
						
							|  |  |  | 			return 0; | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-10 20:29:40 +00:00
										 |  |  | #ifdef HAVE_NETPACKET_PACKET_H
 | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 	case AF_PACKET: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		struct sockaddr_ll* addr; | 
					
						
							|  |  |  | 		struct ifreq ifr; | 
					
						
							|  |  |  | 		char *interfaceName; | 
					
						
							|  |  |  | 		int protoNumber; | 
					
						
							|  |  |  | 		int hatype = 0; | 
					
						
							|  |  |  | 		int pkttype = 0; | 
					
						
							| 
									
										
										
										
											2004-07-10 23:39:35 +00:00
										 |  |  | 		char *haddr = NULL; | 
					
						
							|  |  |  | 		unsigned int halen = 0; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-04-25 15:08:10 +00:00
										 |  |  | 		if (!PyTuple_Check(args)) { | 
					
						
							|  |  |  | 			PyErr_Format( | 
					
						
							|  |  |  | 				PyExc_TypeError, | 
					
						
							|  |  |  | 				"getsockaddrarg: " | 
					
						
							|  |  |  | 				"AF_PACKET address must be tuple, not %.500s", | 
					
						
							|  |  |  | 				args->ob_type->tp_name); | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2004-07-10 23:39:35 +00:00
										 |  |  | 		if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName, | 
					
						
							|  |  |  | 				      &protoNumber, &pkttype, &hatype, | 
					
						
							|  |  |  | 				      &haddr, &halen)) | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 			return 0; | 
					
						
							|  |  |  | 		strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name)); | 
					
						
							|  |  |  | 		ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0'; | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 		if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) { | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		        s->errorhandler(); | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 			return 0; | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 		addr = &(s->sock_addr.ll); | 
					
						
							|  |  |  | 		addr->sll_family = AF_PACKET; | 
					
						
							|  |  |  | 		addr->sll_protocol = htons((short)protoNumber); | 
					
						
							|  |  |  | 		addr->sll_ifindex = ifr.ifr_ifindex; | 
					
						
							|  |  |  | 		addr->sll_pkttype = pkttype; | 
					
						
							|  |  |  | 		addr->sll_hatype = hatype; | 
					
						
							| 
									
										
										
										
											2004-07-10 23:39:35 +00:00
										 |  |  | 		if (halen > 8) { | 
					
						
							|  |  |  | 		  PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				  "Hardware address must be 8 bytes or less"); | 
					
						
							|  |  |  | 		  return 0; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		if (halen != 0) { | 
					
						
							|  |  |  | 		  memcpy(&addr->sll_addr, haddr, halen); | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		addr->sll_halen = halen; | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 		*addr_ret = (struct sockaddr *) addr; | 
					
						
							|  |  |  | 		*len_ret = sizeof *addr; | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	/* More cases here... */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	default: | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "getsockaddrarg: bad family"); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		return 0; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | /* Get the address length according to the socket object's address family.
 | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  |    Return 1 if the family is known, 0 otherwise.  The length is returned | 
					
						
							|  |  |  |    through len_ret. */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static int | 
					
						
							| 
									
										
										
										
											2000-07-11 23:00:12 +00:00
										 |  |  | getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret) | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	switch (s->sock_family) { | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-04-04 07:13:49 +00:00
										 |  |  | #if defined(AF_UNIX)
 | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | 	case AF_UNIX: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		*len_ret = sizeof (struct sockaddr_un); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #endif /* AF_UNIX */
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | #if defined(AF_NETLINK)
 | 
					
						
							|  |  |  |        case AF_NETLINK: | 
					
						
							|  |  |  |        { | 
					
						
							|  |  |  |                *len_ret = sizeof (struct sockaddr_nl); | 
					
						
							|  |  |  |                return 1; | 
					
						
							|  |  |  |        } | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		*len_ret = sizeof (struct sockaddr_in); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		*len_ret = sizeof (struct sockaddr_in6); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #ifdef USE_BLUETOOTH
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 	case AF_BLUETOOTH: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		switch(s->sock_proto) | 
					
						
							|  |  |  | 		{ | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 		case BTPROTO_L2CAP: | 
					
						
							|  |  |  | 			*len_ret = sizeof (struct sockaddr_l2); | 
					
						
							|  |  |  | 			return 1; | 
					
						
							|  |  |  | 		case BTPROTO_RFCOMM: | 
					
						
							|  |  |  | 			*len_ret = sizeof (struct sockaddr_rc); | 
					
						
							|  |  |  | 			return 1; | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #if !defined(__FreeBSD__)
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 		case BTPROTO_SCO: | 
					
						
							|  |  |  | 			*len_ret = sizeof (struct sockaddr_sco); | 
					
						
							|  |  |  | 			return 1; | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 		default: | 
					
						
							|  |  |  | 			PyErr_SetString(socket_error, "getsockaddrlen: " | 
					
						
							|  |  |  | 					"unknown BT protocol"); | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-10 20:29:40 +00:00
										 |  |  | #ifdef HAVE_NETPACKET_PACKET_H
 | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | 	case AF_PACKET: | 
					
						
							|  |  |  | 	{ | 
					
						
							|  |  |  | 		*len_ret = sizeof (struct sockaddr_ll); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | 	/* More cases here... */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	default: | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "getsockaddrlen: bad family"); | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | 		return 0; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* s.accept() method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_accept(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	sock_addr_t addrbuf; | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | 	SOCKET_T newfd; | 
					
						
							| 
									
										
										
										
											2000-04-24 15:16:03 +00:00
										 |  |  | 	socklen_t addrlen; | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 	PyObject *sock = NULL; | 
					
						
							|  |  |  | 	PyObject *addr = NULL; | 
					
						
							|  |  |  | 	PyObject *res = NULL; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int timeout; | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-12 10:39:36 +00:00
										 |  |  | 	if (!getsockaddrlen(s, &addrlen)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	memset(&addrbuf, 0, addrlen); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | #ifdef MS_WINDOWS
 | 
					
						
							|  |  |  | 	newfd = INVALID_SOCKET; | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	newfd = -1; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 	if (!IS_SELECTABLE(s)) | 
					
						
							|  |  |  | 		return select_error(); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = internal_select(s, 0); | 
					
						
							|  |  |  | 	if (!timeout) | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 		newfd = accept(s->sock_fd, (struct sockaddr *) &addrbuf, | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 			       &addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #ifdef MS_WINDOWS
 | 
					
						
							|  |  |  | 	if (newfd == INVALID_SOCKET) | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	if (newfd < 0) | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	/* Create the new object with unspecified family,
 | 
					
						
							|  |  |  | 	   to avoid calls to bind() etc. on it. */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	sock = (PyObject *) new_sockobject(newfd, | 
					
						
							|  |  |  | 					   s->sock_family, | 
					
						
							|  |  |  | 					   s->sock_type, | 
					
						
							|  |  |  | 					   s->sock_proto); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 	if (sock == NULL) { | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | 		SOCKETCLOSE(newfd); | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		goto finally; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	addr = makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			    addrlen, s->sock_proto); | 
					
						
							| 
									
										
										
										
											2001-02-02 19:55:17 +00:00
										 |  |  | 	if (addr == NULL) | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		goto finally; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-10-12 19:09:37 +00:00
										 |  |  | 	res = PyTuple_Pack(2, sock, addr); | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | finally: | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_XDECREF(sock); | 
					
						
							|  |  |  | 	Py_XDECREF(addr); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	return res; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(accept_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "accept() -> (socket object, address info)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Wait for an incoming connection.  Return a new socket representing the\n\ | 
					
						
							|  |  |  | connection, and the address of the client.  For IP sockets, the address\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | info is a pair (hostaddr, port)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | /* s.setblocking(flag) method.  Argument:
 | 
					
						
							|  |  |  |    False -- non-blocking mode; same as settimeout(0) | 
					
						
							|  |  |  |    True -- blocking mode; same as settimeout(None) | 
					
						
							|  |  |  | */ | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_setblocking(PySocketSockObject *s, PyObject *arg) | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int block; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 	block = PyInt_AsLong(arg); | 
					
						
							|  |  |  | 	if (block == -1 && PyErr_Occurred()) | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	s->sock_timeout = block ? -1.0 : 0.0; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:36:20 +00:00
										 |  |  | 	internal_setblocking(s, block); | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(setblocking_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "setblocking(flag)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Set the socket to blocking (flag is true) or non-blocking (false).\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | setblocking(True) is equivalent to settimeout(None);\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | setblocking(False) is equivalent to settimeout(0.0)."); | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* s.settimeout(timeout) method.  Argument:
 | 
					
						
							|  |  |  |    None -- no timeout, blocking mode; same as setblocking(True) | 
					
						
							|  |  |  |    0.0  -- non-blocking mode; same as setblocking(False) | 
					
						
							|  |  |  |    > 0  -- timeout mode; operations time out after timeout seconds | 
					
						
							|  |  |  |    < 0  -- illegal; raises an exception | 
					
						
							|  |  |  | */ | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_settimeout(PySocketSockObject *s, PyObject *arg) | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	double timeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (arg == Py_None) | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 		timeout = -1.0; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	else { | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 		timeout = PyFloat_AsDouble(arg); | 
					
						
							|  |  |  | 		if (timeout < 0.0) { | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 			if (!PyErr_Occurred()) | 
					
						
							|  |  |  | 				PyErr_SetString(PyExc_ValueError, | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 						"Timeout value out of range"); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	s->sock_timeout = timeout; | 
					
						
							|  |  |  | 	internal_setblocking(s, timeout < 0.0); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(settimeout_doc, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | "settimeout(timeout)\n\
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | Set a timeout on socket operations.  'timeout' can be a float,\n\ | 
					
						
							|  |  |  | giving in seconds, or None.  Setting a timeout of None disables\n\ | 
					
						
							|  |  |  | the timeout feature and is equivalent to setblocking(1).\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Setting a timeout of zero is the same as setblocking(0)."); | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* s.gettimeout() method.
 | 
					
						
							|  |  |  |    Returns the timeout associated with a socket. */ | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_gettimeout(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	if (s->sock_timeout < 0.0) { | 
					
						
							|  |  |  | 		Py_INCREF(Py_None); | 
					
						
							|  |  |  | 		return Py_None; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else | 
					
						
							|  |  |  | 		return PyFloat_FromDouble(s->sock_timeout); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(gettimeout_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "gettimeout() -> timeout\n\
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Returns the timeout in floating seconds associated with socket \n\ | 
					
						
							|  |  |  | operations. A timeout of None indicates that timeouts on socket \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | operations are disabled."); | 
					
						
							| 
									
										
										
										
											1994-09-07 14:32:49 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #ifdef RISCOS
 | 
					
						
							|  |  |  | /* s.sleeptaskw(1 | 0) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | sock_sleeptaskw(PySocketSockObject *s,PyObject *arg) | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	int block; | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | 	block = PyInt_AsLong(arg); | 
					
						
							|  |  |  | 	if (block == -1 && PyErr_Occurred()) | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(sleeptaskw_doc, | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | "sleeptaskw(flag)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Allow sleeps in taskwindows."); | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | /* s.setsockopt() method.
 | 
					
						
							|  |  |  |    With an integer third argument, sets an integer option. | 
					
						
							|  |  |  |    With a string third argument, sets an option from a buffer; | 
					
						
							|  |  |  |    use optional built-in module 'struct' to encode the string. */ | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_setsockopt(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int level; | 
					
						
							|  |  |  | 	int optname; | 
					
						
							|  |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	char *buf; | 
					
						
							|  |  |  | 	int buflen; | 
					
						
							|  |  |  | 	int flag; | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (PyArg_ParseTuple(args, "iii:setsockopt", | 
					
						
							|  |  |  | 			     &level, &optname, &flag)) { | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 		buf = (char *) &flag; | 
					
						
							|  |  |  | 		buflen = sizeof flag; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		PyErr_Clear(); | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 		if (!PyArg_ParseTuple(args, "iis#:setsockopt", | 
					
						
							|  |  |  | 				      &level, &optname, &buf, &buflen)) | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 			return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2000-07-25 12:56:38 +00:00
										 |  |  | 	res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen); | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(setsockopt_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "setsockopt(level, option, value)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Set a socket option.  See the Unix manual for level and option.\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | The value argument can either be an integer or a string."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | /* s.getsockopt() method.
 | 
					
						
							|  |  |  |    With two arguments, retrieves an integer option. | 
					
						
							|  |  |  |    With a third integer argument, retrieves a string buffer of that size; | 
					
						
							|  |  |  |    use optional built-in module 'struct' to decode the string. */ | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_getsockopt(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int level; | 
					
						
							|  |  |  | 	int optname; | 
					
						
							|  |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	PyObject *buf; | 
					
						
							| 
									
										
										
										
											2000-04-24 15:16:03 +00:00
										 |  |  | 	socklen_t buflen = 0; | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #ifdef __BEOS__
 | 
					
						
							| 
									
										
										
										
											2001-05-11 20:12:26 +00:00
										 |  |  | 	/* We have incomplete socket support. */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	PyErr_SetString(socket_error, "getsockopt not supported"); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | 	return NULL; | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "ii|i:getsockopt", | 
					
						
							|  |  |  | 			      &level, &optname, &buflen)) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	if (buflen == 0) { | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 		int flag = 0; | 
					
						
							| 
									
										
										
										
											2000-04-24 15:16:03 +00:00
										 |  |  | 		socklen_t flagsize = sizeof flag; | 
					
						
							| 
									
										
										
										
											1993-11-23 17:53:17 +00:00
										 |  |  | 		res = getsockopt(s->sock_fd, level, optname, | 
					
						
							| 
									
										
										
										
											2000-07-25 12:56:38 +00:00
										 |  |  | 				 (void *)&flag, &flagsize); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 		if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 			return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		return PyInt_FromLong(flag); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | 	/* socklen_t is unsigned so no negative test is needed,
 | 
					
						
							|  |  |  | 	   test buflen == 0 is previously done */ | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 	if (buflen > 1024) { | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	if (buflen <= 0 || buflen > 1024) { | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 				"getsockopt buflen out of range"); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	buf = PyString_FromStringAndSize((char *)NULL, buflen); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	if (buf == NULL) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											1993-11-23 17:53:17 +00:00
										 |  |  | 	res = getsockopt(s->sock_fd, level, optname, | 
					
						
							| 
									
										
										
										
											2001-05-11 20:12:26 +00:00
										 |  |  | 			 (void *)PyString_AS_STRING(buf), &buflen); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	if (res < 0) { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		Py_DECREF(buf); | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	_PyString_Resize(&buf, buflen); | 
					
						
							| 
									
										
										
										
											1992-09-08 09:05:33 +00:00
										 |  |  | 	return buf; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #endif /* __BEOS__ */
 | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getsockopt_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "getsockopt(level, option[, buffersize]) -> value\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Get a socket option.  See the Unix manual for level and option.\n\ | 
					
						
							|  |  |  | If a nonzero buffersize argument is given, the return value is a\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | string of that length; otherwise it is an integer."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-05 15:11:30 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | /* s.bind(sockaddr) method */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_bind(PySocketSockObject *s, PyObject *addro) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	struct sockaddr *addr; | 
					
						
							|  |  |  | 	int addrlen; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | 	if (!getsockaddrarg(s, addro, &addr, &addrlen)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	res = bind(s->sock_fd, addr, addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(bind_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "bind(address)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Bind the socket to a local address.  For IP sockets, the address is a\n\ | 
					
						
							| 
									
										
										
										
											2001-02-02 03:23:09 +00:00
										 |  |  | pair (host, port); the host must refer to the local host. For raw packet\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])"); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* s.close() method.
 | 
					
						
							|  |  |  |    Set the file descriptor to -1 so operations tried subsequently | 
					
						
							|  |  |  |    will surely fail. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_close(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2000-12-18 22:23:44 +00:00
										 |  |  | 	SOCKET_T fd; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-12-18 22:23:44 +00:00
										 |  |  | 	if ((fd = s->sock_fd) != -1) { | 
					
						
							|  |  |  | 		s->sock_fd = -1; | 
					
						
							| 
									
										
										
										
											1996-10-12 14:07:22 +00:00
										 |  |  | 		Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2000-12-18 22:23:44 +00:00
										 |  |  | 		(void) SOCKETCLOSE(fd); | 
					
						
							| 
									
										
										
										
											1996-10-12 14:07:22 +00:00
										 |  |  | 		Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(close_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "close()\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Close the socket.  It cannot be used after this call."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | static int | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen, | 
					
						
							|  |  |  | 		 int *timeoutp) | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int res, timeout; | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = 0; | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 	res = connect(s->sock_fd, addr, addrlen); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #ifdef MS_WINDOWS
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (s->sock_timeout > 0.0) { | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 		if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK && | 
					
						
							|  |  |  | 		    IS_SELECTABLE(s)) { | 
					
						
							| 
									
										
										
										
											2003-02-19 17:50:16 +00:00
										 |  |  | 			/* This is a mess.  Best solution: trust select */ | 
					
						
							|  |  |  | 			fd_set fds; | 
					
						
							| 
									
										
										
										
											2004-08-03 05:06:26 +00:00
										 |  |  | 			fd_set fds_exc; | 
					
						
							| 
									
										
										
										
											2003-02-19 17:50:16 +00:00
										 |  |  | 			struct timeval tv; | 
					
						
							|  |  |  | 			tv.tv_sec = (int)s->sock_timeout; | 
					
						
							|  |  |  | 			tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6); | 
					
						
							|  |  |  | 			FD_ZERO(&fds); | 
					
						
							|  |  |  | 			FD_SET(s->sock_fd, &fds); | 
					
						
							| 
									
										
										
										
											2004-08-03 05:06:26 +00:00
										 |  |  | 			FD_ZERO(&fds_exc); | 
					
						
							|  |  |  | 			FD_SET(s->sock_fd, &fds_exc); | 
					
						
							|  |  |  | 			res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv); | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 			if (res == 0) { | 
					
						
							| 
									
										
										
										
											2003-02-19 17:50:16 +00:00
										 |  |  | 				res = WSAEWOULDBLOCK; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 				timeout = 1; | 
					
						
							| 
									
										
										
										
											2004-08-03 05:06:26 +00:00
										 |  |  | 			} else if (res > 0) { | 
					
						
							|  |  |  | 				if (FD_ISSET(s->sock_fd, &fds)) | 
					
						
							|  |  |  | 					/* The socket is in the writeable set - this
 | 
					
						
							|  |  |  | 					   means connected */ | 
					
						
							|  |  |  | 					res = 0; | 
					
						
							|  |  |  | 				else { | 
					
						
							|  |  |  | 					/* As per MS docs, we need to call getsockopt()
 | 
					
						
							|  |  |  | 					   to get the underlying error */ | 
					
						
							|  |  |  | 					int res_size = sizeof res; | 
					
						
							|  |  |  | 					/* It must be in the exception set */ | 
					
						
							|  |  |  | 					assert(FD_ISSET(s->sock_fd, &fds_exc)); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 					if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR, | 
					
						
							| 
									
										
										
										
											2004-08-03 05:06:26 +00:00
										 |  |  | 					                    (char *)&res, &res_size)) | 
					
						
							|  |  |  | 						/* getsockopt also clears WSAGetLastError,
 | 
					
						
							|  |  |  | 						   so reset it back. */ | 
					
						
							|  |  |  | 						WSASetLastError(res); | 
					
						
							|  |  |  | 					else | 
					
						
							|  |  |  | 						res = WSAGetLastError(); | 
					
						
							|  |  |  | 				} | 
					
						
							|  |  |  | 			} | 
					
						
							| 
									
										
										
										
											2003-02-19 17:50:16 +00:00
										 |  |  | 			/* else if (res < 0) an error occurred */ | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (res < 0) | 
					
						
							|  |  |  | 		res = WSAGetLastError(); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (s->sock_timeout > 0.0) { | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 		if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) { | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 			timeout = internal_select(s, 1); | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 			res = connect(s->sock_fd, addr, addrlen); | 
					
						
							| 
									
										
										
										
											2002-08-08 20:39:30 +00:00
										 |  |  | 			if (res < 0 && errno == EISCONN) | 
					
						
							|  |  |  | 				res = 0; | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (res < 0) | 
					
						
							|  |  |  | 		res = errno; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	*timeoutp = timeout; | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	return res; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | /* s.connect(sockaddr) method */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_connect(PySocketSockObject *s, PyObject *addro) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	struct sockaddr *addr; | 
					
						
							|  |  |  | 	int addrlen; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int timeout; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | 	if (!getsockaddrarg(s, addro, &addr, &addrlen)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	res = internal_connect(s, addr, addrlen, &timeout); | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-13 16:07:04 +00:00
										 |  |  | 	if (res != 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(connect_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "connect(address)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Connect the socket to a remote address.  For IP sockets, the address\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | is a pair (host, port)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | /* s.connect_ex(sockaddr) method */ | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_connect_ex(PySocketSockObject *s, PyObject *addro) | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	struct sockaddr *addr; | 
					
						
							|  |  |  | 	int addrlen; | 
					
						
							|  |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int timeout; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-07-01 03:40:12 +00:00
										 |  |  | 	if (!getsockaddrarg(s, addro, &addr, &addrlen)) | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	res = internal_connect(s, addr, addrlen, &timeout); | 
					
						
							| 
									
										
										
										
											2002-06-13 15:07:44 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | 	return PyInt_FromLong((long) res); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(connect_ex_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "connect_ex(address) -> errno\n\
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | This is like connect(address), but returns an error code (the errno value)\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | instead of raising an exception when an error occurs."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-19 18:57:13 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-23 09:07:03 +00:00
										 |  |  | /* s.fileno() method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_fileno(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1992-06-23 09:07:03 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #if SIZEOF_SOCKET_T <= SIZEOF_LONG
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyInt_FromLong((long) s->sock_fd); | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2003-03-29 10:06:18 +00:00
										 |  |  | 	return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd); | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1992-06-23 09:07:03 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(fileno_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "fileno() -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Return the integer file descriptor of the socket."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-06-23 09:07:03 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							|  |  |  | /* s.dup() method */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_dup(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | 	SOCKET_T newfd; | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	PyObject *sock; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	newfd = dup(s->sock_fd); | 
					
						
							|  |  |  | 	if (newfd < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	sock = (PyObject *) new_sockobject(newfd, | 
					
						
							|  |  |  | 					   s->sock_family, | 
					
						
							|  |  |  | 					   s->sock_type, | 
					
						
							|  |  |  | 					   s->sock_proto); | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	if (sock == NULL) | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | 		SOCKETCLOSE(newfd); | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	return sock; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(dup_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "dup() -> socket object\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Return a new socket object connected to the same system resource."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | /* s.getsockname() method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_getsockname(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	sock_addr_t addrbuf; | 
					
						
							| 
									
										
										
										
											2000-04-24 15:16:03 +00:00
										 |  |  | 	int res; | 
					
						
							|  |  |  | 	socklen_t addrlen; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 	if (!getsockaddrlen(s, &addrlen)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	memset(&addrbuf, 0, addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	res = getsockname(s->sock_fd, (struct sockaddr *) &addrbuf, &addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	return makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, addrlen, | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			    s->sock_proto); | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getsockname_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "getsockname() -> address info\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return the address of the local endpoint.  For IP sockets, the address\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | info is a pair (hostaddr, port)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #ifdef HAVE_GETPEERNAME		/* Cray APP doesn't have this :-( */
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | /* s.getpeername() method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_getpeername(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	sock_addr_t addrbuf; | 
					
						
							| 
									
										
										
										
											2000-04-24 15:16:03 +00:00
										 |  |  | 	int res; | 
					
						
							|  |  |  | 	socklen_t addrlen; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 	if (!getsockaddrlen(s, &addrlen)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	memset(&addrbuf, 0, addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	res = getpeername(s->sock_fd, (struct sockaddr *) &addrbuf, &addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	return makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, addrlen, | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			    s->sock_proto); | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getpeername_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "getpeername() -> address info\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return the address of the remote endpoint.  For IP sockets, the address\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | info is a pair (hostaddr, port)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #endif /* HAVE_GETPEERNAME */
 | 
					
						
							| 
									
										
										
										
											1992-11-26 08:54:07 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* s.listen(n) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_listen(PySocketSockObject *s, PyObject *arg) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int backlog; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	backlog = PyInt_AsLong(arg); | 
					
						
							|  |  |  | 	if (backlog == -1 && PyErr_Occurred()) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | 	if (backlog < 1) | 
					
						
							|  |  |  | 		backlog = 1; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	res = listen(s->sock_fd, backlog); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(listen_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "listen(backlog)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Enable a server to accept connections.  The backlog argument must be at\n\ | 
					
						
							|  |  |  | least 1; it specifies the number of unaccepted connection that the system\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | will allow before refusing new connections."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* s.makefile(mode) method.
 | 
					
						
							|  |  |  |    Create a new open file object referring to a dupped version of | 
					
						
							|  |  |  |    the socket's file descriptor.  (The dup() call is necessary so | 
					
						
							|  |  |  |    that the open file and socket objects may be closed independent | 
					
						
							|  |  |  |    of each other.) | 
					
						
							|  |  |  |    The mode argument specifies 'r' or 'w' passed to fdopen(). */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_makefile(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2000-07-09 03:09:57 +00:00
										 |  |  | 	extern int fclose(FILE *); | 
					
						
							| 
									
										
										
										
											1995-03-14 15:05:13 +00:00
										 |  |  | 	char *mode = "r"; | 
					
						
							|  |  |  | 	int bufsize = -1; | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #ifdef MS_WIN32
 | 
					
						
							| 
									
										
										
										
											2001-08-29 21:37:10 +00:00
										 |  |  | 	Py_intptr_t fd; | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	int fd; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	FILE *fp; | 
					
						
							| 
									
										
										
										
											1995-03-14 15:05:13 +00:00
										 |  |  | 	PyObject *f; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | 	char *mode_r = "r"; | 
					
						
							|  |  |  | 	char *mode_w = "w"; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-03-14 15:05:13 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-02-29 13:59:29 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | 	if (strcmp(mode,"rb") == 0) { | 
					
						
							|  |  |  | 	    mode = mode_r; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else { | 
					
						
							|  |  |  | 		if (strcmp(mode,"wb") == 0) { | 
					
						
							|  |  |  | 			mode = mode_w; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1996-06-26 18:22:49 +00:00
										 |  |  | #ifdef MS_WIN32
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 	if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) || | 
					
						
							|  |  |  | 	    ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL)) | 
					
						
							| 
									
										
										
										
											1995-06-14 22:28:08 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 	if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL) | 
					
						
							| 
									
										
										
										
											1995-06-14 22:28:08 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 	{ | 
					
						
							| 
									
										
										
										
											1995-03-14 15:05:13 +00:00
										 |  |  | 		if (fd >= 0) | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | 			SOCKETCLOSE(fd); | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1995-03-14 15:05:13 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 	f = PyFile_FromFile(fp, "<socket>", mode, fclose); | 
					
						
							|  |  |  | 	if (f != NULL) | 
					
						
							|  |  |  | 		PyFile_SetBufSize(f, bufsize); | 
					
						
							|  |  |  | 	return f; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(makefile_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "makefile([mode[, buffersize]]) -> file object\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return a regular file object corresponding to the socket.\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | The mode and buffersize arguments are as for the built-in open() function."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #endif /* NO_DUP */
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | /*
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  |  * This is the guts of the recv() and recv_into() methods, which reads into a | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  |  * char buffer.  If you have any inc/def ref to do to the objects that contain | 
					
						
							|  |  |  |  * the buffer, do it in the caller.  This function returns the number of bytes | 
					
						
							|  |  |  |  * succesfully read.  If there was an error, it returns -1.  Note that it is | 
					
						
							|  |  |  |  * also possible that we return a number of bytes smaller than the request | 
					
						
							|  |  |  |  * bytes. | 
					
						
							|  |  |  |  */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | static ssize_t | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  |         ssize_t outlen = 0; | 
					
						
							|  |  |  |         int timeout; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	int remaining, nread; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 	char *read_buf; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	if (!IS_SELECTABLE(s)) { | 
					
						
							|  |  |  | 		select_error(); | 
					
						
							|  |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											2001-11-19 10:41:26 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #ifndef __VMS
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = internal_select(s, 0); | 
					
						
							|  |  |  | 	if (!timeout) | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		outlen = recv(s->sock_fd, cbuf, len, flags); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	if (outlen < 0) { | 
					
						
							|  |  |  | 		/* Note: the call to errorhandler() ALWAYS indirectly returned
 | 
					
						
							|  |  |  | 		   NULL, so ignore its return value */ | 
					
						
							|  |  |  | 		s->errorhandler(); | 
					
						
							|  |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											1995-09-13 18:39:47 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	read_buf = cbuf; | 
					
						
							|  |  |  | 	remaining = len; | 
					
						
							|  |  |  | 	while (remaining != 0) { | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		unsigned int segment; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		segment = remaining /SEGMENT_SIZE; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		if (segment != 0) { | 
					
						
							|  |  |  | 			segment = SEGMENT_SIZE; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		else { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 			segment = remaining; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		timeout = internal_select(s, 0); | 
					
						
							|  |  |  | 		if (!timeout) | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 			nread = recv(s->sock_fd, read_buf, segment, flags); | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		if (timeout) { | 
					
						
							|  |  |  | 			PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 			return -1; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		if (nread < 0) { | 
					
						
							|  |  |  | 			s->errorhandler(); | 
					
						
							|  |  |  | 			return -1; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		if (nread != remaining) { | 
					
						
							|  |  |  | 			read_buf += nread; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 			break; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		remaining -= segment; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | 		read_buf += segment; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	outlen = read_buf - cbuf; | 
					
						
							| 
									
										
										
										
											2002-12-06 12:48:53 +00:00
										 |  |  | #endif /* !__VMS */
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	return outlen; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* s.recv(nbytes [,flags]) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | sock_recv(PySocketSockObject *s, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	int recvlen, flags = 0; | 
					
						
							|  |  |  |         ssize_t outlen; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	PyObject *buf; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (recvlen < 0) { | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"negative buffersize in recv"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Allocate a new string. */ | 
					
						
							|  |  |  | 	buf = PyString_FromStringAndSize((char *) 0, recvlen); | 
					
						
							|  |  |  | 	if (buf == NULL) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Call the guts */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	if (outlen < 0) { | 
					
						
							|  |  |  | 		/* An error occured, release the string and return an
 | 
					
						
							|  |  |  | 		   error. */ | 
					
						
							|  |  |  | 		Py_DECREF(buf); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	if (outlen != recvlen) { | 
					
						
							|  |  |  | 		/* We did not read as many bytes as we anticipated, resize the
 | 
					
						
							|  |  |  | 		   string if possible and be succesful. */ | 
					
						
							|  |  |  | 		if (_PyString_Resize(&buf, outlen) < 0) | 
					
						
							|  |  |  | 			/* Oopsy, not so succesful after all. */ | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	return buf; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(recv_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "recv(buffersize[, flags]) -> data\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Receive up to buffersize bytes from the socket.  For the optional flags\n\ | 
					
						
							|  |  |  | argument, see the Unix manual.  When no data is available, block until\n\ | 
					
						
							|  |  |  | at least one byte is available or until the remote end is closed.  When\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | the remote end is closed and all data is read, return the empty string."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | /* s.recv_into(buffer, [nbytes [,flags]]) method */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | static PyObject* | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	static char *kwlist[] = {"buffer", "nbytes", "flags", 0}; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	int recvlen = 0, flags = 0; | 
					
						
							|  |  |  |         ssize_t readlen; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	char *buf; | 
					
						
							|  |  |  | 	int buflen; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Get the buffer's memory */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#|ii:recv", kwlist, | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 					 &buf, &buflen, &recvlen, &flags)) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	assert(buf != 0 && buflen > 0); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	if (recvlen < 0) { | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"negative buffersize in recv"); | 
					
						
							| 
									
										
										
										
											1993-05-25 12:16:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 	if (recvlen == 0) { | 
					
						
							|  |  |  |             /* If nbytes was not specified, use the buffer's length */ | 
					
						
							|  |  |  |             recvlen = buflen; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Check if the buffer is large enough */ | 
					
						
							|  |  |  | 	if (buflen < recvlen) { | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"buffer too small for requested bytes"); | 
					
						
							| 
									
										
										
										
											1993-05-25 12:16:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	/* Call the guts */ | 
					
						
							|  |  |  | 	readlen = sock_recv_guts(s, buf, recvlen, flags); | 
					
						
							|  |  |  | 	if (readlen < 0) { | 
					
						
							|  |  |  | 		/* Return an error. */ | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Return the number of bytes read.  Note that we do not do anything
 | 
					
						
							|  |  |  | 	   special here in the case that readlen < recvlen. */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	return PyInt_FromSsize_t(readlen); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | PyDoc_STRVAR(recv_into_doc, | 
					
						
							|  |  |  | "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | A version of recv() that stores its data into a buffer rather than creating \n\ | 
					
						
							|  |  |  | a new string.  Receive up to buffersize bytes from the socket.  If buffersize \n\ | 
					
						
							|  |  |  | is not specified (or 0), receive up to the size available in the given buffer.\n\ | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | See recv() for documentation about the flags."); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  |  * This is the guts of the recv() and recv_into() methods, which reads into a | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  |  * char buffer.  If you have any inc/def ref to do to the objects that contain | 
					
						
							|  |  |  |  * the buffer, do it in the caller.  This function returns the number of bytes | 
					
						
							|  |  |  |  * succesfully read.  If there was an error, it returns -1.  Note that it is | 
					
						
							|  |  |  |  * also possible that we return a number of bytes smaller than the request | 
					
						
							|  |  |  |  * bytes. | 
					
						
							|  |  |  |  * | 
					
						
							|  |  |  |  * 'addr' is a return value for the address object.  Note that you must decref | 
					
						
							|  |  |  |  * it yourself. | 
					
						
							|  |  |  |  */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | static ssize_t | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags, | 
					
						
							|  |  |  | 		   PyObject** addr) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	sock_addr_t addrbuf; | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	int timeout; | 
					
						
							|  |  |  | 	ssize_t n = 0; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	socklen_t addrlen; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	*addr = NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (!getsockaddrlen(s, &addrlen)) | 
					
						
							|  |  |  | 		return -1; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (!IS_SELECTABLE(s)) { | 
					
						
							|  |  |  | 		select_error(); | 
					
						
							|  |  |  | 		return -1; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	memset(&addrbuf, 0, addrlen); | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = internal_select(s, 0); | 
					
						
							| 
									
										
										
										
											2006-04-15 08:35:59 +00:00
										 |  |  | 	if (!timeout) { | 
					
						
							| 
									
										
										
										
											1996-06-26 18:22:49 +00:00
										 |  |  | #ifndef MS_WINDOWS
 | 
					
						
							| 
									
										
										
										
											2002-03-03 03:03:52 +00:00
										 |  |  | #if defined(PYOS_OS2) && !defined(PYCC_GCC)
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		n = recvfrom(s->sock_fd, cbuf, len, flags, | 
					
						
							| 
									
										
										
										
											2006-04-15 08:35:59 +00:00
										 |  |  | 			     (struct sockaddr *) &addrbuf, &addrlen); | 
					
						
							| 
									
										
										
										
											1997-12-02 20:37:32 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		n = recvfrom(s->sock_fd, cbuf, len, flags, | 
					
						
							| 
									
										
										
										
											2006-04-15 08:35:59 +00:00
										 |  |  | 			     (void *) &addrbuf, &addrlen); | 
					
						
							| 
									
										
										
										
											1997-12-02 20:37:32 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		n = recvfrom(s->sock_fd, cbuf, len, flags, | 
					
						
							| 
									
										
										
										
											2006-04-15 08:35:59 +00:00
										 |  |  | 			     (struct sockaddr *) &addrbuf, &addrlen); | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-04-15 08:35:59 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1995-09-13 18:39:47 +00:00
										 |  |  | 	if (n < 0) { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		s->errorhandler(); | 
					
						
							|  |  |  |                 return -1; | 
					
						
							| 
									
										
										
										
											1995-09-13 18:39:47 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	if (!(*addr = makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, | 
					
						
							|  |  |  | 				   addrlen, s->sock_proto))) | 
					
						
							|  |  |  | 		return -1; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	return n; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* s.recvfrom(nbytes [,flags]) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | sock_recvfrom(PySocketSockObject *s, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	PyObject *buf = NULL; | 
					
						
							|  |  |  | 	PyObject *addr = NULL; | 
					
						
							|  |  |  | 	PyObject *ret = NULL; | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	int recvlen, flags = 0; | 
					
						
							|  |  |  |         ssize_t outlen; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	buf = PyString_FromStringAndSize((char *) 0, recvlen); | 
					
						
							|  |  |  | 	if (buf == NULL) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf), | 
					
						
							|  |  |  | 				    recvlen, flags, &addr); | 
					
						
							|  |  |  | 	if (outlen < 0) { | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		goto finally; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (outlen != recvlen) { | 
					
						
							|  |  |  | 		/* We did not read as many bytes as we anticipated, resize the
 | 
					
						
							|  |  |  | 		   string if possible and be succesful. */ | 
					
						
							|  |  |  | 		if (_PyString_Resize(&buf, outlen) < 0) | 
					
						
							|  |  |  | 			/* Oopsy, not so succesful after all. */ | 
					
						
							|  |  |  | 			goto finally; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-10-12 19:09:37 +00:00
										 |  |  | 	ret = PyTuple_Pack(2, buf, addr); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | finally: | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_XDECREF(buf); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	Py_XDECREF(addr); | 
					
						
							| 
									
										
										
										
											1993-02-05 09:46:15 +00:00
										 |  |  | 	return ret; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(recvfrom_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "recvfrom(buffersize[, flags]) -> (data, address info)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Like recv(buffersize, flags) but also return the sender's address info."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | /* s.recvfrom_into(buffer[, nbytes [,flags]]) method */ | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds) | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	static char *kwlist[] = {"buffer", "nbytes", "flags", 0}; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	int recvlen = 0, flags = 0; | 
					
						
							|  |  |  |         ssize_t readlen; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	char *buf; | 
					
						
							|  |  |  | 	int buflen; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	PyObject *addr = NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#|ii:recvfrom", kwlist, | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 					 &buf, &buflen, &recvlen, &flags)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	assert(buf != 0 && buflen > 0); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (recvlen < 0) { | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"negative buffersize in recv"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	if (recvlen == 0) { | 
					
						
							|  |  |  |             /* If nbytes was not specified, use the buffer's length */ | 
					
						
							|  |  |  |             recvlen = buflen; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr); | 
					
						
							|  |  |  | 	if (readlen < 0) { | 
					
						
							|  |  |  | 		/* Return an error */ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 		Py_XDECREF(addr); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Return the number of bytes read and the address.  Note that we do
 | 
					
						
							|  |  |  | 	   not do anything special here in the case that readlen < recvlen. */ | 
					
						
							| 
									
										
										
										
											2006-06-08 05:12:45 +00:00
										 |  |  |  	return Py_BuildValue("lN", readlen, addr); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | PyDoc_STRVAR(recvfrom_into_doc, | 
					
						
							|  |  |  | "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info."); | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1993-05-25 09:38:27 +00:00
										 |  |  | /* s.send(data [,flags]) method */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_send(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	char *buf; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int len, n = 0, flags = 0, timeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-02-29 13:59:29 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s#|i:send", &buf, &len, &flags)) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 	if (!IS_SELECTABLE(s)) | 
					
						
							|  |  |  | 		return select_error(); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = internal_select(s, 1); | 
					
						
							|  |  |  | 	if (!timeout) | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | 		n = sendsegmented(s->sock_fd, buf, len, flags); | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		n = send(s->sock_fd, buf, len, flags); | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	if (n < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyInt_FromLong((long)n); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(send_doc, | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | "send(data[, flags]) -> count\n\
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Send a data string to the socket.  For the optional flags\n\ | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | argument, see the Unix manual.  Return the number of bytes\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | sent; this may be less than len(data) if the network is busy."); | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* s.sendall(data [,flags]) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_sendall(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char *buf; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int len, n = 0, flags = 0, timeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s#|i:sendall", &buf, &len, &flags)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 	if (!IS_SELECTABLE(s)) | 
					
						
							|  |  |  | 		return select_error(); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	do { | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 		timeout = internal_select(s, 1); | 
					
						
							|  |  |  | 		if (timeout) | 
					
						
							|  |  |  | 			break; | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #ifdef __VMS
 | 
					
						
							|  |  |  | 		n = sendsegmented(s->sock_fd, buf, len, flags); | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 		n = send(s->sock_fd, buf, len, flags); | 
					
						
							| 
									
										
										
										
											2006-07-10 01:18:57 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 		if (n < 0) | 
					
						
							|  |  |  | 			break; | 
					
						
							|  |  |  | 		buf += n; | 
					
						
							|  |  |  | 		len -= n; | 
					
						
							|  |  |  | 	} while (len > 0); | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 	if (n < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(sendall_doc, | 
					
						
							| 
									
										
										
										
											2001-10-26 03:25:00 +00:00
										 |  |  | "sendall(data[, flags])\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Send a data string to the socket.  For the optional flags\n\ | 
					
						
							|  |  |  | argument, see the Unix manual.  This calls send() repeatedly\n\ | 
					
						
							|  |  |  | until all data is sent.  If an error occurs, it's impossible\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | to tell how much data has been sent."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1993-05-25 09:38:27 +00:00
										 |  |  | /* s.sendto(data, [flags,] sockaddr) method */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_sendto(PySocketSockObject *s, PyObject *args) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	PyObject *addro; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	char *buf; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	struct sockaddr *addr; | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	int addrlen, len, n = 0, flags, timeout; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1993-05-25 09:38:27 +00:00
										 |  |  | 	flags = 0; | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 		PyErr_Clear(); | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 		if (!PyArg_ParseTuple(args, "s#iO:sendto", | 
					
						
							|  |  |  | 				      &buf, &len, &flags, &addro)) | 
					
						
							| 
									
										
										
										
											1993-05-25 09:38:27 +00:00
										 |  |  | 			return NULL; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1993-05-25 09:38:27 +00:00
										 |  |  | 	if (!getsockaddrarg(s, addro, &addr, &addrlen)) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-02-07 07:04:46 +00:00
										 |  |  | 	if (!IS_SELECTABLE(s)) | 
					
						
							|  |  |  | 		return select_error(); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	timeout = internal_select(s, 1); | 
					
						
							|  |  |  | 	if (!timeout) | 
					
						
							|  |  |  | 		n = sendto(s->sock_fd, buf, len, flags, addr, addrlen); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	if (timeout) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_timeout, "timed out"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 	if (n < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyInt_FromLong((long)n); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(sendto_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "sendto(data[, flags], address) -> count\n\
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Like send(data, flags) but allows specifying the destination address.\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | For IP sockets, the address is a pair (hostaddr, port)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* s.shutdown(how) method */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_shutdown(PySocketSockObject *s, PyObject *arg) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int how; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											2001-10-11 16:36:35 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	how = PyInt_AsLong(arg); | 
					
						
							|  |  |  | 	if (how == -1 && PyErr_Occurred()) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	res = shutdown(s->sock_fd, how); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 		return s->errorhandler(); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(shutdown_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "shutdown(flag)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2003-11-27 19:40:22 +00:00
										 |  |  | Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\ | 
					
						
							|  |  |  | of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR)."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* List of methods for socket objects */ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | static PyMethodDef sock_methods[] = { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"accept",	  (PyCFunction)sock_accept, METH_NOARGS, | 
					
						
							|  |  |  | 			  accept_doc}, | 
					
						
							|  |  |  | 	{"bind",	  (PyCFunction)sock_bind, METH_O, | 
					
						
							|  |  |  | 			  bind_doc}, | 
					
						
							|  |  |  | 	{"close",	  (PyCFunction)sock_close, METH_NOARGS, | 
					
						
							|  |  |  | 			  close_doc}, | 
					
						
							|  |  |  | 	{"connect",	  (PyCFunction)sock_connect, METH_O, | 
					
						
							|  |  |  | 			  connect_doc}, | 
					
						
							|  |  |  | 	{"connect_ex",	  (PyCFunction)sock_connect_ex, METH_O, | 
					
						
							|  |  |  | 			  connect_ex_doc}, | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"dup",		  (PyCFunction)sock_dup, METH_NOARGS, | 
					
						
							|  |  |  | 			  dup_doc}, | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"fileno",	  (PyCFunction)sock_fileno, METH_NOARGS, | 
					
						
							|  |  |  | 			  fileno_doc}, | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #ifdef HAVE_GETPEERNAME
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"getpeername",	  (PyCFunction)sock_getpeername, | 
					
						
							|  |  |  | 			  METH_NOARGS, getpeername_doc}, | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	{"getsockname",	  (PyCFunction)sock_getsockname, | 
					
						
							|  |  |  | 			  METH_NOARGS, getsockname_doc}, | 
					
						
							|  |  |  | 	{"getsockopt",	  (PyCFunction)sock_getsockopt, METH_VARARGS, | 
					
						
							|  |  |  | 			  getsockopt_doc}, | 
					
						
							|  |  |  | 	{"listen",	  (PyCFunction)sock_listen, METH_O, | 
					
						
							|  |  |  | 			  listen_doc}, | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"makefile",	  (PyCFunction)sock_makefile, METH_VARARGS, | 
					
						
							|  |  |  | 			  makefile_doc}, | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	{"recv",	  (PyCFunction)sock_recv, METH_VARARGS, | 
					
						
							|  |  |  | 			  recv_doc}, | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	{"recv_into",	  (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS, | 
					
						
							|  |  |  | 			  recv_into_doc}, | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"recvfrom",	  (PyCFunction)sock_recvfrom, METH_VARARGS, | 
					
						
							|  |  |  | 			  recvfrom_doc}, | 
					
						
							| 
									
										
										
										
											2006-06-04 13:49:49 +00:00
										 |  |  | 	{"recvfrom_into",  (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS, | 
					
						
							|  |  |  | 			  recvfrom_into_doc}, | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"send",	  (PyCFunction)sock_send, METH_VARARGS, | 
					
						
							|  |  |  | 			  send_doc}, | 
					
						
							|  |  |  | 	{"sendall",	  (PyCFunction)sock_sendall, METH_VARARGS, | 
					
						
							|  |  |  | 			  sendall_doc}, | 
					
						
							|  |  |  | 	{"sendto",	  (PyCFunction)sock_sendto, METH_VARARGS, | 
					
						
							|  |  |  | 			  sendto_doc}, | 
					
						
							|  |  |  | 	{"setblocking",	  (PyCFunction)sock_setblocking, METH_O, | 
					
						
							|  |  |  | 			  setblocking_doc}, | 
					
						
							|  |  |  | 	{"settimeout",    (PyCFunction)sock_settimeout, METH_O, | 
					
						
							|  |  |  | 			  settimeout_doc}, | 
					
						
							|  |  |  | 	{"gettimeout",    (PyCFunction)sock_gettimeout, METH_NOARGS, | 
					
						
							|  |  |  | 			  gettimeout_doc}, | 
					
						
							|  |  |  | 	{"setsockopt",	  (PyCFunction)sock_setsockopt, METH_VARARGS, | 
					
						
							|  |  |  | 			  setsockopt_doc}, | 
					
						
							|  |  |  | 	{"shutdown",	  (PyCFunction)sock_shutdown, METH_O, | 
					
						
							|  |  |  | 			  shutdown_doc}, | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #ifdef RISCOS
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 	{"sleeptaskw",	  (PyCFunction)sock_sleeptaskw, METH_O, | 
					
						
							|  |  |  | 	 		  sleeptaskw_doc}, | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | 	{NULL,			NULL}		/* sentinel */ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-03-17 19:17:34 +00:00
										 |  |  | /* SockObject members */ | 
					
						
							|  |  |  | static PyMemberDef sock_memberlist[] = { | 
					
						
							|  |  |  |        {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"}, | 
					
						
							|  |  |  |        {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"}, | 
					
						
							|  |  |  |        {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"}, | 
					
						
							|  |  |  |        {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"}, | 
					
						
							|  |  |  |        {0}, | 
					
						
							|  |  |  | }; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | /* Deallocate a socket object in response to the last Py_DECREF().
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  |    First close the file description. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | static void | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_dealloc(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2000-04-10 12:45:45 +00:00
										 |  |  | 	if (s->sock_fd != -1) | 
					
						
							| 
									
										
										
										
											2000-04-21 20:33:00 +00:00
										 |  |  | 		(void) SOCKETCLOSE(s->sock_fd); | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	s->ob_type->tp_free((PyObject *)s); | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_repr(PySocketSockObject *s) | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char buf[512]; | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | #if SIZEOF_SOCKET_T > SIZEOF_LONG
 | 
					
						
							|  |  |  | 	if (s->sock_fd > LONG_MAX) { | 
					
						
							|  |  |  | 		/* this can occur on Win64, and actually there is a special
 | 
					
						
							|  |  |  | 		   ugly printf formatter for decimal pointer length integer | 
					
						
							|  |  |  | 		   printing, only bother if necessary*/ | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_OverflowError, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 				"no printf formatter to display " | 
					
						
							|  |  |  | 				"the socket descriptor in decimal"); | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	PyOS_snprintf( | 
					
						
							|  |  |  | 		buf, sizeof(buf), | 
					
						
							|  |  |  | 		"<socket object, fd=%ld, family=%d, type=%d, protocol=%d>", | 
					
						
							|  |  |  | 		(long)s->sock_fd, s->sock_family, | 
					
						
							|  |  |  | 		s->sock_type, | 
					
						
							|  |  |  | 		s->sock_proto); | 
					
						
							| 
									
										
										
										
											1996-02-27 15:21:19 +00:00
										 |  |  | 	return PyString_FromString(buf); | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | /* Create a new, uninitialized socket object. */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds) | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	PyObject *new; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	new = type->tp_alloc(type, 0); | 
					
						
							| 
									
										
										
										
											2002-06-06 20:08:25 +00:00
										 |  |  | 	if (new != NULL) { | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 		((PySocketSockObject *)new)->sock_fd = -1; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 		((PySocketSockObject *)new)->sock_timeout = -1.0; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		((PySocketSockObject *)new)->errorhandler = &set_error; | 
					
						
							| 
									
										
										
										
											2002-06-06 20:08:25 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	return new; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* Initialize a new socket object. */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static int | 
					
						
							| 
									
										
										
										
											2002-06-13 11:53:52 +00:00
										 |  |  | sock_initobj(PyObject *self, PyObject *args, PyObject *kwds) | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	PySocketSockObject *s = (PySocketSockObject *)self; | 
					
						
							|  |  |  | 	SOCKET_T fd; | 
					
						
							|  |  |  | 	int family = AF_INET, type = SOCK_STREAM, proto = 0; | 
					
						
							| 
									
										
										
										
											2006-02-27 17:20:04 +00:00
										 |  |  | 	static char *keywords[] = {"family", "type", "proto", 0}; | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (!PyArg_ParseTupleAndKeywords(args, kwds, | 
					
						
							|  |  |  | 					 "|iii:socket", keywords, | 
					
						
							|  |  |  | 					 &family, &type, &proto)) | 
					
						
							|  |  |  | 		return -1; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	fd = socket(family, type, proto); | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | #ifdef MS_WINDOWS
 | 
					
						
							|  |  |  | 	if (fd == INVALID_SOCKET) | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	if (fd < 0) | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	{ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_error(); | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 		return -1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	init_sockobject(s, fd, family, type, proto); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	return 0; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | /* Type object for socket objects. */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | static PyTypeObject sock_type = { | 
					
						
							| 
									
										
										
										
											1996-05-23 22:54:50 +00:00
										 |  |  | 	PyObject_HEAD_INIT(0)	/* Must fill in type value later */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* ob_size */ | 
					
						
							| 
									
										
										
										
											2001-10-28 12:31:33 +00:00
										 |  |  | 	"_socket.socket",			/* tp_name */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	sizeof(PySocketSockObject),		/* tp_basicsize */ | 
					
						
							|  |  |  | 	0,					/* tp_itemsize */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	(destructor)sock_dealloc,		/* tp_dealloc */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* tp_print */ | 
					
						
							|  |  |  | 	0,					/* tp_getattr */ | 
					
						
							|  |  |  | 	0,					/* tp_setattr */ | 
					
						
							|  |  |  | 	0,					/* tp_compare */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	(reprfunc)sock_repr,			/* tp_repr */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* tp_as_number */ | 
					
						
							|  |  |  | 	0,					/* tp_as_sequence */ | 
					
						
							|  |  |  | 	0,					/* tp_as_mapping */ | 
					
						
							|  |  |  | 	0,					/* tp_hash */ | 
					
						
							|  |  |  | 	0,					/* tp_call */ | 
					
						
							|  |  |  | 	0,					/* tp_str */ | 
					
						
							| 
									
										
										
										
											2003-01-06 12:41:26 +00:00
										 |  |  | 	PyObject_GenericGetAttr,		/* tp_getattro */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* tp_setattro */ | 
					
						
							|  |  |  | 	0,					/* tp_as_buffer */ | 
					
						
							|  |  |  | 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	sock_doc,				/* tp_doc */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* tp_traverse */ | 
					
						
							|  |  |  | 	0,					/* tp_clear */ | 
					
						
							|  |  |  | 	0,					/* tp_richcompare */ | 
					
						
							|  |  |  | 	0,					/* tp_weaklistoffset */ | 
					
						
							|  |  |  | 	0,					/* tp_iter */ | 
					
						
							|  |  |  | 	0,					/* tp_iternext */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	sock_methods,				/* tp_methods */ | 
					
						
							| 
									
										
										
										
											2006-03-17 19:17:34 +00:00
										 |  |  | 	sock_memberlist,			/* tp_members */ | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 	0,					/* tp_getset */ | 
					
						
							|  |  |  | 	0,					/* tp_base */ | 
					
						
							|  |  |  | 	0,					/* tp_dict */ | 
					
						
							|  |  |  | 	0,					/* tp_descr_get */ | 
					
						
							|  |  |  | 	0,					/* tp_descr_set */ | 
					
						
							|  |  |  | 	0,					/* tp_dictoffset */ | 
					
						
							| 
									
										
										
										
											2002-06-13 11:53:52 +00:00
										 |  |  | 	sock_initobj,				/* tp_init */ | 
					
						
							| 
									
										
										
										
											2003-01-06 12:41:26 +00:00
										 |  |  | 	PyType_GenericAlloc,			/* tp_alloc */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	sock_new,				/* tp_new */ | 
					
						
							| 
									
										
										
										
											2003-01-06 12:41:26 +00:00
										 |  |  | 	PyObject_Del,				/* tp_free */ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-07-27 21:42:02 +00:00
										 |  |  | /* Python interface to gethostname(). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2006-05-29 21:04:52 +00:00
										 |  |  | socket_gethostname(PyObject *self, PyObject *unused) | 
					
						
							| 
									
										
										
										
											1991-07-27 21:42:02 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char buf[1024]; | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	int res; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	res = gethostname(buf, (int) sizeof buf - 1); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	if (res < 0) | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		return set_error(); | 
					
						
							| 
									
										
										
										
											1991-07-27 21:42:02 +00:00
										 |  |  | 	buf[sizeof buf - 1] = '\0'; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyString_FromString(buf); | 
					
						
							| 
									
										
										
										
											1991-07-27 21:42:02 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(gethostname_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "gethostname() -> string\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Return the current host name."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* Python interface to gethostbyname(name). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_gethostbyname(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | 	char *name; | 
					
						
							| 
									
										
										
										
											2005-09-14 18:09:42 +00:00
										 |  |  | 	sock_addr_t addrbuf; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s:gethostbyname", &name)) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-07-28 16:10:31 +00:00
										 |  |  | 	if (setipaddr(name, (struct sockaddr *)&addrbuf,  sizeof(addrbuf), AF_INET) < 0) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	return makeipaddr((struct sockaddr *)&addrbuf, | 
					
						
							|  |  |  | 		sizeof(struct sockaddr_in)); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(gethostbyname_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "gethostbyname(host) -> address\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Return the IP address (a string of the form '255.255.255.255') for a host."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | /* Convenience function common to gethostbyname_ex and gethostbyaddr */ | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1996-02-27 15:21:19 +00:00
										 |  |  | 	char **pch; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	PyObject *rtn_tuple = (PyObject *)NULL; | 
					
						
							|  |  |  | 	PyObject *name_list = (PyObject *)NULL; | 
					
						
							|  |  |  | 	PyObject *addr_list = (PyObject *)NULL; | 
					
						
							|  |  |  | 	PyObject *tmp; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	if (h == NULL) { | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 		/* Let's get real error message to return */ | 
					
						
							| 
									
										
										
										
											2001-10-24 20:42:55 +00:00
										 |  |  | #ifndef RISCOS
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_herror(h_errno); | 
					
						
							| 
									
										
										
										
											2001-10-24 20:42:55 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "host not found"); | 
					
						
							| 
									
										
										
										
											2001-10-24 20:42:55 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (h->h_addrtype != af) { | 
					
						
							|  |  |  | #ifdef HAVE_STRERROR
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 		/* Let's get real error message to return */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 				(char *)strerror(EAFNOSUPPORT)); | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 		PyErr_SetString( | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			socket_error, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 			"Address family not supported by protocol family"); | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	switch (af) { | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 		if (alen < sizeof(struct sockaddr_in)) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		break; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 		if (alen < sizeof(struct sockaddr_in6)) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	if ((name_list = PyList_New(0)) == NULL) | 
					
						
							|  |  |  | 		goto err; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	if ((addr_list = PyList_New(0)) == NULL) | 
					
						
							|  |  |  | 		goto err; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	for (pch = h->h_aliases; *pch != NULL; pch++) { | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		int status; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		tmp = PyString_FromString(*pch); | 
					
						
							|  |  |  | 		if (tmp == NULL) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		status = PyList_Append(name_list, tmp); | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		Py_DECREF(tmp); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		if (status) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	for (pch = h->h_addr_list; *pch != NULL; pch++) { | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		int status; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		switch (af) { | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		case AF_INET: | 
					
						
							|  |  |  | 		    { | 
					
						
							|  |  |  | 			struct sockaddr_in sin; | 
					
						
							|  |  |  | 			memset(&sin, 0, sizeof(sin)); | 
					
						
							|  |  |  | 			sin.sin_family = af; | 
					
						
							|  |  |  | #ifdef HAVE_SOCKADDR_SA_LEN
 | 
					
						
							|  |  |  | 			sin.sin_len = sizeof(sin); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 			memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr)); | 
					
						
							|  |  |  | 			tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin)); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			if (pch == h->h_addr_list && alen >= sizeof(sin)) | 
					
						
							|  |  |  | 				memcpy((char *) addr, &sin, sizeof(sin)); | 
					
						
							|  |  |  | 			break; | 
					
						
							|  |  |  | 		    } | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		case AF_INET6: | 
					
						
							|  |  |  | 		    { | 
					
						
							|  |  |  | 			struct sockaddr_in6 sin6; | 
					
						
							|  |  |  | 			memset(&sin6, 0, sizeof(sin6)); | 
					
						
							|  |  |  | 			sin6.sin6_family = af; | 
					
						
							|  |  |  | #ifdef HAVE_SOCKADDR_SA_LEN
 | 
					
						
							|  |  |  | 			sin6.sin6_len = sizeof(sin6); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 			memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr)); | 
					
						
							|  |  |  | 			tmp = makeipaddr((struct sockaddr *)&sin6, | 
					
						
							|  |  |  | 				sizeof(sin6)); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			if (pch == h->h_addr_list && alen >= sizeof(sin6)) | 
					
						
							|  |  |  | 				memcpy((char *) addr, &sin6, sizeof(sin6)); | 
					
						
							|  |  |  | 			break; | 
					
						
							|  |  |  | 		    } | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		default:	/* can't happen */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 					"unsupported address family"); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		if (tmp == NULL) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		status = PyList_Append(addr_list, tmp); | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 		Py_DECREF(tmp); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-01-03 17:18:10 +00:00
										 |  |  | 		if (status) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  | 	rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list); | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-01-02 19:30:30 +00:00
										 |  |  |  err: | 
					
						
							|  |  |  | 	Py_XDECREF(name_list); | 
					
						
							|  |  |  | 	Py_XDECREF(addr_list); | 
					
						
							|  |  |  | 	return rtn_tuple; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Python interface to gethostbyname_ex(name). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_gethostbyname_ex(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char *name; | 
					
						
							|  |  |  | 	struct hostent *h; | 
					
						
							| 
									
										
										
										
											2003-05-03 09:14:54 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							|  |  |  |         struct sockaddr_storage addr; | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  |         struct sockaddr_in addr; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-23 01:30:10 +00:00
										 |  |  | 	struct sockaddr *sa; | 
					
						
							| 
									
										
										
										
											1999-03-22 20:14:53 +00:00
										 |  |  | 	PyObject *ret; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #ifdef HAVE_GETHOSTBYNAME_R
 | 
					
						
							|  |  |  | 	struct hostent hp_allocated; | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
 | 
					
						
							|  |  |  | 	struct hostent_data data; | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 	char buf[16384]; | 
					
						
							|  |  |  | 	int buf_len = (sizeof buf) - 1; | 
					
						
							|  |  |  | 	int errnop; | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
 | 
					
						
							| 
									
										
										
										
											1999-03-15 21:40:14 +00:00
										 |  |  | 	int result; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #endif /* HAVE_GETHOSTBYNAME_R */
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name)) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | 	if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | #ifdef HAVE_GETHOSTBYNAME_R
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #if   defined(HAVE_GETHOSTBYNAME_R_6_ARG)
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	result = gethostbyname_r(name, &hp_allocated, buf, buf_len, | 
					
						
							|  |  |  | 				 &h, &errnop); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 	h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:24:33 +00:00
										 |  |  | 	memset((void *) &data, '\0', sizeof(data)); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | 	result = gethostbyname_r(name, &hp_allocated, &data); | 
					
						
							|  |  |  | 	h = (result != 0) ? NULL : &hp_allocated; | 
					
						
							| 
									
										
										
										
											1999-03-15 21:40:14 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #else /* not HAVE_GETHOSTBYNAME_R */
 | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #ifdef USE_GETHOSTBYNAME_LOCK
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	PyThread_acquire_lock(netdb_lock, 1); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	h = gethostbyname(name); | 
					
						
							|  |  |  | #endif /* HAVE_GETHOSTBYNAME_R */
 | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	/* Some C libraries would require addr.__ss_family instead of
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	   addr.ss_family. | 
					
						
							|  |  |  | 	   Therefore, we cast the sockaddr_storage into sockaddr to | 
					
						
							|  |  |  | 	   access sa_family. */ | 
					
						
							| 
									
										
										
										
											2001-07-23 01:30:10 +00:00
										 |  |  | 	sa = (struct sockaddr*)&addr; | 
					
						
							| 
									
										
										
										
											2002-06-06 21:08:16 +00:00
										 |  |  | 	ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 			     sa->sa_family); | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #ifdef USE_GETHOSTBYNAME_LOCK
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	PyThread_release_lock(netdb_lock); | 
					
						
							| 
									
										
										
										
											1999-03-22 20:14:53 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	return ret; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(ghbn_ex_doc, | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | "gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return the true host name, a list of aliases, and a list of IP addresses,\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | for a host.  The host argument is a string giving a host name or IP number."); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /* Python interface to gethostbyaddr(IP). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_gethostbyaddr(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	struct sockaddr_storage addr; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 	struct sockaddr_in addr; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	struct sockaddr *sa = (struct sockaddr *)&addr; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 	char *ip_num; | 
					
						
							|  |  |  | 	struct hostent *h; | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | 	PyObject *ret; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #ifdef HAVE_GETHOSTBYNAME_R
 | 
					
						
							|  |  |  | 	struct hostent hp_allocated; | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
 | 
					
						
							|  |  |  | 	struct hostent_data data; | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 	char buf[16384]; | 
					
						
							|  |  |  | 	int buf_len = (sizeof buf) - 1; | 
					
						
							|  |  |  | 	int errnop; | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
 | 
					
						
							| 
									
										
										
										
											1999-03-15 21:40:14 +00:00
										 |  |  | 	int result; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #endif /* HAVE_GETHOSTBYNAME_R */
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	char *ap; | 
					
						
							|  |  |  | 	int al; | 
					
						
							|  |  |  | 	int af; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num)) | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | 	af = AF_UNSPEC; | 
					
						
							| 
									
										
										
										
											2002-07-28 16:10:31 +00:00
										 |  |  | 	if (setipaddr(ip_num, sa, sizeof(addr), af) < 0) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	af = sa->sa_family; | 
					
						
							|  |  |  | 	ap = NULL; | 
					
						
							|  |  |  | 	al = 0; | 
					
						
							|  |  |  | 	switch (af) { | 
					
						
							|  |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 		ap = (char *)&((struct sockaddr_in *)sa)->sin_addr; | 
					
						
							|  |  |  | 		al = sizeof(((struct sockaddr_in *)sa)->sin_addr); | 
					
						
							|  |  |  | 		break; | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 		ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr; | 
					
						
							|  |  |  | 		al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr); | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	default: | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "unsupported address family"); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | #ifdef HAVE_GETHOSTBYNAME_R
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #if   defined(HAVE_GETHOSTBYNAME_R_6_ARG)
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	result = gethostbyaddr_r(ap, al, af, | 
					
						
							|  |  |  | 		&hp_allocated, buf, buf_len, | 
					
						
							| 
									
										
										
										
											1999-03-15 21:40:14 +00:00
										 |  |  | 		&h, &errnop); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	h = gethostbyaddr_r(ap, al, af, | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | 			    &hp_allocated, buf, buf_len, &errnop); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
 | 
					
						
							| 
									
										
										
										
											1999-03-24 17:24:33 +00:00
										 |  |  | 	memset((void *) &data, '\0', sizeof(data)); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data); | 
					
						
							| 
									
										
										
										
											1999-03-24 17:20:40 +00:00
										 |  |  | 	h = (result != 0) ? NULL : &hp_allocated; | 
					
						
							| 
									
										
										
										
											1999-03-15 21:40:14 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #else /* not HAVE_GETHOSTBYNAME_R */
 | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #ifdef USE_GETHOSTBYNAME_LOCK
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	PyThread_acquire_lock(netdb_lock, 1); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	h = gethostbyaddr(ap, al, af); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | #endif /* HAVE_GETHOSTBYNAME_R */
 | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af); | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #ifdef USE_GETHOSTBYNAME_LOCK
 | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	PyThread_release_lock(netdb_lock); | 
					
						
							| 
									
										
										
										
											1999-03-22 21:44:51 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	return ret; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:16:43 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(gethostbyaddr_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return the true host name, a list of aliases, and a list of IP addresses,\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | for a host.  The host argument is a string giving a host name or IP number."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Python interface to getservbyname(name).
 | 
					
						
							|  |  |  |    This only returns the port number, since the other info is already | 
					
						
							|  |  |  |    known or not useful (like the list of aliases). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_getservbyname(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | 	char *name, *proto=NULL; | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	struct servent *sp; | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto)) | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1992-08-05 19:58:53 +00:00
										 |  |  | 	sp = getservbyname(name, proto); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	if (sp == NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "service/proto not found"); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return PyInt_FromLong((long) ntohs(sp->s_port)); | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getservbyname_doc, | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | "getservbyname(servicename[, protocolname]) -> integer\n\
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Return a port number from a service name and protocol name.\n\ | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | The optional protocol name, if given, should be 'tcp' or 'udp',\n\ | 
					
						
							|  |  |  | otherwise any protocol will match."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | /* Python interface to getservbyport(port).
 | 
					
						
							|  |  |  |    This only returns the service name, since the other info is already | 
					
						
							|  |  |  |    known or not useful (like the list of aliases). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_getservbyport(PyObject *self, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2004-09-28 02:19:40 +00:00
										 |  |  | 	unsigned short port; | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | 	char *proto=NULL; | 
					
						
							|  |  |  | 	struct servent *sp; | 
					
						
							| 
									
										
										
										
											2004-09-28 02:19:40 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "H|s:getservbyport", &port, &proto)) | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	sp = getservbyport(htons(port), proto); | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	if (sp == NULL) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_error, "port/proto not found"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	return PyString_FromString(sp->s_name); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | PyDoc_STRVAR(getservbyport_doc, | 
					
						
							|  |  |  | "getservbyport(port[, protocolname]) -> string\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Return the service name from a port number and protocol name.\n\ | 
					
						
							|  |  |  | The optional protocol name, if given, should be 'tcp' or 'udp',\n\ | 
					
						
							|  |  |  | otherwise any protocol will match."); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | /* Python interface to getprotobyname(name).
 | 
					
						
							|  |  |  |    This only returns the protocol number, since the other info is | 
					
						
							|  |  |  |    already known or not useful (like the list of aliases). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_getprotobyname(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char *name; | 
					
						
							|  |  |  | 	struct protoent *sp; | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #ifdef __BEOS__
 | 
					
						
							|  |  |  | /* Not available in BeOS yet. - [cjh] */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	PyErr_SetString(socket_error, "getprotobyname not supported"); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | 	return NULL; | 
					
						
							|  |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s:getprotobyname", &name)) | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	sp = getprotobyname(name); | 
					
						
							|  |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	if (sp == NULL) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "protocol not found"); | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	return PyInt_FromLong((long) sp->p_proto); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getprotobyname_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "getprotobyname(name) -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Return the protocol number for the named protocol.  (Rarely used.)"); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-12-19 16:35:04 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-08-09 04:51:41 +00:00
										 |  |  | #ifdef HAVE_SOCKETPAIR
 | 
					
						
							|  |  |  | /* Create a pair of sockets using the socketpair() function.
 | 
					
						
							| 
									
										
										
										
											2004-08-23 05:16:23 +00:00
										 |  |  |    Arguments as for socket() except the default family is AF_UNIX if | 
					
						
							| 
									
										
										
										
											2004-08-26 00:51:16 +00:00
										 |  |  |    defined on the platform; otherwise, the default is AF_INET. */ | 
					
						
							| 
									
										
										
										
											2004-08-09 04:51:41 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_socketpair(PyObject *self, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	PySocketSockObject *s0 = NULL, *s1 = NULL; | 
					
						
							|  |  |  | 	SOCKET_T sv[2]; | 
					
						
							|  |  |  | 	int family, type = SOCK_STREAM, proto = 0; | 
					
						
							|  |  |  | 	PyObject *res = NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #if defined(AF_UNIX)
 | 
					
						
							|  |  |  | 	family = AF_UNIX; | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	family = AF_INET; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	if (!PyArg_ParseTuple(args, "|iii:socketpair", | 
					
						
							|  |  |  | 			      &family, &type, &proto)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	/* Create a pair of socket fds */ | 
					
						
							|  |  |  | 	if (socketpair(family, type, proto, sv) < 0) | 
					
						
							|  |  |  | 		return set_error(); | 
					
						
							|  |  |  | 	s0 = new_sockobject(sv[0], family, type, proto); | 
					
						
							|  |  |  | 	if (s0 == NULL) | 
					
						
							|  |  |  | 		goto finally; | 
					
						
							|  |  |  | 	s1 = new_sockobject(sv[1], family, type, proto); | 
					
						
							|  |  |  | 	if (s1 == NULL) | 
					
						
							|  |  |  | 		goto finally; | 
					
						
							|  |  |  | 	res = PyTuple_Pack(2, s0, s1); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | finally: | 
					
						
							|  |  |  | 	if (res == NULL) { | 
					
						
							|  |  |  | 		if (s0 == NULL) | 
					
						
							|  |  |  | 			SOCKETCLOSE(sv[0]); | 
					
						
							|  |  |  | 		if (s1 == NULL) | 
					
						
							|  |  |  | 			SOCKETCLOSE(sv[1]); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	Py_XDECREF(s0); | 
					
						
							|  |  |  | 	Py_XDECREF(s1); | 
					
						
							|  |  |  | 	return res; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | PyDoc_STRVAR(socketpair_doc, | 
					
						
							|  |  |  | "socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Create a pair of socket objects from the sockets returned by the platform\n\ | 
					
						
							|  |  |  | socketpair() function.\n\ | 
					
						
							| 
									
										
										
										
											2004-08-23 05:16:23 +00:00
										 |  |  | The arguments are the same as for socket() except the default family is\n\ | 
					
						
							| 
									
										
										
										
											2004-08-26 00:51:16 +00:00
										 |  |  | AF_UNIX if defined on the platform; otherwise, the default is AF_INET."); | 
					
						
							| 
									
										
										
										
											2004-08-09 04:51:41 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #endif /* HAVE_SOCKETPAIR */
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							| 
									
										
										
										
											1992-12-08 13:38:24 +00:00
										 |  |  | /* Create a socket object from a numeric file description.
 | 
					
						
							|  |  |  |    Useful e.g. if stdin is a socket. | 
					
						
							|  |  |  |    Additional arguments as for socket(). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_fromfd(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1992-12-08 13:38:24 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	PySocketSockObject *s; | 
					
						
							| 
									
										
										
										
											2000-06-30 02:46:07 +00:00
										 |  |  | 	SOCKET_T fd; | 
					
						
							|  |  |  | 	int family, type, proto = 0; | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "iii|i:fromfd", | 
					
						
							|  |  |  | 			      &fd, &family, &type, &proto)) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
											
												* mymalloc.h: always allocate one extra byte, since some malloc's
  return NULL for malloc(0) or realloc(p, 0).  (This should be done
  differently than wasting one byte, but alas...)
* Moved "add'l libraries" option in Makefile to an earlier place.
* Remove argument compatibility hacks (b) and (c).
* Add grey2mono, dither2mono and mono2grey to imageop.
* Dup the fd in socket.fromfd().
* Added new modules mpz, md5 (by JH, requiring GNU MP 1.2).  Affects
  Makefile and config.c.
* socketmodule.c: added socket.fromfd(fd, family, type, [proto]),
  converted socket() to use of getargs().
											
										 
											1992-12-14 16:59:51 +00:00
										 |  |  | 	/* Dup the fd so it and the socket can be closed independently */ | 
					
						
							|  |  |  | 	fd = dup(fd); | 
					
						
							|  |  |  | 	if (fd < 0) | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		return set_error(); | 
					
						
							|  |  |  | 	s = new_sockobject(fd, family, type, proto); | 
					
						
							| 
									
										
										
										
											1994-10-10 17:59:00 +00:00
										 |  |  | 	return (PyObject *) s; | 
					
						
							| 
									
										
										
										
											1992-12-08 13:38:24 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(fromfd_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "fromfd(fd, family, type[, proto]) -> socket object\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2006-04-01 07:33:08 +00:00
										 |  |  | Create a socket object from a duplicate of the given\n\ | 
					
						
							|  |  |  | file descriptor.\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | The remaining arguments are the same as for socket()."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #endif /* NO_DUP */
 | 
					
						
							| 
									
										
										
										
											1992-12-08 13:38:24 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_ntohs(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	int x1, x2; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) { | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	x2 = (int)ntohs((short)x1); | 
					
						
							|  |  |  | 	return PyInt_FromLong(x2); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(ntohs_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "ntohs(integer) -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Convert a 16-bit integer from network to host byte order."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | socket_ntohl(PyObject *self, PyObject *arg) | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	unsigned long x; | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	if (PyInt_Check(arg)) { | 
					
						
							|  |  |  | 		x = PyInt_AS_LONG(arg); | 
					
						
							| 
									
										
										
										
											2002-07-25 16:37:51 +00:00
										 |  |  | 		if (x == (unsigned long) -1 && PyErr_Occurred()) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	else if (PyLong_Check(arg)) { | 
					
						
							|  |  |  | 		x = PyLong_AsUnsignedLong(arg); | 
					
						
							| 
									
										
										
										
											2002-07-25 16:37:51 +00:00
										 |  |  | 		if (x == (unsigned long) -1 && PyErr_Occurred()) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | #if SIZEOF_LONG > 4
 | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			unsigned long y; | 
					
						
							|  |  |  | 			/* only want the trailing 32 bits */ | 
					
						
							|  |  |  | 			y = x & 0xFFFFFFFFUL; | 
					
						
							|  |  |  | 			if (y ^ x) | 
					
						
							|  |  |  | 				return PyErr_Format(PyExc_OverflowError, | 
					
						
							|  |  |  | 					    "long int larger than 32 bits"); | 
					
						
							|  |  |  | 			x = y; | 
					
						
							| 
									
										
										
										
											2002-08-06 22:25:02 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else | 
					
						
							| 
									
										
										
										
											2002-08-06 22:25:02 +00:00
										 |  |  | 		return PyErr_Format(PyExc_TypeError, | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 				    "expected int/long, %s found", | 
					
						
							|  |  |  | 				    arg->ob_type->tp_name); | 
					
						
							|  |  |  | 	if (x == (unsigned long) -1 && PyErr_Occurred()) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	return PyInt_FromLong(ntohl(x)); | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(ntohl_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "ntohl(integer) -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Convert a 32-bit integer from network to host byte order."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_htons(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2003-12-17 09:40:23 +00:00
										 |  |  | 	int x1, x2; | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "i:htons", &x1)) { | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	x2 = (int)htons((short)x1); | 
					
						
							|  |  |  | 	return PyInt_FromLong(x2); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(htons_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "htons(integer) -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Convert a 16-bit integer from host to network byte order."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | socket_htonl(PyObject *self, PyObject *arg) | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	unsigned long x; | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	if (PyInt_Check(arg)) { | 
					
						
							|  |  |  | 		x = PyInt_AS_LONG(arg); | 
					
						
							| 
									
										
										
										
											2002-07-25 16:37:51 +00:00
										 |  |  | 		if (x == (unsigned long) -1 && PyErr_Occurred()) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	else if (PyLong_Check(arg)) { | 
					
						
							|  |  |  | 		x = PyLong_AsUnsignedLong(arg); | 
					
						
							| 
									
										
										
										
											2002-07-25 16:37:51 +00:00
										 |  |  | 		if (x == (unsigned long) -1 && PyErr_Occurred()) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | #if SIZEOF_LONG > 4
 | 
					
						
							|  |  |  | 		{ | 
					
						
							|  |  |  | 			unsigned long y; | 
					
						
							|  |  |  | 			/* only want the trailing 32 bits */ | 
					
						
							|  |  |  | 			y = x & 0xFFFFFFFFUL; | 
					
						
							|  |  |  | 			if (y ^ x) | 
					
						
							|  |  |  | 				return PyErr_Format(PyExc_OverflowError, | 
					
						
							|  |  |  | 					    "long int larger than 32 bits"); | 
					
						
							|  |  |  | 			x = y; | 
					
						
							| 
									
										
										
										
											2002-08-06 22:25:02 +00:00
										 |  |  | 		} | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else | 
					
						
							| 
									
										
										
										
											2002-08-06 22:25:02 +00:00
										 |  |  | 		return PyErr_Format(PyExc_TypeError, | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 				    "expected int/long, %s found", | 
					
						
							|  |  |  | 				    arg->ob_type->tp_name); | 
					
						
							|  |  |  | 	return PyInt_FromLong(htonl(x)); | 
					
						
							| 
									
										
										
										
											1996-06-12 04:04:55 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(htonl_doc, | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | "htonl(integer) -> integer\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Convert a 32-bit integer from host to network byte order."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | /* socket.inet_aton() and socket.inet_ntoa() functions. */ | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(inet_aton_doc, | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | "inet_aton(string) -> packed 32-bit IP representation\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | binary format used in low-level network functions."); | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject* | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_inet_aton(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											1999-09-09 15:42:59 +00:00
										 |  |  | #ifndef INADDR_NONE
 | 
					
						
							|  |  |  | #define INADDR_NONE (-1)
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-02-13 02:15:42 +00:00
										 |  |  | #ifdef HAVE_INET_ATON
 | 
					
						
							| 
									
										
										
										
											2003-02-12 23:08:22 +00:00
										 |  |  | 	struct in_addr buf; | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
 | 
					
						
							| 
									
										
										
										
											2003-02-13 03:13:40 +00:00
										 |  |  | 	/* Have to use inet_addr() instead */ | 
					
						
							|  |  |  | 	unsigned long packed_addr; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	char *ip_addr; | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-02-13 03:13:40 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr)) | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2003-02-12 23:08:22 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-02-13 03:13:40 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifdef HAVE_INET_ATON
 | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifdef USE_INET_ATON_WEAKLINK
 | 
					
						
							|  |  |  |     if (inet_aton != NULL) { | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-02-12 23:08:22 +00:00
										 |  |  | 	if (inet_aton(ip_addr, &buf)) | 
					
						
							|  |  |  | 		return PyString_FromStringAndSize((char *)(&buf), | 
					
						
							|  |  |  | 						  sizeof(buf)); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 			"illegal IP address string passed to inet_aton"); | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | #ifdef USE_INET_ATON_WEAKLINK
 | 
					
						
							|  |  |  |    } else { | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2005-08-26 08:34:00 +00:00
										 |  |  | 	/* special-case this address as inet_addr might return INADDR_NONE
 | 
					
						
							|  |  |  | 	 * for this */ | 
					
						
							|  |  |  | 	if (strcmp(ip_addr, "255.255.255.255") == 0) { | 
					
						
							|  |  |  | 		packed_addr = 0xFFFFFFFF; | 
					
						
							|  |  |  | 	} else { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2005-08-26 08:34:00 +00:00
										 |  |  | 		packed_addr = inet_addr(ip_addr); | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2005-08-26 08:34:00 +00:00
										 |  |  | 		if (packed_addr == INADDR_NONE) {	/* invalid address */ | 
					
						
							|  |  |  | 			PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 				"illegal IP address string passed to inet_aton"); | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 	return PyString_FromStringAndSize((char *) &packed_addr, | 
					
						
							|  |  |  | 					  sizeof(packed_addr)); | 
					
						
							| 
									
										
										
										
											2006-04-23 11:59:25 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifdef USE_INET_ATON_WEAKLINK
 | 
					
						
							|  |  |  |    } | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-02-12 23:08:22 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(inet_ntoa_doc, | 
					
						
							| 
									
										
										
										
											2000-03-07 14:05:16 +00:00
										 |  |  | "inet_ntoa(packed_ip) -> ip_address_string\n\
 | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Convert an IP address from 32-bit packed binary format to string format"); | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static PyObject* | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_inet_ntoa(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	char *packed_str; | 
					
						
							| 
									
										
										
										
											1999-08-20 19:11:27 +00:00
										 |  |  | 	int addr_len; | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 	struct in_addr packed_addr; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2000-03-24 20:56:56 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) { | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 	if (addr_len != sizeof(packed_addr)) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											1999-08-20 18:21:51 +00:00
										 |  |  | 			"packed IP wrong length for inet_ntoa"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	memcpy(&packed_addr, packed_str, addr_len); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	return PyString_FromString(inet_ntoa(packed_addr)); | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | #ifdef HAVE_INET_PTON
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | PyDoc_STRVAR(inet_pton_doc, | 
					
						
							|  |  |  | "inet_pton(af, ip) -> packed IP address string\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Convert an IP address from string format to a packed string suitable\n\ | 
					
						
							|  |  |  | for use with low-level network functions."); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_inet_pton(PyObject *self, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	int af; | 
					
						
							|  |  |  | 	char* ip; | 
					
						
							|  |  |  | 	int retval; | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))]; | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #else
 | 
					
						
							|  |  |  | 	char packed[sizeof(struct in_addr)]; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) { | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-06-02 12:35:29 +00:00
										 |  |  | #if !defined(ENABLE_IPV6) && defined(AF_INET6)
 | 
					
						
							| 
									
										
										
										
											2003-08-05 06:25:06 +00:00
										 |  |  | 	if(af == AF_INET6) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 				"can't use AF_INET6, IPv6 is disabled"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-08-05 06:25:06 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	retval = inet_pton(af, ip, packed); | 
					
						
							|  |  |  | 	if (retval < 0) { | 
					
						
							|  |  |  | 		PyErr_SetFromErrno(socket_error); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} else if (retval == 0) { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_error, | 
					
						
							|  |  |  | 			"illegal IP address string passed to inet_pton"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} else if (af == AF_INET) { | 
					
						
							|  |  |  | 		return PyString_FromStringAndSize(packed, | 
					
						
							|  |  |  | 			sizeof(struct in_addr)); | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	} else if (af == AF_INET6) { | 
					
						
							|  |  |  | 		return PyString_FromStringAndSize(packed, | 
					
						
							|  |  |  | 			sizeof(struct in6_addr)); | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	} else { | 
					
						
							|  |  |  | 		PyErr_SetString(socket_error, "unknown address family"); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | PyDoc_STRVAR(inet_ntop_doc, | 
					
						
							|  |  |  | "inet_ntop(af, packed_ip) -> string formatted IP address\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | Convert a packed IP address of the given family to string format."); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_inet_ntop(PyObject *self, PyObject *args) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	int af; | 
					
						
							|  |  |  | 	char* packed; | 
					
						
							|  |  |  | 	int len; | 
					
						
							|  |  |  | 	const char* retval; | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1]; | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #else
 | 
					
						
							|  |  |  | 	char ip[INET_ADDRSTRLEN + 1]; | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	/* Guarantee NUL-termination for PyString_FromString() below */ | 
					
						
							| 
									
										
										
										
											2004-11-07 14:24:25 +00:00
										 |  |  | 	memset((void *) &ip[0], '\0', sizeof(ip)); | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) { | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (af == AF_INET) { | 
					
						
							|  |  |  | 		if (len != sizeof(struct in_addr)) { | 
					
						
							|  |  |  | 			PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"invalid length of packed IP address string"); | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	} else if (af == AF_INET6) { | 
					
						
							|  |  |  | 		if (len != sizeof(struct in6_addr)) { | 
					
						
							|  |  |  | 			PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 				"invalid length of packed IP address string"); | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	} else { | 
					
						
							|  |  |  | 		PyErr_Format(PyExc_ValueError, | 
					
						
							|  |  |  | 			"unknown address family %d", af); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	retval = inet_ntop(af, packed, ip, sizeof(ip)); | 
					
						
							|  |  |  | 	if (!retval) { | 
					
						
							|  |  |  | 		PyErr_SetFromErrno(socket_error); | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} else { | 
					
						
							|  |  |  | 		return PyString_FromString(retval); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* NOTREACHED */ | 
					
						
							|  |  |  | 	PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop"); | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #endif /* HAVE_INET_PTON */
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | /* Python interface to getaddrinfo(host, port). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_getaddrinfo(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2001-11-07 08:31:03 +00:00
										 |  |  | 	struct addrinfo hints, *res; | 
					
						
							|  |  |  | 	struct addrinfo *res0 = NULL; | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 	PyObject *hobj = NULL; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	PyObject *pobj = (PyObject *)NULL; | 
					
						
							| 
									
										
										
										
											2001-08-12 09:28:40 +00:00
										 |  |  | 	char pbuf[30]; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	char *hptr, *pptr; | 
					
						
							|  |  |  | 	int family, socktype, protocol, flags; | 
					
						
							|  |  |  | 	int error; | 
					
						
							|  |  |  | 	PyObject *all = (PyObject *)NULL; | 
					
						
							|  |  |  | 	PyObject *single = (PyObject *)NULL; | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 	PyObject *idna = NULL; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	family = socktype = protocol = flags = 0; | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | 	family = AF_UNSPEC; | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo", | 
					
						
							|  |  |  | 			      &hobj, &pobj, &family, &socktype, | 
					
						
							|  |  |  | 			      &protocol, &flags)) { | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	if (hobj == Py_None) { | 
					
						
							|  |  |  | 		hptr = NULL; | 
					
						
							|  |  |  | 	} else if (PyUnicode_Check(hobj)) { | 
					
						
							|  |  |  | 		idna = PyObject_CallMethod(hobj, "encode", "s", "idna"); | 
					
						
							|  |  |  | 		if (!idna) | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		hptr = PyString_AsString(idna); | 
					
						
							|  |  |  | 	} else if (PyString_Check(hobj)) { | 
					
						
							|  |  |  | 		hptr = PyString_AsString(hobj); | 
					
						
							|  |  |  | 	} else { | 
					
						
							| 
									
										
										
										
											2006-05-26 12:03:27 +00:00
										 |  |  | 		PyErr_SetString(PyExc_TypeError, | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 				"getaddrinfo() argument 1 must be string or None"); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return NULL; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	if (PyInt_Check(pobj)) { | 
					
						
							| 
									
										
										
										
											2001-07-31 18:05:33 +00:00
										 |  |  | 		PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj)); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		pptr = pbuf; | 
					
						
							|  |  |  | 	} else if (PyString_Check(pobj)) { | 
					
						
							|  |  |  | 		pptr = PyString_AsString(pobj); | 
					
						
							|  |  |  | 	} else if (pobj == Py_None) { | 
					
						
							|  |  |  | 		pptr = (char *)NULL; | 
					
						
							|  |  |  | 	} else { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, "Int or String expected"); | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  |                 goto err; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 	memset(&hints, 0, sizeof(hints)); | 
					
						
							|  |  |  | 	hints.ai_family = family; | 
					
						
							|  |  |  | 	hints.ai_socktype = socktype; | 
					
						
							|  |  |  | 	hints.ai_protocol = protocol; | 
					
						
							|  |  |  | 	hints.ai_flags = flags; | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	ACQUIRE_GETADDRINFO_LOCK | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	error = getaddrinfo(hptr, pptr, &hints, &res0); | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2003-08-07 11:55:15 +00:00
										 |  |  | 		goto err; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if ((all = PyList_New(0)) == NULL) | 
					
						
							|  |  |  | 		goto err; | 
					
						
							|  |  |  | 	for (res = res0; res; res = res->ai_next) { | 
					
						
							| 
									
										
										
										
											2001-10-12 18:59:27 +00:00
										 |  |  | 		PyObject *addr = | 
					
						
							| 
									
										
										
										
											2004-06-03 09:24:42 +00:00
										 |  |  | 			makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol); | 
					
						
							| 
									
										
										
										
											2001-10-12 18:59:27 +00:00
										 |  |  | 		if (addr == NULL) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		single = Py_BuildValue("iiisO", res->ai_family, | 
					
						
							|  |  |  | 			res->ai_socktype, res->ai_protocol, | 
					
						
							|  |  |  | 			res->ai_canonname ? res->ai_canonname : "", | 
					
						
							| 
									
										
										
										
											2001-10-12 18:59:27 +00:00
										 |  |  | 			addr); | 
					
						
							|  |  |  | 		Py_DECREF(addr); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		if (single == NULL) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 		if (PyList_Append(all, single)) | 
					
						
							|  |  |  | 			goto err; | 
					
						
							|  |  |  | 		Py_XDECREF(single); | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 	Py_XDECREF(idna); | 
					
						
							| 
									
										
										
										
											2002-08-09 03:37:42 +00:00
										 |  |  | 	if (res0) | 
					
						
							|  |  |  | 		freeaddrinfo(res0); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	return all; | 
					
						
							|  |  |  |  err: | 
					
						
							|  |  |  | 	Py_XDECREF(single); | 
					
						
							|  |  |  | 	Py_XDECREF(all); | 
					
						
							| 
									
										
										
										
											2003-04-18 10:39:54 +00:00
										 |  |  | 	Py_XDECREF(idna); | 
					
						
							| 
									
										
										
										
											2001-11-07 08:31:03 +00:00
										 |  |  | 	if (res0) | 
					
						
							|  |  |  | 		freeaddrinfo(res0); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	return (PyObject *)NULL; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getaddrinfo_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "getaddrinfo(host, port [, family, socktype, proto, flags])\n\
 | 
					
						
							|  |  |  |     -> list of (family, socktype, proto, canonname, sockaddr)\n\ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Resolve host and port into addrinfo struct."); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Python interface to getnameinfo(sa, flags). */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | /*ARGSUSED*/ | 
					
						
							|  |  |  | static PyObject * | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | socket_getnameinfo(PyObject *self, PyObject *args) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	PyObject *sa = (PyObject *)NULL; | 
					
						
							|  |  |  | 	int flags; | 
					
						
							|  |  |  | 	char *hostp; | 
					
						
							| 
									
										
										
										
											2001-11-02 23:34:52 +00:00
										 |  |  | 	int port, flowinfo, scope_id; | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV]; | 
					
						
							|  |  |  | 	struct addrinfo hints, *res = NULL; | 
					
						
							|  |  |  | 	int error; | 
					
						
							|  |  |  | 	PyObject *ret = (PyObject *)NULL; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	flags = flowinfo = scope_id = 0; | 
					
						
							| 
									
										
										
										
											2001-11-02 23:34:52 +00:00
										 |  |  | 	if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags)) | 
					
						
							|  |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	if  (!PyArg_ParseTuple(sa, "si|ii", | 
					
						
							|  |  |  | 			       &hostp, &port, &flowinfo, &scope_id)) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return NULL; | 
					
						
							| 
									
										
										
										
											2001-07-31 18:05:33 +00:00
										 |  |  | 	PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	memset(&hints, 0, sizeof(hints)); | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | 	hints.ai_family = AF_UNSPEC; | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | 	hints.ai_socktype = SOCK_DGRAM;	/* make numeric port happy */ | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_BEGIN_ALLOW_THREADS | 
					
						
							|  |  |  | 	ACQUIRE_GETADDRINFO_LOCK | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	error = getaddrinfo(hostp, pbuf, &hints, &res); | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | 	Py_END_ALLOW_THREADS | 
					
						
							|  |  |  | 	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */ | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		goto fail; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	if (res->ai_next) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 			"sockaddr resolved to multiple addresses"); | 
					
						
							|  |  |  | 		goto fail; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	switch (res->ai_family) { | 
					
						
							|  |  |  | 	case AF_INET: | 
					
						
							|  |  |  | 	    { | 
					
						
							|  |  |  | 		char *t1; | 
					
						
							|  |  |  | 		int t2; | 
					
						
							|  |  |  | 		if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			PyErr_SetString(socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 				"IPv4 sockaddr must be 2 tuple"); | 
					
						
							|  |  |  | 			goto fail; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | 	    } | 
					
						
							| 
									
										
										
										
											2001-12-02 10:15:37 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	case AF_INET6: | 
					
						
							|  |  |  | 	    { | 
					
						
							|  |  |  | 		struct sockaddr_in6 *sin6; | 
					
						
							|  |  |  | 		sin6 = (struct sockaddr_in6 *)res->ai_addr; | 
					
						
							|  |  |  | 		sin6->sin6_flowinfo = flowinfo; | 
					
						
							|  |  |  | 		sin6->sin6_scope_id = scope_id; | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | 	    } | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	error = getnameinfo(res->ai_addr, res->ai_addrlen, | 
					
						
							|  |  |  | 			hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags); | 
					
						
							|  |  |  | 	if (error) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		set_gaierror(error); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		goto fail; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	ret = Py_BuildValue("ss", hbuf, pbuf); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | fail: | 
					
						
							|  |  |  | 	if (res) | 
					
						
							|  |  |  | 		freeaddrinfo(res); | 
					
						
							|  |  |  | 	return ret; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(getnameinfo_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "getnameinfo(sockaddr, flags) --> (host, port)\n\
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | \n\ | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | Get host and port for a sockaddr."); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Python API to getting and setting the default timeout value. */ | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_getdefaulttimeout(PyObject *self) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	if (defaulttimeout < 0.0) { | 
					
						
							|  |  |  | 		Py_INCREF(Py_None); | 
					
						
							|  |  |  | 		return Py_None; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	else | 
					
						
							|  |  |  | 		return PyFloat_FromDouble(defaulttimeout); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | PyDoc_STRVAR(getdefaulttimeout_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "getdefaulttimeout() -> timeout\n\
 | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Returns the default timeout in floating seconds for new socket objects.\n\ | 
					
						
							|  |  |  | A value of None indicates that new socket objects have no timeout.\n\ | 
					
						
							|  |  |  | When the socket module is first imported, the default is None."); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static PyObject * | 
					
						
							|  |  |  | socket_setdefaulttimeout(PyObject *self, PyObject *arg) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	double timeout; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	if (arg == Py_None) | 
					
						
							|  |  |  | 		timeout = -1.0; | 
					
						
							|  |  |  | 	else { | 
					
						
							|  |  |  | 		timeout = PyFloat_AsDouble(arg); | 
					
						
							|  |  |  | 		if (timeout < 0.0) { | 
					
						
							|  |  |  | 			if (!PyErr_Occurred()) | 
					
						
							|  |  |  | 				PyErr_SetString(PyExc_ValueError, | 
					
						
							|  |  |  | 						"Timeout value out of range"); | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		} | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	defaulttimeout = timeout; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	Py_INCREF(Py_None); | 
					
						
							|  |  |  | 	return Py_None; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | PyDoc_STRVAR(setdefaulttimeout_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "setdefaulttimeout(timeout)\n\
 | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | \n\ | 
					
						
							|  |  |  | Set the default timeout in floating seconds for new socket objects.\n\ | 
					
						
							|  |  |  | A value of None indicates that new socket objects have no timeout.\n\ | 
					
						
							|  |  |  | When the socket module is first imported, the default is None."); | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | /* List of functions exported by this module. */ | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | static PyMethodDef socket_methods[] = { | 
					
						
							|  |  |  | 	{"gethostbyname",	socket_gethostbyname, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, gethostbyname_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"gethostbyname_ex",	socket_gethostbyname_ex, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, ghbn_ex_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"gethostbyaddr",	socket_gethostbyaddr, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, gethostbyaddr_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"gethostname",		socket_gethostname, | 
					
						
							| 
									
										
										
										
											2006-05-29 21:04:52 +00:00
										 |  |  | 	 METH_NOARGS,  gethostname_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"getservbyname",	socket_getservbyname, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, getservbyname_doc}, | 
					
						
							| 
									
										
										
										
											2004-06-28 00:50:43 +00:00
										 |  |  | 	{"getservbyport",	socket_getservbyport, | 
					
						
							|  |  |  | 	 METH_VARARGS, getservbyport_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"getprotobyname",	socket_getprotobyname, | 
					
						
							| 
									
										
										
										
											2006-05-29 21:04:52 +00:00
										 |  |  | 	 METH_VARARGS, getprotobyname_doc}, | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #ifndef NO_DUP
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"fromfd",		socket_fromfd, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, fromfd_doc}, | 
					
						
							| 
									
										
										
										
											2004-08-09 04:51:41 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef HAVE_SOCKETPAIR
 | 
					
						
							|  |  |  | 	{"socketpair",		socket_socketpair, | 
					
						
							|  |  |  | 	 METH_VARARGS, socketpair_doc}, | 
					
						
							| 
									
										
										
										
											1994-08-18 15:42:46 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"ntohs",		socket_ntohs, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, ntohs_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"ntohl",		socket_ntohl, | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	 METH_O, ntohl_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"htons",		socket_htons, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, htons_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"htonl",		socket_htonl, | 
					
						
							| 
									
										
										
										
											2002-07-25 16:01:12 +00:00
										 |  |  | 	 METH_O, htonl_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"inet_aton",		socket_inet_aton, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, inet_aton_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"inet_ntoa",		socket_inet_ntoa, | 
					
						
							| 
									
										
										
										
											2000-08-03 02:06:16 +00:00
										 |  |  | 	 METH_VARARGS, inet_ntoa_doc}, | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | #ifdef HAVE_INET_PTON
 | 
					
						
							|  |  |  | 	{"inet_pton",		socket_inet_pton, | 
					
						
							|  |  |  | 	 METH_VARARGS, inet_pton_doc}, | 
					
						
							|  |  |  | 	{"inet_ntop",		socket_inet_ntop, | 
					
						
							|  |  |  | 	 METH_VARARGS, inet_ntop_doc}, | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"getaddrinfo",		socket_getaddrinfo, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	 METH_VARARGS, getaddrinfo_doc}, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	{"getnameinfo",		socket_getnameinfo, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	 METH_VARARGS, getnameinfo_doc}, | 
					
						
							| 
									
										
										
										
											2002-07-18 21:11:26 +00:00
										 |  |  | 	{"getdefaulttimeout",	(PyCFunction)socket_getdefaulttimeout, | 
					
						
							| 
									
										
										
										
											2002-07-18 17:08:35 +00:00
										 |  |  | 	 METH_NOARGS, getdefaulttimeout_doc}, | 
					
						
							|  |  |  | 	{"setdefaulttimeout",	socket_setdefaulttimeout, | 
					
						
							|  |  |  | 	 METH_O, setdefaulttimeout_doc}, | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 	{NULL,			NULL}		 /* Sentinel */ | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | #ifdef RISCOS
 | 
					
						
							|  |  |  | #define OS_INIT_DEFINED
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static int | 
					
						
							|  |  |  | os_init(void) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	_kernel_swi_regs r; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	r.r[0] = 0; | 
					
						
							|  |  |  | 	_kernel_swi(0x43380, &r, &r); | 
					
						
							|  |  |  | 	taskwindow = r.r[0]; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-05-10 07:36:56 +00:00
										 |  |  | 	return 1; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #endif /* RISCOS */
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-26 18:22:49 +00:00
										 |  |  | #ifdef MS_WINDOWS
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | #define OS_INIT_DEFINED
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | /* Additional initialization and cleanup for Windows */ | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static void | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | os_cleanup(void) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	WSACleanup(); | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | static int | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | os_init(void) | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	WSADATA WSAData; | 
					
						
							|  |  |  | 	int ret; | 
					
						
							|  |  |  | 	char buf[100]; | 
					
						
							|  |  |  | 	ret = WSAStartup(0x0101, &WSAData); | 
					
						
							|  |  |  | 	switch (ret) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	case 0:	/* No error */ | 
					
						
							| 
									
										
										
										
											2003-07-09 04:57:46 +00:00
										 |  |  | 		Py_AtExit(os_cleanup); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		return 1; /* Success */ | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 	case WSASYSNOTREADY: | 
					
						
							|  |  |  | 		PyErr_SetString(PyExc_ImportError, | 
					
						
							|  |  |  | 				"WSAStartup failed: network not ready"); | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | 	case WSAVERNOTSUPPORTED: | 
					
						
							|  |  |  | 	case WSAEINVAL: | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 		PyErr_SetString( | 
					
						
							|  |  |  | 			PyExc_ImportError, | 
					
						
							|  |  |  | 			"WSAStartup failed: requested version not supported"); | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		break; | 
					
						
							|  |  |  | 	default: | 
					
						
							| 
									
										
										
										
											2001-11-28 20:27:42 +00:00
										 |  |  | 		PyOS_snprintf(buf, sizeof(buf), | 
					
						
							|  |  |  | 			      "WSAStartup failed: error code %d", ret); | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 		PyErr_SetString(PyExc_ImportError, buf); | 
					
						
							|  |  |  | 		break; | 
					
						
							|  |  |  | 	} | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	return 0; /* Failure */ | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1996-06-26 18:22:49 +00:00
										 |  |  | #endif /* MS_WINDOWS */
 | 
					
						
							| 
									
										
										
										
											1996-06-20 16:25:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | #ifdef PYOS_OS2
 | 
					
						
							|  |  |  | #define OS_INIT_DEFINED
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | /* Additional initialization for OS/2 */ | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | static int | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | os_init(void) | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | #ifndef PYCC_GCC
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	char reason[64]; | 
					
						
							|  |  |  | 	int rc = sock_init(); | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	if (rc == 0) { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 		return 1; /* Success */ | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	} | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	PyOS_snprintf(reason, sizeof(reason), | 
					
						
							|  |  |  | 		      "OS/2 TCP/IP Error# %d", sock_errno()); | 
					
						
							|  |  |  | 	PyErr_SetString(PyExc_ImportError, reason); | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	return 0;  /* Failure */ | 
					
						
							| 
									
										
										
										
											2002-03-03 03:03:52 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	/* No need to initialise sockets with GCC/EMX */ | 
					
						
							|  |  |  | 	return 1; /* Success */ | 
					
						
							| 
									
										
										
										
											2002-03-03 03:03:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #endif /* PYOS_OS2 */
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifndef OS_INIT_DEFINED
 | 
					
						
							|  |  |  | static int | 
					
						
							|  |  |  | os_init(void) | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  | 	return 1; /* Success */ | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | /* C API table - always add new things to the end for binary
 | 
					
						
							|  |  |  |    compatibility. */ | 
					
						
							|  |  |  | static | 
					
						
							|  |  |  | PySocketModule_APIObject PySocketModuleAPI = | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	&sock_type, | 
					
						
							| 
									
										
										
										
											2004-03-23 23:16:54 +00:00
										 |  |  |         NULL | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | /* Initialize the _socket module.
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  |    This module is actually called "_socket", and there's a wrapper | 
					
						
							|  |  |  |    "socket.py" which implements some additional functionality.  On some | 
					
						
							|  |  |  |    platforms (e.g. Windows and OS/2), socket.py also implements a | 
					
						
							|  |  |  |    wrapper for the socket type that provides missing functionality such | 
					
						
							|  |  |  |    as makefile(), dup() and fromfd().  The import of "_socket" may fail | 
					
						
							|  |  |  |    with an ImportError exception if os-specific initialization fails. | 
					
						
							|  |  |  |    On Windows, this does WINSOCK initialization.  When WINSOCK is | 
					
						
							|  |  |  |    initialized succesfully, a call to WSACleanup() is scheduled to be | 
					
						
							|  |  |  |    made at exit time. | 
					
						
							|  |  |  | */ | 
					
						
							| 
									
										
										
										
											1991-06-27 15:51:29 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-13 20:33:02 +00:00
										 |  |  | PyDoc_STRVAR(socket_doc, | 
					
						
							| 
									
										
										
										
											2002-08-08 20:37:08 +00:00
										 |  |  | "Implementation module for socket operations.\n\
 | 
					
						
							|  |  |  | \n\ | 
					
						
							|  |  |  | See the socket module for documentation."); | 
					
						
							| 
									
										
										
										
											1998-07-07 20:45:43 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-08-02 02:27:13 +00:00
										 |  |  | PyMODINIT_FUNC | 
					
						
							| 
									
										
										
										
											2000-07-24 16:06:23 +00:00
										 |  |  | init_socket(void) | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | 	PyObject *m, *has_ipv6; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (!os_init()) | 
					
						
							| 
									
										
										
										
											1997-11-22 21:53:48 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	sock_type.ob_type = &PyType_Type; | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	m = Py_InitModule3(PySocket_MODULE_NAME, | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			   socket_methods, | 
					
						
							|  |  |  | 			   socket_doc); | 
					
						
							| 
									
										
										
										
											2006-01-19 06:09:39 +00:00
										 |  |  | 	if (m == NULL) | 
					
						
							|  |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	socket_error = PyErr_NewException("socket.error", NULL, NULL); | 
					
						
							|  |  |  | 	if (socket_error == NULL) | 
					
						
							| 
									
										
										
										
											1997-10-01 04:29:29 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2004-03-23 23:16:54 +00:00
										 |  |  |         PySocketModuleAPI.error = socket_error; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	Py_INCREF(socket_error); | 
					
						
							|  |  |  | 	PyModule_AddObject(m, "error", socket_error); | 
					
						
							|  |  |  | 	socket_herror = PyErr_NewException("socket.herror", | 
					
						
							|  |  |  | 					   socket_error, NULL); | 
					
						
							|  |  |  | 	if (socket_herror == NULL) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	Py_INCREF(socket_herror); | 
					
						
							|  |  |  | 	PyModule_AddObject(m, "herror", socket_herror); | 
					
						
							|  |  |  | 	socket_gaierror = PyErr_NewException("socket.gaierror", socket_error, | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	    NULL); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	if (socket_gaierror == NULL) | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	Py_INCREF(socket_gaierror); | 
					
						
							|  |  |  | 	PyModule_AddObject(m, "gaierror", socket_gaierror); | 
					
						
							| 
									
										
										
										
											2003-06-29 03:08:05 +00:00
										 |  |  | 	socket_timeout = PyErr_NewException("socket.timeout", | 
					
						
							|  |  |  | 					    socket_error, NULL); | 
					
						
							|  |  |  | 	if (socket_timeout == NULL) | 
					
						
							|  |  |  | 		return; | 
					
						
							|  |  |  | 	Py_INCREF(socket_timeout); | 
					
						
							|  |  |  | 	PyModule_AddObject(m, "timeout", socket_timeout); | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	Py_INCREF((PyObject *)&sock_type); | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	if (PyModule_AddObject(m, "SocketType", | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			       (PyObject *)&sock_type) != 0) | 
					
						
							| 
									
										
										
										
											1997-10-01 04:29:29 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	Py_INCREF((PyObject *)&sock_type); | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	if (PyModule_AddObject(m, "socket", | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 			       (PyObject *)&sock_type) != 0) | 
					
						
							| 
									
										
										
										
											2001-10-27 22:20:47 +00:00
										 |  |  | 		return; | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | #ifdef ENABLE_IPV6
 | 
					
						
							|  |  |  | 	has_ipv6 = Py_True; | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	has_ipv6 = Py_False; | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	Py_INCREF(has_ipv6); | 
					
						
							|  |  |  | 	PyModule_AddObject(m, "has_ipv6", has_ipv6); | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 	/* Export C API */ | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	if (PyModule_AddObject(m, PySocket_CAPI_NAME, | 
					
						
							| 
									
										
										
										
											2002-02-16 18:23:30 +00:00
										 |  |  | 	       PyCObject_FromVoidPtr((void *)&PySocketModuleAPI, NULL) | 
					
						
							|  |  |  | 				 ) != 0) | 
					
						
							|  |  |  | 		return; | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | 	/* Address families (we only support AF_INET and AF_UNIX) */ | 
					
						
							|  |  |  | #ifdef AF_UNSPEC
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_INET", AF_INET); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #ifdef AF_INET6
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif /* AF_INET6 */
 | 
					
						
							| 
									
										
										
										
											2004-04-04 07:13:49 +00:00
										 |  |  | #if defined(AF_UNIX)
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX); | 
					
						
							| 
									
										
										
										
											1994-08-01 11:34:53 +00:00
										 |  |  | #endif /* AF_UNIX */
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #ifdef AF_AX25
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Amateur Radio AX.25 */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_AX25", AF_AX25); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_IPX
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */ | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_APPLETALK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Appletalk DDP */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_NETROM
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Amateur radio NetROM */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_BRIDGE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Multiprotocol bridge */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-07-19 17:01:20 +00:00
										 |  |  | #ifdef AF_ATMPVC
 | 
					
						
							|  |  |  | 	/* ATM PVCs */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #ifdef AF_AAL5
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Reserved for Werner's ATM */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_X25
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Reserved for X.25 project */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_X25", AF_X25); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_INET6
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */ | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_ROSE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	/* Amateur Radio X.25 PLP */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-07-19 17:01:20 +00:00
										 |  |  | #ifdef AF_DECnet
 | 
					
						
							|  |  |  | 	/* Reserved for DECnet project */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_NETBEUI
 | 
					
						
							|  |  |  | 	/* Reserved for 802.2LLC project */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_SECURITY
 | 
					
						
							|  |  |  | 	/* Security callback pseudo AF */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_KEY
 | 
					
						
							|  |  |  | 	/* PF_KEY key management API */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_KEY", AF_KEY); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_NETLINK
 | 
					
						
							|  |  |  | 	/*  */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK); | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #ifdef NETLINK_SKIP
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NETLINK_W1
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL); | 
					
						
							| 
									
										
										
										
											2006-02-21 01:07:27 +00:00
										 |  |  | #ifdef NETLINK_TCPDIAG
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG); | 
					
						
							| 
									
										
										
										
											2006-02-21 01:07:27 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NETLINK_NFLOG
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG); | 
					
						
							| 
									
										
										
										
											2006-02-21 01:07:27 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-01-16 04:31:40 +00:00
										 |  |  | #ifdef NETLINK_XFRM
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM); | 
					
						
							| 
									
										
										
										
											2006-01-16 04:31:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #ifdef NETLINK_ARPD
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NETLINK_ROUTE6
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #ifdef NETLINK_TAPBASE
 | 
					
						
							| 
									
										
										
										
											2006-01-14 18:12:57 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE); | 
					
						
							| 
									
										
										
										
											2006-04-06 22:29:33 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2006-04-01 07:33:08 +00:00
										 |  |  | #endif /* AF_NETLINK */
 | 
					
						
							| 
									
										
										
										
											2004-07-19 17:01:20 +00:00
										 |  |  | #ifdef AF_ROUTE
 | 
					
						
							|  |  |  | 	/* Alias to emulate 4.4BSD */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_ASH
 | 
					
						
							|  |  |  | 	/* Ash */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ASH", AF_ASH); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_ECONET
 | 
					
						
							|  |  |  | 	/* Acorn Econet */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_ATMSVC
 | 
					
						
							|  |  |  | 	/* ATM SVCs */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_SNA
 | 
					
						
							|  |  |  | 	/* Linux SNA Project (nutters!) */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_SNA", AF_SNA); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_IRDA
 | 
					
						
							|  |  |  | 	/* IRDA sockets */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_PPPOX
 | 
					
						
							|  |  |  | 	/* PPPoX sockets */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_WANPIPE
 | 
					
						
							|  |  |  | 	/* Wanpipe API Sockets */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AF_LLC
 | 
					
						
							|  |  |  | 	/* Linux LLC */ | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AF_LLC", AF_LLC); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #ifdef USE_BLUETOOTH
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP); | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #if !defined(__FreeBSD__)
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO); | 
					
						
							| 
									
										
										
										
											2004-02-02 06:05:24 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM); | 
					
						
							| 
									
										
										
										
											2006-05-30 03:18:50 +00:00
										 |  |  | 	PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00"); | 
					
						
							|  |  |  | 	PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF"); | 
					
						
							| 
									
										
										
										
											2004-01-31 12:34:17 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-10 20:29:40 +00:00
										 |  |  | #ifdef HAVE_NETPACKET_PACKET_H
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE); | 
					
						
							| 
									
										
										
										
											2001-03-02 06:34:14 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	/* Socket types */ | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #ifndef __BEOS__
 | 
					
						
							|  |  |  | /* We have incomplete socket support. */ | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW); | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET); | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | #if defined(SOCK_RDM)
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM); | 
					
						
							| 
									
										
										
										
											1998-08-04 22:53:56 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2002-12-11 13:10:57 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | #ifdef	SO_DEBUG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_ACCEPTCONN
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_REUSEADDR
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2004-07-10 14:19:21 +00:00
										 |  |  | #ifdef SO_EXCLUSIVEADDRUSE
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	SO_KEEPALIVE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_DONTROUTE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_BROADCAST
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_USELOOPBACK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_LINGER
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_OOBINLINE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_REUSEPORT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_SNDBUF
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_RCVBUF
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_SNDLOWAT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_RCVLOWAT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_SNDTIMEO
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_RCVTIMEO
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_ERROR
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SO_TYPE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Maximum number of connections for "listen" */ | 
					
						
							|  |  |  | #ifdef	SOMAXCONN
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */ | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Flags for send, recv */ | 
					
						
							|  |  |  | #ifdef	MSG_OOB
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_PEEK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_DONTROUTE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2000-04-25 21:34:53 +00:00
										 |  |  | #ifdef	MSG_DONTWAIT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT); | 
					
						
							| 
									
										
										
										
											2000-04-25 21:34:53 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	MSG_EOR
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_TRUNC
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_CTRUNC
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_WAITALL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_BTAG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	MSG_ETAG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Protocol level and numbers, usable for [gs]etsockopt */ | 
					
						
							|  |  |  | #ifdef	SOL_SOCKET
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #ifdef	SOL_IP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_IP", SOL_IP); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_IP", 0); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_IPX
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_AX25
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_ATALK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_NETROM
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_ROSE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_TCP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_TCP", 6); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	SOL_UDP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "SOL_UDP", 17); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IPPROTO_IP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP); | 
					
						
							| 
									
										
										
										
											1998-05-28 20:18:18 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IP", 0); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #ifdef	IPPROTO_HOPOPTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IPPROTO_ICMP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP); | 
					
						
							| 
									
										
										
										
											1998-05-28 20:18:18 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_IGMP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_GGP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #ifdef	IPPROTO_IPV4
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-10-03 13:56:20 +00:00
										 |  |  | #ifdef	IPPROTO_IPV6
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #ifdef	IPPROTO_IPIP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IPPROTO_TCP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP); | 
					
						
							| 
									
										
										
										
											1998-05-28 20:18:18 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_TCP", 6); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_EGP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_PUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_UDP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP); | 
					
						
							| 
									
										
										
										
											1998-05-28 20:18:18 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_UDP", 17); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_IDP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_HELLO
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_ND
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_TP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #ifdef	IPPROTO_IPV6
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_ROUTING
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_FRAGMENT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_RSVP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_GRE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_ESP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_AH
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_MOBILE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_ICMPV6
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_NONE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_DSTOPTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IPPROTO_XTP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_EON
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #ifdef	IPPROTO_PIM
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_IPCOMP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_VRRP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IPPROTO_BIP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | /**/ | 
					
						
							|  |  |  | #ifdef	IPPROTO_RAW
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW); | 
					
						
							| 
									
										
										
										
											1998-05-28 20:18:18 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_RAW", 255); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPROTO_MAX
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 	/* Some port configuration */ | 
					
						
							|  |  |  | #ifdef	IPPORT_RESERVED
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPPORT_USERRESERVED
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | 	/* Some reserved IP v.4 addresses */ | 
					
						
							|  |  |  | #ifdef	INADDR_ANY
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_BROADCAST
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_LOOPBACK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_UNSPEC_GROUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_ALLHOSTS_GROUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", | 
					
						
							|  |  |  | 				INADDR_ALLHOSTS_GROUP); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_MAX_LOCAL_GROUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", | 
					
						
							|  |  |  | 				INADDR_MAX_LOCAL_GROUP); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	INADDR_NONE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #else
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff); | 
					
						
							| 
									
										
										
										
											1995-02-17 15:11:07 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | 	/* IPv4 [gs]etsockopt options */ | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #ifdef	IP_OPTIONS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_HDRINCL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_TOS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_TOS", IP_TOS); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_TTL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_TTL", IP_TTL); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_RECVOPTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_RECVRETOPTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_RECVDSTADDR
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_RETOPTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_MULTICAST_IF
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_MULTICAST_TTL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_MULTICAST_LOOP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_ADD_MEMBERSHIP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_DROP_MEMBERSHIP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP); | 
					
						
							| 
									
										
										
										
											1995-02-07 15:39:52 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #ifdef	IP_DEFAULT_MULTICAST_TTL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL", | 
					
						
							|  |  |  | 				IP_DEFAULT_MULTICAST_TTL); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_DEFAULT_MULTICAST_LOOP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP", | 
					
						
							|  |  |  | 				IP_DEFAULT_MULTICAST_LOOP); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IP_MAX_MEMBERSHIPS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | 	/* IPv6 [gs]etsockopt options, defined in RFC2553 */ | 
					
						
							|  |  |  | #ifdef	IPV6_JOIN_GROUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPV6_LEAVE_GROUP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPV6_MULTICAST_HOPS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPV6_MULTICAST_IF
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPV6_MULTICAST_LOOP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	IPV6_UNICAST_HOPS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS); | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-12-30 11:14:01 +00:00
										 |  |  |         /* Additional IPV6 socket options, defined in RFC 3493 */ | 
					
						
							|  |  |  | #ifdef IPV6_V6ONLY
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 	/* Advanced IPV6 socket options, from RFC 3542 */ | 
					
						
							|  |  |  | #ifdef IPV6_CHECKSUM
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_DONTFRAG
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_DSTOPTS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_HOPLIMIT
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_HOPOPTS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_NEXTHOP
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_PATHMTU
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_PKTINFO
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVDSTOPTS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVHOPLIMIT
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVHOPOPTS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVPKTINFO
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVRTHDR
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVTCLASS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RTHDR
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RTHDRDSTOPTS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RTHDR_TYPE_0
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_RECVPATHMTU
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_TCLASS
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef IPV6_USE_MIN_MTU
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-08-04 22:37:23 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | 	/* TCP options */ | 
					
						
							|  |  |  | #ifdef	TCP_NODELAY
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_MAXSEG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #ifdef	TCP_CORK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_KEEPIDLE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_KEEPINTVL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_KEEPCNT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_SYNCNT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_LINGER2
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_DEFER_ACCEPT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_WINDOW_CLAMP
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_INFO
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef	TCP_QUICKACK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK); | 
					
						
							| 
									
										
										
										
											2001-12-22 15:05:32 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	/* IPX options */ | 
					
						
							|  |  |  | #ifdef	IPX_TYPE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE); | 
					
						
							| 
									
										
										
										
											1999-08-09 14:40:40 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1998-04-09 20:56:35 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | 	/* get{addr,name}info parameters */ | 
					
						
							|  |  |  | #ifdef EAI_ADDRFAMILY
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_AGAIN
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_BADFLAGS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_FAIL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_FAMILY
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_MEMORY
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_NODATA
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_NONAME
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-12-30 11:14:01 +00:00
										 |  |  | #ifdef EAI_OVERFLOW
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #ifdef EAI_SERVICE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_SOCKTYPE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_SYSTEM
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_BADHINTS
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_PROTOCOL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef EAI_MAX
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_PASSIVE
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_CANONNAME
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_NUMERICHOST
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2003-12-30 11:14:01 +00:00
										 |  |  | #ifdef AI_NUMERICSERV
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV); | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #ifdef AI_MASK
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_MASK", AI_MASK); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_ALL
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_ALL", AI_ALL); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_V4MAPPED_CFG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_ADDRCONFIG
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_V4MAPPED
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef AI_DEFAULT
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_MAXHOST
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_MAXSERV
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_NOFQDN
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_NUMERICHOST
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_NAMEREQD
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_NUMERICSERV
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef NI_DGRAM
 | 
					
						
							| 
									
										
										
										
											2002-04-01 14:53:37 +00:00
										 |  |  | 	PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM); | 
					
						
							| 
									
										
										
										
											2001-07-21 18:05:31 +00:00
										 |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2003-11-27 19:40:22 +00:00
										 |  |  | 	/* shutdown() parameters */ | 
					
						
							|  |  |  | #ifdef SHUT_RD
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD); | 
					
						
							|  |  |  | #elif defined(SD_RECEIVE)
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE); | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RD", 0); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef SHUT_WR
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR); | 
					
						
							|  |  |  | #elif defined(SD_SEND)
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND); | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_WR", 1); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | #ifdef SHUT_RDWR
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR); | 
					
						
							|  |  |  | #elif defined(SD_BOTH)
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH); | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | 	PyModule_AddIntConstant(m, "SHUT_RDWR", 2); | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											1998-04-09 20:56:35 +00:00
										 |  |  | 	/* Initialize gethostbyname lock */ | 
					
						
							| 
									
										
										
										
											2003-05-09 07:53:18 +00:00
										 |  |  | #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
 | 
					
						
							|  |  |  | 	netdb_lock = PyThread_allocate_lock(); | 
					
						
							| 
									
										
										
										
											1998-04-09 20:56:35 +00:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											1991-06-25 21:36:08 +00:00
										 |  |  | } | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | #ifndef HAVE_INET_PTON
 | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | /* Simplistic emulation code for inet_pton that only works for IPv4 */ | 
					
						
							| 
									
										
										
										
											2003-04-25 05:48:32 +00:00
										 |  |  | /* These are not exposed because they do not set errno properly */ | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2002-06-07 02:08:35 +00:00
										 |  |  | int | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | inet_pton(int af, const char *src, void *dst) | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 	if (af == AF_INET) { | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | 		long packed_addr; | 
					
						
							|  |  |  | 		packed_addr = inet_addr(src); | 
					
						
							|  |  |  | 		if (packed_addr == INADDR_NONE) | 
					
						
							|  |  |  | 			return 0; | 
					
						
							|  |  |  | 		memcpy(dst, &packed_addr, 4); | 
					
						
							|  |  |  | 		return 1; | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	/* Should set errno to EAFNOSUPPORT */ | 
					
						
							|  |  |  | 	return -1; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-07-21 09:42:15 +00:00
										 |  |  | const char * | 
					
						
							|  |  |  | inet_ntop(int af, const void *src, char *dst, socklen_t size) | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | { | 
					
						
							|  |  |  | 	if (af == AF_INET) { | 
					
						
							|  |  |  | 		struct in_addr packed_addr; | 
					
						
							|  |  |  | 		if (size < 16) | 
					
						
							|  |  |  | 			/* Should set errno to ENOSPC. */ | 
					
						
							|  |  |  | 			return NULL; | 
					
						
							|  |  |  | 		memcpy(&packed_addr, src, sizeof(packed_addr)); | 
					
						
							|  |  |  | 		return strncpy(dst, inet_ntoa(packed_addr), size); | 
					
						
							|  |  |  | 	} | 
					
						
							|  |  |  | 	/* Should set errno to EAFNOSUPPORT */ | 
					
						
							|  |  |  | 	return NULL; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2002-06-07 03:19:37 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2001-06-24 21:18:26 +00:00
										 |  |  | #endif
 |