add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/socketmodule.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/socketmodule.c+5100−0

@@ -0,0 +1,5100 @@
	1	+/* Socket module */
	2	+
	3	+/*
	4	+
	5	+This module provides an interface to Berkeley socket IPC.
	6	+
	7	+Limitations:
	8	+
	9	+- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
	10	+ portable manner, though AF_PACKET and AF_NETLINK are supported under Linux.
	11	+- No read/write operations (use sendall/recv or makefile instead).
	12	+- Additional restrictions apply on some non-Unix platforms (compensated
	13	+ for by socket.py).
	14	+
	15	+Module interface:
	16	+
	17	+- socket.error: exception raised for socket specific errors
	18	+- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
	19	+ a subclass of socket.error
	20	+- socket.herror: exception raised for gethostby* errors,
	21	+ a subclass of socket.error
	22	+- socket.fromfd(fd, family, type[, proto]) --> new socket object (created
	23	+ from an existing file descriptor)
	24	+- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
	25	+- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
	26	+- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
	27	+- socket.getprotobyname(protocolname) --> protocol number
	28	+- socket.getservbyname(servicename[, protocolname]) --> port number
	29	+- socket.getservbyport(portnumber[, protocolname]) --> service name
	30	+- socket.socket([family[, type [, proto]]]) --> new socket object
	31	+- socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
	32	+- socket.ntohs(16 bit value) --> new int object
	33	+- socket.ntohl(32 bit value) --> new int object
	34	+- socket.htons(16 bit value) --> new int object
	35	+- socket.htonl(32 bit value) --> new int object
	36	+- socket.getaddrinfo(host, port [, family, socktype, proto, flags])
	37	+ --> List of (family, socktype, proto, canonname, sockaddr)
	38	+- socket.getnameinfo(sockaddr, flags) --> (host, port)
	39	+- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
	40	+- socket.has_ipv6: boolean value indicating if IPv6 is supported
	41	+- socket.inet_aton(IP address) -> 32-bit packed IP representation
	42	+- socket.inet_ntoa(packed IP) -> IP address string
	43	+- socket.getdefaulttimeout() -> None \| float
	44	+- socket.setdefaulttimeout(None \| float)
	45	+- an Internet socket address is a pair (hostname, port)
	46	+ where hostname can be anything recognized by gethostbyname()
	47	+ (including the dd.dd.dd.dd notation) and port is in host byte order
	48	+- where a hostname is returned, the dd.dd.dd.dd notation is used
	49	+- a UNIX domain socket address is a string specifying the pathname
	50	+- an AF_PACKET socket address is a tuple containing a string
	51	+ specifying the ethernet interface and an integer specifying
	52	+ the Ethernet protocol number to be received. For example:
	53	+ ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
	54	+ specify packet-type and ha-type/addr.
	55	+
	56	+Local naming conventions:
	57	+
	58	+- names starting with sock_ are socket object methods
	59	+- names starting with socket_ are module-level functions
	60	+- names starting with PySocket are exported through socketmodule.h
	61	+
	62	+*/
	63	+
	64	+#ifdef __APPLE__
	65	+ /*
	66	+ * inet_aton is not available on OSX 10.3, yet we want to use a binary
	67	+ * that was build on 10.4 or later to work on that release, weak linking
	68	+ * comes to the rescue.
	69	+ */
	70	+# pragma weak inet_aton
	71	+#endif
	72	+
	73	+#include "Python.h"
	74	+#include "structmember.h"
	75	+
	76	+#undef MAX
	77	+#define MAX(x, y) ((x) < (y) ? (y) : (x))
	78	+
	79	+/* Socket object documentation */
	80	+PyDoc_STRVAR(sock_doc,
	81	+"socket([family[, type[, proto]]]) -> socket object\n\
	82	+\n\
	83	+Open a socket of the given type. The family argument specifies the\n\
	84	+address family; it defaults to AF_INET. The type argument specifies\n\
	85	+whether this is a stream (SOCK_STREAM, this is the default)\n\
	86	+or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
	87	+specifying the default protocol. Keyword arguments are accepted.\n\
	88	+\n\
	89	+A socket object represents one endpoint of a network connection.\n\
	90	+\n\
	91	+Methods of socket objects (keyword arguments not allowed):\n\
	92	+\n\
	93	+accept() -- accept a connection, returning new socket and client address\n\
	94	+bind(addr) -- bind the socket to a local address\n\
	95	+close() -- close the socket\n\
	96	+connect(addr) -- connect the socket to a remote address\n\
	97	+connect_ex(addr) -- connect, return an error code instead of an exception\n\
	98	+dup() -- return a new socket object identical to the current one [*]\n\
	99	+fileno() -- return underlying file descriptor\n\
	100	+getpeername() -- return remote address [*]\n\
	101	+getsockname() -- return local address\n\
	102	+getsockopt(level, optname[, buflen]) -- get socket options\n\
	103	+gettimeout() -- return timeout or None\n\
	104	+listen(n) -- start listening for incoming connections\n\
	105	+makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\
	106	+recv(buflen[, flags]) -- receive data\n\
	107	+recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
	108	+recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
	109	+recvfrom_into(buffer[, nbytes, [, flags])\n\
	110	+ -- receive data and sender\'s address (into a buffer)\n\
	111	+sendall(data[, flags]) -- send all data\n\
	112	+send(data[, flags]) -- send data, may not send all of it\n\
	113	+sendto(data[, flags], addr) -- send data to a given address\n\
	114	+setblocking(0 \| 1) -- set or clear the blocking I/O flag\n\
	115	+setsockopt(level, optname, value) -- set socket options\n\
	116	+settimeout(None \| float) -- set or clear the timeout\n\
	117	+shutdown(how) -- shut down traffic in one or both directions\n\
	118	+\n\
	119	+ [*] not available on all platforms!");
	120	+
	121	+/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
	122	+ I hope some day someone can clean this up please... */
	123	+
	124	+/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
	125	+ script doesn't get this right, so we hardcode some platform checks below.
	126	+ On the other hand, not all Linux versions agree, so there the settings
	127	+ computed by the configure script are needed! */
	128	+
	129	+#ifndef linux
	130	+# undef HAVE_GETHOSTBYNAME_R_3_ARG
	131	+# undef HAVE_GETHOSTBYNAME_R_5_ARG
	132	+# undef HAVE_GETHOSTBYNAME_R_6_ARG
	133	+#endif
	134	+
	135	+#ifndef WITH_THREAD
	136	+# undef HAVE_GETHOSTBYNAME_R
	137	+#endif
	138	+
	139	+#ifdef HAVE_GETHOSTBYNAME_R
	140	+# if defined(_AIX) \|\| defined(__osf__)
	141	+# define HAVE_GETHOSTBYNAME_R_3_ARG
	142	+# elif defined(__sun) \|\| defined(__sgi)
	143	+# define HAVE_GETHOSTBYNAME_R_5_ARG
	144	+# elif defined(linux)
	145	+/* Rely on the configure script */
	146	+# else
	147	+# undef HAVE_GETHOSTBYNAME_R
	148	+# endif
	149	+#endif
	150	+
	151	+#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
	152	+ !defined(MS_WINDOWS)
	153	+# define USE_GETHOSTBYNAME_LOCK
	154	+#endif
	155	+
	156	+/* To use __FreeBSD_version */
	157	+#ifdef HAVE_SYS_PARAM_H
	158	+#include <sys/param.h>
	159	+#endif
	160	+/* On systems on which getaddrinfo() is believed to not be thread-safe,
	161	+ (this includes the getaddrinfo emulation) protect access with a lock. */
	162	+#if defined(WITH_THREAD) && (defined(__APPLE__) \|\| \
	163	+ (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) \|\| \
	164	+ defined(__OpenBSD__) \|\| defined(__NetBSD__) \|\| \
	165	+ defined(__VMS) \|\| !defined(HAVE_GETADDRINFO))
	166	+#define USE_GETADDRINFO_LOCK
	167	+#endif
	168	+
	169	+#ifdef USE_GETADDRINFO_LOCK
	170	+#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
	171	+#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
	172	+#else
	173	+#define ACQUIRE_GETADDRINFO_LOCK
	174	+#define RELEASE_GETADDRINFO_LOCK
	175	+#endif
	176	+
	177	+#if defined(USE_GETHOSTBYNAME_LOCK) \|\| defined(USE_GETADDRINFO_LOCK)
	178	+# include "pythread.h"
	179	+#endif
	180	+
	181	+#if defined(PYCC_VACPP)
	182	+# include <types.h>
	183	+# include <io.h>
	184	+# include <sys/ioctl.h>
	185	+# include <utils.h>
	186	+# include <ctype.h>
	187	+#endif
	188	+
	189	+#if defined(__VMS)
	190	+# include <ioctl.h>
	191	+#endif
	192	+
	193	+#if defined(PYOS_OS2)
	194	+# define INCL_DOS
	195	+# define INCL_DOSERRORS
	196	+# define INCL_NOPMAPI
	197	+# include <os2.h>
	198	+#endif
	199	+
	200	+#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
	201	+/* make sure that the reentrant (gethostbyaddr_r etc)
	202	+ functions are declared correctly if compiling with
	203	+ MIPSPro 7.x in ANSI C mode (default) */
	204	+
	205	+/* XXX Using _SGIAPI is the wrong thing,
	206	+ but I don't know what the right thing is. */
	207	+#undef _SGIAPI /* to avoid warning */
	208	+#define _SGIAPI 1
	209	+
	210	+#undef _XOPEN_SOURCE
	211	+#include <sys/socket.h>
	212	+#include <sys/types.h>
	213	+#include <netinet/in.h>
	214	+#ifdef _SS_ALIGNSIZE
	215	+#define HAVE_GETADDRINFO 1
	216	+#define HAVE_GETNAMEINFO 1
	217	+#endif
	218	+
	219	+#define HAVE_INET_PTON
	220	+#include <netdb.h>
	221	+#endif
	222	+
	223	+/* Irix 6.5 fails to define this variable at all. This is needed
	224	+ for both GCC and SGI's compiler. I'd say that the SGI headers
	225	+ are just busted. Same thing for Solaris. */
	226	+#if (defined(__sgi) \|\| defined(sun)) && !defined(INET_ADDRSTRLEN)
	227	+#define INET_ADDRSTRLEN 16
	228	+#endif
	229	+
	230	+/* Generic includes */
	231	+#ifdef HAVE_SYS_TYPES_H
	232	+#include <sys/types.h>
	233	+#endif
	234	+
	235	+/* Generic socket object definitions and includes */
	236	+#define PySocket_BUILDING_SOCKET
	237	+#include "socketmodule.h"
	238	+
	239	+/* Addressing includes */
	240	+
	241	+#ifndef MS_WINDOWS
	242	+
	243	+/* Non-MS WINDOWS includes */
	244	+# include <netdb.h>
	245	+
	246	+/* Headers needed for inet_ntoa() and inet_addr() */
	247	+# ifdef __BEOS__
	248	+# include <net/netdb.h>
	249	+# elif defined(PYOS_OS2) && defined(PYCC_VACPP)
	250	+# include <netdb.h>
	251	+typedef size_t socklen_t;
	252	+# else
	253	+# include <arpa/inet.h>
	254	+# endif
	255	+
	256	+# ifndef RISCOS
	257	+# include <fcntl.h>
	258	+# else
	259	+# include <sys/ioctl.h>
	260	+# include <socklib.h>
	261	+# define NO_DUP
	262	+int h_errno; /* not used */
	263	+# define INET_ADDRSTRLEN 16
	264	+# endif
	265	+
	266	+#else
	267	+
	268	+/* MS_WINDOWS includes */
	269	+# ifdef HAVE_FCNTL_H
	270	+# include <fcntl.h>
	271	+# endif
	272	+
	273	+#endif
	274	+
	275	+#include <stddef.h>
	276	+
	277	+#ifndef offsetof
	278	+# define offsetof(type, member) ((size_t)(&((type *)0)->member))
	279	+#endif
	280	+
	281	+#ifndef O_NONBLOCK
	282	+# define O_NONBLOCK O_NDELAY
	283	+#endif
	284	+
	285	+/* include Python's addrinfo.h unless it causes trouble */
	286	+#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
	287	+ /* Do not include addinfo.h on some newer IRIX versions.
	288	+ * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
	289	+ * for example, but not by 6.5.10.
	290	+ */
	291	+#elif defined(_MSC_VER) && _MSC_VER>1201
	292	+ /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
	293	+ * EAI_* constants are defined in (the already included) ws2tcpip.h.
	294	+ */
	295	+#else
	296	+# include "addrinfo.h"
	297	+#endif
	298	+
	299	+#ifndef HAVE_INET_PTON
	300	+int inet_pton(int af, const char src, void dst);
	301	+const char inet_ntop(int af, const void src, char *dst, socklen_t size);
	302	+#endif
	303	+
	304	+#ifdef __APPLE__
	305	+/* On OS X, getaddrinfo returns no error indication of lookup
	306	+ failure, so we must use the emulation instead of the libinfo
	307	+ implementation. Unfortunately, performing an autoconf test
	308	+ for this bug would require DNS access for the machine performing
	309	+ the configuration, which is not acceptable. Therefore, we
	310	+ determine the bug just by checking for __APPLE__. If this bug
	311	+ gets ever fixed, perhaps checking for sys/version.h would be
	312	+ appropriate, which is 10/0 on the system with the bug. */
	313	+#ifndef HAVE_GETNAMEINFO
	314	+/* This bug seems to be fixed in Jaguar. Ths easiest way I could
	315	+ Find to check for Jaguar is that it has getnameinfo(), which
	316	+ older releases don't have */
	317	+#undef HAVE_GETADDRINFO
	318	+#endif
	319	+
	320	+#ifdef HAVE_INET_ATON
	321	+#define USE_INET_ATON_WEAKLINK
	322	+#endif
	323	+
	324	+#endif
	325	+
	326	+/* I know this is a bad practice, but it is the easiest... */
	327	+#if !defined(HAVE_GETADDRINFO)
	328	+/* avoid clashes with the C library definition of the symbol. */
	329	+#define getaddrinfo fake_getaddrinfo
	330	+#define gai_strerror fake_gai_strerror
	331	+#define freeaddrinfo fake_freeaddrinfo
	332	+#include "getaddrinfo.c"
	333	+#endif
	334	+#if !defined(HAVE_GETNAMEINFO)
	335	+#define getnameinfo fake_getnameinfo
	336	+#include "getnameinfo.c"
	337	+#endif
	338	+
	339	+#if defined(MS_WINDOWS) \|\| defined(__BEOS__)
	340	+/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
	341	+/* seem to be a few differences in the API */
	342	+#define SOCKETCLOSE closesocket
	343	+#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
	344	+#endif
	345	+
	346	+#ifdef MS_WIN32
	347	+#define EAFNOSUPPORT WSAEAFNOSUPPORT
	348	+#define snprintf _snprintf
	349	+#endif
	350	+
	351	+#if defined(PYOS_OS2) && !defined(PYCC_GCC)
	352	+#define SOCKETCLOSE soclose
	353	+#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
	354	+#endif
	355	+
	356	+#ifndef SOCKETCLOSE
	357	+#define SOCKETCLOSE close
	358	+#endif
	359	+
	360	+#if defined(HAVE_BLUETOOTH_H) \|\| defined(HAVE_BLUETOOTH_BLUETOOTH_H)
	361	+#define USE_BLUETOOTH 1
	362	+#if defined(__FreeBSD__)
	363	+#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
	364	+#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
	365	+#define sockaddr_l2 sockaddr_l2cap
	366	+#define sockaddr_rc sockaddr_rfcomm
	367	+#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
	368	+#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
	369	+#elif defined(__NetBSD__)
	370	+#define sockaddr_l2 sockaddr_bt
	371	+#define sockaddr_rc sockaddr_bt
	372	+#define sockaddr_sco sockaddr_bt
	373	+#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
	374	+#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
	375	+#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
	376	+#else
	377	+#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
	378	+#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
	379	+#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
	380	+#endif
	381	+#endif
	382	+
	383	+#ifdef __VMS
	384	+/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
	385	+#define SEGMENT_SIZE (32 * 1024 -1)
	386	+#endif
	387	+
	388	+#define SAS2SA(x) ((struct sockaddr *)(x))
	389	+
	390	+/*
	391	+ * Constants for getnameinfo()
	392	+ */
	393	+#if !defined(NI_MAXHOST)
	394	+#define NI_MAXHOST 1025
	395	+#endif
	396	+#if !defined(NI_MAXSERV)
	397	+#define NI_MAXSERV 32
	398	+#endif
	399	+
	400	+/* XXX There's a problem here: static functions are not supposed to have
	401	+ a Py prefix (or use CapitalizedWords). Later... */
	402	+
	403	+/* Global variable holding the exception type for errors detected
	404	+ by this module (but not argument type or memory errors, etc.). */
	405	+static PyObject *socket_error;
	406	+static PyObject *socket_herror;
	407	+static PyObject *socket_gaierror;
	408	+static PyObject *socket_timeout;
	409	+
	410	+#ifdef RISCOS
	411	+/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
	412	+static int taskwindow;
	413	+#endif
	414	+
	415	+/* A forward reference to the socket type object.
	416	+ The sock_type variable contains pointers to various functions,
	417	+ some of which call new_sockobject(), which uses sock_type, so
	418	+ there has to be a circular reference. */
	419	+static PyTypeObject sock_type;
	420	+
	421	+#if defined(HAVE_POLL_H)
	422	+#include <poll.h>
	423	+#elif defined(HAVE_SYS_POLL_H)
	424	+#include <sys/poll.h>
	425	+#endif
	426	+
	427	+#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
	428	+/* Platform can select file descriptors beyond FD_SETSIZE */
	429	+#define IS_SELECTABLE(s) 1
	430	+#elif defined(HAVE_POLL)
	431	+/* Instead of select(), we'll use poll() since poll() works on any fd. */
	432	+#define IS_SELECTABLE(s) 1
	433	+/* Can we call select() with this socket without a buffer overrun? */
	434	+#else
	435	+/* POSIX says selecting file descriptors beyond FD_SETSIZE
	436	+ has undefined behaviour. If there's no timeout left, we don't have to
	437	+ call select, so it's a safe, little white lie. */
	438	+#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE \|\| s->sock_timeout <= 0.0)
	439	+#endif
	440	+
	441	+static PyObject*
	442	+select_error(void)
	443	+{
	444	+ PyErr_SetString(socket_error, "unable to select on socket");
	445	+ return NULL;
	446	+}
	447	+
	448	+/* Convenience function to raise an error according to errno
	449	+ and return a NULL pointer from a function. */
	450	+
	451	+static PyObject *
	452	+set_error(void)
	453	+{
	454	+#ifdef MS_WINDOWS
	455	+ int err_no = WSAGetLastError();
	456	+ static struct {
	457	+ int no;
	458	+ const char *msg;
	459	+ } *msgp, msgs[] = {
	460	+ {WSAEINTR, "Interrupted system call"},
	461	+ {WSAEBADF, "Bad file descriptor"},
	462	+ {WSAEACCES, "Permission denied"},
	463	+ {WSAEFAULT, "Bad address"},
	464	+ {WSAEINVAL, "Invalid argument"},
	465	+ {WSAEMFILE, "Too many open files"},
	466	+ {WSAEWOULDBLOCK,
	467	+ "The socket operation could not complete "
	468	+ "without blocking"},
	469	+ {WSAEINPROGRESS, "Operation now in progress"},
	470	+ {WSAEALREADY, "Operation already in progress"},
	471	+ {WSAENOTSOCK, "Socket operation on non-socket"},
	472	+ {WSAEDESTADDRREQ, "Destination address required"},
	473	+ {WSAEMSGSIZE, "Message too long"},
	474	+ {WSAEPROTOTYPE, "Protocol wrong type for socket"},
	475	+ {WSAENOPROTOOPT, "Protocol not available"},
	476	+ {WSAEPROTONOSUPPORT, "Protocol not supported"},
	477	+ {WSAESOCKTNOSUPPORT, "Socket type not supported"},
	478	+ {WSAEOPNOTSUPP, "Operation not supported"},
	479	+ {WSAEPFNOSUPPORT, "Protocol family not supported"},
	480	+ {WSAEAFNOSUPPORT, "Address family not supported"},
	481	+ {WSAEADDRINUSE, "Address already in use"},
	482	+ {WSAEADDRNOTAVAIL, "Can't assign requested address"},
	483	+ {WSAENETDOWN, "Network is down"},
	484	+ {WSAENETUNREACH, "Network is unreachable"},
	485	+ {WSAENETRESET, "Network dropped connection on reset"},
	486	+ {WSAECONNABORTED, "Software caused connection abort"},
	487	+ {WSAECONNRESET, "Connection reset by peer"},
	488	+ {WSAENOBUFS, "No buffer space available"},
	489	+ {WSAEISCONN, "Socket is already connected"},
	490	+ {WSAENOTCONN, "Socket is not connected"},
	491	+ {WSAESHUTDOWN, "Can't send after socket shutdown"},
	492	+ {WSAETOOMANYREFS, "Too many references: can't splice"},
	493	+ {WSAETIMEDOUT, "Operation timed out"},
	494	+ {WSAECONNREFUSED, "Connection refused"},
	495	+ {WSAELOOP, "Too many levels of symbolic links"},
	496	+ {WSAENAMETOOLONG, "File name too long"},
	497	+ {WSAEHOSTDOWN, "Host is down"},
	498	+ {WSAEHOSTUNREACH, "No route to host"},
	499	+ {WSAENOTEMPTY, "Directory not empty"},
	500	+ {WSAEPROCLIM, "Too many processes"},
	501	+ {WSAEUSERS, "Too many users"},
	502	+ {WSAEDQUOT, "Disc quota exceeded"},
	503	+ {WSAESTALE, "Stale NFS file handle"},
	504	+ {WSAEREMOTE, "Too many levels of remote in path"},
	505	+ {WSASYSNOTREADY, "Network subsystem is unvailable"},
	506	+ {WSAVERNOTSUPPORTED, "WinSock version is not supported"},
	507	+ {WSANOTINITIALISED,
	508	+ "Successful WSAStartup() not yet performed"},
	509	+ {WSAEDISCON, "Graceful shutdown in progress"},
	510	+ /* Resolver errors */
	511	+ {WSAHOST_NOT_FOUND, "No such host is known"},
	512	+ {WSATRY_AGAIN, "Host not found, or server failed"},
	513	+ {WSANO_RECOVERY, "Unexpected server error encountered"},
	514	+ {WSANO_DATA, "Valid name without requested data"},
	515	+ {WSANO_ADDRESS, "No address, look for MX record"},
	516	+ {0, NULL}
	517	+ };
	518	+ if (err_no) {
	519	+ PyObject *v;
	520	+ const char *msg = "winsock error";
	521	+
	522	+ for (msgp = msgs; msgp->msg; msgp++) {
	523	+ if (err_no == msgp->no) {
	524	+ msg = msgp->msg;
	525	+ break;
	526	+ }
	527	+ }
	528	+
	529	+ v = Py_BuildValue("(is)", err_no, msg);
	530	+ if (v != NULL) {
	531	+ PyErr_SetObject(socket_error, v);
	532	+ Py_DECREF(v);
	533	+ }
	534	+ return NULL;
	535	+ }
	536	+ else
	537	+#endif
	538	+
	539	+#if defined(PYOS_OS2) && !defined(PYCC_GCC)
	540	+ if (sock_errno() != NO_ERROR) {
	541	+ APIRET rc;
	542	+ ULONG msglen;
	543	+ char outbuf[100];
	544	+ int myerrorcode = sock_errno();
	545	+
	546	+ /* Retrieve socket-related error message from MPTN.MSG file */
	547	+ rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
	548	+ myerrorcode - SOCBASEERR + 26,
	549	+ "mptn.msg",
	550	+ &msglen);
	551	+ if (rc == NO_ERROR) {
	552	+ PyObject *v;
	553	+
	554	+ /* OS/2 doesn't guarantee a terminator */
	555	+ outbuf[msglen] = '\0';
	556	+ if (strlen(outbuf) > 0) {
	557	+ /* If non-empty msg, trim CRLF */
	558	+ char *lastc = &outbuf[ strlen(outbuf)-1 ];
	559	+ while (lastc > outbuf &&
	560	+ isspace(Py_CHARMASK(*lastc))) {
	561	+ /* Trim trailing whitespace (CRLF) */
	562	+ *lastc-- = '\0';
	563	+ }
	564	+ }
	565	+ v = Py_BuildValue("(is)", myerrorcode, outbuf);
	566	+ if (v != NULL) {
	567	+ PyErr_SetObject(socket_error, v);
	568	+ Py_DECREF(v);
	569	+ }
	570	+ return NULL;
	571	+ }
	572	+ }
	573	+#endif
	574	+
	575	+#if defined(RISCOS)
	576	+ if (_inet_error.errnum != NULL) {
	577	+ PyObject *v;
	578	+ v = Py_BuildValue("(is)", errno, _inet_err());
	579	+ if (v != NULL) {
	580	+ PyErr_SetObject(socket_error, v);
	581	+ Py_DECREF(v);
	582	+ }
	583	+ return NULL;
	584	+ }
	585	+#endif
	586	+
	587	+ return PyErr_SetFromErrno(socket_error);
	588	+}
	589	+
	590	+
	591	+static PyObject *
	592	+set_herror(int h_error)
	593	+{
	594	+ PyObject *v;
	595	+
	596	+#ifdef HAVE_HSTRERROR
	597	+ v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
	598	+#else
	599	+ v = Py_BuildValue("(is)", h_error, "host not found");
	600	+#endif
	601	+ if (v != NULL) {
	602	+ PyErr_SetObject(socket_herror, v);
	603	+ Py_DECREF(v);
	604	+ }
	605	+
	606	+ return NULL;
	607	+}
	608	+
	609	+
	610	+static PyObject *
	611	+set_gaierror(int error)
	612	+{
	613	+ PyObject *v;
	614	+
	615	+#ifdef EAI_SYSTEM
	616	+ /* EAI_SYSTEM is not available on Windows XP. */
	617	+ if (error == EAI_SYSTEM)
	618	+ return set_error();
	619	+#endif
	620	+
	621	+#ifdef HAVE_GAI_STRERROR
	622	+ v = Py_BuildValue("(is)", error, gai_strerror(error));
	623	+#else
	624	+ v = Py_BuildValue("(is)", error, "getaddrinfo failed");
	625	+#endif
	626	+ if (v != NULL) {
	627	+ PyErr_SetObject(socket_gaierror, v);
	628	+ Py_DECREF(v);
	629	+ }
	630	+
	631	+ return NULL;
	632	+}
	633	+
	634	+#ifdef __VMS
	635	+/* Function to send in segments */
	636	+static int
	637	+sendsegmented(int sock_fd, char *buf, int len, int flags)
	638	+{
	639	+ int n = 0;
	640	+ int remaining = len;
	641	+
	642	+ while (remaining > 0) {
	643	+ unsigned int segment;
	644	+
	645	+ segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
	646	+ n = send(sock_fd, buf, segment, flags);
	647	+ if (n < 0) {
	648	+ return n;
	649	+ }
	650	+ remaining -= segment;
	651	+ buf += segment;
	652	+ } /* end while */
	653	+
	654	+ return len;
	655	+}
	656	+#endif
	657	+
	658	+/* Function to perform the setting of socket blocking mode
	659	+ internally. block = (1 \| 0). */
	660	+static int
	661	+internal_setblocking(PySocketSockObject *s, int block)
	662	+{
	663	+#ifndef RISCOS
	664	+#ifndef MS_WINDOWS
	665	+ int delay_flag;
	666	+#endif
	667	+#endif
	668	+
	669	+ Py_BEGIN_ALLOW_THREADS
	670	+#ifdef __BEOS__
	671	+ block = !block;
	672	+ setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
	673	+ (void *)(&block), sizeof(int));
	674	+#else
	675	+#ifndef RISCOS
	676	+#ifndef MS_WINDOWS
	677	+#if defined(PYOS_OS2) && !defined(PYCC_GCC)
	678	+ block = !block;
	679	+ ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
	680	+#elif defined(__VMS)
	681	+ block = !block;
	682	+ ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
	683	+#else /* !PYOS_OS2 && !__VMS */
	684	+ delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
	685	+ if (block)
	686	+ delay_flag &= (~O_NONBLOCK);
	687	+ else
	688	+ delay_flag \|= O_NONBLOCK;
	689	+ fcntl(s->sock_fd, F_SETFL, delay_flag);
	690	+#endif /* !PYOS_OS2 */
	691	+#else /* MS_WINDOWS */
	692	+ block = !block;
	693	+ ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
	694	+#endif /* MS_WINDOWS */
	695	+#else /* RISCOS */
	696	+ block = !block;
	697	+ socketioctl(s->sock_fd, FIONBIO, (u_long*)&block);
	698	+#endif /* RISCOS */
	699	+#endif /* __BEOS__ */
	700	+ Py_END_ALLOW_THREADS
	701	+
	702	+ /* Since these don't return anything */
	703	+ return 1;
	704	+}
	705	+
	706	+/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
	707	+ The argument writing indicates the direction.
	708	+ This does not raise an exception; we'll let our caller do that
	709	+ after they've reacquired the interpreter lock.
	710	+ Returns 1 on timeout, -1 on error, 0 otherwise. */
	711	+static int
	712	+internal_select(PySocketSockObject *s, int writing)
	713	+{
	714	+ int n;
	715	+
	716	+ /* Nothing to do unless we're in timeout mode (not non-blocking) */
	717	+ if (s->sock_timeout <= 0.0)
	718	+ return 0;
	719	+
	720	+ /* Guard against closed socket */
	721	+ if (s->sock_fd < 0)
	722	+ return 0;
	723	+
	724	+ /* Prefer poll, if available, since you can poll() any fd
	725	+ * which can't be done with select(). */
	726	+#ifdef HAVE_POLL
	727	+ {
	728	+ struct pollfd pollfd;
	729	+ int timeout;
	730	+
	731	+ pollfd.fd = s->sock_fd;
	732	+ pollfd.events = writing ? POLLOUT : POLLIN;
	733	+
	734	+ /* s->sock_timeout is in seconds, timeout in ms */
	735	+ timeout = (int)(s->sock_timeout * 1000 + 0.5);
	736	+ n = poll(&pollfd, 1, timeout);
	737	+ }
	738	+#else
	739	+ {
	740	+ /* Construct the arguments to select */
	741	+ fd_set fds;
	742	+ struct timeval tv;
	743	+ tv.tv_sec = (int)s->sock_timeout;
	744	+ tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
	745	+ FD_ZERO(&fds);
	746	+ FD_SET(s->sock_fd, &fds);
	747	+
	748	+ /* See if the socket is ready */
	749	+ if (writing)
	750	+ n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
	751	+ else
	752	+ n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
	753	+ }
	754	+#endif
	755	+
	756	+ if (n < 0)
	757	+ return -1;
	758	+ if (n == 0)
	759	+ return 1;
	760	+ return 0;
	761	+}
	762	+
	763	+/* Initialize a new socket object. */
	764	+
	765	+static double defaulttimeout = -1.0; /* Default timeout for new sockets */
	766	+
	767	+PyMODINIT_FUNC
	768	+init_sockobject(PySocketSockObject *s,
	769	+ SOCKET_T fd, int family, int type, int proto)
	770	+{
	771	+#ifdef RISCOS
	772	+ int block = 1;
	773	+#endif
	774	+ s->sock_fd = fd;
	775	+ s->sock_family = family;
	776	+ s->sock_type = type;
	777	+ s->sock_proto = proto;
	778	+ s->sock_timeout = defaulttimeout;
	779	+
	780	+ s->errorhandler = &set_error;
	781	+
	782	+ if (defaulttimeout >= 0.0)
	783	+ internal_setblocking(s, 0);
	784	+
	785	+#ifdef RISCOS
	786	+ if (taskwindow)
	787	+ socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
	788	+#endif
	789	+}
	790	+
	791	+
	792	+/* Create a new socket object.
	793	+ This just creates the object and initializes it.
	794	+ If the creation fails, return NULL and set an exception (implicit
	795	+ in NEWOBJ()). */
	796	+
	797	+static PySocketSockObject *
	798	+new_sockobject(SOCKET_T fd, int family, int type, int proto)
	799	+{
	800	+ PySocketSockObject *s;
	801	+ s = (PySocketSockObject *)
	802	+ PyType_GenericNew(&sock_type, NULL, NULL);
	803	+ if (s != NULL)
	804	+ init_sockobject(s, fd, family, type, proto);
	805	+ return s;
	806	+}
	807	+
	808	+
	809	+/* Lock to allow python interpreter to continue, but only allow one
	810	+ thread to be in gethostbyname or getaddrinfo */
	811	+#if defined(USE_GETHOSTBYNAME_LOCK) \|\| defined(USE_GETADDRINFO_LOCK)
	812	+PyThread_type_lock netdb_lock;
	813	+#endif
	814	+
	815	+
	816	+/* Convert a string specifying a host name or one of a few symbolic
	817	+ names to a numeric IP address. This usually calls gethostbyname()
	818	+ to do the work; the names "" and "<broadcast>" are special.
	819	+ Return the length (IPv4 should be 4 bytes), or negative if
	820	+ an error occurred; then an exception is raised. */
	821	+
	822	+static int
	823	+setipaddr(char name, struct sockaddr addr_ret, size_t addr_ret_size, int af)
	824	+{
	825	+ struct addrinfo hints, *res;
	826	+ int error;
	827	+ int d1, d2, d3, d4;
	828	+ char ch;
	829	+
	830	+ memset((void *) addr_ret, '\0', addr_ret_size);
	831	+ if (name[0] == '\0') {
	832	+ int siz;
	833	+ memset(&hints, 0, sizeof(hints));
	834	+ hints.ai_family = af;
	835	+ hints.ai_socktype = SOCK_DGRAM; /dummy/
	836	+ hints.ai_flags = AI_PASSIVE;
	837	+ Py_BEGIN_ALLOW_THREADS
	838	+ ACQUIRE_GETADDRINFO_LOCK
	839	+ error = getaddrinfo(NULL, "0", &hints, &res);
	840	+ Py_END_ALLOW_THREADS
	841	+ /* We assume that those thread-unsafe getaddrinfo() versions
	842	+ are safe regarding their return value, ie. that a
	843	+ subsequent call to getaddrinfo() does not destroy the
	844	+ outcome of the first call. */
	845	+ RELEASE_GETADDRINFO_LOCK
	846	+ if (error) {
	847	+ set_gaierror(error);
	848	+ return -1;
	849	+ }
	850	+ switch (res->ai_family) {
	851	+ case AF_INET:
	852	+ siz = 4;
	853	+ break;
	854	+#ifdef ENABLE_IPV6
	855	+ case AF_INET6:
	856	+ siz = 16;
	857	+ break;
	858	+#endif
	859	+ default:
	860	+ freeaddrinfo(res);
	861	+ PyErr_SetString(socket_error,
	862	+ "unsupported address family");
	863	+ return -1;
	864	+ }
	865	+ if (res->ai_next) {
	866	+ freeaddrinfo(res);
	867	+ PyErr_SetString(socket_error,
	868	+ "wildcard resolved to multiple address");
	869	+ return -1;
	870	+ }
	871	+ if (res->ai_addrlen < addr_ret_size)
	872	+ addr_ret_size = res->ai_addrlen;
	873	+ memcpy(addr_ret, res->ai_addr, addr_ret_size);
	874	+ freeaddrinfo(res);
	875	+ return siz;
	876	+ }
	877	+ if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
	878	+ struct sockaddr_in *sin;
	879	+ if (af != AF_INET && af != AF_UNSPEC) {
	880	+ PyErr_SetString(socket_error,
	881	+ "address family mismatched");
	882	+ return -1;
	883	+ }
	884	+ sin = (struct sockaddr_in *)addr_ret;
	885	+ memset((void ) sin, '\0', sizeof(sin));
	886	+ sin->sin_family = AF_INET;
	887	+#ifdef HAVE_SOCKADDR_SA_LEN
	888	+ sin->sin_len = sizeof(*sin);
	889	+#endif
	890	+ sin->sin_addr.s_addr = INADDR_BROADCAST;
	891	+ return sizeof(sin->sin_addr);
	892	+ }
	893	+ if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
	894	+ 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
	895	+ 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
	896	+ struct sockaddr_in *sin;
	897	+ sin = (struct sockaddr_in *)addr_ret;
	898	+ sin->sin_addr.s_addr = htonl(
	899	+ ((long) d1 << 24) \| ((long) d2 << 16) \|
	900	+ ((long) d3 << 8) \| ((long) d4 << 0));
	901	+ sin->sin_family = AF_INET;
	902	+#ifdef HAVE_SOCKADDR_SA_LEN
	903	+ sin->sin_len = sizeof(*sin);
	904	+#endif
	905	+ return 4;
	906	+ }
	907	+ memset(&hints, 0, sizeof(hints));
	908	+ hints.ai_family = af;
	909	+ Py_BEGIN_ALLOW_THREADS
	910	+ ACQUIRE_GETADDRINFO_LOCK
	911	+ error = getaddrinfo(name, NULL, &hints, &res);
	912	+#if defined(__digital__) && defined(__unix__)
	913	+ if (error == EAI_NONAME && af == AF_UNSPEC) {
	914	+ /* On Tru64 V5.1, numeric-to-addr conversion fails
	915	+ if no address family is given. Assume IPv4 for now.*/
	916	+ hints.ai_family = AF_INET;
	917	+ error = getaddrinfo(name, NULL, &hints, &res);
	918	+ }
	919	+#endif
	920	+ Py_END_ALLOW_THREADS
	921	+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
	922	+ if (error) {
	923	+ set_gaierror(error);
	924	+ return -1;
	925	+ }
	926	+ if (res->ai_addrlen < addr_ret_size)
	927	+ addr_ret_size = res->ai_addrlen;
	928	+ memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
	929	+ freeaddrinfo(res);
	930	+ switch (addr_ret->sa_family) {
	931	+ case AF_INET:
	932	+ return 4;
	933	+#ifdef ENABLE_IPV6
	934	+ case AF_INET6:
	935	+ return 16;
	936	+#endif
	937	+ default:
	938	+ PyErr_SetString(socket_error, "unknown address family");
	939	+ return -1;
	940	+ }
	941	+}
	942	+
	943	+
	944	+/* Create a string object representing an IP address.
	945	+ This is always a string of the form 'dd.dd.dd.dd' (with variable
	946	+ size numbers). */
	947	+
	948	+static PyObject *
	949	+makeipaddr(struct sockaddr *addr, int addrlen)
	950	+{
	951	+ char buf[NI_MAXHOST];
	952	+ int error;
	953	+
	954	+ error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
	955	+ NI_NUMERICHOST);
	956	+ if (error) {
	957	+ set_gaierror(error);
	958	+ return NULL;
	959	+ }
	960	+ return PyString_FromString(buf);
	961	+}
	962	+
	963	+
	964	+#ifdef USE_BLUETOOTH
	965	+/* Convert a string representation of a Bluetooth address into a numeric
	966	+ address. Returns the length (6), or raises an exception and returns -1 if
	967	+ an error occurred. */
	968	+
	969	+static int
	970	+setbdaddr(char name, bdaddr_t bdaddr)
	971	+{
	972	+ unsigned int b0, b1, b2, b3, b4, b5;
	973	+ char ch;
	974	+ int n;
	975	+
	976	+ n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
	977	+ &b5, &b4, &b3, &b2, &b1, &b0, &ch);
	978	+ if (n == 6 && (b0 \| b1 \| b2 \| b3 \| b4 \| b5) < 256) {
	979	+ bdaddr->b[0] = b0;
	980	+ bdaddr->b[1] = b1;
	981	+ bdaddr->b[2] = b2;
	982	+ bdaddr->b[3] = b3;
	983	+ bdaddr->b[4] = b4;
	984	+ bdaddr->b[5] = b5;
	985	+ return 6;
	986	+ } else {
	987	+ PyErr_SetString(socket_error, "bad bluetooth address");
	988	+ return -1;
	989	+ }
	990	+}
	991	+
	992	+/* Create a string representation of the Bluetooth address. This is always a
	993	+ string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
	994	+ value (zero padded if necessary). */
	995	+
	996	+static PyObject *
	997	+makebdaddr(bdaddr_t *bdaddr)
	998	+{
	999	+ char buf[(6 * 2) + 5 + 1];
	1000	+
	1001	+ sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
	1002	+ bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
	1003	+ bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
	1004	+ return PyString_FromString(buf);
	1005	+}
	1006	+#endif
	1007	+
	1008	+
	1009	+/* Create an object representing the given socket address,
	1010	+ suitable for passing it back to bind(), connect() etc.
	1011	+ The family field of the sockaddr structure is inspected
	1012	+ to determine what kind of address it really is. */
	1013	+
	1014	+/ARGSUSED/
	1015	+static PyObject *
	1016	+makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
	1017	+{
	1018	+ if (addrlen == 0) {
	1019	+ /* No address -- may be recvfrom() from known socket */
	1020	+ Py_INCREF(Py_None);
	1021	+ return Py_None;
	1022	+ }
	1023	+
	1024	+#ifdef __BEOS__
	1025	+ /* XXX: BeOS version of accept() doesn't set family correctly */
	1026	+ addr->sa_family = AF_INET;
	1027	+#endif
	1028	+
	1029	+ switch (addr->sa_family) {
	1030	+
	1031	+ case AF_INET:
	1032	+ {
	1033	+ struct sockaddr_in *a;
	1034	+ PyObject addrobj = makeipaddr(addr, sizeof(a));
	1035	+ PyObject *ret = NULL;
	1036	+ if (addrobj) {
	1037	+ a = (struct sockaddr_in *)addr;
	1038	+ ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
	1039	+ Py_DECREF(addrobj);
	1040	+ }
	1041	+ return ret;
	1042	+ }
	1043	+
	1044	+#if defined(AF_UNIX)
	1045	+ case AF_UNIX:
	1046	+ {
	1047	+ struct sockaddr_un a = (struct sockaddr_un ) addr;
	1048	+#ifdef linux
	1049	+ if (a->sun_path[0] == 0) { /* Linux abstract namespace */
	1050	+ addrlen -= (sizeof(*a) - sizeof(a->sun_path));
	1051	+ return PyString_FromStringAndSize(a->sun_path,
	1052	+ addrlen);
	1053	+ }
	1054	+ else
	1055	+#endif /* linux */
	1056	+ {
	1057	+ /* regular NULL-terminated string */
	1058	+ return PyString_FromString(a->sun_path);
	1059	+ }
	1060	+ }
	1061	+#endif /* AF_UNIX */
	1062	+
	1063	+#if defined(AF_NETLINK)
	1064	+ case AF_NETLINK:
	1065	+ {
	1066	+ struct sockaddr_nl a = (struct sockaddr_nl ) addr;
	1067	+ return Py_BuildValue("II", a->nl_pid, a->nl_groups);
	1068	+ }
	1069	+#endif /* AF_NETLINK */
	1070	+
	1071	+#ifdef ENABLE_IPV6
	1072	+ case AF_INET6:
	1073	+ {
	1074	+ struct sockaddr_in6 *a;
	1075	+ PyObject addrobj = makeipaddr(addr, sizeof(a));
	1076	+ PyObject *ret = NULL;
	1077	+ if (addrobj) {
	1078	+ a = (struct sockaddr_in6 *)addr;
	1079	+ ret = Py_BuildValue("Oiii",
	1080	+ addrobj,
	1081	+ ntohs(a->sin6_port),
	1082	+ a->sin6_flowinfo,
	1083	+ a->sin6_scope_id);
	1084	+ Py_DECREF(addrobj);
	1085	+ }
	1086	+ return ret;
	1087	+ }
	1088	+#endif
	1089	+
	1090	+#ifdef USE_BLUETOOTH
	1091	+ case AF_BLUETOOTH:
	1092	+ switch (proto) {
	1093	+
	1094	+ case BTPROTO_L2CAP:
	1095	+ {
	1096	+ struct sockaddr_l2 a = (struct sockaddr_l2 ) addr;
	1097	+ PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
	1098	+ PyObject *ret = NULL;
	1099	+ if (addrobj) {
	1100	+ ret = Py_BuildValue("Oi",
	1101	+ addrobj,
	1102	+ _BT_L2_MEMB(a, psm));
	1103	+ Py_DECREF(addrobj);
	1104	+ }
	1105	+ return ret;
	1106	+ }
	1107	+
	1108	+ case BTPROTO_RFCOMM:
	1109	+ {
	1110	+ struct sockaddr_rc a = (struct sockaddr_rc ) addr;
	1111	+ PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
	1112	+ PyObject *ret = NULL;
	1113	+ if (addrobj) {
	1114	+ ret = Py_BuildValue("Oi",
	1115	+ addrobj,
	1116	+ _BT_RC_MEMB(a, channel));
	1117	+ Py_DECREF(addrobj);
	1118	+ }
	1119	+ return ret;
	1120	+ }
	1121	+
	1122	+#if !defined(__FreeBSD__)
	1123	+ case BTPROTO_SCO:
	1124	+ {
	1125	+ struct sockaddr_sco a = (struct sockaddr_sco ) addr;
	1126	+ return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
	1127	+ }
	1128	+#endif
	1129	+
	1130	+ }
	1131	+#endif
	1132	+
	1133	+#ifdef HAVE_NETPACKET_PACKET_H
	1134	+ case AF_PACKET:
	1135	+ {
	1136	+ struct sockaddr_ll a = (struct sockaddr_ll )addr;
	1137	+ char *ifname = "";
	1138	+ struct ifreq ifr;
	1139	+ /* need to look up interface name give index */
	1140	+ if (a->sll_ifindex) {
	1141	+ ifr.ifr_ifindex = a->sll_ifindex;
	1142	+ if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
	1143	+ ifname = ifr.ifr_name;
	1144	+ }
	1145	+ return Py_BuildValue("shbhs#",
	1146	+ ifname,
	1147	+ ntohs(a->sll_protocol),
	1148	+ a->sll_pkttype,
	1149	+ a->sll_hatype,
	1150	+ a->sll_addr,
	1151	+ a->sll_halen);
	1152	+ }
	1153	+#endif
	1154	+
	1155	+ /* More cases here... */
	1156	+
	1157	+ default:
	1158	+ /* If we don't know the address family, don't raise an
	1159	+ exception -- return it as a tuple. */
	1160	+ return Py_BuildValue("is#",
	1161	+ addr->sa_family,
	1162	+ addr->sa_data,
	1163	+ sizeof(addr->sa_data));
	1164	+
	1165	+ }
	1166	+}
	1167	+
	1168	+
	1169	+/* Parse a socket address argument according to the socket object's
	1170	+ address family. Return 1 if the address was in the proper format,
	1171	+ 0 of not. The address is returned through addr_ret, its length
	1172	+ through len_ret. */
	1173	+
	1174	+static int
	1175	+getsockaddrarg(PySocketSockObject s, PyObject args,
	1176	+ struct sockaddr addr_ret, int len_ret)
	1177	+{
	1178	+ switch (s->sock_family) {
	1179	+
	1180	+#if defined(AF_UNIX)
	1181	+ case AF_UNIX:
	1182	+ {
	1183	+ struct sockaddr_un* addr;
	1184	+ char *path;
	1185	+ int len;
	1186	+ if (!PyArg_Parse(args, "t#", &path, &len))
	1187	+ return 0;
	1188	+
	1189	+ addr = (struct sockaddr_un*)addr_ret;
	1190	+#ifdef linux
	1191	+ if (len > 0 && path[0] == 0) {
	1192	+ /* Linux abstract namespace extension */
	1193	+ if (len > sizeof addr->sun_path) {
	1194	+ PyErr_SetString(socket_error,
	1195	+ "AF_UNIX path too long");
	1196	+ return 0;
	1197	+ }
	1198	+ }
	1199	+ else
	1200	+#endif /* linux */
	1201	+ {
	1202	+ /* regular NULL-terminated string */
	1203	+ if (len >= sizeof addr->sun_path) {
	1204	+ PyErr_SetString(socket_error,
	1205	+ "AF_UNIX path too long");
	1206	+ return 0;
	1207	+ }
	1208	+ addr->sun_path[len] = 0;
	1209	+ }
	1210	+ addr->sun_family = s->sock_family;
	1211	+ memcpy(addr->sun_path, path, len);
	1212	+#if defined(PYOS_OS2)
	1213	+ len_ret = sizeof(addr);
	1214	+#else
	1215	+ len_ret = len + sizeof(addr) - sizeof(addr->sun_path);
	1216	+#endif
	1217	+ return 1;
	1218	+ }
	1219	+#endif /* AF_UNIX */
	1220	+
	1221	+#if defined(AF_NETLINK)
	1222	+ case AF_NETLINK:
	1223	+ {
	1224	+ struct sockaddr_nl* addr;
	1225	+ int pid, groups;
	1226	+ addr = (struct sockaddr_nl *)addr_ret;
	1227	+ if (!PyTuple_Check(args)) {
	1228	+ PyErr_Format(
	1229	+ PyExc_TypeError,
	1230	+ "getsockaddrarg: "
	1231	+ "AF_NETLINK address must be tuple, not %.500s",
	1232	+ args->ob_type->tp_name);
	1233	+ return 0;
	1234	+ }
	1235	+ if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
	1236	+ return 0;
	1237	+ addr->nl_family = AF_NETLINK;
	1238	+ addr->nl_pid = pid;
	1239	+ addr->nl_groups = groups;
	1240	+ len_ret = sizeof(addr);
	1241	+ return 1;
	1242	+ }
	1243	+#endif
	1244	+
	1245	+ case AF_INET:
	1246	+ {
	1247	+ struct sockaddr_in* addr;
	1248	+ char *host;
	1249	+ int port, result;
	1250	+ if (!PyTuple_Check(args)) {
	1251	+ PyErr_Format(
	1252	+ PyExc_TypeError,
	1253	+ "getsockaddrarg: "
	1254	+ "AF_INET address must be tuple, not %.500s",
	1255	+ args->ob_type->tp_name);
	1256	+ return 0;
	1257	+ }
	1258	+ if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
	1259	+ "idna", &host, &port))
	1260	+ return 0;
	1261	+ addr=(struct sockaddr_in*)addr_ret;
	1262	+ result = setipaddr(host, (struct sockaddr *)addr,
	1263	+ sizeof(*addr), AF_INET);
	1264	+ PyMem_Free(host);
	1265	+ if (result < 0)
	1266	+ return 0;
	1267	+ addr->sin_family = AF_INET;
	1268	+ addr->sin_port = htons((short)port);
	1269	+ len_ret = sizeof addr;
	1270	+ return 1;
	1271	+ }
	1272	+
	1273	+#ifdef ENABLE_IPV6
	1274	+ case AF_INET6:
	1275	+ {
	1276	+ struct sockaddr_in6* addr;
	1277	+ char *host;
	1278	+ int port, flowinfo, scope_id, result;
	1279	+ flowinfo = scope_id = 0;
	1280	+ if (!PyTuple_Check(args)) {
	1281	+ PyErr_Format(
	1282	+ PyExc_TypeError,
	1283	+ "getsockaddrarg: "
	1284	+ "AF_INET6 address must be tuple, not %.500s",
	1285	+ args->ob_type->tp_name);
	1286	+ return 0;
	1287	+ }
	1288	+ if (!PyArg_ParseTuple(args, "eti\|ii",
	1289	+ "idna", &host, &port, &flowinfo,
	1290	+ &scope_id)) {
	1291	+ return 0;
	1292	+ }
	1293	+ addr = (struct sockaddr_in6*)addr_ret;
	1294	+ result = setipaddr(host, (struct sockaddr *)addr,
	1295	+ sizeof(*addr), AF_INET6);
	1296	+ PyMem_Free(host);
	1297	+ if (result < 0)
	1298	+ return 0;
	1299	+ addr->sin6_family = s->sock_family;
	1300	+ addr->sin6_port = htons((short)port);
	1301	+ addr->sin6_flowinfo = flowinfo;
	1302	+ addr->sin6_scope_id = scope_id;
	1303	+ len_ret = sizeof addr;
	1304	+ return 1;
	1305	+ }
	1306	+#endif
	1307	+
	1308	+#ifdef USE_BLUETOOTH
	1309	+ case AF_BLUETOOTH:
	1310	+ {
	1311	+ switch (s->sock_proto) {
	1312	+ case BTPROTO_L2CAP:
	1313	+ {
	1314	+ struct sockaddr_l2 *addr;
	1315	+ char *straddr;
	1316	+
	1317	+ addr = (struct sockaddr_l2 *)addr_ret;
	1318	+ _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
	1319	+ if (!PyArg_ParseTuple(args, "si", &straddr,
	1320	+ &_BT_L2_MEMB(addr, psm))) {
	1321	+ PyErr_SetString(socket_error, "getsockaddrarg: "
	1322	+ "wrong format");
	1323	+ return 0;
	1324	+ }
	1325	+ if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
	1326	+ return 0;
	1327	+
	1328	+ len_ret = sizeof addr;
	1329	+ return 1;
	1330	+ }
	1331	+ case BTPROTO_RFCOMM:
	1332	+ {
	1333	+ struct sockaddr_rc *addr;
	1334	+ char *straddr;
	1335	+
	1336	+ addr = (struct sockaddr_rc *)addr_ret;
	1337	+ _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
	1338	+ if (!PyArg_ParseTuple(args, "si", &straddr,
	1339	+ &_BT_RC_MEMB(addr, channel))) {
	1340	+ PyErr_SetString(socket_error, "getsockaddrarg: "
	1341	+ "wrong format");
	1342	+ return 0;
	1343	+ }
	1344	+ if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
	1345	+ return 0;
	1346	+
	1347	+ len_ret = sizeof addr;
	1348	+ return 1;
	1349	+ }
	1350	+#if !defined(__FreeBSD__)
	1351	+ case BTPROTO_SCO:
	1352	+ {
	1353	+ struct sockaddr_sco *addr;
	1354	+ char *straddr;
	1355	+
	1356	+ addr = (struct sockaddr_sco *)addr_ret;
	1357	+ _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
	1358	+ straddr = PyString_AsString(args);
	1359	+ if (straddr == NULL) {
	1360	+ PyErr_SetString(socket_error, "getsockaddrarg: "
	1361	+ "wrong format");
	1362	+ return 0;
	1363	+ }
	1364	+ if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
	1365	+ return 0;
	1366	+
	1367	+ len_ret = sizeof addr;
	1368	+ return 1;
	1369	+ }
	1370	+#endif
	1371	+ default:
	1372	+ PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
	1373	+ return 0;
	1374	+ }
	1375	+ }
	1376	+#endif
	1377	+
	1378	+#ifdef HAVE_NETPACKET_PACKET_H
	1379	+ case AF_PACKET:
	1380	+ {
	1381	+ struct sockaddr_ll* addr;
	1382	+ struct ifreq ifr;
	1383	+ char *interfaceName;
	1384	+ int protoNumber;
	1385	+ int hatype = 0;
	1386	+ int pkttype = 0;
	1387	+ char *haddr = NULL;
	1388	+ unsigned int halen = 0;
	1389	+
	1390	+ if (!PyTuple_Check(args)) {
	1391	+ PyErr_Format(
	1392	+ PyExc_TypeError,
	1393	+ "getsockaddrarg: "
	1394	+ "AF_PACKET address must be tuple, not %.500s",
	1395	+ args->ob_type->tp_name);
	1396	+ return 0;
	1397	+ }
	1398	+ if (!PyArg_ParseTuple(args, "si\|iis#", &interfaceName,
	1399	+ &protoNumber, &pkttype, &hatype,
	1400	+ &haddr, &halen))
	1401	+ return 0;
	1402	+ strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
	1403	+ ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
	1404	+ if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
	1405	+ s->errorhandler();
	1406	+ return 0;
	1407	+ }
	1408	+ if (halen > 8) {
	1409	+ PyErr_SetString(PyExc_ValueError,
	1410	+ "Hardware address must be 8 bytes or less");
	1411	+ return 0;
	1412	+ }
	1413	+ addr = (struct sockaddr_ll*)addr_ret;
	1414	+ addr->sll_family = AF_PACKET;
	1415	+ addr->sll_protocol = htons((short)protoNumber);
	1416	+ addr->sll_ifindex = ifr.ifr_ifindex;
	1417	+ addr->sll_pkttype = pkttype;
	1418	+ addr->sll_hatype = hatype;
	1419	+ if (halen != 0) {
	1420	+ memcpy(&addr->sll_addr, haddr, halen);
	1421	+ }
	1422	+ addr->sll_halen = halen;
	1423	+ len_ret = sizeof addr;
	1424	+ return 1;
	1425	+ }
	1426	+#endif
	1427	+
	1428	+ /* More cases here... */
	1429	+
	1430	+ default:
	1431	+ PyErr_SetString(socket_error, "getsockaddrarg: bad family");
	1432	+ return 0;
	1433	+
	1434	+ }
	1435	+}
	1436	+
	1437	+
	1438	+/* Get the address length according to the socket object's address family.
	1439	+ Return 1 if the family is known, 0 otherwise. The length is returned
	1440	+ through len_ret. */
	1441	+
	1442	+static int
	1443	+getsockaddrlen(PySocketSockObject s, socklen_t len_ret)
	1444	+{
	1445	+ switch (s->sock_family) {
	1446	+
	1447	+#if defined(AF_UNIX)
	1448	+ case AF_UNIX:
	1449	+ {
	1450	+ *len_ret = sizeof (struct sockaddr_un);
	1451	+ return 1;
	1452	+ }
	1453	+#endif /* AF_UNIX */
	1454	+#if defined(AF_NETLINK)
	1455	+ case AF_NETLINK:
	1456	+ {
	1457	+ *len_ret = sizeof (struct sockaddr_nl);
	1458	+ return 1;
	1459	+ }
	1460	+#endif
	1461	+
	1462	+ case AF_INET:
	1463	+ {
	1464	+ *len_ret = sizeof (struct sockaddr_in);
	1465	+ return 1;
	1466	+ }
	1467	+
	1468	+#ifdef ENABLE_IPV6
	1469	+ case AF_INET6:
	1470	+ {
	1471	+ *len_ret = sizeof (struct sockaddr_in6);
	1472	+ return 1;
	1473	+ }
	1474	+#endif
	1475	+
	1476	+#ifdef USE_BLUETOOTH
	1477	+ case AF_BLUETOOTH:
	1478	+ {
	1479	+ switch(s->sock_proto)
	1480	+ {
	1481	+
	1482	+ case BTPROTO_L2CAP:
	1483	+ *len_ret = sizeof (struct sockaddr_l2);
	1484	+ return 1;
	1485	+ case BTPROTO_RFCOMM:
	1486	+ *len_ret = sizeof (struct sockaddr_rc);
	1487	+ return 1;
	1488	+#if !defined(__FreeBSD__)
	1489	+ case BTPROTO_SCO:
	1490	+ *len_ret = sizeof (struct sockaddr_sco);
	1491	+ return 1;
	1492	+#endif
	1493	+ default:
	1494	+ PyErr_SetString(socket_error, "getsockaddrlen: "
	1495	+ "unknown BT protocol");
	1496	+ return 0;
	1497	+
	1498	+ }
	1499	+ }
	1500	+#endif
	1501	+
	1502	+#ifdef HAVE_NETPACKET_PACKET_H
	1503	+ case AF_PACKET:
	1504	+ {
	1505	+ *len_ret = sizeof (struct sockaddr_ll);
	1506	+ return 1;
	1507	+ }
	1508	+#endif
	1509	+
	1510	+ /* More cases here... */
	1511	+
	1512	+ default:
	1513	+ PyErr_SetString(socket_error, "getsockaddrlen: bad family");
	1514	+ return 0;
	1515	+
	1516	+ }
	1517	+}
	1518	+
	1519	+
	1520	+/* s.accept() method */
	1521	+
	1522	+static PyObject *
	1523	+sock_accept(PySocketSockObject *s)
	1524	+{
	1525	+ sock_addr_t addrbuf;
	1526	+ SOCKET_T newfd;
	1527	+ socklen_t addrlen;
	1528	+ PyObject *sock = NULL;
	1529	+ PyObject *addr = NULL;
	1530	+ PyObject *res = NULL;
	1531	+ int timeout;
	1532	+
	1533	+ if (!getsockaddrlen(s, &addrlen))
	1534	+ return NULL;
	1535	+ memset(&addrbuf, 0, addrlen);
	1536	+
	1537	+#ifdef MS_WINDOWS
	1538	+ newfd = INVALID_SOCKET;
	1539	+#else
	1540	+ newfd = -1;
	1541	+#endif
	1542	+
	1543	+ if (!IS_SELECTABLE(s))
	1544	+ return select_error();
	1545	+
	1546	+ Py_BEGIN_ALLOW_THREADS
	1547	+ timeout = internal_select(s, 0);
	1548	+ if (!timeout)
	1549	+ newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
	1550	+ Py_END_ALLOW_THREADS
	1551	+
	1552	+ if (timeout == 1) {
	1553	+ PyErr_SetString(socket_timeout, "timed out");
	1554	+ return NULL;
	1555	+ }
	1556	+
	1557	+#ifdef MS_WINDOWS
	1558	+ if (newfd == INVALID_SOCKET)
	1559	+#else
	1560	+ if (newfd < 0)
	1561	+#endif
	1562	+ return s->errorhandler();
	1563	+
	1564	+ /* Create the new object with unspecified family,
	1565	+ to avoid calls to bind() etc. on it. */
	1566	+ sock = (PyObject *) new_sockobject(newfd,
	1567	+ s->sock_family,
	1568	+ s->sock_type,
	1569	+ s->sock_proto);
	1570	+
	1571	+ if (sock == NULL) {
	1572	+ SOCKETCLOSE(newfd);
	1573	+ goto finally;
	1574	+ }
	1575	+ addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
	1576	+ addrlen, s->sock_proto);
	1577	+ if (addr == NULL)
	1578	+ goto finally;
	1579	+
	1580	+ res = PyTuple_Pack(2, sock, addr);
	1581	+
	1582	+finally:
	1583	+ Py_XDECREF(sock);
	1584	+ Py_XDECREF(addr);
	1585	+ return res;
	1586	+}
	1587	+
	1588	+PyDoc_STRVAR(accept_doc,
	1589	+"accept() -> (socket object, address info)\n\
	1590	+\n\
	1591	+Wait for an incoming connection. Return a new socket representing the\n\
	1592	+connection, and the address of the client. For IP sockets, the address\n\
	1593	+info is a pair (hostaddr, port).");
	1594	+
	1595	+/* s.setblocking(flag) method. Argument:
	1596	+ False -- non-blocking mode; same as settimeout(0)
	1597	+ True -- blocking mode; same as settimeout(None)
	1598	+*/
	1599	+
	1600	+static PyObject *
	1601	+sock_setblocking(PySocketSockObject s, PyObject arg)
	1602	+{
	1603	+ int block;
	1604	+
	1605	+ block = PyInt_AsLong(arg);
	1606	+ if (block == -1 && PyErr_Occurred())
	1607	+ return NULL;
	1608	+
	1609	+ s->sock_timeout = block ? -1.0 : 0.0;
	1610	+ internal_setblocking(s, block);
	1611	+
	1612	+ Py_INCREF(Py_None);
	1613	+ return Py_None;
	1614	+}
	1615	+
	1616	+PyDoc_STRVAR(setblocking_doc,
	1617	+"setblocking(flag)\n\
	1618	+\n\
	1619	+Set the socket to blocking (flag is true) or non-blocking (false).\n\
	1620	+setblocking(True) is equivalent to settimeout(None);\n\
	1621	+setblocking(False) is equivalent to settimeout(0.0).");
	1622	+
	1623	+/* s.settimeout(timeout) method. Argument:
	1624	+ None -- no timeout, blocking mode; same as setblocking(True)
	1625	+ 0.0 -- non-blocking mode; same as setblocking(False)
	1626	+ > 0 -- timeout mode; operations time out after timeout seconds
	1627	+ < 0 -- illegal; raises an exception
	1628	+*/
	1629	+static PyObject *
	1630	+sock_settimeout(PySocketSockObject s, PyObject arg)
	1631	+{
	1632	+ double timeout;
	1633	+
	1634	+ if (arg == Py_None)
	1635	+ timeout = -1.0;
	1636	+ else {
	1637	+ timeout = PyFloat_AsDouble(arg);
	1638	+ if (timeout < 0.0) {
	1639	+ if (!PyErr_Occurred())
	1640	+ PyErr_SetString(PyExc_ValueError,
	1641	+ "Timeout value out of range");
	1642	+ return NULL;
	1643	+ }
	1644	+ }
	1645	+
	1646	+ s->sock_timeout = timeout;
	1647	+ internal_setblocking(s, timeout < 0.0);
	1648	+
	1649	+ Py_INCREF(Py_None);
	1650	+ return Py_None;
	1651	+}
	1652	+
	1653	+PyDoc_STRVAR(settimeout_doc,
	1654	+"settimeout(timeout)\n\
	1655	+\n\
	1656	+Set a timeout on socket operations. 'timeout' can be a float,\n\
	1657	+giving in seconds, or None. Setting a timeout of None disables\n\
	1658	+the timeout feature and is equivalent to setblocking(1).\n\
	1659	+Setting a timeout of zero is the same as setblocking(0).");
	1660	+
	1661	+/* s.gettimeout() method.
	1662	+ Returns the timeout associated with a socket. */
	1663	+static PyObject *
	1664	+sock_gettimeout(PySocketSockObject *s)
	1665	+{
	1666	+ if (s->sock_timeout < 0.0) {
	1667	+ Py_INCREF(Py_None);
	1668	+ return Py_None;
	1669	+ }
	1670	+ else
	1671	+ return PyFloat_FromDouble(s->sock_timeout);
	1672	+}
	1673	+
	1674	+PyDoc_STRVAR(gettimeout_doc,
	1675	+"gettimeout() -> timeout\n\
	1676	+\n\
	1677	+Returns the timeout in floating seconds associated with socket \n\
	1678	+operations. A timeout of None indicates that timeouts on socket \n\
	1679	+operations are disabled.");
	1680	+
	1681	+#ifdef RISCOS
	1682	+/* s.sleeptaskw(1 \| 0) method */
	1683	+
	1684	+static PyObject *
	1685	+sock_sleeptaskw(PySocketSockObject s,PyObject arg)
	1686	+{
	1687	+ int block;
	1688	+ block = PyInt_AsLong(arg);
	1689	+ if (block == -1 && PyErr_Occurred())
	1690	+ return NULL;
	1691	+ Py_BEGIN_ALLOW_THREADS
	1692	+ socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
	1693	+ Py_END_ALLOW_THREADS
	1694	+
	1695	+ Py_INCREF(Py_None);
	1696	+ return Py_None;
	1697	+}
	1698	+PyDoc_STRVAR(sleeptaskw_doc,
	1699	+"sleeptaskw(flag)\n\
	1700	+\n\
	1701	+Allow sleeps in taskwindows.");
	1702	+#endif
	1703	+
	1704	+
	1705	+/* s.setsockopt() method.
	1706	+ With an integer third argument, sets an integer option.
	1707	+ With a string third argument, sets an option from a buffer;
	1708	+ use optional built-in module 'struct' to encode the string. */
	1709	+
	1710	+static PyObject *
	1711	+sock_setsockopt(PySocketSockObject s, PyObject args)
	1712	+{
	1713	+ int level;
	1714	+ int optname;
	1715	+ int res;
	1716	+ char *buf;
	1717	+ int buflen;
	1718	+ int flag;
	1719	+
	1720	+ if (PyArg_ParseTuple(args, "iii:setsockopt",
	1721	+ &level, &optname, &flag)) {
	1722	+ buf = (char *) &flag;
	1723	+ buflen = sizeof flag;
	1724	+ }
	1725	+ else {
	1726	+ PyErr_Clear();
	1727	+ if (!PyArg_ParseTuple(args, "iis#:setsockopt",
	1728	+ &level, &optname, &buf, &buflen))
	1729	+ return NULL;
	1730	+ }
	1731	+ res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
	1732	+ if (res < 0)
	1733	+ return s->errorhandler();
	1734	+ Py_INCREF(Py_None);
	1735	+ return Py_None;
	1736	+}
	1737	+
	1738	+PyDoc_STRVAR(setsockopt_doc,
	1739	+"setsockopt(level, option, value)\n\
	1740	+\n\
	1741	+Set a socket option. See the Unix manual for level and option.\n\
	1742	+The value argument can either be an integer or a string.");
	1743	+
	1744	+
	1745	+/* s.getsockopt() method.
	1746	+ With two arguments, retrieves an integer option.
	1747	+ With a third integer argument, retrieves a string buffer of that size;
	1748	+ use optional built-in module 'struct' to decode the string. */
	1749	+
	1750	+static PyObject *
	1751	+sock_getsockopt(PySocketSockObject s, PyObject args)
	1752	+{
	1753	+ int level;
	1754	+ int optname;
	1755	+ int res;
	1756	+ PyObject *buf;
	1757	+ socklen_t buflen = 0;
	1758	+
	1759	+#ifdef __BEOS__
	1760	+ /* We have incomplete socket support. */
	1761	+ PyErr_SetString(socket_error, "getsockopt not supported");
	1762	+ return NULL;
	1763	+#else
	1764	+
	1765	+ if (!PyArg_ParseTuple(args, "ii\|i:getsockopt",
	1766	+ &level, &optname, &buflen))
	1767	+ return NULL;
	1768	+
	1769	+ if (buflen == 0) {
	1770	+ int flag = 0;
	1771	+ socklen_t flagsize = sizeof flag;
	1772	+ res = getsockopt(s->sock_fd, level, optname,
	1773	+ (void *)&flag, &flagsize);
	1774	+ if (res < 0)
	1775	+ return s->errorhandler();
	1776	+ return PyInt_FromLong(flag);
	1777	+ }
	1778	+#ifdef __VMS
	1779	+ /* socklen_t is unsigned so no negative test is needed,
	1780	+ test buflen == 0 is previously done */
	1781	+ if (buflen > 1024) {
	1782	+#else
	1783	+ if (buflen <= 0 \|\| buflen > 1024) {
	1784	+#endif
	1785	+ PyErr_SetString(socket_error,
	1786	+ "getsockopt buflen out of range");
	1787	+ return NULL;
	1788	+ }
	1789	+ buf = PyString_FromStringAndSize((char *)NULL, buflen);
	1790	+ if (buf == NULL)
	1791	+ return NULL;
	1792	+ res = getsockopt(s->sock_fd, level, optname,
	1793	+ (void *)PyString_AS_STRING(buf), &buflen);
	1794	+ if (res < 0) {
	1795	+ Py_DECREF(buf);
	1796	+ return s->errorhandler();
	1797	+ }
	1798	+ _PyString_Resize(&buf, buflen);
	1799	+ return buf;
	1800	+#endif /* __BEOS__ */
	1801	+}
	1802	+
	1803	+PyDoc_STRVAR(getsockopt_doc,
	1804	+"getsockopt(level, option[, buffersize]) -> value\n\
	1805	+\n\
	1806	+Get a socket option. See the Unix manual for level and option.\n\
	1807	+If a nonzero buffersize argument is given, the return value is a\n\
	1808	+string of that length; otherwise it is an integer.");
	1809	+
	1810	+
	1811	+/* s.bind(sockaddr) method */
	1812	+
	1813	+static PyObject *
	1814	+sock_bind(PySocketSockObject s, PyObject addro)
	1815	+{
	1816	+ sock_addr_t addrbuf;
	1817	+ int addrlen;
	1818	+ int res;
	1819	+
	1820	+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
	1821	+ return NULL;
	1822	+ Py_BEGIN_ALLOW_THREADS
	1823	+ res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
	1824	+ Py_END_ALLOW_THREADS
	1825	+ if (res < 0)
	1826	+ return s->errorhandler();
	1827	+ Py_INCREF(Py_None);
	1828	+ return Py_None;
	1829	+}
	1830	+
	1831	+PyDoc_STRVAR(bind_doc,
	1832	+"bind(address)\n\
	1833	+\n\
	1834	+Bind the socket to a local address. For IP sockets, the address is a\n\
	1835	+pair (host, port); the host must refer to the local host. For raw packet\n\
	1836	+sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
	1837	+
	1838	+
	1839	+/* s.close() method.
	1840	+ Set the file descriptor to -1 so operations tried subsequently
	1841	+ will surely fail. */
	1842	+
	1843	+static PyObject *
	1844	+sock_close(PySocketSockObject *s)
	1845	+{
	1846	+ SOCKET_T fd;
	1847	+
	1848	+ if ((fd = s->sock_fd) != -1) {
	1849	+ s->sock_fd = -1;
	1850	+ Py_BEGIN_ALLOW_THREADS
	1851	+ (void) SOCKETCLOSE(fd);
	1852	+ Py_END_ALLOW_THREADS
	1853	+ }
	1854	+ Py_INCREF(Py_None);
	1855	+ return Py_None;
	1856	+}
	1857	+
	1858	+PyDoc_STRVAR(close_doc,
	1859	+"close()\n\
	1860	+\n\
	1861	+Close the socket. It cannot be used after this call.");
	1862	+
	1863	+static int
	1864	+internal_connect(PySocketSockObject s, struct sockaddr addr, int addrlen,
	1865	+ int *timeoutp)
	1866	+{
	1867	+ int res, timeout;
	1868	+
	1869	+ timeout = 0;
	1870	+ res = connect(s->sock_fd, addr, addrlen);
	1871	+
	1872	+#ifdef MS_WINDOWS
	1873	+
	1874	+ if (s->sock_timeout > 0.0) {
	1875	+ if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
	1876	+ IS_SELECTABLE(s)) {
	1877	+ /* This is a mess. Best solution: trust select */
	1878	+ fd_set fds;
	1879	+ fd_set fds_exc;
	1880	+ struct timeval tv;
	1881	+ tv.tv_sec = (int)s->sock_timeout;
	1882	+ tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
	1883	+ FD_ZERO(&fds);
	1884	+ FD_SET(s->sock_fd, &fds);
	1885	+ FD_ZERO(&fds_exc);
	1886	+ FD_SET(s->sock_fd, &fds_exc);
	1887	+ res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
	1888	+ if (res == 0) {
	1889	+ res = WSAEWOULDBLOCK;
	1890	+ timeout = 1;
	1891	+ } else if (res > 0) {
	1892	+ if (FD_ISSET(s->sock_fd, &fds))
	1893	+ /* The socket is in the writeable set - this
	1894	+ means connected */
	1895	+ res = 0;
	1896	+ else {
	1897	+ /* As per MS docs, we need to call getsockopt()
	1898	+ to get the underlying error */
	1899	+ int res_size = sizeof res;
	1900	+ /* It must be in the exception set */
	1901	+ assert(FD_ISSET(s->sock_fd, &fds_exc));
	1902	+ if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
	1903	+ (char *)&res, &res_size))
	1904	+ /* getsockopt also clears WSAGetLastError,
	1905	+ so reset it back. */
	1906	+ WSASetLastError(res);
	1907	+ else
	1908	+ res = WSAGetLastError();
	1909	+ }
	1910	+ }
	1911	+ /* else if (res < 0) an error occurred */
	1912	+ }
	1913	+ }
	1914	+
	1915	+ if (res < 0)
	1916	+ res = WSAGetLastError();
	1917	+
	1918	+#else
	1919	+
	1920	+ if (s->sock_timeout > 0.0) {
	1921	+ if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
	1922	+ timeout = internal_select(s, 1);
	1923	+ if (timeout == 0) {
	1924	+ res = connect(s->sock_fd, addr, addrlen);
	1925	+ if (res < 0 && errno == EISCONN)
	1926	+ res = 0;
	1927	+ }
	1928	+ else if (timeout == -1)
	1929	+ res = errno; /* had error */
	1930	+ else
	1931	+ res = EWOULDBLOCK; /* timed out */
	1932	+ }
	1933	+ }
	1934	+
	1935	+ if (res < 0)
	1936	+ res = errno;
	1937	+
	1938	+#endif
	1939	+ *timeoutp = timeout;
	1940	+
	1941	+ return res;
	1942	+}
	1943	+
	1944	+/* s.connect(sockaddr) method */
	1945	+
	1946	+static PyObject *
	1947	+sock_connect(PySocketSockObject s, PyObject addro)
	1948	+{
	1949	+ sock_addr_t addrbuf;
	1950	+ int addrlen;
	1951	+ int res;
	1952	+ int timeout;
	1953	+
	1954	+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
	1955	+ return NULL;
	1956	+
	1957	+ Py_BEGIN_ALLOW_THREADS
	1958	+ res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
	1959	+ Py_END_ALLOW_THREADS
	1960	+
	1961	+ if (timeout == 1) {
	1962	+ PyErr_SetString(socket_timeout, "timed out");
	1963	+ return NULL;
	1964	+ }
	1965	+ if (res != 0)
	1966	+ return s->errorhandler();
	1967	+ Py_INCREF(Py_None);
	1968	+ return Py_None;
	1969	+}
	1970	+
	1971	+PyDoc_STRVAR(connect_doc,
	1972	+"connect(address)\n\
	1973	+\n\
	1974	+Connect the socket to a remote address. For IP sockets, the address\n\
	1975	+is a pair (host, port).");
	1976	+
	1977	+
	1978	+/* s.connect_ex(sockaddr) method */
	1979	+
	1980	+static PyObject *
	1981	+sock_connect_ex(PySocketSockObject s, PyObject addro)
	1982	+{
	1983	+ sock_addr_t addrbuf;
	1984	+ int addrlen;
	1985	+ int res;
	1986	+ int timeout;
	1987	+
	1988	+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
	1989	+ return NULL;
	1990	+
	1991	+ Py_BEGIN_ALLOW_THREADS
	1992	+ res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
	1993	+ Py_END_ALLOW_THREADS
	1994	+
	1995	+ /* Signals are not errors (though they may raise exceptions). Adapted
	1996	+ from PyErr_SetFromErrnoWithFilenameObject(). */
	1997	+#ifdef EINTR
	1998	+ if (res == EINTR && PyErr_CheckSignals())
	1999	+ return NULL;
	2000	+#endif
	2001	+
	2002	+ return PyInt_FromLong((long) res);
	2003	+}
	2004	+
	2005	+PyDoc_STRVAR(connect_ex_doc,
	2006	+"connect_ex(address) -> errno\n\
	2007	+\n\
	2008	+This is like connect(address), but returns an error code (the errno value)\n\
	2009	+instead of raising an exception when an error occurs.");
	2010	+
	2011	+
	2012	+/* s.fileno() method */
	2013	+
	2014	+static PyObject *
	2015	+sock_fileno(PySocketSockObject *s)
	2016	+{
	2017	+#if SIZEOF_SOCKET_T <= SIZEOF_LONG
	2018	+ return PyInt_FromLong((long) s->sock_fd);
	2019	+#else
	2020	+ return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd);
	2021	+#endif
	2022	+}
	2023	+
	2024	+PyDoc_STRVAR(fileno_doc,
	2025	+"fileno() -> integer\n\
	2026	+\n\
	2027	+Return the integer file descriptor of the socket.");
	2028	+
	2029	+
	2030	+#ifndef NO_DUP
	2031	+/* s.dup() method */
	2032	+
	2033	+static PyObject *
	2034	+sock_dup(PySocketSockObject *s)
	2035	+{
	2036	+ SOCKET_T newfd;
	2037	+ PyObject *sock;
	2038	+
	2039	+ newfd = dup(s->sock_fd);
	2040	+ if (newfd < 0)
	2041	+ return s->errorhandler();
	2042	+ sock = (PyObject *) new_sockobject(newfd,
	2043	+ s->sock_family,
	2044	+ s->sock_type,
	2045	+ s->sock_proto);
	2046	+ if (sock == NULL)
	2047	+ SOCKETCLOSE(newfd);
	2048	+ return sock;
	2049	+}
	2050	+
	2051	+PyDoc_STRVAR(dup_doc,
	2052	+"dup() -> socket object\n\
	2053	+\n\
	2054	+Return a new socket object connected to the same system resource.");
	2055	+
	2056	+#endif
	2057	+
	2058	+
	2059	+/* s.getsockname() method */
	2060	+
	2061	+static PyObject *
	2062	+sock_getsockname(PySocketSockObject *s)
	2063	+{
	2064	+ sock_addr_t addrbuf;
	2065	+ int res;
	2066	+ socklen_t addrlen;
	2067	+
	2068	+ if (!getsockaddrlen(s, &addrlen))
	2069	+ return NULL;
	2070	+ memset(&addrbuf, 0, addrlen);
	2071	+ Py_BEGIN_ALLOW_THREADS
	2072	+ res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
	2073	+ Py_END_ALLOW_THREADS
	2074	+ if (res < 0)
	2075	+ return s->errorhandler();
	2076	+ return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
	2077	+ s->sock_proto);
	2078	+}
	2079	+
	2080	+PyDoc_STRVAR(getsockname_doc,
	2081	+"getsockname() -> address info\n\
	2082	+\n\
	2083	+Return the address of the local endpoint. For IP sockets, the address\n\
	2084	+info is a pair (hostaddr, port).");
	2085	+
	2086	+
	2087	+#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
	2088	+/* s.getpeername() method */
	2089	+
	2090	+static PyObject *
	2091	+sock_getpeername(PySocketSockObject *s)
	2092	+{
	2093	+ sock_addr_t addrbuf;
	2094	+ int res;
	2095	+ socklen_t addrlen;
	2096	+
	2097	+ if (!getsockaddrlen(s, &addrlen))
	2098	+ return NULL;
	2099	+ memset(&addrbuf, 0, addrlen);
	2100	+ Py_BEGIN_ALLOW_THREADS
	2101	+ res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
	2102	+ Py_END_ALLOW_THREADS
	2103	+ if (res < 0)
	2104	+ return s->errorhandler();
	2105	+ return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
	2106	+ s->sock_proto);
	2107	+}
	2108	+
	2109	+PyDoc_STRVAR(getpeername_doc,
	2110	+"getpeername() -> address info\n\
	2111	+\n\
	2112	+Return the address of the remote endpoint. For IP sockets, the address\n\
	2113	+info is a pair (hostaddr, port).");
	2114	+
	2115	+#endif /* HAVE_GETPEERNAME */
	2116	+
	2117	+
	2118	+/* s.listen(n) method */
	2119	+
	2120	+static PyObject *
	2121	+sock_listen(PySocketSockObject s, PyObject arg)
	2122	+{
	2123	+ int backlog;
	2124	+ int res;
	2125	+
	2126	+ backlog = PyInt_AsLong(arg);
	2127	+ if (backlog == -1 && PyErr_Occurred())
	2128	+ return NULL;
	2129	+ Py_BEGIN_ALLOW_THREADS
	2130	+ if (backlog < 1)
	2131	+ backlog = 1;
	2132	+ res = listen(s->sock_fd, backlog);
	2133	+ Py_END_ALLOW_THREADS
	2134	+ if (res < 0)
	2135	+ return s->errorhandler();
	2136	+ Py_INCREF(Py_None);
	2137	+ return Py_None;
	2138	+}
	2139	+
	2140	+PyDoc_STRVAR(listen_doc,
	2141	+"listen(backlog)\n\
	2142	+\n\
	2143	+Enable a server to accept connections. The backlog argument must be at\n\
	2144	+least 1; it specifies the number of unaccepted connection that the system\n\
	2145	+will allow before refusing new connections.");
	2146	+
	2147	+
	2148	+#ifndef NO_DUP
	2149	+/* s.makefile(mode) method.
	2150	+ Create a new open file object referring to a dupped version of
	2151	+ the socket's file descriptor. (The dup() call is necessary so
	2152	+ that the open file and socket objects may be closed independent
	2153	+ of each other.)
	2154	+ The mode argument specifies 'r' or 'w' passed to fdopen(). */
	2155	+
	2156	+static PyObject *
	2157	+sock_makefile(PySocketSockObject s, PyObject args)
	2158	+{
	2159	+ extern int fclose(FILE *);
	2160	+ char *mode = "r";
	2161	+ int bufsize = -1;
	2162	+#ifdef MS_WIN32
	2163	+ Py_intptr_t fd;
	2164	+#else
	2165	+ int fd;
	2166	+#endif
	2167	+ FILE *fp;
	2168	+ PyObject *f;
	2169	+#ifdef __VMS
	2170	+ char *mode_r = "r";
	2171	+ char *mode_w = "w";
	2172	+#endif
	2173	+
	2174	+ if (!PyArg_ParseTuple(args, "\|si:makefile", &mode, &bufsize))
	2175	+ return NULL;
	2176	+#ifdef __VMS
	2177	+ if (strcmp(mode,"rb") == 0) {
	2178	+ mode = mode_r;
	2179	+ }
	2180	+ else {
	2181	+ if (strcmp(mode,"wb") == 0) {
	2182	+ mode = mode_w;
	2183	+ }
	2184	+ }
	2185	+#endif
	2186	+#ifdef MS_WIN32
	2187	+ if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) \|\|
	2188	+ ((fd = dup(fd)) < 0) \|\| ((fp = fdopen(fd, mode)) == NULL))
	2189	+#else
	2190	+ if ((fd = dup(s->sock_fd)) < 0 \|\| (fp = fdopen(fd, mode)) == NULL)
	2191	+#endif
	2192	+ {
	2193	+ if (fd >= 0)
	2194	+ SOCKETCLOSE(fd);
	2195	+ return s->errorhandler();
	2196	+ }
	2197	+ f = PyFile_FromFile(fp, "<socket>", mode, fclose);
	2198	+ if (f != NULL)
	2199	+ PyFile_SetBufSize(f, bufsize);
	2200	+ return f;
	2201	+}
	2202	+
	2203	+PyDoc_STRVAR(makefile_doc,
	2204	+"makefile([mode[, buffersize]]) -> file object\n\
	2205	+\n\
	2206	+Return a regular file object corresponding to the socket.\n\
	2207	+The mode and buffersize arguments are as for the built-in open() function.");
	2208	+
	2209	+#endif /* NO_DUP */
	2210	+
	2211	+/*
	2212	+ * This is the guts of the recv() and recv_into() methods, which reads into a
	2213	+ * char buffer. If you have any inc/def ref to do to the objects that contain
	2214	+ * the buffer, do it in the caller. This function returns the number of bytes
	2215	+ * succesfully read. If there was an error, it returns -1. Note that it is
	2216	+ * also possible that we return a number of bytes smaller than the request
	2217	+ * bytes.
	2218	+ */
	2219	+static ssize_t
	2220	+sock_recv_guts(PySocketSockObject s, char cbuf, int len, int flags)
	2221	+{
	2222	+ ssize_t outlen = -1;
	2223	+ int timeout;
	2224	+#ifdef __VMS
	2225	+ int remaining;
	2226	+ char *read_buf;
	2227	+#endif
	2228	+
	2229	+ if (!IS_SELECTABLE(s)) {
	2230	+ select_error();
	2231	+ return -1;
	2232	+ }
	2233	+
	2234	+#ifndef __VMS
	2235	+ Py_BEGIN_ALLOW_THREADS
	2236	+ timeout = internal_select(s, 0);
	2237	+ if (!timeout)
	2238	+ outlen = recv(s->sock_fd, cbuf, len, flags);
	2239	+ Py_END_ALLOW_THREADS
	2240	+
	2241	+ if (timeout == 1) {
	2242	+ PyErr_SetString(socket_timeout, "timed out");
	2243	+ return -1;
	2244	+ }
	2245	+ if (outlen < 0) {
	2246	+ /* Note: the call to errorhandler() ALWAYS indirectly returned
	2247	+ NULL, so ignore its return value */
	2248	+ s->errorhandler();
	2249	+ return -1;
	2250	+ }
	2251	+#else
	2252	+ read_buf = cbuf;
	2253	+ remaining = len;
	2254	+ while (remaining != 0) {
	2255	+ unsigned int segment;
	2256	+ int nread = -1;
	2257	+
	2258	+ segment = remaining /SEGMENT_SIZE;
	2259	+ if (segment != 0) {
	2260	+ segment = SEGMENT_SIZE;
	2261	+ }
	2262	+ else {
	2263	+ segment = remaining;
	2264	+ }
	2265	+
	2266	+ Py_BEGIN_ALLOW_THREADS
	2267	+ timeout = internal_select(s, 0);
	2268	+ if (!timeout)
	2269	+ nread = recv(s->sock_fd, read_buf, segment, flags);
	2270	+ Py_END_ALLOW_THREADS
	2271	+
	2272	+ if (timeout == 1) {
	2273	+ PyErr_SetString(socket_timeout, "timed out");
	2274	+ return -1;
	2275	+ }
	2276	+ if (nread < 0) {
	2277	+ s->errorhandler();
	2278	+ return -1;
	2279	+ }
	2280	+ if (nread != remaining) {
	2281	+ read_buf += nread;
	2282	+ break;
	2283	+ }
	2284	+
	2285	+ remaining -= segment;
	2286	+ read_buf += segment;
	2287	+ }
	2288	+ outlen = read_buf - cbuf;
	2289	+#endif /* !__VMS */
	2290	+
	2291	+ return outlen;
	2292	+}
	2293	+
	2294	+
	2295	+/* s.recv(nbytes [,flags]) method */
	2296	+
	2297	+static PyObject *
	2298	+sock_recv(PySocketSockObject s, PyObject args)
	2299	+{
	2300	+ int recvlen, flags = 0;
	2301	+ ssize_t outlen;
	2302	+ PyObject *buf;
	2303	+
	2304	+ if (!PyArg_ParseTuple(args, "i\|i:recv", &recvlen, &flags))
	2305	+ return NULL;
	2306	+
	2307	+ if (recvlen < 0) {
	2308	+ PyErr_SetString(PyExc_ValueError,
	2309	+ "negative buffersize in recv");
	2310	+ return NULL;
	2311	+ }
	2312	+
	2313	+ /* Allocate a new string. */
	2314	+ buf = PyString_FromStringAndSize((char *) 0, recvlen);
	2315	+ if (buf == NULL)
	2316	+ return NULL;
	2317	+
	2318	+ /* Call the guts */
	2319	+ outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags);
	2320	+ if (outlen < 0) {
	2321	+ /* An error occurred, release the string and return an
	2322	+ error. */
	2323	+ Py_DECREF(buf);
	2324	+ return NULL;
	2325	+ }
	2326	+ if (outlen != recvlen) {
	2327	+ /* We did not read as many bytes as we anticipated, resize the
	2328	+ string if possible and be succesful. */
	2329	+ if (_PyString_Resize(&buf, outlen) < 0)
	2330	+ /* Oopsy, not so succesful after all. */
	2331	+ return NULL;
	2332	+ }
	2333	+
	2334	+ return buf;
	2335	+}
	2336	+
	2337	+PyDoc_STRVAR(recv_doc,
	2338	+"recv(buffersize[, flags]) -> data\n\
	2339	+\n\
	2340	+Receive up to buffersize bytes from the socket. For the optional flags\n\
	2341	+argument, see the Unix manual. When no data is available, block until\n\
	2342	+at least one byte is available or until the remote end is closed. When\n\
	2343	+the remote end is closed and all data is read, return the empty string.");
	2344	+
	2345	+
	2346	+/* s.recv_into(buffer, [nbytes [,flags]]) method */
	2347	+
	2348	+static PyObject*
	2349	+sock_recv_into(PySocketSockObject s, PyObject args, PyObject *kwds)
	2350	+{
	2351	+ static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
	2352	+
	2353	+ int recvlen = 0, flags = 0;
	2354	+ ssize_t readlen;
	2355	+ char *buf;
	2356	+ int buflen;
	2357	+
	2358	+ /* Get the buffer's memory */
	2359	+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#\|ii:recv_into", kwlist,
	2360	+ &buf, &buflen, &recvlen, &flags))
	2361	+ return NULL;
	2362	+ assert(buf != 0 && buflen > 0);
	2363	+
	2364	+ if (recvlen < 0) {
	2365	+ PyErr_SetString(PyExc_ValueError,
	2366	+ "negative buffersize in recv_into");
	2367	+ return NULL;
	2368	+ }
	2369	+ if (recvlen == 0) {
	2370	+ /* If nbytes was not specified, use the buffer's length */
	2371	+ recvlen = buflen;
	2372	+ }
	2373	+
	2374	+ /* Check if the buffer is large enough */
	2375	+ if (buflen < recvlen) {
	2376	+ PyErr_SetString(PyExc_ValueError,
	2377	+ "buffer too small for requested bytes");
	2378	+ return NULL;
	2379	+ }
	2380	+
	2381	+ /* Call the guts */
	2382	+ readlen = sock_recv_guts(s, buf, recvlen, flags);
	2383	+ if (readlen < 0) {
	2384	+ /* Return an error. */
	2385	+ return NULL;
	2386	+ }
	2387	+
	2388	+ /* Return the number of bytes read. Note that we do not do anything
	2389	+ special here in the case that readlen < recvlen. */
	2390	+ return PyInt_FromSsize_t(readlen);
	2391	+}
	2392	+
	2393	+PyDoc_STRVAR(recv_into_doc,
	2394	+"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
	2395	+\n\
	2396	+A version of recv() that stores its data into a buffer rather than creating \n\
	2397	+a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
	2398	+is not specified (or 0), receive up to the size available in the given buffer.\n\
	2399	+\n\
	2400	+See recv() for documentation about the flags.");
	2401	+
	2402	+
	2403	+/*
	2404	+ * This is the guts of the recv() and recv_into() methods, which reads into a
	2405	+ * char buffer. If you have any inc/def ref to do to the objects that contain
	2406	+ * the buffer, do it in the caller. This function returns the number of bytes
	2407	+ * succesfully read. If there was an error, it returns -1. Note that it is
	2408	+ * also possible that we return a number of bytes smaller than the request
	2409	+ * bytes.
	2410	+ *
	2411	+ * 'addr' is a return value for the address object. Note that you must decref
	2412	+ * it yourself.
	2413	+ */
	2414	+static ssize_t
	2415	+sock_recvfrom_guts(PySocketSockObject s, char cbuf, int len, int flags,
	2416	+ PyObject** addr)
	2417	+{
	2418	+ sock_addr_t addrbuf;
	2419	+ int timeout;
	2420	+ ssize_t n = -1;
	2421	+ socklen_t addrlen;
	2422	+
	2423	+ *addr = NULL;
	2424	+
	2425	+ if (!getsockaddrlen(s, &addrlen))
	2426	+ return -1;
	2427	+
	2428	+ if (!IS_SELECTABLE(s)) {
	2429	+ select_error();
	2430	+ return -1;
	2431	+ }
	2432	+
	2433	+ Py_BEGIN_ALLOW_THREADS
	2434	+ memset(&addrbuf, 0, addrlen);
	2435	+ timeout = internal_select(s, 0);
	2436	+ if (!timeout) {
	2437	+#ifndef MS_WINDOWS
	2438	+#if defined(PYOS_OS2) && !defined(PYCC_GCC)
	2439	+ n = recvfrom(s->sock_fd, cbuf, len, flags,
	2440	+ SAS2SA(&addrbuf), &addrlen);
	2441	+#else
	2442	+ n = recvfrom(s->sock_fd, cbuf, len, flags,
	2443	+ (void *) &addrbuf, &addrlen);
	2444	+#endif
	2445	+#else
	2446	+ n = recvfrom(s->sock_fd, cbuf, len, flags,
	2447	+ SAS2SA(&addrbuf), &addrlen);
	2448	+#endif
	2449	+ }
	2450	+ Py_END_ALLOW_THREADS
	2451	+
	2452	+ if (timeout == 1) {
	2453	+ PyErr_SetString(socket_timeout, "timed out");
	2454	+ return -1;
	2455	+ }
	2456	+ if (n < 0) {
	2457	+ s->errorhandler();
	2458	+ return -1;
	2459	+ }
	2460	+
	2461	+ if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
	2462	+ addrlen, s->sock_proto)))
	2463	+ return -1;
	2464	+
	2465	+ return n;
	2466	+}
	2467	+
	2468	+/* s.recvfrom(nbytes [,flags]) method */
	2469	+
	2470	+static PyObject *
	2471	+sock_recvfrom(PySocketSockObject s, PyObject args)
	2472	+{
	2473	+ PyObject *buf = NULL;
	2474	+ PyObject *addr = NULL;
	2475	+ PyObject *ret = NULL;
	2476	+ int recvlen, flags = 0;
	2477	+ ssize_t outlen;
	2478	+
	2479	+ if (!PyArg_ParseTuple(args, "i\|i:recvfrom", &recvlen, &flags))
	2480	+ return NULL;
	2481	+
	2482	+ if (recvlen < 0) {
	2483	+ PyErr_SetString(PyExc_ValueError,
	2484	+ "negative buffersize in recvfrom");
	2485	+ return NULL;
	2486	+ }
	2487	+
	2488	+ buf = PyString_FromStringAndSize((char *) 0, recvlen);
	2489	+ if (buf == NULL)
	2490	+ return NULL;
	2491	+
	2492	+ outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf),
	2493	+ recvlen, flags, &addr);
	2494	+ if (outlen < 0) {
	2495	+ goto finally;
	2496	+ }
	2497	+
	2498	+ if (outlen != recvlen) {
	2499	+ /* We did not read as many bytes as we anticipated, resize the
	2500	+ string if possible and be succesful. */
	2501	+ if (_PyString_Resize(&buf, outlen) < 0)
	2502	+ /* Oopsy, not so succesful after all. */
	2503	+ goto finally;
	2504	+ }
	2505	+
	2506	+ ret = PyTuple_Pack(2, buf, addr);
	2507	+
	2508	+finally:
	2509	+ Py_XDECREF(buf);
	2510	+ Py_XDECREF(addr);
	2511	+ return ret;
	2512	+}
	2513	+
	2514	+PyDoc_STRVAR(recvfrom_doc,
	2515	+"recvfrom(buffersize[, flags]) -> (data, address info)\n\
	2516	+\n\
	2517	+Like recv(buffersize, flags) but also return the sender's address info.");
	2518	+
	2519	+
	2520	+/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
	2521	+
	2522	+static PyObject *
	2523	+sock_recvfrom_into(PySocketSockObject s, PyObject args, PyObject* kwds)
	2524	+{
	2525	+ static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
	2526	+
	2527	+ int recvlen = 0, flags = 0;
	2528	+ ssize_t readlen;
	2529	+ char *buf;
	2530	+ int buflen;
	2531	+
	2532	+ PyObject *addr = NULL;
	2533	+
	2534	+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#\|ii:recvfrom_into",
	2535	+ kwlist, &buf, &buflen,
	2536	+ &recvlen, &flags))
	2537	+ return NULL;
	2538	+ assert(buf != 0 && buflen > 0);
	2539	+
	2540	+ if (recvlen < 0) {
	2541	+ PyErr_SetString(PyExc_ValueError,
	2542	+ "negative buffersize in recvfrom_into");
	2543	+ return NULL;
	2544	+ }
	2545	+ if (recvlen == 0) {
	2546	+ /* If nbytes was not specified, use the buffer's length */
	2547	+ recvlen = buflen;
	2548	+ }
	2549	+
	2550	+ readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
	2551	+ if (readlen < 0) {
	2552	+ /* Return an error */
	2553	+ Py_XDECREF(addr);
	2554	+ return NULL;
	2555	+ }
	2556	+
	2557	+ /* Return the number of bytes read and the address. Note that we do
	2558	+ not do anything special here in the case that readlen < recvlen. */
	2559	+ return Py_BuildValue("lN", readlen, addr);
	2560	+}
	2561	+
	2562	+PyDoc_STRVAR(recvfrom_into_doc,
	2563	+"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
	2564	+\n\
	2565	+Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
	2566	+
	2567	+
	2568	+/* s.send(data [,flags]) method */
	2569	+
	2570	+static PyObject *
	2571	+sock_send(PySocketSockObject s, PyObject args)
	2572	+{
	2573	+ char *buf;
	2574	+ int len, n = -1, flags = 0, timeout;
	2575	+
	2576	+ if (!PyArg_ParseTuple(args, "s#\|i:send", &buf, &len, &flags))
	2577	+ return NULL;
	2578	+
	2579	+ if (!IS_SELECTABLE(s))
	2580	+ return select_error();
	2581	+
	2582	+ Py_BEGIN_ALLOW_THREADS
	2583	+ timeout = internal_select(s, 1);
	2584	+ if (!timeout)
	2585	+#ifdef __VMS
	2586	+ n = sendsegmented(s->sock_fd, buf, len, flags);
	2587	+#else
	2588	+ n = send(s->sock_fd, buf, len, flags);
	2589	+#endif
	2590	+ Py_END_ALLOW_THREADS
	2591	+
	2592	+ if (timeout == 1) {
	2593	+ PyErr_SetString(socket_timeout, "timed out");
	2594	+ return NULL;
	2595	+ }
	2596	+ if (n < 0)
	2597	+ return s->errorhandler();
	2598	+ return PyInt_FromLong((long)n);
	2599	+}
	2600	+
	2601	+PyDoc_STRVAR(send_doc,
	2602	+"send(data[, flags]) -> count\n\
	2603	+\n\
	2604	+Send a data string to the socket. For the optional flags\n\
	2605	+argument, see the Unix manual. Return the number of bytes\n\
	2606	+sent; this may be less than len(data) if the network is busy.");
	2607	+
	2608	+
	2609	+/* s.sendall(data [,flags]) method */
	2610	+
	2611	+static PyObject *
	2612	+sock_sendall(PySocketSockObject s, PyObject args)
	2613	+{
	2614	+ char *buf;
	2615	+ int len, n = -1, flags = 0, timeout;
	2616	+
	2617	+ if (!PyArg_ParseTuple(args, "s#\|i:sendall", &buf, &len, &flags))
	2618	+ return NULL;
	2619	+
	2620	+ if (!IS_SELECTABLE(s))
	2621	+ return select_error();
	2622	+
	2623	+ Py_BEGIN_ALLOW_THREADS
	2624	+ do {
	2625	+ timeout = internal_select(s, 1);
	2626	+ n = -1;
	2627	+ if (timeout)
	2628	+ break;
	2629	+#ifdef __VMS
	2630	+ n = sendsegmented(s->sock_fd, buf, len, flags);
	2631	+#else
	2632	+ n = send(s->sock_fd, buf, len, flags);
	2633	+#endif
	2634	+ if (n < 0)
	2635	+ break;
	2636	+ buf += n;
	2637	+ len -= n;
	2638	+ } while (len > 0);
	2639	+ Py_END_ALLOW_THREADS
	2640	+
	2641	+ if (timeout == 1) {
	2642	+ PyErr_SetString(socket_timeout, "timed out");
	2643	+ return NULL;
	2644	+ }
	2645	+ if (n < 0)
	2646	+ return s->errorhandler();
	2647	+
	2648	+ Py_INCREF(Py_None);
	2649	+ return Py_None;
	2650	+}
	2651	+
	2652	+PyDoc_STRVAR(sendall_doc,
	2653	+"sendall(data[, flags])\n\
	2654	+\n\
	2655	+Send a data string to the socket. For the optional flags\n\
	2656	+argument, see the Unix manual. This calls send() repeatedly\n\
	2657	+until all data is sent. If an error occurs, it's impossible\n\
	2658	+to tell how much data has been sent.");
	2659	+
	2660	+
	2661	+/* s.sendto(data, [flags,] sockaddr) method */
	2662	+
	2663	+static PyObject *
	2664	+sock_sendto(PySocketSockObject s, PyObject args)
	2665	+{
	2666	+ PyObject *addro;
	2667	+ char *buf;
	2668	+ sock_addr_t addrbuf;
	2669	+ int addrlen, len, n = -1, flags, timeout;
	2670	+
	2671	+ flags = 0;
	2672	+ if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) {
	2673	+ PyErr_Clear();
	2674	+ if (!PyArg_ParseTuple(args, "s#iO:sendto",
	2675	+ &buf, &len, &flags, &addro))
	2676	+ return NULL;
	2677	+ }
	2678	+
	2679	+ if (!IS_SELECTABLE(s))
	2680	+ return select_error();
	2681	+
	2682	+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
	2683	+ return NULL;
	2684	+
	2685	+ Py_BEGIN_ALLOW_THREADS
	2686	+ timeout = internal_select(s, 1);
	2687	+ if (!timeout)
	2688	+ n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
	2689	+ Py_END_ALLOW_THREADS
	2690	+
	2691	+ if (timeout == 1) {
	2692	+ PyErr_SetString(socket_timeout, "timed out");
	2693	+ return NULL;
	2694	+ }
	2695	+ if (n < 0)
	2696	+ return s->errorhandler();
	2697	+ return PyInt_FromLong((long)n);
	2698	+}
	2699	+
	2700	+PyDoc_STRVAR(sendto_doc,
	2701	+"sendto(data[, flags], address) -> count\n\
	2702	+\n\
	2703	+Like send(data, flags) but allows specifying the destination address.\n\
	2704	+For IP sockets, the address is a pair (hostaddr, port).");
	2705	+
	2706	+
	2707	+/* s.shutdown(how) method */
	2708	+
	2709	+static PyObject *
	2710	+sock_shutdown(PySocketSockObject s, PyObject arg)
	2711	+{
	2712	+ int how;
	2713	+ int res;
	2714	+
	2715	+ how = PyInt_AsLong(arg);
	2716	+ if (how == -1 && PyErr_Occurred())
	2717	+ return NULL;
	2718	+ Py_BEGIN_ALLOW_THREADS
	2719	+ res = shutdown(s->sock_fd, how);
	2720	+ Py_END_ALLOW_THREADS
	2721	+ if (res < 0)
	2722	+ return s->errorhandler();
	2723	+ Py_INCREF(Py_None);
	2724	+ return Py_None;
	2725	+}
	2726	+
	2727	+PyDoc_STRVAR(shutdown_doc,
	2728	+"shutdown(flag)\n\
	2729	+\n\
	2730	+Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
	2731	+of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
	2732	+
	2733	+
	2734	+/* List of methods for socket objects */
	2735	+
	2736	+static PyMethodDef sock_methods[] = {
	2737	+ {"accept", (PyCFunction)sock_accept, METH_NOARGS,
	2738	+ accept_doc},
	2739	+ {"bind", (PyCFunction)sock_bind, METH_O,
	2740	+ bind_doc},
	2741	+ {"close", (PyCFunction)sock_close, METH_NOARGS,
	2742	+ close_doc},
	2743	+ {"connect", (PyCFunction)sock_connect, METH_O,
	2744	+ connect_doc},
	2745	+ {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
	2746	+ connect_ex_doc},
	2747	+#ifndef NO_DUP
	2748	+ {"dup", (PyCFunction)sock_dup, METH_NOARGS,
	2749	+ dup_doc},
	2750	+#endif
	2751	+ {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
	2752	+ fileno_doc},
	2753	+#ifdef HAVE_GETPEERNAME
	2754	+ {"getpeername", (PyCFunction)sock_getpeername,
	2755	+ METH_NOARGS, getpeername_doc},
	2756	+#endif
	2757	+ {"getsockname", (PyCFunction)sock_getsockname,
	2758	+ METH_NOARGS, getsockname_doc},
	2759	+ {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
	2760	+ getsockopt_doc},
	2761	+ {"listen", (PyCFunction)sock_listen, METH_O,
	2762	+ listen_doc},
	2763	+#ifndef NO_DUP
	2764	+ {"makefile", (PyCFunction)sock_makefile, METH_VARARGS,
	2765	+ makefile_doc},
	2766	+#endif
	2767	+ {"recv", (PyCFunction)sock_recv, METH_VARARGS,
	2768	+ recv_doc},
	2769	+ {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS \| METH_KEYWORDS,
	2770	+ recv_into_doc},
	2771	+ {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
	2772	+ recvfrom_doc},
	2773	+ {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS \| METH_KEYWORDS,
	2774	+ recvfrom_into_doc},
	2775	+ {"send", (PyCFunction)sock_send, METH_VARARGS,
	2776	+ send_doc},
	2777	+ {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
	2778	+ sendall_doc},
	2779	+ {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
	2780	+ sendto_doc},
	2781	+ {"setblocking", (PyCFunction)sock_setblocking, METH_O,
	2782	+ setblocking_doc},
	2783	+ {"settimeout", (PyCFunction)sock_settimeout, METH_O,
	2784	+ settimeout_doc},
	2785	+ {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
	2786	+ gettimeout_doc},
	2787	+ {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
	2788	+ setsockopt_doc},
	2789	+ {"shutdown", (PyCFunction)sock_shutdown, METH_O,
	2790	+ shutdown_doc},
	2791	+#ifdef RISCOS
	2792	+ {"sleeptaskw", (PyCFunction)sock_sleeptaskw, METH_O,
	2793	+ sleeptaskw_doc},
	2794	+#endif
	2795	+ {NULL, NULL} /* sentinel */
	2796	+};
	2797	+
	2798	+/* SockObject members */
	2799	+static PyMemberDef sock_memberlist[] = {
	2800	+ {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
	2801	+ {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
	2802	+ {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
	2803	+ {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
	2804	+ {0},
	2805	+};
	2806	+
	2807	+/* Deallocate a socket object in response to the last Py_DECREF().
	2808	+ First close the file description. */
	2809	+
	2810	+static void
	2811	+sock_dealloc(PySocketSockObject *s)
	2812	+{
	2813	+ if (s->sock_fd != -1)
	2814	+ (void) SOCKETCLOSE(s->sock_fd);
	2815	+ s->ob_type->tp_free((PyObject *)s);
	2816	+}
	2817	+
	2818	+
	2819	+static PyObject *
	2820	+sock_repr(PySocketSockObject *s)
	2821	+{
	2822	+ char buf[512];
	2823	+#if SIZEOF_SOCKET_T > SIZEOF_LONG
	2824	+ if (s->sock_fd > LONG_MAX) {
	2825	+ /* this can occur on Win64, and actually there is a special
	2826	+ ugly printf formatter for decimal pointer length integer
	2827	+ printing, only bother if necessary*/
	2828	+ PyErr_SetString(PyExc_OverflowError,
	2829	+ "no printf formatter to display "
	2830	+ "the socket descriptor in decimal");
	2831	+ return NULL;
	2832	+ }
	2833	+#endif
	2834	+ PyOS_snprintf(
	2835	+ buf, sizeof(buf),
	2836	+ "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
	2837	+ (long)s->sock_fd, s->sock_family,
	2838	+ s->sock_type,
	2839	+ s->sock_proto);
	2840	+ return PyString_FromString(buf);
	2841	+}
	2842	+
	2843	+
	2844	+/* Create a new, uninitialized socket object. */
	2845	+
	2846	+static PyObject *
	2847	+sock_new(PyTypeObject type, PyObject args, PyObject *kwds)
	2848	+{
	2849	+ PyObject *new;
	2850	+
	2851	+ new = type->tp_alloc(type, 0);
	2852	+ if (new != NULL) {
	2853	+ ((PySocketSockObject *)new)->sock_fd = -1;
	2854	+ ((PySocketSockObject *)new)->sock_timeout = -1.0;
	2855	+ ((PySocketSockObject *)new)->errorhandler = &set_error;
	2856	+ }
	2857	+ return new;
	2858	+}
	2859	+
	2860	+
	2861	+/* Initialize a new socket object. */
	2862	+
	2863	+/ARGSUSED/
	2864	+static int
	2865	+sock_initobj(PyObject self, PyObject args, PyObject *kwds)
	2866	+{
	2867	+ PySocketSockObject s = (PySocketSockObject )self;
	2868	+ SOCKET_T fd;
	2869	+ int family = AF_INET, type = SOCK_STREAM, proto = 0;
	2870	+ static char *keywords[] = {"family", "type", "proto", 0};
	2871	+
	2872	+ if (!PyArg_ParseTupleAndKeywords(args, kwds,
	2873	+ "\|iii:socket", keywords,
	2874	+ &family, &type, &proto))
	2875	+ return -1;
	2876	+
	2877	+ Py_BEGIN_ALLOW_THREADS
	2878	+ fd = socket(family, type, proto);
	2879	+ Py_END_ALLOW_THREADS
	2880	+
	2881	+#ifdef MS_WINDOWS
	2882	+ if (fd == INVALID_SOCKET)
	2883	+#else
	2884	+ if (fd < 0)
	2885	+#endif
	2886	+ {
	2887	+ set_error();
	2888	+ return -1;
	2889	+ }
	2890	+ init_sockobject(s, fd, family, type, proto);
	2891	+
	2892	+ return 0;
	2893	+
	2894	+}
	2895	+
	2896	+
	2897	+/* Type object for socket objects. */
	2898	+
	2899	+static PyTypeObject sock_type = {
	2900	+ PyObject_HEAD_INIT(0) /* Must fill in type value later */
	2901	+ 0, /* ob_size */
	2902	+ "_socket.socket", /* tp_name */
	2903	+ sizeof(PySocketSockObject), /* tp_basicsize */
	2904	+ 0, /* tp_itemsize */
	2905	+ (destructor)sock_dealloc, /* tp_dealloc */
	2906	+ 0, /* tp_print */
	2907	+ 0, /* tp_getattr */
	2908	+ 0, /* tp_setattr */
	2909	+ 0, /* tp_compare */
	2910	+ (reprfunc)sock_repr, /* tp_repr */
	2911	+ 0, /* tp_as_number */
	2912	+ 0, /* tp_as_sequence */
	2913	+ 0, /* tp_as_mapping */
	2914	+ 0, /* tp_hash */
	2915	+ 0, /* tp_call */
	2916	+ 0, /* tp_str */
	2917	+ PyObject_GenericGetAttr, /* tp_getattro */
	2918	+ 0, /* tp_setattro */
	2919	+ 0, /* tp_as_buffer */
	2920	+ Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
	2921	+ sock_doc, /* tp_doc */
	2922	+ 0, /* tp_traverse */
	2923	+ 0, /* tp_clear */
	2924	+ 0, /* tp_richcompare */
	2925	+ 0, /* tp_weaklistoffset */
	2926	+ 0, /* tp_iter */
	2927	+ 0, /* tp_iternext */
	2928	+ sock_methods, /* tp_methods */
	2929	+ sock_memberlist, /* tp_members */
	2930	+ 0, /* tp_getset */
	2931	+ 0, /* tp_base */
	2932	+ 0, /* tp_dict */
	2933	+ 0, /* tp_descr_get */
	2934	+ 0, /* tp_descr_set */
	2935	+ 0, /* tp_dictoffset */
	2936	+ sock_initobj, /* tp_init */
	2937	+ PyType_GenericAlloc, /* tp_alloc */
	2938	+ sock_new, /* tp_new */
	2939	+ PyObject_Del, /* tp_free */
	2940	+};
	2941	+
	2942	+
	2943	+/* Python interface to gethostname(). */
	2944	+
	2945	+/ARGSUSED/
	2946	+static PyObject *
	2947	+socket_gethostname(PyObject self, PyObject unused)
	2948	+{
	2949	+ char buf[1024];
	2950	+ int res;
	2951	+ Py_BEGIN_ALLOW_THREADS
	2952	+ res = gethostname(buf, (int) sizeof buf - 1);
	2953	+ Py_END_ALLOW_THREADS
	2954	+ if (res < 0)
	2955	+ return set_error();
	2956	+ buf[sizeof buf - 1] = '\0';
	2957	+ return PyString_FromString(buf);
	2958	+}
	2959	+
	2960	+PyDoc_STRVAR(gethostname_doc,
	2961	+"gethostname() -> string\n\
	2962	+\n\
	2963	+Return the current host name.");
	2964	+
	2965	+
	2966	+/* Python interface to gethostbyname(name). */
	2967	+
	2968	+/ARGSUSED/
	2969	+static PyObject *
	2970	+socket_gethostbyname(PyObject self, PyObject args)
	2971	+{
	2972	+ char *name;
	2973	+ sock_addr_t addrbuf;
	2974	+
	2975	+ if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
	2976	+ return NULL;
	2977	+ if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
	2978	+ return NULL;
	2979	+ return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
	2980	+}
	2981	+
	2982	+PyDoc_STRVAR(gethostbyname_doc,
	2983	+"gethostbyname(host) -> address\n\
	2984	+\n\
	2985	+Return the IP address (a string of the form '255.255.255.255') for a host.");
	2986	+
	2987	+
	2988	+/* Convenience function common to gethostbyname_ex and gethostbyaddr */
	2989	+
	2990	+static PyObject *
	2991	+gethost_common(struct hostent h, struct sockaddr addr, int alen, int af)
	2992	+{
	2993	+ char **pch;
	2994	+ PyObject rtn_tuple = (PyObject )NULL;
	2995	+ PyObject name_list = (PyObject )NULL;
	2996	+ PyObject addr_list = (PyObject )NULL;
	2997	+ PyObject *tmp;
	2998	+
	2999	+ if (h == NULL) {
	3000	+ /* Let's get real error message to return */
	3001	+#ifndef RISCOS
	3002	+ set_herror(h_errno);
	3003	+#else
	3004	+ PyErr_SetString(socket_error, "host not found");
	3005	+#endif
	3006	+ return NULL;
	3007	+ }
	3008	+
	3009	+ if (h->h_addrtype != af) {
	3010	+#ifdef HAVE_STRERROR
	3011	+ /* Let's get real error message to return */
	3012	+ PyErr_SetString(socket_error,
	3013	+ (char *)strerror(EAFNOSUPPORT));
	3014	+#else
	3015	+ PyErr_SetString(
	3016	+ socket_error,
	3017	+ "Address family not supported by protocol family");
	3018	+#endif
	3019	+ return NULL;
	3020	+ }
	3021	+
	3022	+ switch (af) {
	3023	+
	3024	+ case AF_INET:
	3025	+ if (alen < sizeof(struct sockaddr_in))
	3026	+ return NULL;
	3027	+ break;
	3028	+
	3029	+#ifdef ENABLE_IPV6
	3030	+ case AF_INET6:
	3031	+ if (alen < sizeof(struct sockaddr_in6))
	3032	+ return NULL;
	3033	+ break;
	3034	+#endif
	3035	+
	3036	+ }
	3037	+
	3038	+ if ((name_list = PyList_New(0)) == NULL)
	3039	+ goto err;
	3040	+
	3041	+ if ((addr_list = PyList_New(0)) == NULL)
	3042	+ goto err;
	3043	+
	3044	+ /* SF #1511317: h_aliases can be NULL */
	3045	+ if (h->h_aliases) {
	3046	+ for (pch = h->h_aliases; *pch != NULL; pch++) {
	3047	+ int status;
	3048	+ tmp = PyString_FromString(*pch);
	3049	+ if (tmp == NULL)
	3050	+ goto err;
	3051	+
	3052	+ status = PyList_Append(name_list, tmp);
	3053	+ Py_DECREF(tmp);
	3054	+
	3055	+ if (status)
	3056	+ goto err;
	3057	+ }
	3058	+ }
	3059	+
	3060	+ for (pch = h->h_addr_list; *pch != NULL; pch++) {
	3061	+ int status;
	3062	+
	3063	+ switch (af) {
	3064	+
	3065	+ case AF_INET:
	3066	+ {
	3067	+ struct sockaddr_in sin;
	3068	+ memset(&sin, 0, sizeof(sin));
	3069	+ sin.sin_family = af;
	3070	+#ifdef HAVE_SOCKADDR_SA_LEN
	3071	+ sin.sin_len = sizeof(sin);
	3072	+#endif
	3073	+ memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
	3074	+ tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
	3075	+
	3076	+ if (pch == h->h_addr_list && alen >= sizeof(sin))
	3077	+ memcpy((char *) addr, &sin, sizeof(sin));
	3078	+ break;
	3079	+ }
	3080	+
	3081	+#ifdef ENABLE_IPV6
	3082	+ case AF_INET6:
	3083	+ {
	3084	+ struct sockaddr_in6 sin6;
	3085	+ memset(&sin6, 0, sizeof(sin6));
	3086	+ sin6.sin6_family = af;
	3087	+#ifdef HAVE_SOCKADDR_SA_LEN
	3088	+ sin6.sin6_len = sizeof(sin6);
	3089	+#endif
	3090	+ memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
	3091	+ tmp = makeipaddr((struct sockaddr *)&sin6,
	3092	+ sizeof(sin6));
	3093	+
	3094	+ if (pch == h->h_addr_list && alen >= sizeof(sin6))
	3095	+ memcpy((char *) addr, &sin6, sizeof(sin6));
	3096	+ break;
	3097	+ }
	3098	+#endif
	3099	+
	3100	+ default: /* can't happen */
	3101	+ PyErr_SetString(socket_error,
	3102	+ "unsupported address family");
	3103	+ return NULL;
	3104	+ }
	3105	+
	3106	+ if (tmp == NULL)
	3107	+ goto err;
	3108	+
	3109	+ status = PyList_Append(addr_list, tmp);
	3110	+ Py_DECREF(tmp);
	3111	+
	3112	+ if (status)
	3113	+ goto err;
	3114	+ }
	3115	+
	3116	+ rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
	3117	+
	3118	+ err:
	3119	+ Py_XDECREF(name_list);
	3120	+ Py_XDECREF(addr_list);
	3121	+ return rtn_tuple;
	3122	+}
	3123	+
	3124	+
	3125	+/* Python interface to gethostbyname_ex(name). */
	3126	+
	3127	+/ARGSUSED/
	3128	+static PyObject *
	3129	+socket_gethostbyname_ex(PyObject self, PyObject args)
	3130	+{
	3131	+ char *name;
	3132	+ struct hostent *h;
	3133	+#ifdef ENABLE_IPV6
	3134	+ struct sockaddr_storage addr;
	3135	+#else
	3136	+ struct sockaddr_in addr;
	3137	+#endif
	3138	+ struct sockaddr *sa;
	3139	+ PyObject *ret;
	3140	+#ifdef HAVE_GETHOSTBYNAME_R
	3141	+ struct hostent hp_allocated;
	3142	+#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
	3143	+ struct hostent_data data;
	3144	+#else
	3145	+ char buf[16384];
	3146	+ int buf_len = (sizeof buf) - 1;
	3147	+ int errnop;
	3148	+#endif
	3149	+#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) \|\| defined(HAVE_GETHOSTBYNAME_R_6_ARG)
	3150	+ int result;
	3151	+#endif
	3152	+#endif /* HAVE_GETHOSTBYNAME_R */
	3153	+
	3154	+ if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
	3155	+ return NULL;
	3156	+ if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
	3157	+ return NULL;
	3158	+ Py_BEGIN_ALLOW_THREADS
	3159	+#ifdef HAVE_GETHOSTBYNAME_R
	3160	+#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
	3161	+ result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
	3162	+ &h, &errnop);
	3163	+#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
	3164	+ h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
	3165	+#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
	3166	+ memset((void *) &data, '\0', sizeof(data));
	3167	+ result = gethostbyname_r(name, &hp_allocated, &data);
	3168	+ h = (result != 0) ? NULL : &hp_allocated;
	3169	+#endif
	3170	+#else /* not HAVE_GETHOSTBYNAME_R */
	3171	+#ifdef USE_GETHOSTBYNAME_LOCK
	3172	+ PyThread_acquire_lock(netdb_lock, 1);
	3173	+#endif
	3174	+ h = gethostbyname(name);
	3175	+#endif /* HAVE_GETHOSTBYNAME_R */
	3176	+ Py_END_ALLOW_THREADS
	3177	+ /* Some C libraries would require addr.__ss_family instead of
	3178	+ addr.ss_family.
	3179	+ Therefore, we cast the sockaddr_storage into sockaddr to
	3180	+ access sa_family. */
	3181	+ sa = (struct sockaddr*)&addr;
	3182	+ ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
	3183	+ sa->sa_family);
	3184	+#ifdef USE_GETHOSTBYNAME_LOCK
	3185	+ PyThread_release_lock(netdb_lock);
	3186	+#endif
	3187	+ return ret;
	3188	+}
	3189	+
	3190	+PyDoc_STRVAR(ghbn_ex_doc,
	3191	+"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
	3192	+\n\
	3193	+Return the true host name, a list of aliases, and a list of IP addresses,\n\
	3194	+for a host. The host argument is a string giving a host name or IP number.");
	3195	+
	3196	+
	3197	+/* Python interface to gethostbyaddr(IP). */
	3198	+
	3199	+/ARGSUSED/
	3200	+static PyObject *
	3201	+socket_gethostbyaddr(PyObject self, PyObject args)
	3202	+{
	3203	+#ifdef ENABLE_IPV6
	3204	+ struct sockaddr_storage addr;
	3205	+#else
	3206	+ struct sockaddr_in addr;
	3207	+#endif
	3208	+ struct sockaddr sa = (struct sockaddr )&addr;
	3209	+ char *ip_num;
	3210	+ struct hostent *h;
	3211	+ PyObject *ret;
	3212	+#ifdef HAVE_GETHOSTBYNAME_R
	3213	+ struct hostent hp_allocated;
	3214	+#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
	3215	+ struct hostent_data data;
	3216	+#else
	3217	+ char buf[16384];
	3218	+ int buf_len = (sizeof buf) - 1;
	3219	+ int errnop;
	3220	+#endif
	3221	+#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) \|\| defined(HAVE_GETHOSTBYNAME_R_6_ARG)
	3222	+ int result;
	3223	+#endif
	3224	+#endif /* HAVE_GETHOSTBYNAME_R */
	3225	+ char *ap;
	3226	+ int al;
	3227	+ int af;
	3228	+
	3229	+ if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
	3230	+ return NULL;
	3231	+ af = AF_UNSPEC;
	3232	+ if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
	3233	+ return NULL;
	3234	+ af = sa->sa_family;
	3235	+ ap = NULL;
	3236	+ al = 0;
	3237	+ switch (af) {
	3238	+ case AF_INET:
	3239	+ ap = (char )&((struct sockaddr_in )sa)->sin_addr;
	3240	+ al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
	3241	+ break;
	3242	+#ifdef ENABLE_IPV6
	3243	+ case AF_INET6:
	3244	+ ap = (char )&((struct sockaddr_in6 )sa)->sin6_addr;
	3245	+ al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
	3246	+ break;
	3247	+#endif
	3248	+ default:
	3249	+ PyErr_SetString(socket_error, "unsupported address family");
	3250	+ return NULL;
	3251	+ }
	3252	+ Py_BEGIN_ALLOW_THREADS
	3253	+#ifdef HAVE_GETHOSTBYNAME_R
	3254	+#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
	3255	+ result = gethostbyaddr_r(ap, al, af,
	3256	+ &hp_allocated, buf, buf_len,
	3257	+ &h, &errnop);
	3258	+#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
	3259	+ h = gethostbyaddr_r(ap, al, af,
	3260	+ &hp_allocated, buf, buf_len, &errnop);
	3261	+#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
	3262	+ memset((void *) &data, '\0', sizeof(data));
	3263	+ result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
	3264	+ h = (result != 0) ? NULL : &hp_allocated;
	3265	+#endif
	3266	+#else /* not HAVE_GETHOSTBYNAME_R */
	3267	+#ifdef USE_GETHOSTBYNAME_LOCK
	3268	+ PyThread_acquire_lock(netdb_lock, 1);
	3269	+#endif
	3270	+ h = gethostbyaddr(ap, al, af);
	3271	+#endif /* HAVE_GETHOSTBYNAME_R */
	3272	+ Py_END_ALLOW_THREADS
	3273	+ ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
	3274	+#ifdef USE_GETHOSTBYNAME_LOCK
	3275	+ PyThread_release_lock(netdb_lock);
	3276	+#endif
	3277	+ return ret;
	3278	+}
	3279	+
	3280	+PyDoc_STRVAR(gethostbyaddr_doc,
	3281	+"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
	3282	+\n\
	3283	+Return the true host name, a list of aliases, and a list of IP addresses,\n\
	3284	+for a host. The host argument is a string giving a host name or IP number.");
	3285	+
	3286	+
	3287	+/* Python interface to getservbyname(name).
	3288	+ This only returns the port number, since the other info is already
	3289	+ known or not useful (like the list of aliases). */
	3290	+
	3291	+/ARGSUSED/
	3292	+static PyObject *
	3293	+socket_getservbyname(PyObject self, PyObject args)
	3294	+{
	3295	+ char name, proto=NULL;
	3296	+ struct servent *sp;
	3297	+ if (!PyArg_ParseTuple(args, "s\|s:getservbyname", &name, &proto))
	3298	+ return NULL;
	3299	+ Py_BEGIN_ALLOW_THREADS
	3300	+ sp = getservbyname(name, proto);
	3301	+ Py_END_ALLOW_THREADS
	3302	+ if (sp == NULL) {
	3303	+ PyErr_SetString(socket_error, "service/proto not found");
	3304	+ return NULL;
	3305	+ }
	3306	+ return PyInt_FromLong((long) ntohs(sp->s_port));
	3307	+}
	3308	+
	3309	+PyDoc_STRVAR(getservbyname_doc,
	3310	+"getservbyname(servicename[, protocolname]) -> integer\n\
	3311	+\n\
	3312	+Return a port number from a service name and protocol name.\n\
	3313	+The optional protocol name, if given, should be 'tcp' or 'udp',\n\
	3314	+otherwise any protocol will match.");
	3315	+
	3316	+
	3317	+/* Python interface to getservbyport(port).
	3318	+ This only returns the service name, since the other info is already
	3319	+ known or not useful (like the list of aliases). */
	3320	+
	3321	+/ARGSUSED/
	3322	+static PyObject *
	3323	+socket_getservbyport(PyObject self, PyObject args)
	3324	+{
	3325	+ unsigned short port;
	3326	+ char *proto=NULL;
	3327	+ struct servent *sp;
	3328	+ if (!PyArg_ParseTuple(args, "H\|s:getservbyport", &port, &proto))
	3329	+ return NULL;
	3330	+ Py_BEGIN_ALLOW_THREADS
	3331	+ sp = getservbyport(htons(port), proto);
	3332	+ Py_END_ALLOW_THREADS
	3333	+ if (sp == NULL) {
	3334	+ PyErr_SetString(socket_error, "port/proto not found");
	3335	+ return NULL;
	3336	+ }
	3337	+ return PyString_FromString(sp->s_name);
	3338	+}
	3339	+
	3340	+PyDoc_STRVAR(getservbyport_doc,
	3341	+"getservbyport(port[, protocolname]) -> string\n\
	3342	+\n\
	3343	+Return the service name from a port number and protocol name.\n\
	3344	+The optional protocol name, if given, should be 'tcp' or 'udp',\n\
	3345	+otherwise any protocol will match.");
	3346	+
	3347	+/* Python interface to getprotobyname(name).
	3348	+ This only returns the protocol number, since the other info is
	3349	+ already known or not useful (like the list of aliases). */
	3350	+
	3351	+/ARGSUSED/
	3352	+static PyObject *
	3353	+socket_getprotobyname(PyObject self, PyObject args)
	3354	+{
	3355	+ char *name;
	3356	+ struct protoent *sp;
	3357	+#ifdef __BEOS__
	3358	+/* Not available in BeOS yet. - [cjh] */
	3359	+ PyErr_SetString(socket_error, "getprotobyname not supported");
	3360	+ return NULL;
	3361	+#else
	3362	+ if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
	3363	+ return NULL;
	3364	+ Py_BEGIN_ALLOW_THREADS
	3365	+ sp = getprotobyname(name);
	3366	+ Py_END_ALLOW_THREADS
	3367	+ if (sp == NULL) {
	3368	+ PyErr_SetString(socket_error, "protocol not found");
	3369	+ return NULL;
	3370	+ }
	3371	+ return PyInt_FromLong((long) sp->p_proto);
	3372	+#endif
	3373	+}
	3374	+
	3375	+PyDoc_STRVAR(getprotobyname_doc,
	3376	+"getprotobyname(name) -> integer\n\
	3377	+\n\
	3378	+Return the protocol number for the named protocol. (Rarely used.)");
	3379	+
	3380	+
	3381	+#ifdef HAVE_SOCKETPAIR
	3382	+/* Create a pair of sockets using the socketpair() function.
	3383	+ Arguments as for socket() except the default family is AF_UNIX if
	3384	+ defined on the platform; otherwise, the default is AF_INET. */
	3385	+
	3386	+/ARGSUSED/
	3387	+static PyObject *
	3388	+socket_socketpair(PyObject self, PyObject args)
	3389	+{
	3390	+ PySocketSockObject s0 = NULL, s1 = NULL;
	3391	+ SOCKET_T sv[2];
	3392	+ int family, type = SOCK_STREAM, proto = 0;
	3393	+ PyObject *res = NULL;
	3394	+
	3395	+#if defined(AF_UNIX)
	3396	+ family = AF_UNIX;
	3397	+#else
	3398	+ family = AF_INET;
	3399	+#endif
	3400	+ if (!PyArg_ParseTuple(args, "\|iii:socketpair",
	3401	+ &family, &type, &proto))
	3402	+ return NULL;
	3403	+ /* Create a pair of socket fds */
	3404	+ if (socketpair(family, type, proto, sv) < 0)
	3405	+ return set_error();
	3406	+ s0 = new_sockobject(sv[0], family, type, proto);
	3407	+ if (s0 == NULL)
	3408	+ goto finally;
	3409	+ s1 = new_sockobject(sv[1], family, type, proto);
	3410	+ if (s1 == NULL)
	3411	+ goto finally;
	3412	+ res = PyTuple_Pack(2, s0, s1);
	3413	+
	3414	+finally:
	3415	+ if (res == NULL) {
	3416	+ if (s0 == NULL)
	3417	+ SOCKETCLOSE(sv[0]);
	3418	+ if (s1 == NULL)
	3419	+ SOCKETCLOSE(sv[1]);
	3420	+ }
	3421	+ Py_XDECREF(s0);
	3422	+ Py_XDECREF(s1);
	3423	+ return res;
	3424	+}
	3425	+
	3426	+PyDoc_STRVAR(socketpair_doc,
	3427	+"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
	3428	+\n\
	3429	+Create a pair of socket objects from the sockets returned by the platform\n\
	3430	+socketpair() function.\n\
	3431	+The arguments are the same as for socket() except the default family is\n\
	3432	+AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
	3433	+
	3434	+#endif /* HAVE_SOCKETPAIR */
	3435	+
	3436	+
	3437	+#ifndef NO_DUP
	3438	+/* Create a socket object from a numeric file description.
	3439	+ Useful e.g. if stdin is a socket.
	3440	+ Additional arguments as for socket(). */
	3441	+
	3442	+/ARGSUSED/
	3443	+static PyObject *
	3444	+socket_fromfd(PyObject self, PyObject args)
	3445	+{
	3446	+ PySocketSockObject *s;
	3447	+ SOCKET_T fd;
	3448	+ int family, type, proto = 0;
	3449	+ if (!PyArg_ParseTuple(args, "iii\|i:fromfd",
	3450	+ &fd, &family, &type, &proto))
	3451	+ return NULL;
	3452	+ /* Dup the fd so it and the socket can be closed independently */
	3453	+ fd = dup(fd);
	3454	+ if (fd < 0)
	3455	+ return set_error();
	3456	+ s = new_sockobject(fd, family, type, proto);
	3457	+ return (PyObject *) s;
	3458	+}
	3459	+
	3460	+PyDoc_STRVAR(fromfd_doc,
	3461	+"fromfd(fd, family, type[, proto]) -> socket object\n\
	3462	+\n\
	3463	+Create a socket object from a duplicate of the given\n\
	3464	+file descriptor.\n\
	3465	+The remaining arguments are the same as for socket().");
	3466	+
	3467	+#endif /* NO_DUP */
	3468	+
	3469	+
	3470	+static PyObject *
	3471	+socket_ntohs(PyObject self, PyObject args)
	3472	+{
	3473	+ int x1, x2;
	3474	+
	3475	+ if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
	3476	+ return NULL;
	3477	+ }
	3478	+ x2 = (int)ntohs((short)x1);
	3479	+ return PyInt_FromLong(x2);
	3480	+}
	3481	+
	3482	+PyDoc_STRVAR(ntohs_doc,
	3483	+"ntohs(integer) -> integer\n\
	3484	+\n\
	3485	+Convert a 16-bit integer from network to host byte order.");
	3486	+
	3487	+
	3488	+static PyObject *
	3489	+socket_ntohl(PyObject self, PyObject arg)
	3490	+{
	3491	+ unsigned long x;
	3492	+
	3493	+ if (PyInt_Check(arg)) {
	3494	+ x = PyInt_AS_LONG(arg);
	3495	+ if (x == (unsigned long) -1 && PyErr_Occurred())
	3496	+ return NULL;
	3497	+ }
	3498	+ else if (PyLong_Check(arg)) {
	3499	+ x = PyLong_AsUnsignedLong(arg);
	3500	+ if (x == (unsigned long) -1 && PyErr_Occurred())
	3501	+ return NULL;
	3502	+#if SIZEOF_LONG > 4
	3503	+ {
	3504	+ unsigned long y;
	3505	+ /* only want the trailing 32 bits */
	3506	+ y = x & 0xFFFFFFFFUL;
	3507	+ if (y ^ x)
	3508	+ return PyErr_Format(PyExc_OverflowError,
	3509	+ "long int larger than 32 bits");
	3510	+ x = y;
	3511	+ }
	3512	+#endif
	3513	+ }
	3514	+ else
	3515	+ return PyErr_Format(PyExc_TypeError,
	3516	+ "expected int/long, %s found",
	3517	+ arg->ob_type->tp_name);
	3518	+ if (x == (unsigned long) -1 && PyErr_Occurred())
	3519	+ return NULL;
	3520	+ return PyInt_FromLong(ntohl(x));
	3521	+}
	3522	+
	3523	+PyDoc_STRVAR(ntohl_doc,
	3524	+"ntohl(integer) -> integer\n\
	3525	+\n\
	3526	+Convert a 32-bit integer from network to host byte order.");
	3527	+
	3528	+
	3529	+static PyObject *
	3530	+socket_htons(PyObject self, PyObject args)
	3531	+{
	3532	+ int x1, x2;
	3533	+
	3534	+ if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
	3535	+ return NULL;
	3536	+ }
	3537	+ x2 = (int)htons((short)x1);
	3538	+ return PyInt_FromLong(x2);
	3539	+}
	3540	+
	3541	+PyDoc_STRVAR(htons_doc,
	3542	+"htons(integer) -> integer\n\
	3543	+\n\
	3544	+Convert a 16-bit integer from host to network byte order.");
	3545	+
	3546	+
	3547	+static PyObject *
	3548	+socket_htonl(PyObject self, PyObject arg)
	3549	+{
	3550	+ unsigned long x;
	3551	+
	3552	+ if (PyInt_Check(arg)) {
	3553	+ x = PyInt_AS_LONG(arg);
	3554	+ if (x == (unsigned long) -1 && PyErr_Occurred())
	3555	+ return NULL;
	3556	+ }
	3557	+ else if (PyLong_Check(arg)) {
	3558	+ x = PyLong_AsUnsignedLong(arg);
	3559	+ if (x == (unsigned long) -1 && PyErr_Occurred())
	3560	+ return NULL;
	3561	+#if SIZEOF_LONG > 4
	3562	+ {
	3563	+ unsigned long y;
	3564	+ /* only want the trailing 32 bits */
	3565	+ y = x & 0xFFFFFFFFUL;
	3566	+ if (y ^ x)
	3567	+ return PyErr_Format(PyExc_OverflowError,
	3568	+ "long int larger than 32 bits");
	3569	+ x = y;
	3570	+ }
	3571	+#endif
	3572	+ }
	3573	+ else
	3574	+ return PyErr_Format(PyExc_TypeError,
	3575	+ "expected int/long, %s found",
	3576	+ arg->ob_type->tp_name);
	3577	+ return PyInt_FromLong(htonl(x));
	3578	+}
	3579	+
	3580	+PyDoc_STRVAR(htonl_doc,
	3581	+"htonl(integer) -> integer\n\
	3582	+\n\
	3583	+Convert a 32-bit integer from host to network byte order.");
	3584	+
	3585	+/* socket.inet_aton() and socket.inet_ntoa() functions. */
	3586	+
	3587	+PyDoc_STRVAR(inet_aton_doc,
	3588	+"inet_aton(string) -> packed 32-bit IP representation\n\
	3589	+\n\
	3590	+Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
	3591	+binary format used in low-level network functions.");
	3592	+
	3593	+static PyObject*
	3594	+socket_inet_aton(PyObject self, PyObject args)
	3595	+{
	3596	+#ifndef INADDR_NONE
	3597	+#define INADDR_NONE (-1)
	3598	+#endif
	3599	+#ifdef HAVE_INET_ATON
	3600	+ struct in_addr buf;
	3601	+#endif
	3602	+
	3603	+#if !defined(HAVE_INET_ATON) \|\| defined(USE_INET_ATON_WEAKLINK)
	3604	+ /* Have to use inet_addr() instead */
	3605	+ unsigned long packed_addr;
	3606	+#endif
	3607	+ char *ip_addr;
	3608	+
	3609	+ if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
	3610	+ return NULL;
	3611	+
	3612	+
	3613	+#ifdef HAVE_INET_ATON
	3614	+
	3615	+#ifdef USE_INET_ATON_WEAKLINK
	3616	+ if (inet_aton != NULL) {
	3617	+#endif
	3618	+ if (inet_aton(ip_addr, &buf))
	3619	+ return PyString_FromStringAndSize((char *)(&buf),
	3620	+ sizeof(buf));
	3621	+
	3622	+ PyErr_SetString(socket_error,
	3623	+ "illegal IP address string passed to inet_aton");
	3624	+ return NULL;
	3625	+
	3626	+#ifdef USE_INET_ATON_WEAKLINK
	3627	+ } else {
	3628	+#endif
	3629	+
	3630	+#endif
	3631	+
	3632	+#if !defined(HAVE_INET_ATON) \|\| defined(USE_INET_ATON_WEAKLINK)
	3633	+
	3634	+ /* special-case this address as inet_addr might return INADDR_NONE
	3635	+ * for this */
	3636	+ if (strcmp(ip_addr, "255.255.255.255") == 0) {
	3637	+ packed_addr = 0xFFFFFFFF;
	3638	+ } else {
	3639	+
	3640	+ packed_addr = inet_addr(ip_addr);
	3641	+
	3642	+ if (packed_addr == INADDR_NONE) { /* invalid address */
	3643	+ PyErr_SetString(socket_error,
	3644	+ "illegal IP address string passed to inet_aton");
	3645	+ return NULL;
	3646	+ }
	3647	+ }
	3648	+ return PyString_FromStringAndSize((char *) &packed_addr,
	3649	+ sizeof(packed_addr));
	3650	+
	3651	+#ifdef USE_INET_ATON_WEAKLINK
	3652	+ }
	3653	+#endif
	3654	+
	3655	+#endif
	3656	+}
	3657	+
	3658	+PyDoc_STRVAR(inet_ntoa_doc,
	3659	+"inet_ntoa(packed_ip) -> ip_address_string\n\
	3660	+\n\
	3661	+Convert an IP address from 32-bit packed binary format to string format");
	3662	+
	3663	+static PyObject*
	3664	+socket_inet_ntoa(PyObject self, PyObject args)
	3665	+{
	3666	+ char *packed_str;
	3667	+ int addr_len;
	3668	+ struct in_addr packed_addr;
	3669	+
	3670	+ if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {
	3671	+ return NULL;
	3672	+ }
	3673	+
	3674	+ if (addr_len != sizeof(packed_addr)) {
	3675	+ PyErr_SetString(socket_error,
	3676	+ "packed IP wrong length for inet_ntoa");
	3677	+ return NULL;
	3678	+ }
	3679	+
	3680	+ memcpy(&packed_addr, packed_str, addr_len);
	3681	+
	3682	+ return PyString_FromString(inet_ntoa(packed_addr));
	3683	+}
	3684	+
	3685	+#ifdef HAVE_INET_PTON
	3686	+
	3687	+PyDoc_STRVAR(inet_pton_doc,
	3688	+"inet_pton(af, ip) -> packed IP address string\n\
	3689	+\n\
	3690	+Convert an IP address from string format to a packed string suitable\n\
	3691	+for use with low-level network functions.");
	3692	+
	3693	+static PyObject *
	3694	+socket_inet_pton(PyObject self, PyObject args)
	3695	+{
	3696	+ int af;
	3697	+ char* ip;
	3698	+ int retval;
	3699	+#ifdef ENABLE_IPV6
	3700	+ char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
	3701	+#else
	3702	+ char packed[sizeof(struct in_addr)];
	3703	+#endif
	3704	+ if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
	3705	+ return NULL;
	3706	+ }
	3707	+
	3708	+#if !defined(ENABLE_IPV6) && defined(AF_INET6)
	3709	+ if(af == AF_INET6) {
	3710	+ PyErr_SetString(socket_error,
	3711	+ "can't use AF_INET6, IPv6 is disabled");
	3712	+ return NULL;
	3713	+ }
	3714	+#endif
	3715	+
	3716	+ retval = inet_pton(af, ip, packed);
	3717	+ if (retval < 0) {
	3718	+ PyErr_SetFromErrno(socket_error);
	3719	+ return NULL;
	3720	+ } else if (retval == 0) {
	3721	+ PyErr_SetString(socket_error,
	3722	+ "illegal IP address string passed to inet_pton");
	3723	+ return NULL;
	3724	+ } else if (af == AF_INET) {
	3725	+ return PyString_FromStringAndSize(packed,
	3726	+ sizeof(struct in_addr));
	3727	+#ifdef ENABLE_IPV6
	3728	+ } else if (af == AF_INET6) {
	3729	+ return PyString_FromStringAndSize(packed,
	3730	+ sizeof(struct in6_addr));
	3731	+#endif
	3732	+ } else {
	3733	+ PyErr_SetString(socket_error, "unknown address family");
	3734	+ return NULL;
	3735	+ }
	3736	+}
	3737	+
	3738	+PyDoc_STRVAR(inet_ntop_doc,
	3739	+"inet_ntop(af, packed_ip) -> string formatted IP address\n\
	3740	+\n\
	3741	+Convert a packed IP address of the given family to string format.");
	3742	+
	3743	+static PyObject *
	3744	+socket_inet_ntop(PyObject self, PyObject args)
	3745	+{
	3746	+ int af;
	3747	+ char* packed;
	3748	+ int len;
	3749	+ const char* retval;
	3750	+#ifdef ENABLE_IPV6
	3751	+ char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
	3752	+#else
	3753	+ char ip[INET_ADDRSTRLEN + 1];
	3754	+#endif
	3755	+
	3756	+ /* Guarantee NUL-termination for PyString_FromString() below */
	3757	+ memset((void *) &ip[0], '\0', sizeof(ip));
	3758	+
	3759	+ if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {
	3760	+ return NULL;
	3761	+ }
	3762	+
	3763	+ if (af == AF_INET) {
	3764	+ if (len != sizeof(struct in_addr)) {
	3765	+ PyErr_SetString(PyExc_ValueError,
	3766	+ "invalid length of packed IP address string");
	3767	+ return NULL;
	3768	+ }
	3769	+#ifdef ENABLE_IPV6
	3770	+ } else if (af == AF_INET6) {
	3771	+ if (len != sizeof(struct in6_addr)) {
	3772	+ PyErr_SetString(PyExc_ValueError,
	3773	+ "invalid length of packed IP address string");
	3774	+ return NULL;
	3775	+ }
	3776	+#endif
	3777	+ } else {
	3778	+ PyErr_Format(PyExc_ValueError,
	3779	+ "unknown address family %d", af);
	3780	+ return NULL;
	3781	+ }
	3782	+
	3783	+ retval = inet_ntop(af, packed, ip, sizeof(ip));
	3784	+ if (!retval) {
	3785	+ PyErr_SetFromErrno(socket_error);
	3786	+ return NULL;
	3787	+ } else {
	3788	+ return PyString_FromString(retval);
	3789	+ }
	3790	+
	3791	+ /* NOTREACHED */
	3792	+ PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
	3793	+ return NULL;
	3794	+}
	3795	+
	3796	+#endif /* HAVE_INET_PTON */
	3797	+
	3798	+/* Python interface to getaddrinfo(host, port). */
	3799	+
	3800	+/ARGSUSED/
	3801	+static PyObject *
	3802	+socket_getaddrinfo(PyObject self, PyObject args)
	3803	+{
	3804	+ struct addrinfo hints, *res;
	3805	+ struct addrinfo *res0 = NULL;
	3806	+ PyObject *hobj = NULL;
	3807	+ PyObject pobj = (PyObject )NULL;
	3808	+ char pbuf[30];
	3809	+ char hptr, pptr;
	3810	+ int family, socktype, protocol, flags;
	3811	+ int error;
	3812	+ PyObject all = (PyObject )NULL;
	3813	+ PyObject single = (PyObject )NULL;
	3814	+ PyObject *idna = NULL;
	3815	+
	3816	+ family = socktype = protocol = flags = 0;
	3817	+ family = AF_UNSPEC;
	3818	+ if (!PyArg_ParseTuple(args, "OO\|iiii:getaddrinfo",
	3819	+ &hobj, &pobj, &family, &socktype,
	3820	+ &protocol, &flags)) {
	3821	+ return NULL;
	3822	+ }
	3823	+ if (hobj == Py_None) {
	3824	+ hptr = NULL;
	3825	+ } else if (PyUnicode_Check(hobj)) {
	3826	+ idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
	3827	+ if (!idna)
	3828	+ return NULL;
	3829	+ hptr = PyString_AsString(idna);
	3830	+ } else if (PyString_Check(hobj)) {
	3831	+ hptr = PyString_AsString(hobj);
	3832	+ } else {
	3833	+ PyErr_SetString(PyExc_TypeError,
	3834	+ "getaddrinfo() argument 1 must be string or None");
	3835	+ return NULL;
	3836	+ }
	3837	+ if (PyInt_Check(pobj)) {
	3838	+ PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
	3839	+ pptr = pbuf;
	3840	+ } else if (PyString_Check(pobj)) {
	3841	+ pptr = PyString_AsString(pobj);
	3842	+ } else if (pobj == Py_None) {
	3843	+ pptr = (char *)NULL;
	3844	+ } else {
	3845	+ PyErr_SetString(socket_error, "Int or String expected");
	3846	+ goto err;
	3847	+ }
	3848	+ memset(&hints, 0, sizeof(hints));
	3849	+ hints.ai_family = family;
	3850	+ hints.ai_socktype = socktype;
	3851	+ hints.ai_protocol = protocol;
	3852	+ hints.ai_flags = flags;
	3853	+ Py_BEGIN_ALLOW_THREADS
	3854	+ ACQUIRE_GETADDRINFO_LOCK
	3855	+ error = getaddrinfo(hptr, pptr, &hints, &res0);
	3856	+ Py_END_ALLOW_THREADS
	3857	+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
	3858	+ if (error) {
	3859	+ set_gaierror(error);
	3860	+ goto err;
	3861	+ }
	3862	+
	3863	+ if ((all = PyList_New(0)) == NULL)
	3864	+ goto err;
	3865	+ for (res = res0; res; res = res->ai_next) {
	3866	+ PyObject *addr =
	3867	+ makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
	3868	+ if (addr == NULL)
	3869	+ goto err;
	3870	+ single = Py_BuildValue("iiisO", res->ai_family,
	3871	+ res->ai_socktype, res->ai_protocol,
	3872	+ res->ai_canonname ? res->ai_canonname : "",
	3873	+ addr);
	3874	+ Py_DECREF(addr);
	3875	+ if (single == NULL)
	3876	+ goto err;
	3877	+
	3878	+ if (PyList_Append(all, single))
	3879	+ goto err;
	3880	+ Py_XDECREF(single);
	3881	+ }
	3882	+ Py_XDECREF(idna);
	3883	+ if (res0)
	3884	+ freeaddrinfo(res0);
	3885	+ return all;
	3886	+ err:
	3887	+ Py_XDECREF(single);
	3888	+ Py_XDECREF(all);
	3889	+ Py_XDECREF(idna);
	3890	+ if (res0)
	3891	+ freeaddrinfo(res0);
	3892	+ return (PyObject *)NULL;
	3893	+}
	3894	+
	3895	+PyDoc_STRVAR(getaddrinfo_doc,
	3896	+"getaddrinfo(host, port [, family, socktype, proto, flags])\n\
	3897	+ -> list of (family, socktype, proto, canonname, sockaddr)\n\
	3898	+\n\
	3899	+Resolve host and port into addrinfo struct.");
	3900	+
	3901	+/* Python interface to getnameinfo(sa, flags). */
	3902	+
	3903	+/ARGSUSED/
	3904	+static PyObject *
	3905	+socket_getnameinfo(PyObject self, PyObject args)
	3906	+{
	3907	+ PyObject sa = (PyObject )NULL;
	3908	+ int flags;
	3909	+ char *hostp;
	3910	+ int port, flowinfo, scope_id;
	3911	+ char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
	3912	+ struct addrinfo hints, *res = NULL;
	3913	+ int error;
	3914	+ PyObject ret = (PyObject )NULL;
	3915	+
	3916	+ flags = flowinfo = scope_id = 0;
	3917	+ if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
	3918	+ return NULL;
	3919	+ if (!PyArg_ParseTuple(sa, "si\|ii",
	3920	+ &hostp, &port, &flowinfo, &scope_id))
	3921	+ return NULL;
	3922	+ PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
	3923	+ memset(&hints, 0, sizeof(hints));
	3924	+ hints.ai_family = AF_UNSPEC;
	3925	+ hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
	3926	+ Py_BEGIN_ALLOW_THREADS
	3927	+ ACQUIRE_GETADDRINFO_LOCK
	3928	+ error = getaddrinfo(hostp, pbuf, &hints, &res);
	3929	+ Py_END_ALLOW_THREADS
	3930	+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
	3931	+ if (error) {
	3932	+ set_gaierror(error);
	3933	+ goto fail;
	3934	+ }
	3935	+ if (res->ai_next) {
	3936	+ PyErr_SetString(socket_error,
	3937	+ "sockaddr resolved to multiple addresses");
	3938	+ goto fail;
	3939	+ }
	3940	+ switch (res->ai_family) {
	3941	+ case AF_INET:
	3942	+ {
	3943	+ char *t1;
	3944	+ int t2;
	3945	+ if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) {
	3946	+ PyErr_SetString(socket_error,
	3947	+ "IPv4 sockaddr must be 2 tuple");
	3948	+ goto fail;
	3949	+ }
	3950	+ break;
	3951	+ }
	3952	+#ifdef ENABLE_IPV6
	3953	+ case AF_INET6:
	3954	+ {
	3955	+ struct sockaddr_in6 *sin6;
	3956	+ sin6 = (struct sockaddr_in6 *)res->ai_addr;
	3957	+ sin6->sin6_flowinfo = flowinfo;
	3958	+ sin6->sin6_scope_id = scope_id;
	3959	+ break;
	3960	+ }
	3961	+#endif
	3962	+ }
	3963	+ error = getnameinfo(res->ai_addr, res->ai_addrlen,
	3964	+ hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
	3965	+ if (error) {
	3966	+ set_gaierror(error);
	3967	+ goto fail;
	3968	+ }
	3969	+ ret = Py_BuildValue("ss", hbuf, pbuf);
	3970	+
	3971	+fail:
	3972	+ if (res)
	3973	+ freeaddrinfo(res);
	3974	+ return ret;
	3975	+}
	3976	+
	3977	+PyDoc_STRVAR(getnameinfo_doc,
	3978	+"getnameinfo(sockaddr, flags) --> (host, port)\n\
	3979	+\n\
	3980	+Get host and port for a sockaddr.");
	3981	+
	3982	+
	3983	+/* Python API to getting and setting the default timeout value. */
	3984	+
	3985	+static PyObject *
	3986	+socket_getdefaulttimeout(PyObject *self)
	3987	+{
	3988	+ if (defaulttimeout < 0.0) {
	3989	+ Py_INCREF(Py_None);
	3990	+ return Py_None;
	3991	+ }
	3992	+ else
	3993	+ return PyFloat_FromDouble(defaulttimeout);
	3994	+}
	3995	+
	3996	+PyDoc_STRVAR(getdefaulttimeout_doc,
	3997	+"getdefaulttimeout() -> timeout\n\
	3998	+\n\
	3999	+Returns the default timeout in floating seconds for new socket objects.\n\
	4000	+A value of None indicates that new socket objects have no timeout.\n\
	4001	+When the socket module is first imported, the default is None.");
	4002	+
	4003	+static PyObject *
	4004	+socket_setdefaulttimeout(PyObject self, PyObject arg)
	4005	+{
	4006	+ double timeout;
	4007	+
	4008	+ if (arg == Py_None)
	4009	+ timeout = -1.0;
	4010	+ else {
	4011	+ timeout = PyFloat_AsDouble(arg);
	4012	+ if (timeout < 0.0) {
	4013	+ if (!PyErr_Occurred())
	4014	+ PyErr_SetString(PyExc_ValueError,
	4015	+ "Timeout value out of range");
	4016	+ return NULL;
	4017	+ }
	4018	+ }
	4019	+
	4020	+ defaulttimeout = timeout;
	4021	+
	4022	+ Py_INCREF(Py_None);
	4023	+ return Py_None;
	4024	+}
	4025	+
	4026	+PyDoc_STRVAR(setdefaulttimeout_doc,
	4027	+"setdefaulttimeout(timeout)\n\
	4028	+\n\
	4029	+Set the default timeout in floating seconds for new socket objects.\n\
	4030	+A value of None indicates that new socket objects have no timeout.\n\
	4031	+When the socket module is first imported, the default is None.");
	4032	+
	4033	+
	4034	+/* List of functions exported by this module. */
	4035	+
	4036	+static PyMethodDef socket_methods[] = {
	4037	+ {"gethostbyname", socket_gethostbyname,
	4038	+ METH_VARARGS, gethostbyname_doc},
	4039	+ {"gethostbyname_ex", socket_gethostbyname_ex,
	4040	+ METH_VARARGS, ghbn_ex_doc},
	4041	+ {"gethostbyaddr", socket_gethostbyaddr,
	4042	+ METH_VARARGS, gethostbyaddr_doc},
	4043	+ {"gethostname", socket_gethostname,
	4044	+ METH_NOARGS, gethostname_doc},
	4045	+ {"getservbyname", socket_getservbyname,
	4046	+ METH_VARARGS, getservbyname_doc},
	4047	+ {"getservbyport", socket_getservbyport,
	4048	+ METH_VARARGS, getservbyport_doc},
	4049	+ {"getprotobyname", socket_getprotobyname,
	4050	+ METH_VARARGS, getprotobyname_doc},
	4051	+#ifndef NO_DUP
	4052	+ {"fromfd", socket_fromfd,
	4053	+ METH_VARARGS, fromfd_doc},
	4054	+#endif
	4055	+#ifdef HAVE_SOCKETPAIR
	4056	+ {"socketpair", socket_socketpair,
	4057	+ METH_VARARGS, socketpair_doc},
	4058	+#endif
	4059	+ {"ntohs", socket_ntohs,
	4060	+ METH_VARARGS, ntohs_doc},
	4061	+ {"ntohl", socket_ntohl,
	4062	+ METH_O, ntohl_doc},
	4063	+ {"htons", socket_htons,
	4064	+ METH_VARARGS, htons_doc},
	4065	+ {"htonl", socket_htonl,
	4066	+ METH_O, htonl_doc},
	4067	+ {"inet_aton", socket_inet_aton,
	4068	+ METH_VARARGS, inet_aton_doc},
	4069	+ {"inet_ntoa", socket_inet_ntoa,
	4070	+ METH_VARARGS, inet_ntoa_doc},
	4071	+#ifdef HAVE_INET_PTON
	4072	+ {"inet_pton", socket_inet_pton,
	4073	+ METH_VARARGS, inet_pton_doc},
	4074	+ {"inet_ntop", socket_inet_ntop,
	4075	+ METH_VARARGS, inet_ntop_doc},
	4076	+#endif
	4077	+ {"getaddrinfo", socket_getaddrinfo,
	4078	+ METH_VARARGS, getaddrinfo_doc},
	4079	+ {"getnameinfo", socket_getnameinfo,
	4080	+ METH_VARARGS, getnameinfo_doc},
	4081	+ {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
	4082	+ METH_NOARGS, getdefaulttimeout_doc},
	4083	+ {"setdefaulttimeout", socket_setdefaulttimeout,
	4084	+ METH_O, setdefaulttimeout_doc},
	4085	+ {NULL, NULL} /* Sentinel */
	4086	+};
	4087	+
	4088	+
	4089	+#ifdef RISCOS
	4090	+#define OS_INIT_DEFINED
	4091	+
	4092	+static int
	4093	+os_init(void)
	4094	+{
	4095	+ _kernel_swi_regs r;
	4096	+
	4097	+ r.r[0] = 0;
	4098	+ _kernel_swi(0x43380, &r, &r);
	4099	+ taskwindow = r.r[0];
	4100	+
	4101	+ return 1;
	4102	+}
	4103	+
	4104	+#endif /* RISCOS */
	4105	+
	4106	+
	4107	+#ifdef MS_WINDOWS
	4108	+#define OS_INIT_DEFINED
	4109	+
	4110	+/* Additional initialization and cleanup for Windows */
	4111	+
	4112	+static void
	4113	+os_cleanup(void)
	4114	+{
	4115	+ WSACleanup();
	4116	+}
	4117	+
	4118	+static int
	4119	+os_init(void)
	4120	+{
	4121	+ WSADATA WSAData;
	4122	+ int ret;
	4123	+ char buf[100];
	4124	+ ret = WSAStartup(0x0101, &WSAData);
	4125	+ switch (ret) {
	4126	+ case 0: /* No error */
	4127	+ Py_AtExit(os_cleanup);
	4128	+ return 1; /* Success */
	4129	+ case WSASYSNOTREADY:
	4130	+ PyErr_SetString(PyExc_ImportError,
	4131	+ "WSAStartup failed: network not ready");
	4132	+ break;
	4133	+ case WSAVERNOTSUPPORTED:
	4134	+ case WSAEINVAL:
	4135	+ PyErr_SetString(
	4136	+ PyExc_ImportError,
	4137	+ "WSAStartup failed: requested version not supported");
	4138	+ break;
	4139	+ default:
	4140	+ PyOS_snprintf(buf, sizeof(buf),
	4141	+ "WSAStartup failed: error code %d", ret);
	4142	+ PyErr_SetString(PyExc_ImportError, buf);
	4143	+ break;
	4144	+ }
	4145	+ return 0; /* Failure */
	4146	+}
	4147	+
	4148	+#endif /* MS_WINDOWS */
	4149	+
	4150	+
	4151	+#ifdef PYOS_OS2
	4152	+#define OS_INIT_DEFINED
	4153	+
	4154	+/* Additional initialization for OS/2 */
	4155	+
	4156	+static int
	4157	+os_init(void)
	4158	+{
	4159	+#ifndef PYCC_GCC
	4160	+ char reason[64];
	4161	+ int rc = sock_init();
	4162	+
	4163	+ if (rc == 0) {
	4164	+ return 1; /* Success */
	4165	+ }
	4166	+
	4167	+ PyOS_snprintf(reason, sizeof(reason),
	4168	+ "OS/2 TCP/IP Error# %d", sock_errno());
	4169	+ PyErr_SetString(PyExc_ImportError, reason);
	4170	+
	4171	+ return 0; /* Failure */
	4172	+#else
	4173	+ /* No need to initialise sockets with GCC/EMX */
	4174	+ return 1; /* Success */
	4175	+#endif
	4176	+}
	4177	+
	4178	+#endif /* PYOS_OS2 */
	4179	+
	4180	+
	4181	+#ifndef OS_INIT_DEFINED
	4182	+static int
	4183	+os_init(void)
	4184	+{
	4185	+ return 1; /* Success */
	4186	+}
	4187	+#endif
	4188	+
	4189	+
	4190	+/* C API table - always add new things to the end for binary
	4191	+ compatibility. */
	4192	+static
	4193	+PySocketModule_APIObject PySocketModuleAPI =
	4194	+{
	4195	+ &sock_type,
	4196	+ NULL
	4197	+};
	4198	+
	4199	+
	4200	+/* Initialize the _socket module.
	4201	+
	4202	+ This module is actually called "_socket", and there's a wrapper
	4203	+ "socket.py" which implements some additional functionality. On some
	4204	+ platforms (e.g. Windows and OS/2), socket.py also implements a
	4205	+ wrapper for the socket type that provides missing functionality such
	4206	+ as makefile(), dup() and fromfd(). The import of "_socket" may fail
	4207	+ with an ImportError exception if os-specific initialization fails.
	4208	+ On Windows, this does WINSOCK initialization. When WINSOCK is
	4209	+ initialized succesfully, a call to WSACleanup() is scheduled to be
	4210	+ made at exit time.
	4211	+*/
	4212	+
	4213	+PyDoc_STRVAR(socket_doc,
	4214	+"Implementation module for socket operations.\n\
	4215	+\n\
	4216	+See the socket module for documentation.");
	4217	+
	4218	+PyMODINIT_FUNC
	4219	+init_socket(void)
	4220	+{
	4221	+ PyObject m, has_ipv6;
	4222	+
	4223	+ if (!os_init())
	4224	+ return;
	4225	+
	4226	+ sock_type.ob_type = &PyType_Type;
	4227	+ m = Py_InitModule3(PySocket_MODULE_NAME,
	4228	+ socket_methods,
	4229	+ socket_doc);
	4230	+ if (m == NULL)
	4231	+ return;
	4232	+
	4233	+ socket_error = PyErr_NewException("socket.error", NULL, NULL);
	4234	+ if (socket_error == NULL)
	4235	+ return;
	4236	+ PySocketModuleAPI.error = socket_error;
	4237	+ Py_INCREF(socket_error);
	4238	+ PyModule_AddObject(m, "error", socket_error);
	4239	+ socket_herror = PyErr_NewException("socket.herror",
	4240	+ socket_error, NULL);
	4241	+ if (socket_herror == NULL)
	4242	+ return;
	4243	+ Py_INCREF(socket_herror);
	4244	+ PyModule_AddObject(m, "herror", socket_herror);
	4245	+ socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
	4246	+ NULL);
	4247	+ if (socket_gaierror == NULL)
	4248	+ return;
	4249	+ Py_INCREF(socket_gaierror);
	4250	+ PyModule_AddObject(m, "gaierror", socket_gaierror);
	4251	+ socket_timeout = PyErr_NewException("socket.timeout",
	4252	+ socket_error, NULL);
	4253	+ if (socket_timeout == NULL)
	4254	+ return;
	4255	+ Py_INCREF(socket_timeout);
	4256	+ PyModule_AddObject(m, "timeout", socket_timeout);
	4257	+ Py_INCREF((PyObject *)&sock_type);
	4258	+ if (PyModule_AddObject(m, "SocketType",
	4259	+ (PyObject *)&sock_type) != 0)
	4260	+ return;
	4261	+ Py_INCREF((PyObject *)&sock_type);
	4262	+ if (PyModule_AddObject(m, "socket",
	4263	+ (PyObject *)&sock_type) != 0)
	4264	+ return;
	4265	+
	4266	+#ifdef ENABLE_IPV6
	4267	+ has_ipv6 = Py_True;
	4268	+#else
	4269	+ has_ipv6 = Py_False;
	4270	+#endif
	4271	+ Py_INCREF(has_ipv6);
	4272	+ PyModule_AddObject(m, "has_ipv6", has_ipv6);
	4273	+
	4274	+ /* Export C API */
	4275	+ if (PyModule_AddObject(m, PySocket_CAPI_NAME,
	4276	+ PyCObject_FromVoidPtr((void *)&PySocketModuleAPI, NULL)
	4277	+ ) != 0)
	4278	+ return;
	4279	+
	4280	+ /* Address families (we only support AF_INET and AF_UNIX) */
	4281	+#ifdef AF_UNSPEC
	4282	+ PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
	4283	+#endif
	4284	+ PyModule_AddIntConstant(m, "AF_INET", AF_INET);
	4285	+#ifdef AF_INET6
	4286	+ PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
	4287	+#endif /* AF_INET6 */
	4288	+#if defined(AF_UNIX)
	4289	+ PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
	4290	+#endif /* AF_UNIX */
	4291	+#ifdef AF_AX25
	4292	+ /* Amateur Radio AX.25 */
	4293	+ PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
	4294	+#endif
	4295	+#ifdef AF_IPX
	4296	+ PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
	4297	+#endif
	4298	+#ifdef AF_APPLETALK
	4299	+ /* Appletalk DDP */
	4300	+ PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
	4301	+#endif
	4302	+#ifdef AF_NETROM
	4303	+ /* Amateur radio NetROM */
	4304	+ PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
	4305	+#endif
	4306	+#ifdef AF_BRIDGE
	4307	+ /* Multiprotocol bridge */
	4308	+ PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
	4309	+#endif
	4310	+#ifdef AF_ATMPVC
	4311	+ /* ATM PVCs */
	4312	+ PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
	4313	+#endif
	4314	+#ifdef AF_AAL5
	4315	+ /* Reserved for Werner's ATM */
	4316	+ PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
	4317	+#endif
	4318	+#ifdef AF_X25
	4319	+ /* Reserved for X.25 project */
	4320	+ PyModule_AddIntConstant(m, "AF_X25", AF_X25);
	4321	+#endif
	4322	+#ifdef AF_INET6
	4323	+ PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
	4324	+#endif
	4325	+#ifdef AF_ROSE
	4326	+ /* Amateur Radio X.25 PLP */
	4327	+ PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
	4328	+#endif
	4329	+#ifdef AF_DECnet
	4330	+ /* Reserved for DECnet project */
	4331	+ PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
	4332	+#endif
	4333	+#ifdef AF_NETBEUI
	4334	+ /* Reserved for 802.2LLC project */
	4335	+ PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
	4336	+#endif
	4337	+#ifdef AF_SECURITY
	4338	+ /* Security callback pseudo AF */
	4339	+ PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
	4340	+#endif
	4341	+#ifdef AF_KEY
	4342	+ /* PF_KEY key management API */
	4343	+ PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
	4344	+#endif
	4345	+#ifdef AF_NETLINK
	4346	+ /* */
	4347	+ PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
	4348	+ PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
	4349	+#ifdef NETLINK_SKIP
	4350	+ PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
	4351	+#endif
	4352	+#ifdef NETLINK_W1
	4353	+ PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
	4354	+#endif
	4355	+ PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
	4356	+ PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
	4357	+#ifdef NETLINK_TCPDIAG
	4358	+ PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
	4359	+#endif
	4360	+#ifdef NETLINK_NFLOG
	4361	+ PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
	4362	+#endif
	4363	+#ifdef NETLINK_XFRM
	4364	+ PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
	4365	+#endif
	4366	+#ifdef NETLINK_ARPD
	4367	+ PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
	4368	+#endif
	4369	+#ifdef NETLINK_ROUTE6
	4370	+ PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
	4371	+#endif
	4372	+ PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
	4373	+#ifdef NETLINK_DNRTMSG
	4374	+ PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
	4375	+#endif
	4376	+#ifdef NETLINK_TAPBASE
	4377	+ PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
	4378	+#endif
	4379	+#endif /* AF_NETLINK */
	4380	+#ifdef AF_ROUTE
	4381	+ /* Alias to emulate 4.4BSD */
	4382	+ PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
	4383	+#endif
	4384	+#ifdef AF_ASH
	4385	+ /* Ash */
	4386	+ PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
	4387	+#endif
	4388	+#ifdef AF_ECONET
	4389	+ /* Acorn Econet */
	4390	+ PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
	4391	+#endif
	4392	+#ifdef AF_ATMSVC
	4393	+ /* ATM SVCs */
	4394	+ PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
	4395	+#endif
	4396	+#ifdef AF_SNA
	4397	+ /* Linux SNA Project (nutters!) */
	4398	+ PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
	4399	+#endif
	4400	+#ifdef AF_IRDA
	4401	+ /* IRDA sockets */
	4402	+ PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
	4403	+#endif
	4404	+#ifdef AF_PPPOX
	4405	+ /* PPPoX sockets */
	4406	+ PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
	4407	+#endif
	4408	+#ifdef AF_WANPIPE
	4409	+ /* Wanpipe API Sockets */
	4410	+ PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
	4411	+#endif
	4412	+#ifdef AF_LLC
	4413	+ /* Linux LLC */
	4414	+ PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
	4415	+#endif
	4416	+
	4417	+#ifdef USE_BLUETOOTH
	4418	+ PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
	4419	+ PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
	4420	+#if !defined(__FreeBSD__)
	4421	+ PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
	4422	+#endif
	4423	+ PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
	4424	+ PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
	4425	+ PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
	4426	+#endif
	4427	+
	4428	+#ifdef HAVE_NETPACKET_PACKET_H
	4429	+ PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
	4430	+ PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
	4431	+ PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
	4432	+ PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
	4433	+ PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
	4434	+ PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
	4435	+ PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
	4436	+ PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
	4437	+ PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
	4438	+#endif
	4439	+
	4440	+ /* Socket types */
	4441	+ PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
	4442	+ PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
	4443	+#ifndef __BEOS__
	4444	+/* We have incomplete socket support. */
	4445	+ PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
	4446	+ PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
	4447	+#if defined(SOCK_RDM)
	4448	+ PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
	4449	+#endif
	4450	+#endif
	4451	+
	4452	+#ifdef SO_DEBUG
	4453	+ PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
	4454	+#endif
	4455	+#ifdef SO_ACCEPTCONN
	4456	+ PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
	4457	+#endif
	4458	+#ifdef SO_REUSEADDR
	4459	+ PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
	4460	+#endif
	4461	+#ifdef SO_EXCLUSIVEADDRUSE
	4462	+ PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
	4463	+#endif
	4464	+
	4465	+#ifdef SO_KEEPALIVE
	4466	+ PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
	4467	+#endif
	4468	+#ifdef SO_DONTROUTE
	4469	+ PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
	4470	+#endif
	4471	+#ifdef SO_BROADCAST
	4472	+ PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
	4473	+#endif
	4474	+#ifdef SO_USELOOPBACK
	4475	+ PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
	4476	+#endif
	4477	+#ifdef SO_LINGER
	4478	+ PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
	4479	+#endif
	4480	+#ifdef SO_OOBINLINE
	4481	+ PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
	4482	+#endif
	4483	+#ifdef SO_REUSEPORT
	4484	+ PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
	4485	+#endif
	4486	+#ifdef SO_SNDBUF
	4487	+ PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
	4488	+#endif
	4489	+#ifdef SO_RCVBUF
	4490	+ PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
	4491	+#endif
	4492	+#ifdef SO_SNDLOWAT
	4493	+ PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
	4494	+#endif
	4495	+#ifdef SO_RCVLOWAT
	4496	+ PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
	4497	+#endif
	4498	+#ifdef SO_SNDTIMEO
	4499	+ PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
	4500	+#endif
	4501	+#ifdef SO_RCVTIMEO
	4502	+ PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
	4503	+#endif
	4504	+#ifdef SO_ERROR
	4505	+ PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
	4506	+#endif
	4507	+#ifdef SO_TYPE
	4508	+ PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
	4509	+#endif
	4510	+
	4511	+ /* Maximum number of connections for "listen" */
	4512	+#ifdef SOMAXCONN
	4513	+ PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
	4514	+#else
	4515	+ PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
	4516	+#endif
	4517	+
	4518	+ /* Flags for send, recv */
	4519	+#ifdef MSG_OOB
	4520	+ PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
	4521	+#endif
	4522	+#ifdef MSG_PEEK
	4523	+ PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
	4524	+#endif
	4525	+#ifdef MSG_DONTROUTE
	4526	+ PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
	4527	+#endif
	4528	+#ifdef MSG_DONTWAIT
	4529	+ PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
	4530	+#endif
	4531	+#ifdef MSG_EOR
	4532	+ PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
	4533	+#endif
	4534	+#ifdef MSG_TRUNC
	4535	+ PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
	4536	+#endif
	4537	+#ifdef MSG_CTRUNC
	4538	+ PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
	4539	+#endif
	4540	+#ifdef MSG_WAITALL
	4541	+ PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
	4542	+#endif
	4543	+#ifdef MSG_BTAG
	4544	+ PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
	4545	+#endif
	4546	+#ifdef MSG_ETAG
	4547	+ PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
	4548	+#endif
	4549	+
	4550	+ /* Protocol level and numbers, usable for [gs]etsockopt */
	4551	+#ifdef SOL_SOCKET
	4552	+ PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
	4553	+#endif
	4554	+#ifdef SOL_IP
	4555	+ PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
	4556	+#else
	4557	+ PyModule_AddIntConstant(m, "SOL_IP", 0);
	4558	+#endif
	4559	+#ifdef SOL_IPX
	4560	+ PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
	4561	+#endif
	4562	+#ifdef SOL_AX25
	4563	+ PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
	4564	+#endif
	4565	+#ifdef SOL_ATALK
	4566	+ PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
	4567	+#endif
	4568	+#ifdef SOL_NETROM
	4569	+ PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
	4570	+#endif
	4571	+#ifdef SOL_ROSE
	4572	+ PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
	4573	+#endif
	4574	+#ifdef SOL_TCP
	4575	+ PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
	4576	+#else
	4577	+ PyModule_AddIntConstant(m, "SOL_TCP", 6);
	4578	+#endif
	4579	+#ifdef SOL_UDP
	4580	+ PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
	4581	+#else
	4582	+ PyModule_AddIntConstant(m, "SOL_UDP", 17);
	4583	+#endif
	4584	+#ifdef IPPROTO_IP
	4585	+ PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
	4586	+#else
	4587	+ PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
	4588	+#endif
	4589	+#ifdef IPPROTO_HOPOPTS
	4590	+ PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
	4591	+#endif
	4592	+#ifdef IPPROTO_ICMP
	4593	+ PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
	4594	+#else
	4595	+ PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
	4596	+#endif
	4597	+#ifdef IPPROTO_IGMP
	4598	+ PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
	4599	+#endif
	4600	+#ifdef IPPROTO_GGP
	4601	+ PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
	4602	+#endif
	4603	+#ifdef IPPROTO_IPV4
	4604	+ PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
	4605	+#endif
	4606	+#ifdef IPPROTO_IPV6
	4607	+ PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
	4608	+#endif
	4609	+#ifdef IPPROTO_IPIP
	4610	+ PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
	4611	+#endif
	4612	+#ifdef IPPROTO_TCP
	4613	+ PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
	4614	+#else
	4615	+ PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
	4616	+#endif
	4617	+#ifdef IPPROTO_EGP
	4618	+ PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
	4619	+#endif
	4620	+#ifdef IPPROTO_PUP
	4621	+ PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
	4622	+#endif
	4623	+#ifdef IPPROTO_UDP
	4624	+ PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
	4625	+#else
	4626	+ PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
	4627	+#endif
	4628	+#ifdef IPPROTO_IDP
	4629	+ PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
	4630	+#endif
	4631	+#ifdef IPPROTO_HELLO
	4632	+ PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
	4633	+#endif
	4634	+#ifdef IPPROTO_ND
	4635	+ PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
	4636	+#endif
	4637	+#ifdef IPPROTO_TP
	4638	+ PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
	4639	+#endif
	4640	+#ifdef IPPROTO_IPV6
	4641	+ PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
	4642	+#endif
	4643	+#ifdef IPPROTO_ROUTING
	4644	+ PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
	4645	+#endif
	4646	+#ifdef IPPROTO_FRAGMENT
	4647	+ PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
	4648	+#endif
	4649	+#ifdef IPPROTO_RSVP
	4650	+ PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
	4651	+#endif
	4652	+#ifdef IPPROTO_GRE
	4653	+ PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
	4654	+#endif
	4655	+#ifdef IPPROTO_ESP
	4656	+ PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
	4657	+#endif
	4658	+#ifdef IPPROTO_AH
	4659	+ PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
	4660	+#endif
	4661	+#ifdef IPPROTO_MOBILE
	4662	+ PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
	4663	+#endif
	4664	+#ifdef IPPROTO_ICMPV6
	4665	+ PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
	4666	+#endif
	4667	+#ifdef IPPROTO_NONE
	4668	+ PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
	4669	+#endif
	4670	+#ifdef IPPROTO_DSTOPTS
	4671	+ PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
	4672	+#endif
	4673	+#ifdef IPPROTO_XTP
	4674	+ PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
	4675	+#endif
	4676	+#ifdef IPPROTO_EON
	4677	+ PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
	4678	+#endif
	4679	+#ifdef IPPROTO_PIM
	4680	+ PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
	4681	+#endif
	4682	+#ifdef IPPROTO_IPCOMP
	4683	+ PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
	4684	+#endif
	4685	+#ifdef IPPROTO_VRRP
	4686	+ PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
	4687	+#endif
	4688	+#ifdef IPPROTO_BIP
	4689	+ PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
	4690	+#endif
	4691	+/**/
	4692	+#ifdef IPPROTO_RAW
	4693	+ PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
	4694	+#else
	4695	+ PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
	4696	+#endif
	4697	+#ifdef IPPROTO_MAX
	4698	+ PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
	4699	+#endif
	4700	+
	4701	+ /* Some port configuration */
	4702	+#ifdef IPPORT_RESERVED
	4703	+ PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
	4704	+#else
	4705	+ PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
	4706	+#endif
	4707	+#ifdef IPPORT_USERRESERVED
	4708	+ PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
	4709	+#else
	4710	+ PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
	4711	+#endif
	4712	+
	4713	+ /* Some reserved IP v.4 addresses */
	4714	+#ifdef INADDR_ANY
	4715	+ PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
	4716	+#else
	4717	+ PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
	4718	+#endif
	4719	+#ifdef INADDR_BROADCAST
	4720	+ PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
	4721	+#else
	4722	+ PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
	4723	+#endif
	4724	+#ifdef INADDR_LOOPBACK
	4725	+ PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
	4726	+#else
	4727	+ PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
	4728	+#endif
	4729	+#ifdef INADDR_UNSPEC_GROUP
	4730	+ PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
	4731	+#else
	4732	+ PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
	4733	+#endif
	4734	+#ifdef INADDR_ALLHOSTS_GROUP
	4735	+ PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
	4736	+ INADDR_ALLHOSTS_GROUP);
	4737	+#else
	4738	+ PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
	4739	+#endif
	4740	+#ifdef INADDR_MAX_LOCAL_GROUP
	4741	+ PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
	4742	+ INADDR_MAX_LOCAL_GROUP);
	4743	+#else
	4744	+ PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
	4745	+#endif
	4746	+#ifdef INADDR_NONE
	4747	+ PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
	4748	+#else
	4749	+ PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
	4750	+#endif
	4751	+
	4752	+ /* IPv4 [gs]etsockopt options */
	4753	+#ifdef IP_OPTIONS
	4754	+ PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
	4755	+#endif
	4756	+#ifdef IP_HDRINCL
	4757	+ PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
	4758	+#endif
	4759	+#ifdef IP_TOS
	4760	+ PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
	4761	+#endif
	4762	+#ifdef IP_TTL
	4763	+ PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
	4764	+#endif
	4765	+#ifdef IP_RECVOPTS
	4766	+ PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
	4767	+#endif
	4768	+#ifdef IP_RECVRETOPTS
	4769	+ PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
	4770	+#endif
	4771	+#ifdef IP_RECVDSTADDR
	4772	+ PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
	4773	+#endif
	4774	+#ifdef IP_RETOPTS
	4775	+ PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
	4776	+#endif
	4777	+#ifdef IP_MULTICAST_IF
	4778	+ PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
	4779	+#endif
	4780	+#ifdef IP_MULTICAST_TTL
	4781	+ PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
	4782	+#endif
	4783	+#ifdef IP_MULTICAST_LOOP
	4784	+ PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
	4785	+#endif
	4786	+#ifdef IP_ADD_MEMBERSHIP
	4787	+ PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
	4788	+#endif
	4789	+#ifdef IP_DROP_MEMBERSHIP
	4790	+ PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
	4791	+#endif
	4792	+#ifdef IP_DEFAULT_MULTICAST_TTL
	4793	+ PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
	4794	+ IP_DEFAULT_MULTICAST_TTL);
	4795	+#endif
	4796	+#ifdef IP_DEFAULT_MULTICAST_LOOP
	4797	+ PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
	4798	+ IP_DEFAULT_MULTICAST_LOOP);
	4799	+#endif
	4800	+#ifdef IP_MAX_MEMBERSHIPS
	4801	+ PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
	4802	+#endif
	4803	+
	4804	+ /* IPv6 [gs]etsockopt options, defined in RFC2553 */
	4805	+#ifdef IPV6_JOIN_GROUP
	4806	+ PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
	4807	+#endif
	4808	+#ifdef IPV6_LEAVE_GROUP
	4809	+ PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
	4810	+#endif
	4811	+#ifdef IPV6_MULTICAST_HOPS
	4812	+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
	4813	+#endif
	4814	+#ifdef IPV6_MULTICAST_IF
	4815	+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
	4816	+#endif
	4817	+#ifdef IPV6_MULTICAST_LOOP
	4818	+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
	4819	+#endif
	4820	+#ifdef IPV6_UNICAST_HOPS
	4821	+ PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
	4822	+#endif
	4823	+ /* Additional IPV6 socket options, defined in RFC 3493 */
	4824	+#ifdef IPV6_V6ONLY
	4825	+ PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
	4826	+#endif
	4827	+ /* Advanced IPV6 socket options, from RFC 3542 */
	4828	+#ifdef IPV6_CHECKSUM
	4829	+ PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
	4830	+#endif
	4831	+#ifdef IPV6_DONTFRAG
	4832	+ PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
	4833	+#endif
	4834	+#ifdef IPV6_DSTOPTS
	4835	+ PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
	4836	+#endif
	4837	+#ifdef IPV6_HOPLIMIT
	4838	+ PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
	4839	+#endif
	4840	+#ifdef IPV6_HOPOPTS
	4841	+ PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
	4842	+#endif
	4843	+#ifdef IPV6_NEXTHOP
	4844	+ PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
	4845	+#endif
	4846	+#ifdef IPV6_PATHMTU
	4847	+ PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
	4848	+#endif
	4849	+#ifdef IPV6_PKTINFO
	4850	+ PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
	4851	+#endif
	4852	+#ifdef IPV6_RECVDSTOPTS
	4853	+ PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
	4854	+#endif
	4855	+#ifdef IPV6_RECVHOPLIMIT
	4856	+ PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
	4857	+#endif
	4858	+#ifdef IPV6_RECVHOPOPTS
	4859	+ PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
	4860	+#endif
	4861	+#ifdef IPV6_RECVPKTINFO
	4862	+ PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
	4863	+#endif
	4864	+#ifdef IPV6_RECVRTHDR
	4865	+ PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
	4866	+#endif
	4867	+#ifdef IPV6_RECVTCLASS
	4868	+ PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
	4869	+#endif
	4870	+#ifdef IPV6_RTHDR
	4871	+ PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
	4872	+#endif
	4873	+#ifdef IPV6_RTHDRDSTOPTS
	4874	+ PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
	4875	+#endif
	4876	+#ifdef IPV6_RTHDR_TYPE_0
	4877	+ PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
	4878	+#endif
	4879	+#ifdef IPV6_RECVPATHMTU
	4880	+ PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
	4881	+#endif
	4882	+#ifdef IPV6_TCLASS
	4883	+ PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
	4884	+#endif
	4885	+#ifdef IPV6_USE_MIN_MTU
	4886	+ PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
	4887	+#endif
	4888	+
	4889	+ /* TCP options */
	4890	+#ifdef TCP_NODELAY
	4891	+ PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
	4892	+#endif
	4893	+#ifdef TCP_MAXSEG
	4894	+ PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
	4895	+#endif
	4896	+#ifdef TCP_CORK
	4897	+ PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
	4898	+#endif
	4899	+#ifdef TCP_KEEPIDLE
	4900	+ PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
	4901	+#endif
	4902	+#ifdef TCP_KEEPINTVL
	4903	+ PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
	4904	+#endif
	4905	+#ifdef TCP_KEEPCNT
	4906	+ PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
	4907	+#endif
	4908	+#ifdef TCP_SYNCNT
	4909	+ PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
	4910	+#endif
	4911	+#ifdef TCP_LINGER2
	4912	+ PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
	4913	+#endif
	4914	+#ifdef TCP_DEFER_ACCEPT
	4915	+ PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
	4916	+#endif
	4917	+#ifdef TCP_WINDOW_CLAMP
	4918	+ PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
	4919	+#endif
	4920	+#ifdef TCP_INFO
	4921	+ PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
	4922	+#endif
	4923	+#ifdef TCP_QUICKACK
	4924	+ PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
	4925	+#endif
	4926	+
	4927	+
	4928	+ /* IPX options */
	4929	+#ifdef IPX_TYPE
	4930	+ PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
	4931	+#endif
	4932	+
	4933	+ /* get{addr,name}info parameters */
	4934	+#ifdef EAI_ADDRFAMILY
	4935	+ PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
	4936	+#endif
	4937	+#ifdef EAI_AGAIN
	4938	+ PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
	4939	+#endif
	4940	+#ifdef EAI_BADFLAGS
	4941	+ PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
	4942	+#endif
	4943	+#ifdef EAI_FAIL
	4944	+ PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
	4945	+#endif
	4946	+#ifdef EAI_FAMILY
	4947	+ PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
	4948	+#endif
	4949	+#ifdef EAI_MEMORY
	4950	+ PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
	4951	+#endif
	4952	+#ifdef EAI_NODATA
	4953	+ PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
	4954	+#endif
	4955	+#ifdef EAI_NONAME
	4956	+ PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
	4957	+#endif
	4958	+#ifdef EAI_OVERFLOW
	4959	+ PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
	4960	+#endif
	4961	+#ifdef EAI_SERVICE
	4962	+ PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
	4963	+#endif
	4964	+#ifdef EAI_SOCKTYPE
	4965	+ PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
	4966	+#endif
	4967	+#ifdef EAI_SYSTEM
	4968	+ PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
	4969	+#endif
	4970	+#ifdef EAI_BADHINTS
	4971	+ PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
	4972	+#endif
	4973	+#ifdef EAI_PROTOCOL
	4974	+ PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
	4975	+#endif
	4976	+#ifdef EAI_MAX
	4977	+ PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
	4978	+#endif
	4979	+#ifdef AI_PASSIVE
	4980	+ PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
	4981	+#endif
	4982	+#ifdef AI_CANONNAME
	4983	+ PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
	4984	+#endif
	4985	+#ifdef AI_NUMERICHOST
	4986	+ PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
	4987	+#endif
	4988	+#ifdef AI_NUMERICSERV
	4989	+ PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
	4990	+#endif
	4991	+#ifdef AI_MASK
	4992	+ PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
	4993	+#endif
	4994	+#ifdef AI_ALL
	4995	+ PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
	4996	+#endif
	4997	+#ifdef AI_V4MAPPED_CFG
	4998	+ PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
	4999	+#endif

101 more lines aren’t shown here.