Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines
Untabify C files. Will watch buildbots.
........
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 085d585..563bdea 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -17,9 +17,9 @@
- socket.error: exception raised for socket specific errors
- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
- a subclass of socket.error
+ a subclass of socket.error
- socket.herror: exception raised for gethostby* errors,
- a subclass of socket.error
+ a subclass of socket.error
- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
@@ -27,14 +27,14 @@
- socket.getservbyname(servicename[, protocolname]) --> port number
- socket.getservbyport(portnumber[, protocolname]) --> service name
- socket.socket([family[, type [, proto, fileno]]]) --> new socket object
- (fileno specifies a pre-existing socket file descriptor)
+ (fileno specifies a pre-existing socket file descriptor)
- socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
- socket.ntohs(16 bit value) --> new int object
- socket.ntohl(32 bit value) --> new int object
- socket.htons(16 bit value) --> new int object
- socket.htonl(32 bit value) --> new int object
- socket.getaddrinfo(host, port [, family, socktype, proto, flags])
- --> List of (family, socktype, proto, canonname, sockaddr)
+ --> List of (family, socktype, proto, canonname, sockaddr)
- socket.getnameinfo(sockaddr, flags) --> (host, port)
- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
- socket.has_ipv6: boolean value indicating if IPv6 is supported
@@ -54,22 +54,22 @@
specify packet-type and ha-type/addr.
- an AF_TIPC socket address is expressed as
(addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:
- TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
+ TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
and scope can be one of:
- TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
+ TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
The meaning of v1, v2 and v3 depends on the value of addr_type:
- if addr_type is TIPC_ADDR_NAME:
- v1 is the server type
- v2 is the port identifier
- v3 is ignored
- if addr_type is TIPC_ADDR_NAMESEQ:
- v1 is the server type
- v2 is the lower port number
- v3 is the upper port number
- if addr_type is TIPC_ADDR_ID:
- v1 is the node
- v2 is the ref
- v3 is ignored
+ if addr_type is TIPC_ADDR_NAME:
+ v1 is the server type
+ v2 is the port identifier
+ v3 is ignored
+ if addr_type is TIPC_ADDR_NAMESEQ:
+ v1 is the server type
+ v2 is the lower port number
+ v3 is the upper port number
+ if addr_type is TIPC_ADDR_ID:
+ v1 is the node
+ v2 is the ref
+ v3 is ignored
Local naming conventions:
@@ -283,7 +283,7 @@
#include <stddef.h>
#ifndef offsetof
-# define offsetof(type, member) ((size_t)(&((type *)0)->member))
+# define offsetof(type, member) ((size_t)(&((type *)0)->member))
#endif
#ifndef O_NONBLOCK
@@ -351,16 +351,16 @@
static SOCKET
dup_socket(SOCKET handle)
{
- HANDLE newhandle;
+ HANDLE newhandle;
- if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)handle,
- GetCurrentProcess(), &newhandle,
- 0, FALSE, DUPLICATE_SAME_ACCESS))
- {
- WSASetLastError(GetLastError());
- return INVALID_SOCKET;
- }
- return (SOCKET)newhandle;
+ if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)handle,
+ GetCurrentProcess(), &newhandle,
+ 0, FALSE, DUPLICATE_SAME_ACCESS))
+ {
+ WSASetLastError(GetLastError());
+ return INVALID_SOCKET;
+ }
+ return (SOCKET)newhandle;
}
#define SOCKETCLOSE closesocket
#else
@@ -418,7 +418,7 @@
#define SEGMENT_SIZE (32 * 1024 -1)
#endif
-#define SAS2SA(x) ((struct sockaddr *)(x))
+#define SAS2SA(x) ((struct sockaddr *)(x))
/*
* Constants for getnameinfo()
@@ -473,8 +473,8 @@
static PyObject*
select_error(void)
{
- PyErr_SetString(socket_error, "unable to select on socket");
- return NULL;
+ PyErr_SetString(socket_error, "unable to select on socket");
+ return NULL;
}
/* Convenience function to raise an error according to errno
@@ -484,95 +484,95 @@
set_error(void)
{
#ifdef MS_WINDOWS
- int err_no = WSAGetLastError();
- /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
- recognizes the error codes used by both GetLastError() and
- WSAGetLastError */
- if (err_no)
- return PyErr_SetExcFromWindowsErr(socket_error, err_no);
+ int err_no = WSAGetLastError();
+ /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
+ recognizes the error codes used by both GetLastError() and
+ WSAGetLastError */
+ if (err_no)
+ return PyErr_SetExcFromWindowsErr(socket_error, err_no);
#endif
#if defined(PYOS_OS2) && !defined(PYCC_GCC)
- if (sock_errno() != NO_ERROR) {
- APIRET rc;
- ULONG msglen;
- char outbuf[100];
- int myerrorcode = sock_errno();
+ if (sock_errno() != NO_ERROR) {
+ APIRET rc;
+ ULONG msglen;
+ char outbuf[100];
+ int myerrorcode = sock_errno();
- /* Retrieve socket-related error message from MPTN.MSG file */
- rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
- myerrorcode - SOCBASEERR + 26,
- "mptn.msg",
- &msglen);
- if (rc == NO_ERROR) {
- PyObject *v;
+ /* Retrieve socket-related error message from MPTN.MSG file */
+ rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
+ myerrorcode - SOCBASEERR + 26,
+ "mptn.msg",
+ &msglen);
+ if (rc == NO_ERROR) {
+ PyObject *v;
- /* OS/2 doesn't guarantee a terminator */
- outbuf[msglen] = '\0';
- if (strlen(outbuf) > 0) {
- /* If non-empty msg, trim CRLF */
- char *lastc = &outbuf[ strlen(outbuf)-1 ];
- while (lastc > outbuf &&
- isspace(Py_CHARMASK(*lastc))) {
- /* Trim trailing whitespace (CRLF) */
- *lastc-- = '\0';
- }
- }
- v = Py_BuildValue("(is)", myerrorcode, outbuf);
- if (v != NULL) {
- PyErr_SetObject(socket_error, v);
- Py_DECREF(v);
- }
- return NULL;
- }
- }
+ /* OS/2 doesn't guarantee a terminator */
+ outbuf[msglen] = '\0';
+ if (strlen(outbuf) > 0) {
+ /* If non-empty msg, trim CRLF */
+ char *lastc = &outbuf[ strlen(outbuf)-1 ];
+ while (lastc > outbuf &&
+ isspace(Py_CHARMASK(*lastc))) {
+ /* Trim trailing whitespace (CRLF) */
+ *lastc-- = '\0';
+ }
+ }
+ v = Py_BuildValue("(is)", myerrorcode, outbuf);
+ if (v != NULL) {
+ PyErr_SetObject(socket_error, v);
+ Py_DECREF(v);
+ }
+ return NULL;
+ }
+ }
#endif
- return PyErr_SetFromErrno(socket_error);
+ return PyErr_SetFromErrno(socket_error);
}
static PyObject *
set_herror(int h_error)
{
- PyObject *v;
+ PyObject *v;
#ifdef HAVE_HSTRERROR
- v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
+ v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
#else
- v = Py_BuildValue("(is)", h_error, "host not found");
+ v = Py_BuildValue("(is)", h_error, "host not found");
#endif
- if (v != NULL) {
- PyErr_SetObject(socket_herror, v);
- Py_DECREF(v);
- }
+ if (v != NULL) {
+ PyErr_SetObject(socket_herror, v);
+ Py_DECREF(v);
+ }
- return NULL;
+ return NULL;
}
static PyObject *
set_gaierror(int error)
{
- PyObject *v;
+ PyObject *v;
#ifdef EAI_SYSTEM
- /* EAI_SYSTEM is not available on Windows XP. */
- if (error == EAI_SYSTEM)
- return set_error();
+ /* EAI_SYSTEM is not available on Windows XP. */
+ if (error == EAI_SYSTEM)
+ return set_error();
#endif
#ifdef HAVE_GAI_STRERROR
- v = Py_BuildValue("(is)", error, gai_strerror(error));
+ v = Py_BuildValue("(is)", error, gai_strerror(error));
#else
- v = Py_BuildValue("(is)", error, "getaddrinfo failed");
+ v = Py_BuildValue("(is)", error, "getaddrinfo failed");
#endif
- if (v != NULL) {
- PyErr_SetObject(socket_gaierror, v);
- Py_DECREF(v);
- }
+ if (v != NULL) {
+ PyErr_SetObject(socket_gaierror, v);
+ Py_DECREF(v);
+ }
- return NULL;
+ return NULL;
}
#ifdef __VMS
@@ -580,22 +580,22 @@
static int
sendsegmented(int sock_fd, char *buf, int len, int flags)
{
- int n = 0;
- int remaining = len;
+ int n = 0;
+ int remaining = len;
- while (remaining > 0) {
- unsigned int segment;
+ while (remaining > 0) {
+ unsigned int segment;
- segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
- n = send(sock_fd, buf, segment, flags);
- if (n < 0) {
- return n;
- }
- remaining -= segment;
- buf += segment;
- } /* end while */
+ segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
+ n = send(sock_fd, buf, segment, flags);
+ if (n < 0) {
+ return n;
+ }
+ remaining -= segment;
+ buf += segment;
+ } /* end while */
- return len;
+ return len;
}
#endif
@@ -605,33 +605,33 @@
internal_setblocking(PySocketSockObject *s, int block)
{
#ifndef MS_WINDOWS
- int delay_flag;
+ int delay_flag;
#endif
- Py_BEGIN_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
#ifndef MS_WINDOWS
#if defined(PYOS_OS2) && !defined(PYCC_GCC)
- block = !block;
- ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
+ block = !block;
+ ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
#elif defined(__VMS)
- block = !block;
- ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
+ block = !block;
+ ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
#else /* !PYOS_OS2 && !__VMS */
- delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
- if (block)
- delay_flag &= (~O_NONBLOCK);
- else
- delay_flag |= O_NONBLOCK;
- fcntl(s->sock_fd, F_SETFL, delay_flag);
+ delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
+ if (block)
+ delay_flag &= (~O_NONBLOCK);
+ else
+ delay_flag |= O_NONBLOCK;
+ fcntl(s->sock_fd, F_SETFL, delay_flag);
#endif /* !PYOS_OS2 */
#else /* MS_WINDOWS */
- block = !block;
- ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
+ block = !block;
+ ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
#endif /* MS_WINDOWS */
- Py_END_ALLOW_THREADS
+ Py_END_ALLOW_THREADS
- /* Since these don't return anything */
- return 1;
+ /* Since these don't return anything */
+ return 1;
}
/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
@@ -642,53 +642,53 @@
static int
internal_select(PySocketSockObject *s, int writing)
{
- int n;
+ int n;
- /* Nothing to do unless we're in timeout mode (not non-blocking) */
- if (s->sock_timeout <= 0.0)
- return 0;
+ /* Nothing to do unless we're in timeout mode (not non-blocking) */
+ if (s->sock_timeout <= 0.0)
+ return 0;
- /* Guard against closed socket */
- if (s->sock_fd < 0)
- return 0;
+ /* Guard against closed socket */
+ if (s->sock_fd < 0)
+ return 0;
- /* Prefer poll, if available, since you can poll() any fd
- * which can't be done with select(). */
+ /* Prefer poll, if available, since you can poll() any fd
+ * which can't be done with select(). */
#ifdef HAVE_POLL
- {
- struct pollfd pollfd;
- int timeout;
+ {
+ struct pollfd pollfd;
+ int timeout;
- pollfd.fd = s->sock_fd;
- pollfd.events = writing ? POLLOUT : POLLIN;
+ pollfd.fd = s->sock_fd;
+ pollfd.events = writing ? POLLOUT : POLLIN;
- /* s->sock_timeout is in seconds, timeout in ms */
- timeout = (int)(s->sock_timeout * 1000 + 0.5);
- n = poll(&pollfd, 1, timeout);
- }
+ /* s->sock_timeout is in seconds, timeout in ms */
+ timeout = (int)(s->sock_timeout * 1000 + 0.5);
+ n = poll(&pollfd, 1, timeout);
+ }
#else
- {
- /* Construct the arguments to select */
- fd_set fds;
- struct timeval tv;
- tv.tv_sec = (int)s->sock_timeout;
- tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
- FD_ZERO(&fds);
- FD_SET(s->sock_fd, &fds);
+ {
+ /* Construct the arguments to select */
+ fd_set fds;
+ struct timeval tv;
+ tv.tv_sec = (int)s->sock_timeout;
+ tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
+ FD_ZERO(&fds);
+ FD_SET(s->sock_fd, &fds);
- /* See if the socket is ready */
- if (writing)
- n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
- else
- n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
- }
+ /* See if the socket is ready */
+ if (writing)
+ n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
+ else
+ n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
+ }
#endif
- if (n < 0)
- return -1;
- if (n == 0)
- return 1;
- return 0;
+ if (n < 0)
+ return -1;
+ if (n == 0)
+ return 1;
+ return 0;
}
/* Initialize a new socket object. */
@@ -697,18 +697,18 @@
static void
init_sockobject(PySocketSockObject *s,
- SOCKET_T fd, int family, int type, int proto)
+ SOCKET_T fd, int family, int type, int proto)
{
- s->sock_fd = fd;
- s->sock_family = family;
- s->sock_type = type;
- s->sock_proto = proto;
- s->sock_timeout = defaulttimeout;
+ s->sock_fd = fd;
+ s->sock_family = family;
+ s->sock_type = type;
+ s->sock_proto = proto;
+ s->sock_timeout = defaulttimeout;
- s->errorhandler = &set_error;
+ s->errorhandler = &set_error;
- if (defaulttimeout >= 0.0)
- internal_setblocking(s, 0);
+ if (defaulttimeout >= 0.0)
+ internal_setblocking(s, 0);
}
@@ -721,12 +721,12 @@
static PySocketSockObject *
new_sockobject(SOCKET_T fd, int family, int type, int proto)
{
- PySocketSockObject *s;
- s = (PySocketSockObject *)
- PyType_GenericNew(&sock_type, NULL, NULL);
- if (s != NULL)
- init_sockobject(s, fd, family, type, proto);
- return s;
+ PySocketSockObject *s;
+ s = (PySocketSockObject *)
+ PyType_GenericNew(&sock_type, NULL, NULL);
+ if (s != NULL)
+ init_sockobject(s, fd, family, type, proto);
+ return s;
}
@@ -746,122 +746,122 @@
static int
setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
{
- struct addrinfo hints, *res;
- int error;
- int d1, d2, d3, d4;
- char ch;
+ struct addrinfo hints, *res;
+ int error;
+ int d1, d2, d3, d4;
+ char ch;
- memset((void *) addr_ret, '\0', sizeof(*addr_ret));
- if (name[0] == '\0') {
- int siz;
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = af;
- hints.ai_socktype = SOCK_DGRAM; /*dummy*/
- hints.ai_flags = AI_PASSIVE;
- Py_BEGIN_ALLOW_THREADS
- ACQUIRE_GETADDRINFO_LOCK
- error = getaddrinfo(NULL, "0", &hints, &res);
- Py_END_ALLOW_THREADS
- /* We assume that those thread-unsafe getaddrinfo() versions
- *are* safe regarding their return value, ie. that a
- subsequent call to getaddrinfo() does not destroy the
- outcome of the first call. */
- RELEASE_GETADDRINFO_LOCK
- if (error) {
- set_gaierror(error);
- return -1;
- }
- switch (res->ai_family) {
- case AF_INET:
- siz = 4;
- break;
+ memset((void *) addr_ret, '\0', sizeof(*addr_ret));
+ if (name[0] == '\0') {
+ int siz;
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = af;
+ hints.ai_socktype = SOCK_DGRAM; /*dummy*/
+ hints.ai_flags = AI_PASSIVE;
+ Py_BEGIN_ALLOW_THREADS
+ ACQUIRE_GETADDRINFO_LOCK
+ error = getaddrinfo(NULL, "0", &hints, &res);
+ Py_END_ALLOW_THREADS
+ /* We assume that those thread-unsafe getaddrinfo() versions
+ *are* safe regarding their return value, ie. that a
+ subsequent call to getaddrinfo() does not destroy the
+ outcome of the first call. */
+ RELEASE_GETADDRINFO_LOCK
+ if (error) {
+ set_gaierror(error);
+ return -1;
+ }
+ switch (res->ai_family) {
+ case AF_INET:
+ siz = 4;
+ break;
#ifdef ENABLE_IPV6
- case AF_INET6:
- siz = 16;
- break;
+ case AF_INET6:
+ siz = 16;
+ break;
#endif
- default:
- freeaddrinfo(res);
- PyErr_SetString(socket_error,
- "unsupported address family");
- return -1;
- }
- if (res->ai_next) {
- freeaddrinfo(res);
- PyErr_SetString(socket_error,
- "wildcard resolved to multiple address");
- return -1;
- }
- if (res->ai_addrlen < addr_ret_size)
- addr_ret_size = res->ai_addrlen;
- memcpy(addr_ret, res->ai_addr, addr_ret_size);
- freeaddrinfo(res);
- return siz;
- }
- if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
- struct sockaddr_in *sin;
- if (af != AF_INET && af != AF_UNSPEC) {
- PyErr_SetString(socket_error,
- "address family mismatched");
- return -1;
- }
- sin = (struct sockaddr_in *)addr_ret;
- memset((void *) sin, '\0', sizeof(*sin));
- sin->sin_family = AF_INET;
+ default:
+ freeaddrinfo(res);
+ PyErr_SetString(socket_error,
+ "unsupported address family");
+ return -1;
+ }
+ if (res->ai_next) {
+ freeaddrinfo(res);
+ PyErr_SetString(socket_error,
+ "wildcard resolved to multiple address");
+ return -1;
+ }
+ if (res->ai_addrlen < addr_ret_size)
+ addr_ret_size = res->ai_addrlen;
+ memcpy(addr_ret, res->ai_addr, addr_ret_size);
+ freeaddrinfo(res);
+ return siz;
+ }
+ if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
+ struct sockaddr_in *sin;
+ if (af != AF_INET && af != AF_UNSPEC) {
+ PyErr_SetString(socket_error,
+ "address family mismatched");
+ return -1;
+ }
+ sin = (struct sockaddr_in *)addr_ret;
+ memset((void *) sin, '\0', sizeof(*sin));
+ sin->sin_family = AF_INET;
#ifdef HAVE_SOCKADDR_SA_LEN
- sin->sin_len = sizeof(*sin);
+ sin->sin_len = sizeof(*sin);
#endif
- sin->sin_addr.s_addr = INADDR_BROADCAST;
- return sizeof(sin->sin_addr);
- }
- if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
- 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
- 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
- struct sockaddr_in *sin;
- sin = (struct sockaddr_in *)addr_ret;
- sin->sin_addr.s_addr = htonl(
- ((long) d1 << 24) | ((long) d2 << 16) |
- ((long) d3 << 8) | ((long) d4 << 0));
- sin->sin_family = AF_INET;
+ sin->sin_addr.s_addr = INADDR_BROADCAST;
+ return sizeof(sin->sin_addr);
+ }
+ if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
+ 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
+ 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
+ struct sockaddr_in *sin;
+ sin = (struct sockaddr_in *)addr_ret;
+ sin->sin_addr.s_addr = htonl(
+ ((long) d1 << 24) | ((long) d2 << 16) |
+ ((long) d3 << 8) | ((long) d4 << 0));
+ sin->sin_family = AF_INET;
#ifdef HAVE_SOCKADDR_SA_LEN
- sin->sin_len = sizeof(*sin);
+ sin->sin_len = sizeof(*sin);
#endif
- return 4;
- }
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = af;
- Py_BEGIN_ALLOW_THREADS
- ACQUIRE_GETADDRINFO_LOCK
- error = getaddrinfo(name, NULL, &hints, &res);
+ return 4;
+ }
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = af;
+ Py_BEGIN_ALLOW_THREADS
+ ACQUIRE_GETADDRINFO_LOCK
+ error = getaddrinfo(name, NULL, &hints, &res);
#if defined(__digital__) && defined(__unix__)
- if (error == EAI_NONAME && af == AF_UNSPEC) {
- /* On Tru64 V5.1, numeric-to-addr conversion fails
- if no address family is given. Assume IPv4 for now.*/
- hints.ai_family = AF_INET;
- error = getaddrinfo(name, NULL, &hints, &res);
- }
+ if (error == EAI_NONAME && af == AF_UNSPEC) {
+ /* On Tru64 V5.1, numeric-to-addr conversion fails
+ if no address family is given. Assume IPv4 for now.*/
+ hints.ai_family = AF_INET;
+ error = getaddrinfo(name, NULL, &hints, &res);
+ }
#endif
- Py_END_ALLOW_THREADS
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
- if (error) {
- set_gaierror(error);
- return -1;
- }
- if (res->ai_addrlen < addr_ret_size)
- addr_ret_size = res->ai_addrlen;
- memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
- freeaddrinfo(res);
- switch (addr_ret->sa_family) {
- case AF_INET:
- return 4;
+ Py_END_ALLOW_THREADS
+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
+ if (error) {
+ set_gaierror(error);
+ return -1;
+ }
+ if (res->ai_addrlen < addr_ret_size)
+ addr_ret_size = res->ai_addrlen;
+ memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
+ freeaddrinfo(res);
+ switch (addr_ret->sa_family) {
+ case AF_INET:
+ return 4;
#ifdef ENABLE_IPV6
- case AF_INET6:
- return 16;
+ case AF_INET6:
+ return 16;
#endif
- default:
- PyErr_SetString(socket_error, "unknown address family");
- return -1;
- }
+ default:
+ PyErr_SetString(socket_error, "unknown address family");
+ return -1;
+ }
}
@@ -872,16 +872,16 @@
static PyObject *
makeipaddr(struct sockaddr *addr, int addrlen)
{
- char buf[NI_MAXHOST];
- int error;
+ char buf[NI_MAXHOST];
+ int error;
- error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
- NI_NUMERICHOST);
- if (error) {
- set_gaierror(error);
- return NULL;
- }
- return PyUnicode_FromString(buf);
+ error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
+ NI_NUMERICHOST);
+ if (error) {
+ set_gaierror(error);
+ return NULL;
+ }
+ return PyUnicode_FromString(buf);
}
@@ -893,24 +893,24 @@
static int
setbdaddr(char *name, bdaddr_t *bdaddr)
{
- unsigned int b0, b1, b2, b3, b4, b5;
- char ch;
- int n;
+ unsigned int b0, b1, b2, b3, b4, b5;
+ char ch;
+ int n;
- n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
- &b5, &b4, &b3, &b2, &b1, &b0, &ch);
- if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
- bdaddr->b[0] = b0;
- bdaddr->b[1] = b1;
- bdaddr->b[2] = b2;
- bdaddr->b[3] = b3;
- bdaddr->b[4] = b4;
- bdaddr->b[5] = b5;
- return 6;
- } else {
- PyErr_SetString(socket_error, "bad bluetooth address");
- return -1;
- }
+ n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
+ &b5, &b4, &b3, &b2, &b1, &b0, &ch);
+ if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
+ bdaddr->b[0] = b0;
+ bdaddr->b[1] = b1;
+ bdaddr->b[2] = b2;
+ bdaddr->b[3] = b3;
+ bdaddr->b[4] = b4;
+ bdaddr->b[5] = b5;
+ return 6;
+ } else {
+ PyErr_SetString(socket_error, "bad bluetooth address");
+ return -1;
+ }
}
/* Create a string representation of the Bluetooth address. This is always a
@@ -920,12 +920,12 @@
static PyObject *
makebdaddr(bdaddr_t *bdaddr)
{
- char buf[(6 * 2) + 5 + 1];
+ char buf[(6 * 2) + 5 + 1];
- sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
- bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
- bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
- return PyUnicode_FromString(buf);
+ sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
+ bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
+ bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
+ return PyUnicode_FromString(buf);
}
#endif
@@ -939,193 +939,193 @@
static PyObject *
makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
{
- if (addrlen == 0) {
- /* No address -- may be recvfrom() from known socket */
- Py_INCREF(Py_None);
- return Py_None;
- }
+ if (addrlen == 0) {
+ /* No address -- may be recvfrom() from known socket */
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
- switch (addr->sa_family) {
+ switch (addr->sa_family) {
- case AF_INET:
- {
- struct sockaddr_in *a;
- PyObject *addrobj = makeipaddr(addr, sizeof(*a));
- PyObject *ret = NULL;
- if (addrobj) {
- a = (struct sockaddr_in *)addr;
- ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
- Py_DECREF(addrobj);
- }
- return ret;
- }
+ case AF_INET:
+ {
+ struct sockaddr_in *a;
+ PyObject *addrobj = makeipaddr(addr, sizeof(*a));
+ PyObject *ret = NULL;
+ if (addrobj) {
+ a = (struct sockaddr_in *)addr;
+ ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
+ Py_DECREF(addrobj);
+ }
+ return ret;
+ }
#if defined(AF_UNIX)
- case AF_UNIX:
- {
- struct sockaddr_un *a = (struct sockaddr_un *) addr;
+ case AF_UNIX:
+ {
+ struct sockaddr_un *a = (struct sockaddr_un *) addr;
#ifdef linux
- if (a->sun_path[0] == 0) { /* Linux abstract namespace */
- addrlen -= offsetof(struct sockaddr_un, sun_path);
- return PyBytes_FromStringAndSize(a->sun_path, addrlen);
- }
- else
+ if (a->sun_path[0] == 0) { /* Linux abstract namespace */
+ addrlen -= offsetof(struct sockaddr_un, sun_path);
+ return PyBytes_FromStringAndSize(a->sun_path, addrlen);
+ }
+ else
#endif /* linux */
- {
- /* regular NULL-terminated string */
- return PyUnicode_FromString(a->sun_path);
- }
- }
+ {
+ /* regular NULL-terminated string */
+ return PyUnicode_FromString(a->sun_path);
+ }
+ }
#endif /* AF_UNIX */
#if defined(AF_NETLINK)
case AF_NETLINK:
{
- struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
- return Py_BuildValue("II", a->nl_pid, a->nl_groups);
+ struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
+ return Py_BuildValue("II", a->nl_pid, a->nl_groups);
}
#endif /* AF_NETLINK */
#ifdef ENABLE_IPV6
- case AF_INET6:
- {
- struct sockaddr_in6 *a;
- PyObject *addrobj = makeipaddr(addr, sizeof(*a));
- PyObject *ret = NULL;
- if (addrobj) {
- a = (struct sockaddr_in6 *)addr;
- ret = Py_BuildValue("Oiii",
- addrobj,
- ntohs(a->sin6_port),
- a->sin6_flowinfo,
- a->sin6_scope_id);
- Py_DECREF(addrobj);
- }
- return ret;
- }
+ case AF_INET6:
+ {
+ struct sockaddr_in6 *a;
+ PyObject *addrobj = makeipaddr(addr, sizeof(*a));
+ PyObject *ret = NULL;
+ if (addrobj) {
+ a = (struct sockaddr_in6 *)addr;
+ ret = Py_BuildValue("Oiii",
+ addrobj,
+ ntohs(a->sin6_port),
+ a->sin6_flowinfo,
+ a->sin6_scope_id);
+ Py_DECREF(addrobj);
+ }
+ return ret;
+ }
#endif
#ifdef USE_BLUETOOTH
- case AF_BLUETOOTH:
- switch (proto) {
+ case AF_BLUETOOTH:
+ switch (proto) {
- case BTPROTO_L2CAP:
- {
- struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
- PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
- PyObject *ret = NULL;
- if (addrobj) {
- ret = Py_BuildValue("Oi",
- addrobj,
- _BT_L2_MEMB(a, psm));
- Py_DECREF(addrobj);
- }
- return ret;
- }
+ case BTPROTO_L2CAP:
+ {
+ struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
+ PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
+ PyObject *ret = NULL;
+ if (addrobj) {
+ ret = Py_BuildValue("Oi",
+ addrobj,
+ _BT_L2_MEMB(a, psm));
+ Py_DECREF(addrobj);
+ }
+ return ret;
+ }
- case BTPROTO_RFCOMM:
- {
- struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
- PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
- PyObject *ret = NULL;
- if (addrobj) {
- ret = Py_BuildValue("Oi",
- addrobj,
- _BT_RC_MEMB(a, channel));
- Py_DECREF(addrobj);
- }
- return ret;
- }
+ case BTPROTO_RFCOMM:
+ {
+ struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
+ PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
+ PyObject *ret = NULL;
+ if (addrobj) {
+ ret = Py_BuildValue("Oi",
+ addrobj,
+ _BT_RC_MEMB(a, channel));
+ Py_DECREF(addrobj);
+ }
+ return ret;
+ }
- case BTPROTO_HCI:
- {
- struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
- PyObject *ret = NULL;
- ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
- return ret;
- }
+ case BTPROTO_HCI:
+ {
+ struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
+ PyObject *ret = NULL;
+ ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
+ return ret;
+ }
#if !defined(__FreeBSD__)
- case BTPROTO_SCO:
- {
- struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
- return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
- }
+ case BTPROTO_SCO:
+ {
+ struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
+ return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
+ }
#endif
- default:
- PyErr_SetString(PyExc_ValueError,
- "Unknown Bluetooth protocol");
- return NULL;
- }
+ default:
+ PyErr_SetString(PyExc_ValueError,
+ "Unknown Bluetooth protocol");
+ return NULL;
+ }
#endif
#ifdef HAVE_NETPACKET_PACKET_H
- case AF_PACKET:
- {
- struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
- char *ifname = "";
- struct ifreq ifr;
- /* need to look up interface name give index */
- if (a->sll_ifindex) {
- ifr.ifr_ifindex = a->sll_ifindex;
- if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
- ifname = ifr.ifr_name;
- }
- return Py_BuildValue("shbhy#",
- ifname,
- ntohs(a->sll_protocol),
- a->sll_pkttype,
- a->sll_hatype,
- a->sll_addr,
- a->sll_halen);
- }
+ case AF_PACKET:
+ {
+ struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
+ char *ifname = "";
+ struct ifreq ifr;
+ /* need to look up interface name give index */
+ if (a->sll_ifindex) {
+ ifr.ifr_ifindex = a->sll_ifindex;
+ if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
+ ifname = ifr.ifr_name;
+ }
+ return Py_BuildValue("shbhy#",
+ ifname,
+ ntohs(a->sll_protocol),
+ a->sll_pkttype,
+ a->sll_hatype,
+ a->sll_addr,
+ a->sll_halen);
+ }
#endif
#ifdef HAVE_LINUX_TIPC_H
- case AF_TIPC:
- {
- struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
- if (a->addrtype == TIPC_ADDR_NAMESEQ) {
- return Py_BuildValue("IIIII",
- a->addrtype,
- a->addr.nameseq.type,
- a->addr.nameseq.lower,
- a->addr.nameseq.upper,
- a->scope);
- } else if (a->addrtype == TIPC_ADDR_NAME) {
- return Py_BuildValue("IIIII",
- a->addrtype,
- a->addr.name.name.type,
- a->addr.name.name.instance,
- a->addr.name.name.instance,
- a->scope);
- } else if (a->addrtype == TIPC_ADDR_ID) {
- return Py_BuildValue("IIIII",
- a->addrtype,
- a->addr.id.node,
- a->addr.id.ref,
- 0,
- a->scope);
- } else {
- PyErr_SetString(PyExc_ValueError,
- "Invalid address type");
- return NULL;
- }
- }
+ case AF_TIPC:
+ {
+ struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
+ if (a->addrtype == TIPC_ADDR_NAMESEQ) {
+ return Py_BuildValue("IIIII",
+ a->addrtype,
+ a->addr.nameseq.type,
+ a->addr.nameseq.lower,
+ a->addr.nameseq.upper,
+ a->scope);
+ } else if (a->addrtype == TIPC_ADDR_NAME) {
+ return Py_BuildValue("IIIII",
+ a->addrtype,
+ a->addr.name.name.type,
+ a->addr.name.name.instance,
+ a->addr.name.name.instance,
+ a->scope);
+ } else if (a->addrtype == TIPC_ADDR_ID) {
+ return Py_BuildValue("IIIII",
+ a->addrtype,
+ a->addr.id.node,
+ a->addr.id.ref,
+ 0,
+ a->scope);
+ } else {
+ PyErr_SetString(PyExc_ValueError,
+ "Invalid address type");
+ return NULL;
+ }
+ }
#endif
- /* More cases here... */
+ /* More cases here... */
- default:
- /* If we don't know the address family, don't raise an
- exception -- return it as an (int, bytes) tuple. */
- return Py_BuildValue("iy#",
- addr->sa_family,
- addr->sa_data,
- sizeof(addr->sa_data));
+ default:
+ /* If we don't know the address family, don't raise an
+ exception -- return it as an (int, bytes) tuple. */
+ return Py_BuildValue("iy#",
+ addr->sa_family,
+ addr->sa_data,
+ sizeof(addr->sa_data));
- }
+ }
}
@@ -1136,346 +1136,346 @@
static int
getsockaddrarg(PySocketSockObject *s, PyObject *args,
- struct sockaddr *addr_ret, int *len_ret)
+ struct sockaddr *addr_ret, int *len_ret)
{
- switch (s->sock_family) {
+ switch (s->sock_family) {
#if defined(AF_UNIX)
- case AF_UNIX:
- {
- struct sockaddr_un* addr;
- char *path;
- int len;
- if (!PyArg_Parse(args, "s#", &path, &len))
- return 0;
+ case AF_UNIX:
+ {
+ struct sockaddr_un* addr;
+ char *path;
+ int len;
+ if (!PyArg_Parse(args, "s#", &path, &len))
+ return 0;
- addr = (struct sockaddr_un*)addr_ret;
+ addr = (struct sockaddr_un*)addr_ret;
#ifdef linux
- if (len > 0 && path[0] == 0) {
- /* Linux abstract namespace extension */
- if (len > sizeof addr->sun_path) {
- PyErr_SetString(socket_error,
- "AF_UNIX path too long");
- return 0;
- }
- }
- else
+ if (len > 0 && path[0] == 0) {
+ /* Linux abstract namespace extension */
+ if (len > sizeof addr->sun_path) {
+ PyErr_SetString(socket_error,
+ "AF_UNIX path too long");
+ return 0;
+ }
+ }
+ else
#endif /* linux */
- {
- /* regular NULL-terminated string */
- if (len >= sizeof addr->sun_path) {
- PyErr_SetString(socket_error,
- "AF_UNIX path too long");
- return 0;
- }
- addr->sun_path[len] = 0;
- }
- addr->sun_family = s->sock_family;
- memcpy(addr->sun_path, path, len);
+ {
+ /* regular NULL-terminated string */
+ if (len >= sizeof addr->sun_path) {
+ PyErr_SetString(socket_error,
+ "AF_UNIX path too long");
+ return 0;
+ }
+ addr->sun_path[len] = 0;
+ }
+ addr->sun_family = s->sock_family;
+ memcpy(addr->sun_path, path, len);
#if defined(PYOS_OS2)
- *len_ret = sizeof(*addr);
+ *len_ret = sizeof(*addr);
#else
- *len_ret = len + offsetof(struct sockaddr_un, sun_path);
+ *len_ret = len + offsetof(struct sockaddr_un, sun_path);
#endif
- return 1;
- }
+ return 1;
+ }
#endif /* AF_UNIX */
#if defined(AF_NETLINK)
- case AF_NETLINK:
- {
- struct sockaddr_nl* addr;
- int pid, groups;
- addr = (struct sockaddr_nl *)addr_ret;
- if (!PyTuple_Check(args)) {
- PyErr_Format(
- PyExc_TypeError,
- "getsockaddrarg: "
- "AF_NETLINK address must be tuple, not %.500s",
- Py_TYPE(args)->tp_name);
- return 0;
- }
- if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
- return 0;
- addr->nl_family = AF_NETLINK;
- addr->nl_pid = pid;
- addr->nl_groups = groups;
- *len_ret = sizeof(*addr);
- return 1;
- }
+ case AF_NETLINK:
+ {
+ struct sockaddr_nl* addr;
+ int pid, groups;
+ addr = (struct sockaddr_nl *)addr_ret;
+ if (!PyTuple_Check(args)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "getsockaddrarg: "
+ "AF_NETLINK address must be tuple, not %.500s",
+ Py_TYPE(args)->tp_name);
+ return 0;
+ }
+ if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
+ return 0;
+ addr->nl_family = AF_NETLINK;
+ addr->nl_pid = pid;
+ addr->nl_groups = groups;
+ *len_ret = sizeof(*addr);
+ return 1;
+ }
#endif
- case AF_INET:
- {
- struct sockaddr_in* addr;
- char *host;
- int port, result;
- if (!PyTuple_Check(args)) {
- PyErr_Format(
- PyExc_TypeError,
- "getsockaddrarg: "
- "AF_INET address must be tuple, not %.500s",
- Py_TYPE(args)->tp_name);
- return 0;
- }
- if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
- "idna", &host, &port))
- return 0;
- addr=(struct sockaddr_in*)addr_ret;
- result = setipaddr(host, (struct sockaddr *)addr,
- sizeof(*addr), AF_INET);
- PyMem_Free(host);
- if (result < 0)
- return 0;
- if (port < 0 || port > 0xffff) {
- PyErr_SetString(
- PyExc_OverflowError,
- "getsockaddrarg: port must be 0-65535.");
- return 0;
- }
- addr->sin_family = AF_INET;
- addr->sin_port = htons((short)port);
- *len_ret = sizeof *addr;
- return 1;
- }
+ case AF_INET:
+ {
+ struct sockaddr_in* addr;
+ char *host;
+ int port, result;
+ if (!PyTuple_Check(args)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "getsockaddrarg: "
+ "AF_INET address must be tuple, not %.500s",
+ Py_TYPE(args)->tp_name);
+ return 0;
+ }
+ if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
+ "idna", &host, &port))
+ return 0;
+ addr=(struct sockaddr_in*)addr_ret;
+ result = setipaddr(host, (struct sockaddr *)addr,
+ sizeof(*addr), AF_INET);
+ PyMem_Free(host);
+ if (result < 0)
+ return 0;
+ if (port < 0 || port > 0xffff) {
+ PyErr_SetString(
+ PyExc_OverflowError,
+ "getsockaddrarg: port must be 0-65535.");
+ return 0;
+ }
+ addr->sin_family = AF_INET;
+ addr->sin_port = htons((short)port);
+ *len_ret = sizeof *addr;
+ return 1;
+ }
#ifdef ENABLE_IPV6
- case AF_INET6:
- {
- struct sockaddr_in6* addr;
- char *host;
- int port, flowinfo, scope_id, result;
- flowinfo = scope_id = 0;
- if (!PyTuple_Check(args)) {
- PyErr_Format(
- PyExc_TypeError,
- "getsockaddrarg: "
- "AF_INET6 address must be tuple, not %.500s",
- Py_TYPE(args)->tp_name);
- return 0;
- }
- if (!PyArg_ParseTuple(args, "eti|ii",
- "idna", &host, &port, &flowinfo,
- &scope_id)) {
- return 0;
- }
- addr = (struct sockaddr_in6*)addr_ret;
- result = setipaddr(host, (struct sockaddr *)addr,
- sizeof(*addr), AF_INET6);
- PyMem_Free(host);
- if (result < 0)
- return 0;
- if (port < 0 || port > 0xffff) {
- PyErr_SetString(
- PyExc_OverflowError,
- "getsockaddrarg: port must be 0-65535.");
- return 0;
- }
- addr->sin6_family = s->sock_family;
- addr->sin6_port = htons((short)port);
- addr->sin6_flowinfo = flowinfo;
- addr->sin6_scope_id = scope_id;
- *len_ret = sizeof *addr;
- return 1;
- }
+ case AF_INET6:
+ {
+ struct sockaddr_in6* addr;
+ char *host;
+ int port, flowinfo, scope_id, result;
+ flowinfo = scope_id = 0;
+ if (!PyTuple_Check(args)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "getsockaddrarg: "
+ "AF_INET6 address must be tuple, not %.500s",
+ Py_TYPE(args)->tp_name);
+ return 0;
+ }
+ if (!PyArg_ParseTuple(args, "eti|ii",
+ "idna", &host, &port, &flowinfo,
+ &scope_id)) {
+ return 0;
+ }
+ addr = (struct sockaddr_in6*)addr_ret;
+ result = setipaddr(host, (struct sockaddr *)addr,
+ sizeof(*addr), AF_INET6);
+ PyMem_Free(host);
+ if (result < 0)
+ return 0;
+ if (port < 0 || port > 0xffff) {
+ PyErr_SetString(
+ PyExc_OverflowError,
+ "getsockaddrarg: port must be 0-65535.");
+ return 0;
+ }
+ addr->sin6_family = s->sock_family;
+ addr->sin6_port = htons((short)port);
+ addr->sin6_flowinfo = flowinfo;
+ addr->sin6_scope_id = scope_id;
+ *len_ret = sizeof *addr;
+ return 1;
+ }
#endif
#ifdef USE_BLUETOOTH
- case AF_BLUETOOTH:
- {
- switch (s->sock_proto) {
- case BTPROTO_L2CAP:
- {
- struct sockaddr_l2 *addr;
- char *straddr;
+ case AF_BLUETOOTH:
+ {
+ switch (s->sock_proto) {
+ case BTPROTO_L2CAP:
+ {
+ struct sockaddr_l2 *addr;
+ char *straddr;
- addr = (struct sockaddr_l2 *)addr_ret;
- memset(addr, 0, sizeof(struct sockaddr_l2));
- _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
- if (!PyArg_ParseTuple(args, "si", &straddr,
- &_BT_L2_MEMB(addr, psm))) {
- PyErr_SetString(socket_error, "getsockaddrarg: "
- "wrong format");
- return 0;
- }
- if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
- return 0;
+ addr = (struct sockaddr_l2 *)addr_ret;
+ memset(addr, 0, sizeof(struct sockaddr_l2));
+ _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
+ if (!PyArg_ParseTuple(args, "si", &straddr,
+ &_BT_L2_MEMB(addr, psm))) {
+ PyErr_SetString(socket_error, "getsockaddrarg: "
+ "wrong format");
+ return 0;
+ }
+ if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
+ return 0;
- *len_ret = sizeof *addr;
- return 1;
- }
- case BTPROTO_RFCOMM:
- {
- struct sockaddr_rc *addr;
- char *straddr;
+ *len_ret = sizeof *addr;
+ return 1;
+ }
+ case BTPROTO_RFCOMM:
+ {
+ struct sockaddr_rc *addr;
+ char *straddr;
- addr = (struct sockaddr_rc *)addr_ret;
- _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
- if (!PyArg_ParseTuple(args, "si", &straddr,
- &_BT_RC_MEMB(addr, channel))) {
- PyErr_SetString(socket_error, "getsockaddrarg: "
- "wrong format");
- return 0;
- }
- if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
- return 0;
+ addr = (struct sockaddr_rc *)addr_ret;
+ _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
+ if (!PyArg_ParseTuple(args, "si", &straddr,
+ &_BT_RC_MEMB(addr, channel))) {
+ PyErr_SetString(socket_error, "getsockaddrarg: "
+ "wrong format");
+ return 0;
+ }
+ if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
+ return 0;
- *len_ret = sizeof *addr;
- return 1;
- }
- case BTPROTO_HCI:
- {
- struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
- _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
- if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
- PyErr_SetString(socket_error, "getsockaddrarg: "
- "wrong format");
- return 0;
- }
- *len_ret = sizeof *addr;
- return 1;
- }
+ *len_ret = sizeof *addr;
+ return 1;
+ }
+ case BTPROTO_HCI:
+ {
+ struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
+ _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
+ if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
+ PyErr_SetString(socket_error, "getsockaddrarg: "
+ "wrong format");
+ return 0;
+ }
+ *len_ret = sizeof *addr;
+ return 1;
+ }
#if !defined(__FreeBSD__)
- case BTPROTO_SCO:
- {
- struct sockaddr_sco *addr;
- char *straddr;
+ case BTPROTO_SCO:
+ {
+ struct sockaddr_sco *addr;
+ char *straddr;
- addr = (struct sockaddr_sco *)addr_ret;
- _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
- if (!PyBytes_Check(args)) {
- PyErr_SetString(socket_error, "getsockaddrarg: "
- "wrong format");
- return 0;
- }
- straddr = PyBytes_AS_STRING(args);
- if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
- return 0;
+ addr = (struct sockaddr_sco *)addr_ret;
+ _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
+ if (!PyBytes_Check(args)) {
+ PyErr_SetString(socket_error, "getsockaddrarg: "
+ "wrong format");
+ return 0;
+ }
+ straddr = PyBytes_AS_STRING(args);
+ if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
+ return 0;
- *len_ret = sizeof *addr;
- return 1;
- }
+ *len_ret = sizeof *addr;
+ return 1;
+ }
#endif
- default:
- PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
- return 0;
- }
- }
+ default:
+ PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
+ return 0;
+ }
+ }
#endif
#ifdef HAVE_NETPACKET_PACKET_H
- case AF_PACKET:
- {
- struct sockaddr_ll* addr;
- struct ifreq ifr;
- char *interfaceName;
- int protoNumber;
- int hatype = 0;
- int pkttype = 0;
- char *haddr = NULL;
- unsigned int halen = 0;
+ case AF_PACKET:
+ {
+ struct sockaddr_ll* addr;
+ struct ifreq ifr;
+ char *interfaceName;
+ int protoNumber;
+ int hatype = 0;
+ int pkttype = 0;
+ char *haddr = NULL;
+ unsigned int halen = 0;
- if (!PyTuple_Check(args)) {
- PyErr_Format(
- PyExc_TypeError,
- "getsockaddrarg: "
- "AF_PACKET address must be tuple, not %.500s",
- Py_TYPE(args)->tp_name);
- return 0;
- }
- if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
- &protoNumber, &pkttype, &hatype,
- &haddr, &halen))
- return 0;
- strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
- ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
- if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
- s->errorhandler();
- return 0;
- }
- if (halen > 8) {
- PyErr_SetString(PyExc_ValueError,
- "Hardware address must be 8 bytes or less");
- return 0;
- }
- if (protoNumber < 0 || protoNumber > 0xffff) {
- PyErr_SetString(
- PyExc_OverflowError,
- "getsockaddrarg: protoNumber must be 0-65535.");
- return 0;
- }
- addr = (struct sockaddr_ll*)addr_ret;
- addr->sll_family = AF_PACKET;
- addr->sll_protocol = htons((short)protoNumber);
- addr->sll_ifindex = ifr.ifr_ifindex;
- addr->sll_pkttype = pkttype;
- addr->sll_hatype = hatype;
- if (halen != 0) {
- memcpy(&addr->sll_addr, haddr, halen);
- }
- addr->sll_halen = halen;
- *len_ret = sizeof *addr;
- return 1;
- }
+ if (!PyTuple_Check(args)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "getsockaddrarg: "
+ "AF_PACKET address must be tuple, not %.500s",
+ Py_TYPE(args)->tp_name);
+ return 0;
+ }
+ if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
+ &protoNumber, &pkttype, &hatype,
+ &haddr, &halen))
+ return 0;
+ strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
+ ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
+ if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
+ s->errorhandler();
+ return 0;
+ }
+ if (halen > 8) {
+ PyErr_SetString(PyExc_ValueError,
+ "Hardware address must be 8 bytes or less");
+ return 0;
+ }
+ if (protoNumber < 0 || protoNumber > 0xffff) {
+ PyErr_SetString(
+ PyExc_OverflowError,
+ "getsockaddrarg: protoNumber must be 0-65535.");
+ return 0;
+ }
+ addr = (struct sockaddr_ll*)addr_ret;
+ addr->sll_family = AF_PACKET;
+ addr->sll_protocol = htons((short)protoNumber);
+ addr->sll_ifindex = ifr.ifr_ifindex;
+ addr->sll_pkttype = pkttype;
+ addr->sll_hatype = hatype;
+ if (halen != 0) {
+ memcpy(&addr->sll_addr, haddr, halen);
+ }
+ addr->sll_halen = halen;
+ *len_ret = sizeof *addr;
+ return 1;
+ }
#endif
#ifdef HAVE_LINUX_TIPC_H
- case AF_TIPC:
- {
- unsigned int atype, v1, v2, v3;
- unsigned int scope = TIPC_CLUSTER_SCOPE;
- struct sockaddr_tipc *addr;
+ case AF_TIPC:
+ {
+ unsigned int atype, v1, v2, v3;
+ unsigned int scope = TIPC_CLUSTER_SCOPE;
+ struct sockaddr_tipc *addr;
- if (!PyTuple_Check(args)) {
- PyErr_Format(
- PyExc_TypeError,
- "getsockaddrarg: "
- "AF_TIPC address must be tuple, not %.500s",
- Py_TYPE(args)->tp_name);
- return 0;
- }
+ if (!PyTuple_Check(args)) {
+ PyErr_Format(
+ PyExc_TypeError,
+ "getsockaddrarg: "
+ "AF_TIPC address must be tuple, not %.500s",
+ Py_TYPE(args)->tp_name);
+ return 0;
+ }
- if (!PyArg_ParseTuple(args,
- "IIII|I;Invalid TIPC address format",
- &atype, &v1, &v2, &v3, &scope))
- return 0;
+ if (!PyArg_ParseTuple(args,
+ "IIII|I;Invalid TIPC address format",
+ &atype, &v1, &v2, &v3, &scope))
+ return 0;
- addr = (struct sockaddr_tipc *) addr_ret;
- memset(addr, 0, sizeof(struct sockaddr_tipc));
+ addr = (struct sockaddr_tipc *) addr_ret;
+ memset(addr, 0, sizeof(struct sockaddr_tipc));
- addr->family = AF_TIPC;
- addr->scope = scope;
- addr->addrtype = atype;
+ addr->family = AF_TIPC;
+ addr->scope = scope;
+ addr->addrtype = atype;
- if (atype == TIPC_ADDR_NAMESEQ) {
- addr->addr.nameseq.type = v1;
- addr->addr.nameseq.lower = v2;
- addr->addr.nameseq.upper = v3;
- } else if (atype == TIPC_ADDR_NAME) {
- addr->addr.name.name.type = v1;
- addr->addr.name.name.instance = v2;
- } else if (atype == TIPC_ADDR_ID) {
- addr->addr.id.node = v1;
- addr->addr.id.ref = v2;
- } else {
- /* Shouldn't happen */
- PyErr_SetString(PyExc_TypeError, "Invalid address type");
- return 0;
- }
+ if (atype == TIPC_ADDR_NAMESEQ) {
+ addr->addr.nameseq.type = v1;
+ addr->addr.nameseq.lower = v2;
+ addr->addr.nameseq.upper = v3;
+ } else if (atype == TIPC_ADDR_NAME) {
+ addr->addr.name.name.type = v1;
+ addr->addr.name.name.instance = v2;
+ } else if (atype == TIPC_ADDR_ID) {
+ addr->addr.id.node = v1;
+ addr->addr.id.ref = v2;
+ } else {
+ /* Shouldn't happen */
+ PyErr_SetString(PyExc_TypeError, "Invalid address type");
+ return 0;
+ }
- *len_ret = sizeof(*addr);
+ *len_ret = sizeof(*addr);
- return 1;
- }
+ return 1;
+ }
#endif
- /* More cases here... */
+ /* More cases here... */
- default:
- PyErr_SetString(socket_error, "getsockaddrarg: bad family");
- return 0;
+ default:
+ PyErr_SetString(socket_error, "getsockaddrarg: bad family");
+ return 0;
- }
+ }
}
@@ -1486,89 +1486,89 @@
static int
getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
{
- switch (s->sock_family) {
+ switch (s->sock_family) {
#if defined(AF_UNIX)
- case AF_UNIX:
- {
- *len_ret = sizeof (struct sockaddr_un);
- return 1;
- }
+ case AF_UNIX:
+ {
+ *len_ret = sizeof (struct sockaddr_un);
+ return 1;
+ }
#endif /* AF_UNIX */
#if defined(AF_NETLINK)
case AF_NETLINK:
{
- *len_ret = sizeof (struct sockaddr_nl);
- return 1;
+ *len_ret = sizeof (struct sockaddr_nl);
+ return 1;
}
#endif
- case AF_INET:
- {
- *len_ret = sizeof (struct sockaddr_in);
- return 1;
- }
+ case AF_INET:
+ {
+ *len_ret = sizeof (struct sockaddr_in);
+ return 1;
+ }
#ifdef ENABLE_IPV6
- case AF_INET6:
- {
- *len_ret = sizeof (struct sockaddr_in6);
- return 1;
- }
+ case AF_INET6:
+ {
+ *len_ret = sizeof (struct sockaddr_in6);
+ return 1;
+ }
#endif
#ifdef USE_BLUETOOTH
- case AF_BLUETOOTH:
- {
- switch(s->sock_proto)
- {
+ case AF_BLUETOOTH:
+ {
+ switch(s->sock_proto)
+ {
- case BTPROTO_L2CAP:
- *len_ret = sizeof (struct sockaddr_l2);
- return 1;
- case BTPROTO_RFCOMM:
- *len_ret = sizeof (struct sockaddr_rc);
- return 1;
- case BTPROTO_HCI:
- *len_ret = sizeof (struct sockaddr_hci);
- return 1;
+ case BTPROTO_L2CAP:
+ *len_ret = sizeof (struct sockaddr_l2);
+ return 1;
+ case BTPROTO_RFCOMM:
+ *len_ret = sizeof (struct sockaddr_rc);
+ return 1;
+ case BTPROTO_HCI:
+ *len_ret = sizeof (struct sockaddr_hci);
+ return 1;
#if !defined(__FreeBSD__)
- case BTPROTO_SCO:
- *len_ret = sizeof (struct sockaddr_sco);
- return 1;
+ case BTPROTO_SCO:
+ *len_ret = sizeof (struct sockaddr_sco);
+ return 1;
#endif
- default:
- PyErr_SetString(socket_error, "getsockaddrlen: "
- "unknown BT protocol");
- return 0;
+ default:
+ PyErr_SetString(socket_error, "getsockaddrlen: "
+ "unknown BT protocol");
+ return 0;
- }
- }
+ }
+ }
#endif
#ifdef HAVE_NETPACKET_PACKET_H
- case AF_PACKET:
- {
- *len_ret = sizeof (struct sockaddr_ll);
- return 1;
- }
+ case AF_PACKET:
+ {
+ *len_ret = sizeof (struct sockaddr_ll);
+ return 1;
+ }
#endif
#ifdef HAVE_LINUX_TIPC_H
- case AF_TIPC:
- {
- *len_ret = sizeof (struct sockaddr_tipc);
- return 1;
- }
+ case AF_TIPC:
+ {
+ *len_ret = sizeof (struct sockaddr_tipc);
+ return 1;
+ }
#endif
- /* More cases here... */
+ /* More cases here... */
- default:
- PyErr_SetString(socket_error, "getsockaddrlen: bad family");
- return 0;
+ default:
+ PyErr_SetString(socket_error, "getsockaddrlen: bad family");
+ return 0;
- }
+ }
}
@@ -1577,52 +1577,52 @@
static PyObject *
sock_accept(PySocketSockObject *s)
{
- sock_addr_t addrbuf;
- SOCKET_T newfd = INVALID_SOCKET;
- socklen_t addrlen;
- PyObject *sock = NULL;
- PyObject *addr = NULL;
- PyObject *res = NULL;
- int timeout;
+ sock_addr_t addrbuf;
+ SOCKET_T newfd = INVALID_SOCKET;
+ socklen_t addrlen;
+ PyObject *sock = NULL;
+ PyObject *addr = NULL;
+ PyObject *res = NULL;
+ int timeout;
- if (!getsockaddrlen(s, &addrlen))
- return NULL;
- memset(&addrbuf, 0, addrlen);
+ if (!getsockaddrlen(s, &addrlen))
+ return NULL;
+ memset(&addrbuf, 0, addrlen);
- if (!IS_SELECTABLE(s))
- return select_error();
+ if (!IS_SELECTABLE(s))
+ return select_error();
- Py_BEGIN_ALLOW_THREADS
- timeout = internal_select(s, 0);
- if (!timeout)
- newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ timeout = internal_select(s, 0);
+ if (!timeout)
+ newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+ Py_END_ALLOW_THREADS
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return NULL;
- }
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return NULL;
+ }
- if (newfd == INVALID_SOCKET)
- return s->errorhandler();
+ if (newfd == INVALID_SOCKET)
+ return s->errorhandler();
- sock = PyLong_FromSocket_t(newfd);
- if (sock == NULL) {
- SOCKETCLOSE(newfd);
- goto finally;
- }
+ sock = PyLong_FromSocket_t(newfd);
+ if (sock == NULL) {
+ SOCKETCLOSE(newfd);
+ goto finally;
+ }
- addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
- addrlen, s->sock_proto);
- if (addr == NULL)
- goto finally;
+ addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
+ addrlen, s->sock_proto);
+ if (addr == NULL)
+ goto finally;
- res = PyTuple_Pack(2, sock, addr);
+ res = PyTuple_Pack(2, sock, addr);
finally:
- Py_XDECREF(sock);
- Py_XDECREF(addr);
- return res;
+ Py_XDECREF(sock);
+ Py_XDECREF(addr);
+ return res;
}
PyDoc_STRVAR(accept_doc,
@@ -1640,17 +1640,17 @@
static PyObject *
sock_setblocking(PySocketSockObject *s, PyObject *arg)
{
- int block;
+ int block;
- block = PyLong_AsLong(arg);
- if (block == -1 && PyErr_Occurred())
- return NULL;
+ block = PyLong_AsLong(arg);
+ if (block == -1 && PyErr_Occurred())
+ return NULL;
- s->sock_timeout = block ? -1.0 : 0.0;
- internal_setblocking(s, block);
+ s->sock_timeout = block ? -1.0 : 0.0;
+ internal_setblocking(s, block);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(setblocking_doc,
@@ -1669,25 +1669,25 @@
static PyObject *
sock_settimeout(PySocketSockObject *s, PyObject *arg)
{
- double timeout;
+ double timeout;
- if (arg == Py_None)
- timeout = -1.0;
- else {
- timeout = PyFloat_AsDouble(arg);
- if (timeout < 0.0) {
- if (!PyErr_Occurred())
- PyErr_SetString(PyExc_ValueError,
- "Timeout value out of range");
- return NULL;
- }
- }
+ if (arg == Py_None)
+ timeout = -1.0;
+ else {
+ timeout = PyFloat_AsDouble(arg);
+ if (timeout < 0.0) {
+ if (!PyErr_Occurred())
+ PyErr_SetString(PyExc_ValueError,
+ "Timeout value out of range");
+ return NULL;
+ }
+ }
- s->sock_timeout = timeout;
- internal_setblocking(s, timeout < 0.0);
+ s->sock_timeout = timeout;
+ internal_setblocking(s, timeout < 0.0);
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(settimeout_doc,
@@ -1703,12 +1703,12 @@
static PyObject *
sock_gettimeout(PySocketSockObject *s)
{
- if (s->sock_timeout < 0.0) {
- Py_INCREF(Py_None);
- return Py_None;
- }
- else
- return PyFloat_FromDouble(s->sock_timeout);
+ if (s->sock_timeout < 0.0) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ else
+ return PyFloat_FromDouble(s->sock_timeout);
}
PyDoc_STRVAR(gettimeout_doc,
@@ -1726,29 +1726,29 @@
static PyObject *
sock_setsockopt(PySocketSockObject *s, PyObject *args)
{
- int level;
- int optname;
- int res;
- char *buf;
- int buflen;
- int flag;
+ int level;
+ int optname;
+ int res;
+ char *buf;
+ int buflen;
+ int flag;
- if (PyArg_ParseTuple(args, "iii:setsockopt",
- &level, &optname, &flag)) {
- buf = (char *) &flag;
- buflen = sizeof flag;
- }
- else {
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
- &level, &optname, &buf, &buflen))
- return NULL;
- }
- res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
- if (res < 0)
- return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ if (PyArg_ParseTuple(args, "iii:setsockopt",
+ &level, &optname, &flag)) {
+ buf = (char *) &flag;
+ buflen = sizeof flag;
+ }
+ else {
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
+ &level, &optname, &buf, &buflen))
+ return NULL;
+ }
+ res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
+ if (res < 0)
+ return s->errorhandler();
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(setsockopt_doc,
@@ -1766,47 +1766,47 @@
static PyObject *
sock_getsockopt(PySocketSockObject *s, PyObject *args)
{
- int level;
- int optname;
- int res;
- PyObject *buf;
- socklen_t buflen = 0;
+ int level;
+ int optname;
+ int res;
+ PyObject *buf;
+ socklen_t buflen = 0;
- if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
- &level, &optname, &buflen))
- return NULL;
+ if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
+ &level, &optname, &buflen))
+ return NULL;
- if (buflen == 0) {
- int flag = 0;
- socklen_t flagsize = sizeof flag;
- res = getsockopt(s->sock_fd, level, optname,
- (void *)&flag, &flagsize);
- if (res < 0)
- return s->errorhandler();
- return PyLong_FromLong(flag);
- }
+ if (buflen == 0) {
+ int flag = 0;
+ socklen_t flagsize = sizeof flag;
+ res = getsockopt(s->sock_fd, level, optname,
+ (void *)&flag, &flagsize);
+ if (res < 0)
+ return s->errorhandler();
+ return PyLong_FromLong(flag);
+ }
#ifdef __VMS
- /* socklen_t is unsigned so no negative test is needed,
- test buflen == 0 is previously done */
- if (buflen > 1024) {
+ /* socklen_t is unsigned so no negative test is needed,
+ test buflen == 0 is previously done */
+ if (buflen > 1024) {
#else
- if (buflen <= 0 || buflen > 1024) {
+ if (buflen <= 0 || buflen > 1024) {
#endif
- PyErr_SetString(socket_error,
- "getsockopt buflen out of range");
- return NULL;
- }
- buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
- if (buf == NULL)
- return NULL;
- res = getsockopt(s->sock_fd, level, optname,
- (void *)PyBytes_AS_STRING(buf), &buflen);
- if (res < 0) {
- Py_DECREF(buf);
- return s->errorhandler();
- }
- _PyBytes_Resize(&buf, buflen);
- return buf;
+ PyErr_SetString(socket_error,
+ "getsockopt buflen out of range");
+ return NULL;
+ }
+ buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
+ if (buf == NULL)
+ return NULL;
+ res = getsockopt(s->sock_fd, level, optname,
+ (void *)PyBytes_AS_STRING(buf), &buflen);
+ if (res < 0) {
+ Py_DECREF(buf);
+ return s->errorhandler();
+ }
+ _PyBytes_Resize(&buf, buflen);
+ return buf;
}
PyDoc_STRVAR(getsockopt_doc,
@@ -1822,19 +1822,19 @@
static PyObject *
sock_bind(PySocketSockObject *s, PyObject *addro)
{
- sock_addr_t addrbuf;
- int addrlen;
- int res;
+ sock_addr_t addrbuf;
+ int addrlen;
+ int res;
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return s->errorhandler();
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(bind_doc,
@@ -1852,16 +1852,16 @@
static PyObject *
sock_close(PySocketSockObject *s)
{
- SOCKET_T fd;
+ SOCKET_T fd;
- if ((fd = s->sock_fd) != -1) {
- s->sock_fd = -1;
- Py_BEGIN_ALLOW_THREADS
- (void) SOCKETCLOSE(fd);
- Py_END_ALLOW_THREADS
- }
- Py_INCREF(Py_None);
- return Py_None;
+ if ((fd = s->sock_fd) != -1) {
+ s->sock_fd = -1;
+ Py_BEGIN_ALLOW_THREADS
+ (void) SOCKETCLOSE(fd);
+ Py_END_ALLOW_THREADS
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(close_doc,
@@ -1871,90 +1871,90 @@
static int
internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
- int *timeoutp)
+ int *timeoutp)
{
- int res, timeout;
+ int res, timeout;
- timeout = 0;
- res = connect(s->sock_fd, addr, addrlen);
+ timeout = 0;
+ res = connect(s->sock_fd, addr, addrlen);
#ifdef MS_WINDOWS
- if (s->sock_timeout > 0.0) {
- if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
- IS_SELECTABLE(s)) {
- /* This is a mess. Best solution: trust select */
- fd_set fds;
- fd_set fds_exc;
- struct timeval tv;
- tv.tv_sec = (int)s->sock_timeout;
- tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
- FD_ZERO(&fds);
- FD_SET(s->sock_fd, &fds);
- FD_ZERO(&fds_exc);
- FD_SET(s->sock_fd, &fds_exc);
- res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
- if (res == 0) {
- res = WSAEWOULDBLOCK;
- timeout = 1;
- } else if (res > 0) {
- if (FD_ISSET(s->sock_fd, &fds))
- /* The socket is in the writable set - this
- means connected */
- res = 0;
- else {
- /* As per MS docs, we need to call getsockopt()
- to get the underlying error */
- int res_size = sizeof res;
- /* It must be in the exception set */
- assert(FD_ISSET(s->sock_fd, &fds_exc));
- if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
- (char *)&res, &res_size))
- /* getsockopt also clears WSAGetLastError,
- so reset it back. */
- WSASetLastError(res);
- else
- res = WSAGetLastError();
- }
- }
- /* else if (res < 0) an error occurred */
- }
- }
+ if (s->sock_timeout > 0.0) {
+ if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
+ IS_SELECTABLE(s)) {
+ /* This is a mess. Best solution: trust select */
+ fd_set fds;
+ fd_set fds_exc;
+ struct timeval tv;
+ tv.tv_sec = (int)s->sock_timeout;
+ tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
+ FD_ZERO(&fds);
+ FD_SET(s->sock_fd, &fds);
+ FD_ZERO(&fds_exc);
+ FD_SET(s->sock_fd, &fds_exc);
+ res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
+ if (res == 0) {
+ res = WSAEWOULDBLOCK;
+ timeout = 1;
+ } else if (res > 0) {
+ if (FD_ISSET(s->sock_fd, &fds))
+ /* The socket is in the writable set - this
+ means connected */
+ res = 0;
+ else {
+ /* As per MS docs, we need to call getsockopt()
+ to get the underlying error */
+ int res_size = sizeof res;
+ /* It must be in the exception set */
+ assert(FD_ISSET(s->sock_fd, &fds_exc));
+ if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
+ (char *)&res, &res_size))
+ /* getsockopt also clears WSAGetLastError,
+ so reset it back. */
+ WSASetLastError(res);
+ else
+ res = WSAGetLastError();
+ }
+ }
+ /* else if (res < 0) an error occurred */
+ }
+ }
- if (res < 0)
- res = WSAGetLastError();
+ if (res < 0)
+ res = WSAGetLastError();
#else
- if (s->sock_timeout > 0.0) {
- if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
- timeout = internal_select(s, 1);
- if (timeout == 0) {
- /* Bug #1019808: in case of an EINPROGRESS,
- use getsockopt(SO_ERROR) to get the real
- error. */
- socklen_t res_size = sizeof res;
- (void)getsockopt(s->sock_fd, SOL_SOCKET,
- SO_ERROR, &res, &res_size);
- if (res == EISCONN)
- res = 0;
- errno = res;
- }
- else if (timeout == -1) {
- res = errno; /* had error */
- }
- else
- res = EWOULDBLOCK; /* timed out */
- }
- }
+ if (s->sock_timeout > 0.0) {
+ if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
+ timeout = internal_select(s, 1);
+ if (timeout == 0) {
+ /* Bug #1019808: in case of an EINPROGRESS,
+ use getsockopt(SO_ERROR) to get the real
+ error. */
+ socklen_t res_size = sizeof res;
+ (void)getsockopt(s->sock_fd, SOL_SOCKET,
+ SO_ERROR, &res, &res_size);
+ if (res == EISCONN)
+ res = 0;
+ errno = res;
+ }
+ else if (timeout == -1) {
+ res = errno; /* had error */
+ }
+ else
+ res = EWOULDBLOCK; /* timed out */
+ }
+ }
- if (res < 0)
- res = errno;
+ if (res < 0)
+ res = errno;
#endif
- *timeoutp = timeout;
+ *timeoutp = timeout;
- return res;
+ return res;
}
/* s.connect(sockaddr) method */
@@ -1962,26 +1962,26 @@
static PyObject *
sock_connect(PySocketSockObject *s, PyObject *addro)
{
- sock_addr_t addrbuf;
- int addrlen;
- int res;
- int timeout;
+ sock_addr_t addrbuf;
+ int addrlen;
+ int res;
+ int timeout;
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
- return NULL;
+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
+ Py_END_ALLOW_THREADS
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return NULL;
- }
- if (res != 0)
- return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return NULL;
+ }
+ if (res != 0)
+ return s->errorhandler();
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(connect_doc,
@@ -1996,26 +1996,26 @@
static PyObject *
sock_connect_ex(PySocketSockObject *s, PyObject *addro)
{
- sock_addr_t addrbuf;
- int addrlen;
- int res;
- int timeout;
+ sock_addr_t addrbuf;
+ int addrlen;
+ int res;
+ int timeout;
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
- return NULL;
+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+ return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
+ Py_END_ALLOW_THREADS
- /* Signals are not errors (though they may raise exceptions). Adapted
- from PyErr_SetFromErrnoWithFilenameObject(). */
+ /* Signals are not errors (though they may raise exceptions). Adapted
+ from PyErr_SetFromErrnoWithFilenameObject(). */
#ifdef EINTR
- if (res == EINTR && PyErr_CheckSignals())
- return NULL;
+ if (res == EINTR && PyErr_CheckSignals())
+ return NULL;
#endif
- return PyLong_FromLong((long) res);
+ return PyLong_FromLong((long) res);
}
PyDoc_STRVAR(connect_ex_doc,
@@ -2030,7 +2030,7 @@
static PyObject *
sock_fileno(PySocketSockObject *s)
{
- return PyLong_FromSocket_t(s->sock_fd);
+ return PyLong_FromSocket_t(s->sock_fd);
}
PyDoc_STRVAR(fileno_doc,
@@ -2044,20 +2044,20 @@
static PyObject *
sock_getsockname(PySocketSockObject *s)
{
- sock_addr_t addrbuf;
- int res;
- socklen_t addrlen;
+ sock_addr_t addrbuf;
+ int res;
+ socklen_t addrlen;
- if (!getsockaddrlen(s, &addrlen))
- return NULL;
- memset(&addrbuf, 0, addrlen);
- Py_BEGIN_ALLOW_THREADS
- res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return s->errorhandler();
- return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
- s->sock_proto);
+ if (!getsockaddrlen(s, &addrlen))
+ return NULL;
+ memset(&addrbuf, 0, addrlen);
+ Py_BEGIN_ALLOW_THREADS
+ res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return s->errorhandler();
+ return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
+ s->sock_proto);
}
PyDoc_STRVAR(getsockname_doc,
@@ -2067,26 +2067,26 @@
info is a pair (hostaddr, port).");
-#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
+#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
/* s.getpeername() method */
static PyObject *
sock_getpeername(PySocketSockObject *s)
{
- sock_addr_t addrbuf;
- int res;
- socklen_t addrlen;
+ sock_addr_t addrbuf;
+ int res;
+ socklen_t addrlen;
- if (!getsockaddrlen(s, &addrlen))
- return NULL;
- memset(&addrbuf, 0, addrlen);
- Py_BEGIN_ALLOW_THREADS
- res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return s->errorhandler();
- return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
- s->sock_proto);
+ if (!getsockaddrlen(s, &addrlen))
+ return NULL;
+ memset(&addrbuf, 0, addrlen);
+ Py_BEGIN_ALLOW_THREADS
+ res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return s->errorhandler();
+ return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
+ s->sock_proto);
}
PyDoc_STRVAR(getpeername_doc,
@@ -2103,21 +2103,21 @@
static PyObject *
sock_listen(PySocketSockObject *s, PyObject *arg)
{
- int backlog;
- int res;
+ int backlog;
+ int res;
- backlog = PyLong_AsLong(arg);
- if (backlog == -1 && PyErr_Occurred())
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- if (backlog < 1)
- backlog = 1;
- res = listen(s->sock_fd, backlog);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ backlog = PyLong_AsLong(arg);
+ if (backlog == -1 && PyErr_Occurred())
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ if (backlog < 1)
+ backlog = 1;
+ res = listen(s->sock_fd, backlog);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return s->errorhandler();
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(listen_doc,
@@ -2139,80 +2139,80 @@
static ssize_t
sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags)
{
- ssize_t outlen = -1;
- int timeout;
+ ssize_t outlen = -1;
+ int timeout;
#ifdef __VMS
- int remaining;
- char *read_buf;
+ int remaining;
+ char *read_buf;
#endif
- if (!IS_SELECTABLE(s)) {
- select_error();
- return -1;
- }
- if (len == 0) {
- /* If 0 bytes were requested, do nothing. */
- return 0;
- }
+ if (!IS_SELECTABLE(s)) {
+ select_error();
+ return -1;
+ }
+ if (len == 0) {
+ /* If 0 bytes were requested, do nothing. */
+ return 0;
+ }
#ifndef __VMS
- Py_BEGIN_ALLOW_THREADS
- timeout = internal_select(s, 0);
- if (!timeout)
- outlen = recv(s->sock_fd, cbuf, len, flags);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ timeout = internal_select(s, 0);
+ if (!timeout)
+ outlen = recv(s->sock_fd, cbuf, len, flags);
+ Py_END_ALLOW_THREADS
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return -1;
- }
- if (outlen < 0) {
- /* Note: the call to errorhandler() ALWAYS indirectly returned
- NULL, so ignore its return value */
- s->errorhandler();
- return -1;
- }
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return -1;
+ }
+ if (outlen < 0) {
+ /* Note: the call to errorhandler() ALWAYS indirectly returned
+ NULL, so ignore its return value */
+ s->errorhandler();
+ return -1;
+ }
#else
- read_buf = cbuf;
- remaining = len;
- while (remaining != 0) {
- unsigned int segment;
- int nread = -1;
+ read_buf = cbuf;
+ remaining = len;
+ while (remaining != 0) {
+ unsigned int segment;
+ int nread = -1;
- segment = remaining /SEGMENT_SIZE;
- if (segment != 0) {
- segment = SEGMENT_SIZE;
- }
- else {
- segment = remaining;
- }
+ segment = remaining /SEGMENT_SIZE;
+ if (segment != 0) {
+ segment = SEGMENT_SIZE;
+ }
+ else {
+ segment = remaining;
+ }
- Py_BEGIN_ALLOW_THREADS
- timeout = internal_select(s, 0);
- if (!timeout)
- nread = recv(s->sock_fd, read_buf, segment, flags);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ timeout = internal_select(s, 0);
+ if (!timeout)
+ nread = recv(s->sock_fd, read_buf, segment, flags);
+ Py_END_ALLOW_THREADS
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return -1;
- }
- if (nread < 0) {
- s->errorhandler();
- return -1;
- }
- if (nread != remaining) {
- read_buf += nread;
- break;
- }
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return -1;
+ }
+ if (nread < 0) {
+ s->errorhandler();
+ return -1;
+ }
+ if (nread != remaining) {
+ read_buf += nread;
+ break;
+ }
- remaining -= segment;
- read_buf += segment;
- }
- outlen = read_buf - cbuf;
+ remaining -= segment;
+ read_buf += segment;
+ }
+ outlen = read_buf - cbuf;
#endif /* !__VMS */
- return outlen;
+ return outlen;
}
@@ -2221,39 +2221,39 @@
static PyObject *
sock_recv(PySocketSockObject *s, PyObject *args)
{
- int recvlen, flags = 0;
- ssize_t outlen;
- PyObject *buf;
+ int recvlen, flags = 0;
+ ssize_t outlen;
+ PyObject *buf;
- if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
+ return NULL;
- if (recvlen < 0) {
- PyErr_SetString(PyExc_ValueError,
- "negative buffersize in recv");
- return NULL;
- }
+ if (recvlen < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "negative buffersize in recv");
+ return NULL;
+ }
- /* Allocate a new string. */
- buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
- if (buf == NULL)
- return NULL;
+ /* Allocate a new string. */
+ buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+ if (buf == NULL)
+ return NULL;
- /* Call the guts */
- outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
- if (outlen < 0) {
- /* An error occurred, release the string and return an
- error. */
- Py_DECREF(buf);
- return NULL;
- }
- if (outlen != recvlen) {
- /* We did not read as many bytes as we anticipated, resize the
- string if possible and be successful. */
- _PyBytes_Resize(&buf, outlen);
- }
+ /* Call the guts */
+ outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
+ if (outlen < 0) {
+ /* An error occurred, release the string and return an
+ error. */
+ Py_DECREF(buf);
+ return NULL;
+ }
+ if (outlen != recvlen) {
+ /* We did not read as many bytes as we anticipated, resize the
+ string if possible and be successful. */
+ _PyBytes_Resize(&buf, outlen);
+ }
- return buf;
+ return buf;
}
PyDoc_STRVAR(recv_doc,
@@ -2270,52 +2270,52 @@
static PyObject*
sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
{
- static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
+ static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
- int recvlen = 0, flags = 0;
- ssize_t readlen;
- Py_buffer pbuf;
- char *buf;
- int buflen;
+ int recvlen = 0, flags = 0;
+ ssize_t readlen;
+ Py_buffer pbuf;
+ char *buf;
+ int buflen;
- /* Get the buffer's memory */
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,
- &pbuf, &recvlen, &flags))
- return NULL;
- buf = pbuf.buf;
- buflen = pbuf.len;
+ /* Get the buffer's memory */
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,
+ &pbuf, &recvlen, &flags))
+ return NULL;
+ buf = pbuf.buf;
+ buflen = pbuf.len;
- if (recvlen < 0) {
- PyBuffer_Release(&pbuf);
- PyErr_SetString(PyExc_ValueError,
- "negative buffersize in recv_into");
- return NULL;
- }
- if (recvlen == 0) {
- /* If nbytes was not specified, use the buffer's length */
- recvlen = buflen;
- }
+ if (recvlen < 0) {
+ PyBuffer_Release(&pbuf);
+ PyErr_SetString(PyExc_ValueError,
+ "negative buffersize in recv_into");
+ return NULL;
+ }
+ if (recvlen == 0) {
+ /* If nbytes was not specified, use the buffer's length */
+ recvlen = buflen;
+ }
- /* Check if the buffer is large enough */
- if (buflen < recvlen) {
- PyBuffer_Release(&pbuf);
- PyErr_SetString(PyExc_ValueError,
- "buffer too small for requested bytes");
- return NULL;
- }
+ /* Check if the buffer is large enough */
+ if (buflen < recvlen) {
+ PyBuffer_Release(&pbuf);
+ PyErr_SetString(PyExc_ValueError,
+ "buffer too small for requested bytes");
+ return NULL;
+ }
- /* Call the guts */
- readlen = sock_recv_guts(s, buf, recvlen, flags);
- if (readlen < 0) {
- /* Return an error. */
- PyBuffer_Release(&pbuf);
- return NULL;
- }
+ /* Call the guts */
+ readlen = sock_recv_guts(s, buf, recvlen, flags);
+ if (readlen < 0) {
+ /* Return an error. */
+ PyBuffer_Release(&pbuf);
+ return NULL;
+ }
- PyBuffer_Release(&pbuf);
- /* Return the number of bytes read. Note that we do not do anything
- special here in the case that readlen < recvlen. */
- return PyLong_FromSsize_t(readlen);
+ PyBuffer_Release(&pbuf);
+ /* Return the number of bytes read. Note that we do not do anything
+ special here in the case that readlen < recvlen. */
+ return PyLong_FromSsize_t(readlen);
}
PyDoc_STRVAR(recv_into_doc,
@@ -2341,56 +2341,56 @@
*/
static ssize_t
sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags,
- PyObject** addr)
+ PyObject** addr)
{
- sock_addr_t addrbuf;
- int timeout;
- ssize_t n = -1;
- socklen_t addrlen;
+ sock_addr_t addrbuf;
+ int timeout;
+ ssize_t n = -1;
+ socklen_t addrlen;
- *addr = NULL;
+ *addr = NULL;
- if (!getsockaddrlen(s, &addrlen))
- return -1;
+ if (!getsockaddrlen(s, &addrlen))
+ return -1;
- if (!IS_SELECTABLE(s)) {
- select_error();
- return -1;
- }
+ if (!IS_SELECTABLE(s)) {
+ select_error();
+ return -1;
+ }
- Py_BEGIN_ALLOW_THREADS
- memset(&addrbuf, 0, addrlen);
- timeout = internal_select(s, 0);
- if (!timeout) {
+ Py_BEGIN_ALLOW_THREADS
+ memset(&addrbuf, 0, addrlen);
+ timeout = internal_select(s, 0);
+ if (!timeout) {
#ifndef MS_WINDOWS
#if defined(PYOS_OS2) && !defined(PYCC_GCC)
- n = recvfrom(s->sock_fd, cbuf, len, flags,
- SAS2SA(&addrbuf), &addrlen);
+ n = recvfrom(s->sock_fd, cbuf, len, flags,
+ SAS2SA(&addrbuf), &addrlen);
#else
- n = recvfrom(s->sock_fd, cbuf, len, flags,
- (void *) &addrbuf, &addrlen);
+ n = recvfrom(s->sock_fd, cbuf, len, flags,
+ (void *) &addrbuf, &addrlen);
#endif
#else
- n = recvfrom(s->sock_fd, cbuf, len, flags,
- SAS2SA(&addrbuf), &addrlen);
+ n = recvfrom(s->sock_fd, cbuf, len, flags,
+ SAS2SA(&addrbuf), &addrlen);
#endif
- }
- Py_END_ALLOW_THREADS
+ }
+ Py_END_ALLOW_THREADS
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return -1;
- }
- if (n < 0) {
- s->errorhandler();
- return -1;
- }
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return -1;
+ }
+ if (n < 0) {
+ s->errorhandler();
+ return -1;
+ }
- if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
- addrlen, s->sock_proto)))
- return -1;
+ if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
+ addrlen, s->sock_proto)))
+ return -1;
- return n;
+ return n;
}
/* s.recvfrom(nbytes [,flags]) method */
@@ -2398,45 +2398,45 @@
static PyObject *
sock_recvfrom(PySocketSockObject *s, PyObject *args)
{
- PyObject *buf = NULL;
- PyObject *addr = NULL;
- PyObject *ret = NULL;
- int recvlen, flags = 0;
- ssize_t outlen;
+ PyObject *buf = NULL;
+ PyObject *addr = NULL;
+ PyObject *ret = NULL;
+ int recvlen, flags = 0;
+ ssize_t outlen;
- if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
- return NULL;
+ if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
+ return NULL;
- if (recvlen < 0) {
- PyErr_SetString(PyExc_ValueError,
- "negative buffersize in recvfrom");
- return NULL;
- }
+ if (recvlen < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "negative buffersize in recvfrom");
+ return NULL;
+ }
- buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
- if (buf == NULL)
- return NULL;
+ buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+ if (buf == NULL)
+ return NULL;
- outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
- recvlen, flags, &addr);
- if (outlen < 0) {
- goto finally;
- }
+ outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
+ recvlen, flags, &addr);
+ if (outlen < 0) {
+ goto finally;
+ }
- if (outlen != recvlen) {
- /* We did not read as many bytes as we anticipated, resize the
- string if possible and be succesful. */
- if (_PyBytes_Resize(&buf, outlen) < 0)
- /* Oopsy, not so succesful after all. */
- goto finally;
- }
+ if (outlen != recvlen) {
+ /* We did not read as many bytes as we anticipated, resize the
+ string if possible and be succesful. */
+ if (_PyBytes_Resize(&buf, outlen) < 0)
+ /* Oopsy, not so succesful after all. */
+ goto finally;
+ }
- ret = PyTuple_Pack(2, buf, addr);
+ ret = PyTuple_Pack(2, buf, addr);
finally:
- Py_XDECREF(buf);
- Py_XDECREF(addr);
- return ret;
+ Py_XDECREF(buf);
+ Py_XDECREF(addr);
+ return ret;
}
PyDoc_STRVAR(recvfrom_doc,
@@ -2450,47 +2450,47 @@
static PyObject *
sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
{
- static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
+ static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
- int recvlen = 0, flags = 0;
- ssize_t readlen;
- Py_buffer pbuf;
- char *buf;
- int buflen;
+ int recvlen = 0, flags = 0;
+ ssize_t readlen;
+ Py_buffer pbuf;
+ char *buf;
+ int buflen;
- PyObject *addr = NULL;
+ PyObject *addr = NULL;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",
- kwlist, &pbuf,
- &recvlen, &flags))
- return NULL;
- buf = pbuf.buf;
- buflen = pbuf.len;
- assert(buf != 0 && buflen > 0);
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",
+ kwlist, &pbuf,
+ &recvlen, &flags))
+ return NULL;
+ buf = pbuf.buf;
+ buflen = pbuf.len;
+ assert(buf != 0 && buflen > 0);
- if (recvlen < 0) {
- PyBuffer_Release(&pbuf);
- PyErr_SetString(PyExc_ValueError,
- "negative buffersize in recvfrom_into");
- return NULL;
- }
- if (recvlen == 0) {
- /* If nbytes was not specified, use the buffer's length */
- recvlen = buflen;
- }
+ if (recvlen < 0) {
+ PyBuffer_Release(&pbuf);
+ PyErr_SetString(PyExc_ValueError,
+ "negative buffersize in recvfrom_into");
+ return NULL;
+ }
+ if (recvlen == 0) {
+ /* If nbytes was not specified, use the buffer's length */
+ recvlen = buflen;
+ }
- readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
- if (readlen < 0) {
- PyBuffer_Release(&pbuf);
- /* Return an error */
- Py_XDECREF(addr);
- return NULL;
- }
+ readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
+ if (readlen < 0) {
+ PyBuffer_Release(&pbuf);
+ /* Return an error */
+ Py_XDECREF(addr);
+ return NULL;
+ }
- PyBuffer_Release(&pbuf);
- /* Return the number of bytes read and the address. Note that we do
- not do anything special here in the case that readlen < recvlen. */
- return Py_BuildValue("lN", readlen, addr);
+ PyBuffer_Release(&pbuf);
+ /* Return the number of bytes read and the address. Note that we do
+ not do anything special here in the case that readlen < recvlen. */
+ return Py_BuildValue("lN", readlen, addr);
}
PyDoc_STRVAR(recvfrom_into_doc,
@@ -2504,39 +2504,39 @@
static PyObject *
sock_send(PySocketSockObject *s, PyObject *args)
{
- char *buf;
- int len, n = -1, flags = 0, timeout;
- Py_buffer pbuf;
+ char *buf;
+ int len, n = -1, flags = 0, timeout;
+ Py_buffer pbuf;
- if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
- return NULL;
+ if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
+ return NULL;
- if (!IS_SELECTABLE(s)) {
- PyBuffer_Release(&pbuf);
- return select_error();
- }
- buf = pbuf.buf;
- len = pbuf.len;
+ if (!IS_SELECTABLE(s)) {
+ PyBuffer_Release(&pbuf);
+ return select_error();
+ }
+ buf = pbuf.buf;
+ len = pbuf.len;
- Py_BEGIN_ALLOW_THREADS
- timeout = internal_select(s, 1);
- if (!timeout)
+ Py_BEGIN_ALLOW_THREADS
+ timeout = internal_select(s, 1);
+ if (!timeout)
#ifdef __VMS
- n = sendsegmented(s->sock_fd, buf, len, flags);
+ n = sendsegmented(s->sock_fd, buf, len, flags);
#else
- n = send(s->sock_fd, buf, len, flags);
+ n = send(s->sock_fd, buf, len, flags);
#endif
- Py_END_ALLOW_THREADS
+ Py_END_ALLOW_THREADS
- PyBuffer_Release(&pbuf);
+ PyBuffer_Release(&pbuf);
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return NULL;
- }
- if (n < 0)
- return s->errorhandler();
- return PyLong_FromLong((long)n);
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return NULL;
+ }
+ if (n < 0)
+ return s->errorhandler();
+ return PyLong_FromLong((long)n);
}
PyDoc_STRVAR(send_doc,
@@ -2552,61 +2552,61 @@
static PyObject *
sock_sendall(PySocketSockObject *s, PyObject *args)
{
- char *buf;
- int len, n = -1, flags = 0, timeout;
- Py_buffer pbuf;
+ char *buf;
+ int len, n = -1, flags = 0, timeout;
+ Py_buffer pbuf;
- if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
- return NULL;
- buf = pbuf.buf;
- len = pbuf.len;
+ if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
+ return NULL;
+ buf = pbuf.buf;
+ len = pbuf.len;
- if (!IS_SELECTABLE(s)) {
- PyBuffer_Release(&pbuf);
- return select_error();
- }
+ if (!IS_SELECTABLE(s)) {
+ PyBuffer_Release(&pbuf);
+ return select_error();
+ }
- Py_BEGIN_ALLOW_THREADS
- do {
- timeout = internal_select(s, 1);
- n = -1;
- if (timeout)
- break;
+ Py_BEGIN_ALLOW_THREADS
+ do {
+ timeout = internal_select(s, 1);
+ n = -1;
+ if (timeout)
+ break;
#ifdef __VMS
- n = sendsegmented(s->sock_fd, buf, len, flags);
+ n = sendsegmented(s->sock_fd, buf, len, flags);
#else
- n = send(s->sock_fd, buf, len, flags);
+ n = send(s->sock_fd, buf, len, flags);
#endif
- if (n < 0) {
+ if (n < 0) {
#ifdef EINTR
- /* We must handle EINTR here as there is no way for
- * the caller to know how much was sent otherwise. */
- if (errno == EINTR) {
- /* Run signal handlers. If an exception was
- * raised, abort and leave this socket in
- * an unknown state. */
- if (PyErr_CheckSignals())
- return NULL;
- continue;
- }
+ /* We must handle EINTR here as there is no way for
+ * the caller to know how much was sent otherwise. */
+ if (errno == EINTR) {
+ /* Run signal handlers. If an exception was
+ * raised, abort and leave this socket in
+ * an unknown state. */
+ if (PyErr_CheckSignals())
+ return NULL;
+ continue;
+ }
#endif
- break;
- }
- buf += n;
- len -= n;
- } while (len > 0);
- Py_END_ALLOW_THREADS
- PyBuffer_Release(&pbuf);
+ break;
+ }
+ buf += n;
+ len -= n;
+ } while (len > 0);
+ Py_END_ALLOW_THREADS
+ PyBuffer_Release(&pbuf);
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return NULL;
- }
- if (n < 0)
- return s->errorhandler();
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return NULL;
+ }
+ if (n < 0)
+ return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(sendall_doc,
@@ -2623,47 +2623,47 @@
static PyObject *
sock_sendto(PySocketSockObject *s, PyObject *args)
{
- Py_buffer pbuf;
- PyObject *addro;
- char *buf;
- Py_ssize_t len;
- sock_addr_t addrbuf;
- int addrlen, n = -1, flags, timeout;
+ Py_buffer pbuf;
+ PyObject *addro;
+ char *buf;
+ Py_ssize_t len;
+ sock_addr_t addrbuf;
+ int addrlen, n = -1, flags, timeout;
- flags = 0;
- if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
- PyErr_Clear();
- if (!PyArg_ParseTuple(args, "y*iO:sendto",
- &pbuf, &flags, &addro))
- return NULL;
- }
- buf = pbuf.buf;
- len = pbuf.len;
+ flags = 0;
+ if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
+ PyErr_Clear();
+ if (!PyArg_ParseTuple(args, "y*iO:sendto",
+ &pbuf, &flags, &addro))
+ return NULL;
+ }
+ buf = pbuf.buf;
+ len = pbuf.len;
- if (!IS_SELECTABLE(s)) {
- PyBuffer_Release(&pbuf);
- return select_error();
- }
+ if (!IS_SELECTABLE(s)) {
+ PyBuffer_Release(&pbuf);
+ return select_error();
+ }
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
- PyBuffer_Release(&pbuf);
- return NULL;
- }
+ if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
+ PyBuffer_Release(&pbuf);
+ return NULL;
+ }
- Py_BEGIN_ALLOW_THREADS
- timeout = internal_select(s, 1);
- if (!timeout)
- n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
- Py_END_ALLOW_THREADS
+ Py_BEGIN_ALLOW_THREADS
+ timeout = internal_select(s, 1);
+ if (!timeout)
+ n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
+ Py_END_ALLOW_THREADS
- PyBuffer_Release(&pbuf);
- if (timeout == 1) {
- PyErr_SetString(socket_timeout, "timed out");
- return NULL;
- }
- if (n < 0)
- return s->errorhandler();
- return PyLong_FromLong((long)n);
+ PyBuffer_Release(&pbuf);
+ if (timeout == 1) {
+ PyErr_SetString(socket_timeout, "timed out");
+ return NULL;
+ }
+ if (n < 0)
+ return s->errorhandler();
+ return PyLong_FromLong((long)n);
}
PyDoc_STRVAR(sendto_doc,
@@ -2678,19 +2678,19 @@
static PyObject *
sock_shutdown(PySocketSockObject *s, PyObject *arg)
{
- int how;
- int res;
+ int how;
+ int res;
- how = PyLong_AsLong(arg);
- if (how == -1 && PyErr_Occurred())
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = shutdown(s->sock_fd, how);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return s->errorhandler();
- Py_INCREF(Py_None);
- return Py_None;
+ how = PyLong_AsLong(arg);
+ if (how == -1 && PyErr_Occurred())
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ res = shutdown(s->sock_fd, how);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return s->errorhandler();
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(shutdown_doc,
@@ -2703,37 +2703,37 @@
static PyObject*
sock_ioctl(PySocketSockObject *s, PyObject *arg)
{
- unsigned long cmd = SIO_RCVALL;
- PyObject *argO;
- DWORD recv;
+ unsigned long cmd = SIO_RCVALL;
+ PyObject *argO;
+ DWORD recv;
- if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
- return NULL;
+ if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
+ return NULL;
- switch (cmd) {
- case SIO_RCVALL: {
- unsigned int option = RCVALL_ON;
- if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
- return NULL;
- if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
- NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
- return set_error();
- }
- return PyLong_FromUnsignedLong(recv); }
- case SIO_KEEPALIVE_VALS: {
- struct tcp_keepalive ka;
- if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
- &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
- return NULL;
- if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
- NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
- return set_error();
- }
- return PyLong_FromUnsignedLong(recv); }
- default:
- PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
- return NULL;
- }
+ switch (cmd) {
+ case SIO_RCVALL: {
+ unsigned int option = RCVALL_ON;
+ if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
+ return NULL;
+ if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
+ NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
+ return set_error();
+ }
+ return PyLong_FromUnsignedLong(recv); }
+ case SIO_KEEPALIVE_VALS: {
+ struct tcp_keepalive ka;
+ if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
+ &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
+ return NULL;
+ if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
+ NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
+ return set_error();
+ }
+ return PyLong_FromUnsignedLong(recv); }
+ default:
+ PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
+ return NULL;
+ }
}
PyDoc_STRVAR(sock_ioctl_doc,
"ioctl(cmd, option) -> long\n\
@@ -2747,57 +2747,57 @@
/* List of methods for socket objects */
static PyMethodDef sock_methods[] = {
- {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
- accept_doc},
- {"bind", (PyCFunction)sock_bind, METH_O,
- bind_doc},
- {"close", (PyCFunction)sock_close, METH_NOARGS,
- close_doc},
- {"connect", (PyCFunction)sock_connect, METH_O,
- connect_doc},
- {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
- connect_ex_doc},
- {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
- fileno_doc},
+ {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
+ accept_doc},
+ {"bind", (PyCFunction)sock_bind, METH_O,
+ bind_doc},
+ {"close", (PyCFunction)sock_close, METH_NOARGS,
+ close_doc},
+ {"connect", (PyCFunction)sock_connect, METH_O,
+ connect_doc},
+ {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
+ connect_ex_doc},
+ {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
+ fileno_doc},
#ifdef HAVE_GETPEERNAME
- {"getpeername", (PyCFunction)sock_getpeername,
- METH_NOARGS, getpeername_doc},
+ {"getpeername", (PyCFunction)sock_getpeername,
+ METH_NOARGS, getpeername_doc},
#endif
- {"getsockname", (PyCFunction)sock_getsockname,
- METH_NOARGS, getsockname_doc},
- {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
- getsockopt_doc},
+ {"getsockname", (PyCFunction)sock_getsockname,
+ METH_NOARGS, getsockname_doc},
+ {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
+ getsockopt_doc},
#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
- {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
- sock_ioctl_doc},
+ {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
+ sock_ioctl_doc},
#endif
- {"listen", (PyCFunction)sock_listen, METH_O,
- listen_doc},
- {"recv", (PyCFunction)sock_recv, METH_VARARGS,
- recv_doc},
- {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
- recv_into_doc},
- {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
- recvfrom_doc},
- {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
- recvfrom_into_doc},
- {"send", (PyCFunction)sock_send, METH_VARARGS,
- send_doc},
- {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
- sendall_doc},
- {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
- sendto_doc},
- {"setblocking", (PyCFunction)sock_setblocking, METH_O,
- setblocking_doc},
- {"settimeout", (PyCFunction)sock_settimeout, METH_O,
- settimeout_doc},
- {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
- gettimeout_doc},
- {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
- setsockopt_doc},
- {"shutdown", (PyCFunction)sock_shutdown, METH_O,
- shutdown_doc},
- {NULL, NULL} /* sentinel */
+ {"listen", (PyCFunction)sock_listen, METH_O,
+ listen_doc},
+ {"recv", (PyCFunction)sock_recv, METH_VARARGS,
+ recv_doc},
+ {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
+ recv_into_doc},
+ {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
+ recvfrom_doc},
+ {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
+ recvfrom_into_doc},
+ {"send", (PyCFunction)sock_send, METH_VARARGS,
+ send_doc},
+ {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
+ sendall_doc},
+ {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
+ sendto_doc},
+ {"setblocking", (PyCFunction)sock_setblocking, METH_O,
+ setblocking_doc},
+ {"settimeout", (PyCFunction)sock_settimeout, METH_O,
+ settimeout_doc},
+ {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
+ gettimeout_doc},
+ {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
+ setsockopt_doc},
+ {"shutdown", (PyCFunction)sock_shutdown, METH_O,
+ shutdown_doc},
+ {NULL, NULL} /* sentinel */
};
/* SockObject members */
@@ -2815,9 +2815,9 @@
static void
sock_dealloc(PySocketSockObject *s)
{
- if (s->sock_fd != -1)
- (void) SOCKETCLOSE(s->sock_fd);
- Py_TYPE(s)->tp_free((PyObject *)s);
+ if (s->sock_fd != -1)
+ (void) SOCKETCLOSE(s->sock_fd);
+ Py_TYPE(s)->tp_free((PyObject *)s);
}
@@ -2825,21 +2825,21 @@
sock_repr(PySocketSockObject *s)
{
#if SIZEOF_SOCKET_T > SIZEOF_LONG
- if (s->sock_fd > LONG_MAX) {
- /* this can occur on Win64, and actually there is a special
- ugly printf formatter for decimal pointer length integer
- printing, only bother if necessary*/
- PyErr_SetString(PyExc_OverflowError,
- "no printf formatter to display "
- "the socket descriptor in decimal");
- return NULL;
- }
+ if (s->sock_fd > LONG_MAX) {
+ /* this can occur on Win64, and actually there is a special
+ ugly printf formatter for decimal pointer length integer
+ printing, only bother if necessary*/
+ PyErr_SetString(PyExc_OverflowError,
+ "no printf formatter to display "
+ "the socket descriptor in decimal");
+ return NULL;
+ }
#endif
- return PyUnicode_FromFormat(
- "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
- (long)s->sock_fd, s->sock_family,
- s->sock_type,
- s->sock_proto);
+ return PyUnicode_FromFormat(
+ "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
+ (long)s->sock_fd, s->sock_family,
+ s->sock_type,
+ s->sock_proto);
}
@@ -2848,15 +2848,15 @@
static PyObject *
sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *new;
+ PyObject *new;
- new = type->tp_alloc(type, 0);
- if (new != NULL) {
- ((PySocketSockObject *)new)->sock_fd = -1;
- ((PySocketSockObject *)new)->sock_timeout = -1.0;
- ((PySocketSockObject *)new)->errorhandler = &set_error;
- }
- return new;
+ new = type->tp_alloc(type, 0);
+ if (new != NULL) {
+ ((PySocketSockObject *)new)->sock_fd = -1;
+ ((PySocketSockObject *)new)->sock_timeout = -1.0;
+ ((PySocketSockObject *)new)->errorhandler = &set_error;
+ }
+ return new;
}
@@ -2866,40 +2866,40 @@
static int
sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
{
- PySocketSockObject *s = (PySocketSockObject *)self;
- PyObject *fdobj = NULL;
- SOCKET_T fd = INVALID_SOCKET;
- int family = AF_INET, type = SOCK_STREAM, proto = 0;
- static char *keywords[] = {"family", "type", "proto", "fileno", 0};
+ PySocketSockObject *s = (PySocketSockObject *)self;
+ PyObject *fdobj = NULL;
+ SOCKET_T fd = INVALID_SOCKET;
+ int family = AF_INET, type = SOCK_STREAM, proto = 0;
+ static char *keywords[] = {"family", "type", "proto", "fileno", 0};
- if (!PyArg_ParseTupleAndKeywords(args, kwds,
- "|iiiO:socket", keywords,
- &family, &type, &proto, &fdobj))
- return -1;
+ if (!PyArg_ParseTupleAndKeywords(args, kwds,
+ "|iiiO:socket", keywords,
+ &family, &type, &proto, &fdobj))
+ return -1;
- if (fdobj != NULL && fdobj != Py_None) {
- fd = PyLong_AsSocket_t(fdobj);
- if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
- return -1;
- if (fd == INVALID_SOCKET) {
- PyErr_SetString(PyExc_ValueError,
- "can't use invalid socket value");
- return -1;
- }
- }
- else {
- Py_BEGIN_ALLOW_THREADS
- fd = socket(family, type, proto);
- Py_END_ALLOW_THREADS
+ if (fdobj != NULL && fdobj != Py_None) {
+ fd = PyLong_AsSocket_t(fdobj);
+ if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
+ return -1;
+ if (fd == INVALID_SOCKET) {
+ PyErr_SetString(PyExc_ValueError,
+ "can't use invalid socket value");
+ return -1;
+ }
+ }
+ else {
+ Py_BEGIN_ALLOW_THREADS
+ fd = socket(family, type, proto);
+ Py_END_ALLOW_THREADS
- if (fd == INVALID_SOCKET) {
- set_error();
- return -1;
- }
- }
- init_sockobject(s, fd, family, type, proto);
+ if (fd == INVALID_SOCKET) {
+ set_error();
+ return -1;
+ }
+ }
+ init_sockobject(s, fd, family, type, proto);
- return 0;
+ return 0;
}
@@ -2907,45 +2907,45 @@
/* Type object for socket objects. */
static PyTypeObject sock_type = {
- PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
- "_socket.socket", /* tp_name */
- sizeof(PySocketSockObject), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor)sock_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_reserved */
- (reprfunc)sock_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- 0, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
- sock_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
- sock_methods, /* tp_methods */
- sock_memberlist, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- sock_initobj, /* tp_init */
- PyType_GenericAlloc, /* tp_alloc */
- sock_new, /* tp_new */
- PyObject_Del, /* tp_free */
+ PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
+ "_socket.socket", /* tp_name */
+ sizeof(PySocketSockObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)sock_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ (reprfunc)sock_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+ sock_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ sock_methods, /* tp_methods */
+ sock_memberlist, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ sock_initobj, /* tp_init */
+ PyType_GenericAlloc, /* tp_alloc */
+ sock_new, /* tp_new */
+ PyObject_Del, /* tp_free */
};
@@ -2955,15 +2955,15 @@
static PyObject *
socket_gethostname(PyObject *self, PyObject *unused)
{
- char buf[1024];
- int res;
- Py_BEGIN_ALLOW_THREADS
- res = gethostname(buf, (int) sizeof buf - 1);
- Py_END_ALLOW_THREADS
- if (res < 0)
- return set_error();
- buf[sizeof buf - 1] = '\0';
- return PyUnicode_FromString(buf);
+ char buf[1024];
+ int res;
+ Py_BEGIN_ALLOW_THREADS
+ res = gethostname(buf, (int) sizeof buf - 1);
+ Py_END_ALLOW_THREADS
+ if (res < 0)
+ return set_error();
+ buf[sizeof buf - 1] = '\0';
+ return PyUnicode_FromString(buf);
}
PyDoc_STRVAR(gethostname_doc,
@@ -2978,14 +2978,14 @@
static PyObject *
socket_gethostbyname(PyObject *self, PyObject *args)
{
- char *name;
- sock_addr_t addrbuf;
+ char *name;
+ sock_addr_t addrbuf;
- if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
- return NULL;
- if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
- return NULL;
- return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
+ if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
+ return NULL;
+ if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
+ return NULL;
+ return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
}
PyDoc_STRVAR(gethostbyname_doc,
@@ -2999,126 +2999,126 @@
static PyObject *
gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
{
- char **pch;
- PyObject *rtn_tuple = (PyObject *)NULL;
- PyObject *name_list = (PyObject *)NULL;
- PyObject *addr_list = (PyObject *)NULL;
- PyObject *tmp;
+ char **pch;
+ PyObject *rtn_tuple = (PyObject *)NULL;
+ PyObject *name_list = (PyObject *)NULL;
+ PyObject *addr_list = (PyObject *)NULL;
+ PyObject *tmp;
- if (h == NULL) {
- /* Let's get real error message to return */
- set_herror(h_errno);
- return NULL;
- }
+ if (h == NULL) {
+ /* Let's get real error message to return */
+ set_herror(h_errno);
+ return NULL;
+ }
- if (h->h_addrtype != af) {
- /* Let's get real error message to return */
- PyErr_SetString(socket_error,
- (char *)strerror(EAFNOSUPPORT));
+ if (h->h_addrtype != af) {
+ /* Let's get real error message to return */
+ PyErr_SetString(socket_error,
+ (char *)strerror(EAFNOSUPPORT));
- return NULL;
- }
+ return NULL;
+ }
- switch (af) {
+ switch (af) {
- case AF_INET:
- if (alen < sizeof(struct sockaddr_in))
- return NULL;
- break;
+ case AF_INET:
+ if (alen < sizeof(struct sockaddr_in))
+ return NULL;
+ break;
#ifdef ENABLE_IPV6
- case AF_INET6:
- if (alen < sizeof(struct sockaddr_in6))
- return NULL;
- break;
+ case AF_INET6:
+ if (alen < sizeof(struct sockaddr_in6))
+ return NULL;
+ break;
#endif
- }
+ }
- if ((name_list = PyList_New(0)) == NULL)
- goto err;
+ if ((name_list = PyList_New(0)) == NULL)
+ goto err;
- if ((addr_list = PyList_New(0)) == NULL)
- goto err;
+ if ((addr_list = PyList_New(0)) == NULL)
+ goto err;
- /* SF #1511317: h_aliases can be NULL */
- if (h->h_aliases) {
- for (pch = h->h_aliases; *pch != NULL; pch++) {
- int status;
- tmp = PyUnicode_FromString(*pch);
- if (tmp == NULL)
- goto err;
+ /* SF #1511317: h_aliases can be NULL */
+ if (h->h_aliases) {
+ for (pch = h->h_aliases; *pch != NULL; pch++) {
+ int status;
+ tmp = PyUnicode_FromString(*pch);
+ if (tmp == NULL)
+ goto err;
- status = PyList_Append(name_list, tmp);
- Py_DECREF(tmp);
+ status = PyList_Append(name_list, tmp);
+ Py_DECREF(tmp);
- if (status)
- goto err;
- }
- }
+ if (status)
+ goto err;
+ }
+ }
- for (pch = h->h_addr_list; *pch != NULL; pch++) {
- int status;
+ for (pch = h->h_addr_list; *pch != NULL; pch++) {
+ int status;
- switch (af) {
+ switch (af) {
- case AF_INET:
- {
- struct sockaddr_in sin;
- memset(&sin, 0, sizeof(sin));
- sin.sin_family = af;
+ case AF_INET:
+ {
+ struct sockaddr_in sin;
+ memset(&sin, 0, sizeof(sin));
+ sin.sin_family = af;
#ifdef HAVE_SOCKADDR_SA_LEN
- sin.sin_len = sizeof(sin);
+ sin.sin_len = sizeof(sin);
#endif
- memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
- tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
+ memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
+ tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
- if (pch == h->h_addr_list && alen >= sizeof(sin))
- memcpy((char *) addr, &sin, sizeof(sin));
- break;
- }
+ if (pch == h->h_addr_list && alen >= sizeof(sin))
+ memcpy((char *) addr, &sin, sizeof(sin));
+ break;
+ }
#ifdef ENABLE_IPV6
- case AF_INET6:
- {
- struct sockaddr_in6 sin6;
- memset(&sin6, 0, sizeof(sin6));
- sin6.sin6_family = af;
+ case AF_INET6:
+ {
+ struct sockaddr_in6 sin6;
+ memset(&sin6, 0, sizeof(sin6));
+ sin6.sin6_family = af;
#ifdef HAVE_SOCKADDR_SA_LEN
- sin6.sin6_len = sizeof(sin6);
+ sin6.sin6_len = sizeof(sin6);
#endif
- memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
- tmp = makeipaddr((struct sockaddr *)&sin6,
- sizeof(sin6));
+ memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
+ tmp = makeipaddr((struct sockaddr *)&sin6,
+ sizeof(sin6));
- if (pch == h->h_addr_list && alen >= sizeof(sin6))
- memcpy((char *) addr, &sin6, sizeof(sin6));
- break;
- }
+ if (pch == h->h_addr_list && alen >= sizeof(sin6))
+ memcpy((char *) addr, &sin6, sizeof(sin6));
+ break;
+ }
#endif
- default: /* can't happen */
- PyErr_SetString(socket_error,
- "unsupported address family");
- return NULL;
- }
+ default: /* can't happen */
+ PyErr_SetString(socket_error,
+ "unsupported address family");
+ return NULL;
+ }
- if (tmp == NULL)
- goto err;
+ if (tmp == NULL)
+ goto err;
- status = PyList_Append(addr_list, tmp);
- Py_DECREF(tmp);
+ status = PyList_Append(addr_list, tmp);
+ Py_DECREF(tmp);
- if (status)
- goto err;
- }
+ if (status)
+ goto err;
+ }
- rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
+ rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
err:
- Py_XDECREF(name_list);
- Py_XDECREF(addr_list);
- return rtn_tuple;
+ Py_XDECREF(name_list);
+ Py_XDECREF(addr_list);
+ return rtn_tuple;
}
@@ -3128,63 +3128,63 @@
static PyObject *
socket_gethostbyname_ex(PyObject *self, PyObject *args)
{
- char *name;
- struct hostent *h;
+ char *name;
+ struct hostent *h;
#ifdef ENABLE_IPV6
- struct sockaddr_storage addr;
+ struct sockaddr_storage addr;
#else
- struct sockaddr_in addr;
+ struct sockaddr_in addr;
#endif
- struct sockaddr *sa;
- PyObject *ret;
+ struct sockaddr *sa;
+ PyObject *ret;
#ifdef HAVE_GETHOSTBYNAME_R
- struct hostent hp_allocated;
+ struct hostent hp_allocated;
#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
- struct hostent_data data;
+ struct hostent_data data;
#else
- char buf[16384];
- int buf_len = (sizeof buf) - 1;
- int errnop;
+ char buf[16384];
+ int buf_len = (sizeof buf) - 1;
+ int errnop;
#endif
#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
- int result;
+ int result;
#endif
#endif /* HAVE_GETHOSTBYNAME_R */
- if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
- return NULL;
- if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
- return NULL;
- Py_BEGIN_ALLOW_THREADS
+ if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
+ return NULL;
+ if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
#ifdef HAVE_GETHOSTBYNAME_R
#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
- result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
- &h, &errnop);
+ result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
+ &h, &errnop);
#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
- h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
+ h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
- memset((void *) &data, '\0', sizeof(data));
- result = gethostbyname_r(name, &hp_allocated, &data);
- h = (result != 0) ? NULL : &hp_allocated;
+ memset((void *) &data, '\0', sizeof(data));
+ result = gethostbyname_r(name, &hp_allocated, &data);
+ h = (result != 0) ? NULL : &hp_allocated;
#endif
#else /* not HAVE_GETHOSTBYNAME_R */
#ifdef USE_GETHOSTBYNAME_LOCK
- PyThread_acquire_lock(netdb_lock, 1);
+ PyThread_acquire_lock(netdb_lock, 1);
#endif
- h = gethostbyname(name);
+ h = gethostbyname(name);
#endif /* HAVE_GETHOSTBYNAME_R */
- Py_END_ALLOW_THREADS
- /* Some C libraries would require addr.__ss_family instead of
- addr.ss_family.
- Therefore, we cast the sockaddr_storage into sockaddr to
- access sa_family. */
- sa = (struct sockaddr*)&addr;
- ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
- sa->sa_family);
+ Py_END_ALLOW_THREADS
+ /* Some C libraries would require addr.__ss_family instead of
+ addr.ss_family.
+ Therefore, we cast the sockaddr_storage into sockaddr to
+ access sa_family. */
+ sa = (struct sockaddr*)&addr;
+ ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
+ sa->sa_family);
#ifdef USE_GETHOSTBYNAME_LOCK
- PyThread_release_lock(netdb_lock);
+ PyThread_release_lock(netdb_lock);
#endif
- return ret;
+ return ret;
}
PyDoc_STRVAR(ghbn_ex_doc,
@@ -3201,84 +3201,84 @@
socket_gethostbyaddr(PyObject *self, PyObject *args)
{
#ifdef ENABLE_IPV6
- struct sockaddr_storage addr;
+ struct sockaddr_storage addr;
#else
- struct sockaddr_in addr;
+ struct sockaddr_in addr;
#endif
- struct sockaddr *sa = (struct sockaddr *)&addr;
- char *ip_num;
- struct hostent *h;
- PyObject *ret;
+ struct sockaddr *sa = (struct sockaddr *)&addr;
+ char *ip_num;
+ struct hostent *h;
+ PyObject *ret;
#ifdef HAVE_GETHOSTBYNAME_R
- struct hostent hp_allocated;
+ struct hostent hp_allocated;
#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
- struct hostent_data data;
+ struct hostent_data data;
#else
- /* glibcs up to 2.10 assume that the buf argument to
- gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
- does not ensure. The attribute below instructs the compiler
- to maintain this alignment. */
- char buf[16384] Py_ALIGNED(8);
- int buf_len = (sizeof buf) - 1;
- int errnop;
+ /* glibcs up to 2.10 assume that the buf argument to
+ gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
+ does not ensure. The attribute below instructs the compiler
+ to maintain this alignment. */
+ char buf[16384] Py_ALIGNED(8);
+ int buf_len = (sizeof buf) - 1;
+ int errnop;
#endif
#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
- int result;
+ int result;
#endif
#endif /* HAVE_GETHOSTBYNAME_R */
- char *ap;
- int al;
- int af;
+ char *ap;
+ int al;
+ int af;
- if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
- return NULL;
- af = AF_UNSPEC;
- if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
- return NULL;
- af = sa->sa_family;
- ap = NULL;
- al = 0;
- switch (af) {
- case AF_INET:
- ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
- al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
- break;
+ if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
+ return NULL;
+ af = AF_UNSPEC;
+ if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
+ return NULL;
+ af = sa->sa_family;
+ ap = NULL;
+ al = 0;
+ switch (af) {
+ case AF_INET:
+ ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
+ al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
+ break;
#ifdef ENABLE_IPV6
- case AF_INET6:
- ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
- al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
- break;
+ case AF_INET6:
+ ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
+ al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
+ break;
#endif
- default:
- PyErr_SetString(socket_error, "unsupported address family");
- return NULL;
- }
- Py_BEGIN_ALLOW_THREADS
+ default:
+ PyErr_SetString(socket_error, "unsupported address family");
+ return NULL;
+ }
+ Py_BEGIN_ALLOW_THREADS
#ifdef HAVE_GETHOSTBYNAME_R
#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
- result = gethostbyaddr_r(ap, al, af,
- &hp_allocated, buf, buf_len,
- &h, &errnop);
+ result = gethostbyaddr_r(ap, al, af,
+ &hp_allocated, buf, buf_len,
+ &h, &errnop);
#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
- h = gethostbyaddr_r(ap, al, af,
- &hp_allocated, buf, buf_len, &errnop);
+ h = gethostbyaddr_r(ap, al, af,
+ &hp_allocated, buf, buf_len, &errnop);
#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
- memset((void *) &data, '\0', sizeof(data));
- result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
- h = (result != 0) ? NULL : &hp_allocated;
+ memset((void *) &data, '\0', sizeof(data));
+ result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
+ h = (result != 0) ? NULL : &hp_allocated;
#endif
#else /* not HAVE_GETHOSTBYNAME_R */
#ifdef USE_GETHOSTBYNAME_LOCK
- PyThread_acquire_lock(netdb_lock, 1);
+ PyThread_acquire_lock(netdb_lock, 1);
#endif
- h = gethostbyaddr(ap, al, af);
+ h = gethostbyaddr(ap, al, af);
#endif /* HAVE_GETHOSTBYNAME_R */
- Py_END_ALLOW_THREADS
- ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
+ Py_END_ALLOW_THREADS
+ ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
#ifdef USE_GETHOSTBYNAME_LOCK
- PyThread_release_lock(netdb_lock);
+ PyThread_release_lock(netdb_lock);
#endif
- return ret;
+ return ret;
}
PyDoc_STRVAR(gethostbyaddr_doc,
@@ -3296,18 +3296,18 @@
static PyObject *
socket_getservbyname(PyObject *self, PyObject *args)
{
- char *name, *proto=NULL;
- struct servent *sp;
- if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- sp = getservbyname(name, proto);
- Py_END_ALLOW_THREADS
- if (sp == NULL) {
- PyErr_SetString(socket_error, "service/proto not found");
- return NULL;
- }
- return PyLong_FromLong((long) ntohs(sp->s_port));
+ char *name, *proto=NULL;
+ struct servent *sp;
+ if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ sp = getservbyname(name, proto);
+ Py_END_ALLOW_THREADS
+ if (sp == NULL) {
+ PyErr_SetString(socket_error, "service/proto not found");
+ return NULL;
+ }
+ return PyLong_FromLong((long) ntohs(sp->s_port));
}
PyDoc_STRVAR(getservbyname_doc,
@@ -3326,25 +3326,25 @@
static PyObject *
socket_getservbyport(PyObject *self, PyObject *args)
{
- int port;
- char *proto=NULL;
- struct servent *sp;
- if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
- return NULL;
- if (port < 0 || port > 0xffff) {
- PyErr_SetString(
- PyExc_OverflowError,
- "getservbyport: port must be 0-65535.");
- return NULL;
- }
- Py_BEGIN_ALLOW_THREADS
- sp = getservbyport(htons((short)port), proto);
- Py_END_ALLOW_THREADS
- if (sp == NULL) {
- PyErr_SetString(socket_error, "port/proto not found");
- return NULL;
- }
- return PyUnicode_FromString(sp->s_name);
+ int port;
+ char *proto=NULL;
+ struct servent *sp;
+ if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
+ return NULL;
+ if (port < 0 || port > 0xffff) {
+ PyErr_SetString(
+ PyExc_OverflowError,
+ "getservbyport: port must be 0-65535.");
+ return NULL;
+ }
+ Py_BEGIN_ALLOW_THREADS
+ sp = getservbyport(htons((short)port), proto);
+ Py_END_ALLOW_THREADS
+ if (sp == NULL) {
+ PyErr_SetString(socket_error, "port/proto not found");
+ return NULL;
+ }
+ return PyUnicode_FromString(sp->s_name);
}
PyDoc_STRVAR(getservbyport_doc,
@@ -3362,18 +3362,18 @@
static PyObject *
socket_getprotobyname(PyObject *self, PyObject *args)
{
- char *name;
- struct protoent *sp;
- if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- sp = getprotobyname(name);
- Py_END_ALLOW_THREADS
- if (sp == NULL) {
- PyErr_SetString(socket_error, "protocol not found");
- return NULL;
- }
- return PyLong_FromLong((long) sp->p_proto);
+ char *name;
+ struct protoent *sp;
+ if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
+ return NULL;
+ Py_BEGIN_ALLOW_THREADS
+ sp = getprotobyname(name);
+ Py_END_ALLOW_THREADS
+ if (sp == NULL) {
+ PyErr_SetString(socket_error, "protocol not found");
+ return NULL;
+ }
+ return PyLong_FromLong((long) sp->p_proto);
}
PyDoc_STRVAR(getprotobyname_doc,
@@ -3388,22 +3388,22 @@
static PyObject *
socket_dup(PyObject *self, PyObject *fdobj)
{
- SOCKET_T fd, newfd;
- PyObject *newfdobj;
+ SOCKET_T fd, newfd;
+ PyObject *newfdobj;
- fd = PyLong_AsSocket_t(fdobj);
- if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
- return NULL;
+ fd = PyLong_AsSocket_t(fdobj);
+ if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
+ return NULL;
- newfd = dup_socket(fd);
- if (newfd == INVALID_SOCKET)
- return set_error();
+ newfd = dup_socket(fd);
+ if (newfd == INVALID_SOCKET)
+ return set_error();
- newfdobj = PyLong_FromSocket_t(newfd);
- if (newfdobj == NULL)
- SOCKETCLOSE(newfd);
- return newfdobj;
+ newfdobj = PyLong_FromSocket_t(newfd);
+ if (newfdobj == NULL)
+ SOCKETCLOSE(newfd);
+ return newfdobj;
}
PyDoc_STRVAR(dup_doc,
@@ -3423,40 +3423,40 @@
static PyObject *
socket_socketpair(PyObject *self, PyObject *args)
{
- PySocketSockObject *s0 = NULL, *s1 = NULL;
- SOCKET_T sv[2];
- int family, type = SOCK_STREAM, proto = 0;
- PyObject *res = NULL;
+ PySocketSockObject *s0 = NULL, *s1 = NULL;
+ SOCKET_T sv[2];
+ int family, type = SOCK_STREAM, proto = 0;
+ PyObject *res = NULL;
#if defined(AF_UNIX)
- family = AF_UNIX;
+ family = AF_UNIX;
#else
- family = AF_INET;
+ family = AF_INET;
#endif
- if (!PyArg_ParseTuple(args, "|iii:socketpair",
- &family, &type, &proto))
- return NULL;
- /* Create a pair of socket fds */
- if (socketpair(family, type, proto, sv) < 0)
- return set_error();
- s0 = new_sockobject(sv[0], family, type, proto);
- if (s0 == NULL)
- goto finally;
- s1 = new_sockobject(sv[1], family, type, proto);
- if (s1 == NULL)
- goto finally;
- res = PyTuple_Pack(2, s0, s1);
+ if (!PyArg_ParseTuple(args, "|iii:socketpair",
+ &family, &type, &proto))
+ return NULL;
+ /* Create a pair of socket fds */
+ if (socketpair(family, type, proto, sv) < 0)
+ return set_error();
+ s0 = new_sockobject(sv[0], family, type, proto);
+ if (s0 == NULL)
+ goto finally;
+ s1 = new_sockobject(sv[1], family, type, proto);
+ if (s1 == NULL)
+ goto finally;
+ res = PyTuple_Pack(2, s0, s1);
finally:
- if (res == NULL) {
- if (s0 == NULL)
- SOCKETCLOSE(sv[0]);
- if (s1 == NULL)
- SOCKETCLOSE(sv[1]);
- }
- Py_XDECREF(s0);
- Py_XDECREF(s1);
- return res;
+ if (res == NULL) {
+ if (s0 == NULL)
+ SOCKETCLOSE(sv[0]);
+ if (s1 == NULL)
+ SOCKETCLOSE(sv[1]);
+ }
+ Py_XDECREF(s0);
+ Py_XDECREF(s1);
+ return res;
}
PyDoc_STRVAR(socketpair_doc,
@@ -3473,18 +3473,18 @@
static PyObject *
socket_ntohs(PyObject *self, PyObject *args)
{
- int x1, x2;
+ int x1, x2;
- if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
- return NULL;
- }
- if (x1 < 0) {
- PyErr_SetString(PyExc_OverflowError,
- "can't convert negative number to unsigned long");
- return NULL;
- }
- x2 = (unsigned int)ntohs((unsigned short)x1);
- return PyLong_FromLong(x2);
+ if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
+ return NULL;
+ }
+ if (x1 < 0) {
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative number to unsigned long");
+ return NULL;
+ }
+ x2 = (unsigned int)ntohs((unsigned short)x1);
+ return PyLong_FromLong(x2);
}
PyDoc_STRVAR(ntohs_doc,
@@ -3496,31 +3496,31 @@
static PyObject *
socket_ntohl(PyObject *self, PyObject *arg)
{
- unsigned long x;
+ unsigned long x;
- if (PyLong_Check(arg)) {
- x = PyLong_AsUnsignedLong(arg);
- if (x == (unsigned long) -1 && PyErr_Occurred())
- return NULL;
+ if (PyLong_Check(arg)) {
+ x = PyLong_AsUnsignedLong(arg);
+ if (x == (unsigned long) -1 && PyErr_Occurred())
+ return NULL;
#if SIZEOF_LONG > 4
- {
- unsigned long y;
- /* only want the trailing 32 bits */
- y = x & 0xFFFFFFFFUL;
- if (y ^ x)
- return PyErr_Format(PyExc_OverflowError,
- "long int larger than 32 bits");
- x = y;
- }
+ {
+ unsigned long y;
+ /* only want the trailing 32 bits */
+ y = x & 0xFFFFFFFFUL;
+ if (y ^ x)
+ return PyErr_Format(PyExc_OverflowError,
+ "long int larger than 32 bits");
+ x = y;
+ }
#endif
- }
- else
- return PyErr_Format(PyExc_TypeError,
- "expected int/long, %s found",
- Py_TYPE(arg)->tp_name);
- if (x == (unsigned long) -1 && PyErr_Occurred())
- return NULL;
- return PyLong_FromUnsignedLong(ntohl(x));
+ }
+ else
+ return PyErr_Format(PyExc_TypeError,
+ "expected int/long, %s found",
+ Py_TYPE(arg)->tp_name);
+ if (x == (unsigned long) -1 && PyErr_Occurred())
+ return NULL;
+ return PyLong_FromUnsignedLong(ntohl(x));
}
PyDoc_STRVAR(ntohl_doc,
@@ -3532,18 +3532,18 @@
static PyObject *
socket_htons(PyObject *self, PyObject *args)
{
- int x1, x2;
+ int x1, x2;
- if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
- return NULL;
- }
- if (x1 < 0) {
- PyErr_SetString(PyExc_OverflowError,
- "can't convert negative number to unsigned long");
- return NULL;
- }
- x2 = (unsigned int)htons((unsigned short)x1);
- return PyLong_FromLong(x2);
+ if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
+ return NULL;
+ }
+ if (x1 < 0) {
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative number to unsigned long");
+ return NULL;
+ }
+ x2 = (unsigned int)htons((unsigned short)x1);
+ return PyLong_FromLong(x2);
}
PyDoc_STRVAR(htons_doc,
@@ -3555,29 +3555,29 @@
static PyObject *
socket_htonl(PyObject *self, PyObject *arg)
{
- unsigned long x;
+ unsigned long x;
- if (PyLong_Check(arg)) {
- x = PyLong_AsUnsignedLong(arg);
- if (x == (unsigned long) -1 && PyErr_Occurred())
- return NULL;
+ if (PyLong_Check(arg)) {
+ x = PyLong_AsUnsignedLong(arg);
+ if (x == (unsigned long) -1 && PyErr_Occurred())
+ return NULL;
#if SIZEOF_LONG > 4
- {
- unsigned long y;
- /* only want the trailing 32 bits */
- y = x & 0xFFFFFFFFUL;
- if (y ^ x)
- return PyErr_Format(PyExc_OverflowError,
- "long int larger than 32 bits");
- x = y;
- }
+ {
+ unsigned long y;
+ /* only want the trailing 32 bits */
+ y = x & 0xFFFFFFFFUL;
+ if (y ^ x)
+ return PyErr_Format(PyExc_OverflowError,
+ "long int larger than 32 bits");
+ x = y;
+ }
#endif
- }
- else
- return PyErr_Format(PyExc_TypeError,
- "expected int/long, %s found",
- Py_TYPE(arg)->tp_name);
- return PyLong_FromUnsignedLong(htonl((unsigned long)x));
+ }
+ else
+ return PyErr_Format(PyExc_TypeError,
+ "expected int/long, %s found",
+ Py_TYPE(arg)->tp_name);
+ return PyLong_FromUnsignedLong(htonl((unsigned long)x));
}
PyDoc_STRVAR(htonl_doc,
@@ -3600,20 +3600,20 @@
#define INADDR_NONE (-1)
#endif
#ifdef HAVE_INET_ATON
- struct in_addr buf;
+ struct in_addr buf;
#endif
#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
#if (SIZEOF_INT != 4)
#error "Not sure if in_addr_t exists and int is not 32-bits."
#endif
- /* Have to use inet_addr() instead */
- unsigned int packed_addr;
+ /* Have to use inet_addr() instead */
+ unsigned int packed_addr;
#endif
- char *ip_addr;
+ char *ip_addr;
- if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
- return NULL;
+ if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
+ return NULL;
#ifdef HAVE_INET_ATON
@@ -3621,13 +3621,13 @@
#ifdef USE_INET_ATON_WEAKLINK
if (inet_aton != NULL) {
#endif
- if (inet_aton(ip_addr, &buf))
- return PyBytes_FromStringAndSize((char *)(&buf),
- sizeof(buf));
+ if (inet_aton(ip_addr, &buf))
+ return PyBytes_FromStringAndSize((char *)(&buf),
+ sizeof(buf));
- PyErr_SetString(socket_error,
- "illegal IP address string passed to inet_aton");
- return NULL;
+ PyErr_SetString(socket_error,
+ "illegal IP address string passed to inet_aton");
+ return NULL;
#ifdef USE_INET_ATON_WEAKLINK
} else {
@@ -3637,22 +3637,22 @@
#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
- /* special-case this address as inet_addr might return INADDR_NONE
- * for this */
- if (strcmp(ip_addr, "255.255.255.255") == 0) {
- packed_addr = 0xFFFFFFFF;
- } else {
+ /* special-case this address as inet_addr might return INADDR_NONE
+ * for this */
+ if (strcmp(ip_addr, "255.255.255.255") == 0) {
+ packed_addr = 0xFFFFFFFF;
+ } else {
- packed_addr = inet_addr(ip_addr);
+ packed_addr = inet_addr(ip_addr);
- if (packed_addr == INADDR_NONE) { /* invalid address */
- PyErr_SetString(socket_error,
- "illegal IP address string passed to inet_aton");
- return NULL;
- }
- }
- return PyBytes_FromStringAndSize((char *) &packed_addr,
- sizeof(packed_addr));
+ if (packed_addr == INADDR_NONE) { /* invalid address */
+ PyErr_SetString(socket_error,
+ "illegal IP address string passed to inet_aton");
+ return NULL;
+ }
+ }
+ return PyBytes_FromStringAndSize((char *) &packed_addr,
+ sizeof(packed_addr));
#ifdef USE_INET_ATON_WEAKLINK
}
@@ -3669,23 +3669,23 @@
static PyObject*
socket_inet_ntoa(PyObject *self, PyObject *args)
{
- char *packed_str;
- int addr_len;
- struct in_addr packed_addr;
+ char *packed_str;
+ int addr_len;
+ struct in_addr packed_addr;
- if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
- return NULL;
- }
+ if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
+ return NULL;
+ }
- if (addr_len != sizeof(packed_addr)) {
- PyErr_SetString(socket_error,
- "packed IP wrong length for inet_ntoa");
- return NULL;
- }
+ if (addr_len != sizeof(packed_addr)) {
+ PyErr_SetString(socket_error,
+ "packed IP wrong length for inet_ntoa");
+ return NULL;
+ }
- memcpy(&packed_addr, packed_str, addr_len);
+ memcpy(&packed_addr, packed_str, addr_len);
- return PyUnicode_FromString(inet_ntoa(packed_addr));
+ return PyUnicode_FromString(inet_ntoa(packed_addr));
}
#ifdef HAVE_INET_PTON
@@ -3699,46 +3699,46 @@
static PyObject *
socket_inet_pton(PyObject *self, PyObject *args)
{
- int af;
- char* ip;
- int retval;
+ int af;
+ char* ip;
+ int retval;
#ifdef ENABLE_IPV6
- char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
+ char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
#else
- char packed[sizeof(struct in_addr)];
+ char packed[sizeof(struct in_addr)];
#endif
- if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
- return NULL;
- }
+ if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
+ return NULL;
+ }
#if !defined(ENABLE_IPV6) && defined(AF_INET6)
- if(af == AF_INET6) {
- PyErr_SetString(socket_error,
- "can't use AF_INET6, IPv6 is disabled");
- return NULL;
- }
+ if(af == AF_INET6) {
+ PyErr_SetString(socket_error,
+ "can't use AF_INET6, IPv6 is disabled");
+ return NULL;
+ }
#endif
- retval = inet_pton(af, ip, packed);
- if (retval < 0) {
- PyErr_SetFromErrno(socket_error);
- return NULL;
- } else if (retval == 0) {
- PyErr_SetString(socket_error,
- "illegal IP address string passed to inet_pton");
- return NULL;
- } else if (af == AF_INET) {
- return PyBytes_FromStringAndSize(packed,
- sizeof(struct in_addr));
+ retval = inet_pton(af, ip, packed);
+ if (retval < 0) {
+ PyErr_SetFromErrno(socket_error);
+ return NULL;
+ } else if (retval == 0) {
+ PyErr_SetString(socket_error,
+ "illegal IP address string passed to inet_pton");
+ return NULL;
+ } else if (af == AF_INET) {
+ return PyBytes_FromStringAndSize(packed,
+ sizeof(struct in_addr));
#ifdef ENABLE_IPV6
- } else if (af == AF_INET6) {
- return PyBytes_FromStringAndSize(packed,
- sizeof(struct in6_addr));
+ } else if (af == AF_INET6) {
+ return PyBytes_FromStringAndSize(packed,
+ sizeof(struct in6_addr));
#endif
- } else {
- PyErr_SetString(socket_error, "unknown address family");
- return NULL;
- }
+ } else {
+ PyErr_SetString(socket_error, "unknown address family");
+ return NULL;
+ }
}
PyDoc_STRVAR(inet_ntop_doc,
@@ -3749,54 +3749,54 @@
static PyObject *
socket_inet_ntop(PyObject *self, PyObject *args)
{
- int af;
- char* packed;
- int len;
- const char* retval;
+ int af;
+ char* packed;
+ int len;
+ const char* retval;
#ifdef ENABLE_IPV6
- char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
+ char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
#else
- char ip[INET_ADDRSTRLEN + 1];
+ char ip[INET_ADDRSTRLEN + 1];
#endif
- /* Guarantee NUL-termination for PyUnicode_FromString() below */
- memset((void *) &ip[0], '\0', sizeof(ip));
+ /* Guarantee NUL-termination for PyUnicode_FromString() below */
+ memset((void *) &ip[0], '\0', sizeof(ip));
- if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
- return NULL;
- }
+ if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
+ return NULL;
+ }
- if (af == AF_INET) {
- if (len != sizeof(struct in_addr)) {
- PyErr_SetString(PyExc_ValueError,
- "invalid length of packed IP address string");
- return NULL;
- }
+ if (af == AF_INET) {
+ if (len != sizeof(struct in_addr)) {
+ PyErr_SetString(PyExc_ValueError,
+ "invalid length of packed IP address string");
+ return NULL;
+ }
#ifdef ENABLE_IPV6
- } else if (af == AF_INET6) {
- if (len != sizeof(struct in6_addr)) {
- PyErr_SetString(PyExc_ValueError,
- "invalid length of packed IP address string");
- return NULL;
- }
+ } else if (af == AF_INET6) {
+ if (len != sizeof(struct in6_addr)) {
+ PyErr_SetString(PyExc_ValueError,
+ "invalid length of packed IP address string");
+ return NULL;
+ }
#endif
- } else {
- PyErr_Format(PyExc_ValueError,
- "unknown address family %d", af);
- return NULL;
- }
+ } else {
+ PyErr_Format(PyExc_ValueError,
+ "unknown address family %d", af);
+ return NULL;
+ }
- retval = inet_ntop(af, packed, ip, sizeof(ip));
- if (!retval) {
- PyErr_SetFromErrno(socket_error);
- return NULL;
- } else {
- return PyUnicode_FromString(retval);
- }
+ retval = inet_ntop(af, packed, ip, sizeof(ip));
+ if (!retval) {
+ PyErr_SetFromErrno(socket_error);
+ return NULL;
+ } else {
+ return PyUnicode_FromString(retval);
+ }
- /* NOTREACHED */
- PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
- return NULL;
+ /* NOTREACHED */
+ PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
+ return NULL;
}
#endif /* HAVE_INET_PTON */
@@ -3807,100 +3807,100 @@
static PyObject *
socket_getaddrinfo(PyObject *self, PyObject *args)
{
- struct addrinfo hints, *res;
- struct addrinfo *res0 = NULL;
- PyObject *hobj = NULL;
- PyObject *pobj = (PyObject *)NULL;
- char pbuf[30];
- char *hptr, *pptr;
- int family, socktype, protocol, flags;
- int error;
- PyObject *all = (PyObject *)NULL;
- PyObject *idna = NULL;
+ struct addrinfo hints, *res;
+ struct addrinfo *res0 = NULL;
+ PyObject *hobj = NULL;
+ PyObject *pobj = (PyObject *)NULL;
+ char pbuf[30];
+ char *hptr, *pptr;
+ int family, socktype, protocol, flags;
+ int error;
+ PyObject *all = (PyObject *)NULL;
+ PyObject *idna = NULL;
- family = socktype = protocol = flags = 0;
- family = AF_UNSPEC;
- if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
- &hobj, &pobj, &family, &socktype,
- &protocol, &flags)) {
- return NULL;
- }
- if (hobj == Py_None) {
- hptr = NULL;
- } else if (PyUnicode_Check(hobj)) {
- idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
- if (!idna)
- return NULL;
- assert(PyBytes_Check(idna));
- hptr = PyBytes_AS_STRING(idna);
- } else if (PyBytes_Check(hobj)) {
- hptr = PyBytes_AsString(hobj);
- } else {
- PyErr_SetString(PyExc_TypeError,
- "getaddrinfo() argument 1 must be string or None");
- return NULL;
- }
- if (PyLong_CheckExact(pobj)) {
- long value = PyLong_AsLong(pobj);
- if (value == -1 && PyErr_Occurred())
- goto err;
- PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
- pptr = pbuf;
- } else if (PyUnicode_Check(pobj)) {
- pptr = _PyUnicode_AsString(pobj);
- } else if (PyBytes_Check(pobj)) {
- pptr = PyBytes_AsString(pobj);
- } else if (pobj == Py_None) {
- pptr = (char *)NULL;
- } else {
- PyErr_SetString(socket_error, "Int or String expected");
- goto err;
- }
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = family;
- hints.ai_socktype = socktype;
- hints.ai_protocol = protocol;
- hints.ai_flags = flags;
- Py_BEGIN_ALLOW_THREADS
- ACQUIRE_GETADDRINFO_LOCK
- error = getaddrinfo(hptr, pptr, &hints, &res0);
- Py_END_ALLOW_THREADS
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
- if (error) {
- set_gaierror(error);
- goto err;
- }
+ family = socktype = protocol = flags = 0;
+ family = AF_UNSPEC;
+ if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
+ &hobj, &pobj, &family, &socktype,
+ &protocol, &flags)) {
+ return NULL;
+ }
+ if (hobj == Py_None) {
+ hptr = NULL;
+ } else if (PyUnicode_Check(hobj)) {
+ idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
+ if (!idna)
+ return NULL;
+ assert(PyBytes_Check(idna));
+ hptr = PyBytes_AS_STRING(idna);
+ } else if (PyBytes_Check(hobj)) {
+ hptr = PyBytes_AsString(hobj);
+ } else {
+ PyErr_SetString(PyExc_TypeError,
+ "getaddrinfo() argument 1 must be string or None");
+ return NULL;
+ }
+ if (PyLong_CheckExact(pobj)) {
+ long value = PyLong_AsLong(pobj);
+ if (value == -1 && PyErr_Occurred())
+ goto err;
+ PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
+ pptr = pbuf;
+ } else if (PyUnicode_Check(pobj)) {
+ pptr = _PyUnicode_AsString(pobj);
+ } else if (PyBytes_Check(pobj)) {
+ pptr = PyBytes_AsString(pobj);
+ } else if (pobj == Py_None) {
+ pptr = (char *)NULL;
+ } else {
+ PyErr_SetString(socket_error, "Int or String expected");
+ goto err;
+ }
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = family;
+ hints.ai_socktype = socktype;
+ hints.ai_protocol = protocol;
+ hints.ai_flags = flags;
+ Py_BEGIN_ALLOW_THREADS
+ ACQUIRE_GETADDRINFO_LOCK
+ error = getaddrinfo(hptr, pptr, &hints, &res0);
+ Py_END_ALLOW_THREADS
+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
+ if (error) {
+ set_gaierror(error);
+ goto err;
+ }
- if ((all = PyList_New(0)) == NULL)
- goto err;
- for (res = res0; res; res = res->ai_next) {
- PyObject *single;
- PyObject *addr =
- makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
- if (addr == NULL)
- goto err;
- single = Py_BuildValue("iiisO", res->ai_family,
- res->ai_socktype, res->ai_protocol,
- res->ai_canonname ? res->ai_canonname : "",
- addr);
- Py_DECREF(addr);
- if (single == NULL)
- goto err;
+ if ((all = PyList_New(0)) == NULL)
+ goto err;
+ for (res = res0; res; res = res->ai_next) {
+ PyObject *single;
+ PyObject *addr =
+ makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
+ if (addr == NULL)
+ goto err;
+ single = Py_BuildValue("iiisO", res->ai_family,
+ res->ai_socktype, res->ai_protocol,
+ res->ai_canonname ? res->ai_canonname : "",
+ addr);
+ Py_DECREF(addr);
+ if (single == NULL)
+ goto err;
- if (PyList_Append(all, single))
- goto err;
- Py_XDECREF(single);
- }
- Py_XDECREF(idna);
- if (res0)
- freeaddrinfo(res0);
- return all;
+ if (PyList_Append(all, single))
+ goto err;
+ Py_XDECREF(single);
+ }
+ Py_XDECREF(idna);
+ if (res0)
+ freeaddrinfo(res0);
+ return all;
err:
- Py_XDECREF(all);
- Py_XDECREF(idna);
- if (res0)
- freeaddrinfo(res0);
- return (PyObject *)NULL;
+ Py_XDECREF(all);
+ Py_XDECREF(idna);
+ if (res0)
+ freeaddrinfo(res0);
+ return (PyObject *)NULL;
}
PyDoc_STRVAR(getaddrinfo_doc,
@@ -3915,77 +3915,77 @@
static PyObject *
socket_getnameinfo(PyObject *self, PyObject *args)
{
- PyObject *sa = (PyObject *)NULL;
- int flags;
- char *hostp;
- int port, flowinfo, scope_id;
- char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
- struct addrinfo hints, *res = NULL;
- int error;
- PyObject *ret = (PyObject *)NULL;
+ PyObject *sa = (PyObject *)NULL;
+ int flags;
+ char *hostp;
+ int port, flowinfo, scope_id;
+ char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
+ struct addrinfo hints, *res = NULL;
+ int error;
+ PyObject *ret = (PyObject *)NULL;
- flags = flowinfo = scope_id = 0;
- if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
- return NULL;
- if (!PyTuple_Check(sa)) {
- PyErr_SetString(PyExc_TypeError,
- "getnameinfo() argument 1 must be a tuple");
- return NULL;
- }
- if (!PyArg_ParseTuple(sa, "si|ii",
- &hostp, &port, &flowinfo, &scope_id))
- return NULL;
- PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
- memset(&hints, 0, sizeof(hints));
- hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
- Py_BEGIN_ALLOW_THREADS
- ACQUIRE_GETADDRINFO_LOCK
- error = getaddrinfo(hostp, pbuf, &hints, &res);
- Py_END_ALLOW_THREADS
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
- if (error) {
- set_gaierror(error);
- goto fail;
- }
- if (res->ai_next) {
- PyErr_SetString(socket_error,
- "sockaddr resolved to multiple addresses");
- goto fail;
- }
- switch (res->ai_family) {
- case AF_INET:
- {
- if (PyTuple_GET_SIZE(sa) != 2) {
- PyErr_SetString(socket_error,
- "IPv4 sockaddr must be 2 tuple");
- goto fail;
- }
- break;
- }
+ flags = flowinfo = scope_id = 0;
+ if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
+ return NULL;
+ if (!PyTuple_Check(sa)) {
+ PyErr_SetString(PyExc_TypeError,
+ "getnameinfo() argument 1 must be a tuple");
+ return NULL;
+ }
+ if (!PyArg_ParseTuple(sa, "si|ii",
+ &hostp, &port, &flowinfo, &scope_id))
+ return NULL;
+ PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
+ Py_BEGIN_ALLOW_THREADS
+ ACQUIRE_GETADDRINFO_LOCK
+ error = getaddrinfo(hostp, pbuf, &hints, &res);
+ Py_END_ALLOW_THREADS
+ RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
+ if (error) {
+ set_gaierror(error);
+ goto fail;
+ }
+ if (res->ai_next) {
+ PyErr_SetString(socket_error,
+ "sockaddr resolved to multiple addresses");
+ goto fail;
+ }
+ switch (res->ai_family) {
+ case AF_INET:
+ {
+ if (PyTuple_GET_SIZE(sa) != 2) {
+ PyErr_SetString(socket_error,
+ "IPv4 sockaddr must be 2 tuple");
+ goto fail;
+ }
+ break;
+ }
#ifdef ENABLE_IPV6
- case AF_INET6:
- {
- struct sockaddr_in6 *sin6;
- sin6 = (struct sockaddr_in6 *)res->ai_addr;
- sin6->sin6_flowinfo = flowinfo;
- sin6->sin6_scope_id = scope_id;
- break;
- }
+ case AF_INET6:
+ {
+ struct sockaddr_in6 *sin6;
+ sin6 = (struct sockaddr_in6 *)res->ai_addr;
+ sin6->sin6_flowinfo = flowinfo;
+ sin6->sin6_scope_id = scope_id;
+ break;
+ }
#endif
- }
- error = getnameinfo(res->ai_addr, res->ai_addrlen,
- hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
- if (error) {
- set_gaierror(error);
- goto fail;
- }
- ret = Py_BuildValue("ss", hbuf, pbuf);
+ }
+ error = getnameinfo(res->ai_addr, res->ai_addrlen,
+ hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
+ if (error) {
+ set_gaierror(error);
+ goto fail;
+ }
+ ret = Py_BuildValue("ss", hbuf, pbuf);
fail:
- if (res)
- freeaddrinfo(res);
- return ret;
+ if (res)
+ freeaddrinfo(res);
+ return ret;
}
PyDoc_STRVAR(getnameinfo_doc,
@@ -3999,12 +3999,12 @@
static PyObject *
socket_getdefaulttimeout(PyObject *self)
{
- if (defaulttimeout < 0.0) {
- Py_INCREF(Py_None);
- return Py_None;
- }
- else
- return PyFloat_FromDouble(defaulttimeout);
+ if (defaulttimeout < 0.0) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ else
+ return PyFloat_FromDouble(defaulttimeout);
}
PyDoc_STRVAR(getdefaulttimeout_doc,
@@ -4017,24 +4017,24 @@
static PyObject *
socket_setdefaulttimeout(PyObject *self, PyObject *arg)
{
- double timeout;
+ double timeout;
- if (arg == Py_None)
- timeout = -1.0;
- else {
- timeout = PyFloat_AsDouble(arg);
- if (timeout < 0.0) {
- if (!PyErr_Occurred())
- PyErr_SetString(PyExc_ValueError,
- "Timeout value out of range");
- return NULL;
- }
- }
+ if (arg == Py_None)
+ timeout = -1.0;
+ else {
+ timeout = PyFloat_AsDouble(arg);
+ if (timeout < 0.0) {
+ if (!PyErr_Occurred())
+ PyErr_SetString(PyExc_ValueError,
+ "Timeout value out of range");
+ return NULL;
+ }
+ }
- defaulttimeout = timeout;
+ defaulttimeout = timeout;
- Py_INCREF(Py_None);
- return Py_None;
+ Py_INCREF(Py_None);
+ return Py_None;
}
PyDoc_STRVAR(setdefaulttimeout_doc,
@@ -4048,55 +4048,55 @@
/* List of functions exported by this module. */
static PyMethodDef socket_methods[] = {
- {"gethostbyname", socket_gethostbyname,
- METH_VARARGS, gethostbyname_doc},
- {"gethostbyname_ex", socket_gethostbyname_ex,
- METH_VARARGS, ghbn_ex_doc},
- {"gethostbyaddr", socket_gethostbyaddr,
- METH_VARARGS, gethostbyaddr_doc},
- {"gethostname", socket_gethostname,
- METH_NOARGS, gethostname_doc},
- {"getservbyname", socket_getservbyname,
- METH_VARARGS, getservbyname_doc},
- {"getservbyport", socket_getservbyport,
- METH_VARARGS, getservbyport_doc},
- {"getprotobyname", socket_getprotobyname,
- METH_VARARGS, getprotobyname_doc},
+ {"gethostbyname", socket_gethostbyname,
+ METH_VARARGS, gethostbyname_doc},
+ {"gethostbyname_ex", socket_gethostbyname_ex,
+ METH_VARARGS, ghbn_ex_doc},
+ {"gethostbyaddr", socket_gethostbyaddr,
+ METH_VARARGS, gethostbyaddr_doc},
+ {"gethostname", socket_gethostname,
+ METH_NOARGS, gethostname_doc},
+ {"getservbyname", socket_getservbyname,
+ METH_VARARGS, getservbyname_doc},
+ {"getservbyport", socket_getservbyport,
+ METH_VARARGS, getservbyport_doc},
+ {"getprotobyname", socket_getprotobyname,
+ METH_VARARGS, getprotobyname_doc},
#ifndef NO_DUP
- {"dup", socket_dup,
- METH_O, dup_doc},
+ {"dup", socket_dup,
+ METH_O, dup_doc},
#endif
#ifdef HAVE_SOCKETPAIR
- {"socketpair", socket_socketpair,
- METH_VARARGS, socketpair_doc},
+ {"socketpair", socket_socketpair,
+ METH_VARARGS, socketpair_doc},
#endif
- {"ntohs", socket_ntohs,
- METH_VARARGS, ntohs_doc},
- {"ntohl", socket_ntohl,
- METH_O, ntohl_doc},
- {"htons", socket_htons,
- METH_VARARGS, htons_doc},
- {"htonl", socket_htonl,
- METH_O, htonl_doc},
- {"inet_aton", socket_inet_aton,
- METH_VARARGS, inet_aton_doc},
- {"inet_ntoa", socket_inet_ntoa,
- METH_VARARGS, inet_ntoa_doc},
+ {"ntohs", socket_ntohs,
+ METH_VARARGS, ntohs_doc},
+ {"ntohl", socket_ntohl,
+ METH_O, ntohl_doc},
+ {"htons", socket_htons,
+ METH_VARARGS, htons_doc},
+ {"htonl", socket_htonl,
+ METH_O, htonl_doc},
+ {"inet_aton", socket_inet_aton,
+ METH_VARARGS, inet_aton_doc},
+ {"inet_ntoa", socket_inet_ntoa,
+ METH_VARARGS, inet_ntoa_doc},
#ifdef HAVE_INET_PTON
- {"inet_pton", socket_inet_pton,
- METH_VARARGS, inet_pton_doc},
- {"inet_ntop", socket_inet_ntop,
- METH_VARARGS, inet_ntop_doc},
+ {"inet_pton", socket_inet_pton,
+ METH_VARARGS, inet_pton_doc},
+ {"inet_ntop", socket_inet_ntop,
+ METH_VARARGS, inet_ntop_doc},
#endif
- {"getaddrinfo", socket_getaddrinfo,
- METH_VARARGS, getaddrinfo_doc},
- {"getnameinfo", socket_getnameinfo,
- METH_VARARGS, getnameinfo_doc},
- {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
- METH_NOARGS, getdefaulttimeout_doc},
- {"setdefaulttimeout", socket_setdefaulttimeout,
- METH_O, setdefaulttimeout_doc},
- {NULL, NULL} /* Sentinel */
+ {"getaddrinfo", socket_getaddrinfo,
+ METH_VARARGS, getaddrinfo_doc},
+ {"getnameinfo", socket_getnameinfo,
+ METH_VARARGS, getnameinfo_doc},
+ {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
+ METH_NOARGS, getdefaulttimeout_doc},
+ {"setdefaulttimeout", socket_setdefaulttimeout,
+ METH_O, setdefaulttimeout_doc},
+ {NULL, NULL} /* Sentinel */
};
@@ -4108,34 +4108,34 @@
static void
os_cleanup(void)
{
- WSACleanup();
+ WSACleanup();
}
static int
os_init(void)
{
- WSADATA WSAData;
- int ret;
- ret = WSAStartup(0x0101, &WSAData);
- switch (ret) {
- case 0: /* No error */
- Py_AtExit(os_cleanup);
- return 1; /* Success */
- case WSASYSNOTREADY:
- PyErr_SetString(PyExc_ImportError,
- "WSAStartup failed: network not ready");
- break;
- case WSAVERNOTSUPPORTED:
- case WSAEINVAL:
- PyErr_SetString(
- PyExc_ImportError,
- "WSAStartup failed: requested version not supported");
- break;
- default:
- PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
- break;
- }
- return 0; /* Failure */
+ WSADATA WSAData;
+ int ret;
+ ret = WSAStartup(0x0101, &WSAData);
+ switch (ret) {
+ case 0: /* No error */
+ Py_AtExit(os_cleanup);
+ return 1; /* Success */
+ case WSASYSNOTREADY:
+ PyErr_SetString(PyExc_ImportError,
+ "WSAStartup failed: network not ready");
+ break;
+ case WSAVERNOTSUPPORTED:
+ case WSAEINVAL:
+ PyErr_SetString(
+ PyExc_ImportError,
+ "WSAStartup failed: requested version not supported");
+ break;
+ default:
+ PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
+ break;
+ }
+ return 0; /* Failure */
}
#endif /* MS_WINDOWS */
@@ -4150,18 +4150,18 @@
os_init(void)
{
#ifndef PYCC_GCC
- int rc = sock_init();
+ int rc = sock_init();
- if (rc == 0) {
- return 1; /* Success */
- }
+ if (rc == 0) {
+ return 1; /* Success */
+ }
- PyErr_Format(PyExc_ImportError, "OS/2 TCP/IP Error# %d", sock_errno());
+ PyErr_Format(PyExc_ImportError, "OS/2 TCP/IP Error# %d", sock_errno());
- return 0; /* Failure */
+ return 0; /* Failure */
#else
- /* No need to initialise sockets with GCC/EMX */
- return 1; /* Success */
+ /* No need to initialise sockets with GCC/EMX */
+ return 1; /* Success */
#endif
}
@@ -4172,7 +4172,7 @@
static int
os_init(void)
{
- return 1; /* Success */
+ return 1; /* Success */
}
#endif
@@ -4182,8 +4182,8 @@
static
PySocketModule_APIObject PySocketModuleAPI =
{
- &sock_type,
- NULL
+ &sock_type,
+ NULL
};
@@ -4203,931 +4203,931 @@
See the socket module for documentation.");
static struct PyModuleDef socketmodule = {
- PyModuleDef_HEAD_INIT,
- PySocket_MODULE_NAME,
- socket_doc,
- -1,
- socket_methods,
- NULL,
- NULL,
- NULL,
- NULL
+ PyModuleDef_HEAD_INIT,
+ PySocket_MODULE_NAME,
+ socket_doc,
+ -1,
+ socket_methods,
+ NULL,
+ NULL,
+ NULL,
+ NULL
};
PyMODINIT_FUNC
PyInit__socket(void)
{
- PyObject *m, *has_ipv6;
+ PyObject *m, *has_ipv6;
- if (!os_init())
- return NULL;
+ if (!os_init())
+ return NULL;
- Py_TYPE(&sock_type) = &PyType_Type;
- m = PyModule_Create(&socketmodule);
- if (m == NULL)
- return NULL;
+ Py_TYPE(&sock_type) = &PyType_Type;
+ m = PyModule_Create(&socketmodule);
+ if (m == NULL)
+ return NULL;
- socket_error = PyErr_NewException("socket.error",
- PyExc_IOError, NULL);
- if (socket_error == NULL)
- return NULL;
- PySocketModuleAPI.error = socket_error;
- Py_INCREF(socket_error);
- PyModule_AddObject(m, "error", socket_error);
- socket_herror = PyErr_NewException("socket.herror",
- socket_error, NULL);
- if (socket_herror == NULL)
- return NULL;
- Py_INCREF(socket_herror);
- PyModule_AddObject(m, "herror", socket_herror);
- socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
- NULL);
- if (socket_gaierror == NULL)
- return NULL;
- Py_INCREF(socket_gaierror);
- PyModule_AddObject(m, "gaierror", socket_gaierror);
- socket_timeout = PyErr_NewException("socket.timeout",
- socket_error, NULL);
- if (socket_timeout == NULL)
- return NULL;
- Py_INCREF(socket_timeout);
- PyModule_AddObject(m, "timeout", socket_timeout);
- Py_INCREF((PyObject *)&sock_type);
- if (PyModule_AddObject(m, "SocketType",
- (PyObject *)&sock_type) != 0)
- return NULL;
- Py_INCREF((PyObject *)&sock_type);
- if (PyModule_AddObject(m, "socket",
- (PyObject *)&sock_type) != 0)
- return NULL;
+ socket_error = PyErr_NewException("socket.error",
+ PyExc_IOError, NULL);
+ if (socket_error == NULL)
+ return NULL;
+ PySocketModuleAPI.error = socket_error;
+ Py_INCREF(socket_error);
+ PyModule_AddObject(m, "error", socket_error);
+ socket_herror = PyErr_NewException("socket.herror",
+ socket_error, NULL);
+ if (socket_herror == NULL)
+ return NULL;
+ Py_INCREF(socket_herror);
+ PyModule_AddObject(m, "herror", socket_herror);
+ socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
+ NULL);
+ if (socket_gaierror == NULL)
+ return NULL;
+ Py_INCREF(socket_gaierror);
+ PyModule_AddObject(m, "gaierror", socket_gaierror);
+ socket_timeout = PyErr_NewException("socket.timeout",
+ socket_error, NULL);
+ if (socket_timeout == NULL)
+ return NULL;
+ Py_INCREF(socket_timeout);
+ PyModule_AddObject(m, "timeout", socket_timeout);
+ Py_INCREF((PyObject *)&sock_type);
+ if (PyModule_AddObject(m, "SocketType",
+ (PyObject *)&sock_type) != 0)
+ return NULL;
+ Py_INCREF((PyObject *)&sock_type);
+ if (PyModule_AddObject(m, "socket",
+ (PyObject *)&sock_type) != 0)
+ return NULL;
#ifdef ENABLE_IPV6
- has_ipv6 = Py_True;
+ has_ipv6 = Py_True;
#else
- has_ipv6 = Py_False;
+ has_ipv6 = Py_False;
#endif
- Py_INCREF(has_ipv6);
- PyModule_AddObject(m, "has_ipv6", has_ipv6);
+ Py_INCREF(has_ipv6);
+ PyModule_AddObject(m, "has_ipv6", has_ipv6);
- /* Export C API */
- if (PyModule_AddObject(m, PySocket_CAPI_NAME,
- PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
- ) != 0)
- return NULL;
+ /* Export C API */
+ if (PyModule_AddObject(m, PySocket_CAPI_NAME,
+ PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
+ ) != 0)
+ return NULL;
- /* Address families (we only support AF_INET and AF_UNIX) */
+ /* Address families (we only support AF_INET and AF_UNIX) */
#ifdef AF_UNSPEC
- PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
+ PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
#endif
- PyModule_AddIntConstant(m, "AF_INET", AF_INET);
+ PyModule_AddIntConstant(m, "AF_INET", AF_INET);
#ifdef AF_INET6
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
+ PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
#endif /* AF_INET6 */
#if defined(AF_UNIX)
- PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
+ PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
#endif /* AF_UNIX */
#ifdef AF_AX25
- /* Amateur Radio AX.25 */
- PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
+ /* Amateur Radio AX.25 */
+ PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
#endif
#ifdef AF_IPX
- PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
+ PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
#endif
#ifdef AF_APPLETALK
- /* Appletalk DDP */
- PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
+ /* Appletalk DDP */
+ PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
#endif
#ifdef AF_NETROM
- /* Amateur radio NetROM */
- PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
+ /* Amateur radio NetROM */
+ PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
#endif
#ifdef AF_BRIDGE
- /* Multiprotocol bridge */
- PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
+ /* Multiprotocol bridge */
+ PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
#endif
#ifdef AF_ATMPVC
- /* ATM PVCs */
- PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
+ /* ATM PVCs */
+ PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
#endif
#ifdef AF_AAL5
- /* Reserved for Werner's ATM */
- PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
+ /* Reserved for Werner's ATM */
+ PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
#endif
#ifdef AF_X25
- /* Reserved for X.25 project */
- PyModule_AddIntConstant(m, "AF_X25", AF_X25);
+ /* Reserved for X.25 project */
+ PyModule_AddIntConstant(m, "AF_X25", AF_X25);
#endif
#ifdef AF_INET6
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
+ PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
#endif
#ifdef AF_ROSE
- /* Amateur Radio X.25 PLP */
- PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
+ /* Amateur Radio X.25 PLP */
+ PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
#endif
#ifdef AF_DECnet
- /* Reserved for DECnet project */
- PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
+ /* Reserved for DECnet project */
+ PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
#endif
#ifdef AF_NETBEUI
- /* Reserved for 802.2LLC project */
- PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
+ /* Reserved for 802.2LLC project */
+ PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
#endif
#ifdef AF_SECURITY
- /* Security callback pseudo AF */
- PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
+ /* Security callback pseudo AF */
+ PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
#endif
#ifdef AF_KEY
- /* PF_KEY key management API */
- PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
+ /* PF_KEY key management API */
+ PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
#endif
#ifdef AF_NETLINK
- /* */
- PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
- PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
+ /* */
+ PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
+ PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
#ifdef NETLINK_SKIP
- PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
+ PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
#endif
#ifdef NETLINK_W1
- PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
+ PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
#endif
- PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
- PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
+ PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
+ PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
#ifdef NETLINK_TCPDIAG
- PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
+ PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
#endif
#ifdef NETLINK_NFLOG
- PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
+ PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
#endif
#ifdef NETLINK_XFRM
- PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
+ PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
#endif
#ifdef NETLINK_ARPD
- PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
+ PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
#endif
#ifdef NETLINK_ROUTE6
- PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
+ PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
#endif
- PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
+ PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
#ifdef NETLINK_DNRTMSG
- PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
+ PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
#endif
#ifdef NETLINK_TAPBASE
- PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
+ PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
#endif
#endif /* AF_NETLINK */
#ifdef AF_ROUTE
- /* Alias to emulate 4.4BSD */
- PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
+ /* Alias to emulate 4.4BSD */
+ PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
#endif
#ifdef AF_ASH
- /* Ash */
- PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
+ /* Ash */
+ PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
#endif
#ifdef AF_ECONET
- /* Acorn Econet */
- PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
+ /* Acorn Econet */
+ PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
#endif
#ifdef AF_ATMSVC
- /* ATM SVCs */
- PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
+ /* ATM SVCs */
+ PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
#endif
#ifdef AF_SNA
- /* Linux SNA Project (nutters!) */
- PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
+ /* Linux SNA Project (nutters!) */
+ PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
#endif
#ifdef AF_IRDA
- /* IRDA sockets */
- PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
+ /* IRDA sockets */
+ PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
#endif
#ifdef AF_PPPOX
- /* PPPoX sockets */
- PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
+ /* PPPoX sockets */
+ PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
#endif
#ifdef AF_WANPIPE
- /* Wanpipe API Sockets */
- PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
+ /* Wanpipe API Sockets */
+ PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
#endif
#ifdef AF_LLC
- /* Linux LLC */
- PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
+ /* Linux LLC */
+ PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
#endif
#ifdef USE_BLUETOOTH
- PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
- PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
- PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
- PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
- PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
+ PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
+ PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
+ PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
+ PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
+ PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
#if !defined(__FreeBSD__)
- PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
- PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
- PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
+ PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
+ PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
+ PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
#endif
- PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
- PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
- PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
+ PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
+ PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
+ PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
#endif
#ifdef HAVE_NETPACKET_PACKET_H
- PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
- PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
- PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
- PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
- PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
- PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
- PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
- PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
- PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
+ PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
+ PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
+ PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
+ PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
+ PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
+ PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
+ PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
+ PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
+ PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
#endif
#ifdef HAVE_LINUX_TIPC_H
- PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
+ PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
- /* for addresses */
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
- PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
+ /* for addresses */
+ PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
+ PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
+ PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
- PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
- PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
- PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
+ PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
+ PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
+ PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
- /* for setsockopt() */
- PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
- PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
- PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
- TIPC_DEST_DROPPABLE);
- PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
+ /* for setsockopt() */
+ PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
+ PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
+ PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
+ PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
+ TIPC_DEST_DROPPABLE);
+ PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
- PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
- TIPC_LOW_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
- TIPC_MEDIUM_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
- TIPC_HIGH_IMPORTANCE);
- PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
- TIPC_CRITICAL_IMPORTANCE);
+ PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
+ TIPC_LOW_IMPORTANCE);
+ PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
+ TIPC_MEDIUM_IMPORTANCE);
+ PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
+ TIPC_HIGH_IMPORTANCE);
+ PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
+ TIPC_CRITICAL_IMPORTANCE);
- /* for subscriptions */
- PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
- PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
+ /* for subscriptions */
+ PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
+ PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
#ifdef TIPC_SUB_CANCEL
- /* doesn't seem to be available everywhere */
- PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
+ /* doesn't seem to be available everywhere */
+ PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
#endif
- PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
- PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
- PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
- PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
- PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
- PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
+ PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
+ PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
+ PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
+ PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
+ PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
+ PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
#endif
- /* Socket types */
- PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
- PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
+ /* Socket types */
+ PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
+ PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
/* We have incomplete socket support. */
- PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
- PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
+ PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
+ PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
#if defined(SOCK_RDM)
- PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
+ PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
#endif
-#ifdef SO_DEBUG
- PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
+#ifdef SO_DEBUG
+ PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
#endif
-#ifdef SO_ACCEPTCONN
- PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
+#ifdef SO_ACCEPTCONN
+ PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
#endif
-#ifdef SO_REUSEADDR
- PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
+#ifdef SO_REUSEADDR
+ PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
#endif
#ifdef SO_EXCLUSIVEADDRUSE
- PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
+ PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
#endif
-#ifdef SO_KEEPALIVE
- PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
+#ifdef SO_KEEPALIVE
+ PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
#endif
-#ifdef SO_DONTROUTE
- PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
+#ifdef SO_DONTROUTE
+ PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
#endif
-#ifdef SO_BROADCAST
- PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
+#ifdef SO_BROADCAST
+ PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
#endif
-#ifdef SO_USELOOPBACK
- PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
+#ifdef SO_USELOOPBACK
+ PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
#endif
-#ifdef SO_LINGER
- PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
+#ifdef SO_LINGER
+ PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
#endif
-#ifdef SO_OOBINLINE
- PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
+#ifdef SO_OOBINLINE
+ PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
#endif
-#ifdef SO_REUSEPORT
- PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
+#ifdef SO_REUSEPORT
+ PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
#endif
-#ifdef SO_SNDBUF
- PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
+#ifdef SO_SNDBUF
+ PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
#endif
-#ifdef SO_RCVBUF
- PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
+#ifdef SO_RCVBUF
+ PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
#endif
-#ifdef SO_SNDLOWAT
- PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
+#ifdef SO_SNDLOWAT
+ PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
#endif
-#ifdef SO_RCVLOWAT
- PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
+#ifdef SO_RCVLOWAT
+ PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
#endif
-#ifdef SO_SNDTIMEO
- PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
+#ifdef SO_SNDTIMEO
+ PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
#endif
-#ifdef SO_RCVTIMEO
- PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
+#ifdef SO_RCVTIMEO
+ PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
#endif
-#ifdef SO_ERROR
- PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
+#ifdef SO_ERROR
+ PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
#endif
-#ifdef SO_TYPE
- PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
+#ifdef SO_TYPE
+ PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
#endif
-#ifdef SO_SETFIB
- PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
+#ifdef SO_SETFIB
+ PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
#endif
- /* Maximum number of connections for "listen" */
-#ifdef SOMAXCONN
- PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
+ /* Maximum number of connections for "listen" */
+#ifdef SOMAXCONN
+ PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
#else
- PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
+ PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
#endif
- /* Flags for send, recv */
-#ifdef MSG_OOB
- PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
+ /* Flags for send, recv */
+#ifdef MSG_OOB
+ PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
#endif
-#ifdef MSG_PEEK
- PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
+#ifdef MSG_PEEK
+ PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
#endif
-#ifdef MSG_DONTROUTE
- PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
+#ifdef MSG_DONTROUTE
+ PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
#endif
-#ifdef MSG_DONTWAIT
- PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
+#ifdef MSG_DONTWAIT
+ PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
#endif
-#ifdef MSG_EOR
- PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
+#ifdef MSG_EOR
+ PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
#endif
-#ifdef MSG_TRUNC
- PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
+#ifdef MSG_TRUNC
+ PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
#endif
-#ifdef MSG_CTRUNC
- PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
+#ifdef MSG_CTRUNC
+ PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
#endif
-#ifdef MSG_WAITALL
- PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
+#ifdef MSG_WAITALL
+ PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
#endif
-#ifdef MSG_BTAG
- PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
+#ifdef MSG_BTAG
+ PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
#endif
-#ifdef MSG_ETAG
- PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
+#ifdef MSG_ETAG
+ PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
#endif
- /* Protocol level and numbers, usable for [gs]etsockopt */
-#ifdef SOL_SOCKET
- PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
+ /* Protocol level and numbers, usable for [gs]etsockopt */
+#ifdef SOL_SOCKET
+ PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
#endif
-#ifdef SOL_IP
- PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
+#ifdef SOL_IP
+ PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
#else
- PyModule_AddIntConstant(m, "SOL_IP", 0);
+ PyModule_AddIntConstant(m, "SOL_IP", 0);
#endif
-#ifdef SOL_IPX
- PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
+#ifdef SOL_IPX
+ PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
#endif
-#ifdef SOL_AX25
- PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
+#ifdef SOL_AX25
+ PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
#endif
-#ifdef SOL_ATALK
- PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
+#ifdef SOL_ATALK
+ PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
#endif
-#ifdef SOL_NETROM
- PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
+#ifdef SOL_NETROM
+ PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
#endif
-#ifdef SOL_ROSE
- PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
+#ifdef SOL_ROSE
+ PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
#endif
-#ifdef SOL_TCP
- PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
+#ifdef SOL_TCP
+ PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
#else
- PyModule_AddIntConstant(m, "SOL_TCP", 6);
+ PyModule_AddIntConstant(m, "SOL_TCP", 6);
#endif
-#ifdef SOL_UDP
- PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
+#ifdef SOL_UDP
+ PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
#else
- PyModule_AddIntConstant(m, "SOL_UDP", 17);
+ PyModule_AddIntConstant(m, "SOL_UDP", 17);
#endif
-#ifdef IPPROTO_IP
- PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
+#ifdef IPPROTO_IP
+ PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
#else
- PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
+ PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
#endif
-#ifdef IPPROTO_HOPOPTS
- PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
+#ifdef IPPROTO_HOPOPTS
+ PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
#endif
-#ifdef IPPROTO_ICMP
- PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
+#ifdef IPPROTO_ICMP
+ PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
#else
- PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
+ PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
#endif
-#ifdef IPPROTO_IGMP
- PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
+#ifdef IPPROTO_IGMP
+ PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
#endif
-#ifdef IPPROTO_GGP
- PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
+#ifdef IPPROTO_GGP
+ PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
#endif
-#ifdef IPPROTO_IPV4
- PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
+#ifdef IPPROTO_IPV4
+ PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
#endif
-#ifdef IPPROTO_IPV6
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+#ifdef IPPROTO_IPV6
+ PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
#endif
-#ifdef IPPROTO_IPIP
- PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
+#ifdef IPPROTO_IPIP
+ PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
#endif
-#ifdef IPPROTO_TCP
- PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
+#ifdef IPPROTO_TCP
+ PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
#else
- PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
+ PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
#endif
-#ifdef IPPROTO_EGP
- PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
+#ifdef IPPROTO_EGP
+ PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
#endif
-#ifdef IPPROTO_PUP
- PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
+#ifdef IPPROTO_PUP
+ PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
#endif
-#ifdef IPPROTO_UDP
- PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
+#ifdef IPPROTO_UDP
+ PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
#else
- PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
+ PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
#endif
-#ifdef IPPROTO_IDP
- PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
+#ifdef IPPROTO_IDP
+ PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
#endif
-#ifdef IPPROTO_HELLO
- PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
+#ifdef IPPROTO_HELLO
+ PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
#endif
-#ifdef IPPROTO_ND
- PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
+#ifdef IPPROTO_ND
+ PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
#endif
-#ifdef IPPROTO_TP
- PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
+#ifdef IPPROTO_TP
+ PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
#endif
-#ifdef IPPROTO_IPV6
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+#ifdef IPPROTO_IPV6
+ PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
#endif
-#ifdef IPPROTO_ROUTING
- PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
+#ifdef IPPROTO_ROUTING
+ PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
#endif
-#ifdef IPPROTO_FRAGMENT
- PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
+#ifdef IPPROTO_FRAGMENT
+ PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
#endif
-#ifdef IPPROTO_RSVP
- PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
+#ifdef IPPROTO_RSVP
+ PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
#endif
-#ifdef IPPROTO_GRE
- PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
+#ifdef IPPROTO_GRE
+ PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
#endif
-#ifdef IPPROTO_ESP
- PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
+#ifdef IPPROTO_ESP
+ PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
#endif
-#ifdef IPPROTO_AH
- PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
+#ifdef IPPROTO_AH
+ PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
#endif
-#ifdef IPPROTO_MOBILE
- PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
+#ifdef IPPROTO_MOBILE
+ PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
#endif
-#ifdef IPPROTO_ICMPV6
- PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
+#ifdef IPPROTO_ICMPV6
+ PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
#endif
-#ifdef IPPROTO_NONE
- PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
+#ifdef IPPROTO_NONE
+ PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
#endif
-#ifdef IPPROTO_DSTOPTS
- PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
+#ifdef IPPROTO_DSTOPTS
+ PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
#endif
-#ifdef IPPROTO_XTP
- PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
+#ifdef IPPROTO_XTP
+ PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
#endif
-#ifdef IPPROTO_EON
- PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
+#ifdef IPPROTO_EON
+ PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
#endif
-#ifdef IPPROTO_PIM
- PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
+#ifdef IPPROTO_PIM
+ PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
#endif
-#ifdef IPPROTO_IPCOMP
- PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
+#ifdef IPPROTO_IPCOMP
+ PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
#endif
-#ifdef IPPROTO_VRRP
- PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
+#ifdef IPPROTO_VRRP
+ PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
#endif
-#ifdef IPPROTO_BIP
- PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
+#ifdef IPPROTO_BIP
+ PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
#endif
/**/
-#ifdef IPPROTO_RAW
- PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
+#ifdef IPPROTO_RAW
+ PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
#else
- PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
+ PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
#endif
-#ifdef IPPROTO_MAX
- PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
+#ifdef IPPROTO_MAX
+ PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
#endif
- /* Some port configuration */
-#ifdef IPPORT_RESERVED
- PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
+ /* Some port configuration */
+#ifdef IPPORT_RESERVED
+ PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
#else
- PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
+ PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
#endif
-#ifdef IPPORT_USERRESERVED
- PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
+#ifdef IPPORT_USERRESERVED
+ PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
#else
- PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
+ PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
#endif
- /* Some reserved IP v.4 addresses */
-#ifdef INADDR_ANY
- PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
+ /* Some reserved IP v.4 addresses */
+#ifdef INADDR_ANY
+ PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
#else
- PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
+ PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
#endif
-#ifdef INADDR_BROADCAST
- PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
+#ifdef INADDR_BROADCAST
+ PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
#else
- PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
+ PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
#endif
-#ifdef INADDR_LOOPBACK
- PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
+#ifdef INADDR_LOOPBACK
+ PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
#else
- PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
+ PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
#endif
-#ifdef INADDR_UNSPEC_GROUP
- PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
+#ifdef INADDR_UNSPEC_GROUP
+ PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
#else
- PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
+ PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
#endif
-#ifdef INADDR_ALLHOSTS_GROUP
- PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
- INADDR_ALLHOSTS_GROUP);
+#ifdef INADDR_ALLHOSTS_GROUP
+ PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
+ INADDR_ALLHOSTS_GROUP);
#else
- PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
+ PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
#endif
-#ifdef INADDR_MAX_LOCAL_GROUP
- PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
- INADDR_MAX_LOCAL_GROUP);
+#ifdef INADDR_MAX_LOCAL_GROUP
+ PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
+ INADDR_MAX_LOCAL_GROUP);
#else
- PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
+ PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
#endif
-#ifdef INADDR_NONE
- PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
+#ifdef INADDR_NONE
+ PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
#else
- PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
+ PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
#endif
- /* IPv4 [gs]etsockopt options */
-#ifdef IP_OPTIONS
- PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
+ /* IPv4 [gs]etsockopt options */
+#ifdef IP_OPTIONS
+ PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
#endif
-#ifdef IP_HDRINCL
- PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
+#ifdef IP_HDRINCL
+ PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
#endif
-#ifdef IP_TOS
- PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
+#ifdef IP_TOS
+ PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
#endif
-#ifdef IP_TTL
- PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
+#ifdef IP_TTL
+ PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
#endif
-#ifdef IP_RECVOPTS
- PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
+#ifdef IP_RECVOPTS
+ PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
#endif
-#ifdef IP_RECVRETOPTS
- PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
+#ifdef IP_RECVRETOPTS
+ PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
#endif
-#ifdef IP_RECVDSTADDR
- PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
+#ifdef IP_RECVDSTADDR
+ PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
#endif
-#ifdef IP_RETOPTS
- PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
+#ifdef IP_RETOPTS
+ PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
#endif
-#ifdef IP_MULTICAST_IF
- PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
+#ifdef IP_MULTICAST_IF
+ PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
#endif
-#ifdef IP_MULTICAST_TTL
- PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
+#ifdef IP_MULTICAST_TTL
+ PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
#endif
-#ifdef IP_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
+#ifdef IP_MULTICAST_LOOP
+ PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
#endif
-#ifdef IP_ADD_MEMBERSHIP
- PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
+#ifdef IP_ADD_MEMBERSHIP
+ PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
#endif
-#ifdef IP_DROP_MEMBERSHIP
- PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
+#ifdef IP_DROP_MEMBERSHIP
+ PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
#endif
-#ifdef IP_DEFAULT_MULTICAST_TTL
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
- IP_DEFAULT_MULTICAST_TTL);
+#ifdef IP_DEFAULT_MULTICAST_TTL
+ PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
+ IP_DEFAULT_MULTICAST_TTL);
#endif
-#ifdef IP_DEFAULT_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
- IP_DEFAULT_MULTICAST_LOOP);
+#ifdef IP_DEFAULT_MULTICAST_LOOP
+ PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
+ IP_DEFAULT_MULTICAST_LOOP);
#endif
-#ifdef IP_MAX_MEMBERSHIPS
- PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
+#ifdef IP_MAX_MEMBERSHIPS
+ PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
#endif
- /* IPv6 [gs]etsockopt options, defined in RFC2553 */
-#ifdef IPV6_JOIN_GROUP
- PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
+ /* IPv6 [gs]etsockopt options, defined in RFC2553 */
+#ifdef IPV6_JOIN_GROUP
+ PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
#endif
-#ifdef IPV6_LEAVE_GROUP
- PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
+#ifdef IPV6_LEAVE_GROUP
+ PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
#endif
-#ifdef IPV6_MULTICAST_HOPS
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
+#ifdef IPV6_MULTICAST_HOPS
+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
#endif
-#ifdef IPV6_MULTICAST_IF
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
+#ifdef IPV6_MULTICAST_IF
+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
#endif
-#ifdef IPV6_MULTICAST_LOOP
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
+#ifdef IPV6_MULTICAST_LOOP
+ PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
#endif
-#ifdef IPV6_UNICAST_HOPS
- PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
+#ifdef IPV6_UNICAST_HOPS
+ PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
#endif
- /* Additional IPV6 socket options, defined in RFC 3493 */
+ /* Additional IPV6 socket options, defined in RFC 3493 */
#ifdef IPV6_V6ONLY
- PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
+ PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
#endif
- /* Advanced IPV6 socket options, from RFC 3542 */
+ /* Advanced IPV6 socket options, from RFC 3542 */
#ifdef IPV6_CHECKSUM
- PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
+ PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
#endif
#ifdef IPV6_DONTFRAG
- PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
+ PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
#endif
#ifdef IPV6_DSTOPTS
- PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
+ PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
#endif
#ifdef IPV6_HOPLIMIT
- PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
+ PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
#endif
#ifdef IPV6_HOPOPTS
- PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
+ PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
#endif
#ifdef IPV6_NEXTHOP
- PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
+ PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
#endif
#ifdef IPV6_PATHMTU
- PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
+ PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
#endif
#ifdef IPV6_PKTINFO
- PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
+ PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
#endif
#ifdef IPV6_RECVDSTOPTS
- PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
+ PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
#endif
#ifdef IPV6_RECVHOPLIMIT
- PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
+ PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
#endif
#ifdef IPV6_RECVHOPOPTS
- PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
+ PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
#endif
#ifdef IPV6_RECVPKTINFO
- PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
+ PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
#endif
#ifdef IPV6_RECVRTHDR
- PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
+ PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
#endif
#ifdef IPV6_RECVTCLASS
- PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
+ PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
#endif
#ifdef IPV6_RTHDR
- PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
+ PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
#endif
#ifdef IPV6_RTHDRDSTOPTS
- PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
+ PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
#endif
#ifdef IPV6_RTHDR_TYPE_0
- PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
+ PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
#endif
#ifdef IPV6_RECVPATHMTU
- PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
+ PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
#endif
#ifdef IPV6_TCLASS
- PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
+ PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
#endif
#ifdef IPV6_USE_MIN_MTU
- PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
+ PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
#endif
- /* TCP options */
-#ifdef TCP_NODELAY
- PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
+ /* TCP options */
+#ifdef TCP_NODELAY
+ PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
#endif
-#ifdef TCP_MAXSEG
- PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
+#ifdef TCP_MAXSEG
+ PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
#endif
-#ifdef TCP_CORK
- PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
+#ifdef TCP_CORK
+ PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
#endif
-#ifdef TCP_KEEPIDLE
- PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
+#ifdef TCP_KEEPIDLE
+ PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
#endif
-#ifdef TCP_KEEPINTVL
- PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
+#ifdef TCP_KEEPINTVL
+ PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
#endif
-#ifdef TCP_KEEPCNT
- PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
+#ifdef TCP_KEEPCNT
+ PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
#endif
-#ifdef TCP_SYNCNT
- PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
+#ifdef TCP_SYNCNT
+ PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
#endif
-#ifdef TCP_LINGER2
- PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
+#ifdef TCP_LINGER2
+ PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
#endif
-#ifdef TCP_DEFER_ACCEPT
- PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
+#ifdef TCP_DEFER_ACCEPT
+ PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
#endif
-#ifdef TCP_WINDOW_CLAMP
- PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
+#ifdef TCP_WINDOW_CLAMP
+ PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
#endif
-#ifdef TCP_INFO
- PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
+#ifdef TCP_INFO
+ PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
#endif
-#ifdef TCP_QUICKACK
- PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
+#ifdef TCP_QUICKACK
+ PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
#endif
- /* IPX options */
-#ifdef IPX_TYPE
- PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
+ /* IPX options */
+#ifdef IPX_TYPE
+ PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
#endif
- /* get{addr,name}info parameters */
+ /* get{addr,name}info parameters */
#ifdef EAI_ADDRFAMILY
- PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
+ PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
#endif
#ifdef EAI_AGAIN
- PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
+ PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
#endif
#ifdef EAI_BADFLAGS
- PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
+ PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
#endif
#ifdef EAI_FAIL
- PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
+ PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
#endif
#ifdef EAI_FAMILY
- PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
+ PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
#endif
#ifdef EAI_MEMORY
- PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
+ PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
#endif
#ifdef EAI_NODATA
- PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
+ PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
#endif
#ifdef EAI_NONAME
- PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
+ PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
#endif
#ifdef EAI_OVERFLOW
- PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
+ PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
#endif
#ifdef EAI_SERVICE
- PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
+ PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
#endif
#ifdef EAI_SOCKTYPE
- PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
+ PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
#endif
#ifdef EAI_SYSTEM
- PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
+ PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
#endif
#ifdef EAI_BADHINTS
- PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
+ PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
#endif
#ifdef EAI_PROTOCOL
- PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
+ PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
#endif
#ifdef EAI_MAX
- PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
+ PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
#endif
#ifdef AI_PASSIVE
- PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
+ PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
#endif
#ifdef AI_CANONNAME
- PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
+ PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
#endif
#ifdef AI_NUMERICHOST
- PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
+ PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
#endif
#ifdef AI_NUMERICSERV
- PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
+ PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
#endif
#ifdef AI_MASK
- PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
+ PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
#endif
#ifdef AI_ALL
- PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
+ PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
#endif
#ifdef AI_V4MAPPED_CFG
- PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
+ PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
#endif
#ifdef AI_ADDRCONFIG
- PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
+ PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
#endif
#ifdef AI_V4MAPPED
- PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
+ PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
#endif
#ifdef AI_DEFAULT
- PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
+ PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
#endif
#ifdef NI_MAXHOST
- PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
+ PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
#endif
#ifdef NI_MAXSERV
- PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
+ PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
#endif
#ifdef NI_NOFQDN
- PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
+ PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
#endif
#ifdef NI_NUMERICHOST
- PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
+ PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
#endif
#ifdef NI_NAMEREQD
- PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
+ PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
#endif
#ifdef NI_NUMERICSERV
- PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
+ PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
#endif
#ifdef NI_DGRAM
- PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
+ PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
#endif
- /* shutdown() parameters */
+ /* shutdown() parameters */
#ifdef SHUT_RD
- PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
+ PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
#elif defined(SD_RECEIVE)
- PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
+ PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
#else
- PyModule_AddIntConstant(m, "SHUT_RD", 0);
+ PyModule_AddIntConstant(m, "SHUT_RD", 0);
#endif
#ifdef SHUT_WR
- PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
+ PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
#elif defined(SD_SEND)
- PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
+ PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
#else
- PyModule_AddIntConstant(m, "SHUT_WR", 1);
+ PyModule_AddIntConstant(m, "SHUT_WR", 1);
#endif
#ifdef SHUT_RDWR
- PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
+ PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
#elif defined(SD_BOTH)
- PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
+ PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
#else
- PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
+ PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
#endif
#ifdef SIO_RCVALL
- {
- DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
- const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
- int i;
- for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {
- PyObject *tmp;
- tmp = PyLong_FromUnsignedLong(codes[i]);
- if (tmp == NULL)
- return NULL;
- PyModule_AddObject(m, names[i], tmp);
- }
- }
- PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
- PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
- PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
+ {
+ DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
+ const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
+ int i;
+ for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {
+ PyObject *tmp;
+ tmp = PyLong_FromUnsignedLong(codes[i]);
+ if (tmp == NULL)
+ return NULL;
+ PyModule_AddObject(m, names[i], tmp);
+ }
+ }
+ PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
+ PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
+ PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
#ifdef RCVALL_IPLEVEL
- PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
+ PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
#endif
#ifdef RCVALL_MAX
- PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
+ PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
#endif
#endif /* _MSTCPIP_ */
- /* Initialize gethostbyname lock */
+ /* Initialize gethostbyname lock */
#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
- netdb_lock = PyThread_allocate_lock();
+ netdb_lock = PyThread_allocate_lock();
#endif
- return m;
+ return m;
}
@@ -5140,34 +5140,34 @@
int
inet_pton(int af, const char *src, void *dst)
{
- if (af == AF_INET) {
+ if (af == AF_INET) {
#if (SIZEOF_INT != 4)
#error "Not sure if in_addr_t exists and int is not 32-bits."
#endif
- unsigned int packed_addr;
- packed_addr = inet_addr(src);
- if (packed_addr == INADDR_NONE)
- return 0;
- memcpy(dst, &packed_addr, 4);
- return 1;
- }
- /* Should set errno to EAFNOSUPPORT */
- return -1;
+ unsigned int packed_addr;
+ packed_addr = inet_addr(src);
+ if (packed_addr == INADDR_NONE)
+ return 0;
+ memcpy(dst, &packed_addr, 4);
+ return 1;
+ }
+ /* Should set errno to EAFNOSUPPORT */
+ return -1;
}
const char *
inet_ntop(int af, const void *src, char *dst, socklen_t size)
{
- if (af == AF_INET) {
- struct in_addr packed_addr;
- if (size < 16)
- /* Should set errno to ENOSPC. */
- return NULL;
- memcpy(&packed_addr, src, sizeof(packed_addr));
- return strncpy(dst, inet_ntoa(packed_addr), size);
- }
- /* Should set errno to EAFNOSUPPORT */
- return NULL;
+ if (af == AF_INET) {
+ struct in_addr packed_addr;
+ if (size < 16)
+ /* Should set errno to ENOSPC. */
+ return NULL;
+ memcpy(&packed_addr, src, sizeof(packed_addr));
+ return strncpy(dst, inet_ntoa(packed_addr), size);
+ }
+ /* Should set errno to EAFNOSUPPORT */
+ return NULL;
}
#endif