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.