cpython-lru_cache-weakref: Modules/socketmodule.c comparison

comparison Modules/socketmodule.c @ 61467:f197407bdba2 3.1

Recorded merge of revisions 81032 via svnmerge from svn+ssh://pythondev@svn.python.org/python/branches/py3k ................ r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines 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. ........ ................

author	Antoine Pitrou <solipsis@pitrou.net>
date	Sun, 09 May 2010 16:14:21 +0000
parents	e918b84ef968
children	2a4ceebdfcfb

comparison

equal deleted inserted replaced

-:f8c19c5f5dd2
+:f197407bdba2
 Module interface:
 - 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')
 - socket.getprotobyname(protocolname) --> protocol number
 - 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)
 - 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
 - socket.inet_aton(IP address) -> 32-bit packed IP representation
 - socket.inet_ntoa(packed IP) -> IP address string
 the Ethernet protocol number to be received. For example:
 ("eth0",0x1234).  Optional 3rd,4th,5th elements in the tuple
 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:
+if addr_type is TIPC_ADDR_NAME:
-		v1 is the server type
+v1 is the server type
-		v2 is the port identifier
+v2 is the port identifier
-		v3 is ignored
+v3 is ignored
-	if addr_type is TIPC_ADDR_NAMESEQ:
+if addr_type is TIPC_ADDR_NAMESEQ:
-		v1 is the server type
+v1 is the server type
-		v2 is the lower port number
+v2 is the lower port number
-		v3 is the upper port number
+v3 is the upper port number
-	if addr_type is TIPC_ADDR_ID:
+if addr_type is TIPC_ADDR_ID:
-		v1 is the node
+v1 is the node
-		v2 is the ref
+v2 is the ref
-		v3 is ignored
+v3 is ignored
 Local naming conventions:
 - names starting with sock_ are socket object methods
 #endif
 #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
 # define O_NONBLOCK O_NDELAY
 #endif
 #ifdef MS_WINDOWS
 /* On Windows a socket is really a handle not an fd */
 static SOCKET
 dup_socket(SOCKET handle)
 {
-	HANDLE newhandle;
+HANDLE newhandle;
-	if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)handle,
+if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)handle,
-			     GetCurrentProcess(), &newhandle,
+GetCurrentProcess(), &newhandle,
-			     0, FALSE, DUPLICATE_SAME_ACCESS))
+0, FALSE, DUPLICATE_SAME_ACCESS))
-	{
+{
-		WSASetLastError(GetLastError());
+WSASetLastError(GetLastError());
-		return INVALID_SOCKET;
+return INVALID_SOCKET;
-	}
+}
-	return (SOCKET)newhandle;
+return (SOCKET)newhandle;
 }
 #define SOCKETCLOSE closesocket
 #else
 /* On Unix we can use dup to duplicate the file descriptor of a socket*/
 #define dup_socket(fd) dup(fd)
 #ifdef __VMS
 /* TCP/IP Services for VMS uses a maximum send/recv buffer length */
 #define SEGMENT_SIZE (32 * 1024 -1)
 #endif
-#define	SAS2SA(x)	((struct sockaddr *)(x))
+#define SAS2SA(x)       ((struct sockaddr *)(x))
 /*
 * Constants for getnameinfo()
 */
 #if !defined(NI_MAXHOST)
 #endif
 static PyObject*
 select_error(void)
 {
-	PyErr_SetString(socket_error, "unable to select on socket");
+PyErr_SetString(socket_error, "unable to select on socket");
-	return NULL;
+return NULL;
 }
 /* Convenience function to raise an error according to errno
 and return a NULL pointer from a function. */
 static PyObject *
 set_error(void)
 {
 #ifdef MS_WINDOWS
-	int err_no = WSAGetLastError();
+int err_no = WSAGetLastError();
-	/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
+/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
-	   recognizes the error codes used by both GetLastError() and
+recognizes the error codes used by both GetLastError() and
-	   WSAGetLastError */
+WSAGetLastError */
-	if (err_no)
+if (err_no)
-		return PyErr_SetExcFromWindowsErr(socket_error, err_no);
+return PyErr_SetExcFromWindowsErr(socket_error, err_no);
 #endif
 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
-	if (sock_errno() != NO_ERROR) {
+if (sock_errno() != NO_ERROR) {
-		APIRET rc;
+APIRET rc;
-		ULONG  msglen;
+ULONG  msglen;
-		char outbuf[100];
+char outbuf[100];
-		int myerrorcode = sock_errno();
+int myerrorcode = sock_errno();
-		/* Retrieve socket-related error message from MPTN.MSG file */
+/* Retrieve socket-related error message from MPTN.MSG file */
-		rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
+rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
-				   myerrorcode - SOCBASEERR + 26,
+myerrorcode - SOCBASEERR + 26,
-				   "mptn.msg",
+"mptn.msg",
-				   &msglen);
+&msglen);
-		if (rc == NO_ERROR) {
+if (rc == NO_ERROR) {
-			PyObject *v;
+PyObject *v;
-			/* OS/2 doesn't guarantee a terminator */
+/* OS/2 doesn't guarantee a terminator */
-			outbuf[msglen] = '\0';
+outbuf[msglen] = '\0';
-			if (strlen(outbuf) > 0) {
+if (strlen(outbuf) > 0) {
-				/* If non-empty msg, trim CRLF */
+/* If non-empty msg, trim CRLF */
-				char *lastc = &outbuf[ strlen(outbuf)-1 ];
+char *lastc = &outbuf[ strlen(outbuf)-1 ];
-				while (lastc > outbuf &&
+while (lastc > outbuf &&
-				       isspace(Py_CHARMASK(*lastc))) {
+isspace(Py_CHARMASK(*lastc))) {
-					/* Trim trailing whitespace (CRLF) */
+/* Trim trailing whitespace (CRLF) */
-					*lastc-- = '\0';
+*lastc-- = '\0';
-				}
+}
-			}
+}
-			v = Py_BuildValue("(is)", myerrorcode, outbuf);
+v = Py_BuildValue("(is)", myerrorcode, outbuf);
-			if (v != NULL) {
+if (v != NULL) {
-				PyErr_SetObject(socket_error, v);
+PyErr_SetObject(socket_error, v);
-				Py_DECREF(v);
+Py_DECREF(v);
-			}
+}
-			return NULL;
+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) {
+if (v != NULL) {
-		PyErr_SetObject(socket_herror, v);
+PyErr_SetObject(socket_herror, v);
-		Py_DECREF(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. */
+/* EAI_SYSTEM is not available on Windows XP. */
-	if (error == EAI_SYSTEM)
+if (error == EAI_SYSTEM)
-		return set_error();
+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) {
+if (v != NULL) {
-		PyErr_SetObject(socket_gaierror, v);
+PyErr_SetObject(socket_gaierror, v);
-		Py_DECREF(v);
+Py_DECREF(v);
-	}
+}
-	return NULL;
+return NULL;
 }
 #ifdef __VMS
 /* Function to send in segments */
 static int
 sendsegmented(int sock_fd, char *buf, int len, int flags)
 {
-	int n = 0;
+int n = 0;
-	int remaining = len;
+int remaining = len;
-	while (remaining > 0) {
+while (remaining > 0) {
-		unsigned int segment;
+unsigned int segment;
-		segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
+segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
-		n = send(sock_fd, buf, segment, flags);
+n = send(sock_fd, buf, segment, flags);
-		if (n < 0) {
+if (n < 0) {
-			return n;
+return n;
-		}
+}
-		remaining -= segment;
+remaining -= segment;
-		buf += segment;
+buf += segment;
-	} /* end while */
+} /* end while */
-	return len;
+return len;
 }
 #endif
 /* Function to perform the setting of socket blocking mode
 internally. block = (1 | 0). */
 static int
 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;
+block = !block;
-	ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
+ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
 #elif defined(__VMS)
-	block = !block;
+block = !block;
-	ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
+ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
 #else  /* !PYOS_OS2 && !__VMS */
-	delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
+delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
-	if (block)
+if (block)
-		delay_flag &= (~O_NONBLOCK);
+delay_flag &= (~O_NONBLOCK);
-	else
+else
-		delay_flag |= O_NONBLOCK;
+delay_flag |= O_NONBLOCK;
-	fcntl(s->sock_fd, F_SETFL, delay_flag);
+fcntl(s->sock_fd, F_SETFL, delay_flag);
 #endif /* !PYOS_OS2 */
 #else /* MS_WINDOWS */
-	block = !block;
+block = !block;
-	ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&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 */
+/* Since these don't return anything */
-	return 1;
+return 1;
 }
 /* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
 The argument writing indicates the direction.
 This does not raise an exception; we'll let our caller do that
 after they've reacquired the interpreter lock.
 Returns 1 on timeout, -1 on error, 0 otherwise. */
 static int
 internal_select(PySocketSockObject *s, int writing)
 {
-	int n;
+int n;
-	/* Nothing to do unless we're in timeout mode (not non-blocking) */
+/* Nothing to do unless we're in timeout mode (not non-blocking) */
-	if (s->sock_timeout <= 0.0)
+if (s->sock_timeout <= 0.0)
-		return 0;
+return 0;
-	/* Guard against closed socket */
+/* Guard against closed socket */
-	if (s->sock_fd < 0)
+if (s->sock_fd < 0)
-		return 0;
+return 0;
-	/* Prefer poll, if available, since you can poll() any fd
+/* Prefer poll, if available, since you can poll() any fd
-	 * which can't be done with select(). */
+* which can't be done with select(). */
 #ifdef HAVE_POLL
-	{
+{
-		struct pollfd pollfd;
+struct pollfd pollfd;
-		int timeout;
+int timeout;
-		pollfd.fd = s->sock_fd;
+pollfd.fd = s->sock_fd;
-		pollfd.events = writing ? POLLOUT : POLLIN;
+pollfd.events = writing ? POLLOUT : POLLIN;
-		/* s->sock_timeout is in seconds, timeout in ms */
+/* s->sock_timeout is in seconds, timeout in ms */
-		timeout = (int)(s->sock_timeout * 1000 + 0.5);
+timeout = (int)(s->sock_timeout * 1000 + 0.5);
-		n = poll(&pollfd, 1, timeout);
+n = poll(&pollfd, 1, timeout);
-	}
+}
 #else
-	{
+{
-		/* Construct the arguments to select */
+/* Construct the arguments to select */
-		fd_set fds;
+fd_set fds;
-		struct timeval tv;
+struct timeval tv;
-		tv.tv_sec = (int)s->sock_timeout;
+tv.tv_sec = (int)s->sock_timeout;
-		tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
+tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
-		FD_ZERO(&fds);
+FD_ZERO(&fds);
-		FD_SET(s->sock_fd, &fds);
+FD_SET(s->sock_fd, &fds);
-		/* See if the socket is ready */
+/* See if the socket is ready */
-		if (writing)
+if (writing)
-			n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
+n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
-		else
+else
-			n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
+n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
-	}
+}
 #endif
-	if (n < 0)
+if (n < 0)
-		return -1;
+return -1;
-	if (n == 0)
+if (n == 0)
-		return 1;
+return 1;
-	return 0;
+return 0;
 }
 /* Initialize a new socket object. */
 static double defaulttimeout = -1.0; /* Default timeout for new sockets */
 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_fd = fd;
-	s->sock_family = family;
+s->sock_family = family;
-	s->sock_type = type;
+s->sock_type = type;
-	s->sock_proto = proto;
+s->sock_proto = proto;
-	s->sock_timeout = defaulttimeout;
+s->sock_timeout = defaulttimeout;
-	s->errorhandler = &set_error;
+s->errorhandler = &set_error;
-	if (defaulttimeout >= 0.0)
+if (defaulttimeout >= 0.0)
-		internal_setblocking(s, 0);
+internal_setblocking(s, 0);
 }
 /* Create a new socket object.
 in NEWOBJ()). */
 static PySocketSockObject *
 new_sockobject(SOCKET_T fd, int family, int type, int proto)
 {
-	PySocketSockObject *s;
+PySocketSockObject *s;
-	s = (PySocketSockObject *)
+s = (PySocketSockObject *)
-		PyType_GenericNew(&sock_type, NULL, NULL);
+PyType_GenericNew(&sock_type, NULL, NULL);
-	if (s != NULL)
+if (s != NULL)
-		init_sockobject(s, fd, family, type, proto);
+init_sockobject(s, fd, family, type, proto);
-	return s;
+return s;
 }
 /* Lock to allow python interpreter to continue, but only allow one
 thread to be in gethostbyname or getaddrinfo */
 an error occurred; then an exception is raised. */
 static int
 setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
 {
-	struct addrinfo hints, *res;
+struct addrinfo hints, *res;
-	int error;
+int error;
-	int d1, d2, d3, d4;
+int d1, d2, d3, d4;
-	char ch;
+char ch;
-	memset((void *) addr_ret, '\0', sizeof(*addr_ret));
+memset((void *) addr_ret, '\0', sizeof(*addr_ret));
-	if (name[0] == '\0') {
+if (name[0] == '\0') {
-		int siz;
+int siz;
-		memset(&hints, 0, sizeof(hints));
+memset(&hints, 0, sizeof(hints));
-		hints.ai_family = af;
+hints.ai_family = af;
-		hints.ai_socktype = SOCK_DGRAM;	/*dummy*/
+hints.ai_socktype = SOCK_DGRAM;         /*dummy*/
-		hints.ai_flags = AI_PASSIVE;
+hints.ai_flags = AI_PASSIVE;
-		Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-		ACQUIRE_GETADDRINFO_LOCK
+ACQUIRE_GETADDRINFO_LOCK
-		error = getaddrinfo(NULL, "0", &hints, &res);
+error = getaddrinfo(NULL, "0", &hints, &res);
-		Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-		/* We assume that those thread-unsafe getaddrinfo() versions
+/* We assume that those thread-unsafe getaddrinfo() versions
-		   *are* safe regarding their return value, ie. that a
+*are* safe regarding their return value, ie. that a
-		   subsequent call to getaddrinfo() does not destroy the
+subsequent call to getaddrinfo() does not destroy the
-		   outcome of the first call. */
+outcome of the first call. */
-		RELEASE_GETADDRINFO_LOCK
+RELEASE_GETADDRINFO_LOCK
-		if (error) {
+if (error) {
-			set_gaierror(error);
+set_gaierror(error);
-			return -1;
+return -1;
-		}
+}
-		switch (res->ai_family) {
+switch (res->ai_family) {
-		case AF_INET:
+case AF_INET:
-			siz = 4;
+siz = 4;
-			break;
+break;
 #ifdef ENABLE_IPV6
-		case AF_INET6:
+case AF_INET6:
-			siz = 16;
+siz = 16;
-			break;
+break;
 #endif
-		default:
+default:
-			freeaddrinfo(res);
+freeaddrinfo(res);
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"unsupported address family");
+"unsupported address family");
-			return -1;
+return -1;
-		}
+}
-		if (res->ai_next) {
+if (res->ai_next) {
-			freeaddrinfo(res);
+freeaddrinfo(res);
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"wildcard resolved to multiple address");
+"wildcard resolved to multiple address");
-			return -1;
+return -1;
-		}
+}
-		if (res->ai_addrlen < addr_ret_size)
+if (res->ai_addrlen < addr_ret_size)
-			addr_ret_size = res->ai_addrlen;
+addr_ret_size = res->ai_addrlen;
-		memcpy(addr_ret, res->ai_addr, addr_ret_size);
+memcpy(addr_ret, res->ai_addr, addr_ret_size);
-		freeaddrinfo(res);
+freeaddrinfo(res);
-		return siz;
+return siz;
-	}
+}
-	if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
+if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
-		struct sockaddr_in *sin;
+struct sockaddr_in *sin;
-		if (af != AF_INET && af != AF_UNSPEC) {
+if (af != AF_INET && af != AF_UNSPEC) {
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"address family mismatched");
+"address family mismatched");
-			return -1;
+return -1;
-		}
+}
-		sin = (struct sockaddr_in *)addr_ret;
+sin = (struct sockaddr_in *)addr_ret;
-		memset((void *) sin, '\0', sizeof(*sin));
+memset((void *) sin, '\0', sizeof(*sin));
-		sin->sin_family = AF_INET;
+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;
+sin->sin_addr.s_addr = INADDR_BROADCAST;
-		return sizeof(sin->sin_addr);
+return sizeof(sin->sin_addr);
-	}
+}
-	if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
+if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
-	    0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
+0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
-	    0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
+0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
-		struct sockaddr_in *sin;
+struct sockaddr_in *sin;
-		sin = (struct sockaddr_in *)addr_ret;
+sin = (struct sockaddr_in *)addr_ret;
-		sin->sin_addr.s_addr = htonl(
+sin->sin_addr.s_addr = htonl(
-			((long) d1 << 24) | ((long) d2 << 16) |
+((long) d1 << 24) | ((long) d2 << 16) |
-			((long) d3 << 8) | ((long) d4 << 0));
+((long) d3 << 8) | ((long) d4 << 0));
-		sin->sin_family = AF_INET;
+sin->sin_family = AF_INET;
 #ifdef HAVE_SOCKADDR_SA_LEN
-		sin->sin_len = sizeof(*sin);
+sin->sin_len = sizeof(*sin);
 #endif
-		return 4;
+return 4;
-	}
+}
-	memset(&hints, 0, sizeof(hints));
+memset(&hints, 0, sizeof(hints));
-	hints.ai_family = af;
+hints.ai_family = af;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	ACQUIRE_GETADDRINFO_LOCK
+ACQUIRE_GETADDRINFO_LOCK
-	error = getaddrinfo(name, NULL, &hints, &res);
+error = getaddrinfo(name, NULL, &hints, &res);
 #if defined(__digital__) && defined(__unix__)
-	if (error == EAI_NONAME && af == AF_UNSPEC) {
+if (error == EAI_NONAME && af == AF_UNSPEC) {
-		/* On Tru64 V5.1, numeric-to-addr conversion fails
+/* On Tru64 V5.1, numeric-to-addr conversion fails
-		   if no address family is given. Assume IPv4 for now.*/
+if no address family is given. Assume IPv4 for now.*/
-		hints.ai_family = AF_INET;
+hints.ai_family = AF_INET;
-		error = getaddrinfo(name, NULL, &hints, &res);
+error = getaddrinfo(name, NULL, &hints, &res);
-	}
+}
 #endif
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
+RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
-	if (error) {
+if (error) {
-		set_gaierror(error);
+set_gaierror(error);
-		return -1;
+return -1;
-	}
+}
-	if (res->ai_addrlen < addr_ret_size)
+if (res->ai_addrlen < addr_ret_size)
-		addr_ret_size = res->ai_addrlen;
+addr_ret_size = res->ai_addrlen;
-	memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
+memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
-	freeaddrinfo(res);
+freeaddrinfo(res);
-	switch (addr_ret->sa_family) {
+switch (addr_ret->sa_family) {
-	case AF_INET:
+case AF_INET:
-		return 4;
+return 4;
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-		return 16;
+return 16;
 #endif
-	default:
+default:
-		PyErr_SetString(socket_error, "unknown address family");
+PyErr_SetString(socket_error, "unknown address family");
-		return -1;
+return -1;
-	}
+}
 }
 /* Create a string object representing an IP address.
 This is always a string of the form 'dd.dd.dd.dd' (with variable
 size numbers). */
 static PyObject *
 makeipaddr(struct sockaddr *addr, int addrlen)
 {
-	char buf[NI_MAXHOST];
+char buf[NI_MAXHOST];
-	int error;
+int error;
-	error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
+error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
-		NI_NUMERICHOST);
+NI_NUMERICHOST);
-	if (error) {
+if (error) {
-		set_gaierror(error);
+set_gaierror(error);
-		return NULL;
+return NULL;
-	}
+}
-	return PyUnicode_FromString(buf);
+return PyUnicode_FromString(buf);
 }
 #ifdef USE_BLUETOOTH
 /* Convert a string representation of a Bluetooth address into a numeric
 an error occurred. */
 static int
 setbdaddr(char *name, bdaddr_t *bdaddr)
 {
-	unsigned int b0, b1, b2, b3, b4, b5;
+unsigned int b0, b1, b2, b3, b4, b5;
-	char ch;
+char ch;
-	int n;
+int n;
-	n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
+n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
-		   &b5, &b4, &b3, &b2, &b1, &b0, &ch);
+&b5, &b4, &b3, &b2, &b1, &b0, &ch);
-	if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
+if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
-		bdaddr->b[0] = b0;
+bdaddr->b[0] = b0;
-		bdaddr->b[1] = b1;
+bdaddr->b[1] = b1;
-		bdaddr->b[2] = b2;
+bdaddr->b[2] = b2;
-		bdaddr->b[3] = b3;
+bdaddr->b[3] = b3;
-		bdaddr->b[4] = b4;
+bdaddr->b[4] = b4;
-		bdaddr->b[5] = b5;
+bdaddr->b[5] = b5;
-		return 6;
+return 6;
-	} else {
+} else {
-		PyErr_SetString(socket_error, "bad bluetooth address");
+PyErr_SetString(socket_error, "bad bluetooth address");
-		return -1;
+return -1;
-	}
+}
 }
 /* Create a string representation of the Bluetooth address.  This is always a
 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
 value (zero padded if necessary). */
 static PyObject *
 makebdaddr(bdaddr_t *bdaddr)
 {
-	char buf[(6 * 2) + 5 + 1];
+char buf[(6 * 2) + 5 + 1];
-	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
+sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
-		bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
+bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
-		bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
+bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
-	return PyUnicode_FromString(buf);
+return PyUnicode_FromString(buf);
 }
 #endif
 /* Create an object representing the given socket address,
 /*ARGSUSED*/
 static PyObject *
 makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
 {
-	if (addrlen == 0) {
+if (addrlen == 0) {
-		/* No address -- may be recvfrom() from known socket */
+/* No address -- may be recvfrom() from known socket */
-		Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-		return Py_None;
+return Py_None;
-	}
+}
-	switch (addr->sa_family) {
+switch (addr->sa_family) {
-	case AF_INET:
+case AF_INET:
-	{
+{
-		struct sockaddr_in *a;
+struct sockaddr_in *a;
-		PyObject *addrobj = makeipaddr(addr, sizeof(*a));
+PyObject *addrobj = makeipaddr(addr, sizeof(*a));
-		PyObject *ret = NULL;
+PyObject *ret = NULL;
-		if (addrobj) {
+if (addrobj) {
-			a = (struct sockaddr_in *)addr;
+a = (struct sockaddr_in *)addr;
-			ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
+ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
-			Py_DECREF(addrobj);
+Py_DECREF(addrobj);
-		}
+}
-		return ret;
+return ret;
-	}
+}
 #if defined(AF_UNIX)
-	case AF_UNIX:
+case AF_UNIX:
-	{
+{
-		struct sockaddr_un *a = (struct sockaddr_un *) addr;
+struct sockaddr_un *a = (struct sockaddr_un *) addr;
 #ifdef linux
-		if (a->sun_path[0] == 0) {  /* Linux abstract namespace */
+if (a->sun_path[0] == 0) {  /* Linux abstract namespace */
-			addrlen -= offsetof(struct sockaddr_un, sun_path);
+addrlen -= offsetof(struct sockaddr_un, sun_path);
-			return PyBytes_FromStringAndSize(a->sun_path, addrlen);
+return PyBytes_FromStringAndSize(a->sun_path, addrlen);
-		}
+}
-		else
+else
 #endif /* linux */
-		{
+{
-			/* regular NULL-terminated string */
+/* regular NULL-terminated string */
-			return PyUnicode_FromString(a->sun_path);
+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);
 }
 #endif /* AF_NETLINK */
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-	{
+{
-		struct sockaddr_in6 *a;
+struct sockaddr_in6 *a;
-		PyObject *addrobj = makeipaddr(addr, sizeof(*a));
+PyObject *addrobj = makeipaddr(addr, sizeof(*a));
-		PyObject *ret = NULL;
+PyObject *ret = NULL;
-		if (addrobj) {
+if (addrobj) {
-			a = (struct sockaddr_in6 *)addr;
+a = (struct sockaddr_in6 *)addr;
-			ret = Py_BuildValue("Oiii",
+ret = Py_BuildValue("Oiii",
-					    addrobj,
+addrobj,
-					    ntohs(a->sin6_port),
+ntohs(a->sin6_port),
-					    a->sin6_flowinfo,
+a->sin6_flowinfo,
-					    a->sin6_scope_id);
+a->sin6_scope_id);
-			Py_DECREF(addrobj);
+Py_DECREF(addrobj);
-		}
+}
-		return ret;
+return ret;
-	}
+}
 #endif
 #ifdef USE_BLUETOOTH
-	case AF_BLUETOOTH:
+case AF_BLUETOOTH:
-		switch (proto) {
+switch (proto) {
-		case BTPROTO_L2CAP:
+case BTPROTO_L2CAP:
-		{
+{
-			struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
+struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
-			PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
+PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
-			PyObject *ret = NULL;
+PyObject *ret = NULL;
-			if (addrobj) {
+if (addrobj) {
-				ret = Py_BuildValue("Oi",
+ret = Py_BuildValue("Oi",
-						    addrobj,
+addrobj,
-						    _BT_L2_MEMB(a, psm));
+_BT_L2_MEMB(a, psm));
-				Py_DECREF(addrobj);
+Py_DECREF(addrobj);
-			}
+}
-			return ret;
+return ret;
-		}
+}
-		case BTPROTO_RFCOMM:
+case BTPROTO_RFCOMM:
-		{
+{
-			struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
+struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
-			PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
+PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
-			PyObject *ret = NULL;
+PyObject *ret = NULL;
-			if (addrobj) {
+if (addrobj) {
-				ret = Py_BuildValue("Oi",
+ret = Py_BuildValue("Oi",
-						    addrobj,
+addrobj,
-						    _BT_RC_MEMB(a, channel));
+_BT_RC_MEMB(a, channel));
-				Py_DECREF(addrobj);
+Py_DECREF(addrobj);
-			}
+}
-			return ret;
+return ret;
-		}
+}
-		case BTPROTO_HCI:
+case BTPROTO_HCI:
-		{
+{
-			struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
+struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
-			PyObject *ret = NULL;
+PyObject *ret = NULL;
-			ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
+ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
-			return ret;
+return ret;
-		}
+}
 #if !defined(__FreeBSD__)
-		case BTPROTO_SCO:
+case BTPROTO_SCO:
-		{
+{
-			struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
+struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
-			return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
+return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
-		}
+}
 #endif
-		default:
+default:
-			PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-					"Unknown Bluetooth protocol");
+"Unknown Bluetooth protocol");
-			return NULL;
+return NULL;
-		}
+}
 #endif
 #ifdef HAVE_NETPACKET_PACKET_H
-	case AF_PACKET:
+case AF_PACKET:
-	{
+{
-		struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
+struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
-		char *ifname = "";
+char *ifname = "";
-		struct ifreq ifr;
+struct ifreq ifr;
-		/* need to look up interface name give index */
+/* need to look up interface name give index */
-		if (a->sll_ifindex) {
+if (a->sll_ifindex) {
-			ifr.ifr_ifindex = a->sll_ifindex;
+ifr.ifr_ifindex = a->sll_ifindex;
-			if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
+if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
-				ifname = ifr.ifr_name;
+ifname = ifr.ifr_name;
-		}
+}
-		return Py_BuildValue("shbhy#",
+return Py_BuildValue("shbhy#",
-				     ifname,
+ifname,
-				     ntohs(a->sll_protocol),
+ntohs(a->sll_protocol),
-				     a->sll_pkttype,
+a->sll_pkttype,
-				     a->sll_hatype,
+a->sll_hatype,
-				     a->sll_addr,
+a->sll_addr,
-				     a->sll_halen);
+a->sll_halen);
-	}
+}
 #endif
 #ifdef HAVE_LINUX_TIPC_H
-	case AF_TIPC:
+case AF_TIPC:
-	{
+{
-		struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
+struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
-		if (a->addrtype == TIPC_ADDR_NAMESEQ) {
+if (a->addrtype == TIPC_ADDR_NAMESEQ) {
-			return Py_BuildValue("IIIII",
+return Py_BuildValue("IIIII",
-					a->addrtype,
+a->addrtype,
-					a->addr.nameseq.type,
+a->addr.nameseq.type,
-					a->addr.nameseq.lower,
+a->addr.nameseq.lower,
-					a->addr.nameseq.upper,
+a->addr.nameseq.upper,
-					a->scope);
+a->scope);
-		} else if (a->addrtype == TIPC_ADDR_NAME) {
+} else if (a->addrtype == TIPC_ADDR_NAME) {
-			return Py_BuildValue("IIIII",
+return Py_BuildValue("IIIII",
-					a->addrtype,
+a->addrtype,
-					a->addr.name.name.type,
+a->addr.name.name.type,
-					a->addr.name.name.instance,
+a->addr.name.name.instance,
-					a->addr.name.name.instance,
+a->addr.name.name.instance,
-					a->scope);
+a->scope);
-		} else if (a->addrtype == TIPC_ADDR_ID) {
+} else if (a->addrtype == TIPC_ADDR_ID) {
-			return Py_BuildValue("IIIII",
+return Py_BuildValue("IIIII",
-					a->addrtype,
+a->addrtype,
-					a->addr.id.node,
+a->addr.id.node,
-					a->addr.id.ref,
+a->addr.id.ref,
-					0,
+0,
-					a->scope);
+a->scope);
-		} else {
+} else {
-			PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-					"Invalid address type");
+"Invalid address type");
-			return NULL;
+return NULL;
-		}
+}
-	}
+}
 #endif
-	/* More cases here... */
+/* More cases here... */
-	default:
+default:
-		/* If we don't know the address family, don't raise an
+/* If we don't know the address family, don't raise an
-		   exception -- return it as an (int, bytes) tuple. */
+exception -- return it as an (int, bytes) tuple. */
-		return Py_BuildValue("iy#",
+return Py_BuildValue("iy#",
-				     addr->sa_family,
+addr->sa_family,
-				     addr->sa_data,
+addr->sa_data,
-				     sizeof(addr->sa_data));
+sizeof(addr->sa_data));
-	}
+}
 }
 /* Parse a socket address argument according to the socket object's
 address family.  Return 1 if the address was in the proper format,
 0 of not.  The address is returned through addr_ret, its length
 through len_ret. */
 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:
+case AF_UNIX:
-	{
+{
-		struct sockaddr_un* addr;
+struct sockaddr_un* addr;
-		char *path;
+char *path;
-		int len;
+int len;
-		if (!PyArg_Parse(args, "s#", &path, &len))
+if (!PyArg_Parse(args, "s#", &path, &len))
-			return 0;
+return 0;
-		addr = (struct sockaddr_un*)addr_ret;
+addr = (struct sockaddr_un*)addr_ret;
 #ifdef linux
-		if (len > 0 && path[0] == 0) {
+if (len > 0 && path[0] == 0) {
-			/* Linux abstract namespace extension */
+/* Linux abstract namespace extension */
-			if (len > sizeof addr->sun_path) {
+if (len > sizeof addr->sun_path) {
-				PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-						"AF_UNIX path too long");
+"AF_UNIX path too long");
-				return 0;
+return 0;
-			}
+}
-		}
+}
-		else
+else
 #endif /* linux */
 {
-			/* regular NULL-terminated string */
+/* regular NULL-terminated string */
-			if (len >= sizeof addr->sun_path) {
+if (len >= sizeof addr->sun_path) {
-				PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-						"AF_UNIX path too long");
+"AF_UNIX path too long");
-				return 0;
+return 0;
-			}
+}
-			addr->sun_path[len] = 0;
+addr->sun_path[len] = 0;
-		}
+}
-		addr->sun_family = s->sock_family;
+addr->sun_family = s->sock_family;
-		memcpy(addr->sun_path, path, len);
+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:
+case AF_NETLINK:
-	{
+{
-		struct sockaddr_nl* addr;
+struct sockaddr_nl* addr;
-		int pid, groups;
+int pid, groups;
-		addr = (struct sockaddr_nl *)addr_ret;
+addr = (struct sockaddr_nl *)addr_ret;
-		if (!PyTuple_Check(args)) {
+if (!PyTuple_Check(args)) {
-			PyErr_Format(
+PyErr_Format(
-				PyExc_TypeError,
+PyExc_TypeError,
-				"getsockaddrarg: "
+"getsockaddrarg: "
-				"AF_NETLINK address must be tuple, not %.500s",
+"AF_NETLINK address must be tuple, not %.500s",
-				Py_TYPE(args)->tp_name);
+Py_TYPE(args)->tp_name);
-			return 0;
+return 0;
-		}
+}
-		if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
+if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
-			return 0;
+return 0;
-		addr->nl_family = AF_NETLINK;
+addr->nl_family = AF_NETLINK;
-		addr->nl_pid = pid;
+addr->nl_pid = pid;
-		addr->nl_groups = groups;
+addr->nl_groups = groups;
-		*len_ret = sizeof(*addr);
+*len_ret = sizeof(*addr);
-		return 1;
+return 1;
-	}
+}
 #endif
-	case AF_INET:
+case AF_INET:
-	{
+{
-		struct sockaddr_in* addr;
+struct sockaddr_in* addr;
-		char *host;
+char *host;
-		int port, result;
+int port, result;
-		if (!PyTuple_Check(args)) {
+if (!PyTuple_Check(args)) {
-			PyErr_Format(
+PyErr_Format(
-				PyExc_TypeError,
+PyExc_TypeError,
-				"getsockaddrarg: "
+"getsockaddrarg: "
-				"AF_INET address must be tuple, not %.500s",
+"AF_INET address must be tuple, not %.500s",
-				Py_TYPE(args)->tp_name);
+Py_TYPE(args)->tp_name);
-			return 0;
+return 0;
-		}
+}
-		if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
+if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
-				      "idna", &host, &port))
+"idna", &host, &port))
-			return 0;
+return 0;
-		addr=(struct sockaddr_in*)addr_ret;
+addr=(struct sockaddr_in*)addr_ret;
 result = setipaddr(host, (struct sockaddr *)addr,
 sizeof(*addr),  AF_INET);
 PyMem_Free(host);
 if (result < 0)
-			return 0;
+return 0;
-		if (port < 0 || port > 0xffff) {
+if (port < 0 || port > 0xffff) {
-			PyErr_SetString(
+PyErr_SetString(
-				PyExc_OverflowError,
+PyExc_OverflowError,
-				"getsockaddrarg: port must be 0-65535.");
+"getsockaddrarg: port must be 0-65535.");
-			return 0;
+return 0;
-		}
+}
-		addr->sin_family = AF_INET;
+addr->sin_family = AF_INET;
-		addr->sin_port = htons((short)port);
+addr->sin_port = htons((short)port);
-		*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-		return 1;
+return 1;
-	}
+}
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-	{
+{
-		struct sockaddr_in6* addr;
+struct sockaddr_in6* addr;
-		char *host;
+char *host;
-		int port, flowinfo, scope_id, result;
+int port, flowinfo, scope_id, result;
-		flowinfo = scope_id = 0;
+flowinfo = scope_id = 0;
-		if (!PyTuple_Check(args)) {
+if (!PyTuple_Check(args)) {
-			PyErr_Format(
+PyErr_Format(
-				PyExc_TypeError,
+PyExc_TypeError,
-				"getsockaddrarg: "
+"getsockaddrarg: "
-				"AF_INET6 address must be tuple, not %.500s",
+"AF_INET6 address must be tuple, not %.500s",
-				Py_TYPE(args)->tp_name);
+Py_TYPE(args)->tp_name);
-			return 0;
+return 0;
-		}
+}
-		if (!PyArg_ParseTuple(args, "eti|ii",
+if (!PyArg_ParseTuple(args, "eti|ii",
-				      "idna", &host, &port, &flowinfo,
+"idna", &host, &port, &flowinfo,
-				      &scope_id)) {
+&scope_id)) {
-			return 0;
+return 0;
-		}
+}
-		addr = (struct sockaddr_in6*)addr_ret;
+addr = (struct sockaddr_in6*)addr_ret;
 result = setipaddr(host, (struct sockaddr *)addr,
 sizeof(*addr), AF_INET6);
 PyMem_Free(host);
 if (result < 0)
-			return 0;
+return 0;
-		if (port < 0 || port > 0xffff) {
+if (port < 0 || port > 0xffff) {
-			PyErr_SetString(
+PyErr_SetString(
-				PyExc_OverflowError,
+PyExc_OverflowError,
-				"getsockaddrarg: port must be 0-65535.");
+"getsockaddrarg: port must be 0-65535.");
-			return 0;
+return 0;
-		}
+}
-		addr->sin6_family = s->sock_family;
+addr->sin6_family = s->sock_family;
-		addr->sin6_port = htons((short)port);
+addr->sin6_port = htons((short)port);
-		addr->sin6_flowinfo = flowinfo;
+addr->sin6_flowinfo = flowinfo;
-		addr->sin6_scope_id = scope_id;
+addr->sin6_scope_id = scope_id;
-		*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-		return 1;
+return 1;
-	}
+}
 #endif
 #ifdef USE_BLUETOOTH
-	case AF_BLUETOOTH:
+case AF_BLUETOOTH:
-	{
+{
-		switch (s->sock_proto) {
+switch (s->sock_proto) {
-		case BTPROTO_L2CAP:
+case BTPROTO_L2CAP:
-		{
+{
-			struct sockaddr_l2 *addr;
+struct sockaddr_l2 *addr;
-			char *straddr;
+char *straddr;
-			addr = (struct sockaddr_l2 *)addr_ret;
+addr = (struct sockaddr_l2 *)addr_ret;
-			memset(addr, 0, sizeof(struct sockaddr_l2));
+memset(addr, 0, sizeof(struct sockaddr_l2));
-			_BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
+_BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
-			if (!PyArg_ParseTuple(args, "si", &straddr,
+if (!PyArg_ParseTuple(args, "si", &straddr,
-					      &_BT_L2_MEMB(addr, psm))) {
+&_BT_L2_MEMB(addr, psm))) {
-				PyErr_SetString(socket_error, "getsockaddrarg: "
+PyErr_SetString(socket_error, "getsockaddrarg: "
-						"wrong format");
+"wrong format");
-				return 0;
+return 0;
-			}
+}
-			if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
+if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
-				return 0;
+return 0;
-			*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-			return 1;
+return 1;
-		}
+}
-		case BTPROTO_RFCOMM:
+case BTPROTO_RFCOMM:
-		{
+{
-			struct sockaddr_rc *addr;
+struct sockaddr_rc *addr;
-			char *straddr;
+char *straddr;
-			addr = (struct sockaddr_rc *)addr_ret;
+addr = (struct sockaddr_rc *)addr_ret;
-			_BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
+_BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
-			if (!PyArg_ParseTuple(args, "si", &straddr,
+if (!PyArg_ParseTuple(args, "si", &straddr,
-					      &_BT_RC_MEMB(addr, channel))) {
+&_BT_RC_MEMB(addr, channel))) {
-				PyErr_SetString(socket_error, "getsockaddrarg: "
+PyErr_SetString(socket_error, "getsockaddrarg: "
-						"wrong format");
+"wrong format");
-				return 0;
+return 0;
-			}
+}
-			if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
+if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
-				return 0;
+return 0;
-			*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-			return 1;
+return 1;
-		}
+}
-		case BTPROTO_HCI:
+case BTPROTO_HCI:
-		{
+{
-			struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
+struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
-			_BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
+_BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
-			if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
+if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
-				PyErr_SetString(socket_error, "getsockaddrarg: "
+PyErr_SetString(socket_error, "getsockaddrarg: "
-						"wrong format");
+"wrong format");
-				return 0;
+return 0;
-			}
+}
-			*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-			return 1;
+return 1;
-		}
+}
 #if !defined(__FreeBSD__)
-		case BTPROTO_SCO:
+case BTPROTO_SCO:
-		{
+{
-			struct sockaddr_sco *addr;
+struct sockaddr_sco *addr;
-			char *straddr;
+char *straddr;
-			addr = (struct sockaddr_sco *)addr_ret;
+addr = (struct sockaddr_sco *)addr_ret;
-			_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
+_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
-			if (!PyBytes_Check(args)) {
+if (!PyBytes_Check(args)) {
-				PyErr_SetString(socket_error, "getsockaddrarg: "
+PyErr_SetString(socket_error, "getsockaddrarg: "
-						"wrong format");
+"wrong format");
-				return 0;
+return 0;
-			}
+}
-			straddr = PyBytes_AS_STRING(args);
+straddr = PyBytes_AS_STRING(args);
-			if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
+if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
-				return 0;
+return 0;
-			*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-			return 1;
+return 1;
-		}
+}
 #endif
-		default:
+default:
-			PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
+PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
-			return 0;
+return 0;
-		}
+}
-	}
+}
 #endif
 #ifdef HAVE_NETPACKET_PACKET_H
-	case AF_PACKET:
+case AF_PACKET:
-	{
+{
-		struct sockaddr_ll* addr;
+struct sockaddr_ll* addr;
-		struct ifreq ifr;
+struct ifreq ifr;
-		char *interfaceName;
+char *interfaceName;
-		int protoNumber;
+int protoNumber;
-		int hatype = 0;
+int hatype = 0;
-		int pkttype = 0;
+int pkttype = 0;
-		char *haddr = NULL;
+char *haddr = NULL;
-		unsigned int halen = 0;
+unsigned int halen = 0;
-		if (!PyTuple_Check(args)) {
+if (!PyTuple_Check(args)) {
-			PyErr_Format(
+PyErr_Format(
-				PyExc_TypeError,
+PyExc_TypeError,
-				"getsockaddrarg: "
+"getsockaddrarg: "
-				"AF_PACKET address must be tuple, not %.500s",
+"AF_PACKET address must be tuple, not %.500s",
-				Py_TYPE(args)->tp_name);
+Py_TYPE(args)->tp_name);
-			return 0;
+return 0;
-		}
+}
-		if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
+if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
-				      &protoNumber, &pkttype, &hatype,
+&protoNumber, &pkttype, &hatype,
-				      &haddr, &halen))
+&haddr, &halen))
-			return 0;
+return 0;
-		strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
+strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
-		ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
+ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
-		if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
+if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
-		        s->errorhandler();
+s->errorhandler();
-			return 0;
+return 0;
-		}
+}
-		if (halen > 8) {
+if (halen > 8) {
-		  PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				  "Hardware address must be 8 bytes or less");
+"Hardware address must be 8 bytes or less");
-		  return 0;
+return 0;
-		}
+}
-		if (protoNumber < 0 || protoNumber > 0xffff) {
+if (protoNumber < 0 || protoNumber > 0xffff) {
-			PyErr_SetString(
+PyErr_SetString(
-				PyExc_OverflowError,
+PyExc_OverflowError,
-				"getsockaddrarg: protoNumber must be 0-65535.");
+"getsockaddrarg: protoNumber must be 0-65535.");
-			return 0;
+return 0;
-		}
+}
-		addr = (struct sockaddr_ll*)addr_ret;
+addr = (struct sockaddr_ll*)addr_ret;
-		addr->sll_family = AF_PACKET;
+addr->sll_family = AF_PACKET;
-		addr->sll_protocol = htons((short)protoNumber);
+addr->sll_protocol = htons((short)protoNumber);
-		addr->sll_ifindex = ifr.ifr_ifindex;
+addr->sll_ifindex = ifr.ifr_ifindex;
-		addr->sll_pkttype = pkttype;
+addr->sll_pkttype = pkttype;
-		addr->sll_hatype = hatype;
+addr->sll_hatype = hatype;
-		if (halen != 0) {
+if (halen != 0) {
-		  memcpy(&addr->sll_addr, haddr, halen);
+memcpy(&addr->sll_addr, haddr, halen);
-		}
+}
-		addr->sll_halen = halen;
+addr->sll_halen = halen;
-		*len_ret = sizeof *addr;
+*len_ret = sizeof *addr;
-		return 1;
+return 1;
-	}
+}
 #endif
 #ifdef HAVE_LINUX_TIPC_H
-	case AF_TIPC:
+case AF_TIPC:
-	{
+{
-		unsigned int atype, v1, v2, v3;
+unsigned int atype, v1, v2, v3;
-		unsigned int scope = TIPC_CLUSTER_SCOPE;
+unsigned int scope = TIPC_CLUSTER_SCOPE;
-		struct sockaddr_tipc *addr;
+struct sockaddr_tipc *addr;
-		if (!PyTuple_Check(args)) {
+if (!PyTuple_Check(args)) {
-			PyErr_Format(
+PyErr_Format(
-				PyExc_TypeError,
+PyExc_TypeError,
-				"getsockaddrarg: "
+"getsockaddrarg: "
-				"AF_TIPC address must be tuple, not %.500s",
+"AF_TIPC address must be tuple, not %.500s",
-				Py_TYPE(args)->tp_name);
+Py_TYPE(args)->tp_name);
-			return 0;
+return 0;
-		}
+}
-		if (!PyArg_ParseTuple(args,
+if (!PyArg_ParseTuple(args,
-					"IIII|I;Invalid TIPC address format",
+"IIII|I;Invalid TIPC address format",
-					&atype, &v1, &v2, &v3, &scope))
+&atype, &v1, &v2, &v3, &scope))
-			return 0;
+return 0;
-		addr = (struct sockaddr_tipc *) addr_ret;
+addr = (struct sockaddr_tipc *) addr_ret;
-		memset(addr, 0, sizeof(struct sockaddr_tipc));
+memset(addr, 0, sizeof(struct sockaddr_tipc));
-		addr->family = AF_TIPC;
+addr->family = AF_TIPC;
-		addr->scope = scope;
+addr->scope = scope;
-		addr->addrtype = atype;
+addr->addrtype = atype;
-		if (atype == TIPC_ADDR_NAMESEQ) {
+if (atype == TIPC_ADDR_NAMESEQ) {
-			addr->addr.nameseq.type = v1;
+addr->addr.nameseq.type = v1;
-			addr->addr.nameseq.lower = v2;
+addr->addr.nameseq.lower = v2;
-			addr->addr.nameseq.upper = v3;
+addr->addr.nameseq.upper = v3;
-		} else if (atype == TIPC_ADDR_NAME) {
+} else if (atype == TIPC_ADDR_NAME) {
-			addr->addr.name.name.type = v1;
+addr->addr.name.name.type = v1;
-			addr->addr.name.name.instance = v2;
+addr->addr.name.name.instance = v2;
-		} else if (atype == TIPC_ADDR_ID) {
+} else if (atype == TIPC_ADDR_ID) {
-			addr->addr.id.node = v1;
+addr->addr.id.node = v1;
-			addr->addr.id.ref = v2;
+addr->addr.id.ref = v2;
-		} else {
+} else {
-			/* Shouldn't happen */
+/* Shouldn't happen */
-			PyErr_SetString(PyExc_TypeError, "Invalid address type");
+PyErr_SetString(PyExc_TypeError, "Invalid address type");
-			return 0;
+return 0;
-		}
+}
-		*len_ret = sizeof(*addr);
+*len_ret = sizeof(*addr);
-		return 1;
+return 1;
-	}
+}
 #endif
-	/* More cases here... */
+/* More cases here... */
-	default:
+default:
-		PyErr_SetString(socket_error, "getsockaddrarg: bad family");
+PyErr_SetString(socket_error, "getsockaddrarg: bad family");
-		return 0;
+return 0;
-	}
+}
 }
 /* Get the address length according to the socket object's address family.
 Return 1 if the family is known, 0 otherwise.  The length is returned
 through len_ret. */
 static int
 getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
 {
-	switch (s->sock_family) {
+switch (s->sock_family) {
 #if defined(AF_UNIX)
-	case AF_UNIX:
+case AF_UNIX:
-	{
+{
-		*len_ret = sizeof (struct sockaddr_un);
+*len_ret = sizeof (struct sockaddr_un);
-		return 1;
+return 1;
-	}
+}
 #endif /* AF_UNIX */
 #if defined(AF_NETLINK)
 case AF_NETLINK:
 {
 *len_ret = sizeof (struct sockaddr_nl);
 return 1;
 }
 #endif
-	case AF_INET:
+case AF_INET:
-	{
+{
-		*len_ret = sizeof (struct sockaddr_in);
+*len_ret = sizeof (struct sockaddr_in);
-		return 1;
+return 1;
-	}
+}
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-	{
+{
-		*len_ret = sizeof (struct sockaddr_in6);
+*len_ret = sizeof (struct sockaddr_in6);
-		return 1;
+return 1;
-	}
+}
 #endif
 #ifdef USE_BLUETOOTH
-	case AF_BLUETOOTH:
+case AF_BLUETOOTH:
-	{
+{
-		switch(s->sock_proto)
+switch(s->sock_proto)
-		{
+{
-		case BTPROTO_L2CAP:
+case BTPROTO_L2CAP:
-			*len_ret = sizeof (struct sockaddr_l2);
+*len_ret = sizeof (struct sockaddr_l2);
-			return 1;
+return 1;
-		case BTPROTO_RFCOMM:
+case BTPROTO_RFCOMM:
-			*len_ret = sizeof (struct sockaddr_rc);
+*len_ret = sizeof (struct sockaddr_rc);
-			return 1;
+return 1;
-		case BTPROTO_HCI:
+case BTPROTO_HCI:
-			*len_ret = sizeof (struct sockaddr_hci);
+*len_ret = sizeof (struct sockaddr_hci);
-			return 1;
+return 1;
 #if !defined(__FreeBSD__)
-		case BTPROTO_SCO:
+case BTPROTO_SCO:
-			*len_ret = sizeof (struct sockaddr_sco);
+*len_ret = sizeof (struct sockaddr_sco);
-			return 1;
+return 1;
 #endif
-		default:
+default:
-			PyErr_SetString(socket_error, "getsockaddrlen: "
+PyErr_SetString(socket_error, "getsockaddrlen: "
-					"unknown BT protocol");
+"unknown BT protocol");
-			return 0;
+return 0;
-		}
+}
-	}
+}
 #endif
 #ifdef HAVE_NETPACKET_PACKET_H
-	case AF_PACKET:
+case AF_PACKET:
-	{
+{
-		*len_ret = sizeof (struct sockaddr_ll);
+*len_ret = sizeof (struct sockaddr_ll);
-		return 1;
+return 1;
-	}
+}
 #endif
 #ifdef HAVE_LINUX_TIPC_H
-	case AF_TIPC:
+case AF_TIPC:
-	{
+{
-		*len_ret = sizeof (struct sockaddr_tipc);
+*len_ret = sizeof (struct sockaddr_tipc);
-		return 1;
+return 1;
-	}
+}
 #endif
-	/* More cases here... */
+/* More cases here... */
-	default:
+default:
-		PyErr_SetString(socket_error, "getsockaddrlen: bad family");
+PyErr_SetString(socket_error, "getsockaddrlen: bad family");
-		return 0;
+return 0;
-	}
+}
 }
 /* s._accept() -> (fd, address) */
 static PyObject *
 sock_accept(PySocketSockObject *s)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	SOCKET_T newfd = INVALID_SOCKET;
+SOCKET_T newfd = INVALID_SOCKET;
-	socklen_t addrlen;
+socklen_t addrlen;
-	PyObject *sock = NULL;
+PyObject *sock = NULL;
-	PyObject *addr = NULL;
+PyObject *addr = NULL;
-	PyObject *res = NULL;
+PyObject *res = NULL;
-	int timeout;
+int timeout;
-	if (!getsockaddrlen(s, &addrlen))
+if (!getsockaddrlen(s, &addrlen))
-		return NULL;
+return NULL;
-	memset(&addrbuf, 0, addrlen);
+memset(&addrbuf, 0, addrlen);
-	if (!IS_SELECTABLE(s))
+if (!IS_SELECTABLE(s))
-		return select_error();
+return select_error();
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	timeout = internal_select(s, 0);
+timeout = internal_select(s, 0);
-	if (!timeout)
+if (!timeout)
-		newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return NULL;
+return NULL;
-	}
+}
-	if (newfd == INVALID_SOCKET)
+if (newfd == INVALID_SOCKET)
-		return s->errorhandler();
+return s->errorhandler();
-	sock = PyLong_FromSocket_t(newfd);
+sock = PyLong_FromSocket_t(newfd);
-	if (sock == NULL) {
+if (sock == NULL) {
-		SOCKETCLOSE(newfd);
+SOCKETCLOSE(newfd);
-		goto finally;
+goto finally;
-	}
+}
-	addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
+addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
-			    addrlen, s->sock_proto);
+addrlen, s->sock_proto);
-	if (addr == NULL)
+if (addr == NULL)
-		goto finally;
+goto finally;
-	res = PyTuple_Pack(2, sock, addr);
+res = PyTuple_Pack(2, sock, addr);
 finally:
-	Py_XDECREF(sock);
+Py_XDECREF(sock);
-	Py_XDECREF(addr);
+Py_XDECREF(addr);
-	return res;
+return res;
 }
 PyDoc_STRVAR(accept_doc,
 "_accept() -> (integer, address info)\n\
 \n\
 */
 static PyObject *
 sock_setblocking(PySocketSockObject *s, PyObject *arg)
 {
-	int block;
+int block;
-	block = PyLong_AsLong(arg);
+block = PyLong_AsLong(arg);
-	if (block == -1 && PyErr_Occurred())
+if (block == -1 && PyErr_Occurred())
-		return NULL;
+return NULL;
-	s->sock_timeout = block ? -1.0 : 0.0;
+s->sock_timeout = block ? -1.0 : 0.0;
-	internal_setblocking(s, block);
+internal_setblocking(s, block);
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(setblocking_doc,
 "setblocking(flag)\n\
 \n\
 < 0  -- illegal; raises an exception
 */
 static PyObject *
 sock_settimeout(PySocketSockObject *s, PyObject *arg)
 {
-	double timeout;
+double timeout;
-	if (arg == Py_None)
+if (arg == Py_None)
-		timeout = -1.0;
+timeout = -1.0;
-	else {
+else {
-		timeout = PyFloat_AsDouble(arg);
+timeout = PyFloat_AsDouble(arg);
-		if (timeout < 0.0) {
+if (timeout < 0.0) {
-			if (!PyErr_Occurred())
+if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-						"Timeout value out of range");
+"Timeout value out of range");
-			return NULL;
+return NULL;
-		}
+}
-	}
+}
-	s->sock_timeout = timeout;
+s->sock_timeout = timeout;
-	internal_setblocking(s, timeout < 0.0);
+internal_setblocking(s, timeout < 0.0);
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(settimeout_doc,
 "settimeout(timeout)\n\
 \n\
 /* s.gettimeout() method.
 Returns the timeout associated with a socket. */
 static PyObject *
 sock_gettimeout(PySocketSockObject *s)
 {
-	if (s->sock_timeout < 0.0) {
+if (s->sock_timeout < 0.0) {
-		Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-		return Py_None;
+return Py_None;
-	}
+}
-	else
+else
-		return PyFloat_FromDouble(s->sock_timeout);
+return PyFloat_FromDouble(s->sock_timeout);
 }
 PyDoc_STRVAR(gettimeout_doc,
 "gettimeout() -> timeout\n\
 \n\
 use optional built-in module 'struct' to encode the string. */
 static PyObject *
 sock_setsockopt(PySocketSockObject *s, PyObject *args)
 {
-	int level;
+int level;
-	int optname;
+int optname;
-	int res;
+int res;
-	char *buf;
+char *buf;
-	int buflen;
+int buflen;
-	int flag;
+int flag;
-	if (PyArg_ParseTuple(args, "iii:setsockopt",
+if (PyArg_ParseTuple(args, "iii:setsockopt",
-			     &level, &optname, &flag)) {
+&level, &optname, &flag)) {
-		buf = (char *) &flag;
+buf = (char *) &flag;
-		buflen = sizeof flag;
+buflen = sizeof flag;
-	}
+}
-	else {
+else {
-		PyErr_Clear();
+PyErr_Clear();
-		if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
+if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
-				      &level, &optname, &buf, &buflen))
+&level, &optname, &buf, &buflen))
-			return NULL;
+return NULL;
-	}
+}
-	res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
+res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(setsockopt_doc,
 "setsockopt(level, option, value)\n\
 \n\
 use optional built-in module 'struct' to decode the string. */
 static PyObject *
 sock_getsockopt(PySocketSockObject *s, PyObject *args)
 {
-	int level;
+int level;
-	int optname;
+int optname;
-	int res;
+int res;
-	PyObject *buf;
+PyObject *buf;
-	socklen_t buflen = 0;
+socklen_t buflen = 0;
-	if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
+if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
-			      &level, &optname, &buflen))
+&level, &optname, &buflen))
-		return NULL;
+return NULL;
-	if (buflen == 0) {
+if (buflen == 0) {
-		int flag = 0;
+int flag = 0;
-		socklen_t flagsize = sizeof flag;
+socklen_t flagsize = sizeof flag;
-		res = getsockopt(s->sock_fd, level, optname,
+res = getsockopt(s->sock_fd, level, optname,
-				 (void *)&flag, &flagsize);
+(void *)&flag, &flagsize);
-		if (res < 0)
+if (res < 0)
-			return s->errorhandler();
+return s->errorhandler();
-		return PyLong_FromLong(flag);
+return PyLong_FromLong(flag);
-	}
+}
 #ifdef __VMS
-	/* socklen_t is unsigned so no negative test is needed,
+/* socklen_t is unsigned so no negative test is needed,
-	   test buflen == 0 is previously done */
+test buflen == 0 is previously done */
-	if (buflen > 1024) {
+if (buflen > 1024) {
 #else
-	if (buflen <= 0 || buflen > 1024) {
+if (buflen <= 0 || buflen > 1024) {
 #endif
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"getsockopt buflen out of range");
+"getsockopt buflen out of range");
-		return NULL;
+return NULL;
-	}
+}
-	buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
+buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
-	if (buf == NULL)
+if (buf == NULL)
-		return NULL;
+return NULL;
-	res = getsockopt(s->sock_fd, level, optname,
+res = getsockopt(s->sock_fd, level, optname,
-			 (void *)PyBytes_AS_STRING(buf), &buflen);
+(void *)PyBytes_AS_STRING(buf), &buflen);
-	if (res < 0) {
+if (res < 0) {
-		Py_DECREF(buf);
+Py_DECREF(buf);
-		return s->errorhandler();
+return s->errorhandler();
-	}
+}
-	_PyBytes_Resize(&buf, buflen);
+_PyBytes_Resize(&buf, buflen);
-	return buf;
+return buf;
 }
 PyDoc_STRVAR(getsockopt_doc,
 "getsockopt(level, option[, buffersize]) -> value\n\
 \n\
 /* s.bind(sockaddr) method */
 static PyObject *
 sock_bind(PySocketSockObject *s, PyObject *addro)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int addrlen;
+int addrlen;
-	int res;
+int res;
-	if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
+res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(bind_doc,
 "bind(address)\n\
 \n\
 will surely fail. */
 static PyObject *
 sock_close(PySocketSockObject *s)
 {
-	SOCKET_T fd;
+SOCKET_T fd;
-	if ((fd = s->sock_fd) != -1) {
+if ((fd = s->sock_fd) != -1) {
-		s->sock_fd = -1;
+s->sock_fd = -1;
-		Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-		(void) SOCKETCLOSE(fd);
+(void) SOCKETCLOSE(fd);
-		Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	}
+}
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(close_doc,
 "close()\n\
 \n\
 Close the socket.  It cannot be used after this call.");
 static int
 internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
-		 int *timeoutp)
+int *timeoutp)
 {
-	int res, timeout;
+int res, timeout;
-	timeout = 0;
+timeout = 0;
-	res = connect(s->sock_fd, addr, addrlen);
+res = connect(s->sock_fd, addr, addrlen);
 #ifdef MS_WINDOWS
-	if (s->sock_timeout > 0.0) {
+if (s->sock_timeout > 0.0) {
-		if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
+if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
-		    IS_SELECTABLE(s)) {
+IS_SELECTABLE(s)) {
-			/* This is a mess.  Best solution: trust select */
+/* This is a mess.  Best solution: trust select */
-			fd_set fds;
+fd_set fds;
-			fd_set fds_exc;
+fd_set fds_exc;
-			struct timeval tv;
+struct timeval tv;
-			tv.tv_sec = (int)s->sock_timeout;
+tv.tv_sec = (int)s->sock_timeout;
-			tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
+tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
-			FD_ZERO(&fds);
+FD_ZERO(&fds);
-			FD_SET(s->sock_fd, &fds);
+FD_SET(s->sock_fd, &fds);
-			FD_ZERO(&fds_exc);
+FD_ZERO(&fds_exc);
-			FD_SET(s->sock_fd, &fds_exc);
+FD_SET(s->sock_fd, &fds_exc);
-			res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
+res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
-			if (res == 0) {
+if (res == 0) {
-				res = WSAEWOULDBLOCK;
+res = WSAEWOULDBLOCK;
-				timeout = 1;
+timeout = 1;
-			} else if (res > 0) {
+} else if (res > 0) {
-				if (FD_ISSET(s->sock_fd, &fds))
+if (FD_ISSET(s->sock_fd, &fds))
-					/* The socket is in the writable set - this
+/* The socket is in the writable set - this
-					   means connected */
+means connected */
-					res = 0;
+res = 0;
-				else {
+else {
-					/* As per MS docs, we need to call getsockopt()
+/* As per MS docs, we need to call getsockopt()
-					   to get the underlying error */
+to get the underlying error */
-					int res_size = sizeof res;
+int res_size = sizeof res;
-					/* It must be in the exception set */
+/* It must be in the exception set */
-					assert(FD_ISSET(s->sock_fd, &fds_exc));
+assert(FD_ISSET(s->sock_fd, &fds_exc));
-					if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
+if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
-					                    (char *)&res, &res_size))
+(char *)&res, &res_size))
-						/* getsockopt also clears WSAGetLastError,
+/* getsockopt also clears WSAGetLastError,
-						   so reset it back. */
+so reset it back. */
-						WSASetLastError(res);
+WSASetLastError(res);
-					else
+else
-						res = WSAGetLastError();
+res = WSAGetLastError();
-				}
+}
-			}
+}
-			/* else if (res < 0) an error occurred */
+/* else if (res < 0) an error occurred */
-		}
+}
-	}
+}
-	if (res < 0)
+if (res < 0)
-		res = WSAGetLastError();
+res = WSAGetLastError();
 #else
-	if (s->sock_timeout > 0.0) {
+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
+else
-				res = EWOULDBLOCK;	/* timed out */
+res = EWOULDBLOCK;                      /* timed out */
-		}
+}
-	}
+}
-	if (res < 0)
+if (res < 0)
-		res = errno;
+res = errno;
 #endif
-	*timeoutp = timeout;
+*timeoutp = timeout;
-	return res;
+return res;
 }
 /* s.connect(sockaddr) method */
 static PyObject *
 sock_connect(PySocketSockObject *s, PyObject *addro)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int addrlen;
+int addrlen;
-	int res;
+int res;
-	int timeout;
+int timeout;
-	if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
+res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return NULL;
+return NULL;
-	}
+}
-	if (res != 0)
+if (res != 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(connect_doc,
 "connect(address)\n\
 \n\
 /* s.connect_ex(sockaddr) method */
 static PyObject *
 sock_connect_ex(PySocketSockObject *s, PyObject *addro)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int addrlen;
+int addrlen;
-	int res;
+int res;
-	int timeout;
+int timeout;
-	if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
+if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
+res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	/* Signals are not errors (though they may raise exceptions).  Adapted
+/* Signals are not errors (though they may raise exceptions).  Adapted
-	   from PyErr_SetFromErrnoWithFilenameObject(). */
+from PyErr_SetFromErrnoWithFilenameObject(). */
 #ifdef EINTR
-	if (res == EINTR && PyErr_CheckSignals())
+if (res == EINTR && PyErr_CheckSignals())
-		return NULL;
+return NULL;
 #endif
-	return PyLong_FromLong((long) res);
+return PyLong_FromLong((long) res);
 }
 PyDoc_STRVAR(connect_ex_doc,
 "connect_ex(address) -> errno\n\
 \n\
 /* s.fileno() method */
 static PyObject *
 sock_fileno(PySocketSockObject *s)
 {
-	return PyLong_FromSocket_t(s->sock_fd);
+return PyLong_FromSocket_t(s->sock_fd);
 }
 PyDoc_STRVAR(fileno_doc,
 "fileno() -> integer\n\
 \n\
 /* s.getsockname() method */
 static PyObject *
 sock_getsockname(PySocketSockObject *s)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int res;
+int res;
-	socklen_t addrlen;
+socklen_t addrlen;
-	if (!getsockaddrlen(s, &addrlen))
+if (!getsockaddrlen(s, &addrlen))
-		return NULL;
+return NULL;
-	memset(&addrbuf, 0, addrlen);
+memset(&addrbuf, 0, addrlen);
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
+return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
-			    s->sock_proto);
+s->sock_proto);
 }
 PyDoc_STRVAR(getsockname_doc,
 "getsockname() -> address info\n\
 \n\
 Return the address of the local endpoint.  For IP sockets, the address\n\
 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;
+sock_addr_t addrbuf;
-	int res;
+int res;
-	socklen_t addrlen;
+socklen_t addrlen;
-	if (!getsockaddrlen(s, &addrlen))
+if (!getsockaddrlen(s, &addrlen))
-		return NULL;
+return NULL;
-	memset(&addrbuf, 0, addrlen);
+memset(&addrbuf, 0, addrlen);
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
+res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
+return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
-			    s->sock_proto);
+s->sock_proto);
 }
 PyDoc_STRVAR(getpeername_doc,
 "getpeername() -> address info\n\
 \n\
 /* s.listen(n) method */
 static PyObject *
 sock_listen(PySocketSockObject *s, PyObject *arg)
 {
-	int backlog;
+int backlog;
-	int res;
+int res;
-	backlog = PyLong_AsLong(arg);
+backlog = PyLong_AsLong(arg);
-	if (backlog == -1 && PyErr_Occurred())
+if (backlog == -1 && PyErr_Occurred())
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	if (backlog < 1)
+if (backlog < 1)
-		backlog = 1;
+backlog = 1;
-	res = listen(s->sock_fd, backlog);
+res = listen(s->sock_fd, backlog);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(listen_doc,
 "listen(backlog)\n\
 \n\
 * bytes.
 */
 static ssize_t
 sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags)
 {
 ssize_t outlen = -1;
 int timeout;
 #ifdef __VMS
-	int remaining;
+int remaining;
-	char *read_buf;
+char *read_buf;
 #endif
-	if (!IS_SELECTABLE(s)) {
+if (!IS_SELECTABLE(s)) {
-		select_error();
+select_error();
-		return -1;
+return -1;
-	}
+}
 if (len == 0) {
-		/* If 0 bytes were requested, do nothing. */
+/* If 0 bytes were requested, do nothing. */
-		return 0;
+return 0;
-	}
+}
 #ifndef __VMS
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	timeout = internal_select(s, 0);
+timeout = internal_select(s, 0);
-	if (!timeout)
+if (!timeout)
-		outlen = recv(s->sock_fd, cbuf, len, flags);
+outlen = recv(s->sock_fd, cbuf, len, flags);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return -1;
+return -1;
-	}
+}
-	if (outlen < 0) {
+if (outlen < 0) {
-		/* Note: the call to errorhandler() ALWAYS indirectly returned
+/* Note: the call to errorhandler() ALWAYS indirectly returned
-		   NULL, so ignore its return value */
+NULL, so ignore its return value */
-		s->errorhandler();
+s->errorhandler();
-		return -1;
+return -1;
-	}
+}
 #else
-	read_buf = cbuf;
+read_buf = cbuf;
-	remaining = len;
+remaining = len;
-	while (remaining != 0) {
+while (remaining != 0) {
-		unsigned int segment;
+unsigned int segment;
-		int nread = -1;
+int nread = -1;
-		segment = remaining /SEGMENT_SIZE;
+segment = remaining /SEGMENT_SIZE;
-		if (segment != 0) {
+if (segment != 0) {
-			segment = SEGMENT_SIZE;
+segment = SEGMENT_SIZE;
-		}
+}
-		else {
+else {
-			segment = remaining;
+segment = remaining;
-		}
+}
-		Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-		timeout = internal_select(s, 0);
+timeout = internal_select(s, 0);
-		if (!timeout)
+if (!timeout)
-			nread = recv(s->sock_fd, read_buf, segment, flags);
+nread = recv(s->sock_fd, read_buf, segment, flags);
-		Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-		if (timeout == 1) {
+if (timeout == 1) {
-			PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-			return -1;
+return -1;
-		}
+}
-		if (nread < 0) {
+if (nread < 0) {
-			s->errorhandler();
+s->errorhandler();
-			return -1;
+return -1;
-		}
+}
-		if (nread != remaining) {
+if (nread != remaining) {
-			read_buf += nread;
+read_buf += nread;
-			break;
+break;
-		}
+}
-		remaining -= segment;
+remaining -= segment;
-		read_buf += segment;
+read_buf += segment;
-	}
+}
-	outlen = read_buf - cbuf;
+outlen = read_buf - cbuf;
 #endif /* !__VMS */
-	return outlen;
+return outlen;
 }
 /* s.recv(nbytes [,flags]) method */
 static PyObject *
 sock_recv(PySocketSockObject *s, PyObject *args)
 {
-	int recvlen, flags = 0;
+int recvlen, flags = 0;
 ssize_t outlen;
-	PyObject *buf;
+PyObject *buf;
-	if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
+if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
-		return NULL;
+return NULL;
-	if (recvlen < 0) {
+if (recvlen < 0) {
-		PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"negative buffersize in recv");
+"negative buffersize in recv");
-		return NULL;
+return NULL;
-	}
+}
-	/* Allocate a new string. */
+/* Allocate a new string. */
-	buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
-	if (buf == NULL)
+if (buf == NULL)
-		return NULL;
+return NULL;
-	/* Call the guts */
+/* Call the guts */
-	outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
+outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
-	if (outlen < 0) {
+if (outlen < 0) {
-		/* An error occurred, release the string and return an
+/* An error occurred, release the string and return an
-		   error. */
+error. */
-		Py_DECREF(buf);
+Py_DECREF(buf);
-		return NULL;
+return NULL;
-	}
+}
-	if (outlen != recvlen) {
+if (outlen != recvlen) {
-		/* We did not read as many bytes as we anticipated, resize the
+/* We did not read as many bytes as we anticipated, resize the
-		   string if possible and be successful. */
+string if possible and be successful. */
-		_PyBytes_Resize(&buf, outlen);
+_PyBytes_Resize(&buf, outlen);
-	}
+}
-	return buf;
+return buf;
 }
 PyDoc_STRVAR(recv_doc,
 "recv(buffersize[, flags]) -> data\n\
 \n\
 /* s.recv_into(buffer, [nbytes [,flags]]) method */
 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;
+int recvlen = 0, flags = 0;
 ssize_t readlen;
-	Py_buffer pbuf;
+Py_buffer pbuf;
-	char *buf;
+char *buf;
-	int buflen;
+int buflen;
-	/* Get the buffer's memory */
+/* Get the buffer's memory */
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,
+if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,
-					 &pbuf, &recvlen, &flags))
+&pbuf, &recvlen, &flags))
-		return NULL;
+return NULL;
-	buf = pbuf.buf;
+buf = pbuf.buf;
-	buflen = pbuf.len;
+buflen = pbuf.len;
-	if (recvlen < 0) {
+if (recvlen < 0) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"negative buffersize in recv_into");
+"negative buffersize in recv_into");
-		return NULL;
+return NULL;
-	}
+}
-	if (recvlen == 0) {
+if (recvlen == 0) {
 /* If nbytes was not specified, use the buffer's length */
 recvlen = buflen;
-	}
+}
-	/* Check if the buffer is large enough */
+/* Check if the buffer is large enough */
-	if (buflen < recvlen) {
+if (buflen < recvlen) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"buffer too small for requested bytes");
+"buffer too small for requested bytes");
-		return NULL;
+return NULL;
-	}
+}
-	/* Call the guts */
+/* Call the guts */
-	readlen = sock_recv_guts(s, buf, recvlen, flags);
+readlen = sock_recv_guts(s, buf, recvlen, flags);
-	if (readlen < 0) {
+if (readlen < 0) {
-		/* Return an error. */
+/* Return an error. */
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		return NULL;
+return NULL;
-	}
+}
-	PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-	/* Return the number of bytes read.  Note that we do not do anything
+/* Return the number of bytes read.  Note that we do not do anything
-	   special here in the case that readlen < recvlen. */
+special here in the case that readlen < recvlen. */
-	return PyLong_FromSsize_t(readlen);
+return PyLong_FromSsize_t(readlen);
 }
 PyDoc_STRVAR(recv_into_doc,
 "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
 \n\
 * 'addr' is a return value for the address object.  Note that you must decref
 * it yourself.
 */
 static ssize_t
 sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags,
-		   PyObject** addr)
+PyObject** addr)
 {
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int timeout;
+int timeout;
-	ssize_t n = -1;
+ssize_t n = -1;
-	socklen_t addrlen;
+socklen_t addrlen;
-	*addr = NULL;
+*addr = NULL;
-	if (!getsockaddrlen(s, &addrlen))
+if (!getsockaddrlen(s, &addrlen))
-		return -1;
+return -1;
-	if (!IS_SELECTABLE(s)) {
+if (!IS_SELECTABLE(s)) {
-		select_error();
+select_error();
-		return -1;
+return -1;
-	}
+}
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	memset(&addrbuf, 0, addrlen);
+memset(&addrbuf, 0, addrlen);
-	timeout = internal_select(s, 0);
+timeout = internal_select(s, 0);
-	if (!timeout) {
+if (!timeout) {
 #ifndef MS_WINDOWS
 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
-		n = recvfrom(s->sock_fd, cbuf, len, flags,
+n = recvfrom(s->sock_fd, cbuf, len, flags,
-			     SAS2SA(&addrbuf), &addrlen);
+SAS2SA(&addrbuf), &addrlen);
 #else
-		n = recvfrom(s->sock_fd, cbuf, len, flags,
+n = recvfrom(s->sock_fd, cbuf, len, flags,
-			     (void *) &addrbuf, &addrlen);
+(void *) &addrbuf, &addrlen);
 #endif
 #else
-		n = recvfrom(s->sock_fd, cbuf, len, flags,
+n = recvfrom(s->sock_fd, cbuf, len, flags,
-			     SAS2SA(&addrbuf), &addrlen);
+SAS2SA(&addrbuf), &addrlen);
 #endif
-	}
+}
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return -1;
+return -1;
-	}
+}
-	if (n < 0) {
+if (n < 0) {
-		s->errorhandler();
+s->errorhandler();
 return -1;
-	}
+}
-	if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
+if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
-				   addrlen, s->sock_proto)))
+addrlen, s->sock_proto)))
-		return -1;
+return -1;
-	return n;
+return n;
 }
 /* s.recvfrom(nbytes [,flags]) method */
 static PyObject *
 sock_recvfrom(PySocketSockObject *s, PyObject *args)
 {
-	PyObject *buf = NULL;
+PyObject *buf = NULL;
-	PyObject *addr = NULL;
+PyObject *addr = NULL;
-	PyObject *ret = NULL;
+PyObject *ret = NULL;
-	int recvlen, flags = 0;
+int recvlen, flags = 0;
 ssize_t outlen;
-	if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
+if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
-		return NULL;
+return NULL;
-	if (recvlen < 0) {
+if (recvlen < 0) {
-		PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"negative buffersize in recvfrom");
+"negative buffersize in recvfrom");
-		return NULL;
+return NULL;
-	}
+}
-	buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
+buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
-	if (buf == NULL)
+if (buf == NULL)
-		return NULL;
+return NULL;
-	outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
+outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
-				    recvlen, flags, &addr);
+recvlen, flags, &addr);
-	if (outlen < 0) {
+if (outlen < 0) {
-		goto finally;
+goto finally;
-	}
+}
-	if (outlen != recvlen) {
+if (outlen != recvlen) {
-		/* We did not read as many bytes as we anticipated, resize the
+/* We did not read as many bytes as we anticipated, resize the
-		   string if possible and be succesful. */
+string if possible and be succesful. */
-		if (_PyBytes_Resize(&buf, outlen) < 0)
+if (_PyBytes_Resize(&buf, outlen) < 0)
-			/* Oopsy, not so succesful after all. */
+/* Oopsy, not so succesful after all. */
-			goto finally;
+goto finally;
-	}
+}
-	ret = PyTuple_Pack(2, buf, addr);
+ret = PyTuple_Pack(2, buf, addr);
 finally:
-	Py_XDECREF(buf);
+Py_XDECREF(buf);
-	Py_XDECREF(addr);
+Py_XDECREF(addr);
-	return ret;
+return ret;
 }
 PyDoc_STRVAR(recvfrom_doc,
 "recvfrom(buffersize[, flags]) -> (data, address info)\n\
 \n\
 /* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
 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;
+int recvlen = 0, flags = 0;
 ssize_t readlen;
-	Py_buffer pbuf;
+Py_buffer pbuf;
-	char *buf;
+char *buf;
-	int buflen;
+int buflen;
-	PyObject *addr = NULL;
+PyObject *addr = NULL;
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",
+if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",
-					 kwlist, &pbuf,
+kwlist, &pbuf,
-					 &recvlen, &flags))
+&recvlen, &flags))
-		return NULL;
+return NULL;
-	buf = pbuf.buf;
+buf = pbuf.buf;
-	buflen = pbuf.len;
+buflen = pbuf.len;
-	assert(buf != 0 && buflen > 0);
+assert(buf != 0 && buflen > 0);
-	if (recvlen < 0) {
+if (recvlen < 0) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"negative buffersize in recvfrom_into");
+"negative buffersize in recvfrom_into");
-		return NULL;
+return NULL;
-	}
+}
-	if (recvlen == 0) {
+if (recvlen == 0) {
 /* If nbytes was not specified, use the buffer's length */
 recvlen = buflen;
-	}
+}
-	readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
+readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
-	if (readlen < 0) {
+if (readlen < 0) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		/* Return an error */
+/* Return an error */
-		Py_XDECREF(addr);
+Py_XDECREF(addr);
-		return NULL;
+return NULL;
-	}
+}
-	PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-	/* Return the number of bytes read and the address.  Note that we do
+/* Return the number of bytes read and the address.  Note that we do
-	   not do anything special here in the case that readlen < recvlen. */
+not do anything special here in the case that readlen < recvlen. */
-	return Py_BuildValue("lN", readlen, addr);
+return Py_BuildValue("lN", readlen, addr);
 }
 PyDoc_STRVAR(recvfrom_into_doc,
 "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
 \n\
 /* s.send(data [,flags]) method */
 static PyObject *
 sock_send(PySocketSockObject *s, PyObject *args)
 {
-	char *buf;
+char *buf;
-	int len, n = -1, flags = 0, timeout;
+int len, n = -1, flags = 0, timeout;
-	Py_buffer pbuf;
+Py_buffer pbuf;
-	if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
+if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
-		return NULL;
+return NULL;
-	if (!IS_SELECTABLE(s)) {
+if (!IS_SELECTABLE(s)) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		return select_error();
+return select_error();
-	}
+}
-	buf = pbuf.buf;
+buf = pbuf.buf;
-	len = pbuf.len;
+len = pbuf.len;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	timeout = internal_select(s, 1);
+timeout = internal_select(s, 1);
-	if (!timeout)
+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) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return NULL;
+return NULL;
-	}
+}
-	if (n < 0)
+if (n < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	return PyLong_FromLong((long)n);
+return PyLong_FromLong((long)n);
 }
 PyDoc_STRVAR(send_doc,
 "send(data[, flags]) -> count\n\
 \n\
 /* s.sendall(data [,flags]) method */
 static PyObject *
 sock_sendall(PySocketSockObject *s, PyObject *args)
 {
-	char *buf;
+char *buf;
-	int len, n = -1, flags = 0, timeout;
+int len, n = -1, flags = 0, timeout;
-	Py_buffer pbuf;
+Py_buffer pbuf;
-	if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
+if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
-		return NULL;
+return NULL;
-	buf = pbuf.buf;
+buf = pbuf.buf;
-	len = pbuf.len;
+len = pbuf.len;
-	if (!IS_SELECTABLE(s)) {
+if (!IS_SELECTABLE(s)) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		return select_error();
+return select_error();
-	}
+}
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	do {
+do {
-		timeout = internal_select(s, 1);
+timeout = internal_select(s, 1);
-		n = -1;
+n = -1;
-		if (timeout)
+if (timeout)
-			break;
+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)
-			break;
+break;
-		buf += n;
+buf += n;
-		len -= n;
+len -= n;
-	} while (len > 0);
+} while (len > 0);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return NULL;
+return NULL;
-	}
+}
-	if (n < 0)
+if (n < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(sendall_doc,
 "sendall(data[, flags])\n\
 \n\
 /* s.sendto(data, [flags,] sockaddr) method */
 static PyObject *
 sock_sendto(PySocketSockObject *s, PyObject *args)
 {
-	Py_buffer pbuf;
+Py_buffer pbuf;
-	PyObject *addro;
+PyObject *addro;
-	char *buf;
+char *buf;
-	Py_ssize_t len;
+Py_ssize_t len;
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	int addrlen, n = -1, flags, timeout;
+int addrlen, n = -1, flags, timeout;
-	flags = 0;
+flags = 0;
-	if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
+if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
-		PyErr_Clear();
+PyErr_Clear();
-		if (!PyArg_ParseTuple(args, "y*iO:sendto",
+if (!PyArg_ParseTuple(args, "y*iO:sendto",
-				      &pbuf, &flags, &addro))
+&pbuf, &flags, &addro))
-			return NULL;
+return NULL;
-	}
+}
-	buf = pbuf.buf;
+buf = pbuf.buf;
-	len = pbuf.len;
+len = pbuf.len;
-	if (!IS_SELECTABLE(s)) {
+if (!IS_SELECTABLE(s)) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		return select_error();
+return select_error();
-	}
+}
-	if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
+if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
-		PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-		return NULL;
+return NULL;
-	}
+}
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	timeout = internal_select(s, 1);
+timeout = internal_select(s, 1);
-	if (!timeout)
+if (!timeout)
-		n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
+n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	PyBuffer_Release(&pbuf);
+PyBuffer_Release(&pbuf);
-	if (timeout == 1) {
+if (timeout == 1) {
-		PyErr_SetString(socket_timeout, "timed out");
+PyErr_SetString(socket_timeout, "timed out");
-		return NULL;
+return NULL;
-	}
+}
-	if (n < 0)
+if (n < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	return PyLong_FromLong((long)n);
+return PyLong_FromLong((long)n);
 }
 PyDoc_STRVAR(sendto_doc,
 "sendto(data[, flags], address) -> count\n\
 \n\
 /* s.shutdown(how) method */
 static PyObject *
 sock_shutdown(PySocketSockObject *s, PyObject *arg)
 {
-	int how;
+int how;
-	int res;
+int res;
-	how = PyLong_AsLong(arg);
+how = PyLong_AsLong(arg);
-	if (how == -1 && PyErr_Occurred())
+if (how == -1 && PyErr_Occurred())
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = shutdown(s->sock_fd, how);
+res = shutdown(s->sock_fd, how);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return s->errorhandler();
+return s->errorhandler();
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(shutdown_doc,
 "shutdown(flag)\n\
 \n\
 #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
 static PyObject*
 sock_ioctl(PySocketSockObject *s, PyObject *arg)
 {
-	unsigned long cmd = SIO_RCVALL;
+unsigned long cmd = SIO_RCVALL;
-	unsigned int option = RCVALL_ON;
+unsigned int option = RCVALL_ON;
 DWORD recv;
-	if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
+if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
-		return NULL;
+return NULL;
-	if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
+if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
-		     NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
+NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
-		return set_error();
+return set_error();
-	}
+}
-	return PyLong_FromUnsignedLong(recv);
+return PyLong_FromUnsignedLong(recv);
 }
 PyDoc_STRVAR(sock_ioctl_doc,
 "ioctl(cmd, option) -> long\n\
 \n\
 Control the socket with WSAIoctl syscall. Currently only socket.SIO_RCVALL\n\
 #endif
 /* List of methods for socket objects */
 static PyMethodDef sock_methods[] = {
-	{"_accept",	  (PyCFunction)sock_accept, METH_NOARGS,
+{"_accept",           (PyCFunction)sock_accept, METH_NOARGS,
-			  accept_doc},
+accept_doc},
-	{"bind",	  (PyCFunction)sock_bind, METH_O,
+{"bind",              (PyCFunction)sock_bind, METH_O,
-			  bind_doc},
+bind_doc},
-	{"close",	  (PyCFunction)sock_close, METH_NOARGS,
+{"close",             (PyCFunction)sock_close, METH_NOARGS,
-			  close_doc},
+close_doc},
-	{"connect",	  (PyCFunction)sock_connect, METH_O,
+{"connect",           (PyCFunction)sock_connect, METH_O,
-			  connect_doc},
+connect_doc},
-	{"connect_ex",	  (PyCFunction)sock_connect_ex, METH_O,
+{"connect_ex",        (PyCFunction)sock_connect_ex, METH_O,
-			  connect_ex_doc},
+connect_ex_doc},
-	{"fileno",	  (PyCFunction)sock_fileno, METH_NOARGS,
+{"fileno",            (PyCFunction)sock_fileno, METH_NOARGS,
-			  fileno_doc},
+fileno_doc},
 #ifdef HAVE_GETPEERNAME
-	{"getpeername",	  (PyCFunction)sock_getpeername,
+{"getpeername",       (PyCFunction)sock_getpeername,
-			  METH_NOARGS, getpeername_doc},
+METH_NOARGS, getpeername_doc},
 #endif
-	{"getsockname",	  (PyCFunction)sock_getsockname,
+{"getsockname",       (PyCFunction)sock_getsockname,
-			  METH_NOARGS, getsockname_doc},
+METH_NOARGS, getsockname_doc},
-	{"getsockopt",	  (PyCFunction)sock_getsockopt, METH_VARARGS,
+{"getsockopt",        (PyCFunction)sock_getsockopt, METH_VARARGS,
-			  getsockopt_doc},
+getsockopt_doc},
 #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
-	{"ioctl",	  (PyCFunction)sock_ioctl, METH_VARARGS,
+{"ioctl",             (PyCFunction)sock_ioctl, METH_VARARGS,
-			  sock_ioctl_doc},
+sock_ioctl_doc},
 #endif
-	{"listen",	  (PyCFunction)sock_listen, METH_O,
+{"listen",            (PyCFunction)sock_listen, METH_O,
-			  listen_doc},
+listen_doc},
-	{"recv",	  (PyCFunction)sock_recv, METH_VARARGS,
+{"recv",              (PyCFunction)sock_recv, METH_VARARGS,
-			  recv_doc},
+recv_doc},
-	{"recv_into",	  (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
+{"recv_into",         (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
-			  recv_into_doc},
+recv_into_doc},
-	{"recvfrom",	  (PyCFunction)sock_recvfrom, METH_VARARGS,
+{"recvfrom",          (PyCFunction)sock_recvfrom, METH_VARARGS,
-			  recvfrom_doc},
+recvfrom_doc},
-	{"recvfrom_into",  (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
+{"recvfrom_into",  (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
-			  recvfrom_into_doc},
+recvfrom_into_doc},
-	{"send",	  (PyCFunction)sock_send, METH_VARARGS,
+{"send",              (PyCFunction)sock_send, METH_VARARGS,
-			  send_doc},
+send_doc},
-	{"sendall",	  (PyCFunction)sock_sendall, METH_VARARGS,
+{"sendall",           (PyCFunction)sock_sendall, METH_VARARGS,
-			  sendall_doc},
+sendall_doc},
-	{"sendto",	  (PyCFunction)sock_sendto, METH_VARARGS,
+{"sendto",            (PyCFunction)sock_sendto, METH_VARARGS,
-			  sendto_doc},
+sendto_doc},
-	{"setblocking",	  (PyCFunction)sock_setblocking, METH_O,
+{"setblocking",       (PyCFunction)sock_setblocking, METH_O,
-			  setblocking_doc},
+setblocking_doc},
-	{"settimeout",    (PyCFunction)sock_settimeout, METH_O,
+{"settimeout",    (PyCFunction)sock_settimeout, METH_O,
-			  settimeout_doc},
+settimeout_doc},
-	{"gettimeout",    (PyCFunction)sock_gettimeout, METH_NOARGS,
+{"gettimeout",    (PyCFunction)sock_gettimeout, METH_NOARGS,
-			  gettimeout_doc},
+gettimeout_doc},
-	{"setsockopt",	  (PyCFunction)sock_setsockopt, METH_VARARGS,
+{"setsockopt",        (PyCFunction)sock_setsockopt, METH_VARARGS,
-			  setsockopt_doc},
+setsockopt_doc},
-	{"shutdown",	  (PyCFunction)sock_shutdown, METH_O,
+{"shutdown",          (PyCFunction)sock_shutdown, METH_O,
-			  shutdown_doc},
+shutdown_doc},
-	{NULL,			NULL}		/* sentinel */
+{NULL,                      NULL}           /* sentinel */
 };
 /* SockObject members */
 static PyMemberDef sock_memberlist[] = {
 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
 First close the file description. */
 static void
 sock_dealloc(PySocketSockObject *s)
 {
-	if (s->sock_fd != -1)
+if (s->sock_fd != -1)
-		(void) SOCKETCLOSE(s->sock_fd);
+(void) SOCKETCLOSE(s->sock_fd);
-	Py_TYPE(s)->tp_free((PyObject *)s);
+Py_TYPE(s)->tp_free((PyObject *)s);
 }
 static PyObject *
 sock_repr(PySocketSockObject *s)
 {
 #if SIZEOF_SOCKET_T > SIZEOF_LONG
-	if (s->sock_fd > LONG_MAX) {
+if (s->sock_fd > LONG_MAX) {
-		/* this can occur on Win64, and actually there is a special
+/* this can occur on Win64, and actually there is a special
-		   ugly printf formatter for decimal pointer length integer
+ugly printf formatter for decimal pointer length integer
-		   printing, only bother if necessary*/
+printing, only bother if necessary*/
-		PyErr_SetString(PyExc_OverflowError,
+PyErr_SetString(PyExc_OverflowError,
-				"no printf formatter to display "
+"no printf formatter to display "
-				"the socket descriptor in decimal");
+"the socket descriptor in decimal");
-		return NULL;
+return NULL;
-	}
+}
 #endif
-	return PyUnicode_FromFormat(
+return PyUnicode_FromFormat(
-		"<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
+"<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
-		(long)s->sock_fd, s->sock_family,
+(long)s->sock_fd, s->sock_family,
-		s->sock_type,
+s->sock_type,
-		s->sock_proto);
+s->sock_proto);
 }
 /* Create a new, uninitialized socket object. */
 static PyObject *
 sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-	PyObject *new;
+PyObject *new;
-	new = type->tp_alloc(type, 0);
+new = type->tp_alloc(type, 0);
-	if (new != NULL) {
+if (new != NULL) {
-		((PySocketSockObject *)new)->sock_fd = -1;
+((PySocketSockObject *)new)->sock_fd = -1;
-		((PySocketSockObject *)new)->sock_timeout = -1.0;
+((PySocketSockObject *)new)->sock_timeout = -1.0;
-		((PySocketSockObject *)new)->errorhandler = &set_error;
+((PySocketSockObject *)new)->errorhandler = &set_error;
-	}
+}
-	return new;
+return new;
 }
 /* Initialize a new socket object. */
 /*ARGSUSED*/
 static int
 sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	PySocketSockObject *s = (PySocketSockObject *)self;
+PySocketSockObject *s = (PySocketSockObject *)self;
-	PyObject *fdobj = NULL;
+PyObject *fdobj = NULL;
-	SOCKET_T fd = INVALID_SOCKET;
+SOCKET_T fd = INVALID_SOCKET;
-	int family = AF_INET, type = SOCK_STREAM, proto = 0;
+int family = AF_INET, type = SOCK_STREAM, proto = 0;
-	static char *keywords[] = {"family", "type", "proto", "fileno", 0};
+static char *keywords[] = {"family", "type", "proto", "fileno", 0};
-	if (!PyArg_ParseTupleAndKeywords(args, kwds,
+if (!PyArg_ParseTupleAndKeywords(args, kwds,
-					 "|iiiO:socket", keywords,
+"|iiiO:socket", keywords,
-					 &family, &type, &proto, &fdobj))
+&family, &type, &proto, &fdobj))
-		return -1;
+return -1;
-	if (fdobj != NULL && fdobj != Py_None) {
+if (fdobj != NULL && fdobj != Py_None) {
-		fd = PyLong_AsSocket_t(fdobj);
+fd = PyLong_AsSocket_t(fdobj);
-		if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
+if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
-			return -1;
+return -1;
-		if (fd == INVALID_SOCKET) {
+if (fd == INVALID_SOCKET) {
-			PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-					"can't use invalid socket value");
+"can't use invalid socket value");
-			return -1;
+return -1;
-		}
+}
-	}
+}
-	else {
+else {
-		Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-		fd = socket(family, type, proto);
+fd = socket(family, type, proto);
-		Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-		if (fd == INVALID_SOCKET) {
+if (fd == INVALID_SOCKET) {
-			set_error();
+set_error();
-			return -1;
+return -1;
-		}
+}
-	}
+}
-	init_sockobject(s, fd, family, type, proto);
+init_sockobject(s, fd, family, type, proto);
-	return 0;
+return 0;
 }
 /* Type object for socket objects. */
 static PyTypeObject sock_type = {
-	PyVarObject_HEAD_INIT(0, 0)	/* Must fill in type value later */
+PyVarObject_HEAD_INIT(0, 0)         /* Must fill in type value later */
-	"_socket.socket",			/* tp_name */
+"_socket.socket",                           /* tp_name */
-	sizeof(PySocketSockObject),		/* tp_basicsize */
+sizeof(PySocketSockObject),                 /* tp_basicsize */
-	0,					/* tp_itemsize */
+0,                                          /* tp_itemsize */
-	(destructor)sock_dealloc,		/* tp_dealloc */
+(destructor)sock_dealloc,                   /* tp_dealloc */
-	0,					/* tp_print */
+0,                                          /* tp_print */
-	0,					/* tp_getattr */
+0,                                          /* tp_getattr */
-	0,					/* tp_setattr */
+0,                                          /* tp_setattr */
-	0,					/* tp_reserved */
+0,                                          /* tp_reserved */
-	(reprfunc)sock_repr,			/* tp_repr */
+(reprfunc)sock_repr,                        /* tp_repr */
-	0,					/* tp_as_number */
+0,                                          /* tp_as_number */
-	0,					/* tp_as_sequence */
+0,                                          /* tp_as_sequence */
-	0,					/* tp_as_mapping */
+0,                                          /* tp_as_mapping */
-	0,					/* tp_hash */
+0,                                          /* tp_hash */
-	0,					/* tp_call */
+0,                                          /* tp_call */
-	0,					/* tp_str */
+0,                                          /* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
+PyObject_GenericGetAttr,                    /* tp_getattro */
-	0,					/* tp_setattro */
+0,                                          /* tp_setattro */
-	0,					/* tp_as_buffer */
+0,                                          /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	sock_doc,				/* tp_doc */
+sock_doc,                                   /* tp_doc */
-	0,					/* tp_traverse */
+0,                                          /* tp_traverse */
-	0,					/* tp_clear */
+0,                                          /* tp_clear */
-	0,					/* tp_richcompare */
+0,                                          /* tp_richcompare */
-	0,					/* tp_weaklistoffset */
+0,                                          /* tp_weaklistoffset */
-	0,					/* tp_iter */
+0,                                          /* tp_iter */
-	0,					/* tp_iternext */
+0,                                          /* tp_iternext */
-	sock_methods,				/* tp_methods */
+sock_methods,                               /* tp_methods */
-	sock_memberlist,			/* tp_members */
+sock_memberlist,                            /* tp_members */
-	0,					/* tp_getset */
+0,                                          /* tp_getset */
-	0,					/* tp_base */
+0,                                          /* tp_base */
-	0,					/* tp_dict */
+0,                                          /* tp_dict */
-	0,					/* tp_descr_get */
+0,                                          /* tp_descr_get */
-	0,					/* tp_descr_set */
+0,                                          /* tp_descr_set */
-	0,					/* tp_dictoffset */
+0,                                          /* tp_dictoffset */
-	sock_initobj,				/* tp_init */
+sock_initobj,                               /* tp_init */
-	PyType_GenericAlloc,			/* tp_alloc */
+PyType_GenericAlloc,                        /* tp_alloc */
-	sock_new,				/* tp_new */
+sock_new,                                   /* tp_new */
-	PyObject_Del,				/* tp_free */
+PyObject_Del,                               /* tp_free */
 };
 /* Python interface to gethostname(). */
 /*ARGSUSED*/
 static PyObject *
 socket_gethostname(PyObject *self, PyObject *unused)
 {
-	char buf[1024];
+char buf[1024];
-	int res;
+int res;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	res = gethostname(buf, (int) sizeof buf - 1);
+res = gethostname(buf, (int) sizeof buf - 1);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (res < 0)
+if (res < 0)
-		return set_error();
+return set_error();
-	buf[sizeof buf - 1] = '\0';
+buf[sizeof buf - 1] = '\0';
-	return PyUnicode_FromString(buf);
+return PyUnicode_FromString(buf);
 }
 PyDoc_STRVAR(gethostname_doc,
 "gethostname() -> string\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 socket_gethostbyname(PyObject *self, PyObject *args)
 {
-	char *name;
+char *name;
-	sock_addr_t addrbuf;
+sock_addr_t addrbuf;
-	if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
+if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
-		return NULL;
+return NULL;
-	if (setipaddr(name, SAS2SA(&addrbuf),  sizeof(addrbuf), AF_INET) < 0)
+if (setipaddr(name, SAS2SA(&addrbuf),  sizeof(addrbuf), AF_INET) < 0)
-		return NULL;
+return NULL;
-	return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
+return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
 }
 PyDoc_STRVAR(gethostbyname_doc,
 "gethostbyname(host) -> address\n\
 \n\
 /* Convenience function common to gethostbyname_ex and gethostbyaddr */
 static PyObject *
 gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
 {
-	char **pch;
+char **pch;
-	PyObject *rtn_tuple = (PyObject *)NULL;
+PyObject *rtn_tuple = (PyObject *)NULL;
-	PyObject *name_list = (PyObject *)NULL;
+PyObject *name_list = (PyObject *)NULL;
-	PyObject *addr_list = (PyObject *)NULL;
+PyObject *addr_list = (PyObject *)NULL;
-	PyObject *tmp;
+PyObject *tmp;
-	if (h == NULL) {
+if (h == NULL) {
-		/* Let's get real error message to return */
+/* Let's get real error message to return */
-		set_herror(h_errno);
+set_herror(h_errno);
-		return NULL;
+return NULL;
-	}
+}
-	if (h->h_addrtype != af) {
+if (h->h_addrtype != af) {
-		/* Let's get real error message to return */
+/* Let's get real error message to return */
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				(char *)strerror(EAFNOSUPPORT));
+(char *)strerror(EAFNOSUPPORT));
-		return NULL;
+return NULL;
-	}
+}
-	switch (af) {
+switch (af) {
-	case AF_INET:
+case AF_INET:
-		if (alen < sizeof(struct sockaddr_in))
+if (alen < sizeof(struct sockaddr_in))
-			return NULL;
+return NULL;
-		break;
+break;
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-		if (alen < sizeof(struct sockaddr_in6))
+if (alen < sizeof(struct sockaddr_in6))
-			return NULL;
+return NULL;
-		break;
+break;
 #endif
-	}
+}
-	if ((name_list = PyList_New(0)) == NULL)
+if ((name_list = PyList_New(0)) == NULL)
-		goto err;
+goto err;
-	if ((addr_list = PyList_New(0)) == NULL)
+if ((addr_list = PyList_New(0)) == NULL)
-		goto err;
+goto err;
-	/* SF #1511317: h_aliases can be NULL */
+/* SF #1511317: h_aliases can be NULL */
-	if (h->h_aliases) {
+if (h->h_aliases) {
-		for (pch = h->h_aliases; *pch != NULL; pch++) {
+for (pch = h->h_aliases; *pch != NULL; pch++) {
-			int status;
+int status;
-			tmp = PyUnicode_FromString(*pch);
+tmp = PyUnicode_FromString(*pch);
-			if (tmp == NULL)
+if (tmp == NULL)
-				goto err;
+goto err;
-			status = PyList_Append(name_list, tmp);
+status = PyList_Append(name_list, tmp);
-			Py_DECREF(tmp);
+Py_DECREF(tmp);
-			if (status)
+if (status)
-				goto err;
+goto err;
-		}
+}
-	}
+}
-	for (pch = h->h_addr_list; *pch != NULL; pch++) {
+for (pch = h->h_addr_list; *pch != NULL; pch++) {
-		int status;
+int status;
-		switch (af) {
+switch (af) {
-		case AF_INET:
+case AF_INET:
-		    {
+{
-			struct sockaddr_in sin;
+struct sockaddr_in sin;
-			memset(&sin, 0, sizeof(sin));
+memset(&sin, 0, sizeof(sin));
-			sin.sin_family = af;
+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));
+memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
-			tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
+tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
-			if (pch == h->h_addr_list && alen >= sizeof(sin))
+if (pch == h->h_addr_list && alen >= sizeof(sin))
-				memcpy((char *) addr, &sin, sizeof(sin));
+memcpy((char *) addr, &sin, sizeof(sin));
-			break;
+break;
-		    }
+}
 #ifdef ENABLE_IPV6
-		case AF_INET6:
+case AF_INET6:
-		    {
+{
-			struct sockaddr_in6 sin6;
+struct sockaddr_in6 sin6;
-			memset(&sin6, 0, sizeof(sin6));
+memset(&sin6, 0, sizeof(sin6));
-			sin6.sin6_family = af;
+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));
+memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
-			tmp = makeipaddr((struct sockaddr *)&sin6,
+tmp = makeipaddr((struct sockaddr *)&sin6,
-				sizeof(sin6));
+sizeof(sin6));
-			if (pch == h->h_addr_list && alen >= sizeof(sin6))
+if (pch == h->h_addr_list && alen >= sizeof(sin6))
-				memcpy((char *) addr, &sin6, sizeof(sin6));
+memcpy((char *) addr, &sin6, sizeof(sin6));
-			break;
+break;
-		    }
+}
 #endif
-		default:	/* can't happen */
+default:                /* can't happen */
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-					"unsupported address family");
+"unsupported address family");
-			return NULL;
+return NULL;
-		}
+}
-		if (tmp == NULL)
+if (tmp == NULL)
-			goto err;
+goto err;
-		status = PyList_Append(addr_list, tmp);
+status = PyList_Append(addr_list, tmp);
-		Py_DECREF(tmp);
+Py_DECREF(tmp);
-		if (status)
+if (status)
-			goto err;
+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(name_list);
-	Py_XDECREF(addr_list);
+Py_XDECREF(addr_list);
-	return rtn_tuple;
+return rtn_tuple;
 }
 /* Python interface to gethostbyname_ex(name). */
 /*ARGSUSED*/
 static PyObject *
 socket_gethostbyname_ex(PyObject *self, PyObject *args)
 {
-	char *name;
+char *name;
-	struct hostent *h;
+struct hostent *h;
 #ifdef ENABLE_IPV6
 struct sockaddr_storage addr;
 #else
 struct sockaddr_in addr;
 #endif
-	struct sockaddr *sa;
+struct sockaddr *sa;
-	PyObject *ret;
+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];
+char buf[16384];
-	int buf_len = (sizeof buf) - 1;
+int buf_len = (sizeof buf) - 1;
-	int errnop;
+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))
+if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
-		return NULL;
+return NULL;
-	if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
+if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
 #ifdef HAVE_GETHOSTBYNAME_R
 #if   defined(HAVE_GETHOSTBYNAME_R_6_ARG)
-	result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
+result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
-				 &h, &errnop);
+&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));
+memset((void *) &data, '\0', sizeof(data));
-	result = gethostbyname_r(name, &hp_allocated, &data);
+result = gethostbyname_r(name, &hp_allocated, &data);
-	h = (result != 0) ? NULL : &hp_allocated;
+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
+Py_END_ALLOW_THREADS
-	/* Some C libraries would require addr.__ss_family instead of
+/* Some C libraries would require addr.__ss_family instead of
-	   addr.ss_family.
+addr.ss_family.
-	   Therefore, we cast the sockaddr_storage into sockaddr to
+Therefore, we cast the sockaddr_storage into sockaddr to
-	   access sa_family. */
+access sa_family. */
-	sa = (struct sockaddr*)&addr;
+sa = (struct sockaddr*)&addr;
-	ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
+ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
-			     sa->sa_family);
+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,
 "gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 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;
+struct sockaddr *sa = (struct sockaddr *)&addr;
-	char *ip_num;
+char *ip_num;
-	struct hostent *h;
+struct hostent *h;
-	PyObject *ret;
+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
+/* glibcs up to 2.10 assume that the buf argument to
-	   gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
+gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
-	   does not ensure. The attribute below instructs the compiler
+does not ensure. The attribute below instructs the compiler
-	   to maintain this alignment. */
+to maintain this alignment. */
-	char buf[16384] Py_ALIGNED(8);
+char buf[16384] Py_ALIGNED(8);
-	int buf_len = (sizeof buf) - 1;
+int buf_len = (sizeof buf) - 1;
-	int errnop;
+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;
+char *ap;
-	int al;
+int al;
-	int af;
+int af;
-	if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
+if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
-		return NULL;
+return NULL;
-	af = AF_UNSPEC;
+af = AF_UNSPEC;
-	if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
+if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
-		return NULL;
+return NULL;
-	af = sa->sa_family;
+af = sa->sa_family;
-	ap = NULL;
+ap = NULL;
-	al = 0;
+al = 0;
-	switch (af) {
+switch (af) {
-	case AF_INET:
+case AF_INET:
-		ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
+ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
-		al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
+al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
-		break;
+break;
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-		ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
+ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
-		al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
+al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
-		break;
+break;
 #endif
-	default:
+default:
-		PyErr_SetString(socket_error, "unsupported address family");
+PyErr_SetString(socket_error, "unsupported address family");
-		return NULL;
+return NULL;
-	}
+}
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
 #ifdef HAVE_GETHOSTBYNAME_R
 #if   defined(HAVE_GETHOSTBYNAME_R_6_ARG)
-	result = gethostbyaddr_r(ap, al, af,
+result = gethostbyaddr_r(ap, al, af,
-		&hp_allocated, buf, buf_len,
+&hp_allocated, buf, buf_len,
-		&h, &errnop);
+&h, &errnop);
 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
-	h = gethostbyaddr_r(ap, al, af,
+h = gethostbyaddr_r(ap, al, af,
-			    &hp_allocated, buf, buf_len, &errnop);
+&hp_allocated, buf, buf_len, &errnop);
 #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
-	memset((void *) &data, '\0', sizeof(data));
+memset((void *) &data, '\0', sizeof(data));
-	result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
+result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
-	h = (result != 0) ? NULL : &hp_allocated;
+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
+Py_END_ALLOW_THREADS
-	ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
+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,
 "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 socket_getservbyname(PyObject *self, PyObject *args)
 {
-	char *name, *proto=NULL;
+char *name, *proto=NULL;
-	struct servent *sp;
+struct servent *sp;
-	if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
+if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	sp = getservbyname(name, proto);
+sp = getservbyname(name, proto);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (sp == NULL) {
+if (sp == NULL) {
-		PyErr_SetString(socket_error, "service/proto not found");
+PyErr_SetString(socket_error, "service/proto not found");
-		return NULL;
+return NULL;
-	}
+}
-	return PyLong_FromLong((long) ntohs(sp->s_port));
+return PyLong_FromLong((long) ntohs(sp->s_port));
 }
 PyDoc_STRVAR(getservbyname_doc,
 "getservbyname(servicename[, protocolname]) -> integer\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 socket_getservbyport(PyObject *self, PyObject *args)
 {
-	int port;
+int port;
-	char *proto=NULL;
+char *proto=NULL;
-	struct servent *sp;
+struct servent *sp;
-	if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
+if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
-		return NULL;
+return NULL;
-	if (port < 0 || port > 0xffff) {
+if (port < 0 || port > 0xffff) {
-		PyErr_SetString(
+PyErr_SetString(
-			PyExc_OverflowError,
+PyExc_OverflowError,
-			"getservbyport: port must be 0-65535.");
+"getservbyport: port must be 0-65535.");
-		return NULL;
+return NULL;
-	}
+}
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	sp = getservbyport(htons((short)port), proto);
+sp = getservbyport(htons((short)port), proto);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (sp == NULL) {
+if (sp == NULL) {
-		PyErr_SetString(socket_error, "port/proto not found");
+PyErr_SetString(socket_error, "port/proto not found");
-		return NULL;
+return NULL;
-	}
+}
-	return PyUnicode_FromString(sp->s_name);
+return PyUnicode_FromString(sp->s_name);
 }
 PyDoc_STRVAR(getservbyport_doc,
 "getservbyport(port[, protocolname]) -> string\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 socket_getprotobyname(PyObject *self, PyObject *args)
 {
-	char *name;
+char *name;
-	struct protoent *sp;
+struct protoent *sp;
-	if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
+if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
-		return NULL;
+return NULL;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	sp = getprotobyname(name);
+sp = getprotobyname(name);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	if (sp == NULL) {
+if (sp == NULL) {
-		PyErr_SetString(socket_error, "protocol not found");
+PyErr_SetString(socket_error, "protocol not found");
-		return NULL;
+return NULL;
-	}
+}
-	return PyLong_FromLong((long) sp->p_proto);
+return PyLong_FromLong((long) sp->p_proto);
 }
 PyDoc_STRVAR(getprotobyname_doc,
 "getprotobyname(name) -> integer\n\
 \n\
 /* dup() function for socket fds */
 static PyObject *
 socket_dup(PyObject *self, PyObject *fdobj)
 {
-	SOCKET_T fd, newfd;
+SOCKET_T fd, newfd;
-	PyObject *newfdobj;
+PyObject *newfdobj;
-	fd = PyLong_AsSocket_t(fdobj);
+fd = PyLong_AsSocket_t(fdobj);
-	if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
+if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
-		return NULL;
+return NULL;
-	newfd = dup_socket(fd);
+newfd = dup_socket(fd);
-	if (newfd == INVALID_SOCKET)
+if (newfd == INVALID_SOCKET)
-		return set_error();
+return set_error();
-	newfdobj = PyLong_FromSocket_t(newfd);
+newfdobj = PyLong_FromSocket_t(newfd);
-	if (newfdobj == NULL)
+if (newfdobj == NULL)
-		SOCKETCLOSE(newfd);
+SOCKETCLOSE(newfd);
-	return newfdobj;
+return newfdobj;
 }
 PyDoc_STRVAR(dup_doc,
 "dup(integer) -> integer\n\
 \n\
 /*ARGSUSED*/
 static PyObject *
 socket_socketpair(PyObject *self, PyObject *args)
 {
-	PySocketSockObject *s0 = NULL, *s1 = NULL;
+PySocketSockObject *s0 = NULL, *s1 = NULL;
-	SOCKET_T sv[2];
+SOCKET_T sv[2];
-	int family, type = SOCK_STREAM, proto = 0;
+int family, type = SOCK_STREAM, proto = 0;
-	PyObject *res = NULL;
+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",
+if (!PyArg_ParseTuple(args, "|iii:socketpair",
-			      &family, &type, &proto))
+&family, &type, &proto))
-		return NULL;
+return NULL;
-	/* Create a pair of socket fds */
+/* Create a pair of socket fds */
-	if (socketpair(family, type, proto, sv) < 0)
+if (socketpair(family, type, proto, sv) < 0)
-		return set_error();
+return set_error();
-	s0 = new_sockobject(sv[0], family, type, proto);
+s0 = new_sockobject(sv[0], family, type, proto);
-	if (s0 == NULL)
+if (s0 == NULL)
-		goto finally;
+goto finally;
-	s1 = new_sockobject(sv[1], family, type, proto);
+s1 = new_sockobject(sv[1], family, type, proto);
-	if (s1 == NULL)
+if (s1 == NULL)
-		goto finally;
+goto finally;
-	res = PyTuple_Pack(2, s0, s1);
+res = PyTuple_Pack(2, s0, s1);
 finally:
-	if (res == NULL) {
+if (res == NULL) {
-		if (s0 == NULL)
+if (s0 == NULL)
-			SOCKETCLOSE(sv[0]);
+SOCKETCLOSE(sv[0]);
-		if (s1 == NULL)
+if (s1 == NULL)
-			SOCKETCLOSE(sv[1]);
+SOCKETCLOSE(sv[1]);
-	}
+}
-	Py_XDECREF(s0);
+Py_XDECREF(s0);
-	Py_XDECREF(s1);
+Py_XDECREF(s1);
-	return res;
+return res;
 }
 PyDoc_STRVAR(socketpair_doc,
 "socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
 \n\
 static PyObject *
 socket_ntohs(PyObject *self, PyObject *args)
 {
-	int x1, x2;
+int x1, x2;
-	if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
+if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
-		return NULL;
+return NULL;
-	}
+}
-	if (x1 < 0) {
+if (x1 < 0) {
-		PyErr_SetString(PyExc_OverflowError,
+PyErr_SetString(PyExc_OverflowError,
-			"can't convert negative number to unsigned long");
+"can't convert negative number to unsigned long");
-		return NULL;
+return NULL;
-	}
+}
-	x2 = (unsigned int)ntohs((unsigned short)x1);
+x2 = (unsigned int)ntohs((unsigned short)x1);
-	return PyLong_FromLong(x2);
+return PyLong_FromLong(x2);
 }
 PyDoc_STRVAR(ntohs_doc,
 "ntohs(integer) -> integer\n\
 \n\
 static PyObject *
 socket_ntohl(PyObject *self, PyObject *arg)
 {
-	unsigned long x;
+unsigned long x;
-	if (PyLong_Check(arg)) {
+if (PyLong_Check(arg)) {
-		x = PyLong_AsUnsignedLong(arg);
+x = PyLong_AsUnsignedLong(arg);
-		if (x == (unsigned long) -1 && PyErr_Occurred())
+if (x == (unsigned long) -1 && PyErr_Occurred())
-			return NULL;
+return NULL;
 #if SIZEOF_LONG > 4
-		{
+{
-			unsigned long y;
+unsigned long y;
-			/* only want the trailing 32 bits */
+/* only want the trailing 32 bits */
-			y = x & 0xFFFFFFFFUL;
+y = x & 0xFFFFFFFFUL;
-			if (y ^ x)
+if (y ^ x)
-				return PyErr_Format(PyExc_OverflowError,
+return PyErr_Format(PyExc_OverflowError,
-					    "long int larger than 32 bits");
+"long int larger than 32 bits");
-			x = y;
+x = y;
-		}
+}
 #endif
-	}
+}
-	else
+else
-		return PyErr_Format(PyExc_TypeError,
+return PyErr_Format(PyExc_TypeError,
-				    "expected int/long, %s found",
+"expected int/long, %s found",
-				    Py_TYPE(arg)->tp_name);
+Py_TYPE(arg)->tp_name);
-	if (x == (unsigned long) -1 && PyErr_Occurred())
+if (x == (unsigned long) -1 && PyErr_Occurred())
-		return NULL;
+return NULL;
-	return PyLong_FromUnsignedLong(ntohl(x));
+return PyLong_FromUnsignedLong(ntohl(x));
 }
 PyDoc_STRVAR(ntohl_doc,
 "ntohl(integer) -> integer\n\
 \n\
 static PyObject *
 socket_htons(PyObject *self, PyObject *args)
 {
-	int x1, x2;
+int x1, x2;
-	if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
+if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
-		return NULL;
+return NULL;
-	}
+}
-	if (x1 < 0) {
+if (x1 < 0) {
-		PyErr_SetString(PyExc_OverflowError,
+PyErr_SetString(PyExc_OverflowError,
-			"can't convert negative number to unsigned long");
+"can't convert negative number to unsigned long");
-		return NULL;
+return NULL;
-	}
+}
-	x2 = (unsigned int)htons((unsigned short)x1);
+x2 = (unsigned int)htons((unsigned short)x1);
-	return PyLong_FromLong(x2);
+return PyLong_FromLong(x2);
 }
 PyDoc_STRVAR(htons_doc,
 "htons(integer) -> integer\n\
 \n\
 static PyObject *
 socket_htonl(PyObject *self, PyObject *arg)
 {
-	unsigned long x;
+unsigned long x;
-	if (PyLong_Check(arg)) {
+if (PyLong_Check(arg)) {
-		x = PyLong_AsUnsignedLong(arg);
+x = PyLong_AsUnsignedLong(arg);
-		if (x == (unsigned long) -1 && PyErr_Occurred())
+if (x == (unsigned long) -1 && PyErr_Occurred())
-			return NULL;
+return NULL;
 #if SIZEOF_LONG > 4
-		{
+{
-			unsigned long y;
+unsigned long y;
-			/* only want the trailing 32 bits */
+/* only want the trailing 32 bits */
-			y = x & 0xFFFFFFFFUL;
+y = x & 0xFFFFFFFFUL;
-			if (y ^ x)
+if (y ^ x)
-				return PyErr_Format(PyExc_OverflowError,
+return PyErr_Format(PyExc_OverflowError,
-					    "long int larger than 32 bits");
+"long int larger than 32 bits");
-			x = y;
+x = y;
-		}
+}
 #endif
-	}
+}
-	else
+else
-		return PyErr_Format(PyExc_TypeError,
+return PyErr_Format(PyExc_TypeError,
-				    "expected int/long, %s found",
+"expected int/long, %s found",
-				    Py_TYPE(arg)->tp_name);
+Py_TYPE(arg)->tp_name);
-	return PyLong_FromUnsignedLong(htonl((unsigned long)x));
+return PyLong_FromUnsignedLong(htonl((unsigned long)x));
 }
 PyDoc_STRVAR(htonl_doc,
 "htonl(integer) -> integer\n\
 \n\
 {
 #ifndef INADDR_NONE
 #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 */
+/* Have to use inet_addr() instead */
-	unsigned int packed_addr;
+unsigned int packed_addr;
 #endif
-	char *ip_addr;
+char *ip_addr;
-	if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
+if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
-		return NULL;
+return NULL;
 #ifdef HAVE_INET_ATON
 #ifdef USE_INET_ATON_WEAKLINK
 if (inet_aton != NULL) {
 #endif
-	if (inet_aton(ip_addr, &buf))
+if (inet_aton(ip_addr, &buf))
-		return PyBytes_FromStringAndSize((char *)(&buf),
+return PyBytes_FromStringAndSize((char *)(&buf),
-						  sizeof(buf));
+sizeof(buf));
-	PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-			"illegal IP address string passed to inet_aton");
+"illegal IP address string passed to inet_aton");
-	return NULL;
+return NULL;
 #ifdef USE_INET_ATON_WEAKLINK
 } else {
 #endif
 #endif
 #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
-	/* special-case this address as inet_addr might return INADDR_NONE
+/* special-case this address as inet_addr might return INADDR_NONE
-	 * for this */
+* for this */
-	if (strcmp(ip_addr, "255.255.255.255") == 0) {
+if (strcmp(ip_addr, "255.255.255.255") == 0) {
-		packed_addr = 0xFFFFFFFF;
+packed_addr = 0xFFFFFFFF;
-	} else {
+} else {
-		packed_addr = inet_addr(ip_addr);
+packed_addr = inet_addr(ip_addr);
-		if (packed_addr == INADDR_NONE) {	/* invalid address */
+if (packed_addr == INADDR_NONE) {               /* invalid address */
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"illegal IP address string passed to inet_aton");
+"illegal IP address string passed to inet_aton");
-			return NULL;
+return NULL;
-		}
+}
-	}
+}
-	return PyBytes_FromStringAndSize((char *) &packed_addr,
+return PyBytes_FromStringAndSize((char *) &packed_addr,
 sizeof(packed_addr));
 #ifdef USE_INET_ATON_WEAKLINK
 }
 #endif
 Convert an IP address from 32-bit packed binary format to string format");
 static PyObject*
 socket_inet_ntoa(PyObject *self, PyObject *args)
 {
-	char *packed_str;
+char *packed_str;
-	int addr_len;
+int addr_len;
-	struct in_addr packed_addr;
+struct in_addr packed_addr;
-	if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
+if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
-		return NULL;
+return NULL;
-	}
+}
-	if (addr_len != sizeof(packed_addr)) {
+if (addr_len != sizeof(packed_addr)) {
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-			"packed IP wrong length for inet_ntoa");
+"packed IP wrong length for inet_ntoa");
-		return NULL;
+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
 PyDoc_STRVAR(inet_pton_doc,
 for use with low-level network functions.");
 static PyObject *
 socket_inet_pton(PyObject *self, PyObject *args)
 {
-	int af;
+int af;
-	char* ip;
+char* ip;
-	int retval;
+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)) {
+if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
-		return NULL;
+return NULL;
-	}
+}
 #if !defined(ENABLE_IPV6) && defined(AF_INET6)
-	if(af == AF_INET6) {
+if(af == AF_INET6) {
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"can't use AF_INET6, IPv6 is disabled");
+"can't use AF_INET6, IPv6 is disabled");
-		return NULL;
+return NULL;
-	}
+}
 #endif
-	retval = inet_pton(af, ip, packed);
+retval = inet_pton(af, ip, packed);
-	if (retval < 0) {
+if (retval < 0) {
-		PyErr_SetFromErrno(socket_error);
+PyErr_SetFromErrno(socket_error);
-		return NULL;
+return NULL;
-	} else if (retval == 0) {
+} else if (retval == 0) {
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-			"illegal IP address string passed to inet_pton");
+"illegal IP address string passed to inet_pton");
-		return NULL;
+return NULL;
-	} else if (af == AF_INET) {
+} else if (af == AF_INET) {
-		return PyBytes_FromStringAndSize(packed,
+return PyBytes_FromStringAndSize(packed,
 sizeof(struct in_addr));
 #ifdef ENABLE_IPV6
-	} else if (af == AF_INET6) {
+} else if (af == AF_INET6) {
-		return PyBytes_FromStringAndSize(packed,
+return PyBytes_FromStringAndSize(packed,
 sizeof(struct in6_addr));
 #endif
-	} else {
+} else {
-		PyErr_SetString(socket_error, "unknown address family");
+PyErr_SetString(socket_error, "unknown address family");
-		return NULL;
+return NULL;
-	}
+}
 }
 PyDoc_STRVAR(inet_ntop_doc,
 "inet_ntop(af, packed_ip) -> string formatted IP address\n\
 \n\
 Convert a packed IP address of the given family to string format.");
 static PyObject *
 socket_inet_ntop(PyObject *self, PyObject *args)
 {
-	int af;
+int af;
-	char* packed;
+char* packed;
-	int len;
+int len;
-	const char* retval;
+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 */
+/* Guarantee NUL-termination for PyUnicode_FromString() below */
-	memset((void *) &ip[0], '\0', sizeof(ip));
+memset((void *) &ip[0], '\0', sizeof(ip));
-	if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
+if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
-		return NULL;
+return NULL;
-	}
+}
-	if (af == AF_INET) {
+if (af == AF_INET) {
-		if (len != sizeof(struct in_addr)) {
+if (len != sizeof(struct in_addr)) {
-			PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"invalid length of packed IP address string");
+"invalid length of packed IP address string");
-			return NULL;
+return NULL;
-		}
+}
 #ifdef ENABLE_IPV6
-	} else if (af == AF_INET6) {
+} else if (af == AF_INET6) {
-		if (len != sizeof(struct in6_addr)) {
+if (len != sizeof(struct in6_addr)) {
-			PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-				"invalid length of packed IP address string");
+"invalid length of packed IP address string");
-			return NULL;
+return NULL;
-		}
+}
 #endif
-	} else {
+} else {
-		PyErr_Format(PyExc_ValueError,
+PyErr_Format(PyExc_ValueError,
-			"unknown address family %d", af);
+"unknown address family %d", af);
-		return NULL;
+return NULL;
-	}
+}
-	retval = inet_ntop(af, packed, ip, sizeof(ip));
+retval = inet_ntop(af, packed, ip, sizeof(ip));
-	if (!retval) {
+if (!retval) {
-		PyErr_SetFromErrno(socket_error);
+PyErr_SetFromErrno(socket_error);
-		return NULL;
+return NULL;
-	} else {
+} else {
-		return PyUnicode_FromString(retval);
+return PyUnicode_FromString(retval);
-	}
+}
-	/* NOTREACHED */
+/* NOTREACHED */
-	PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
+PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
-	return NULL;
+return NULL;
 }
 #endif /* HAVE_INET_PTON */
 /* Python interface to getaddrinfo(host, port). */
 /*ARGSUSED*/
 static PyObject *
 socket_getaddrinfo(PyObject *self, PyObject *args)
 {
-	struct addrinfo hints, *res;
+struct addrinfo hints, *res;
-	struct addrinfo *res0 = NULL;
+struct addrinfo *res0 = NULL;
-	PyObject *hobj = NULL;
+PyObject *hobj = NULL;
-	PyObject *pobj = (PyObject *)NULL;
+PyObject *pobj = (PyObject *)NULL;
-	char pbuf[30];
+char pbuf[30];
-	char *hptr, *pptr;
+char *hptr, *pptr;
-	int family, socktype, protocol, flags;
+int family, socktype, protocol, flags;
-	int error;
+int error;
-	PyObject *all = (PyObject *)NULL;
+PyObject *all = (PyObject *)NULL;
-	PyObject *idna = NULL;
+PyObject *idna = NULL;
-	family = socktype = protocol = flags = 0;
+family = socktype = protocol = flags = 0;
-	family = AF_UNSPEC;
+family = AF_UNSPEC;
-	if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
+if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
-			      &hobj, &pobj, &family, &socktype,
+&hobj, &pobj, &family, &socktype,
-			      &protocol, &flags)) {
+&protocol, &flags)) {
-		return NULL;
+return NULL;
-	}
+}
-	if (hobj == Py_None) {
+if (hobj == Py_None) {
-		hptr = NULL;
+hptr = NULL;
-	} else if (PyUnicode_Check(hobj)) {
+} else if (PyUnicode_Check(hobj)) {
-		idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
+idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
-		if (!idna)
+if (!idna)
-			return NULL;
+return NULL;
-		assert(PyBytes_Check(idna));
+assert(PyBytes_Check(idna));
-		hptr = PyBytes_AS_STRING(idna);
+hptr = PyBytes_AS_STRING(idna);
-	} else if (PyBytes_Check(hobj)) {
+} else if (PyBytes_Check(hobj)) {
-		hptr = PyBytes_AsString(hobj);
+hptr = PyBytes_AsString(hobj);
-	} else {
+} else {
-		PyErr_SetString(PyExc_TypeError,
+PyErr_SetString(PyExc_TypeError,
-				"getaddrinfo() argument 1 must be string or None");
+"getaddrinfo() argument 1 must be string or None");
-		return NULL;
+return NULL;
-	}
+}
-	if (PyLong_CheckExact(pobj)) {
+if (PyLong_CheckExact(pobj)) {
-		long value = PyLong_AsLong(pobj);
+long value = PyLong_AsLong(pobj);
-		if (value == -1 && PyErr_Occurred())
+if (value == -1 && PyErr_Occurred())
-			goto err;
+goto err;
-		PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
+PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
-		pptr = pbuf;
+pptr = pbuf;
-	} else if (PyUnicode_Check(pobj)) {
+} else if (PyUnicode_Check(pobj)) {
-		pptr = _PyUnicode_AsString(pobj);
+pptr = _PyUnicode_AsString(pobj);
-	} else if (PyBytes_Check(pobj)) {
+} else if (PyBytes_Check(pobj)) {
-		pptr = PyBytes_AsString(pobj);
+pptr = PyBytes_AsString(pobj);
-	} else if (pobj == Py_None) {
+} else if (pobj == Py_None) {
-		pptr = (char *)NULL;
+pptr = (char *)NULL;
-	} else {
+} else {
-		PyErr_SetString(socket_error, "Int or String expected");
+PyErr_SetString(socket_error, "Int or String expected");
 goto err;
-	}
+}
-	memset(&hints, 0, sizeof(hints));
+memset(&hints, 0, sizeof(hints));
-	hints.ai_family = family;
+hints.ai_family = family;
-	hints.ai_socktype = socktype;
+hints.ai_socktype = socktype;
-	hints.ai_protocol = protocol;
+hints.ai_protocol = protocol;
-	hints.ai_flags = flags;
+hints.ai_flags = flags;
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	ACQUIRE_GETADDRINFO_LOCK
+ACQUIRE_GETADDRINFO_LOCK
-	error = getaddrinfo(hptr, pptr, &hints, &res0);
+error = getaddrinfo(hptr, pptr, &hints, &res0);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
+RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
-	if (error) {
+if (error) {
-		set_gaierror(error);
+set_gaierror(error);
-		goto err;
+goto err;
-	}
+}
-	if ((all = PyList_New(0)) == NULL)
+if ((all = PyList_New(0)) == NULL)
-		goto err;
+goto err;
-	for (res = res0; res; res = res->ai_next) {
+for (res = res0; res; res = res->ai_next) {
-		PyObject *single;
+PyObject *single;
-		PyObject *addr =
+PyObject *addr =
-			makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
+makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
-		if (addr == NULL)
+if (addr == NULL)
-			goto err;
+goto err;
-		single = Py_BuildValue("iiisO", res->ai_family,
+single = Py_BuildValue("iiisO", res->ai_family,
-			res->ai_socktype, res->ai_protocol,
+res->ai_socktype, res->ai_protocol,
-			res->ai_canonname ? res->ai_canonname : "",
+res->ai_canonname ? res->ai_canonname : "",
-			addr);
+addr);
-		Py_DECREF(addr);
+Py_DECREF(addr);
-		if (single == NULL)
+if (single == NULL)
-			goto err;
+goto err;
-		if (PyList_Append(all, single))
+if (PyList_Append(all, single))
-			goto err;
+goto err;
-		Py_XDECREF(single);
+Py_XDECREF(single);
-	}
+}
-	Py_XDECREF(idna);
+Py_XDECREF(idna);
-	if (res0)
+if (res0)
-		freeaddrinfo(res0);
+freeaddrinfo(res0);
-	return all;
+return all;
 err:
-	Py_XDECREF(all);
+Py_XDECREF(all);
-	Py_XDECREF(idna);
+Py_XDECREF(idna);
-	if (res0)
+if (res0)
-		freeaddrinfo(res0);
+freeaddrinfo(res0);
-	return (PyObject *)NULL;
+return (PyObject *)NULL;
 }
 PyDoc_STRVAR(getaddrinfo_doc,
 "getaddrinfo(host, port [, family, socktype, proto, flags])\n\
 -> list of (family, socktype, proto, canonname, sockaddr)\n\
 /*ARGSUSED*/
 static PyObject *
 socket_getnameinfo(PyObject *self, PyObject *args)
 {
-	PyObject *sa = (PyObject *)NULL;
+PyObject *sa = (PyObject *)NULL;
-	int flags;
+int flags;
-	char *hostp;
+char *hostp;
-	int port, flowinfo, scope_id;
+int port, flowinfo, scope_id;
-	char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
+char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
-	struct addrinfo hints, *res = NULL;
+struct addrinfo hints, *res = NULL;
-	int error;
+int error;
-	PyObject *ret = (PyObject *)NULL;
+PyObject *ret = (PyObject *)NULL;
-	flags = flowinfo = scope_id = 0;
+flags = flowinfo = scope_id = 0;
-	if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
+if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
-		return NULL;
+return NULL;
-	if (!PyTuple_Check(sa)) {
+if (!PyTuple_Check(sa)) {
-		PyErr_SetString(PyExc_TypeError,
+PyErr_SetString(PyExc_TypeError,
-				"getnameinfo() argument 1 must be a tuple");
+"getnameinfo() argument 1 must be a tuple");
-		return NULL;
+return NULL;
-	}
+}
-	if (!PyArg_ParseTuple(sa, "si|ii",
+if (!PyArg_ParseTuple(sa, "si|ii",
-			      &hostp, &port, &flowinfo, &scope_id))
+&hostp, &port, &flowinfo, &scope_id))
-		return NULL;
+return NULL;
-	PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
+PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
-	memset(&hints, 0, sizeof(hints));
+memset(&hints, 0, sizeof(hints));
-	hints.ai_family = AF_UNSPEC;
+hints.ai_family = AF_UNSPEC;
-	hints.ai_socktype = SOCK_DGRAM;	/* make numeric port happy */
+hints.ai_socktype = SOCK_DGRAM;     /* make numeric port happy */
-	Py_BEGIN_ALLOW_THREADS
+Py_BEGIN_ALLOW_THREADS
-	ACQUIRE_GETADDRINFO_LOCK
+ACQUIRE_GETADDRINFO_LOCK
-	error = getaddrinfo(hostp, pbuf, &hints, &res);
+error = getaddrinfo(hostp, pbuf, &hints, &res);
-	Py_END_ALLOW_THREADS
+Py_END_ALLOW_THREADS
-	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
+RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
-	if (error) {
+if (error) {
-		set_gaierror(error);
+set_gaierror(error);
-		goto fail;
+goto fail;
-	}
+}
-	if (res->ai_next) {
+if (res->ai_next) {
-		PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-			"sockaddr resolved to multiple addresses");
+"sockaddr resolved to multiple addresses");
-		goto fail;
+goto fail;
-	}
+}
-	switch (res->ai_family) {
+switch (res->ai_family) {
-	case AF_INET:
+case AF_INET:
-	    {
+{
-		if (PyTuple_GET_SIZE(sa) != 2) {
+if (PyTuple_GET_SIZE(sa) != 2) {
-			PyErr_SetString(socket_error,
+PyErr_SetString(socket_error,
-				"IPv4 sockaddr must be 2 tuple");
+"IPv4 sockaddr must be 2 tuple");
-			goto fail;
+goto fail;
-		}
+}
-		break;
+break;
-	    }
+}
 #ifdef ENABLE_IPV6
-	case AF_INET6:
+case AF_INET6:
-	    {
+{
-		struct sockaddr_in6 *sin6;
+struct sockaddr_in6 *sin6;
-		sin6 = (struct sockaddr_in6 *)res->ai_addr;
+sin6 = (struct sockaddr_in6 *)res->ai_addr;
-		sin6->sin6_flowinfo = flowinfo;
+sin6->sin6_flowinfo = flowinfo;
-		sin6->sin6_scope_id = scope_id;
+sin6->sin6_scope_id = scope_id;
-		break;
+break;
-	    }
+}
 #endif
-	}
+}
-	error = getnameinfo(res->ai_addr, res->ai_addrlen,
+error = getnameinfo(res->ai_addr, res->ai_addrlen,
-			hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
+hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
-	if (error) {
+if (error) {
-		set_gaierror(error);
+set_gaierror(error);
-		goto fail;
+goto fail;
-	}
+}
-	ret = Py_BuildValue("ss", hbuf, pbuf);
+ret = Py_BuildValue("ss", hbuf, pbuf);
 fail:
-	if (res)
+if (res)
-		freeaddrinfo(res);
+freeaddrinfo(res);
-	return ret;
+return ret;
 }
 PyDoc_STRVAR(getnameinfo_doc,
 "getnameinfo(sockaddr, flags) --> (host, port)\n\
 \n\
 /* Python API to getting and setting the default timeout value. */
 static PyObject *
 socket_getdefaulttimeout(PyObject *self)
 {
-	if (defaulttimeout < 0.0) {
+if (defaulttimeout < 0.0) {
-		Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-		return Py_None;
+return Py_None;
-	}
+}
-	else
+else
-		return PyFloat_FromDouble(defaulttimeout);
+return PyFloat_FromDouble(defaulttimeout);
 }
 PyDoc_STRVAR(getdefaulttimeout_doc,
 "getdefaulttimeout() -> timeout\n\
 \n\
 When the socket module is first imported, the default is None.");
 static PyObject *
 socket_setdefaulttimeout(PyObject *self, PyObject *arg)
 {
-	double timeout;
+double timeout;
-	if (arg == Py_None)
+if (arg == Py_None)
-		timeout = -1.0;
+timeout = -1.0;
-	else {
+else {
-		timeout = PyFloat_AsDouble(arg);
+timeout = PyFloat_AsDouble(arg);
-		if (timeout < 0.0) {
+if (timeout < 0.0) {
-			if (!PyErr_Occurred())
+if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_ValueError,
+PyErr_SetString(PyExc_ValueError,
-						"Timeout value out of range");
+"Timeout value out of range");
-			return NULL;
+return NULL;
-		}
+}
-	}
+}
-	defaulttimeout = timeout;
+defaulttimeout = timeout;
-	Py_INCREF(Py_None);
+Py_INCREF(Py_None);
-	return Py_None;
+return Py_None;
 }
 PyDoc_STRVAR(setdefaulttimeout_doc,
 "setdefaulttimeout(timeout)\n\
 \n\
 /* List of functions exported by this module. */
 static PyMethodDef socket_methods[] = {
-	{"gethostbyname",	socket_gethostbyname,
+{"gethostbyname",           socket_gethostbyname,
-	 METH_VARARGS, gethostbyname_doc},
+METH_VARARGS, gethostbyname_doc},
-	{"gethostbyname_ex",	socket_gethostbyname_ex,
+{"gethostbyname_ex",        socket_gethostbyname_ex,
-	 METH_VARARGS, ghbn_ex_doc},
+METH_VARARGS, ghbn_ex_doc},
-	{"gethostbyaddr",	socket_gethostbyaddr,
+{"gethostbyaddr",           socket_gethostbyaddr,
-	 METH_VARARGS, gethostbyaddr_doc},
+METH_VARARGS, gethostbyaddr_doc},
-	{"gethostname",		socket_gethostname,
+{"gethostname",             socket_gethostname,
-	 METH_NOARGS,  gethostname_doc},
+METH_NOARGS,  gethostname_doc},
-	{"getservbyname",	socket_getservbyname,
+{"getservbyname",           socket_getservbyname,
-	 METH_VARARGS, getservbyname_doc},
+METH_VARARGS, getservbyname_doc},
-	{"getservbyport",	socket_getservbyport,
+{"getservbyport",           socket_getservbyport,
-	 METH_VARARGS, getservbyport_doc},
+METH_VARARGS, getservbyport_doc},
-	{"getprotobyname",	socket_getprotobyname,
+{"getprotobyname",          socket_getprotobyname,
-	 METH_VARARGS, getprotobyname_doc},
+METH_VARARGS, getprotobyname_doc},
 #ifndef NO_DUP
-	{"dup",			socket_dup,
+{"dup",                     socket_dup,
 METH_O, dup_doc},
 #endif
 #ifdef HAVE_SOCKETPAIR
-	{"socketpair",		socket_socketpair,
+{"socketpair",              socket_socketpair,
-	 METH_VARARGS, socketpair_doc},
+METH_VARARGS, socketpair_doc},
 #endif
-	{"ntohs",		socket_ntohs,
+{"ntohs",                   socket_ntohs,
-	 METH_VARARGS, ntohs_doc},
+METH_VARARGS, ntohs_doc},
-	{"ntohl",		socket_ntohl,
+{"ntohl",                   socket_ntohl,
-	 METH_O, ntohl_doc},
+METH_O, ntohl_doc},
-	{"htons",		socket_htons,
+{"htons",                   socket_htons,
-	 METH_VARARGS, htons_doc},
+METH_VARARGS, htons_doc},
-	{"htonl",		socket_htonl,
+{"htonl",                   socket_htonl,
-	 METH_O, htonl_doc},
+METH_O, htonl_doc},
-	{"inet_aton",		socket_inet_aton,
+{"inet_aton",               socket_inet_aton,
-	 METH_VARARGS, inet_aton_doc},
+METH_VARARGS, inet_aton_doc},
-	{"inet_ntoa",		socket_inet_ntoa,
+{"inet_ntoa",               socket_inet_ntoa,
-	 METH_VARARGS, inet_ntoa_doc},
+METH_VARARGS, inet_ntoa_doc},
 #ifdef HAVE_INET_PTON
-	{"inet_pton",		socket_inet_pton,
+{"inet_pton",               socket_inet_pton,
-	 METH_VARARGS, inet_pton_doc},
+METH_VARARGS, inet_pton_doc},
-	{"inet_ntop",		socket_inet_ntop,
+{"inet_ntop",               socket_inet_ntop,
-	 METH_VARARGS, inet_ntop_doc},
+METH_VARARGS, inet_ntop_doc},
 #endif
-	{"getaddrinfo",		socket_getaddrinfo,
+{"getaddrinfo",             socket_getaddrinfo,
-	 METH_VARARGS, getaddrinfo_doc},
+METH_VARARGS, getaddrinfo_doc},
-	{"getnameinfo",		socket_getnameinfo,
+{"getnameinfo",             socket_getnameinfo,
-	 METH_VARARGS, getnameinfo_doc},
+METH_VARARGS, getnameinfo_doc},
-	{"getdefaulttimeout",	(PyCFunction)socket_getdefaulttimeout,
+{"getdefaulttimeout",       (PyCFunction)socket_getdefaulttimeout,
-	 METH_NOARGS, getdefaulttimeout_doc},
+METH_NOARGS, getdefaulttimeout_doc},
-	{"setdefaulttimeout",	socket_setdefaulttimeout,
+{"setdefaulttimeout",       socket_setdefaulttimeout,
-	 METH_O, setdefaulttimeout_doc},
+METH_O, setdefaulttimeout_doc},
-	{NULL,			NULL}		 /* Sentinel */
+{NULL,                      NULL}            /* Sentinel */
 };
 #ifdef MS_WINDOWS
 #define OS_INIT_DEFINED
 /* Additional initialization and cleanup for Windows */
 static void
 os_cleanup(void)
 {
-	WSACleanup();
+WSACleanup();
 }
 static int
 os_init(void)
 {
-	WSADATA WSAData;
+WSADATA WSAData;
-	int ret;
+int ret;
-	ret = WSAStartup(0x0101, &WSAData);
+ret = WSAStartup(0x0101, &WSAData);
-	switch (ret) {
+switch (ret) {
-	case 0:	/* No error */
+case 0:     /* No error */
-		Py_AtExit(os_cleanup);
+Py_AtExit(os_cleanup);
-		return 1; /* Success */
+return 1; /* Success */
-	case WSASYSNOTREADY:
+case WSASYSNOTREADY:
-		PyErr_SetString(PyExc_ImportError,
+PyErr_SetString(PyExc_ImportError,
-				"WSAStartup failed: network not ready");
+"WSAStartup failed: network not ready");
-		break;
+break;
-	case WSAVERNOTSUPPORTED:
+case WSAVERNOTSUPPORTED:
-	case WSAEINVAL:
+case WSAEINVAL:
-		PyErr_SetString(
+PyErr_SetString(
-			PyExc_ImportError,
+PyExc_ImportError,
-			"WSAStartup failed: requested version not supported");
+"WSAStartup failed: requested version not supported");
-		break;
+break;
-	default:
+default:
-		PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
+PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
-		break;
+break;
-	}
+}
-	return 0; /* Failure */
+return 0; /* Failure */
 }
 #endif /* MS_WINDOWS */
 static int
 os_init(void)
 {
 #ifndef PYCC_GCC
-	int rc = sock_init();
+int rc = sock_init();
-	if (rc == 0) {
+if (rc == 0) {
-		return 1; /* Success */
+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 */
+/* No need to initialise sockets with GCC/EMX */
-	return 1; /* Success */
+return 1; /* Success */
 #endif
 }
 #endif /* PYOS_OS2 */
 #ifndef OS_INIT_DEFINED
 static int
 os_init(void)
 {
-	return 1; /* Success */
+return 1; /* Success */
 }
 #endif
 /* C API table - always add new things to the end for binary
 compatibility. */
 static
 PySocketModule_APIObject PySocketModuleAPI =
 {
-	&sock_type,
+&sock_type,
 NULL
 };
 /* Initialize the _socket module.
 "Implementation module for socket operations.\n\
 \n\
 See the socket module for documentation.");
 static struct PyModuleDef socketmodule = {
-	PyModuleDef_HEAD_INIT,
+PyModuleDef_HEAD_INIT,
-	PySocket_MODULE_NAME,
+PySocket_MODULE_NAME,
-	socket_doc,
+socket_doc,
-	-1,
+-1,
-	socket_methods,
+socket_methods,
-	NULL,
+NULL,
-	NULL,
+NULL,
-	NULL,
+NULL,
-	NULL
+NULL
 };
 PyMODINIT_FUNC
 PyInit__socket(void)
 {
-	PyObject *m, *has_ipv6;
+PyObject *m, *has_ipv6;
-	if (!os_init())
+if (!os_init())
-		return NULL;
+return NULL;
-	Py_TYPE(&sock_type) = &PyType_Type;
+Py_TYPE(&sock_type) = &PyType_Type;
-	m = PyModule_Create(&socketmodule);
+m = PyModule_Create(&socketmodule);
-	if (m == NULL)
+if (m == NULL)
-		return NULL;
+return NULL;
-	socket_error = PyErr_NewException("socket.error",
+socket_error = PyErr_NewException("socket.error",
-					  PyExc_IOError, NULL);
+PyExc_IOError, NULL);
-	if (socket_error == NULL)
+if (socket_error == NULL)
-		return NULL;
+return NULL;
 PySocketModuleAPI.error = socket_error;
-	Py_INCREF(socket_error);
+Py_INCREF(socket_error);
-	PyModule_AddObject(m, "error", socket_error);
+PyModule_AddObject(m, "error", socket_error);
-	socket_herror = PyErr_NewException("socket.herror",
+socket_herror = PyErr_NewException("socket.herror",
-					   socket_error, NULL);
+socket_error, NULL);
-	if (socket_herror == NULL)
+if (socket_herror == NULL)
-		return NULL;
+return NULL;
-	Py_INCREF(socket_herror);
+Py_INCREF(socket_herror);
-	PyModule_AddObject(m, "herror", socket_herror);
+PyModule_AddObject(m, "herror", socket_herror);
-	socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
+socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
-	    NULL);
+NULL);
-	if (socket_gaierror == NULL)
+if (socket_gaierror == NULL)
-		return NULL;
+return NULL;
-	Py_INCREF(socket_gaierror);
+Py_INCREF(socket_gaierror);
-	PyModule_AddObject(m, "gaierror", socket_gaierror);
+PyModule_AddObject(m, "gaierror", socket_gaierror);
-	socket_timeout = PyErr_NewException("socket.timeout",
+socket_timeout = PyErr_NewException("socket.timeout",
-					    socket_error, NULL);
+socket_error, NULL);
-	if (socket_timeout == NULL)
+if (socket_timeout == NULL)
-		return NULL;
+return NULL;
-	Py_INCREF(socket_timeout);
+Py_INCREF(socket_timeout);
-	PyModule_AddObject(m, "timeout", socket_timeout);
+PyModule_AddObject(m, "timeout", socket_timeout);
-	Py_INCREF((PyObject *)&sock_type);
+Py_INCREF((PyObject *)&sock_type);
-	if (PyModule_AddObject(m, "SocketType",
+if (PyModule_AddObject(m, "SocketType",
-			       (PyObject *)&sock_type) != 0)
+(PyObject *)&sock_type) != 0)
-		return NULL;
+return NULL;
-	Py_INCREF((PyObject *)&sock_type);
+Py_INCREF((PyObject *)&sock_type);
-	if (PyModule_AddObject(m, "socket",
+if (PyModule_AddObject(m, "socket",
-			       (PyObject *)&sock_type) != 0)
+(PyObject *)&sock_type) != 0)
-		return NULL;
+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);
+Py_INCREF(has_ipv6);
-	PyModule_AddObject(m, "has_ipv6", has_ipv6);
+PyModule_AddObject(m, "has_ipv6", has_ipv6);
-	/* Export C API */
+/* Export C API */
-	if (PyModule_AddObject(m, PySocket_CAPI_NAME,
+if (PyModule_AddObject(m, PySocket_CAPI_NAME,
-	       PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
+PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
-				 ) != 0)
+) != 0)
-		return NULL;
+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 */
+/* Amateur Radio AX.25 */
-	PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
+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 */
+/* Appletalk DDP */
-	PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
+PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
 #endif
 #ifdef AF_NETROM
-	/* Amateur radio NetROM */
+/* Amateur radio NetROM */
-	PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
+PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
 #endif
 #ifdef AF_BRIDGE
-	/* Multiprotocol bridge */
+/* Multiprotocol bridge */
-	PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
+PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
 #endif
 #ifdef AF_ATMPVC
-	/* ATM PVCs */
+/* ATM PVCs */
-	PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
+PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
 #endif
 #ifdef AF_AAL5
-	/* Reserved for Werner's ATM */
+/* Reserved for Werner's ATM */
-	PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
+PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
 #endif
 #ifdef AF_X25
-	/* Reserved for X.25 project */
+/* Reserved for X.25 project */
-	PyModule_AddIntConstant(m, "AF_X25", AF_X25);
+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 */
+/* Amateur Radio X.25 PLP */
-	PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
+PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
 #endif
 #ifdef AF_DECnet
-	/* Reserved for DECnet project */
+/* Reserved for DECnet project */
-	PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
+PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
 #endif
 #ifdef AF_NETBEUI
-	/* Reserved for 802.2LLC project */
+/* Reserved for 802.2LLC project */
-	PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
+PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
 #endif
 #ifdef AF_SECURITY
-	/* Security callback pseudo AF */
+/* Security callback pseudo AF */
-	PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
+PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
 #endif
 #ifdef AF_KEY
-	/* PF_KEY key management API */
+/* PF_KEY key management API */
-	PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
+PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
 #endif
 #ifdef AF_NETLINK
-	/*  */
+/*  */
-	PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
+PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
-	PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
+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_USERSOCK", NETLINK_USERSOCK);
-	PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
+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 */
+/* Alias to emulate 4.4BSD */
-	PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
+PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
 #endif
 #ifdef AF_ASH
-	/* Ash */
+/* Ash */
-	PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
+PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
 #endif
 #ifdef AF_ECONET
-	/* Acorn Econet */
+/* Acorn Econet */
-	PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
+PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
 #endif
 #ifdef AF_ATMSVC
-	/* ATM SVCs */
+/* ATM SVCs */
-	PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
+PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
 #endif
 #ifdef AF_SNA
-	/* Linux SNA Project (nutters!) */
+/* Linux SNA Project (nutters!) */
-	PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
+PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
 #endif
 #ifdef AF_IRDA
-	/* IRDA sockets */
+/* IRDA sockets */
-	PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
+PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
 #endif
 #ifdef AF_PPPOX
-	/* PPPoX sockets */
+/* PPPoX sockets */
-	PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
+PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
 #endif
 #ifdef AF_WANPIPE
-	/* Wanpipe API Sockets */
+/* Wanpipe API Sockets */
-	PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
+PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
 #endif
 #ifdef AF_LLC
-	/* Linux LLC */
+/* Linux LLC */
-	PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
+PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
 #endif
 #ifdef USE_BLUETOOTH
-	PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
+PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
-	PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
+PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
-	PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
+PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
-	PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
+PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
-	PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
+PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
 #if !defined(__FreeBSD__)
-	PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
+PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
-	PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
+PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
-	PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
+PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
 #endif
-	PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
+PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
-	PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
+PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
-	PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
+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, "AF_PACKET", AF_PACKET);
-	PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
+PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
-	PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
+PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
-	PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
+PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
-	PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
+PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
-	PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
+PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
-	PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
+PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
-	PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
+PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
-	PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
+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 */
+/* for addresses */
-	PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
+PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
-	PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
+PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
-	PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
+PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
-	PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
+PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
-	PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
+PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
-	PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
+PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
-	/* for setsockopt() */
+/* for setsockopt() */
-	PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
+PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
-	PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
+PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
-	PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
+PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
-	PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
+PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
-			TIPC_DEST_DROPPABLE);
+TIPC_DEST_DROPPABLE);
-	PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
+PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
-	PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
+PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
-			TIPC_LOW_IMPORTANCE);
+TIPC_LOW_IMPORTANCE);
-	PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
+PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
-			TIPC_MEDIUM_IMPORTANCE);
+TIPC_MEDIUM_IMPORTANCE);
-	PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
+PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
-			TIPC_HIGH_IMPORTANCE);
+TIPC_HIGH_IMPORTANCE);
-	PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
+PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
-			TIPC_CRITICAL_IMPORTANCE);
+TIPC_CRITICAL_IMPORTANCE);
-	/* for subscriptions */
+/* for subscriptions */
-	PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
+PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
-	PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
+PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
 #ifdef TIPC_SUB_CANCEL
-	/* doesn't seem to be available everywhere */
+/* doesn't seem to be available everywhere */
-	PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
+PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
 #endif
-	PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
+PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
-	PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
+PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
-	PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
+PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
-	PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
+PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
-	PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
+PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
-	PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
+PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
 #endif
-	/* Socket types */
+/* Socket types */
-	PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
+PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
-	PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
+PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
 /* We have incomplete socket support. */
-	PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
+PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
-	PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
+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
+#ifdef  SO_DEBUG
-	PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
+PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
 #endif
-#ifdef	SO_ACCEPTCONN
+#ifdef  SO_ACCEPTCONN
-	PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
+PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
 #endif
-#ifdef	SO_REUSEADDR
+#ifdef  SO_REUSEADDR
-	PyModule_AddIntConstant(m, "SO_REUSEADDR", 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
+#ifdef  SO_KEEPALIVE
-	PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
+PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
 #endif
-#ifdef	SO_DONTROUTE
+#ifdef  SO_DONTROUTE
-	PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
+PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
 #endif
-#ifdef	SO_BROADCAST
+#ifdef  SO_BROADCAST
-	PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
+PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
 #endif
-#ifdef	SO_USELOOPBACK
+#ifdef  SO_USELOOPBACK
-	PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
+PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
 #endif
-#ifdef	SO_LINGER
+#ifdef  SO_LINGER
-	PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
+PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
 #endif
-#ifdef	SO_OOBINLINE
+#ifdef  SO_OOBINLINE
-	PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
+PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
 #endif
-#ifdef	SO_REUSEPORT
+#ifdef  SO_REUSEPORT
-	PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
+PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
 #endif
-#ifdef	SO_SNDBUF
+#ifdef  SO_SNDBUF
-	PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
+PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
 #endif
-#ifdef	SO_RCVBUF
+#ifdef  SO_RCVBUF
-	PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
+PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
 #endif
-#ifdef	SO_SNDLOWAT
+#ifdef  SO_SNDLOWAT
-	PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
+PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
 #endif
-#ifdef	SO_RCVLOWAT
+#ifdef  SO_RCVLOWAT
-	PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
+PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
 #endif
-#ifdef	SO_SNDTIMEO
+#ifdef  SO_SNDTIMEO
-	PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
+PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
 #endif
-#ifdef	SO_RCVTIMEO
+#ifdef  SO_RCVTIMEO
-	PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
+PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
 #endif
-#ifdef	SO_ERROR
+#ifdef  SO_ERROR
-	PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
+PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
 #endif
-#ifdef	SO_TYPE
+#ifdef  SO_TYPE
-	PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
+PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
 #endif
-	/* Maximum number of connections for "listen" */
+/* Maximum number of connections for "listen" */
-#ifdef	SOMAXCONN
+#ifdef  SOMAXCONN
-	PyModule_AddIntConstant(m, "SOMAXCONN", 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 */
+/* Flags for send, recv */
-#ifdef	MSG_OOB
+#ifdef  MSG_OOB
-	PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
+PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
 #endif
-#ifdef	MSG_PEEK
+#ifdef  MSG_PEEK
-	PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
+PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
 #endif
-#ifdef	MSG_DONTROUTE
+#ifdef  MSG_DONTROUTE
-	PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
+PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
 #endif
-#ifdef	MSG_DONTWAIT
+#ifdef  MSG_DONTWAIT
-	PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
+PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
 #endif
-#ifdef	MSG_EOR
+#ifdef  MSG_EOR
-	PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
+PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
 #endif
-#ifdef	MSG_TRUNC
+#ifdef  MSG_TRUNC
-	PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
+PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
 #endif
-#ifdef	MSG_CTRUNC
+#ifdef  MSG_CTRUNC
-	PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
+PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
 #endif
-#ifdef	MSG_WAITALL
+#ifdef  MSG_WAITALL
-	PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
+PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
 #endif
-#ifdef	MSG_BTAG
+#ifdef  MSG_BTAG
-	PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
+PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
 #endif
-#ifdef	MSG_ETAG
+#ifdef  MSG_ETAG
-	PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
+PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
 #endif
-	/* Protocol level and numbers, usable for [gs]etsockopt */
+/* Protocol level and numbers, usable for [gs]etsockopt */
-#ifdef	SOL_SOCKET
+#ifdef  SOL_SOCKET
-	PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
+PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
 #endif
-#ifdef	SOL_IP
+#ifdef  SOL_IP
-	PyModule_AddIntConstant(m, "SOL_IP", 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
+#ifdef  SOL_IPX
-	PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
+PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
 #endif
-#ifdef	SOL_AX25
+#ifdef  SOL_AX25
-	PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
+PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
 #endif
-#ifdef	SOL_ATALK
+#ifdef  SOL_ATALK
-	PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
+PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
 #endif
-#ifdef	SOL_NETROM
+#ifdef  SOL_NETROM
-	PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
+PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
 #endif
-#ifdef	SOL_ROSE
+#ifdef  SOL_ROSE
-	PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
+PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
 #endif
-#ifdef	SOL_TCP
+#ifdef  SOL_TCP
-	PyModule_AddIntConstant(m, "SOL_TCP", 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
+#ifdef  SOL_UDP
-	PyModule_AddIntConstant(m, "SOL_UDP", 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
+#ifdef  IPPROTO_IP
-	PyModule_AddIntConstant(m, "IPPROTO_IP", 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
+#ifdef  IPPROTO_HOPOPTS
-	PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
+PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
 #endif
-#ifdef	IPPROTO_ICMP
+#ifdef  IPPROTO_ICMP
-	PyModule_AddIntConstant(m, "IPPROTO_ICMP", 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
+#ifdef  IPPROTO_IGMP
-	PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
+PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
 #endif
-#ifdef	IPPROTO_GGP
+#ifdef  IPPROTO_GGP
-	PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
+PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
 #endif
-#ifdef	IPPROTO_IPV4
+#ifdef  IPPROTO_IPV4
-	PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
+PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
 #endif
-#ifdef	IPPROTO_IPV6
+#ifdef  IPPROTO_IPV6
-	PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
 #endif
-#ifdef	IPPROTO_IPIP
+#ifdef  IPPROTO_IPIP
-	PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
+PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
 #endif
-#ifdef	IPPROTO_TCP
+#ifdef  IPPROTO_TCP
-	PyModule_AddIntConstant(m, "IPPROTO_TCP", 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
+#ifdef  IPPROTO_EGP
-	PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
+PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
 #endif
-#ifdef	IPPROTO_PUP
+#ifdef  IPPROTO_PUP
-	PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
+PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
 #endif
-#ifdef	IPPROTO_UDP
+#ifdef  IPPROTO_UDP
-	PyModule_AddIntConstant(m, "IPPROTO_UDP", 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
+#ifdef  IPPROTO_IDP
-	PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
+PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
 #endif
-#ifdef	IPPROTO_HELLO
+#ifdef  IPPROTO_HELLO
-	PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
+PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
 #endif
-#ifdef	IPPROTO_ND
+#ifdef  IPPROTO_ND
-	PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
+PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
 #endif
-#ifdef	IPPROTO_TP
+#ifdef  IPPROTO_TP
-	PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
+PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
 #endif
-#ifdef	IPPROTO_IPV6
+#ifdef  IPPROTO_IPV6
-	PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
+PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
 #endif
-#ifdef	IPPROTO_ROUTING
+#ifdef  IPPROTO_ROUTING
-	PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
+PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
 #endif
-#ifdef	IPPROTO_FRAGMENT
+#ifdef  IPPROTO_FRAGMENT
-	PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
+PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
 #endif
-#ifdef	IPPROTO_RSVP
+#ifdef  IPPROTO_RSVP
-	PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
+PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
 #endif
-#ifdef	IPPROTO_GRE
+#ifdef  IPPROTO_GRE
-	PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
+PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
 #endif
-#ifdef	IPPROTO_ESP
+#ifdef  IPPROTO_ESP
-	PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
+PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
 #endif
-#ifdef	IPPROTO_AH
+#ifdef  IPPROTO_AH
-	PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
+PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
 #endif
-#ifdef	IPPROTO_MOBILE
+#ifdef  IPPROTO_MOBILE
-	PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
+PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
 #endif
-#ifdef	IPPROTO_ICMPV6
+#ifdef  IPPROTO_ICMPV6
-	PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
+PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
 #endif
-#ifdef	IPPROTO_NONE
+#ifdef  IPPROTO_NONE
-	PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
+PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
 #endif
-#ifdef	IPPROTO_DSTOPTS
+#ifdef  IPPROTO_DSTOPTS
-	PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
+PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
 #endif
-#ifdef	IPPROTO_XTP
+#ifdef  IPPROTO_XTP
-	PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
+PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
 #endif
-#ifdef	IPPROTO_EON
+#ifdef  IPPROTO_EON
-	PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
+PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
 #endif
-#ifdef	IPPROTO_PIM
+#ifdef  IPPROTO_PIM
-	PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
+PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
 #endif
-#ifdef	IPPROTO_IPCOMP
+#ifdef  IPPROTO_IPCOMP
-	PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
+PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
 #endif
-#ifdef	IPPROTO_VRRP
+#ifdef  IPPROTO_VRRP
-	PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
+PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
 #endif
-#ifdef	IPPROTO_BIP
+#ifdef  IPPROTO_BIP
-	PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
+PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
 #endif
 /**/
-#ifdef	IPPROTO_RAW
+#ifdef  IPPROTO_RAW
-	PyModule_AddIntConstant(m, "IPPROTO_RAW", 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
+#ifdef  IPPROTO_MAX
-	PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
+PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
 #endif
-	/* Some port configuration */
+/* Some port configuration */
-#ifdef	IPPORT_RESERVED
+#ifdef  IPPORT_RESERVED
-	PyModule_AddIntConstant(m, "IPPORT_RESERVED", 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
+#ifdef  IPPORT_USERRESERVED
-	PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 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 */
+/* Some reserved IP v.4 addresses */
-#ifdef	INADDR_ANY
+#ifdef  INADDR_ANY
-	PyModule_AddIntConstant(m, "INADDR_ANY", 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
+#ifdef  INADDR_BROADCAST
-	PyModule_AddIntConstant(m, "INADDR_BROADCAST", 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
+#ifdef  INADDR_LOOPBACK
-	PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 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
+#ifdef  INADDR_UNSPEC_GROUP
-	PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 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
+#ifdef  INADDR_ALLHOSTS_GROUP
-	PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
+PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
-				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
+#ifdef  INADDR_MAX_LOCAL_GROUP
-	PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
+PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
-				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
+#ifdef  INADDR_NONE
-	PyModule_AddIntConstant(m, "INADDR_NONE", 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 */
+/* IPv4 [gs]etsockopt options */
-#ifdef	IP_OPTIONS
+#ifdef  IP_OPTIONS
-	PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
+PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
 #endif
-#ifdef	IP_HDRINCL
+#ifdef  IP_HDRINCL
-	PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
+PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
 #endif
-#ifdef	IP_TOS
+#ifdef  IP_TOS
-	PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
+PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
 #endif
-#ifdef	IP_TTL
+#ifdef  IP_TTL
-	PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
+PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
 #endif
-#ifdef	IP_RECVOPTS
+#ifdef  IP_RECVOPTS
-	PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
+PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
 #endif
-#ifdef	IP_RECVRETOPTS
+#ifdef  IP_RECVRETOPTS
-	PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
+PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
 #endif
-#ifdef	IP_RECVDSTADDR
+#ifdef  IP_RECVDSTADDR
-	PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
+PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
 #endif
-#ifdef	IP_RETOPTS
+#ifdef  IP_RETOPTS
-	PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
+PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
 #endif
-#ifdef	IP_MULTICAST_IF
+#ifdef  IP_MULTICAST_IF
-	PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
+PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
 #endif
-#ifdef	IP_MULTICAST_TTL
+#ifdef  IP_MULTICAST_TTL
-	PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
+PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
 #endif
-#ifdef	IP_MULTICAST_LOOP
+#ifdef  IP_MULTICAST_LOOP
-	PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
+PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
 #endif
-#ifdef	IP_ADD_MEMBERSHIP
+#ifdef  IP_ADD_MEMBERSHIP
-	PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
+PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
 #endif
-#ifdef	IP_DROP_MEMBERSHIP
+#ifdef  IP_DROP_MEMBERSHIP
-	PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
+PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
 #endif
-#ifdef	IP_DEFAULT_MULTICAST_TTL
+#ifdef  IP_DEFAULT_MULTICAST_TTL
-	PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
+PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
-				IP_DEFAULT_MULTICAST_TTL);
+IP_DEFAULT_MULTICAST_TTL);
 #endif
-#ifdef	IP_DEFAULT_MULTICAST_LOOP
+#ifdef  IP_DEFAULT_MULTICAST_LOOP
-	PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
+PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
-				IP_DEFAULT_MULTICAST_LOOP);
+IP_DEFAULT_MULTICAST_LOOP);
 #endif
-#ifdef	IP_MAX_MEMBERSHIPS
+#ifdef  IP_MAX_MEMBERSHIPS
-	PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
+PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
 #endif
-	/* IPv6 [gs]etsockopt options, defined in RFC2553 */
+/* IPv6 [gs]etsockopt options, defined in RFC2553 */
-#ifdef	IPV6_JOIN_GROUP
+#ifdef  IPV6_JOIN_GROUP
-	PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
+PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
 #endif
-#ifdef	IPV6_LEAVE_GROUP
+#ifdef  IPV6_LEAVE_GROUP
-	PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
+PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
 #endif
-#ifdef	IPV6_MULTICAST_HOPS
+#ifdef  IPV6_MULTICAST_HOPS
-	PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
+PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
 #endif
-#ifdef	IPV6_MULTICAST_IF
+#ifdef  IPV6_MULTICAST_IF
-	PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
+PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
 #endif
-#ifdef	IPV6_MULTICAST_LOOP
+#ifdef  IPV6_MULTICAST_LOOP
-	PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
+PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
 #endif
-#ifdef	IPV6_UNICAST_HOPS
+#ifdef  IPV6_UNICAST_HOPS
-	PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
+PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
 #endif
 /* 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 */
+/* TCP options */
-#ifdef	TCP_NODELAY
+#ifdef  TCP_NODELAY
-	PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
+PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
 #endif
-#ifdef	TCP_MAXSEG
+#ifdef  TCP_MAXSEG
-	PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
+PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
 #endif
-#ifdef	TCP_CORK
+#ifdef  TCP_CORK
-	PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
+PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
 #endif
-#ifdef	TCP_KEEPIDLE
+#ifdef  TCP_KEEPIDLE
-	PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
+PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
 #endif
-#ifdef	TCP_KEEPINTVL
+#ifdef  TCP_KEEPINTVL
-	PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
+PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
 #endif
-#ifdef	TCP_KEEPCNT
+#ifdef  TCP_KEEPCNT
-	PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
+PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
 #endif
-#ifdef	TCP_SYNCNT
+#ifdef  TCP_SYNCNT
-	PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
+PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
 #endif
-#ifdef	TCP_LINGER2
+#ifdef  TCP_LINGER2
-	PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
+PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
 #endif
-#ifdef	TCP_DEFER_ACCEPT
+#ifdef  TCP_DEFER_ACCEPT
-	PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
+PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
 #endif
-#ifdef	TCP_WINDOW_CLAMP
+#ifdef  TCP_WINDOW_CLAMP
-	PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
+PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
 #endif
-#ifdef	TCP_INFO
+#ifdef  TCP_INFO
-	PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
+PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
 #endif
-#ifdef	TCP_QUICKACK
+#ifdef  TCP_QUICKACK
-	PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
+PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
 #endif
-	/* IPX options */
+/* IPX options */
-#ifdef	IPX_TYPE
+#ifdef  IPX_TYPE
-	PyModule_AddIntConstant(m, "IPX_TYPE", 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
-	{
+{
-		PyObject *tmp;
+PyObject *tmp;
-		tmp = PyLong_FromUnsignedLong(SIO_RCVALL);
+tmp = PyLong_FromUnsignedLong(SIO_RCVALL);
-		if (tmp == NULL)
+if (tmp == NULL)
-			return NULL;
+return NULL;
-		PyModule_AddObject(m, "SIO_RCVALL", tmp);
+PyModule_AddObject(m, "SIO_RCVALL", tmp);
-	}
+}
-	PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
+PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
-	PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
+PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
-	PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
+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;
 }
 #ifndef HAVE_INET_PTON
 #if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
 /* These are not exposed because they do not set errno properly */
 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;
+unsigned int packed_addr;
-		packed_addr = inet_addr(src);
+packed_addr = inet_addr(src);
-		if (packed_addr == INADDR_NONE)
+if (packed_addr == INADDR_NONE)
-			return 0;
+return 0;
-		memcpy(dst, &packed_addr, 4);
+memcpy(dst, &packed_addr, 4);
-		return 1;
+return 1;
-	}
+}
-	/* Should set errno to EAFNOSUPPORT */
+/* Should set errno to EAFNOSUPPORT */
-	return -1;
+return -1;
 }
 const char *
 inet_ntop(int af, const void *src, char *dst, socklen_t size)
 {
-	if (af == AF_INET) {
+if (af == AF_INET) {
-		struct in_addr packed_addr;
+struct in_addr packed_addr;
-		if (size < 16)
+if (size < 16)
-			/* Should set errno to ENOSPC. */
+/* Should set errno to ENOSPC. */
-			return NULL;
+return NULL;
-		memcpy(&packed_addr, src, sizeof(packed_addr));
+memcpy(&packed_addr, src, sizeof(packed_addr));
-		return strncpy(dst, inet_ntoa(packed_addr), size);
+return strncpy(dst, inet_ntoa(packed_addr), size);
-	}
+}
-	/* Should set errno to EAFNOSUPPORT */
+/* Should set errno to EAFNOSUPPORT */
-	return NULL;
+return NULL;
 }
 #endif
 #endif

Mercurial > cpython-lru_cache-weakref

comparison Modules/socketmodule.c @ 61467:f197407bdba2 3.1