blob: 3e1a460703261eafa93b6afa0cd820fad0932135 [file] [log] [blame]
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001/* Socket module */
2
3/*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005This module provides an interface to Berkeley socket IPC.
6
7Limitations:
8
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00009- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
Christian Heimes043d6f62008-01-07 17:19:16 +000010 portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported
11 under Linux.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000012- No read/write operations (use sendall/recv or makefile instead).
13- Additional restrictions apply on some non-Unix platforms (compensated
14 for by socket.py).
Guido van Rossum6574b3e1991-06-25 21:36:08 +000015
Guido van Rossum27e177d1995-03-16 15:43:47 +000016Module interface:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000017
Andrew Svetlov0832af62012-12-18 23:10:48 +020018- socket.error: exception raised for socket specific errors, alias for OSError
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000019- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000020 a subclass of socket.error
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000021- socket.herror: exception raised for gethostby* errors,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000022 a subclass of socket.error
Guido van Rossum30a685f1991-06-27 15:51:29 +000023- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
Guido van Rossum3bbc62e1995-01-02 19:30:30 +000024- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
Guido van Rossum27e177d1995-03-16 15:43:47 +000025- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
Guido van Rossum25405c71996-12-19 16:42:52 +000026- socket.getprotobyname(protocolname) --> protocol number
Barry Warsaw11b91a02004-06-28 00:50:43 +000027- socket.getservbyname(servicename[, protocolname]) --> port number
28- socket.getservbyport(portnumber[, protocolname]) --> service name
Guido van Rossum7d0a8262007-05-21 23:13:11 +000029- socket.socket([family[, type [, proto, fileno]]]) --> new socket object
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000030 (fileno specifies a pre-existing socket file descriptor)
Dave Cole331708b2004-08-09 04:51:41 +000031- socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
Guido van Rossum006bf911996-06-12 04:04:55 +000032- socket.ntohs(16 bit value) --> new int object
33- socket.ntohl(32 bit value) --> new int object
34- socket.htons(16 bit value) --> new int object
35- socket.htonl(32 bit value) --> new int object
Berker Peksaga6ec5ee2014-06-30 11:28:40 +030036- socket.getaddrinfo(host, port [, family, type, proto, flags])
37 --> List of (family, type, proto, canonname, sockaddr)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000038- socket.getnameinfo(sockaddr, flags) --> (host, port)
Guido van Rossum27e177d1995-03-16 15:43:47 +000039- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
Guido van Rossum47dfa4a2003-04-25 05:48:32 +000040- socket.has_ipv6: boolean value indicating if IPv6 is supported
Guido van Rossum5c9eb211999-08-20 18:21:51 +000041- socket.inet_aton(IP address) -> 32-bit packed IP representation
42- socket.inet_ntoa(packed IP) -> IP address string
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +000043- socket.getdefaulttimeout() -> None | float
44- socket.setdefaulttimeout(None | float)
Gregory P. Smith5ed2e772011-05-15 00:26:45 -070045- socket.if_nameindex() -> list of tuples (if_index, if_name)
46- socket.if_nametoindex(name) -> corresponding interface index
47- socket.if_indextoname(index) -> corresponding interface name
Guido van Rossum6574b3e1991-06-25 21:36:08 +000048- an Internet socket address is a pair (hostname, port)
49 where hostname can be anything recognized by gethostbyname()
50 (including the dd.dd.dd.dd notation) and port is in host byte order
51- where a hostname is returned, the dd.dd.dd.dd notation is used
Guido van Rossum27e177d1995-03-16 15:43:47 +000052- a UNIX domain socket address is a string specifying the pathname
Jeremy Hylton22308652001-02-02 03:23:09 +000053- an AF_PACKET socket address is a tuple containing a string
54 specifying the ethernet interface and an integer specifying
55 the Ethernet protocol number to be received. For example:
Jeremy Hyltondbfb6622001-02-02 19:55:17 +000056 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
Andrew M. Kuchlingb8e17172004-07-10 23:39:35 +000057 specify packet-type and ha-type/addr.
Christian Heimes043d6f62008-01-07 17:19:16 +000058- an AF_TIPC socket address is expressed as
59 (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000060 TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
Christian Heimes043d6f62008-01-07 17:19:16 +000061 and scope can be one of:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000062 TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
Christian Heimes043d6f62008-01-07 17:19:16 +000063 The meaning of v1, v2 and v3 depends on the value of addr_type:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000064 if addr_type is TIPC_ADDR_NAME:
65 v1 is the server type
66 v2 is the port identifier
67 v3 is ignored
68 if addr_type is TIPC_ADDR_NAMESEQ:
69 v1 is the server type
70 v2 is the lower port number
71 v3 is the upper port number
72 if addr_type is TIPC_ADDR_ID:
73 v1 is the node
74 v2 is the ref
75 v3 is ignored
Christian Heimes043d6f62008-01-07 17:19:16 +000076
Guido van Rossum6574b3e1991-06-25 21:36:08 +000077
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000078Local naming conventions:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000079
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000080- names starting with sock_ are socket object methods
81- names starting with socket_ are module-level functions
82- names starting with PySocket are exported through socketmodule.h
Guido van Rossum30a685f1991-06-27 15:51:29 +000083
Guido van Rossum6574b3e1991-06-25 21:36:08 +000084*/
85
Thomas Wouters477c8d52006-05-27 19:21:47 +000086#ifdef __APPLE__
Ned Deily47299fd2016-02-15 16:54:08 +110087#include <AvailabilityMacros.h>
88/* for getaddrinfo thread safety test on old versions of OS X */
89#ifndef MAC_OS_X_VERSION_10_5
90#define MAC_OS_X_VERSION_10_5 1050
91#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +000092 /*
93 * inet_aton is not available on OSX 10.3, yet we want to use a binary
94 * that was build on 10.4 or later to work on that release, weak linking
95 * comes to the rescue.
96 */
97# pragma weak inet_aton
98#endif
99
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000100#include "Python.h"
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000101#include "structmember.h"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000102
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000103/* Socket object documentation */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000104PyDoc_STRVAR(sock_doc,
Victor Stinnerdaf45552013-08-28 00:53:59 +0200105"socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None) -> socket object\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000106\n\
107Open a socket of the given type. The family argument specifies the\n\
108address family; it defaults to AF_INET. The type argument specifies\n\
109whether this is a stream (SOCK_STREAM, this is the default)\n\
110or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
111specifying the default protocol. Keyword arguments are accepted.\n\
Victor Stinnerdaf45552013-08-28 00:53:59 +0200112The socket is created as non-inheritable.\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000113\n\
114A socket object represents one endpoint of a network connection.\n\
115\n\
116Methods of socket objects (keyword arguments not allowed):\n\
117\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000118_accept() -- accept connection, returning new socket fd and client address\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000119bind(addr) -- bind the socket to a local address\n\
120close() -- close the socket\n\
121connect(addr) -- connect the socket to a remote address\n\
122connect_ex(addr) -- connect, return an error code instead of an exception\n\
Victor Stinnerdaf45552013-08-28 00:53:59 +0200123dup() -- return a new socket fd duplicated from fileno()\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000124fileno() -- return underlying file descriptor\n\
125getpeername() -- return remote address [*]\n\
126getsockname() -- return local address\n\
127getsockopt(level, optname[, buflen]) -- get socket options\n\
128gettimeout() -- return timeout or None\n\
Charles-François Natali644b8f52014-05-22 19:45:39 +0100129listen([n]) -- start listening for incoming connections\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000130recv(buflen[, flags]) -- receive data\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000131recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000132recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000133recvfrom_into(buffer[, nbytes, [, flags])\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000134 -- receive data and sender\'s address (into a buffer)\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000135sendall(data[, flags]) -- send all data\n\
136send(data[, flags]) -- send data, may not send all of it\n\
137sendto(data[, flags], addr) -- send data to a given address\n\
138setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
139setsockopt(level, optname, value) -- set socket options\n\
140settimeout(None | float) -- set or clear the timeout\n\
141shutdown(how) -- shut down traffic in one or both directions\n\
Gregory P. Smith5ed2e772011-05-15 00:26:45 -0700142if_nameindex() -- return all network interface indices and names\n\
Gregory P. Smithb6471db2011-05-22 22:47:55 -0700143if_nametoindex(name) -- return the corresponding interface index\n\
144if_indextoname(index) -- return the corresponding interface name\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000145\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000146 [*] not available on all platforms!");
Guido van Rossum3baaa131999-03-22 21:44:51 +0000147
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000148/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000149 I hope some day someone can clean this up please... */
150
Guido van Rossum9376b741999-09-15 22:01:40 +0000151/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
152 script doesn't get this right, so we hardcode some platform checks below.
153 On the other hand, not all Linux versions agree, so there the settings
154 computed by the configure script are needed! */
155
156#ifndef linux
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000157# undef HAVE_GETHOSTBYNAME_R_3_ARG
158# undef HAVE_GETHOSTBYNAME_R_5_ARG
159# undef HAVE_GETHOSTBYNAME_R_6_ARG
Guido van Rossum9376b741999-09-15 22:01:40 +0000160#endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000161
Victor Stinner710d27e2011-08-23 10:57:32 +0200162#if defined(__OpenBSD__)
163# include <sys/uio.h>
164#endif
165
Guido van Rossum7a122991999-04-13 04:07:32 +0000166#ifndef WITH_THREAD
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000167# undef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +0000168#endif
169
Guido van Rossume7de2061999-03-24 17:24:33 +0000170#ifdef HAVE_GETHOSTBYNAME_R
Jesus Cea736e7fc2011-03-14 17:36:54 +0100171# if defined(_AIX)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000172# define HAVE_GETHOSTBYNAME_R_3_ARG
173# elif defined(__sun) || defined(__sgi)
174# define HAVE_GETHOSTBYNAME_R_5_ARG
175# elif defined(linux)
Guido van Rossum9376b741999-09-15 22:01:40 +0000176/* Rely on the configure script */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000177# else
178# undef HAVE_GETHOSTBYNAME_R
179# endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000180#endif
181
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000182#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
183 !defined(MS_WINDOWS)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000184# define USE_GETHOSTBYNAME_LOCK
Guido van Rossum3baaa131999-03-22 21:44:51 +0000185#endif
186
Ned Deilye1d4e582016-02-23 22:05:29 +1100187/* To use __FreeBSD_version, __OpenBSD__, and __NetBSD_Version__ */
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000188#ifdef HAVE_SYS_PARAM_H
189#include <sys/param.h>
190#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000191/* On systems on which getaddrinfo() is believed to not be thread-safe,
Ned Deily47299fd2016-02-15 16:54:08 +1100192 (this includes the getaddrinfo emulation) protect access with a lock.
193
194 getaddrinfo is thread-safe on Mac OS X 10.5 and later. Originally it was
195 a mix of code including an unsafe implementation from an old BSD's
196 libresolv. In 10.5 Apple reimplemented it as a safe IPC call to the
197 mDNSResponder process. 10.5 is the first be UNIX '03 certified, which
Ned Deilye1d4e582016-02-23 22:05:29 +1100198 includes the requirement that getaddrinfo be thread-safe. See issue #25924.
Ned Deily47299fd2016-02-15 16:54:08 +1100199
Ned Deilye1d4e582016-02-23 22:05:29 +1100200 It's thread-safe in OpenBSD starting with 5.4, released Nov 2013:
201 http://www.openbsd.org/plus54.html
202
203 It's thread-safe in NetBSD starting with 4.0, released Dec 2007:
204
205http://cvsweb.netbsd.org/bsdweb.cgi/src/lib/libc/net/getaddrinfo.c.diff?r1=1.82&r2=1.83
Ned Deily47299fd2016-02-15 16:54:08 +1100206 */
207#if defined(WITH_THREAD) && ( \
208 (defined(__APPLE__) && \
209 MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5) || \
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000210 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
Ned Deilye1d4e582016-02-23 22:05:29 +1100211 (defined(__OpenBSD__) && OpenBSD+0 < 201311) || \
212 (defined(__NetBSD__) && __NetBSD_Version__+0 < 400000000) || \
Christian Heimesaf01f662013-12-21 16:19:10 +0100213 !defined(HAVE_GETADDRINFO))
Just van Rossum1040d2c2003-05-09 07:53:18 +0000214#define USE_GETADDRINFO_LOCK
215#endif
216
217#ifdef USE_GETADDRINFO_LOCK
218#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
219#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
220#else
221#define ACQUIRE_GETADDRINFO_LOCK
222#define RELEASE_GETADDRINFO_LOCK
223#endif
224
225#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000226# include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000227#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000228
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000229#if defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000230# include <types.h>
231# include <io.h>
232# include <sys/ioctl.h>
233# include <utils.h>
234# include <ctype.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000235#endif
236
Martin v. Löwis9d6c6692012-02-03 17:44:58 +0100237#ifdef __APPLE__
238# include <sys/ioctl.h>
239#endif
240
241
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000242#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000243/* make sure that the reentrant (gethostbyaddr_r etc)
244 functions are declared correctly if compiling with
245 MIPSPro 7.x in ANSI C mode (default) */
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000246
Thomas Wouters477c8d52006-05-27 19:21:47 +0000247/* XXX Using _SGIAPI is the wrong thing,
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000248 but I don't know what the right thing is. */
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000249#undef _SGIAPI /* to avoid warning */
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000250#define _SGIAPI 1
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000251
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000252#undef _XOPEN_SOURCE
253#include <sys/socket.h>
254#include <sys/types.h>
255#include <netinet/in.h>
256#ifdef _SS_ALIGNSIZE
257#define HAVE_GETADDRINFO 1
258#define HAVE_GETNAMEINFO 1
259#endif
260
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000261#define HAVE_INET_PTON
262#include <netdb.h>
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000263#endif
264
Thomas Wouters477c8d52006-05-27 19:21:47 +0000265/* Irix 6.5 fails to define this variable at all. This is needed
266 for both GCC and SGI's compiler. I'd say that the SGI headers
Georg Brandldbd83392006-02-20 09:42:33 +0000267 are just busted. Same thing for Solaris. */
268#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000269#define INET_ADDRSTRLEN 16
270#endif
271
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000272/* Generic includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000273#ifdef HAVE_SYS_TYPES_H
Guido van Rossumb6775db1994-08-01 11:34:53 +0000274#include <sys/types.h>
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000275#endif
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000276
Gregory P. Smith3b1f2c32011-05-15 12:18:23 -0700277#ifdef HAVE_SYS_SOCKET_H
278#include <sys/socket.h>
279#endif
280
281#ifdef HAVE_NET_IF_H
282#include <net/if.h>
283#endif
284
Marc-André Lemburg976ade62002-02-16 18:47:07 +0000285/* Generic socket object definitions and includes */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000286#define PySocket_BUILDING_SOCKET
Marc-André Lemburgbb8b78b2002-02-16 18:44:52 +0000287#include "socketmodule.h"
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000288
289/* Addressing includes */
290
Guido van Rossum6f489d91996-06-28 20:15:15 +0000291#ifndef MS_WINDOWS
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000292
293/* Non-MS WINDOWS includes */
294# include <netdb.h>
Nick Coghlan4ecf6cf2011-08-22 15:45:19 +1000295# include <unistd.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000296
Guido van Rossum9376b741999-09-15 22:01:40 +0000297/* Headers needed for inet_ntoa() and inet_addr() */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000298# include <arpa/inet.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000299
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000300# include <fcntl.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000301
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000302#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000303
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000304/* MS_WINDOWS includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000305# ifdef HAVE_FCNTL_H
306# include <fcntl.h>
307# endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000308
Steve Dower65e4cb12014-11-22 12:54:57 -0800309#if defined(_MSC_VER) && _MSC_VER >= 1800
310/* Provides the IsWindows7SP1OrGreater() function */
311#include <VersionHelpers.h>
312#endif
313
Jeremy Hylton22308652001-02-02 03:23:09 +0000314#endif
315
Skip Montanaro7befb992004-02-10 16:50:21 +0000316#include <stddef.h>
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000317
Neal Norwitz39d22e52002-11-02 19:55:21 +0000318#ifndef O_NONBLOCK
319# define O_NONBLOCK O_NDELAY
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000320#endif
321
Trent Micka708d6e2004-09-07 17:48:26 +0000322/* include Python's addrinfo.h unless it causes trouble */
323#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
324 /* Do not include addinfo.h on some newer IRIX versions.
325 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
326 * for example, but not by 6.5.10.
327 */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000328#elif defined(_MSC_VER) && _MSC_VER>1201
Trent Micka708d6e2004-09-07 17:48:26 +0000329 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
330 * EAI_* constants are defined in (the already included) ws2tcpip.h.
331 */
332#else
333# include "addrinfo.h"
334#endif
Jason Tishlerc246cb72004-08-09 13:25:59 +0000335
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000336#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +0000337#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000338int inet_pton(int af, const char *src, void *dst);
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000339const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000340#endif
Christian Heimesb6150692007-11-15 23:37:07 +0000341#endif
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000342
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000343#ifdef __APPLE__
344/* On OS X, getaddrinfo returns no error indication of lookup
345 failure, so we must use the emulation instead of the libinfo
346 implementation. Unfortunately, performing an autoconf test
347 for this bug would require DNS access for the machine performing
348 the configuration, which is not acceptable. Therefore, we
349 determine the bug just by checking for __APPLE__. If this bug
350 gets ever fixed, perhaps checking for sys/version.h would be
351 appropriate, which is 10/0 on the system with the bug. */
Jack Jansen84262fb2002-07-02 14:40:42 +0000352#ifndef HAVE_GETNAMEINFO
353/* This bug seems to be fixed in Jaguar. Ths easiest way I could
354 Find to check for Jaguar is that it has getnameinfo(), which
355 older releases don't have */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000356#undef HAVE_GETADDRINFO
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000357#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000358
359#ifdef HAVE_INET_ATON
360#define USE_INET_ATON_WEAKLINK
361#endif
362
Jack Jansen84262fb2002-07-02 14:40:42 +0000363#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000364
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000365/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000366#if !defined(HAVE_GETADDRINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000367/* avoid clashes with the C library definition of the symbol. */
368#define getaddrinfo fake_getaddrinfo
369#define gai_strerror fake_gai_strerror
370#define freeaddrinfo fake_freeaddrinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000371#include "getaddrinfo.c"
372#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000373#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000374#define getnameinfo fake_getnameinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000375#include "getnameinfo.c"
376#endif
377
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000378#ifdef MS_WINDOWS
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000379#define SOCKETCLOSE closesocket
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000380#endif
381
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000382#ifdef MS_WIN32
Kristján Valur Jónsson310052c2012-03-31 13:35:00 +0000383#undef EAFNOSUPPORT
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000384#define EAFNOSUPPORT WSAEAFNOSUPPORT
385#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000386#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000387
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000388#ifndef SOCKETCLOSE
389#define SOCKETCLOSE close
390#endif
391
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000392#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000393#define USE_BLUETOOTH 1
394#if defined(__FreeBSD__)
395#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
396#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
Thomas Wouterscf297e42007-02-23 15:07:44 +0000397#define BTPROTO_HCI BLUETOOTH_PROTO_HCI
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000398#define SOL_HCI SOL_HCI_RAW
399#define HCI_FILTER SO_HCI_RAW_FILTER
Hye-Shik Chang81268602004-02-02 06:05:24 +0000400#define sockaddr_l2 sockaddr_l2cap
401#define sockaddr_rc sockaddr_rfcomm
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000402#define hci_dev hci_node
Hye-Shik Chang81268602004-02-02 06:05:24 +0000403#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
404#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000405#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000406#elif defined(__NetBSD__) || defined(__DragonFly__)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000407#define sockaddr_l2 sockaddr_bt
408#define sockaddr_rc sockaddr_bt
Thomas Wouterscf297e42007-02-23 15:07:44 +0000409#define sockaddr_hci sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000410#define sockaddr_sco sockaddr_bt
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000411#define SOL_HCI BTPROTO_HCI
412#define HCI_DATA_DIR SO_HCI_DIRECTION
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000413#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
414#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000415#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000416#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000417#else
Hye-Shik Chang81268602004-02-02 06:05:24 +0000418#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
419#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000420#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000421#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
422#endif
423#endif
424
Charles-François Natali8b759652011-12-23 16:44:51 +0100425/* Convert "sock_addr_t *" to "struct sockaddr *". */
426#define SAS2SA(x) (&((x)->sa))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000427
Martin v. Löwise9416172003-05-03 10:12:45 +0000428/*
429 * Constants for getnameinfo()
430 */
431#if !defined(NI_MAXHOST)
432#define NI_MAXHOST 1025
433#endif
434#if !defined(NI_MAXSERV)
435#define NI_MAXSERV 32
436#endif
437
Guido van Rossum7d0a8262007-05-21 23:13:11 +0000438#ifndef INVALID_SOCKET /* MS defines this */
439#define INVALID_SOCKET (-1)
440#endif
441
Charles-François Natali0cc86852013-09-13 19:53:08 +0200442#ifndef INADDR_NONE
443#define INADDR_NONE (-1)
444#endif
445
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000446/* XXX There's a problem here: *static* functions are not supposed to have
447 a Py prefix (or use CapitalizedWords). Later... */
448
Guido van Rossum30a685f1991-06-27 15:51:29 +0000449/* Global variable holding the exception type for errors detected
450 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000451static PyObject *socket_herror;
452static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000453static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000454
Tim Peters643a7fc2002-02-17 04:13:21 +0000455/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000456 The sock_type variable contains pointers to various functions,
457 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000458 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000459static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000460
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000461#if defined(HAVE_POLL_H)
462#include <poll.h>
463#elif defined(HAVE_SYS_POLL_H)
464#include <sys/poll.h>
465#endif
466
Nick Coghlan96fe56a2011-08-22 11:55:57 +1000467/* Largest value to try to store in a socklen_t (used when handling
468 ancillary data). POSIX requires socklen_t to hold at least
469 (2**31)-1 and recommends against storing larger values, but
470 socklen_t was originally int in the BSD interface, so to be on the
471 safe side we use the smaller of (2**31)-1 and INT_MAX. */
472#if INT_MAX > 0x7fffffff
473#define SOCKLEN_T_LIMIT 0x7fffffff
474#else
475#define SOCKLEN_T_LIMIT INT_MAX
476#endif
477
Charles-François Nataliaa26b272011-08-28 17:51:43 +0200478#ifdef HAVE_POLL
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000479/* Instead of select(), we'll use poll() since poll() works on any fd. */
480#define IS_SELECTABLE(s) 1
481/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000482#else
Charles-François Nataliaa26b272011-08-28 17:51:43 +0200483/* If there's no timeout left, we don't have to call select, so it's a safe,
484 * little white lie. */
Victor Stinner71694d52015-03-28 01:18:54 +0100485#define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000486#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000487
488static PyObject*
489select_error(void)
490{
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200491 PyErr_SetString(PyExc_OSError, "unable to select on socket");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000492 return NULL;
Neal Norwitz082b2df2006-02-07 07:04:46 +0000493}
494
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000495#ifdef MS_WINDOWS
Antoine Pitrouc8f01962010-09-28 22:03:27 +0000496#ifndef WSAEAGAIN
497#define WSAEAGAIN WSAEWOULDBLOCK
498#endif
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000499#define CHECK_ERRNO(expected) \
500 (WSAGetLastError() == WSA ## expected)
501#else
502#define CHECK_ERRNO(expected) \
503 (errno == expected)
504#endif
505
Victor Stinnerdaf45552013-08-28 00:53:59 +0200506#ifdef MS_WINDOWS
Victor Stinner81c41db2015-04-02 11:50:57 +0200507# define GET_SOCK_ERROR WSAGetLastError()
508# define SET_SOCK_ERROR(err) WSASetLastError(err)
509# define SOCK_TIMEOUT_ERR WSAEWOULDBLOCK
510# define SOCK_INPROGRESS_ERR WSAEWOULDBLOCK
511#else
512# define GET_SOCK_ERROR errno
513# define SET_SOCK_ERROR(err) do { errno = err; } while (0)
514# define SOCK_TIMEOUT_ERR EWOULDBLOCK
515# define SOCK_INPROGRESS_ERR EINPROGRESS
516#endif
517
518
519#ifdef MS_WINDOWS
Victor Stinnerdaf45552013-08-28 00:53:59 +0200520/* Does WSASocket() support the WSA_FLAG_NO_HANDLE_INHERIT flag? */
521static int support_wsa_no_inherit = -1;
522#endif
523
Guido van Rossum30a685f1991-06-27 15:51:29 +0000524/* Convenience function to raise an error according to errno
525 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000526
Guido van Rossum73624e91994-10-10 17:59:00 +0000527static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000528set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000529{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000530#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000531 int err_no = WSAGetLastError();
532 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
533 recognizes the error codes used by both GetLastError() and
534 WSAGetLastError */
535 if (err_no)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200536 return PyErr_SetExcFromWindowsErr(PyExc_OSError, err_no);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000537#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000538
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200539 return PyErr_SetFromErrno(PyExc_OSError);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000540}
541
Guido van Rossum30a685f1991-06-27 15:51:29 +0000542
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000543static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000544set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000545{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000546 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000547
548#ifdef HAVE_HSTRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000549 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000550#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000551 v = Py_BuildValue("(is)", h_error, "host not found");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000552#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000553 if (v != NULL) {
554 PyErr_SetObject(socket_herror, v);
555 Py_DECREF(v);
556 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000557
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000558 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000559}
560
561
562static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000563set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000564{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000565 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000566
Martin v. Löwis272cb402002-03-01 08:31:07 +0000567#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000568 /* EAI_SYSTEM is not available on Windows XP. */
569 if (error == EAI_SYSTEM)
570 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000571#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000572
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000573#ifdef HAVE_GAI_STRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000574 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000575#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000576 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000577#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000578 if (v != NULL) {
579 PyErr_SetObject(socket_gaierror, v);
580 Py_DECREF(v);
581 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000582
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000583 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000584}
585
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000586/* Function to perform the setting of socket blocking mode
587 internally. block = (1 | 0). */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000588static int
589internal_setblocking(PySocketSockObject *s, int block)
590{
Victor Stinnerb6dab6b2014-07-23 22:56:55 +0200591#ifdef MS_WINDOWS
592 u_long arg;
593#endif
Victor Stinner9a954832013-12-04 00:41:24 +0100594#if !defined(MS_WINDOWS) \
Christian Heimesaf01f662013-12-21 16:19:10 +0100595 && !((defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO)))
Victor Stinner9a954832013-12-04 00:41:24 +0100596 int delay_flag, new_delay_flag;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000597#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +0000598#ifdef SOCK_NONBLOCK
599 if (block)
600 s->sock_type &= (~SOCK_NONBLOCK);
601 else
602 s->sock_type |= SOCK_NONBLOCK;
603#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000604
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000605 Py_BEGIN_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000606#ifndef MS_WINDOWS
Christian Heimesaf01f662013-12-21 16:19:10 +0100607#if (defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000608 block = !block;
609 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
Victor Stinner9a954832013-12-04 00:41:24 +0100610#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000611 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
612 if (block)
Victor Stinner9a954832013-12-04 00:41:24 +0100613 new_delay_flag = delay_flag & (~O_NONBLOCK);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000614 else
Victor Stinner9a954832013-12-04 00:41:24 +0100615 new_delay_flag = delay_flag | O_NONBLOCK;
616 if (new_delay_flag != delay_flag)
617 fcntl(s->sock_fd, F_SETFL, new_delay_flag);
618#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000619#else /* MS_WINDOWS */
Victor Stinnerb6dab6b2014-07-23 22:56:55 +0200620 arg = !block;
621 ioctlsocket(s->sock_fd, FIONBIO, &arg);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000622#endif /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000623 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000624
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000625 /* Since these don't return anything */
626 return 1;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000627}
628
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000629static int
Victor Stinner81c41db2015-04-02 11:50:57 +0200630internal_select(PySocketSockObject *s, int writing, _PyTime_t interval,
631 int connect)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000632{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000633 int n;
Victor Stinner71694d52015-03-28 01:18:54 +0100634#ifdef HAVE_POLL
635 struct pollfd pollfd;
Victor Stinnere6951c62015-03-31 13:50:44 +0200636 _PyTime_t ms;
Victor Stinner71694d52015-03-28 01:18:54 +0100637#else
Victor Stinner416f2e62015-03-31 13:56:29 +0200638 fd_set fds, efds;
Victor Stinnerced11742015-04-09 10:27:25 +0200639 struct timeval tv, *tvp;
Victor Stinner71694d52015-03-28 01:18:54 +0100640#endif
Guido van Rossum11ba0942002-06-13 15:07:44 +0000641
Victor Stinnerb7df3142015-03-27 22:59:32 +0100642#ifdef WITH_THREAD
643 /* must be called with the GIL held */
644 assert(PyGILState_Check());
645#endif
646
Victor Stinner416f2e62015-03-31 13:56:29 +0200647 /* Error condition is for output only */
Victor Stinner81c41db2015-04-02 11:50:57 +0200648 assert(!(connect && !writing));
Guido van Rossum67f7a382002-06-06 21:08:16 +0000649
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000650 /* Guard against closed socket */
Victor Stinner0cec8772016-07-22 17:26:53 +0200651 if (s->sock_fd == INVALID_SOCKET)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000652 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000653
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000654 /* Prefer poll, if available, since you can poll() any fd
655 * which can't be done with select(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000656#ifdef HAVE_POLL
Victor Stinner71694d52015-03-28 01:18:54 +0100657 pollfd.fd = s->sock_fd;
658 pollfd.events = writing ? POLLOUT : POLLIN;
Victor Stinner81c41db2015-04-02 11:50:57 +0200659 if (connect) {
660 /* On Windows, the socket becomes writable on connection success,
661 but a connection failure is notified as an error. On POSIX, the
662 socket becomes writable on connection success or on connection
663 failure. */
Victor Stinner416f2e62015-03-31 13:56:29 +0200664 pollfd.events |= POLLERR;
Victor Stinner81c41db2015-04-02 11:50:57 +0200665 }
Guido van Rossum67f7a382002-06-06 21:08:16 +0000666
Victor Stinner71694d52015-03-28 01:18:54 +0100667 /* s->sock_timeout is in seconds, timeout in ms */
Victor Stinner10550cd2015-04-03 13:22:27 +0200668 ms = _PyTime_AsMilliseconds(interval, _PyTime_ROUND_CEILING);
Victor Stinnere6951c62015-03-31 13:50:44 +0200669 assert(ms <= INT_MAX);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000670
Victor Stinner71694d52015-03-28 01:18:54 +0100671 Py_BEGIN_ALLOW_THREADS;
Victor Stinnere6951c62015-03-31 13:50:44 +0200672 n = poll(&pollfd, 1, (int)ms);
Victor Stinner71694d52015-03-28 01:18:54 +0100673 Py_END_ALLOW_THREADS;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000674#else
Victor Stinnerced11742015-04-09 10:27:25 +0200675 if (interval >= 0) {
676 _PyTime_AsTimeval_noraise(interval, &tv, _PyTime_ROUND_CEILING);
677 tvp = &tv;
678 }
679 else
680 tvp = NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000681
Victor Stinner71694d52015-03-28 01:18:54 +0100682 FD_ZERO(&fds);
683 FD_SET(s->sock_fd, &fds);
Victor Stinner416f2e62015-03-31 13:56:29 +0200684 FD_ZERO(&efds);
Victor Stinner81c41db2015-04-02 11:50:57 +0200685 if (connect) {
686 /* On Windows, the socket becomes writable on connection success,
687 but a connection failure is notified as an error. On POSIX, the
688 socket becomes writable on connection success or on connection
689 failure. */
Victor Stinner416f2e62015-03-31 13:56:29 +0200690 FD_SET(s->sock_fd, &efds);
Victor Stinner81c41db2015-04-02 11:50:57 +0200691 }
Victor Stinner71694d52015-03-28 01:18:54 +0100692
693 /* See if the socket is ready */
694 Py_BEGIN_ALLOW_THREADS;
695 if (writing)
696 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
Victor Stinnerced11742015-04-09 10:27:25 +0200697 NULL, &fds, &efds, tvp);
Victor Stinner71694d52015-03-28 01:18:54 +0100698 else
699 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
Victor Stinnerced11742015-04-09 10:27:25 +0200700 &fds, NULL, &efds, tvp);
Victor Stinner71694d52015-03-28 01:18:54 +0100701 Py_END_ALLOW_THREADS;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000702#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000703
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000704 if (n < 0)
705 return -1;
706 if (n == 0)
707 return 1;
708 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000709}
710
Victor Stinner31bf2d52015-04-01 21:57:09 +0200711/* Call a socket function.
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000712
Victor Stinner81c41db2015-04-02 11:50:57 +0200713 On error, raise an exception and return -1 if err is set, or fill err and
714 return -1 otherwise. If a signal was received and the signal handler raised
715 an exception, return -1, and set err to -1 if err is set.
716
717 On success, return 0, and set err to 0 if err is set.
Victor Stinnerb7df3142015-03-27 22:59:32 +0100718
Victor Stinner31bf2d52015-04-01 21:57:09 +0200719 If the socket has a timeout, wait until the socket is ready before calling
720 the function: wait until the socket is writable if writing is nonzero, wait
721 until the socket received data otherwise.
Victor Stinnerb7df3142015-03-27 22:59:32 +0100722
Victor Stinner81c41db2015-04-02 11:50:57 +0200723 If the socket function is interrupted by a signal (failed with EINTR): retry
Victor Stinner31bf2d52015-04-01 21:57:09 +0200724 the function, except if the signal handler raised an exception (PEP 475).
725
726 When the function is retried, recompute the timeout using a monotonic clock.
727
Victor Stinner81c41db2015-04-02 11:50:57 +0200728 sock_call_ex() must be called with the GIL held. The socket function is
729 called with the GIL released. */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200730static int
Victor Stinner81c41db2015-04-02 11:50:57 +0200731sock_call_ex(PySocketSockObject *s,
732 int writing,
733 int (*sock_func) (PySocketSockObject *s, void *data),
734 void *data,
735 int connect,
Victor Stinner8912d142015-04-06 23:16:34 +0200736 int *err,
737 _PyTime_t timeout)
Victor Stinner31bf2d52015-04-01 21:57:09 +0200738{
Victor Stinner8912d142015-04-06 23:16:34 +0200739 int has_timeout = (timeout > 0);
Victor Stinner31bf2d52015-04-01 21:57:09 +0200740 _PyTime_t deadline = 0;
741 int deadline_initialized = 0;
742 int res;
743
Victor Stinnerbc5b80b2015-10-11 09:54:42 +0200744#ifdef WITH_THREAD
Victor Stinner31bf2d52015-04-01 21:57:09 +0200745 /* sock_call() must be called with the GIL held. */
746 assert(PyGILState_Check());
Victor Stinnerbc5b80b2015-10-11 09:54:42 +0200747#endif
Victor Stinner31bf2d52015-04-01 21:57:09 +0200748
749 /* outer loop to retry select() when select() is interrupted by a signal
Victor Stinner81c41db2015-04-02 11:50:57 +0200750 or to retry select()+sock_func() on false positive (see above) */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200751 while (1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200752 /* For connect(), poll even for blocking socket. The connection
753 runs asynchronously. */
754 if (has_timeout || connect) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200755 if (has_timeout) {
Victor Stinner10550cd2015-04-03 13:22:27 +0200756 _PyTime_t interval;
757
Victor Stinner81c41db2015-04-02 11:50:57 +0200758 if (deadline_initialized) {
759 /* recompute the timeout */
760 interval = deadline - _PyTime_GetMonotonicClock();
761 }
762 else {
763 deadline_initialized = 1;
Victor Stinner8912d142015-04-06 23:16:34 +0200764 deadline = _PyTime_GetMonotonicClock() + timeout;
765 interval = timeout;
Victor Stinner81c41db2015-04-02 11:50:57 +0200766 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200767
Victor Stinner10550cd2015-04-03 13:22:27 +0200768 if (interval >= 0)
769 res = internal_select(s, writing, interval, connect);
770 else
771 res = 1;
772 }
773 else {
Victor Stinner222dfc72015-04-06 22:30:41 +0200774 res = internal_select(s, writing, timeout, connect);
Victor Stinner10550cd2015-04-03 13:22:27 +0200775 }
776
Victor Stinner31bf2d52015-04-01 21:57:09 +0200777 if (res == -1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200778 if (err)
779 *err = GET_SOCK_ERROR;
780
Victor Stinner31bf2d52015-04-01 21:57:09 +0200781 if (CHECK_ERRNO(EINTR)) {
782 /* select() was interrupted by a signal */
Victor Stinner81c41db2015-04-02 11:50:57 +0200783 if (PyErr_CheckSignals()) {
784 if (err)
785 *err = -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200786 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +0200787 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200788
789 /* retry select() */
790 continue;
791 }
792
793 /* select() failed */
794 s->errorhandler();
795 return -1;
796 }
797
798 if (res == 1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200799 if (err)
800 *err = SOCK_TIMEOUT_ERR;
801 else
802 PyErr_SetString(socket_timeout, "timed out");
Victor Stinner31bf2d52015-04-01 21:57:09 +0200803 return -1;
804 }
805
806 /* the socket is ready */
807 }
808
Victor Stinner81c41db2015-04-02 11:50:57 +0200809 /* inner loop to retry sock_func() when sock_func() is interrupted
810 by a signal */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200811 while (1) {
812 Py_BEGIN_ALLOW_THREADS
Victor Stinner81c41db2015-04-02 11:50:57 +0200813 res = sock_func(s, data);
Victor Stinner31bf2d52015-04-01 21:57:09 +0200814 Py_END_ALLOW_THREADS
815
816 if (res) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200817 /* sock_func() succeeded */
818 if (err)
819 *err = 0;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200820 return 0;
821 }
822
Victor Stinner81c41db2015-04-02 11:50:57 +0200823 if (err)
824 *err = GET_SOCK_ERROR;
825
Victor Stinner31bf2d52015-04-01 21:57:09 +0200826 if (!CHECK_ERRNO(EINTR))
827 break;
828
Victor Stinner81c41db2015-04-02 11:50:57 +0200829 /* sock_func() was interrupted by a signal */
830 if (PyErr_CheckSignals()) {
831 if (err)
832 *err = -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200833 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +0200834 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200835
Victor Stinner81c41db2015-04-02 11:50:57 +0200836 /* retry sock_func() */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200837 }
838
839 if (s->sock_timeout > 0
840 && (CHECK_ERRNO(EWOULDBLOCK) || CHECK_ERRNO(EAGAIN))) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200841 /* False positive: sock_func() failed with EWOULDBLOCK or EAGAIN.
Victor Stinner31bf2d52015-04-01 21:57:09 +0200842
843 For example, select() could indicate a socket is ready for
844 reading, but the data then discarded by the OS because of a
845 wrong checksum.
846
847 Loop on select() to recheck for socket readyness. */
848 continue;
849 }
850
Victor Stinner81c41db2015-04-02 11:50:57 +0200851 /* sock_func() failed */
852 if (!err)
853 s->errorhandler();
854 /* else: err was already set before */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000855 return -1;
856 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200857}
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000858
Victor Stinner81c41db2015-04-02 11:50:57 +0200859static int
860sock_call(PySocketSockObject *s,
861 int writing,
862 int (*func) (PySocketSockObject *s, void *data),
863 void *data)
864{
Victor Stinner8912d142015-04-06 23:16:34 +0200865 return sock_call_ex(s, writing, func, data, 0, NULL, s->sock_timeout);
Victor Stinner81c41db2015-04-02 11:50:57 +0200866}
867
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000868
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000869/* Initialize a new socket object. */
870
Victor Stinner88ed6402015-04-09 10:23:12 +0200871/* Default timeout for new sockets */
872static _PyTime_t defaulttimeout = _PYTIME_FROMSECONDS(-1);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000873
Martin v. Löwis1a214512008-06-11 05:26:20 +0000874static void
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000875init_sockobject(PySocketSockObject *s,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000876 SOCKET_T fd, int family, int type, int proto)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000877{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000878 s->sock_fd = fd;
879 s->sock_family = family;
880 s->sock_type = type;
881 s->sock_proto = proto;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000882
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000883 s->errorhandler = &set_error;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000884#ifdef SOCK_NONBLOCK
885 if (type & SOCK_NONBLOCK)
Victor Stinner71694d52015-03-28 01:18:54 +0100886 s->sock_timeout = 0;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000887 else
888#endif
889 {
890 s->sock_timeout = defaulttimeout;
Victor Stinner71694d52015-03-28 01:18:54 +0100891 if (defaulttimeout >= 0)
Antoine Pitroub1c54962010-10-14 15:05:38 +0000892 internal_setblocking(s, 0);
893 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000894
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000895}
896
897
Guido van Rossum30a685f1991-06-27 15:51:29 +0000898/* Create a new socket object.
899 This just creates the object and initializes it.
900 If the creation fails, return NULL and set an exception (implicit
901 in NEWOBJ()). */
902
Guido van Rossum73624e91994-10-10 17:59:00 +0000903static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000904new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000905{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000906 PySocketSockObject *s;
907 s = (PySocketSockObject *)
908 PyType_GenericNew(&sock_type, NULL, NULL);
909 if (s != NULL)
910 init_sockobject(s, fd, family, type, proto);
911 return s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000912}
913
Guido van Rossum30a685f1991-06-27 15:51:29 +0000914
Guido van Rossum48a680c2001-03-02 06:34:14 +0000915/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000916 thread to be in gethostbyname or getaddrinfo */
917#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Matthias Klosed182a6c2012-08-14 17:29:04 +0200918static PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000919#endif
920
921
Guido van Rossum30a685f1991-06-27 15:51:29 +0000922/* Convert a string specifying a host name or one of a few symbolic
923 names to a numeric IP address. This usually calls gethostbyname()
924 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000925 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000926 an error occurred; then an exception is raised. */
927
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000928static int
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000929setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000930{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000931 struct addrinfo hints, *res;
932 int error;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000933
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000934 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
935 if (name[0] == '\0') {
936 int siz;
937 memset(&hints, 0, sizeof(hints));
938 hints.ai_family = af;
939 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
940 hints.ai_flags = AI_PASSIVE;
941 Py_BEGIN_ALLOW_THREADS
942 ACQUIRE_GETADDRINFO_LOCK
943 error = getaddrinfo(NULL, "0", &hints, &res);
944 Py_END_ALLOW_THREADS
945 /* We assume that those thread-unsafe getaddrinfo() versions
946 *are* safe regarding their return value, ie. that a
947 subsequent call to getaddrinfo() does not destroy the
948 outcome of the first call. */
949 RELEASE_GETADDRINFO_LOCK
950 if (error) {
951 set_gaierror(error);
952 return -1;
953 }
954 switch (res->ai_family) {
955 case AF_INET:
956 siz = 4;
957 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000958#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000959 case AF_INET6:
960 siz = 16;
961 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000962#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000963 default:
964 freeaddrinfo(res);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200965 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000966 "unsupported address family");
967 return -1;
968 }
969 if (res->ai_next) {
970 freeaddrinfo(res);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200971 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000972 "wildcard resolved to multiple address");
973 return -1;
974 }
975 if (res->ai_addrlen < addr_ret_size)
976 addr_ret_size = res->ai_addrlen;
977 memcpy(addr_ret, res->ai_addr, addr_ret_size);
978 freeaddrinfo(res);
979 return siz;
980 }
Charles-François Natali0cc86852013-09-13 19:53:08 +0200981 /* special-case broadcast - inet_addr() below can return INADDR_NONE for
Victor Stinnere990c6e2013-11-16 00:18:58 +0100982 * this */
Charles-François Natali0cc86852013-09-13 19:53:08 +0200983 if (strcmp(name, "255.255.255.255") == 0 ||
984 strcmp(name, "<broadcast>") == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000985 struct sockaddr_in *sin;
986 if (af != AF_INET && af != AF_UNSPEC) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200987 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000988 "address family mismatched");
989 return -1;
990 }
991 sin = (struct sockaddr_in *)addr_ret;
992 memset((void *) sin, '\0', sizeof(*sin));
993 sin->sin_family = AF_INET;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000994#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000995 sin->sin_len = sizeof(*sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000996#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000997 sin->sin_addr.s_addr = INADDR_BROADCAST;
998 return sizeof(sin->sin_addr);
999 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001000
1001 /* avoid a name resolution in case of numeric address */
1002#ifdef HAVE_INET_PTON
1003 /* check for an IPv4 address */
1004 if (af == AF_UNSPEC || af == AF_INET) {
1005 struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1006 memset(sin, 0, sizeof(*sin));
1007 if (inet_pton(AF_INET, name, &sin->sin_addr) > 0) {
1008 sin->sin_family = AF_INET;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +00001009#ifdef HAVE_SOCKADDR_SA_LEN
Charles-François Natali0cc86852013-09-13 19:53:08 +02001010 sin->sin_len = sizeof(*sin);
Anthony Baxter0e85f9d2003-05-02 15:40:46 +00001011#endif
Charles-François Natali0cc86852013-09-13 19:53:08 +02001012 return 4;
1013 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001014 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001015#ifdef ENABLE_IPV6
1016 /* check for an IPv6 address - if the address contains a scope ID, we
1017 * fallback to getaddrinfo(), which can handle translation from interface
1018 * name to interface index */
1019 if ((af == AF_UNSPEC || af == AF_INET6) && !strchr(name, '%')) {
1020 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)addr_ret;
1021 memset(sin, 0, sizeof(*sin));
1022 if (inet_pton(AF_INET6, name, &sin->sin6_addr) > 0) {
1023 sin->sin6_family = AF_INET6;
1024#ifdef HAVE_SOCKADDR_SA_LEN
1025 sin->sin6_len = sizeof(*sin);
1026#endif
1027 return 16;
1028 }
1029 }
1030#endif /* ENABLE_IPV6 */
1031#else /* HAVE_INET_PTON */
1032 /* check for an IPv4 address */
1033 if (af == AF_INET || af == AF_UNSPEC) {
1034 struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1035 memset(sin, 0, sizeof(*sin));
1036 if ((sin->sin_addr.s_addr = inet_addr(name)) != INADDR_NONE) {
1037 sin->sin_family = AF_INET;
1038#ifdef HAVE_SOCKADDR_SA_LEN
1039 sin->sin_len = sizeof(*sin);
1040#endif
1041 return 4;
1042 }
Victor Stinnere990c6e2013-11-16 00:18:58 +01001043 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001044#endif /* HAVE_INET_PTON */
1045
1046 /* perform a name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001047 memset(&hints, 0, sizeof(hints));
1048 hints.ai_family = af;
1049 Py_BEGIN_ALLOW_THREADS
1050 ACQUIRE_GETADDRINFO_LOCK
1051 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +00001052#if defined(__digital__) && defined(__unix__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001053 if (error == EAI_NONAME && af == AF_UNSPEC) {
1054 /* On Tru64 V5.1, numeric-to-addr conversion fails
1055 if no address family is given. Assume IPv4 for now.*/
1056 hints.ai_family = AF_INET;
1057 error = getaddrinfo(name, NULL, &hints, &res);
1058 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +00001059#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001060 Py_END_ALLOW_THREADS
1061 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
1062 if (error) {
1063 set_gaierror(error);
1064 return -1;
1065 }
1066 if (res->ai_addrlen < addr_ret_size)
1067 addr_ret_size = res->ai_addrlen;
1068 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
1069 freeaddrinfo(res);
1070 switch (addr_ret->sa_family) {
1071 case AF_INET:
1072 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001073#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001074 case AF_INET6:
1075 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +00001076#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001077 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001078 PyErr_SetString(PyExc_OSError, "unknown address family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001079 return -1;
1080 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001081}
1082
Guido van Rossum30a685f1991-06-27 15:51:29 +00001083
Guido van Rossum30a685f1991-06-27 15:51:29 +00001084/* Create a string object representing an IP address.
1085 This is always a string of the form 'dd.dd.dd.dd' (with variable
1086 size numbers). */
1087
Guido van Rossum73624e91994-10-10 17:59:00 +00001088static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001089makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001090{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001091 char buf[NI_MAXHOST];
1092 int error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001093
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001094 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
1095 NI_NUMERICHOST);
1096 if (error) {
1097 set_gaierror(error);
1098 return NULL;
1099 }
1100 return PyUnicode_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +00001101}
1102
1103
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001104#ifdef USE_BLUETOOTH
1105/* Convert a string representation of a Bluetooth address into a numeric
1106 address. Returns the length (6), or raises an exception and returns -1 if
1107 an error occurred. */
1108
1109static int
1110setbdaddr(char *name, bdaddr_t *bdaddr)
1111{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001112 unsigned int b0, b1, b2, b3, b4, b5;
1113 char ch;
1114 int n;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001115
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001116 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
1117 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
1118 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
1119 bdaddr->b[0] = b0;
1120 bdaddr->b[1] = b1;
1121 bdaddr->b[2] = b2;
1122 bdaddr->b[3] = b3;
1123 bdaddr->b[4] = b4;
1124 bdaddr->b[5] = b5;
1125 return 6;
1126 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001127 PyErr_SetString(PyExc_OSError, "bad bluetooth address");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001128 return -1;
1129 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001130}
1131
1132/* Create a string representation of the Bluetooth address. This is always a
1133 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
1134 value (zero padded if necessary). */
1135
1136static PyObject *
1137makebdaddr(bdaddr_t *bdaddr)
1138{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001139 char buf[(6 * 2) + 5 + 1];
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001140
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001141 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1142 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1143 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1144 return PyUnicode_FromString(buf);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001145}
1146#endif
1147
1148
Guido van Rossum30a685f1991-06-27 15:51:29 +00001149/* Create an object representing the given socket address,
1150 suitable for passing it back to bind(), connect() etc.
1151 The family field of the sockaddr structure is inspected
1152 to determine what kind of address it really is. */
1153
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001154/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001155static PyObject *
Antoine Pitrou19467d22010-08-17 19:33:30 +00001156makesockaddr(SOCKET_T sockfd, struct sockaddr *addr, size_t addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001157{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001158 if (addrlen == 0) {
1159 /* No address -- may be recvfrom() from known socket */
1160 Py_INCREF(Py_None);
1161 return Py_None;
1162 }
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001163
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001164 switch (addr->sa_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001165
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001166 case AF_INET:
1167 {
1168 struct sockaddr_in *a;
1169 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1170 PyObject *ret = NULL;
1171 if (addrobj) {
1172 a = (struct sockaddr_in *)addr;
1173 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1174 Py_DECREF(addrobj);
1175 }
1176 return ret;
1177 }
Guido van Rossum30a685f1991-06-27 15:51:29 +00001178
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001179#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001180 case AF_UNIX:
1181 {
1182 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001183#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001184 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
1185 addrlen -= offsetof(struct sockaddr_un, sun_path);
Charles-François Natalib10c71d2013-05-21 10:45:46 +02001186 return PyBytes_FromStringAndSize(a->sun_path, addrlen);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001187 }
1188 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001189#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001190 {
1191 /* regular NULL-terminated string */
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001192 return PyUnicode_DecodeFSDefault(a->sun_path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001193 }
1194 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001195#endif /* AF_UNIX */
1196
Martin v. Löwis11017b12006-01-14 18:12:57 +00001197#if defined(AF_NETLINK)
1198 case AF_NETLINK:
1199 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001200 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1201 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +00001202 }
1203#endif /* AF_NETLINK */
1204
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001205#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001206 case AF_INET6:
1207 {
1208 struct sockaddr_in6 *a;
1209 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1210 PyObject *ret = NULL;
1211 if (addrobj) {
1212 a = (struct sockaddr_in6 *)addr;
Charles-François Natali366999a2012-01-02 15:47:29 +01001213 ret = Py_BuildValue("OiII",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001214 addrobj,
1215 ntohs(a->sin6_port),
Charles-François Natali366999a2012-01-02 15:47:29 +01001216 ntohl(a->sin6_flowinfo),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001217 a->sin6_scope_id);
1218 Py_DECREF(addrobj);
1219 }
1220 return ret;
1221 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001222#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001223
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001224#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001225 case AF_BLUETOOTH:
1226 switch (proto) {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001227
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001228 case BTPROTO_L2CAP:
1229 {
1230 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1231 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1232 PyObject *ret = NULL;
1233 if (addrobj) {
1234 ret = Py_BuildValue("Oi",
1235 addrobj,
1236 _BT_L2_MEMB(a, psm));
1237 Py_DECREF(addrobj);
1238 }
1239 return ret;
1240 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001241
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001242 case BTPROTO_RFCOMM:
1243 {
1244 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1245 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1246 PyObject *ret = NULL;
1247 if (addrobj) {
1248 ret = Py_BuildValue("Oi",
1249 addrobj,
1250 _BT_RC_MEMB(a, channel));
1251 Py_DECREF(addrobj);
1252 }
1253 return ret;
1254 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001255
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001256 case BTPROTO_HCI:
1257 {
1258 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001259#if defined(__NetBSD__) || defined(__DragonFly__)
1260 return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));
1261#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001262 PyObject *ret = NULL;
1263 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1264 return ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001265#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001266 }
Thomas Wouterscf297e42007-02-23 15:07:44 +00001267
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001268#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001269 case BTPROTO_SCO:
1270 {
1271 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1272 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1273 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001274#endif
1275
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001276 default:
1277 PyErr_SetString(PyExc_ValueError,
1278 "Unknown Bluetooth protocol");
1279 return NULL;
1280 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001281#endif
1282
Antoine Pitroub156a462010-10-27 20:13:57 +00001283#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001284 case AF_PACKET:
1285 {
1286 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1287 char *ifname = "";
1288 struct ifreq ifr;
1289 /* need to look up interface name give index */
1290 if (a->sll_ifindex) {
1291 ifr.ifr_ifindex = a->sll_ifindex;
1292 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1293 ifname = ifr.ifr_name;
1294 }
1295 return Py_BuildValue("shbhy#",
1296 ifname,
1297 ntohs(a->sll_protocol),
1298 a->sll_pkttype,
1299 a->sll_hatype,
1300 a->sll_addr,
1301 a->sll_halen);
1302 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001303#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001304
Christian Heimes043d6f62008-01-07 17:19:16 +00001305#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001306 case AF_TIPC:
1307 {
1308 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1309 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1310 return Py_BuildValue("IIIII",
1311 a->addrtype,
1312 a->addr.nameseq.type,
1313 a->addr.nameseq.lower,
1314 a->addr.nameseq.upper,
1315 a->scope);
1316 } else if (a->addrtype == TIPC_ADDR_NAME) {
1317 return Py_BuildValue("IIIII",
1318 a->addrtype,
1319 a->addr.name.name.type,
1320 a->addr.name.name.instance,
1321 a->addr.name.name.instance,
1322 a->scope);
1323 } else if (a->addrtype == TIPC_ADDR_ID) {
1324 return Py_BuildValue("IIIII",
1325 a->addrtype,
1326 a->addr.id.node,
1327 a->addr.id.ref,
1328 0,
1329 a->scope);
1330 } else {
1331 PyErr_SetString(PyExc_ValueError,
1332 "Invalid address type");
1333 return NULL;
1334 }
1335 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001336#endif
1337
Vinay Sajipecfc98c2014-03-20 12:42:42 +00001338#ifdef AF_CAN
Charles-François Natali47413c12011-10-06 19:47:44 +02001339 case AF_CAN:
1340 {
1341 struct sockaddr_can *a = (struct sockaddr_can *)addr;
1342 char *ifname = "";
1343 struct ifreq ifr;
1344 /* need to look up interface name given index */
1345 if (a->can_ifindex) {
1346 ifr.ifr_ifindex = a->can_ifindex;
1347 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1348 ifname = ifr.ifr_name;
1349 }
1350
1351 return Py_BuildValue("O&h", PyUnicode_DecodeFSDefault,
1352 ifname,
1353 a->can_family);
1354 }
1355#endif
1356
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001357#ifdef PF_SYSTEM
1358 case PF_SYSTEM:
1359 switch(proto) {
1360#ifdef SYSPROTO_CONTROL
1361 case SYSPROTO_CONTROL:
1362 {
1363 struct sockaddr_ctl *a = (struct sockaddr_ctl *)addr;
1364 return Py_BuildValue("(II)", a->sc_id, a->sc_unit);
1365 }
1366#endif
1367 default:
1368 PyErr_SetString(PyExc_ValueError,
1369 "Invalid address type");
1370 return 0;
1371 }
1372#endif
1373
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001374 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001375
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001376 default:
1377 /* If we don't know the address family, don't raise an
1378 exception -- return it as an (int, bytes) tuple. */
1379 return Py_BuildValue("iy#",
1380 addr->sa_family,
1381 addr->sa_data,
1382 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001383
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001384 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001385}
1386
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001387/* Helper for getsockaddrarg: bypass IDNA for ASCII-only host names
1388 (in particular, numeric IP addresses). */
1389struct maybe_idna {
1390 PyObject *obj;
1391 char *buf;
1392};
1393
1394static void
1395idna_cleanup(struct maybe_idna *data)
1396{
1397 Py_CLEAR(data->obj);
1398}
1399
1400static int
1401idna_converter(PyObject *obj, struct maybe_idna *data)
1402{
1403 size_t len;
1404 PyObject *obj2, *obj3;
1405 if (obj == NULL) {
1406 idna_cleanup(data);
1407 return 1;
1408 }
1409 data->obj = NULL;
1410 len = -1;
1411 if (PyBytes_Check(obj)) {
1412 data->buf = PyBytes_AsString(obj);
1413 len = PyBytes_Size(obj);
1414 }
1415 else if (PyByteArray_Check(obj)) {
1416 data->buf = PyByteArray_AsString(obj);
1417 len = PyByteArray_Size(obj);
1418 }
1419 else if (PyUnicode_Check(obj) && PyUnicode_READY(obj) == 0 && PyUnicode_IS_COMPACT_ASCII(obj)) {
1420 data->buf = PyUnicode_DATA(obj);
1421 len = PyUnicode_GET_LENGTH(obj);
1422 }
1423 else {
1424 obj2 = PyUnicode_FromObject(obj);
1425 if (!obj2) {
1426 PyErr_Format(PyExc_TypeError, "string or unicode text buffer expected, not %s",
1427 obj->ob_type->tp_name);
1428 return 0;
1429 }
1430 obj3 = PyUnicode_AsEncodedString(obj2, "idna", NULL);
1431 Py_DECREF(obj2);
1432 if (!obj3) {
1433 PyErr_SetString(PyExc_TypeError, "encoding of hostname failed");
1434 return 0;
1435 }
1436 if (!PyBytes_Check(obj3)) {
Martin v. Löwis17fd1e12014-08-05 16:13:50 +02001437 Py_DECREF(obj3);
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001438 PyErr_SetString(PyExc_TypeError, "encoding of hostname failed to return bytes");
1439 return 0;
1440 }
1441 data->obj = obj3;
1442 data->buf = PyBytes_AS_STRING(obj3);
1443 len = PyBytes_GET_SIZE(obj3);
1444 }
1445 if (strlen(data->buf) != len) {
1446 Py_CLEAR(data->obj);
Serhiy Storchakad8a14472014-09-06 20:07:17 +03001447 PyErr_SetString(PyExc_TypeError, "host name must not contain null character");
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001448 return 0;
1449 }
1450 return Py_CLEANUP_SUPPORTED;
Victor Stinner1a62a682014-08-17 19:33:28 +02001451}
Guido van Rossum30a685f1991-06-27 15:51:29 +00001452
1453/* Parse a socket address argument according to the socket object's
1454 address family. Return 1 if the address was in the proper format,
1455 0 of not. The address is returned through addr_ret, its length
1456 through len_ret. */
1457
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001458static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001459getsockaddrarg(PySocketSockObject *s, PyObject *args,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001460 struct sockaddr *addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001461{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001462 switch (s->sock_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001463
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001464#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001465 case AF_UNIX:
1466 {
1467 struct sockaddr_un* addr;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001468 Py_buffer path;
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001469 int retval = 0;
1470
1471 /* PEP 383. Not using PyUnicode_FSConverter since we need to
1472 allow embedded nulls on Linux. */
1473 if (PyUnicode_Check(args)) {
1474 if ((args = PyUnicode_EncodeFSDefault(args)) == NULL)
1475 return 0;
1476 }
1477 else
1478 Py_INCREF(args);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001479 if (!PyArg_Parse(args, "y*", &path)) {
1480 Py_DECREF(args);
1481 return retval;
1482 }
1483 assert(path.len >= 0);
Thomas Wouters89f507f2006-12-13 04:49:30 +00001484
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001485 addr = (struct sockaddr_un*)addr_ret;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001486#ifdef linux
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001487 if (path.len > 0 && *(const char *)path.buf == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001488 /* Linux abstract namespace extension */
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001489 if ((size_t)path.len > sizeof addr->sun_path) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001490 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001491 "AF_UNIX path too long");
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001492 goto unix_out;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001493 }
1494 }
1495 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001496#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001497 {
1498 /* regular NULL-terminated string */
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001499 if ((size_t)path.len >= sizeof addr->sun_path) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001500 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001501 "AF_UNIX path too long");
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001502 goto unix_out;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001503 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001504 addr->sun_path[path.len] = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001505 }
1506 addr->sun_family = s->sock_family;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001507 memcpy(addr->sun_path, path.buf, path.len);
1508 *len_ret = path.len + offsetof(struct sockaddr_un, sun_path);
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001509 retval = 1;
1510 unix_out:
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001511 PyBuffer_Release(&path);
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001512 Py_DECREF(args);
1513 return retval;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001514 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001515#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001516
Martin v. Löwis11017b12006-01-14 18:12:57 +00001517#if defined(AF_NETLINK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001518 case AF_NETLINK:
1519 {
1520 struct sockaddr_nl* addr;
1521 int pid, groups;
1522 addr = (struct sockaddr_nl *)addr_ret;
1523 if (!PyTuple_Check(args)) {
1524 PyErr_Format(
1525 PyExc_TypeError,
1526 "getsockaddrarg: "
1527 "AF_NETLINK address must be tuple, not %.500s",
1528 Py_TYPE(args)->tp_name);
1529 return 0;
1530 }
1531 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1532 return 0;
1533 addr->nl_family = AF_NETLINK;
1534 addr->nl_pid = pid;
1535 addr->nl_groups = groups;
1536 *len_ret = sizeof(*addr);
1537 return 1;
1538 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001539#endif
1540
Charles-François Natali10b8cf42011-11-10 19:21:37 +01001541#ifdef AF_RDS
1542 case AF_RDS:
1543 /* RDS sockets use sockaddr_in: fall-through */
1544#endif
1545
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001546 case AF_INET:
1547 {
1548 struct sockaddr_in* addr;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001549 struct maybe_idna host = {NULL, NULL};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001550 int port, result;
1551 if (!PyTuple_Check(args)) {
1552 PyErr_Format(
1553 PyExc_TypeError,
1554 "getsockaddrarg: "
1555 "AF_INET address must be tuple, not %.500s",
1556 Py_TYPE(args)->tp_name);
1557 return 0;
1558 }
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001559 if (!PyArg_ParseTuple(args, "O&i:getsockaddrarg",
1560 idna_converter, &host, &port))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001561 return 0;
1562 addr=(struct sockaddr_in*)addr_ret;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001563 result = setipaddr(host.buf, (struct sockaddr *)addr,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001564 sizeof(*addr), AF_INET);
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001565 idna_cleanup(&host);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001566 if (result < 0)
1567 return 0;
1568 if (port < 0 || port > 0xffff) {
1569 PyErr_SetString(
1570 PyExc_OverflowError,
1571 "getsockaddrarg: port must be 0-65535.");
1572 return 0;
1573 }
1574 addr->sin_family = AF_INET;
1575 addr->sin_port = htons((short)port);
1576 *len_ret = sizeof *addr;
1577 return 1;
1578 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001579
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001580#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001581 case AF_INET6:
1582 {
1583 struct sockaddr_in6* addr;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001584 struct maybe_idna host = {NULL, NULL};
Charles-François Natali366999a2012-01-02 15:47:29 +01001585 int port, result;
1586 unsigned int flowinfo, scope_id;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001587 flowinfo = scope_id = 0;
1588 if (!PyTuple_Check(args)) {
1589 PyErr_Format(
1590 PyExc_TypeError,
1591 "getsockaddrarg: "
1592 "AF_INET6 address must be tuple, not %.500s",
1593 Py_TYPE(args)->tp_name);
1594 return 0;
1595 }
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001596 if (!PyArg_ParseTuple(args, "O&i|II",
1597 idna_converter, &host, &port, &flowinfo,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001598 &scope_id)) {
1599 return 0;
1600 }
1601 addr = (struct sockaddr_in6*)addr_ret;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001602 result = setipaddr(host.buf, (struct sockaddr *)addr,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001603 sizeof(*addr), AF_INET6);
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001604 idna_cleanup(&host);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001605 if (result < 0)
1606 return 0;
1607 if (port < 0 || port > 0xffff) {
1608 PyErr_SetString(
1609 PyExc_OverflowError,
1610 "getsockaddrarg: port must be 0-65535.");
1611 return 0;
1612 }
Charles-François Natali9b0c0062012-06-23 10:17:05 +02001613 if (flowinfo > 0xfffff) {
Charles-François Natali366999a2012-01-02 15:47:29 +01001614 PyErr_SetString(
1615 PyExc_OverflowError,
1616 "getsockaddrarg: flowinfo must be 0-1048575.");
1617 return 0;
1618 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001619 addr->sin6_family = s->sock_family;
1620 addr->sin6_port = htons((short)port);
Charles-François Natali366999a2012-01-02 15:47:29 +01001621 addr->sin6_flowinfo = htonl(flowinfo);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001622 addr->sin6_scope_id = scope_id;
1623 *len_ret = sizeof *addr;
1624 return 1;
1625 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001626#endif
1627
Hye-Shik Chang81268602004-02-02 06:05:24 +00001628#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001629 case AF_BLUETOOTH:
1630 {
1631 switch (s->sock_proto) {
1632 case BTPROTO_L2CAP:
1633 {
1634 struct sockaddr_l2 *addr;
1635 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001636
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001637 addr = (struct sockaddr_l2 *)addr_ret;
1638 memset(addr, 0, sizeof(struct sockaddr_l2));
1639 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1640 if (!PyArg_ParseTuple(args, "si", &straddr,
1641 &_BT_L2_MEMB(addr, psm))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001642 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001643 "wrong format");
1644 return 0;
1645 }
1646 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1647 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001648
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001649 *len_ret = sizeof *addr;
1650 return 1;
1651 }
1652 case BTPROTO_RFCOMM:
1653 {
1654 struct sockaddr_rc *addr;
1655 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001656
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001657 addr = (struct sockaddr_rc *)addr_ret;
1658 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1659 if (!PyArg_ParseTuple(args, "si", &straddr,
1660 &_BT_RC_MEMB(addr, channel))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001661 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001662 "wrong format");
1663 return 0;
1664 }
1665 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1666 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001667
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001668 *len_ret = sizeof *addr;
1669 return 1;
1670 }
1671 case BTPROTO_HCI:
1672 {
1673 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001674#if defined(__NetBSD__) || defined(__DragonFly__)
Alexander Belopolskye239d232010-12-08 23:31:48 +00001675 char *straddr = PyBytes_AS_STRING(args);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001676
Alexander Belopolskye239d232010-12-08 23:31:48 +00001677 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001678 if (straddr == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001679 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001680 "wrong format");
1681 return 0;
1682 }
1683 if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)
1684 return 0;
1685#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001686 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1687 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001688 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001689 "wrong format");
1690 return 0;
1691 }
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001692#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 *len_ret = sizeof *addr;
1694 return 1;
1695 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001696#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001697 case BTPROTO_SCO:
1698 {
1699 struct sockaddr_sco *addr;
1700 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001701
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001702 addr = (struct sockaddr_sco *)addr_ret;
1703 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1704 if (!PyBytes_Check(args)) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001705 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001706 "wrong format");
1707 return 0;
1708 }
1709 straddr = PyBytes_AS_STRING(args);
1710 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1711 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001712
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001713 *len_ret = sizeof *addr;
1714 return 1;
1715 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001716#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001717 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001718 PyErr_SetString(PyExc_OSError, "getsockaddrarg: unknown Bluetooth protocol");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001719 return 0;
1720 }
1721 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001722#endif
1723
Antoine Pitroub156a462010-10-27 20:13:57 +00001724#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001725 case AF_PACKET:
1726 {
1727 struct sockaddr_ll* addr;
1728 struct ifreq ifr;
1729 char *interfaceName;
1730 int protoNumber;
1731 int hatype = 0;
1732 int pkttype = 0;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001733 Py_buffer haddr = {NULL, NULL};
Guido van Rossum48a680c2001-03-02 06:34:14 +00001734
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001735 if (!PyTuple_Check(args)) {
1736 PyErr_Format(
1737 PyExc_TypeError,
1738 "getsockaddrarg: "
1739 "AF_PACKET address must be tuple, not %.500s",
1740 Py_TYPE(args)->tp_name);
1741 return 0;
1742 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001743 if (!PyArg_ParseTuple(args, "si|iiy*", &interfaceName,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001744 &protoNumber, &pkttype, &hatype,
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001745 &haddr))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001746 return 0;
1747 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1748 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1749 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1750 s->errorhandler();
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001751 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001752 return 0;
1753 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001754 if (haddr.buf && haddr.len > 8) {
1755 PyErr_SetString(PyExc_ValueError,
1756 "Hardware address must be 8 bytes or less");
1757 PyBuffer_Release(&haddr);
1758 return 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001759 }
1760 if (protoNumber < 0 || protoNumber > 0xffff) {
1761 PyErr_SetString(
1762 PyExc_OverflowError,
1763 "getsockaddrarg: protoNumber must be 0-65535.");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001764 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001765 return 0;
1766 }
1767 addr = (struct sockaddr_ll*)addr_ret;
1768 addr->sll_family = AF_PACKET;
1769 addr->sll_protocol = htons((short)protoNumber);
1770 addr->sll_ifindex = ifr.ifr_ifindex;
1771 addr->sll_pkttype = pkttype;
1772 addr->sll_hatype = hatype;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001773 if (haddr.buf) {
1774 memcpy(&addr->sll_addr, haddr.buf, haddr.len);
1775 addr->sll_halen = haddr.len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001776 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001777 else
1778 addr->sll_halen = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001779 *len_ret = sizeof *addr;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001780 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001781 return 1;
1782 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001783#endif
1784
Christian Heimes043d6f62008-01-07 17:19:16 +00001785#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001786 case AF_TIPC:
1787 {
1788 unsigned int atype, v1, v2, v3;
1789 unsigned int scope = TIPC_CLUSTER_SCOPE;
1790 struct sockaddr_tipc *addr;
Christian Heimes043d6f62008-01-07 17:19:16 +00001791
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001792 if (!PyTuple_Check(args)) {
1793 PyErr_Format(
1794 PyExc_TypeError,
1795 "getsockaddrarg: "
1796 "AF_TIPC address must be tuple, not %.500s",
1797 Py_TYPE(args)->tp_name);
1798 return 0;
1799 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001800
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001801 if (!PyArg_ParseTuple(args,
1802 "IIII|I;Invalid TIPC address format",
1803 &atype, &v1, &v2, &v3, &scope))
1804 return 0;
Christian Heimes043d6f62008-01-07 17:19:16 +00001805
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001806 addr = (struct sockaddr_tipc *) addr_ret;
1807 memset(addr, 0, sizeof(struct sockaddr_tipc));
Christian Heimes043d6f62008-01-07 17:19:16 +00001808
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001809 addr->family = AF_TIPC;
1810 addr->scope = scope;
1811 addr->addrtype = atype;
Christian Heimes043d6f62008-01-07 17:19:16 +00001812
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001813 if (atype == TIPC_ADDR_NAMESEQ) {
1814 addr->addr.nameseq.type = v1;
1815 addr->addr.nameseq.lower = v2;
1816 addr->addr.nameseq.upper = v3;
1817 } else if (atype == TIPC_ADDR_NAME) {
1818 addr->addr.name.name.type = v1;
1819 addr->addr.name.name.instance = v2;
1820 } else if (atype == TIPC_ADDR_ID) {
1821 addr->addr.id.node = v1;
1822 addr->addr.id.ref = v2;
1823 } else {
1824 /* Shouldn't happen */
1825 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1826 return 0;
1827 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001828
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001829 *len_ret = sizeof(*addr);
Christian Heimes043d6f62008-01-07 17:19:16 +00001830
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001831 return 1;
1832 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001833#endif
1834
Vinay Sajiped6783f2014-03-21 11:44:32 +00001835#if defined(AF_CAN) && defined(CAN_RAW) && defined(CAN_BCM)
Charles-François Natali47413c12011-10-06 19:47:44 +02001836 case AF_CAN:
1837 switch (s->sock_proto) {
1838 case CAN_RAW:
Charles-François Natali773e42d2013-02-05 19:42:01 +01001839 /* fall-through */
1840 case CAN_BCM:
Charles-François Natali47413c12011-10-06 19:47:44 +02001841 {
1842 struct sockaddr_can *addr;
1843 PyObject *interfaceName;
1844 struct ifreq ifr;
Charles-François Natali47413c12011-10-06 19:47:44 +02001845 Py_ssize_t len;
1846
Benjamin Peterson18b71912013-05-16 15:29:44 -05001847 addr = (struct sockaddr_can *)addr_ret;
1848
Charles-François Natali47413c12011-10-06 19:47:44 +02001849 if (!PyArg_ParseTuple(args, "O&", PyUnicode_FSConverter,
1850 &interfaceName))
1851 return 0;
1852
1853 len = PyBytes_GET_SIZE(interfaceName);
1854
1855 if (len == 0) {
1856 ifr.ifr_ifindex = 0;
Victor Stinner1a62a682014-08-17 19:33:28 +02001857 } else if ((size_t)len < sizeof(ifr.ifr_name)) {
Christian Heimes15b68852012-09-10 01:25:50 +02001858 strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
1859 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
Charles-François Natali47413c12011-10-06 19:47:44 +02001860 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1861 s->errorhandler();
1862 Py_DECREF(interfaceName);
1863 return 0;
1864 }
1865 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001866 PyErr_SetString(PyExc_OSError,
Charles-François Natali47413c12011-10-06 19:47:44 +02001867 "AF_CAN interface name too long");
1868 Py_DECREF(interfaceName);
1869 return 0;
1870 }
1871
1872 addr->can_family = AF_CAN;
1873 addr->can_ifindex = ifr.ifr_ifindex;
1874
1875 *len_ret = sizeof(*addr);
1876 Py_DECREF(interfaceName);
1877 return 1;
1878 }
1879 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001880 PyErr_SetString(PyExc_OSError,
Charles-François Natali47413c12011-10-06 19:47:44 +02001881 "getsockaddrarg: unsupported CAN protocol");
1882 return 0;
1883 }
1884#endif
Victor Stinnera534fc42013-06-03 22:07:27 +02001885
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001886#ifdef PF_SYSTEM
1887 case PF_SYSTEM:
1888 switch (s->sock_proto) {
1889#ifdef SYSPROTO_CONTROL
1890 case SYSPROTO_CONTROL:
1891 {
1892 struct sockaddr_ctl *addr;
Victor Stinnera534fc42013-06-03 22:07:27 +02001893
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001894 addr = (struct sockaddr_ctl *)addr_ret;
1895 addr->sc_family = AF_SYSTEM;
Victor Stinnera534fc42013-06-03 22:07:27 +02001896 addr->ss_sysaddr = AF_SYS_CONTROL;
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001897
1898 if (PyUnicode_Check(args)) {
1899 struct ctl_info info;
1900 PyObject *ctl_name;
1901
1902 if (!PyArg_Parse(args, "O&",
1903 PyUnicode_FSConverter, &ctl_name)) {
1904 return 0;
1905 }
1906
Victor Stinnerf50e1872015-03-20 11:32:24 +01001907 if (PyBytes_GET_SIZE(ctl_name) > (Py_ssize_t)sizeof(info.ctl_name)) {
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001908 PyErr_SetString(PyExc_ValueError,
1909 "provided string is too long");
1910 Py_DECREF(ctl_name);
1911 return 0;
1912 }
1913 strncpy(info.ctl_name, PyBytes_AS_STRING(ctl_name),
1914 sizeof(info.ctl_name));
1915 Py_DECREF(ctl_name);
1916
1917 if (ioctl(s->sock_fd, CTLIOCGINFO, &info)) {
1918 PyErr_SetString(PyExc_OSError,
1919 "cannot find kernel control with provided name");
1920 return 0;
1921 }
Victor Stinnera534fc42013-06-03 22:07:27 +02001922
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001923 addr->sc_id = info.ctl_id;
1924 addr->sc_unit = 0;
1925 } else if (!PyArg_ParseTuple(args, "II",
1926 &(addr->sc_id), &(addr->sc_unit))) {
1927 PyErr_SetString(PyExc_TypeError, "getsockaddrarg: "
1928 "expected str or tuple of two ints");
Victor Stinnera534fc42013-06-03 22:07:27 +02001929
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001930 return 0;
1931 }
Victor Stinnera534fc42013-06-03 22:07:27 +02001932
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001933 *len_ret = sizeof(*addr);
1934 return 1;
1935 }
1936#endif
1937 default:
1938 PyErr_SetString(PyExc_OSError,
1939 "getsockaddrarg: unsupported PF_SYSTEM protocol");
1940 return 0;
1941 }
1942#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02001943
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001944 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001945
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001946 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001947 PyErr_SetString(PyExc_OSError, "getsockaddrarg: bad family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001948 return 0;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001949
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001950 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001951}
1952
Guido van Rossum30a685f1991-06-27 15:51:29 +00001953
Guido van Rossum48a680c2001-03-02 06:34:14 +00001954/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00001955 Return 1 if the family is known, 0 otherwise. The length is returned
1956 through len_ret. */
1957
1958static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00001959getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001960{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001961 switch (s->sock_family) {
Guido van Rossum710e1df1992-06-12 10:39:36 +00001962
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001963#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001964 case AF_UNIX:
1965 {
1966 *len_ret = sizeof (struct sockaddr_un);
1967 return 1;
1968 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001969#endif /* AF_UNIX */
Martin Panter6d57fe12016-09-17 03:26:16 +00001970
Martin v. Löwis11017b12006-01-14 18:12:57 +00001971#if defined(AF_NETLINK)
Martin Panter6d57fe12016-09-17 03:26:16 +00001972 case AF_NETLINK:
1973 {
1974 *len_ret = sizeof (struct sockaddr_nl);
1975 return 1;
1976 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001977#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00001978
Charles-François Natali10b8cf42011-11-10 19:21:37 +01001979#ifdef AF_RDS
1980 case AF_RDS:
1981 /* RDS sockets use sockaddr_in: fall-through */
1982#endif
1983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001984 case AF_INET:
1985 {
1986 *len_ret = sizeof (struct sockaddr_in);
1987 return 1;
1988 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001989
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001990#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001991 case AF_INET6:
1992 {
1993 *len_ret = sizeof (struct sockaddr_in6);
1994 return 1;
1995 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001996#endif
1997
Hye-Shik Chang81268602004-02-02 06:05:24 +00001998#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001999 case AF_BLUETOOTH:
2000 {
2001 switch(s->sock_proto)
2002 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00002003
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002004 case BTPROTO_L2CAP:
2005 *len_ret = sizeof (struct sockaddr_l2);
2006 return 1;
2007 case BTPROTO_RFCOMM:
2008 *len_ret = sizeof (struct sockaddr_rc);
2009 return 1;
2010 case BTPROTO_HCI:
2011 *len_ret = sizeof (struct sockaddr_hci);
2012 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00002013#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002014 case BTPROTO_SCO:
2015 *len_ret = sizeof (struct sockaddr_sco);
2016 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00002017#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002018 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002019 PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002020 "unknown BT protocol");
2021 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00002022
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002023 }
2024 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00002025#endif
2026
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00002027#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002028 case AF_PACKET:
2029 {
2030 *len_ret = sizeof (struct sockaddr_ll);
2031 return 1;
2032 }
Jeremy Hylton22308652001-02-02 03:23:09 +00002033#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00002034
Christian Heimes043d6f62008-01-07 17:19:16 +00002035#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002036 case AF_TIPC:
2037 {
2038 *len_ret = sizeof (struct sockaddr_tipc);
2039 return 1;
2040 }
Christian Heimes043d6f62008-01-07 17:19:16 +00002041#endif
2042
Vinay Sajipecfc98c2014-03-20 12:42:42 +00002043#ifdef AF_CAN
Charles-François Natali47413c12011-10-06 19:47:44 +02002044 case AF_CAN:
2045 {
2046 *len_ret = sizeof (struct sockaddr_can);
2047 return 1;
2048 }
2049#endif
Victor Stinnera534fc42013-06-03 22:07:27 +02002050
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01002051#ifdef PF_SYSTEM
2052 case PF_SYSTEM:
2053 switch(s->sock_proto) {
2054#ifdef SYSPROTO_CONTROL
2055 case SYSPROTO_CONTROL:
2056 *len_ret = sizeof (struct sockaddr_ctl);
2057 return 1;
2058#endif
2059 default:
2060 PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
2061 "unknown PF_SYSTEM protocol");
2062 return 0;
2063 }
2064#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02002065
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002066 /* More cases here... */
Guido van Rossum710e1df1992-06-12 10:39:36 +00002067
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002068 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002069 PyErr_SetString(PyExc_OSError, "getsockaddrlen: bad family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002070 return 0;
Guido van Rossum710e1df1992-06-12 10:39:36 +00002071
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002072 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00002073}
2074
2075
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002076/* Support functions for the sendmsg() and recvmsg[_into]() methods.
2077 Currently, these methods are only compiled if the RFC 2292/3542
2078 CMSG_LEN() macro is available. Older systems seem to have used
2079 sizeof(struct cmsghdr) + (length) where CMSG_LEN() is used now, so
2080 it may be possible to define CMSG_LEN() that way if it's not
2081 provided. Some architectures might need extra padding after the
2082 cmsghdr, however, and CMSG_LEN() would have to take account of
2083 this. */
2084#ifdef CMSG_LEN
2085/* If length is in range, set *result to CMSG_LEN(length) and return
2086 true; otherwise, return false. */
2087static int
2088get_CMSG_LEN(size_t length, size_t *result)
2089{
2090 size_t tmp;
2091
2092 if (length > (SOCKLEN_T_LIMIT - CMSG_LEN(0)))
2093 return 0;
2094 tmp = CMSG_LEN(length);
2095 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2096 return 0;
2097 *result = tmp;
2098 return 1;
2099}
2100
2101#ifdef CMSG_SPACE
2102/* If length is in range, set *result to CMSG_SPACE(length) and return
2103 true; otherwise, return false. */
2104static int
2105get_CMSG_SPACE(size_t length, size_t *result)
2106{
2107 size_t tmp;
2108
2109 /* Use CMSG_SPACE(1) here in order to take account of the padding
2110 necessary before *and* after the data. */
2111 if (length > (SOCKLEN_T_LIMIT - CMSG_SPACE(1)))
2112 return 0;
2113 tmp = CMSG_SPACE(length);
2114 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2115 return 0;
2116 *result = tmp;
2117 return 1;
2118}
2119#endif
2120
2121/* Return true iff msg->msg_controllen is valid, cmsgh is a valid
2122 pointer in msg->msg_control with at least "space" bytes after it,
2123 and its cmsg_len member inside the buffer. */
2124static int
2125cmsg_min_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t space)
2126{
2127 size_t cmsg_offset;
2128 static const size_t cmsg_len_end = (offsetof(struct cmsghdr, cmsg_len) +
2129 sizeof(cmsgh->cmsg_len));
2130
Charles-François Natali466517d2011-08-28 18:23:43 +02002131 /* Note that POSIX allows msg_controllen to be of signed type. */
Brett Cannonb05cbe62014-01-07 17:01:01 -05002132 if (cmsgh == NULL || msg->msg_control == NULL)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002133 return 0;
Brett Cannonb05cbe62014-01-07 17:01:01 -05002134 /* Note that POSIX allows msg_controllen to be of a signed type. This is
2135 annoying under OS X as it's unsigned there and so it triggers a
2136 tautological comparison warning under Clang when compared against 0.
2137 Since the check is valid on other platforms, silence the warning under
2138 Clang. */
2139 #ifdef __clang__
2140 #pragma clang diagnostic push
2141 #pragma clang diagnostic ignored "-Wtautological-compare"
2142 #endif
Serhiy Storchakacaa01f82015-03-05 23:42:24 +02002143 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +02002144 #pragma GCC diagnostic push
2145 #pragma GCC diagnostic ignored "-Wtype-limits"
2146 #endif
Brett Cannonb05cbe62014-01-07 17:01:01 -05002147 if (msg->msg_controllen < 0)
2148 return 0;
Serhiy Storchakacaa01f82015-03-05 23:42:24 +02002149 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +02002150 #pragma GCC diagnostic pop
2151 #endif
Brett Cannonb05cbe62014-01-07 17:01:01 -05002152 #ifdef __clang__
2153 #pragma clang diagnostic pop
2154 #endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002155 if (space < cmsg_len_end)
2156 space = cmsg_len_end;
2157 cmsg_offset = (char *)cmsgh - (char *)msg->msg_control;
2158 return (cmsg_offset <= (size_t)-1 - space &&
2159 cmsg_offset + space <= msg->msg_controllen);
2160}
2161
2162/* If pointer CMSG_DATA(cmsgh) is in buffer msg->msg_control, set
2163 *space to number of bytes following it in the buffer and return
2164 true; otherwise, return false. Assumes cmsgh, msg->msg_control and
2165 msg->msg_controllen are valid. */
2166static int
2167get_cmsg_data_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *space)
2168{
2169 size_t data_offset;
2170 char *data_ptr;
2171
2172 if ((data_ptr = (char *)CMSG_DATA(cmsgh)) == NULL)
2173 return 0;
2174 data_offset = data_ptr - (char *)msg->msg_control;
2175 if (data_offset > msg->msg_controllen)
2176 return 0;
2177 *space = msg->msg_controllen - data_offset;
2178 return 1;
2179}
2180
2181/* If cmsgh is invalid or not contained in the buffer pointed to by
2182 msg->msg_control, return -1. If cmsgh is valid and its associated
2183 data is entirely contained in the buffer, set *data_len to the
2184 length of the associated data and return 0. If only part of the
2185 associated data is contained in the buffer but cmsgh is otherwise
2186 valid, set *data_len to the length contained in the buffer and
2187 return 1. */
2188static int
2189get_cmsg_data_len(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *data_len)
2190{
2191 size_t space, cmsg_data_len;
2192
2193 if (!cmsg_min_space(msg, cmsgh, CMSG_LEN(0)) ||
2194 cmsgh->cmsg_len < CMSG_LEN(0))
2195 return -1;
2196 cmsg_data_len = cmsgh->cmsg_len - CMSG_LEN(0);
2197 if (!get_cmsg_data_space(msg, cmsgh, &space))
2198 return -1;
2199 if (space >= cmsg_data_len) {
2200 *data_len = cmsg_data_len;
2201 return 0;
2202 }
2203 *data_len = space;
2204 return 1;
2205}
2206#endif /* CMSG_LEN */
2207
2208
Victor Stinner31bf2d52015-04-01 21:57:09 +02002209struct sock_accept {
2210 socklen_t *addrlen;
2211 sock_addr_t *addrbuf;
2212 SOCKET_T result;
2213};
2214
2215#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2216/* accept4() is available on Linux 2.6.28+ and glibc 2.10 */
2217static int accept4_works = -1;
2218#endif
2219
2220static int
2221sock_accept_impl(PySocketSockObject *s, void *data)
2222{
2223 struct sock_accept *ctx = data;
2224
2225#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2226 if (accept4_works != 0) {
2227 ctx->result = accept4(s->sock_fd, SAS2SA(ctx->addrbuf), ctx->addrlen,
2228 SOCK_CLOEXEC);
2229 if (ctx->result == INVALID_SOCKET && accept4_works == -1) {
2230 /* On Linux older than 2.6.28, accept4() fails with ENOSYS */
2231 accept4_works = (errno != ENOSYS);
2232 }
2233 }
2234 if (accept4_works == 0)
2235 ctx->result = accept(s->sock_fd, SAS2SA(ctx->addrbuf), ctx->addrlen);
2236#else
2237 ctx->result = accept(s->sock_fd, SAS2SA(ctx->addrbuf), ctx->addrlen);
2238#endif
Victor Stinnerbea232a2015-07-27 23:37:11 +02002239
2240#ifdef MS_WINDOWS
2241 return (ctx->result != INVALID_SOCKET);
2242#else
Victor Stinner31bf2d52015-04-01 21:57:09 +02002243 return (ctx->result >= 0);
Victor Stinnerbea232a2015-07-27 23:37:11 +02002244#endif
Victor Stinner31bf2d52015-04-01 21:57:09 +02002245}
2246
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002247/* s._accept() -> (fd, address) */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002248
Guido van Rossum73624e91994-10-10 17:59:00 +00002249static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002250sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002251{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002252 sock_addr_t addrbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002253 SOCKET_T newfd;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002254 socklen_t addrlen;
2255 PyObject *sock = NULL;
2256 PyObject *addr = NULL;
2257 PyObject *res = NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002258 struct sock_accept ctx;
Victor Stinnerdaf45552013-08-28 00:53:59 +02002259
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002260 if (!getsockaddrlen(s, &addrlen))
2261 return NULL;
2262 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002263
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002264 if (!IS_SELECTABLE(s))
2265 return select_error();
Neal Norwitz082b2df2006-02-07 07:04:46 +00002266
Victor Stinner31bf2d52015-04-01 21:57:09 +02002267 ctx.addrlen = &addrlen;
2268 ctx.addrbuf = &addrbuf;
2269 if (sock_call(s, 0, sock_accept_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002270 return NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002271 newfd = ctx.result;
Barry Warsaw752300b1997-01-03 17:18:10 +00002272
Victor Stinnerdaf45552013-08-28 00:53:59 +02002273#ifdef MS_WINDOWS
2274 if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
2275 PyErr_SetFromWindowsErr(0);
2276 SOCKETCLOSE(newfd);
2277 goto finally;
2278 }
2279#else
2280
2281#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2282 if (!accept4_works)
2283#endif
2284 {
2285 if (_Py_set_inheritable(newfd, 0, NULL) < 0) {
2286 SOCKETCLOSE(newfd);
2287 goto finally;
2288 }
2289 }
2290#endif
2291
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002292 sock = PyLong_FromSocket_t(newfd);
2293 if (sock == NULL) {
2294 SOCKETCLOSE(newfd);
2295 goto finally;
2296 }
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002297
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002298 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2299 addrlen, s->sock_proto);
2300 if (addr == NULL)
2301 goto finally;
Barry Warsaw752300b1997-01-03 17:18:10 +00002302
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002303 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00002304
Guido van Rossum67f7a382002-06-06 21:08:16 +00002305finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002306 Py_XDECREF(sock);
2307 Py_XDECREF(addr);
2308 return res;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002309}
2310
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002311PyDoc_STRVAR(accept_doc,
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002312"_accept() -> (integer, address info)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002313\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002314Wait for an incoming connection. Return a new socket file descriptor\n\
2315representing the connection, and the address of the client.\n\
2316For IP sockets, the address info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002317
Guido van Rossum11ba0942002-06-13 15:07:44 +00002318/* s.setblocking(flag) method. Argument:
2319 False -- non-blocking mode; same as settimeout(0)
2320 True -- blocking mode; same as settimeout(None)
2321*/
Guido van Rossume4485b01994-09-07 14:32:49 +00002322
Guido van Rossum73624e91994-10-10 17:59:00 +00002323static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002324sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00002325{
Serhiy Storchaka78980432013-01-15 01:12:17 +02002326 long block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002327
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002328 block = PyLong_AsLong(arg);
2329 if (block == -1 && PyErr_Occurred())
2330 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002331
Victor Stinner9001d802015-04-06 23:06:01 +02002332 s->sock_timeout = _PyTime_FromSeconds(block ? -1 : 0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002333 internal_setblocking(s, block);
Guido van Rossume4485b01994-09-07 14:32:49 +00002334
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002335 Py_INCREF(Py_None);
2336 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00002337}
Guido van Rossume4485b01994-09-07 14:32:49 +00002338
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002339PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002340"setblocking(flag)\n\
2341\n\
2342Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00002343setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002344setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002345
Victor Stinner71694d52015-03-28 01:18:54 +01002346static int
2347socket_parse_timeout(_PyTime_t *timeout, PyObject *timeout_obj)
2348{
2349#ifdef MS_WINDOWS
2350 struct timeval tv;
2351#endif
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002352#ifndef HAVE_POLL
2353 _PyTime_t ms;
2354#endif
Victor Stinner71694d52015-03-28 01:18:54 +01002355 int overflow = 0;
2356
2357 if (timeout_obj == Py_None) {
Victor Stinner10550cd2015-04-03 13:22:27 +02002358 *timeout = _PyTime_FromSeconds(-1);
Victor Stinner71694d52015-03-28 01:18:54 +01002359 return 0;
2360 }
2361
Victor Stinner869e1772015-03-30 03:49:14 +02002362 if (_PyTime_FromSecondsObject(timeout,
2363 timeout_obj, _PyTime_ROUND_CEILING) < 0)
Victor Stinner71694d52015-03-28 01:18:54 +01002364 return -1;
2365
2366 if (*timeout < 0) {
2367 PyErr_SetString(PyExc_ValueError, "Timeout value out of range");
2368 return -1;
2369 }
2370
2371#ifdef MS_WINDOWS
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002372 overflow |= (_PyTime_AsTimeval(*timeout, &tv, _PyTime_ROUND_CEILING) < 0);
Victor Stinner71694d52015-03-28 01:18:54 +01002373#endif
2374#ifndef HAVE_POLL
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002375 ms = _PyTime_AsMilliseconds(*timeout, _PyTime_ROUND_CEILING);
2376 overflow |= (ms > INT_MAX);
Victor Stinner71694d52015-03-28 01:18:54 +01002377#endif
2378 if (overflow) {
2379 PyErr_SetString(PyExc_OverflowError,
2380 "timeout doesn't fit into C timeval");
2381 return -1;
2382 }
2383
2384 return 0;
2385}
2386
Guido van Rossum11ba0942002-06-13 15:07:44 +00002387/* s.settimeout(timeout) method. Argument:
2388 None -- no timeout, blocking mode; same as setblocking(True)
2389 0.0 -- non-blocking mode; same as setblocking(False)
2390 > 0 -- timeout mode; operations time out after timeout seconds
2391 < 0 -- illegal; raises an exception
2392*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00002393static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002394sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00002395{
Victor Stinner71694d52015-03-28 01:18:54 +01002396 _PyTime_t timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002397
Victor Stinner71694d52015-03-28 01:18:54 +01002398 if (socket_parse_timeout(&timeout, arg) < 0)
2399 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002400
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002401 s->sock_timeout = timeout;
Victor Stinner71694d52015-03-28 01:18:54 +01002402 internal_setblocking(s, timeout < 0);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002403
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002404 Py_INCREF(Py_None);
2405 return Py_None;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002406}
2407
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002408PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002409"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002410\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00002411Set a timeout on socket operations. 'timeout' can be a float,\n\
2412giving in seconds, or None. Setting a timeout of None disables\n\
2413the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002414Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00002415
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002416/* s.gettimeout() method.
2417 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00002418static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002419sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00002420{
Victor Stinner71694d52015-03-28 01:18:54 +01002421 if (s->sock_timeout < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002422 Py_INCREF(Py_None);
2423 return Py_None;
2424 }
Victor Stinner71694d52015-03-28 01:18:54 +01002425 else {
2426 double seconds = _PyTime_AsSecondsDouble(s->sock_timeout);
2427 return PyFloat_FromDouble(seconds);
2428 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002429}
2430
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002431PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002432"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002433\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03002434Returns the timeout in seconds (float) associated with socket \n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002435operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002436operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00002437
Guido van Rossumaee08791992-09-08 09:05:33 +00002438/* s.setsockopt() method.
2439 With an integer third argument, sets an integer option.
2440 With a string third argument, sets an option from a buffer;
2441 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002442
Guido van Rossum73624e91994-10-10 17:59:00 +00002443static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002444sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002445{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002446 int level;
2447 int optname;
2448 int res;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02002449 Py_buffer optval;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002450 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002451
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002452 if (PyArg_ParseTuple(args, "iii:setsockopt",
2453 &level, &optname, &flag)) {
Victor Stinnerb6c15bc2015-03-31 16:35:35 +02002454 res = setsockopt(s->sock_fd, level, optname,
2455 (char*)&flag, sizeof flag);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002456 }
2457 else {
2458 PyErr_Clear();
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02002459 if (!PyArg_ParseTuple(args, "iiy*:setsockopt",
2460 &level, &optname, &optval))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002461 return NULL;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02002462 res = setsockopt(s->sock_fd, level, optname, optval.buf, optval.len);
2463 PyBuffer_Release(&optval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002464 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002465 if (res < 0)
2466 return s->errorhandler();
2467 Py_INCREF(Py_None);
2468 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002469}
2470
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002471PyDoc_STRVAR(setsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002472"setsockopt(level, option, value)\n\
2473\n\
2474Set a socket option. See the Unix manual for level and option.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002475The value argument can either be an integer or a string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002476
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002477
Guido van Rossumaee08791992-09-08 09:05:33 +00002478/* s.getsockopt() method.
2479 With two arguments, retrieves an integer option.
2480 With a third integer argument, retrieves a string buffer of that size;
2481 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002482
Guido van Rossum73624e91994-10-10 17:59:00 +00002483static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002484sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002485{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002486 int level;
2487 int optname;
2488 int res;
2489 PyObject *buf;
2490 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002491
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002492 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
2493 &level, &optname, &buflen))
2494 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002495
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002496 if (buflen == 0) {
2497 int flag = 0;
2498 socklen_t flagsize = sizeof flag;
2499 res = getsockopt(s->sock_fd, level, optname,
2500 (void *)&flag, &flagsize);
2501 if (res < 0)
2502 return s->errorhandler();
2503 return PyLong_FromLong(flag);
2504 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002505 if (buflen <= 0 || buflen > 1024) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002506 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002507 "getsockopt buflen out of range");
2508 return NULL;
2509 }
2510 buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
2511 if (buf == NULL)
2512 return NULL;
2513 res = getsockopt(s->sock_fd, level, optname,
2514 (void *)PyBytes_AS_STRING(buf), &buflen);
2515 if (res < 0) {
2516 Py_DECREF(buf);
2517 return s->errorhandler();
2518 }
2519 _PyBytes_Resize(&buf, buflen);
2520 return buf;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002521}
2522
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002523PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002524"getsockopt(level, option[, buffersize]) -> value\n\
2525\n\
2526Get a socket option. See the Unix manual for level and option.\n\
2527If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002528string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002529
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002530
Fred Drake728819a2000-07-01 03:40:12 +00002531/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002532
Guido van Rossum73624e91994-10-10 17:59:00 +00002533static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002534sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002535{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002536 sock_addr_t addrbuf;
2537 int addrlen;
2538 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002539
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002540 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2541 return NULL;
2542 Py_BEGIN_ALLOW_THREADS
2543 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
2544 Py_END_ALLOW_THREADS
2545 if (res < 0)
2546 return s->errorhandler();
2547 Py_INCREF(Py_None);
2548 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002549}
2550
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002551PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002552"bind(address)\n\
2553\n\
2554Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00002555pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002556sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002557
Guido van Rossum30a685f1991-06-27 15:51:29 +00002558
2559/* s.close() method.
2560 Set the file descriptor to -1 so operations tried subsequently
2561 will surely fail. */
2562
Guido van Rossum73624e91994-10-10 17:59:00 +00002563static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002564sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002565{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002566 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002567
Charles-François Natali6e6c59b2015-02-07 13:27:50 +00002568 /* We do not want to retry upon EINTR: see http://lwn.net/Articles/576478/
2569 * and http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
2570 * for more details.
2571 */
Victor Stinner524714e2016-07-22 17:43:59 +02002572 fd = s->sock_fd;
2573 if (fd != INVALID_SOCKET) {
2574 s->sock_fd = INVALID_SOCKET;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002575 Py_BEGIN_ALLOW_THREADS
2576 (void) SOCKETCLOSE(fd);
2577 Py_END_ALLOW_THREADS
2578 }
2579 Py_INCREF(Py_None);
2580 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002581}
2582
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002583PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002584"close()\n\
2585\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002586Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002587
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002588static PyObject *
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002589sock_detach(PySocketSockObject *s)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002590{
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002591 SOCKET_T fd = s->sock_fd;
Victor Stinner524714e2016-07-22 17:43:59 +02002592 s->sock_fd = INVALID_SOCKET;
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002593 return PyLong_FromSocket_t(fd);
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002594}
2595
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002596PyDoc_STRVAR(detach_doc,
2597"detach()\n\
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002598\n\
Guido van Rossum638aebd2013-12-04 11:50:09 -08002599Close the socket object without closing the underlying file descriptor.\n\
2600The object cannot be used after this call, but the file descriptor\n\
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002601can be reused for other purposes. The file descriptor is returned.");
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002602
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002603static int
Victor Stinner81c41db2015-04-02 11:50:57 +02002604sock_connect_impl(PySocketSockObject *s, void* Py_UNUSED(data))
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002605{
Victor Stinner81c41db2015-04-02 11:50:57 +02002606 int err;
2607 socklen_t size = sizeof err;
Victor Stinnerb6c15bc2015-03-31 16:35:35 +02002608
Victor Stinner81c41db2015-04-02 11:50:57 +02002609 if (getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR, (void *)&err, &size)) {
2610 /* getsockopt() failed */
2611 return 0;
2612 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002613
Victor Stinner81c41db2015-04-02 11:50:57 +02002614 if (err == EISCONN)
2615 return 1;
Victor Stinner38aec752015-04-02 14:37:20 +02002616 if (err != 0) {
2617 /* sock_call_ex() uses GET_SOCK_ERROR() to get the error code */
2618 SET_SOCK_ERROR(err);
Victor Stinner38aec752015-04-02 14:37:20 +02002619 return 0;
2620 }
2621 return 1;
Victor Stinner81c41db2015-04-02 11:50:57 +02002622}
2623
2624static int
2625internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
2626 int raise)
2627{
2628 int res, err, wait_connect;
Victor Stinnerb7df3142015-03-27 22:59:32 +01002629
2630 Py_BEGIN_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002631 res = connect(s->sock_fd, addr, addrlen);
Victor Stinnerb7df3142015-03-27 22:59:32 +01002632 Py_END_ALLOW_THREADS
2633
Victor Stinner70a46f62015-03-31 22:03:59 +02002634 if (!res) {
2635 /* connect() succeeded, the socket is connected */
2636 return 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002637 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002638
Victor Stinner81c41db2015-04-02 11:50:57 +02002639 /* connect() failed */
Victor Stinneree699e92015-03-31 21:28:42 +02002640
Victor Stinner81c41db2015-04-02 11:50:57 +02002641 /* save error, PyErr_CheckSignals() can replace it */
2642 err = GET_SOCK_ERROR;
2643 if (CHECK_ERRNO(EINTR)) {
2644 if (PyErr_CheckSignals())
Victor Stinner70a46f62015-03-31 22:03:59 +02002645 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +02002646
2647 /* Issue #23618: when connect() fails with EINTR, the connection is
2648 running asynchronously.
2649
2650 If the socket is blocking or has a timeout, wait until the
2651 connection completes, fails or timed out using select(), and then
2652 get the connection status using getsockopt(SO_ERROR).
2653
2654 If the socket is non-blocking, raise InterruptedError. The caller is
2655 responsible to wait until the connection completes, fails or timed
2656 out (it's the case in asyncio for example). */
2657 wait_connect = (s->sock_timeout != 0 && IS_SELECTABLE(s));
2658 }
2659 else {
2660 wait_connect = (s->sock_timeout > 0 && err == SOCK_INPROGRESS_ERR
2661 && IS_SELECTABLE(s));
Victor Stinner70a46f62015-03-31 22:03:59 +02002662 }
2663
Victor Stinner81c41db2015-04-02 11:50:57 +02002664 if (!wait_connect) {
2665 if (raise) {
2666 /* restore error, maybe replaced by PyErr_CheckSignals() */
2667 SET_SOCK_ERROR(err);
2668 s->errorhandler();
2669 return -1;
2670 }
2671 else
2672 return err;
Victor Stinner70a46f62015-03-31 22:03:59 +02002673 }
2674
Victor Stinner81c41db2015-04-02 11:50:57 +02002675 if (raise) {
2676 /* socket.connect() raises an exception on error */
Victor Stinner8912d142015-04-06 23:16:34 +02002677 if (sock_call_ex(s, 1, sock_connect_impl, NULL,
2678 1, NULL, s->sock_timeout) < 0)
Victor Stinner81c41db2015-04-02 11:50:57 +02002679 return -1;
Victor Stinner70a46f62015-03-31 22:03:59 +02002680 }
Victor Stinner81c41db2015-04-02 11:50:57 +02002681 else {
2682 /* socket.connect_ex() returns the error code on error */
Victor Stinner8912d142015-04-06 23:16:34 +02002683 if (sock_call_ex(s, 1, sock_connect_impl, NULL,
2684 1, &err, s->sock_timeout) < 0)
Victor Stinner81c41db2015-04-02 11:50:57 +02002685 return err;
2686 }
2687 return 0;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002688}
Guido van Rossum30a685f1991-06-27 15:51:29 +00002689
Fred Drake728819a2000-07-01 03:40:12 +00002690/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002691
Guido van Rossum73624e91994-10-10 17:59:00 +00002692static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002693sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002694{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002695 sock_addr_t addrbuf;
2696 int addrlen;
2697 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002698
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002699 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2700 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002701
Victor Stinner81c41db2015-04-02 11:50:57 +02002702 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 1);
Victor Stinneree699e92015-03-31 21:28:42 +02002703 if (res < 0)
2704 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002705
Victor Stinneree699e92015-03-31 21:28:42 +02002706 Py_RETURN_NONE;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002707}
2708
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002709PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002710"connect(address)\n\
2711\n\
2712Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002713is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002714
Guido van Rossum30a685f1991-06-27 15:51:29 +00002715
Fred Drake728819a2000-07-01 03:40:12 +00002716/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002717
2718static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002719sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002720{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002721 sock_addr_t addrbuf;
2722 int addrlen;
2723 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002724
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002725 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2726 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002727
Victor Stinner81c41db2015-04-02 11:50:57 +02002728 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 0);
Victor Stinner71694d52015-03-28 01:18:54 +01002729 if (res < 0)
2730 return NULL;
2731
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002732 return PyLong_FromLong((long) res);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002733}
2734
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002735PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002736"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002737\n\
2738This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002739instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002740
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002741
Guido van Rossumed233a51992-06-23 09:07:03 +00002742/* s.fileno() method */
2743
Guido van Rossum73624e91994-10-10 17:59:00 +00002744static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002745sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00002746{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002747 return PyLong_FromSocket_t(s->sock_fd);
Guido van Rossumed233a51992-06-23 09:07:03 +00002748}
2749
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002750PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002751"fileno() -> integer\n\
2752\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002753Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002754
Guido van Rossumed233a51992-06-23 09:07:03 +00002755
Guido van Rossumc89705d1992-11-26 08:54:07 +00002756/* s.getsockname() method */
2757
Guido van Rossum73624e91994-10-10 17:59:00 +00002758static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002759sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002760{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002761 sock_addr_t addrbuf;
2762 int res;
2763 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002764
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002765 if (!getsockaddrlen(s, &addrlen))
2766 return NULL;
2767 memset(&addrbuf, 0, addrlen);
2768 Py_BEGIN_ALLOW_THREADS
2769 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2770 Py_END_ALLOW_THREADS
2771 if (res < 0)
2772 return s->errorhandler();
2773 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2774 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002775}
2776
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002777PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002778"getsockname() -> address info\n\
2779\n\
2780Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002781info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002782
Guido van Rossumc89705d1992-11-26 08:54:07 +00002783
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002784#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002785/* s.getpeername() method */
2786
Guido van Rossum73624e91994-10-10 17:59:00 +00002787static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002788sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002789{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002790 sock_addr_t addrbuf;
2791 int res;
2792 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002793
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002794 if (!getsockaddrlen(s, &addrlen))
2795 return NULL;
2796 memset(&addrbuf, 0, addrlen);
2797 Py_BEGIN_ALLOW_THREADS
2798 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2799 Py_END_ALLOW_THREADS
2800 if (res < 0)
2801 return s->errorhandler();
2802 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2803 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002804}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002805
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002806PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002807"getpeername() -> address info\n\
2808\n\
2809Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002810info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002811
Guido van Rossumb6775db1994-08-01 11:34:53 +00002812#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002813
2814
Guido van Rossum30a685f1991-06-27 15:51:29 +00002815/* s.listen(n) method */
2816
Guido van Rossum73624e91994-10-10 17:59:00 +00002817static PyObject *
Charles-François Natali644b8f52014-05-22 19:45:39 +01002818sock_listen(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002819{
Charles-François Natali644b8f52014-05-22 19:45:39 +01002820 /* We try to choose a default backlog high enough to avoid connection drops
2821 * for common workloads, yet not too high to limit resource usage. */
2822 int backlog = Py_MIN(SOMAXCONN, 128);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002823 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002824
Charles-François Natali644b8f52014-05-22 19:45:39 +01002825 if (!PyArg_ParseTuple(args, "|i:listen", &backlog))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002826 return NULL;
Charles-François Natali644b8f52014-05-22 19:45:39 +01002827
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002828 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou1be815a2011-05-10 19:16:29 +02002829 /* To avoid problems on systems that don't allow a negative backlog
2830 * (which doesn't make sense anyway) we force a minimum value of 0. */
2831 if (backlog < 0)
2832 backlog = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002833 res = listen(s->sock_fd, backlog);
2834 Py_END_ALLOW_THREADS
2835 if (res < 0)
2836 return s->errorhandler();
2837 Py_INCREF(Py_None);
2838 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002839}
2840
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002841PyDoc_STRVAR(listen_doc,
Charles-François Natali644b8f52014-05-22 19:45:39 +01002842"listen([backlog])\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002843\n\
Charles-François Natali644b8f52014-05-22 19:45:39 +01002844Enable a server to accept connections. If backlog is specified, it must be\n\
2845at least 0 (if it is lower, it is set to 0); it specifies the number of\n\
Antoine Pitrou1be815a2011-05-10 19:16:29 +02002846unaccepted connections that the system will allow before refusing new\n\
Charles-François Natali644b8f52014-05-22 19:45:39 +01002847connections. If not specified, a default reasonable value is chosen.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002848
Victor Stinner31bf2d52015-04-01 21:57:09 +02002849struct sock_recv {
2850 char *cbuf;
2851 Py_ssize_t len;
2852 int flags;
2853 Py_ssize_t result;
2854};
2855
2856static int
2857sock_recv_impl(PySocketSockObject *s, void *data)
2858{
2859 struct sock_recv *ctx = data;
2860
2861#ifdef MS_WINDOWS
2862 if (ctx->len > INT_MAX)
2863 ctx->len = INT_MAX;
2864 ctx->result = recv(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags);
2865#else
2866 ctx->result = recv(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags);
2867#endif
2868 return (ctx->result >= 0);
2869}
2870
Guido van Rossum82a5c661998-07-07 20:45:43 +00002871
Thomas Wouters477c8d52006-05-27 19:21:47 +00002872/*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002873 * This is the guts of the recv() and recv_into() methods, which reads into a
Thomas Wouters902d6eb2007-01-09 23:18:33 +00002874 * char buffer. If you have any inc/dec ref to do to the objects that contain
Thomas Wouters477c8d52006-05-27 19:21:47 +00002875 * the buffer, do it in the caller. This function returns the number of bytes
Ezio Melotti13925002011-03-16 11:05:33 +02002876 * successfully read. If there was an error, it returns -1. Note that it is
Thomas Wouters477c8d52006-05-27 19:21:47 +00002877 * also possible that we return a number of bytes smaller than the request
2878 * bytes.
2879 */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002880
Antoine Pitrou19467d22010-08-17 19:33:30 +00002881static Py_ssize_t
2882sock_recv_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002883{
Victor Stinner31bf2d52015-04-01 21:57:09 +02002884 struct sock_recv ctx;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002885
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002886 if (!IS_SELECTABLE(s)) {
2887 select_error();
2888 return -1;
2889 }
2890 if (len == 0) {
2891 /* If 0 bytes were requested, do nothing. */
2892 return 0;
2893 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002894
Victor Stinner31bf2d52015-04-01 21:57:09 +02002895 ctx.cbuf = cbuf;
2896 ctx.len = len;
2897 ctx.flags = flags;
2898 if (sock_call(s, 0, sock_recv_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002899 return -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002900
2901 return ctx.result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002902}
2903
Guido van Rossum48a680c2001-03-02 06:34:14 +00002904
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002905/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002906
Guido van Rossum73624e91994-10-10 17:59:00 +00002907static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002908sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002909{
Antoine Pitrou19467d22010-08-17 19:33:30 +00002910 Py_ssize_t recvlen, outlen;
2911 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002912 PyObject *buf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002913
Antoine Pitrou19467d22010-08-17 19:33:30 +00002914 if (!PyArg_ParseTuple(args, "n|i:recv", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002915 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002916
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002917 if (recvlen < 0) {
2918 PyErr_SetString(PyExc_ValueError,
2919 "negative buffersize in recv");
2920 return NULL;
2921 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002922
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002923 /* Allocate a new string. */
2924 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2925 if (buf == NULL)
2926 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002927
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002928 /* Call the guts */
2929 outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
2930 if (outlen < 0) {
2931 /* An error occurred, release the string and return an
2932 error. */
2933 Py_DECREF(buf);
2934 return NULL;
2935 }
2936 if (outlen != recvlen) {
2937 /* We did not read as many bytes as we anticipated, resize the
2938 string if possible and be successful. */
2939 _PyBytes_Resize(&buf, outlen);
2940 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002941
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002942 return buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002943}
2944
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002945PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002946"recv(buffersize[, flags]) -> data\n\
2947\n\
2948Receive up to buffersize bytes from the socket. For the optional flags\n\
2949argument, see the Unix manual. When no data is available, block until\n\
2950at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002951the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002952
Guido van Rossum30a685f1991-06-27 15:51:29 +00002953
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002954/* s.recv_into(buffer, [nbytes [,flags]]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002955
Thomas Wouters477c8d52006-05-27 19:21:47 +00002956static PyObject*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002957sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002958{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002959 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002960
Antoine Pitrou19467d22010-08-17 19:33:30 +00002961 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002962 Py_buffer pbuf;
2963 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002964 Py_ssize_t buflen, readlen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002965
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002966 /* Get the buffer's memory */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002967 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recv_into", kwlist,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002968 &pbuf, &recvlen, &flags))
2969 return NULL;
2970 buf = pbuf.buf;
2971 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002972
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002973 if (recvlen < 0) {
2974 PyBuffer_Release(&pbuf);
2975 PyErr_SetString(PyExc_ValueError,
2976 "negative buffersize in recv_into");
2977 return NULL;
2978 }
2979 if (recvlen == 0) {
2980 /* If nbytes was not specified, use the buffer's length */
2981 recvlen = buflen;
2982 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002984 /* Check if the buffer is large enough */
2985 if (buflen < recvlen) {
2986 PyBuffer_Release(&pbuf);
2987 PyErr_SetString(PyExc_ValueError,
2988 "buffer too small for requested bytes");
2989 return NULL;
2990 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002992 /* Call the guts */
2993 readlen = sock_recv_guts(s, buf, recvlen, flags);
2994 if (readlen < 0) {
2995 /* Return an error. */
2996 PyBuffer_Release(&pbuf);
2997 return NULL;
2998 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002999
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003000 PyBuffer_Release(&pbuf);
3001 /* Return the number of bytes read. Note that we do not do anything
3002 special here in the case that readlen < recvlen. */
3003 return PyLong_FromSsize_t(readlen);
Thomas Wouters477c8d52006-05-27 19:21:47 +00003004}
3005
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003006PyDoc_STRVAR(recv_into_doc,
3007"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00003008\n\
3009A version of recv() that stores its data into a buffer rather than creating \n\
3010a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
3011is not specified (or 0), receive up to the size available in the given buffer.\n\
3012\n\
3013See recv() for documentation about the flags.");
3014
Victor Stinner31bf2d52015-04-01 21:57:09 +02003015struct sock_recvfrom {
3016 char* cbuf;
3017 Py_ssize_t len;
3018 int flags;
3019 socklen_t *addrlen;
3020 sock_addr_t *addrbuf;
3021 Py_ssize_t result;
3022};
3023
3024static int
3025sock_recvfrom_impl(PySocketSockObject *s, void *data)
3026{
3027 struct sock_recvfrom *ctx = data;
3028
3029 memset(ctx->addrbuf, 0, *ctx->addrlen);
3030
3031#ifdef MS_WINDOWS
3032 if (ctx->len > INT_MAX)
3033 ctx->len = INT_MAX;
3034 ctx->result = recvfrom(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags,
3035 SAS2SA(ctx->addrbuf), ctx->addrlen);
3036#else
3037 ctx->result = recvfrom(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags,
3038 SAS2SA(ctx->addrbuf), ctx->addrlen);
3039#endif
3040 return (ctx->result >= 0);
3041}
3042
Thomas Wouters477c8d52006-05-27 19:21:47 +00003043
3044/*
Christian Heimes99170a52007-12-19 02:07:34 +00003045 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
3046 * into a char buffer. If you have any inc/def ref to do to the objects that
3047 * contain the buffer, do it in the caller. This function returns the number
Ezio Melotti13925002011-03-16 11:05:33 +02003048 * of bytes successfully read. If there was an error, it returns -1. Note
Christian Heimes99170a52007-12-19 02:07:34 +00003049 * that it is also possible that we return a number of bytes smaller than the
3050 * request bytes.
Thomas Wouters477c8d52006-05-27 19:21:47 +00003051 *
3052 * 'addr' is a return value for the address object. Note that you must decref
3053 * it yourself.
3054 */
Antoine Pitrou19467d22010-08-17 19:33:30 +00003055static Py_ssize_t
3056sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003057 PyObject** addr)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003058{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003059 sock_addr_t addrbuf;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003060 socklen_t addrlen;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003061 struct sock_recvfrom ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003062
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003063 *addr = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003065 if (!getsockaddrlen(s, &addrlen))
3066 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003067
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003068 if (!IS_SELECTABLE(s)) {
3069 select_error();
3070 return -1;
3071 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003072
Victor Stinner31bf2d52015-04-01 21:57:09 +02003073 ctx.cbuf = cbuf;
3074 ctx.len = len;
3075 ctx.flags = flags;
3076 ctx.addrbuf = &addrbuf;
3077 ctx.addrlen = &addrlen;
3078 if (sock_call(s, 0, sock_recvfrom_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003079 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003080
Victor Stinner31bf2d52015-04-01 21:57:09 +02003081 *addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
3082 s->sock_proto);
3083 if (*addr == NULL)
3084 return -1;
3085
3086 return ctx.result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003087}
3088
3089/* s.recvfrom(nbytes [,flags]) method */
3090
3091static PyObject *
3092sock_recvfrom(PySocketSockObject *s, PyObject *args)
3093{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003094 PyObject *buf = NULL;
3095 PyObject *addr = NULL;
3096 PyObject *ret = NULL;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003097 int flags = 0;
3098 Py_ssize_t recvlen, outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003099
Antoine Pitrou19467d22010-08-17 19:33:30 +00003100 if (!PyArg_ParseTuple(args, "n|i:recvfrom", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003101 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00003102
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003103 if (recvlen < 0) {
3104 PyErr_SetString(PyExc_ValueError,
3105 "negative buffersize in recvfrom");
3106 return NULL;
3107 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00003108
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003109 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
3110 if (buf == NULL)
3111 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003112
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003113 outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
3114 recvlen, flags, &addr);
3115 if (outlen < 0) {
3116 goto finally;
3117 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003118
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003119 if (outlen != recvlen) {
3120 /* We did not read as many bytes as we anticipated, resize the
Ezio Melotti13925002011-03-16 11:05:33 +02003121 string if possible and be successful. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003122 if (_PyBytes_Resize(&buf, outlen) < 0)
Ezio Melotti13925002011-03-16 11:05:33 +02003123 /* Oopsy, not so successful after all. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003124 goto finally;
3125 }
Barry Warsaw752300b1997-01-03 17:18:10 +00003126
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003127 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003128
3129finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003130 Py_XDECREF(buf);
3131 Py_XDECREF(addr);
3132 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003133}
3134
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003135PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003136"recvfrom(buffersize[, flags]) -> (data, address info)\n\
3137\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003138Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003139
Thomas Wouters477c8d52006-05-27 19:21:47 +00003140
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003141/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
Thomas Wouters477c8d52006-05-27 19:21:47 +00003142
3143static PyObject *
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003144sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00003145{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003146 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00003147
Antoine Pitrou19467d22010-08-17 19:33:30 +00003148 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003149 Py_buffer pbuf;
3150 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003151 Py_ssize_t readlen, buflen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003152
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003153 PyObject *addr = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003154
Antoine Pitrou19467d22010-08-17 19:33:30 +00003155 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recvfrom_into",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003156 kwlist, &pbuf,
3157 &recvlen, &flags))
3158 return NULL;
3159 buf = pbuf.buf;
3160 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003161
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003162 if (recvlen < 0) {
3163 PyBuffer_Release(&pbuf);
3164 PyErr_SetString(PyExc_ValueError,
3165 "negative buffersize in recvfrom_into");
3166 return NULL;
3167 }
3168 if (recvlen == 0) {
3169 /* If nbytes was not specified, use the buffer's length */
3170 recvlen = buflen;
Benjamin Petersonc6b37e22014-01-13 23:14:42 -05003171 } else if (recvlen > buflen) {
3172 PyBuffer_Release(&pbuf);
3173 PyErr_SetString(PyExc_ValueError,
3174 "nbytes is greater than the length of the buffer");
3175 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003176 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003177
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003178 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
3179 if (readlen < 0) {
3180 PyBuffer_Release(&pbuf);
3181 /* Return an error */
3182 Py_XDECREF(addr);
3183 return NULL;
3184 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003185
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003186 PyBuffer_Release(&pbuf);
3187 /* Return the number of bytes read and the address. Note that we do
3188 not do anything special here in the case that readlen < recvlen. */
Antoine Pitrou19467d22010-08-17 19:33:30 +00003189 return Py_BuildValue("nN", readlen, addr);
Thomas Wouters477c8d52006-05-27 19:21:47 +00003190}
3191
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003192PyDoc_STRVAR(recvfrom_into_doc,
3193"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00003194\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003195Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00003196
Victor Stinner35bee932015-04-02 12:28:07 +02003197/* The sendmsg() and recvmsg[_into]() methods require a working
3198 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3199#ifdef CMSG_LEN
Victor Stinner31bf2d52015-04-01 21:57:09 +02003200struct sock_recvmsg {
3201 struct msghdr *msg;
3202 int flags;
3203 ssize_t result;
3204};
3205
3206static int
3207sock_recvmsg_impl(PySocketSockObject *s, void *data)
3208{
3209 struct sock_recvmsg *ctx = data;
3210
3211 ctx->result = recvmsg(s->sock_fd, ctx->msg, ctx->flags);
3212 return (ctx->result >= 0);
3213}
3214
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003215/*
3216 * Call recvmsg() with the supplied iovec structures, flags, and
3217 * ancillary data buffer size (controllen). Returns the tuple return
3218 * value for recvmsg() or recvmsg_into(), with the first item provided
3219 * by the supplied makeval() function. makeval() will be called with
3220 * the length read and makeval_data as arguments, and must return a
3221 * new reference (which will be decrefed if there is a subsequent
3222 * error). On error, closes any file descriptors received via
3223 * SCM_RIGHTS.
3224 */
3225static PyObject *
3226sock_recvmsg_guts(PySocketSockObject *s, struct iovec *iov, int iovlen,
3227 int flags, Py_ssize_t controllen,
3228 PyObject *(*makeval)(ssize_t, void *), void *makeval_data)
3229{
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003230 sock_addr_t addrbuf;
3231 socklen_t addrbuflen;
Charles-François Natalie9e95ae2011-08-24 21:40:53 +02003232 struct msghdr msg = {0};
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003233 PyObject *cmsg_list = NULL, *retval = NULL;
3234 void *controlbuf = NULL;
3235 struct cmsghdr *cmsgh;
3236 size_t cmsgdatalen = 0;
3237 int cmsg_status;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003238 struct sock_recvmsg ctx;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003239
3240 /* XXX: POSIX says that msg_name and msg_namelen "shall be
3241 ignored" when the socket is connected (Linux fills them in
3242 anyway for AF_UNIX sockets at least). Normally msg_namelen
3243 seems to be set to 0 if there's no address, but try to
3244 initialize msg_name to something that won't be mistaken for a
3245 real address if that doesn't happen. */
3246 if (!getsockaddrlen(s, &addrbuflen))
3247 return NULL;
3248 memset(&addrbuf, 0, addrbuflen);
3249 SAS2SA(&addrbuf)->sa_family = AF_UNSPEC;
3250
3251 if (controllen < 0 || controllen > SOCKLEN_T_LIMIT) {
3252 PyErr_SetString(PyExc_ValueError,
3253 "invalid ancillary data buffer length");
3254 return NULL;
3255 }
3256 if (controllen > 0 && (controlbuf = PyMem_Malloc(controllen)) == NULL)
3257 return PyErr_NoMemory();
3258
3259 /* Make the system call. */
3260 if (!IS_SELECTABLE(s)) {
3261 select_error();
3262 goto finally;
3263 }
3264
Victor Stinner31bf2d52015-04-01 21:57:09 +02003265 msg.msg_name = SAS2SA(&addrbuf);
3266 msg.msg_namelen = addrbuflen;
3267 msg.msg_iov = iov;
3268 msg.msg_iovlen = iovlen;
3269 msg.msg_control = controlbuf;
3270 msg.msg_controllen = controllen;
Victor Stinnerb7df3142015-03-27 22:59:32 +01003271
Victor Stinner31bf2d52015-04-01 21:57:09 +02003272 ctx.msg = &msg;
3273 ctx.flags = flags;
3274 if (sock_call(s, 0, sock_recvmsg_impl, &ctx) < 0)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003275 goto finally;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003276
3277 /* Make list of (level, type, data) tuples from control messages. */
3278 if ((cmsg_list = PyList_New(0)) == NULL)
3279 goto err_closefds;
3280 /* Check for empty ancillary data as old CMSG_FIRSTHDR()
3281 implementations didn't do so. */
3282 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
3283 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
3284 PyObject *bytes, *tuple;
3285 int tmp;
3286
3287 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
3288 if (cmsg_status != 0) {
3289 if (PyErr_WarnEx(PyExc_RuntimeWarning,
3290 "received malformed or improperly-truncated "
3291 "ancillary data", 1) == -1)
3292 goto err_closefds;
3293 }
3294 if (cmsg_status < 0)
3295 break;
3296 if (cmsgdatalen > PY_SSIZE_T_MAX) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003297 PyErr_SetString(PyExc_OSError, "control message too long");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003298 goto err_closefds;
3299 }
3300
3301 bytes = PyBytes_FromStringAndSize((char *)CMSG_DATA(cmsgh),
3302 cmsgdatalen);
3303 tuple = Py_BuildValue("iiN", (int)cmsgh->cmsg_level,
3304 (int)cmsgh->cmsg_type, bytes);
3305 if (tuple == NULL)
3306 goto err_closefds;
3307 tmp = PyList_Append(cmsg_list, tuple);
3308 Py_DECREF(tuple);
3309 if (tmp != 0)
3310 goto err_closefds;
3311
3312 if (cmsg_status != 0)
3313 break;
3314 }
3315
3316 retval = Py_BuildValue("NOiN",
Victor Stinner31bf2d52015-04-01 21:57:09 +02003317 (*makeval)(ctx.result, makeval_data),
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003318 cmsg_list,
3319 (int)msg.msg_flags,
3320 makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
3321 ((msg.msg_namelen > addrbuflen) ?
3322 addrbuflen : msg.msg_namelen),
3323 s->sock_proto));
3324 if (retval == NULL)
3325 goto err_closefds;
3326
3327finally:
3328 Py_XDECREF(cmsg_list);
3329 PyMem_Free(controlbuf);
3330 return retval;
3331
3332err_closefds:
3333#ifdef SCM_RIGHTS
3334 /* Close all descriptors coming from SCM_RIGHTS, so they don't leak. */
3335 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
3336 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
3337 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
3338 if (cmsg_status < 0)
3339 break;
3340 if (cmsgh->cmsg_level == SOL_SOCKET &&
3341 cmsgh->cmsg_type == SCM_RIGHTS) {
3342 size_t numfds;
3343 int *fdp;
3344
3345 numfds = cmsgdatalen / sizeof(int);
3346 fdp = (int *)CMSG_DATA(cmsgh);
3347 while (numfds-- > 0)
3348 close(*fdp++);
3349 }
3350 if (cmsg_status != 0)
3351 break;
3352 }
3353#endif /* SCM_RIGHTS */
3354 goto finally;
3355}
3356
3357
3358static PyObject *
3359makeval_recvmsg(ssize_t received, void *data)
3360{
3361 PyObject **buf = data;
3362
3363 if (received < PyBytes_GET_SIZE(*buf))
3364 _PyBytes_Resize(buf, received);
3365 Py_XINCREF(*buf);
3366 return *buf;
3367}
3368
3369/* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
3370
3371static PyObject *
3372sock_recvmsg(PySocketSockObject *s, PyObject *args)
3373{
3374 Py_ssize_t bufsize, ancbufsize = 0;
3375 int flags = 0;
3376 struct iovec iov;
3377 PyObject *buf = NULL, *retval = NULL;
3378
3379 if (!PyArg_ParseTuple(args, "n|ni:recvmsg", &bufsize, &ancbufsize, &flags))
3380 return NULL;
3381
3382 if (bufsize < 0) {
3383 PyErr_SetString(PyExc_ValueError, "negative buffer size in recvmsg()");
3384 return NULL;
3385 }
3386 if ((buf = PyBytes_FromStringAndSize(NULL, bufsize)) == NULL)
3387 return NULL;
3388 iov.iov_base = PyBytes_AS_STRING(buf);
3389 iov.iov_len = bufsize;
3390
3391 /* Note that we're passing a pointer to *our pointer* to the bytes
3392 object here (&buf); makeval_recvmsg() may incref the object, or
3393 deallocate it and set our pointer to NULL. */
3394 retval = sock_recvmsg_guts(s, &iov, 1, flags, ancbufsize,
3395 &makeval_recvmsg, &buf);
3396 Py_XDECREF(buf);
3397 return retval;
3398}
3399
3400PyDoc_STRVAR(recvmsg_doc,
3401"recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\
3402\n\
3403Receive normal data (up to bufsize bytes) and ancillary data from the\n\
3404socket. The ancbufsize argument sets the size in bytes of the\n\
3405internal buffer used to receive the ancillary data; it defaults to 0,\n\
3406meaning that no ancillary data will be received. Appropriate buffer\n\
3407sizes for ancillary data can be calculated using CMSG_SPACE() or\n\
3408CMSG_LEN(), and items which do not fit into the buffer might be\n\
3409truncated or discarded. The flags argument defaults to 0 and has the\n\
3410same meaning as for recv().\n\
3411\n\
3412The return value is a 4-tuple: (data, ancdata, msg_flags, address).\n\
3413The data item is a bytes object holding the non-ancillary data\n\
3414received. The ancdata item is a list of zero or more tuples\n\
3415(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n\
3416(control messages) received: cmsg_level and cmsg_type are integers\n\
3417specifying the protocol level and protocol-specific type respectively,\n\
3418and cmsg_data is a bytes object holding the associated data. The\n\
3419msg_flags item is the bitwise OR of various flags indicating\n\
3420conditions on the received message; see your system documentation for\n\
3421details. If the receiving socket is unconnected, address is the\n\
3422address of the sending socket, if available; otherwise, its value is\n\
3423unspecified.\n\
3424\n\
3425If recvmsg() raises an exception after the system call returns, it\n\
3426will first attempt to close any file descriptors received via the\n\
3427SCM_RIGHTS mechanism.");
3428
3429
3430static PyObject *
3431makeval_recvmsg_into(ssize_t received, void *data)
3432{
3433 return PyLong_FromSsize_t(received);
3434}
3435
3436/* s.recvmsg_into(buffers[, ancbufsize[, flags]]) method */
3437
3438static PyObject *
3439sock_recvmsg_into(PySocketSockObject *s, PyObject *args)
3440{
3441 Py_ssize_t ancbufsize = 0;
3442 int flags = 0;
3443 struct iovec *iovs = NULL;
3444 Py_ssize_t i, nitems, nbufs = 0;
3445 Py_buffer *bufs = NULL;
3446 PyObject *buffers_arg, *fast, *retval = NULL;
3447
3448 if (!PyArg_ParseTuple(args, "O|ni:recvmsg_into",
3449 &buffers_arg, &ancbufsize, &flags))
3450 return NULL;
3451
3452 if ((fast = PySequence_Fast(buffers_arg,
3453 "recvmsg_into() argument 1 must be an "
3454 "iterable")) == NULL)
3455 return NULL;
3456 nitems = PySequence_Fast_GET_SIZE(fast);
3457 if (nitems > INT_MAX) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003458 PyErr_SetString(PyExc_OSError, "recvmsg_into() argument 1 is too long");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003459 goto finally;
3460 }
3461
3462 /* Fill in an iovec for each item, and save the Py_buffer
3463 structs to release afterwards. */
3464 if (nitems > 0 && ((iovs = PyMem_New(struct iovec, nitems)) == NULL ||
3465 (bufs = PyMem_New(Py_buffer, nitems)) == NULL)) {
3466 PyErr_NoMemory();
3467 goto finally;
3468 }
3469 for (; nbufs < nitems; nbufs++) {
3470 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(fast, nbufs),
3471 "w*;recvmsg_into() argument 1 must be an iterable "
3472 "of single-segment read-write buffers",
3473 &bufs[nbufs]))
3474 goto finally;
3475 iovs[nbufs].iov_base = bufs[nbufs].buf;
3476 iovs[nbufs].iov_len = bufs[nbufs].len;
3477 }
3478
3479 retval = sock_recvmsg_guts(s, iovs, nitems, flags, ancbufsize,
3480 &makeval_recvmsg_into, NULL);
3481finally:
3482 for (i = 0; i < nbufs; i++)
3483 PyBuffer_Release(&bufs[i]);
3484 PyMem_Free(bufs);
3485 PyMem_Free(iovs);
3486 Py_DECREF(fast);
3487 return retval;
3488}
3489
3490PyDoc_STRVAR(recvmsg_into_doc,
3491"recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\
3492\n\
3493Receive normal data and ancillary data from the socket, scattering the\n\
3494non-ancillary data into a series of buffers. The buffers argument\n\
3495must be an iterable of objects that export writable buffers\n\
3496(e.g. bytearray objects); these will be filled with successive chunks\n\
3497of the non-ancillary data until it has all been written or there are\n\
3498no more buffers. The ancbufsize argument sets the size in bytes of\n\
3499the internal buffer used to receive the ancillary data; it defaults to\n\
35000, meaning that no ancillary data will be received. Appropriate\n\
3501buffer sizes for ancillary data can be calculated using CMSG_SPACE()\n\
3502or CMSG_LEN(), and items which do not fit into the buffer might be\n\
3503truncated or discarded. The flags argument defaults to 0 and has the\n\
3504same meaning as for recv().\n\
3505\n\
3506The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\n\
3507The nbytes item is the total number of bytes of non-ancillary data\n\
3508written into the buffers. The ancdata item is a list of zero or more\n\
3509tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\n\
3510data (control messages) received: cmsg_level and cmsg_type are\n\
3511integers specifying the protocol level and protocol-specific type\n\
3512respectively, and cmsg_data is a bytes object holding the associated\n\
3513data. The msg_flags item is the bitwise OR of various flags\n\
3514indicating conditions on the received message; see your system\n\
3515documentation for details. If the receiving socket is unconnected,\n\
3516address is the address of the sending socket, if available; otherwise,\n\
3517its value is unspecified.\n\
3518\n\
3519If recvmsg_into() raises an exception after the system call returns,\n\
3520it will first attempt to close any file descriptors received via the\n\
3521SCM_RIGHTS mechanism.");
3522#endif /* CMSG_LEN */
3523
3524
Victor Stinner31bf2d52015-04-01 21:57:09 +02003525struct sock_send {
3526 char *buf;
3527 Py_ssize_t len;
3528 int flags;
3529 Py_ssize_t result;
3530};
3531
3532static int
3533sock_send_impl(PySocketSockObject *s, void *data)
3534{
3535 struct sock_send *ctx = data;
3536
3537#ifdef MS_WINDOWS
3538 if (ctx->len > INT_MAX)
3539 ctx->len = INT_MAX;
3540 ctx->result = send(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags);
3541#else
3542 ctx->result = send(s->sock_fd, ctx->buf, ctx->len, ctx->flags);
3543#endif
3544 return (ctx->result >= 0);
3545}
3546
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003547/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003548
Guido van Rossum73624e91994-10-10 17:59:00 +00003549static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003550sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003551{
Victor Stinner31bf2d52015-04-01 21:57:09 +02003552 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003553 Py_buffer pbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003554 struct sock_send ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003555
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003556 if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
3557 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003558
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003559 if (!IS_SELECTABLE(s)) {
3560 PyBuffer_Release(&pbuf);
3561 return select_error();
3562 }
Victor Stinner31bf2d52015-04-01 21:57:09 +02003563 ctx.buf = pbuf.buf;
3564 ctx.len = pbuf.len;
3565 ctx.flags = flags;
3566 if (sock_call(s, 1, sock_send_impl, &ctx) < 0) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003567 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003568 return NULL;
3569 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003570 PyBuffer_Release(&pbuf);
Victor Stinner31bf2d52015-04-01 21:57:09 +02003571
3572 return PyLong_FromSsize_t(ctx.result);
Guido van Rossum30a685f1991-06-27 15:51:29 +00003573}
3574
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003575PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003576"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003577\n\
3578Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003579argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003580sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003581
3582
3583/* s.sendall(data [,flags]) method */
3584
3585static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003586sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003587{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003588 char *buf;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003589 Py_ssize_t len, n;
3590 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003591 Py_buffer pbuf;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003592 struct sock_send ctx;
Victor Stinner8912d142015-04-06 23:16:34 +02003593 int has_timeout = (s->sock_timeout > 0);
3594 _PyTime_t interval = s->sock_timeout;
3595 _PyTime_t deadline = 0;
3596 int deadline_initialized = 0;
3597 PyObject *res = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003598
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003599 if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
3600 return NULL;
3601 buf = pbuf.buf;
3602 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003603
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003604 if (!IS_SELECTABLE(s)) {
3605 PyBuffer_Release(&pbuf);
3606 return select_error();
3607 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003608
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003609 do {
Victor Stinner8912d142015-04-06 23:16:34 +02003610 if (has_timeout) {
3611 if (deadline_initialized) {
3612 /* recompute the timeout */
3613 interval = deadline - _PyTime_GetMonotonicClock();
3614 }
3615 else {
3616 deadline_initialized = 1;
3617 deadline = _PyTime_GetMonotonicClock() + s->sock_timeout;
3618 }
3619
3620 if (interval <= 0) {
3621 PyErr_SetString(socket_timeout, "timed out");
3622 goto done;
3623 }
3624 }
3625
Victor Stinner02f32ab2015-04-01 22:53:26 +02003626 ctx.buf = buf;
3627 ctx.len = len;
3628 ctx.flags = flags;
Victor Stinner8912d142015-04-06 23:16:34 +02003629 if (sock_call_ex(s, 1, sock_send_impl, &ctx, 0, NULL, interval) < 0)
3630 goto done;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003631 n = ctx.result;
3632 assert(n >= 0);
3633
3634 buf += n;
3635 len -= n;
3636
3637 /* We must run our signal handlers before looping again.
3638 send() can return a successful partial write when it is
3639 interrupted, so we can't restrict ourselves to EINTR. */
Victor Stinner8912d142015-04-06 23:16:34 +02003640 if (PyErr_CheckSignals())
3641 goto done;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003642 } while (len > 0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003643 PyBuffer_Release(&pbuf);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003644
Victor Stinner8912d142015-04-06 23:16:34 +02003645 Py_INCREF(Py_None);
3646 res = Py_None;
3647
3648done:
3649 PyBuffer_Release(&pbuf);
3650 return res;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003651}
3652
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003653PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003654"sendall(data[, flags])\n\
3655\n\
3656Send a data string to the socket. For the optional flags\n\
3657argument, see the Unix manual. This calls send() repeatedly\n\
3658until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003659to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003660
Guido van Rossum30a685f1991-06-27 15:51:29 +00003661
Victor Stinner31bf2d52015-04-01 21:57:09 +02003662struct sock_sendto {
3663 char *buf;
3664 Py_ssize_t len;
3665 int flags;
3666 int addrlen;
3667 sock_addr_t *addrbuf;
3668 Py_ssize_t result;
3669};
3670
3671static int
3672sock_sendto_impl(PySocketSockObject *s, void *data)
3673{
3674 struct sock_sendto *ctx = data;
3675
3676#ifdef MS_WINDOWS
3677 if (ctx->len > INT_MAX)
3678 ctx->len = INT_MAX;
3679 ctx->result = sendto(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags,
3680 SAS2SA(ctx->addrbuf), ctx->addrlen);
3681#else
3682 ctx->result = sendto(s->sock_fd, ctx->buf, ctx->len, ctx->flags,
3683 SAS2SA(ctx->addrbuf), ctx->addrlen);
3684#endif
3685 return (ctx->result >= 0);
3686}
3687
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003688/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003689
Guido van Rossum73624e91994-10-10 17:59:00 +00003690static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003691sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003692{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003693 Py_buffer pbuf;
3694 PyObject *addro;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003695 Py_ssize_t arglen;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003696 sock_addr_t addrbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003697 int addrlen, flags;
3698 struct sock_sendto ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003699
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003700 flags = 0;
Antoine Pitrou5e981412011-03-17 22:38:37 +01003701 arglen = PyTuple_Size(args);
3702 switch (arglen) {
3703 case 2:
3704 PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro);
3705 break;
3706 case 3:
3707 PyArg_ParseTuple(args, "y*iO:sendto",
3708 &pbuf, &flags, &addro);
3709 break;
3710 default:
3711 PyErr_Format(PyExc_TypeError,
3712 "sendto() takes 2 or 3 arguments (%d given)",
3713 arglen);
Victor Stinner77af1722011-05-26 14:05:59 +02003714 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003715 }
Antoine Pitrou5e981412011-03-17 22:38:37 +01003716 if (PyErr_Occurred())
3717 return NULL;
3718
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003719 if (!IS_SELECTABLE(s)) {
3720 PyBuffer_Release(&pbuf);
3721 return select_error();
3722 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003723
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003724 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
3725 PyBuffer_Release(&pbuf);
3726 return NULL;
3727 }
Thomas Wouters89f507f2006-12-13 04:49:30 +00003728
Victor Stinner31bf2d52015-04-01 21:57:09 +02003729 ctx.buf = pbuf.buf;
3730 ctx.len = pbuf.len;
3731 ctx.flags = flags;
3732 ctx.addrlen = addrlen;
3733 ctx.addrbuf = &addrbuf;
3734 if (sock_call(s, 1, sock_sendto_impl, &ctx) < 0) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003735 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003736 return NULL;
3737 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003738 PyBuffer_Release(&pbuf);
Victor Stinner31bf2d52015-04-01 21:57:09 +02003739
3740 return PyLong_FromSsize_t(ctx.result);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003741}
3742
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003743PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003744"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003745\n\
3746Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003747For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003748
Guido van Rossum30a685f1991-06-27 15:51:29 +00003749
Victor Stinner35bee932015-04-02 12:28:07 +02003750/* The sendmsg() and recvmsg[_into]() methods require a working
3751 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3752#ifdef CMSG_LEN
Victor Stinner31bf2d52015-04-01 21:57:09 +02003753struct sock_sendmsg {
3754 struct msghdr *msg;
3755 int flags;
3756 ssize_t result;
3757};
3758
3759static int
3760sock_sendmsg_impl(PySocketSockObject *s, void *data)
3761{
3762 struct sock_sendmsg *ctx = data;
3763
3764 ctx->result = sendmsg(s->sock_fd, ctx->msg, ctx->flags);
3765 return (ctx->result >= 0);
3766}
3767
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003768/* s.sendmsg(buffers[, ancdata[, flags[, address]]]) method */
3769
3770static PyObject *
3771sock_sendmsg(PySocketSockObject *s, PyObject *args)
3772{
3773 Py_ssize_t i, ndataparts, ndatabufs = 0, ncmsgs, ncmsgbufs = 0;
3774 Py_buffer *databufs = NULL;
3775 struct iovec *iovs = NULL;
3776 sock_addr_t addrbuf;
Charles-François Natalie9e95ae2011-08-24 21:40:53 +02003777 struct msghdr msg = {0};
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003778 struct cmsginfo {
3779 int level;
3780 int type;
3781 Py_buffer data;
3782 } *cmsgs = NULL;
3783 void *controlbuf = NULL;
3784 size_t controllen, controllen_last;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003785 int addrlen, flags = 0;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003786 PyObject *data_arg, *cmsg_arg = NULL, *addr_arg = NULL, *data_fast = NULL,
3787 *cmsg_fast = NULL, *retval = NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003788 struct sock_sendmsg ctx;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003789
3790 if (!PyArg_ParseTuple(args, "O|OiO:sendmsg",
3791 &data_arg, &cmsg_arg, &flags, &addr_arg))
3792 return NULL;
3793
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003794 /* Parse destination address. */
3795 if (addr_arg != NULL && addr_arg != Py_None) {
3796 if (!getsockaddrarg(s, addr_arg, SAS2SA(&addrbuf), &addrlen))
3797 goto finally;
3798 msg.msg_name = &addrbuf;
3799 msg.msg_namelen = addrlen;
3800 }
3801
3802 /* Fill in an iovec for each message part, and save the Py_buffer
3803 structs to release afterwards. */
3804 if ((data_fast = PySequence_Fast(data_arg,
3805 "sendmsg() argument 1 must be an "
3806 "iterable")) == NULL)
3807 goto finally;
3808 ndataparts = PySequence_Fast_GET_SIZE(data_fast);
3809 if (ndataparts > INT_MAX) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003810 PyErr_SetString(PyExc_OSError, "sendmsg() argument 1 is too long");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003811 goto finally;
3812 }
3813 msg.msg_iovlen = ndataparts;
3814 if (ndataparts > 0 &&
3815 ((msg.msg_iov = iovs = PyMem_New(struct iovec, ndataparts)) == NULL ||
3816 (databufs = PyMem_New(Py_buffer, ndataparts)) == NULL)) {
3817 PyErr_NoMemory();
3818 goto finally;
3819 }
3820 for (; ndatabufs < ndataparts; ndatabufs++) {
3821 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(data_fast, ndatabufs),
3822 "y*;sendmsg() argument 1 must be an iterable of "
Serhiy Storchakab757c832014-12-05 22:25:22 +02003823 "bytes-like objects",
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003824 &databufs[ndatabufs]))
3825 goto finally;
3826 iovs[ndatabufs].iov_base = databufs[ndatabufs].buf;
3827 iovs[ndatabufs].iov_len = databufs[ndatabufs].len;
3828 }
3829
3830 if (cmsg_arg == NULL)
3831 ncmsgs = 0;
3832 else {
3833 if ((cmsg_fast = PySequence_Fast(cmsg_arg,
3834 "sendmsg() argument 2 must be an "
3835 "iterable")) == NULL)
3836 goto finally;
3837 ncmsgs = PySequence_Fast_GET_SIZE(cmsg_fast);
3838 }
3839
3840#ifndef CMSG_SPACE
3841 if (ncmsgs > 1) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003842 PyErr_SetString(PyExc_OSError,
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003843 "sending multiple control messages is not supported "
3844 "on this system");
3845 goto finally;
3846 }
3847#endif
3848 /* Save level, type and Py_buffer for each control message,
3849 and calculate total size. */
3850 if (ncmsgs > 0 && (cmsgs = PyMem_New(struct cmsginfo, ncmsgs)) == NULL) {
3851 PyErr_NoMemory();
3852 goto finally;
3853 }
3854 controllen = controllen_last = 0;
3855 while (ncmsgbufs < ncmsgs) {
3856 size_t bufsize, space;
3857
3858 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(cmsg_fast, ncmsgbufs),
3859 "(iiy*):[sendmsg() ancillary data items]",
3860 &cmsgs[ncmsgbufs].level,
3861 &cmsgs[ncmsgbufs].type,
3862 &cmsgs[ncmsgbufs].data))
3863 goto finally;
3864 bufsize = cmsgs[ncmsgbufs++].data.len;
3865
3866#ifdef CMSG_SPACE
3867 if (!get_CMSG_SPACE(bufsize, &space)) {
3868#else
3869 if (!get_CMSG_LEN(bufsize, &space)) {
3870#endif
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003871 PyErr_SetString(PyExc_OSError, "ancillary data item too large");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003872 goto finally;
3873 }
3874 controllen += space;
3875 if (controllen > SOCKLEN_T_LIMIT || controllen < controllen_last) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003876 PyErr_SetString(PyExc_OSError, "too much ancillary data");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003877 goto finally;
3878 }
3879 controllen_last = controllen;
3880 }
3881
3882 /* Construct ancillary data block from control message info. */
3883 if (ncmsgbufs > 0) {
3884 struct cmsghdr *cmsgh = NULL;
3885
3886 if ((msg.msg_control = controlbuf =
3887 PyMem_Malloc(controllen)) == NULL) {
3888 PyErr_NoMemory();
3889 goto finally;
3890 }
3891 msg.msg_controllen = controllen;
3892
3893 /* Need to zero out the buffer as a workaround for glibc's
3894 CMSG_NXTHDR() implementation. After getting the pointer to
3895 the next header, it checks its (uninitialized) cmsg_len
3896 member to see if the "message" fits in the buffer, and
3897 returns NULL if it doesn't. Zero-filling the buffer
Terry Jan Reedy0f847642013-03-11 18:34:00 -04003898 ensures that this doesn't happen. */
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003899 memset(controlbuf, 0, controllen);
3900
3901 for (i = 0; i < ncmsgbufs; i++) {
3902 size_t msg_len, data_len = cmsgs[i].data.len;
3903 int enough_space = 0;
3904
3905 cmsgh = (i == 0) ? CMSG_FIRSTHDR(&msg) : CMSG_NXTHDR(&msg, cmsgh);
3906 if (cmsgh == NULL) {
3907 PyErr_Format(PyExc_RuntimeError,
3908 "unexpected NULL result from %s()",
3909 (i == 0) ? "CMSG_FIRSTHDR" : "CMSG_NXTHDR");
3910 goto finally;
3911 }
3912 if (!get_CMSG_LEN(data_len, &msg_len)) {
3913 PyErr_SetString(PyExc_RuntimeError,
3914 "item size out of range for CMSG_LEN()");
3915 goto finally;
3916 }
3917 if (cmsg_min_space(&msg, cmsgh, msg_len)) {
3918 size_t space;
3919
3920 cmsgh->cmsg_len = msg_len;
3921 if (get_cmsg_data_space(&msg, cmsgh, &space))
3922 enough_space = (space >= data_len);
3923 }
3924 if (!enough_space) {
3925 PyErr_SetString(PyExc_RuntimeError,
3926 "ancillary data does not fit in calculated "
3927 "space");
3928 goto finally;
3929 }
3930 cmsgh->cmsg_level = cmsgs[i].level;
3931 cmsgh->cmsg_type = cmsgs[i].type;
3932 memcpy(CMSG_DATA(cmsgh), cmsgs[i].data.buf, data_len);
3933 }
3934 }
3935
3936 /* Make the system call. */
3937 if (!IS_SELECTABLE(s)) {
3938 select_error();
3939 goto finally;
3940 }
3941
Victor Stinner31bf2d52015-04-01 21:57:09 +02003942 ctx.msg = &msg;
3943 ctx.flags = flags;
3944 if (sock_call(s, 1, sock_sendmsg_impl, &ctx) < 0)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003945 goto finally;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003946
3947 retval = PyLong_FromSsize_t(ctx.result);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003948
3949finally:
3950 PyMem_Free(controlbuf);
3951 for (i = 0; i < ncmsgbufs; i++)
3952 PyBuffer_Release(&cmsgs[i].data);
3953 PyMem_Free(cmsgs);
3954 Py_XDECREF(cmsg_fast);
3955 for (i = 0; i < ndatabufs; i++)
3956 PyBuffer_Release(&databufs[i]);
3957 PyMem_Free(databufs);
3958 PyMem_Free(iovs);
3959 Py_XDECREF(data_fast);
3960 return retval;
3961}
3962
3963PyDoc_STRVAR(sendmsg_doc,
3964"sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\
3965\n\
3966Send normal and ancillary data to the socket, gathering the\n\
3967non-ancillary data from a series of buffers and concatenating it into\n\
3968a single message. The buffers argument specifies the non-ancillary\n\
Serhiy Storchakab757c832014-12-05 22:25:22 +02003969data as an iterable of bytes-like objects (e.g. bytes objects).\n\
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003970The ancdata argument specifies the ancillary data (control messages)\n\
3971as an iterable of zero or more tuples (cmsg_level, cmsg_type,\n\
3972cmsg_data), where cmsg_level and cmsg_type are integers specifying the\n\
3973protocol level and protocol-specific type respectively, and cmsg_data\n\
Serhiy Storchakab757c832014-12-05 22:25:22 +02003974is a bytes-like object holding the associated data. The flags\n\
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003975argument defaults to 0 and has the same meaning as for send(). If\n\
3976address is supplied and not None, it sets a destination address for\n\
3977the message. The return value is the number of bytes of non-ancillary\n\
3978data sent.");
3979#endif /* CMSG_LEN */
3980
3981
Guido van Rossum30a685f1991-06-27 15:51:29 +00003982/* s.shutdown(how) method */
3983
Guido van Rossum73624e91994-10-10 17:59:00 +00003984static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003985sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003986{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003987 int how;
3988 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00003989
Serhiy Storchaka78980432013-01-15 01:12:17 +02003990 how = _PyLong_AsInt(arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003991 if (how == -1 && PyErr_Occurred())
3992 return NULL;
3993 Py_BEGIN_ALLOW_THREADS
3994 res = shutdown(s->sock_fd, how);
3995 Py_END_ALLOW_THREADS
3996 if (res < 0)
3997 return s->errorhandler();
3998 Py_INCREF(Py_None);
3999 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004000}
4001
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004002PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004003"shutdown(flag)\n\
4004\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00004005Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
4006of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004007
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00004008#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Christian Heimesfaf2f632008-01-06 16:59:19 +00004009static PyObject*
4010sock_ioctl(PySocketSockObject *s, PyObject *arg)
4011{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004012 unsigned long cmd = SIO_RCVALL;
4013 PyObject *argO;
4014 DWORD recv;
Christian Heimesfaf2f632008-01-06 16:59:19 +00004015
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004016 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
4017 return NULL;
Christian Heimesfaf2f632008-01-06 16:59:19 +00004018
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004019 switch (cmd) {
4020 case SIO_RCVALL: {
4021 unsigned int option = RCVALL_ON;
4022 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
4023 return NULL;
4024 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
4025 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4026 return set_error();
4027 }
4028 return PyLong_FromUnsignedLong(recv); }
4029 case SIO_KEEPALIVE_VALS: {
4030 struct tcp_keepalive ka;
4031 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
4032 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
4033 return NULL;
4034 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
4035 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4036 return set_error();
4037 }
4038 return PyLong_FromUnsignedLong(recv); }
4039 default:
4040 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
4041 return NULL;
4042 }
Christian Heimesfaf2f632008-01-06 16:59:19 +00004043}
4044PyDoc_STRVAR(sock_ioctl_doc,
4045"ioctl(cmd, option) -> long\n\
4046\n\
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00004047Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
4048SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
4049SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).");
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004050#endif
4051
4052#if defined(MS_WINDOWS)
4053static PyObject*
4054sock_share(PySocketSockObject *s, PyObject *arg)
4055{
4056 WSAPROTOCOL_INFO info;
4057 DWORD processId;
4058 int result;
4059
4060 if (!PyArg_ParseTuple(arg, "I", &processId))
4061 return NULL;
4062
4063 Py_BEGIN_ALLOW_THREADS
4064 result = WSADuplicateSocket(s->sock_fd, processId, &info);
4065 Py_END_ALLOW_THREADS
4066 if (result == SOCKET_ERROR)
4067 return set_error();
4068 return PyBytes_FromStringAndSize((const char*)&info, sizeof(info));
4069}
4070PyDoc_STRVAR(sock_share_doc,
4071"share(process_id) -> bytes\n\
4072\n\
4073Share the socket with another process. The target process id\n\
4074must be provided and the resulting bytes object passed to the target\n\
4075process. There the shared socket can be instantiated by calling\n\
4076socket.fromshare().");
4077
Christian Heimesfaf2f632008-01-06 16:59:19 +00004078
4079#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00004080
4081/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004082
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004083static PyMethodDef sock_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004084 {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
4085 accept_doc},
4086 {"bind", (PyCFunction)sock_bind, METH_O,
4087 bind_doc},
4088 {"close", (PyCFunction)sock_close, METH_NOARGS,
4089 close_doc},
4090 {"connect", (PyCFunction)sock_connect, METH_O,
4091 connect_doc},
4092 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
4093 connect_ex_doc},
Antoine Pitrou6e451df2010-08-09 20:39:54 +00004094 {"detach", (PyCFunction)sock_detach, METH_NOARGS,
4095 detach_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004096 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
4097 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00004098#ifdef HAVE_GETPEERNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004099 {"getpeername", (PyCFunction)sock_getpeername,
4100 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00004101#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004102 {"getsockname", (PyCFunction)sock_getsockname,
4103 METH_NOARGS, getsockname_doc},
4104 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
4105 getsockopt_doc},
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00004106#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004107 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
4108 sock_ioctl_doc},
Christian Heimesfaf2f632008-01-06 16:59:19 +00004109#endif
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004110#if defined(MS_WINDOWS)
4111 {"share", (PyCFunction)sock_share, METH_VARARGS,
4112 sock_share_doc},
4113#endif
Charles-François Natali644b8f52014-05-22 19:45:39 +01004114 {"listen", (PyCFunction)sock_listen, METH_VARARGS,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004115 listen_doc},
4116 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
4117 recv_doc},
4118 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
4119 recv_into_doc},
4120 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
4121 recvfrom_doc},
4122 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
4123 recvfrom_into_doc},
4124 {"send", (PyCFunction)sock_send, METH_VARARGS,
4125 send_doc},
4126 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
4127 sendall_doc},
4128 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
4129 sendto_doc},
4130 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
4131 setblocking_doc},
4132 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
4133 settimeout_doc},
4134 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
4135 gettimeout_doc},
4136 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
4137 setsockopt_doc},
4138 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
4139 shutdown_doc},
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004140#ifdef CMSG_LEN
4141 {"recvmsg", (PyCFunction)sock_recvmsg, METH_VARARGS,
4142 recvmsg_doc},
4143 {"recvmsg_into", (PyCFunction)sock_recvmsg_into, METH_VARARGS,
4144 recvmsg_into_doc,},
4145 {"sendmsg", (PyCFunction)sock_sendmsg, METH_VARARGS,
4146 sendmsg_doc},
4147#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004148 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004149};
4150
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004151/* SockObject members */
4152static PyMemberDef sock_memberlist[] = {
4153 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
4154 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
4155 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004156 {0},
4157};
Guido van Rossum30a685f1991-06-27 15:51:29 +00004158
Victor Stinner71694d52015-03-28 01:18:54 +01004159static PyGetSetDef sock_getsetlist[] = {
4160 {"timeout", (getter)sock_gettimeout, NULL, PyDoc_STR("the socket timeout")},
4161 {NULL} /* sentinel */
4162};
4163
Guido van Rossum73624e91994-10-10 17:59:00 +00004164/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00004165 First close the file description. */
4166
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004167static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004168sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004169{
Victor Stinner524714e2016-07-22 17:43:59 +02004170 if (s->sock_fd != INVALID_SOCKET) {
Antoine Pitroue033e062010-10-29 10:38:18 +00004171 PyObject *exc, *val, *tb;
4172 Py_ssize_t old_refcount = Py_REFCNT(s);
4173 ++Py_REFCNT(s);
4174 PyErr_Fetch(&exc, &val, &tb);
4175 if (PyErr_WarnFormat(PyExc_ResourceWarning, 1,
4176 "unclosed %R", s))
4177 /* Spurious errors can appear at shutdown */
4178 if (PyErr_ExceptionMatches(PyExc_Warning))
4179 PyErr_WriteUnraisable((PyObject *) s);
4180 PyErr_Restore(exc, val, tb);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004181 (void) SOCKETCLOSE(s->sock_fd);
Antoine Pitroue033e062010-10-29 10:38:18 +00004182 Py_REFCNT(s) = old_refcount;
4183 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004184 Py_TYPE(s)->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004185}
4186
Guido van Rossum30a685f1991-06-27 15:51:29 +00004187
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004188static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004189sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004190{
Victor Stinnere254e532014-07-26 14:36:55 +02004191 long sock_fd;
4192 /* On Windows, this test is needed because SOCKET_T is unsigned */
4193 if (s->sock_fd == INVALID_SOCKET) {
4194 sock_fd = -1;
4195 }
Fred Drakea04eaad2000-06-30 02:46:07 +00004196#if SIZEOF_SOCKET_T > SIZEOF_LONG
Victor Stinnere254e532014-07-26 14:36:55 +02004197 else if (s->sock_fd > LONG_MAX) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004198 /* this can occur on Win64, and actually there is a special
4199 ugly printf formatter for decimal pointer length integer
4200 printing, only bother if necessary*/
4201 PyErr_SetString(PyExc_OverflowError,
4202 "no printf formatter to display "
4203 "the socket descriptor in decimal");
4204 return NULL;
4205 }
Fred Drakea04eaad2000-06-30 02:46:07 +00004206#endif
Victor Stinnere254e532014-07-26 14:36:55 +02004207 else
4208 sock_fd = (long)s->sock_fd;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004209 return PyUnicode_FromFormat(
4210 "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
Victor Stinnere254e532014-07-26 14:36:55 +02004211 sock_fd, s->sock_family,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004212 s->sock_type,
4213 s->sock_proto);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004214}
4215
4216
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004217/* Create a new, uninitialized socket object. */
4218
4219static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004220sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004221{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004222 PyObject *new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004223
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004224 new = type->tp_alloc(type, 0);
4225 if (new != NULL) {
Victor Stinner524714e2016-07-22 17:43:59 +02004226 ((PySocketSockObject *)new)->sock_fd = INVALID_SOCKET;
Victor Stinner9001d802015-04-06 23:06:01 +02004227 ((PySocketSockObject *)new)->sock_timeout = _PyTime_FromSeconds(-1);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004228 ((PySocketSockObject *)new)->errorhandler = &set_error;
4229 }
4230 return new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004231}
4232
4233
4234/* Initialize a new socket object. */
4235
Victor Stinnerdaf45552013-08-28 00:53:59 +02004236#ifdef SOCK_CLOEXEC
4237/* socket() and socketpair() fail with EINVAL on Linux kernel older
4238 * than 2.6.27 if SOCK_CLOEXEC flag is set in the socket type. */
4239static int sock_cloexec_works = -1;
4240#endif
4241
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004242/*ARGSUSED*/
4243static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00004244sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004245{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004246 PySocketSockObject *s = (PySocketSockObject *)self;
4247 PyObject *fdobj = NULL;
4248 SOCKET_T fd = INVALID_SOCKET;
4249 int family = AF_INET, type = SOCK_STREAM, proto = 0;
4250 static char *keywords[] = {"family", "type", "proto", "fileno", 0};
Victor Stinnerdaf45552013-08-28 00:53:59 +02004251#ifndef MS_WINDOWS
4252#ifdef SOCK_CLOEXEC
4253 int *atomic_flag_works = &sock_cloexec_works;
4254#else
4255 int *atomic_flag_works = NULL;
4256#endif
4257#endif
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004258
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004259 if (!PyArg_ParseTupleAndKeywords(args, kwds,
4260 "|iiiO:socket", keywords,
4261 &family, &type, &proto, &fdobj))
4262 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004263
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004264 if (fdobj != NULL && fdobj != Py_None) {
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004265#ifdef MS_WINDOWS
4266 /* recreate a socket that was duplicated */
4267 if (PyBytes_Check(fdobj)) {
4268 WSAPROTOCOL_INFO info;
4269 if (PyBytes_GET_SIZE(fdobj) != sizeof(info)) {
4270 PyErr_Format(PyExc_ValueError,
4271 "socket descriptor string has wrong size, "
4272 "should be %zu bytes.", sizeof(info));
4273 return -1;
4274 }
4275 memcpy(&info, PyBytes_AS_STRING(fdobj), sizeof(info));
4276 Py_BEGIN_ALLOW_THREADS
4277 fd = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
4278 FROM_PROTOCOL_INFO, &info, 0, WSA_FLAG_OVERLAPPED);
4279 Py_END_ALLOW_THREADS
4280 if (fd == INVALID_SOCKET) {
4281 set_error();
4282 return -1;
4283 }
4284 family = info.iAddressFamily;
4285 type = info.iSocketType;
4286 proto = info.iProtocol;
4287 }
4288 else
4289#endif
4290 {
4291 fd = PyLong_AsSocket_t(fdobj);
4292 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
4293 return -1;
4294 if (fd == INVALID_SOCKET) {
4295 PyErr_SetString(PyExc_ValueError,
4296 "can't use invalid socket value");
4297 return -1;
4298 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004299 }
4300 }
4301 else {
Victor Stinnerdaf45552013-08-28 00:53:59 +02004302#ifdef MS_WINDOWS
4303 /* Windows implementation */
4304#ifndef WSA_FLAG_NO_HANDLE_INHERIT
4305#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
4306#endif
4307
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004308 Py_BEGIN_ALLOW_THREADS
Victor Stinnerdaf45552013-08-28 00:53:59 +02004309 if (support_wsa_no_inherit) {
4310 fd = WSASocket(family, type, proto,
4311 NULL, 0,
4312 WSA_FLAG_OVERLAPPED | WSA_FLAG_NO_HANDLE_INHERIT);
4313 if (fd == INVALID_SOCKET) {
4314 /* Windows 7 or Windows 2008 R2 without SP1 or the hotfix */
4315 support_wsa_no_inherit = 0;
4316 fd = socket(family, type, proto);
4317 }
4318 }
4319 else {
4320 fd = socket(family, type, proto);
4321 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004322 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00004323
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004324 if (fd == INVALID_SOCKET) {
4325 set_error();
4326 return -1;
4327 }
Victor Stinnerdaf45552013-08-28 00:53:59 +02004328
4329 if (!support_wsa_no_inherit) {
4330 if (!SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0)) {
4331 closesocket(fd);
4332 PyErr_SetFromWindowsErr(0);
4333 return -1;
4334 }
4335 }
4336#else
4337 /* UNIX */
4338 Py_BEGIN_ALLOW_THREADS
4339#ifdef SOCK_CLOEXEC
4340 if (sock_cloexec_works != 0) {
4341 fd = socket(family, type | SOCK_CLOEXEC, proto);
4342 if (sock_cloexec_works == -1) {
4343 if (fd >= 0) {
4344 sock_cloexec_works = 1;
4345 }
4346 else if (errno == EINVAL) {
4347 /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
4348 sock_cloexec_works = 0;
4349 fd = socket(family, type, proto);
4350 }
4351 }
4352 }
4353 else
4354#endif
4355 {
4356 fd = socket(family, type, proto);
4357 }
4358 Py_END_ALLOW_THREADS
4359
4360 if (fd == INVALID_SOCKET) {
4361 set_error();
4362 return -1;
4363 }
4364
4365 if (_Py_set_inheritable(fd, 0, atomic_flag_works) < 0) {
4366 SOCKETCLOSE(fd);
4367 return -1;
4368 }
4369#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004370 }
4371 init_sockobject(s, fd, family, type, proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004372
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004373 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004374
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004375}
4376
4377
Guido van Rossumb6775db1994-08-01 11:34:53 +00004378/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00004379
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004380static PyTypeObject sock_type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004381 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
4382 "_socket.socket", /* tp_name */
4383 sizeof(PySocketSockObject), /* tp_basicsize */
4384 0, /* tp_itemsize */
4385 (destructor)sock_dealloc, /* tp_dealloc */
4386 0, /* tp_print */
4387 0, /* tp_getattr */
4388 0, /* tp_setattr */
4389 0, /* tp_reserved */
4390 (reprfunc)sock_repr, /* tp_repr */
4391 0, /* tp_as_number */
4392 0, /* tp_as_sequence */
4393 0, /* tp_as_mapping */
4394 0, /* tp_hash */
4395 0, /* tp_call */
4396 0, /* tp_str */
4397 PyObject_GenericGetAttr, /* tp_getattro */
4398 0, /* tp_setattro */
4399 0, /* tp_as_buffer */
4400 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
4401 sock_doc, /* tp_doc */
4402 0, /* tp_traverse */
4403 0, /* tp_clear */
4404 0, /* tp_richcompare */
4405 0, /* tp_weaklistoffset */
4406 0, /* tp_iter */
4407 0, /* tp_iternext */
4408 sock_methods, /* tp_methods */
4409 sock_memberlist, /* tp_members */
Victor Stinner71694d52015-03-28 01:18:54 +01004410 sock_getsetlist, /* tp_getset */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004411 0, /* tp_base */
4412 0, /* tp_dict */
4413 0, /* tp_descr_get */
4414 0, /* tp_descr_set */
4415 0, /* tp_dictoffset */
4416 sock_initobj, /* tp_init */
4417 PyType_GenericAlloc, /* tp_alloc */
4418 sock_new, /* tp_new */
4419 PyObject_Del, /* tp_free */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004420};
4421
Guido van Rossum30a685f1991-06-27 15:51:29 +00004422
Guido van Rossum81194471991-07-27 21:42:02 +00004423/* Python interface to gethostname(). */
4424
4425/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004426static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00004427socket_gethostname(PyObject *self, PyObject *unused)
Guido van Rossum81194471991-07-27 21:42:02 +00004428{
Martin v. Löwis72f48422010-10-29 18:20:08 +00004429#ifdef MS_WINDOWS
4430 /* Don't use winsock's gethostname, as this returns the ANSI
4431 version of the hostname, whereas we need a Unicode string.
4432 Otherwise, gethostname apparently also returns the DNS name. */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00004433 wchar_t buf[MAX_COMPUTERNAME_LENGTH + 1];
Victor Stinner63941882011-09-29 00:42:28 +02004434 DWORD size = Py_ARRAY_LENGTH(buf);
Victor Stinner74168972011-11-17 01:11:36 +01004435 wchar_t *name;
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00004436 PyObject *result;
Victor Stinner74168972011-11-17 01:11:36 +01004437
4438 if (GetComputerNameExW(ComputerNamePhysicalDnsHostname, buf, &size))
Victor Stinner9d3b93b2011-11-22 02:27:30 +01004439 return PyUnicode_FromWideChar(buf, size);
Victor Stinner74168972011-11-17 01:11:36 +01004440
4441 if (GetLastError() != ERROR_MORE_DATA)
4442 return PyErr_SetFromWindowsErr(0);
4443
4444 if (size == 0)
4445 return PyUnicode_New(0, 0);
4446
4447 /* MSDN says ERROR_MORE_DATA may occur because DNS allows longer
4448 names */
Serhiy Storchaka1a1ff292015-02-16 13:28:22 +02004449 name = PyMem_New(wchar_t, size);
4450 if (!name) {
4451 PyErr_NoMemory();
Victor Stinner74168972011-11-17 01:11:36 +01004452 return NULL;
Serhiy Storchaka1a1ff292015-02-16 13:28:22 +02004453 }
Victor Stinner74168972011-11-17 01:11:36 +01004454 if (!GetComputerNameExW(ComputerNamePhysicalDnsHostname,
4455 name,
4456 &size))
4457 {
4458 PyMem_Free(name);
4459 return PyErr_SetFromWindowsErr(0);
Martin v. Löwis72f48422010-10-29 18:20:08 +00004460 }
Victor Stinner74168972011-11-17 01:11:36 +01004461
4462 result = PyUnicode_FromWideChar(name, size);
4463 PyMem_Free(name);
4464 return result;
Martin v. Löwis72f48422010-10-29 18:20:08 +00004465#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004466 char buf[1024];
4467 int res;
4468 Py_BEGIN_ALLOW_THREADS
4469 res = gethostname(buf, (int) sizeof buf - 1);
4470 Py_END_ALLOW_THREADS
4471 if (res < 0)
4472 return set_error();
4473 buf[sizeof buf - 1] = '\0';
Victor Stinnera534fc42013-06-03 22:07:27 +02004474 return PyUnicode_DecodeFSDefault(buf);
Martin v. Löwis72f48422010-10-29 18:20:08 +00004475#endif
Guido van Rossum81194471991-07-27 21:42:02 +00004476}
Guido van Rossumff4949e1992-08-05 19:58:53 +00004477
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004478PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004479"gethostname() -> string\n\
4480\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004481Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004482
Antoine Pitrou061cfb52011-02-28 22:25:22 +00004483#ifdef HAVE_SETHOSTNAME
4484PyDoc_STRVAR(sethostname_doc,
4485"sethostname(name)\n\n\
4486Sets the hostname to name.");
4487
4488static PyObject *
4489socket_sethostname(PyObject *self, PyObject *args)
4490{
4491 PyObject *hnobj;
4492 Py_buffer buf;
4493 int res, flag = 0;
4494
Christian Heimesd2774c72013-06-19 02:06:29 +02004495#ifdef _AIX
4496/* issue #18259, not declared in any useful header file */
4497extern int sethostname(const char *, size_t);
4498#endif
4499
Antoine Pitrou061cfb52011-02-28 22:25:22 +00004500 if (!PyArg_ParseTuple(args, "S:sethostname", &hnobj)) {
4501 PyErr_Clear();
4502 if (!PyArg_ParseTuple(args, "O&:sethostname",
4503 PyUnicode_FSConverter, &hnobj))
4504 return NULL;
4505 flag = 1;
4506 }
4507 res = PyObject_GetBuffer(hnobj, &buf, PyBUF_SIMPLE);
4508 if (!res) {
4509 res = sethostname(buf.buf, buf.len);
4510 PyBuffer_Release(&buf);
4511 }
4512 if (flag)
4513 Py_DECREF(hnobj);
4514 if (res)
4515 return set_error();
4516 Py_RETURN_NONE;
4517}
4518#endif
Guido van Rossumff4949e1992-08-05 19:58:53 +00004519
Guido van Rossum30a685f1991-06-27 15:51:29 +00004520/* Python interface to gethostbyname(name). */
4521
4522/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004523static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004524socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00004525{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004526 char *name;
4527 sock_addr_t addrbuf;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004528 PyObject *ret = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004529
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004530 if (!PyArg_ParseTuple(args, "et:gethostbyname", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004531 return NULL;
4532 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004533 goto finally;
4534 ret = makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
4535finally:
4536 PyMem_Free(name);
4537 return ret;
Guido van Rossum30a685f1991-06-27 15:51:29 +00004538}
4539
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004540PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004541"gethostbyname(host) -> address\n\
4542\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004543Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004544
4545
Victor Stinner72400302016-01-28 15:41:01 +01004546static PyObject*
4547sock_decode_hostname(const char *name)
4548{
4549#ifdef MS_WINDOWS
4550 /* Issue #26227: gethostbyaddr() returns a string encoded
4551 * to the ANSI code page */
4552 return PyUnicode_DecodeFSDefault(name);
4553#else
4554 /* Decode from UTF-8 */
4555 return PyUnicode_FromString(name);
4556#endif
4557}
4558
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004559/* Convenience function common to gethostbyname_ex and gethostbyaddr */
4560
4561static PyObject *
Victor Stinner1a62a682014-08-17 19:33:28 +02004562gethost_common(struct hostent *h, struct sockaddr *addr, size_t alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004563{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004564 char **pch;
4565 PyObject *rtn_tuple = (PyObject *)NULL;
4566 PyObject *name_list = (PyObject *)NULL;
4567 PyObject *addr_list = (PyObject *)NULL;
4568 PyObject *tmp;
Victor Stinner72400302016-01-28 15:41:01 +01004569 PyObject *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004571 if (h == NULL) {
4572 /* Let's get real error message to return */
4573 set_herror(h_errno);
4574 return NULL;
4575 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004576
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004577 if (h->h_addrtype != af) {
4578 /* Let's get real error message to return */
Victor Stinner1f33f2b2011-12-17 04:45:09 +01004579 errno = EAFNOSUPPORT;
4580 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004581 return NULL;
4582 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004583
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004584 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00004585
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004586 case AF_INET:
4587 if (alen < sizeof(struct sockaddr_in))
4588 return NULL;
4589 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004590
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004591#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004592 case AF_INET6:
4593 if (alen < sizeof(struct sockaddr_in6))
4594 return NULL;
4595 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004596#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00004597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004598 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004600 if ((name_list = PyList_New(0)) == NULL)
4601 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004602
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004603 if ((addr_list = PyList_New(0)) == NULL)
4604 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004606 /* SF #1511317: h_aliases can be NULL */
4607 if (h->h_aliases) {
4608 for (pch = h->h_aliases; *pch != NULL; pch++) {
4609 int status;
4610 tmp = PyUnicode_FromString(*pch);
4611 if (tmp == NULL)
4612 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004613
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004614 status = PyList_Append(name_list, tmp);
4615 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004616
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004617 if (status)
4618 goto err;
4619 }
4620 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004621
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004622 for (pch = h->h_addr_list; *pch != NULL; pch++) {
4623 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004624
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004625 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00004626
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004627 case AF_INET:
4628 {
4629 struct sockaddr_in sin;
4630 memset(&sin, 0, sizeof(sin));
4631 sin.sin_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004632#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004633 sin.sin_len = sizeof(sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004634#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004635 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
4636 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00004637
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004638 if (pch == h->h_addr_list && alen >= sizeof(sin))
4639 memcpy((char *) addr, &sin, sizeof(sin));
4640 break;
4641 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004642
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004643#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004644 case AF_INET6:
4645 {
4646 struct sockaddr_in6 sin6;
4647 memset(&sin6, 0, sizeof(sin6));
4648 sin6.sin6_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004649#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004650 sin6.sin6_len = sizeof(sin6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004651#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004652 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
4653 tmp = makeipaddr((struct sockaddr *)&sin6,
4654 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00004655
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004656 if (pch == h->h_addr_list && alen >= sizeof(sin6))
4657 memcpy((char *) addr, &sin6, sizeof(sin6));
4658 break;
4659 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004660#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00004661
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004662 default: /* can't happen */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004663 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004664 "unsupported address family");
4665 return NULL;
4666 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004667
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004668 if (tmp == NULL)
4669 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004670
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004671 status = PyList_Append(addr_list, tmp);
4672 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004673
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004674 if (status)
4675 goto err;
4676 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004677
Victor Stinner72400302016-01-28 15:41:01 +01004678 name = sock_decode_hostname(h->h_name);
4679 if (name == NULL)
4680 goto err;
4681 rtn_tuple = Py_BuildValue("NOO", name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004682
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004683 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004684 Py_XDECREF(name_list);
4685 Py_XDECREF(addr_list);
4686 return rtn_tuple;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004687}
4688
4689
4690/* Python interface to gethostbyname_ex(name). */
4691
4692/*ARGSUSED*/
4693static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004694socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004695{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004696 char *name;
4697 struct hostent *h;
Charles-François Natali8b759652011-12-23 16:44:51 +01004698 sock_addr_t addr;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004699 struct sockaddr *sa;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004700 PyObject *ret = NULL;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004701#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004702 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004703#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004704 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004705#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004706 char buf[16384];
4707 int buf_len = (sizeof buf) - 1;
4708 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004709#endif
Ross Lagerwall8c159762012-03-06 21:36:18 +02004710#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004711 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004712#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004713#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004714
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004715 if (!PyArg_ParseTuple(args, "et:gethostbyname_ex", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004716 return NULL;
Charles-François Natali8b759652011-12-23 16:44:51 +01004717 if (setipaddr(name, SAS2SA(&addr), sizeof(addr), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004718 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004719 Py_BEGIN_ALLOW_THREADS
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004720#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004721#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Ross Lagerwall8c159762012-03-06 21:36:18 +02004722 gethostbyname_r(name, &hp_allocated, buf, buf_len,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004723 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004724#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004725 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004726#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004727 memset((void *) &data, '\0', sizeof(data));
4728 result = gethostbyname_r(name, &hp_allocated, &data);
4729 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004730#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004731#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00004732#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004733 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004734#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004735 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004736#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004737 Py_END_ALLOW_THREADS
4738 /* Some C libraries would require addr.__ss_family instead of
4739 addr.ss_family.
4740 Therefore, we cast the sockaddr_storage into sockaddr to
4741 access sa_family. */
Charles-François Natali8b759652011-12-23 16:44:51 +01004742 sa = SAS2SA(&addr);
4743 ret = gethost_common(h, SAS2SA(&addr), sizeof(addr),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004744 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004745#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004746 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00004747#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004748finally:
4749 PyMem_Free(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004750 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004751}
4752
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004753PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004754"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
4755\n\
4756Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004757for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004758
4759
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004760/* Python interface to gethostbyaddr(IP). */
4761
4762/*ARGSUSED*/
4763static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004764socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004765{
Charles-François Natali8b759652011-12-23 16:44:51 +01004766 sock_addr_t addr;
4767 struct sockaddr *sa = SAS2SA(&addr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004768 char *ip_num;
4769 struct hostent *h;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004770 PyObject *ret = NULL;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004771#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004772 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004773#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004774 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004775#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004776 /* glibcs up to 2.10 assume that the buf argument to
4777 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
4778 does not ensure. The attribute below instructs the compiler
4779 to maintain this alignment. */
4780 char buf[16384] Py_ALIGNED(8);
4781 int buf_len = (sizeof buf) - 1;
4782 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004783#endif
Ross Lagerwall8c159762012-03-06 21:36:18 +02004784#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004785 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004786#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004787#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004788 char *ap;
4789 int al;
4790 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004791
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004792 if (!PyArg_ParseTuple(args, "et:gethostbyaddr", "idna", &ip_num))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004793 return NULL;
4794 af = AF_UNSPEC;
4795 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004796 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004797 af = sa->sa_family;
4798 ap = NULL;
Brett Cannonb94767f2011-02-22 20:15:44 +00004799 /* al = 0; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004800 switch (af) {
4801 case AF_INET:
4802 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
4803 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
4804 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004805#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004806 case AF_INET6:
4807 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
4808 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
4809 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004810#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004811 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004812 PyErr_SetString(PyExc_OSError, "unsupported address family");
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004813 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004814 }
4815 Py_BEGIN_ALLOW_THREADS
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004816#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004817#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Ross Lagerwall8c159762012-03-06 21:36:18 +02004818 gethostbyaddr_r(ap, al, af,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004819 &hp_allocated, buf, buf_len,
4820 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004821#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004822 h = gethostbyaddr_r(ap, al, af,
4823 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004824#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004825 memset((void *) &data, '\0', sizeof(data));
4826 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
4827 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004828#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004829#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00004830#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004831 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004832#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004833 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004834#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004835 Py_END_ALLOW_THREADS
Charles-François Natali8b759652011-12-23 16:44:51 +01004836 ret = gethost_common(h, SAS2SA(&addr), sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004837#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004838 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004839#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004840finally:
4841 PyMem_Free(ip_num);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004842 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004843}
4844
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004845PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004846"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
4847\n\
4848Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004849for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004850
Guido van Rossum30a685f1991-06-27 15:51:29 +00004851
4852/* Python interface to getservbyname(name).
4853 This only returns the port number, since the other info is already
4854 known or not useful (like the list of aliases). */
4855
4856/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004857static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004858socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00004859{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004860 char *name, *proto=NULL;
4861 struct servent *sp;
4862 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
4863 return NULL;
4864 Py_BEGIN_ALLOW_THREADS
4865 sp = getservbyname(name, proto);
4866 Py_END_ALLOW_THREADS
4867 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004868 PyErr_SetString(PyExc_OSError, "service/proto not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004869 return NULL;
4870 }
4871 return PyLong_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00004872}
4873
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004874PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00004875"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00004876\n\
4877Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00004878The optional protocol name, if given, should be 'tcp' or 'udp',\n\
4879otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004880
Guido van Rossum30a685f1991-06-27 15:51:29 +00004881
Barry Warsaw11b91a02004-06-28 00:50:43 +00004882/* Python interface to getservbyport(port).
4883 This only returns the service name, since the other info is already
4884 known or not useful (like the list of aliases). */
4885
4886/*ARGSUSED*/
4887static PyObject *
4888socket_getservbyport(PyObject *self, PyObject *args)
4889{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004890 int port;
4891 char *proto=NULL;
4892 struct servent *sp;
4893 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
4894 return NULL;
4895 if (port < 0 || port > 0xffff) {
4896 PyErr_SetString(
4897 PyExc_OverflowError,
4898 "getservbyport: port must be 0-65535.");
4899 return NULL;
4900 }
4901 Py_BEGIN_ALLOW_THREADS
4902 sp = getservbyport(htons((short)port), proto);
4903 Py_END_ALLOW_THREADS
4904 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004905 PyErr_SetString(PyExc_OSError, "port/proto not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004906 return NULL;
4907 }
4908 return PyUnicode_FromString(sp->s_name);
Barry Warsaw11b91a02004-06-28 00:50:43 +00004909}
4910
4911PyDoc_STRVAR(getservbyport_doc,
4912"getservbyport(port[, protocolname]) -> string\n\
4913\n\
4914Return the service name from a port number and protocol name.\n\
4915The optional protocol name, if given, should be 'tcp' or 'udp',\n\
4916otherwise any protocol will match.");
4917
Guido van Rossum3901d851996-12-19 16:35:04 +00004918/* Python interface to getprotobyname(name).
4919 This only returns the protocol number, since the other info is
4920 already known or not useful (like the list of aliases). */
4921
4922/*ARGSUSED*/
4923static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004924socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00004925{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004926 char *name;
4927 struct protoent *sp;
4928 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
4929 return NULL;
4930 Py_BEGIN_ALLOW_THREADS
4931 sp = getprotobyname(name);
4932 Py_END_ALLOW_THREADS
4933 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004934 PyErr_SetString(PyExc_OSError, "protocol not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004935 return NULL;
4936 }
4937 return PyLong_FromLong((long) sp->p_proto);
Guido van Rossum3901d851996-12-19 16:35:04 +00004938}
4939
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004940PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004941"getprotobyname(name) -> integer\n\
4942\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004943Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004944
Guido van Rossum3901d851996-12-19 16:35:04 +00004945
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004946#ifndef NO_DUP
4947/* dup() function for socket fds */
4948
4949static PyObject *
4950socket_dup(PyObject *self, PyObject *fdobj)
4951{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004952 SOCKET_T fd, newfd;
4953 PyObject *newfdobj;
Victor Stinnerdaf45552013-08-28 00:53:59 +02004954#ifdef MS_WINDOWS
4955 WSAPROTOCOL_INFO info;
4956#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004957
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004958 fd = PyLong_AsSocket_t(fdobj);
4959 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
4960 return NULL;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004961
Victor Stinnerdaf45552013-08-28 00:53:59 +02004962#ifdef MS_WINDOWS
4963 if (WSADuplicateSocket(fd, GetCurrentProcessId(), &info))
4964 return set_error();
4965
4966 newfd = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
4967 FROM_PROTOCOL_INFO,
4968 &info, 0, WSA_FLAG_OVERLAPPED);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004969 if (newfd == INVALID_SOCKET)
4970 return set_error();
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004971
Victor Stinnerdaf45552013-08-28 00:53:59 +02004972 if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
4973 closesocket(newfd);
4974 PyErr_SetFromWindowsErr(0);
4975 return NULL;
4976 }
4977#else
4978 /* On UNIX, dup can be used to duplicate the file descriptor of a socket */
4979 newfd = _Py_dup(fd);
4980 if (newfd == INVALID_SOCKET)
Victor Stinnere990c6e2013-11-16 00:18:58 +01004981 return NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02004982#endif
4983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004984 newfdobj = PyLong_FromSocket_t(newfd);
4985 if (newfdobj == NULL)
4986 SOCKETCLOSE(newfd);
4987 return newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004988}
4989
4990PyDoc_STRVAR(dup_doc,
4991"dup(integer) -> integer\n\
4992\n\
4993Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
4994sockets; on some platforms os.dup() won't work for socket file descriptors.");
4995#endif
4996
4997
Dave Cole331708b2004-08-09 04:51:41 +00004998#ifdef HAVE_SOCKETPAIR
4999/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00005000 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00005001 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00005002
5003/*ARGSUSED*/
5004static PyObject *
5005socket_socketpair(PyObject *self, PyObject *args)
5006{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005007 PySocketSockObject *s0 = NULL, *s1 = NULL;
5008 SOCKET_T sv[2];
5009 int family, type = SOCK_STREAM, proto = 0;
5010 PyObject *res = NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005011#ifdef SOCK_CLOEXEC
5012 int *atomic_flag_works = &sock_cloexec_works;
5013#else
5014 int *atomic_flag_works = NULL;
5015#endif
5016 int ret;
Dave Cole331708b2004-08-09 04:51:41 +00005017
5018#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005019 family = AF_UNIX;
Dave Cole331708b2004-08-09 04:51:41 +00005020#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005021 family = AF_INET;
Dave Cole331708b2004-08-09 04:51:41 +00005022#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005023 if (!PyArg_ParseTuple(args, "|iii:socketpair",
5024 &family, &type, &proto))
5025 return NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005026
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005027 /* Create a pair of socket fds */
Victor Stinnerdaf45552013-08-28 00:53:59 +02005028 Py_BEGIN_ALLOW_THREADS
5029#ifdef SOCK_CLOEXEC
5030 if (sock_cloexec_works != 0) {
5031 ret = socketpair(family, type | SOCK_CLOEXEC, proto, sv);
5032 if (sock_cloexec_works == -1) {
5033 if (ret >= 0) {
5034 sock_cloexec_works = 1;
5035 }
5036 else if (errno == EINVAL) {
5037 /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
5038 sock_cloexec_works = 0;
5039 ret = socketpair(family, type, proto, sv);
5040 }
5041 }
5042 }
5043 else
5044#endif
5045 {
5046 ret = socketpair(family, type, proto, sv);
5047 }
5048 Py_END_ALLOW_THREADS
5049
5050 if (ret < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005051 return set_error();
Victor Stinnerdaf45552013-08-28 00:53:59 +02005052
5053 if (_Py_set_inheritable(sv[0], 0, atomic_flag_works) < 0)
5054 goto finally;
5055 if (_Py_set_inheritable(sv[1], 0, atomic_flag_works) < 0)
5056 goto finally;
5057
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005058 s0 = new_sockobject(sv[0], family, type, proto);
5059 if (s0 == NULL)
5060 goto finally;
5061 s1 = new_sockobject(sv[1], family, type, proto);
5062 if (s1 == NULL)
5063 goto finally;
5064 res = PyTuple_Pack(2, s0, s1);
Dave Cole331708b2004-08-09 04:51:41 +00005065
5066finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005067 if (res == NULL) {
5068 if (s0 == NULL)
5069 SOCKETCLOSE(sv[0]);
5070 if (s1 == NULL)
5071 SOCKETCLOSE(sv[1]);
5072 }
5073 Py_XDECREF(s0);
5074 Py_XDECREF(s1);
5075 return res;
Dave Cole331708b2004-08-09 04:51:41 +00005076}
5077
5078PyDoc_STRVAR(socketpair_doc,
Victor Stinnerdaf45552013-08-28 00:53:59 +02005079"socketpair([family[, type [, proto]]]) -> (socket object, socket object)\n\
Dave Cole331708b2004-08-09 04:51:41 +00005080\n\
5081Create a pair of socket objects from the sockets returned by the platform\n\
5082socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00005083The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00005084AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00005085
5086#endif /* HAVE_SOCKETPAIR */
5087
5088
Guido van Rossum006bf911996-06-12 04:04:55 +00005089static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005090socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00005091{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005092 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00005093
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005094 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
5095 return NULL;
5096 }
5097 if (x1 < 0) {
5098 PyErr_SetString(PyExc_OverflowError,
5099 "can't convert negative number to unsigned long");
5100 return NULL;
5101 }
5102 x2 = (unsigned int)ntohs((unsigned short)x1);
5103 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00005104}
5105
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005106PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005107"ntohs(integer) -> integer\n\
5108\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005109Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005110
5111
Guido van Rossum006bf911996-06-12 04:04:55 +00005112static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005113socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00005114{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005115 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00005116
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005117 if (PyLong_Check(arg)) {
5118 x = PyLong_AsUnsignedLong(arg);
5119 if (x == (unsigned long) -1 && PyErr_Occurred())
5120 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005121#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005122 {
5123 unsigned long y;
5124 /* only want the trailing 32 bits */
5125 y = x & 0xFFFFFFFFUL;
5126 if (y ^ x)
5127 return PyErr_Format(PyExc_OverflowError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005128 "int larger than 32 bits");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005129 x = y;
5130 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005131#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005132 }
5133 else
5134 return PyErr_Format(PyExc_TypeError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005135 "expected int, %s found",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005136 Py_TYPE(arg)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005137 return PyLong_FromUnsignedLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00005138}
5139
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005140PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005141"ntohl(integer) -> integer\n\
5142\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005143Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005144
5145
Guido van Rossum006bf911996-06-12 04:04:55 +00005146static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005147socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00005148{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005149 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00005150
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005151 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
5152 return NULL;
5153 }
5154 if (x1 < 0) {
5155 PyErr_SetString(PyExc_OverflowError,
5156 "can't convert negative number to unsigned long");
5157 return NULL;
5158 }
5159 x2 = (unsigned int)htons((unsigned short)x1);
5160 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00005161}
5162
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005163PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005164"htons(integer) -> integer\n\
5165\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005166Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005167
5168
Guido van Rossum006bf911996-06-12 04:04:55 +00005169static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005170socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00005171{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005172 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00005173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005174 if (PyLong_Check(arg)) {
5175 x = PyLong_AsUnsignedLong(arg);
5176 if (x == (unsigned long) -1 && PyErr_Occurred())
5177 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005178#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005179 {
5180 unsigned long y;
5181 /* only want the trailing 32 bits */
5182 y = x & 0xFFFFFFFFUL;
5183 if (y ^ x)
5184 return PyErr_Format(PyExc_OverflowError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005185 "int larger than 32 bits");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005186 x = y;
5187 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005188#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005189 }
5190 else
5191 return PyErr_Format(PyExc_TypeError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005192 "expected int, %s found",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005193 Py_TYPE(arg)->tp_name);
5194 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
Guido van Rossum006bf911996-06-12 04:04:55 +00005195}
5196
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005197PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005198"htonl(integer) -> integer\n\
5199\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005200Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005201
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005202/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005203
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005204PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum7d0a8262007-05-21 23:13:11 +00005205"inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005206\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005207Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005208binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005209
5210static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005211socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005212{
Neal Norwitz88f115b2003-02-13 02:15:42 +00005213#ifdef HAVE_INET_ATON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005214 struct in_addr buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00005215#endif
5216
5217#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
Benjamin Petersonf91df042009-02-13 02:50:59 +00005218#if (SIZEOF_INT != 4)
5219#error "Not sure if in_addr_t exists and int is not 32-bits."
5220#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005221 /* Have to use inet_addr() instead */
5222 unsigned int packed_addr;
Tim Peters1df9fdd2003-02-13 03:13:40 +00005223#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005224 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005225
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005226 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
5227 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005228
Tim Peters1df9fdd2003-02-13 03:13:40 +00005229
5230#ifdef HAVE_INET_ATON
Thomas Wouters477c8d52006-05-27 19:21:47 +00005231
5232#ifdef USE_INET_ATON_WEAKLINK
5233 if (inet_aton != NULL) {
5234#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005235 if (inet_aton(ip_addr, &buf))
5236 return PyBytes_FromStringAndSize((char *)(&buf),
5237 sizeof(buf));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005238
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005239 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005240 "illegal IP address string passed to inet_aton");
5241 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005242
Thomas Wouters477c8d52006-05-27 19:21:47 +00005243#ifdef USE_INET_ATON_WEAKLINK
5244 } else {
5245#endif
5246
5247#endif
5248
5249#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
5250
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005251 /* special-case this address as inet_addr might return INADDR_NONE
5252 * for this */
5253 if (strcmp(ip_addr, "255.255.255.255") == 0) {
Charles-François Natali24aa0412013-08-31 14:48:25 +02005254 packed_addr = INADDR_BROADCAST;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005255 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00005256
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005257 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005258
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005259 if (packed_addr == INADDR_NONE) { /* invalid address */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005260 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005261 "illegal IP address string passed to inet_aton");
5262 return NULL;
5263 }
5264 }
5265 return PyBytes_FromStringAndSize((char *) &packed_addr,
5266 sizeof(packed_addr));
Thomas Wouters477c8d52006-05-27 19:21:47 +00005267
5268#ifdef USE_INET_ATON_WEAKLINK
5269 }
5270#endif
5271
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005272#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005273}
5274
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005275PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00005276"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005277\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005278Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005279
5280static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005281socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005282{
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005283 Py_buffer packed_ip;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005284 struct in_addr packed_addr;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005285
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005286 if (!PyArg_ParseTuple(args, "y*:inet_ntoa", &packed_ip)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005287 return NULL;
5288 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00005289
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005290 if (packed_ip.len != sizeof(packed_addr)) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005291 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005292 "packed IP wrong length for inet_ntoa");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005293 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005294 return NULL;
5295 }
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005296
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005297 memcpy(&packed_addr, packed_ip.buf, packed_ip.len);
5298 PyBuffer_Release(&packed_ip);
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005299
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005300 return PyUnicode_FromString(inet_ntoa(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005301}
Guido van Rossum82a5c661998-07-07 20:45:43 +00005302
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005303#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005304
5305PyDoc_STRVAR(inet_pton_doc,
5306"inet_pton(af, ip) -> packed IP address string\n\
5307\n\
5308Convert an IP address from string format to a packed string suitable\n\
5309for use with low-level network functions.");
5310
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005311#endif
5312
5313#ifdef HAVE_INET_PTON
5314
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005315static PyObject *
5316socket_inet_pton(PyObject *self, PyObject *args)
5317{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005318 int af;
5319 char* ip;
5320 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005321#ifdef ENABLE_IPV6
Victor Stinner640c35c2013-06-04 23:14:37 +02005322 char packed[Py_MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005323#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005324 char packed[sizeof(struct in_addr)];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005325#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005326 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
5327 return NULL;
5328 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005329
Martin v. Löwis04697e82004-06-02 12:35:29 +00005330#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005331 if(af == AF_INET6) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005332 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005333 "can't use AF_INET6, IPv6 is disabled");
5334 return NULL;
5335 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00005336#endif
Martin v. Löwis10649092003-08-05 06:25:06 +00005337
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005338 retval = inet_pton(af, ip, packed);
5339 if (retval < 0) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005340 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005341 return NULL;
5342 } else if (retval == 0) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005343 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005344 "illegal IP address string passed to inet_pton");
5345 return NULL;
5346 } else if (af == AF_INET) {
5347 return PyBytes_FromStringAndSize(packed,
5348 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005349#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005350 } else if (af == AF_INET6) {
5351 return PyBytes_FromStringAndSize(packed,
5352 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005353#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005354 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005355 PyErr_SetString(PyExc_OSError, "unknown address family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005356 return NULL;
5357 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005358}
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005359#elif defined(MS_WINDOWS)
5360
5361static PyObject *
5362socket_inet_pton(PyObject *self, PyObject *args)
5363{
5364 int af;
5365 char* ip;
5366 struct sockaddr_in6 addr;
5367 INT ret, size;
5368
5369 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
5370 return NULL;
5371 }
5372
Victor Stinnere990c6e2013-11-16 00:18:58 +01005373 size = sizeof(addr);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005374 ret = WSAStringToAddressA(ip, af, NULL, (LPSOCKADDR)&addr, &size);
5375
5376 if (ret) {
5377 PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
5378 return NULL;
5379 } else if(af == AF_INET) {
5380 struct sockaddr_in *addr4 = (struct sockaddr_in*)&addr;
Victor Stinnere990c6e2013-11-16 00:18:58 +01005381 return PyBytes_FromStringAndSize((const char *)&(addr4->sin_addr),
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005382 sizeof(addr4->sin_addr));
5383 } else if (af == AF_INET6) {
Victor Stinnere990c6e2013-11-16 00:18:58 +01005384 return PyBytes_FromStringAndSize((const char *)&(addr.sin6_addr),
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005385 sizeof(addr.sin6_addr));
5386 } else {
5387 PyErr_SetString(PyExc_OSError, "unknown address family");
5388 return NULL;
5389 }
5390}
5391
5392#endif
5393
5394#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Thomas Wouters477c8d52006-05-27 19:21:47 +00005395
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005396PyDoc_STRVAR(inet_ntop_doc,
5397"inet_ntop(af, packed_ip) -> string formatted IP address\n\
5398\n\
5399Convert a packed IP address of the given family to string format.");
5400
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005401#endif
5402
5403
5404#ifdef HAVE_INET_PTON
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005405static PyObject *
5406socket_inet_ntop(PyObject *self, PyObject *args)
5407{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005408 int af;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005409 Py_buffer packed_ip;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005410 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005411#ifdef ENABLE_IPV6
Victor Stinner640c35c2013-06-04 23:14:37 +02005412 char ip[Py_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005413#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005414 char ip[INET_ADDRSTRLEN + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005415#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00005416
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005417 /* Guarantee NUL-termination for PyUnicode_FromString() below */
5418 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005419
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005420 if (!PyArg_ParseTuple(args, "iy*:inet_ntop", &af, &packed_ip)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005421 return NULL;
5422 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005423
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005424 if (af == AF_INET) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005425 if (packed_ip.len != sizeof(struct in_addr)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005426 PyErr_SetString(PyExc_ValueError,
5427 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005428 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005429 return NULL;
5430 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005431#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005432 } else if (af == AF_INET6) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005433 if (packed_ip.len != sizeof(struct in6_addr)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005434 PyErr_SetString(PyExc_ValueError,
5435 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005436 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005437 return NULL;
5438 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005439#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005440 } else {
5441 PyErr_Format(PyExc_ValueError,
5442 "unknown address family %d", af);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005443 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005444 return NULL;
5445 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005446
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005447 retval = inet_ntop(af, packed_ip.buf, ip, sizeof(ip));
5448 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005449 if (!retval) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005450 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005451 return NULL;
5452 } else {
5453 return PyUnicode_FromString(retval);
5454 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005455
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005456 /* NOTREACHED */
5457 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
5458 return NULL;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005459}
5460
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005461#elif defined(MS_WINDOWS)
5462
5463static PyObject *
5464socket_inet_ntop(PyObject *self, PyObject *args)
5465{
5466 int af;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005467 Py_buffer packed_ip;
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005468 struct sockaddr_in6 addr;
5469 DWORD addrlen, ret, retlen;
Jason R. Coombs8ec784c2013-11-10 13:43:22 -05005470#ifdef ENABLE_IPV6
5471 char ip[Py_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
5472#else
5473 char ip[INET_ADDRSTRLEN + 1];
5474#endif
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005475
5476 /* Guarantee NUL-termination for PyUnicode_FromString() below */
5477 memset((void *) &ip[0], '\0', sizeof(ip));
5478
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005479 if (!PyArg_ParseTuple(args, "iy*:inet_ntop", &af, &packed_ip)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005480 return NULL;
5481 }
5482
5483 if (af == AF_INET) {
5484 struct sockaddr_in * addr4 = (struct sockaddr_in *)&addr;
5485
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005486 if (packed_ip.len != sizeof(struct in_addr)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005487 PyErr_SetString(PyExc_ValueError,
5488 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005489 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005490 return NULL;
5491 }
5492 memset(addr4, 0, sizeof(struct sockaddr_in));
5493 addr4->sin_family = AF_INET;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005494 memcpy(&(addr4->sin_addr), packed_ip.buf, sizeof(addr4->sin_addr));
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005495 addrlen = sizeof(struct sockaddr_in);
5496 } else if (af == AF_INET6) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005497 if (packed_ip.len != sizeof(struct in6_addr)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005498 PyErr_SetString(PyExc_ValueError,
5499 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005500 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005501 return NULL;
5502 }
5503
5504 memset(&addr, 0, sizeof(addr));
5505 addr.sin6_family = AF_INET6;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005506 memcpy(&(addr.sin6_addr), packed_ip.buf, sizeof(addr.sin6_addr));
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005507 addrlen = sizeof(addr);
5508 } else {
5509 PyErr_Format(PyExc_ValueError,
5510 "unknown address family %d", af);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005511 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005512 return NULL;
5513 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005514 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005515
5516 retlen = sizeof(ip);
Victor Stinnere990c6e2013-11-16 00:18:58 +01005517 ret = WSAAddressToStringA((struct sockaddr*)&addr, addrlen, NULL,
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005518 ip, &retlen);
5519
5520 if (ret) {
5521 PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
5522 return NULL;
5523 } else {
5524 return PyUnicode_FromString(ip);
5525 }
5526}
5527
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005528#endif /* HAVE_INET_PTON */
5529
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005530/* Python interface to getaddrinfo(host, port). */
5531
5532/*ARGSUSED*/
5533static PyObject *
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005534socket_getaddrinfo(PyObject *self, PyObject *args, PyObject* kwargs)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005535{
Victor Stinner77af1722011-05-26 14:05:59 +02005536 static char* kwnames[] = {"host", "port", "family", "type", "proto",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005537 "flags", 0};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005538 struct addrinfo hints, *res;
5539 struct addrinfo *res0 = NULL;
5540 PyObject *hobj = NULL;
5541 PyObject *pobj = (PyObject *)NULL;
5542 char pbuf[30];
5543 char *hptr, *pptr;
5544 int family, socktype, protocol, flags;
5545 int error;
5546 PyObject *all = (PyObject *)NULL;
5547 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005548
Georg Brandl6083a4b2013-10-14 06:51:46 +02005549 socktype = protocol = flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005550 family = AF_UNSPEC;
Victor Stinner77af1722011-05-26 14:05:59 +02005551 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iiii:getaddrinfo",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005552 kwnames, &hobj, &pobj, &family, &socktype,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005553 &protocol, &flags)) {
5554 return NULL;
5555 }
5556 if (hobj == Py_None) {
5557 hptr = NULL;
5558 } else if (PyUnicode_Check(hobj)) {
Victor Stinnerec1a4982015-09-11 12:37:30 +02005559 idna = PyUnicode_AsEncodedString(hobj, "idna", NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005560 if (!idna)
5561 return NULL;
5562 assert(PyBytes_Check(idna));
5563 hptr = PyBytes_AS_STRING(idna);
5564 } else if (PyBytes_Check(hobj)) {
5565 hptr = PyBytes_AsString(hobj);
5566 } else {
5567 PyErr_SetString(PyExc_TypeError,
5568 "getaddrinfo() argument 1 must be string or None");
5569 return NULL;
5570 }
5571 if (PyLong_CheckExact(pobj)) {
5572 long value = PyLong_AsLong(pobj);
5573 if (value == -1 && PyErr_Occurred())
5574 goto err;
5575 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
5576 pptr = pbuf;
5577 } else if (PyUnicode_Check(pobj)) {
5578 pptr = _PyUnicode_AsString(pobj);
Alexander Belopolskye239d232010-12-08 23:31:48 +00005579 if (pptr == NULL)
5580 goto err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005581 } else if (PyBytes_Check(pobj)) {
Alexander Belopolskye239d232010-12-08 23:31:48 +00005582 pptr = PyBytes_AS_STRING(pobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005583 } else if (pobj == Py_None) {
5584 pptr = (char *)NULL;
5585 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005586 PyErr_SetString(PyExc_OSError, "Int or String expected");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005587 goto err;
5588 }
Ronald Oussorena822d3662013-06-10 10:36:28 +02005589#if defined(__APPLE__) && defined(AI_NUMERICSERV)
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02005590 if ((flags & AI_NUMERICSERV) && (pptr == NULL || (pptr[0] == '0' && pptr[1] == 0))) {
5591 /* On OSX upto at least OSX 10.8 getaddrinfo crashes
Christian Heimesaf01f662013-12-21 16:19:10 +01005592 * if AI_NUMERICSERV is set and the servname is NULL or "0".
5593 * This workaround avoids a segfault in libsystem.
5594 */
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02005595 pptr = "00";
5596 }
5597#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005598 memset(&hints, 0, sizeof(hints));
5599 hints.ai_family = family;
5600 hints.ai_socktype = socktype;
5601 hints.ai_protocol = protocol;
5602 hints.ai_flags = flags;
5603 Py_BEGIN_ALLOW_THREADS
5604 ACQUIRE_GETADDRINFO_LOCK
5605 error = getaddrinfo(hptr, pptr, &hints, &res0);
5606 Py_END_ALLOW_THREADS
5607 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
5608 if (error) {
5609 set_gaierror(error);
5610 goto err;
5611 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005612
Benjamin Peterson4fd929b2015-04-01 11:16:40 -04005613 all = PyList_New(0);
5614 if (all == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005615 goto err;
5616 for (res = res0; res; res = res->ai_next) {
5617 PyObject *single;
5618 PyObject *addr =
5619 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
5620 if (addr == NULL)
5621 goto err;
5622 single = Py_BuildValue("iiisO", res->ai_family,
5623 res->ai_socktype, res->ai_protocol,
5624 res->ai_canonname ? res->ai_canonname : "",
5625 addr);
5626 Py_DECREF(addr);
5627 if (single == NULL)
5628 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005629
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005630 if (PyList_Append(all, single))
5631 goto err;
5632 Py_XDECREF(single);
5633 }
5634 Py_XDECREF(idna);
5635 if (res0)
5636 freeaddrinfo(res0);
5637 return all;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005638 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005639 Py_XDECREF(all);
5640 Py_XDECREF(idna);
5641 if (res0)
5642 freeaddrinfo(res0);
5643 return (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005644}
5645
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005646PyDoc_STRVAR(getaddrinfo_doc,
Berker Peksaga6ec5ee2014-06-30 11:28:40 +03005647"getaddrinfo(host, port [, family, type, proto, flags])\n\
5648 -> list of (family, type, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005649\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005650Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005651
5652/* Python interface to getnameinfo(sa, flags). */
5653
5654/*ARGSUSED*/
5655static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005656socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005657{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005658 PyObject *sa = (PyObject *)NULL;
5659 int flags;
5660 char *hostp;
Charles-François Natali366999a2012-01-02 15:47:29 +01005661 int port;
5662 unsigned int flowinfo, scope_id;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005663 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
5664 struct addrinfo hints, *res = NULL;
5665 int error;
5666 PyObject *ret = (PyObject *)NULL;
Victor Stinner72400302016-01-28 15:41:01 +01005667 PyObject *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005668
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005669 flags = flowinfo = scope_id = 0;
5670 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
5671 return NULL;
5672 if (!PyTuple_Check(sa)) {
5673 PyErr_SetString(PyExc_TypeError,
5674 "getnameinfo() argument 1 must be a tuple");
5675 return NULL;
5676 }
Charles-François Natali366999a2012-01-02 15:47:29 +01005677 if (!PyArg_ParseTuple(sa, "si|II",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005678 &hostp, &port, &flowinfo, &scope_id))
5679 return NULL;
Charles-François Natali9b0c0062012-06-23 10:17:05 +02005680 if (flowinfo > 0xfffff) {
Charles-François Natali366999a2012-01-02 15:47:29 +01005681 PyErr_SetString(PyExc_OverflowError,
5682 "getsockaddrarg: flowinfo must be 0-1048575.");
5683 return NULL;
5684 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005685 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
5686 memset(&hints, 0, sizeof(hints));
5687 hints.ai_family = AF_UNSPEC;
5688 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Martin v. Löwis112c0f32010-08-25 07:38:15 +00005689 hints.ai_flags = AI_NUMERICHOST; /* don't do any name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005690 Py_BEGIN_ALLOW_THREADS
5691 ACQUIRE_GETADDRINFO_LOCK
5692 error = getaddrinfo(hostp, pbuf, &hints, &res);
5693 Py_END_ALLOW_THREADS
5694 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
5695 if (error) {
5696 set_gaierror(error);
5697 goto fail;
5698 }
5699 if (res->ai_next) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005700 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005701 "sockaddr resolved to multiple addresses");
5702 goto fail;
5703 }
5704 switch (res->ai_family) {
5705 case AF_INET:
5706 {
5707 if (PyTuple_GET_SIZE(sa) != 2) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005708 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005709 "IPv4 sockaddr must be 2 tuple");
5710 goto fail;
5711 }
5712 break;
5713 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00005714#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005715 case AF_INET6:
5716 {
5717 struct sockaddr_in6 *sin6;
5718 sin6 = (struct sockaddr_in6 *)res->ai_addr;
Charles-François Natali366999a2012-01-02 15:47:29 +01005719 sin6->sin6_flowinfo = htonl(flowinfo);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005720 sin6->sin6_scope_id = scope_id;
5721 break;
5722 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005723#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005724 }
Antoine Pitrou19467d22010-08-17 19:33:30 +00005725 error = getnameinfo(res->ai_addr, (socklen_t) res->ai_addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005726 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
5727 if (error) {
5728 set_gaierror(error);
5729 goto fail;
5730 }
Victor Stinner72400302016-01-28 15:41:01 +01005731
5732 name = sock_decode_hostname(hbuf);
5733 if (name == NULL)
5734 goto fail;
5735 ret = Py_BuildValue("Ns", name, pbuf);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005736
5737fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005738 if (res)
5739 freeaddrinfo(res);
5740 return ret;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005741}
5742
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005743PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00005744"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005745\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005746Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005747
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005748
5749/* Python API to getting and setting the default timeout value. */
5750
5751static PyObject *
5752socket_getdefaulttimeout(PyObject *self)
5753{
Victor Stinner71694d52015-03-28 01:18:54 +01005754 if (defaulttimeout < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005755 Py_INCREF(Py_None);
5756 return Py_None;
5757 }
Victor Stinner71694d52015-03-28 01:18:54 +01005758 else {
5759 double seconds = _PyTime_AsSecondsDouble(defaulttimeout);
5760 return PyFloat_FromDouble(seconds);
5761 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005762}
5763
5764PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00005765"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005766\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03005767Returns the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005768A value of None indicates that new socket objects have no timeout.\n\
5769When the socket module is first imported, the default is None.");
5770
5771static PyObject *
5772socket_setdefaulttimeout(PyObject *self, PyObject *arg)
5773{
Victor Stinner71694d52015-03-28 01:18:54 +01005774 _PyTime_t timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005775
Victor Stinner71694d52015-03-28 01:18:54 +01005776 if (socket_parse_timeout(&timeout, arg) < 0)
5777 return NULL;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005778
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005779 defaulttimeout = timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005780
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005781 Py_INCREF(Py_None);
5782 return Py_None;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005783}
5784
5785PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00005786"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005787\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03005788Set the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00005789A value of None indicates that new socket objects have no timeout.\n\
5790When the socket module is first imported, the default is None.");
5791
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005792#ifdef HAVE_IF_NAMEINDEX
5793/* Python API for getting interface indices and names */
5794
5795static PyObject *
5796socket_if_nameindex(PyObject *self, PyObject *arg)
5797{
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005798 PyObject *list;
Charles-François Natali60713592011-05-20 16:55:06 +02005799 int i;
5800 struct if_nameindex *ni;
Victor Stinner77af1722011-05-26 14:05:59 +02005801
Charles-François Natali60713592011-05-20 16:55:06 +02005802 ni = if_nameindex();
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005803 if (ni == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005804 PyErr_SetFromErrno(PyExc_OSError);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005805 return NULL;
5806 }
5807
5808 list = PyList_New(0);
5809 if (list == NULL) {
5810 if_freenameindex(ni);
5811 return NULL;
5812 }
5813
Charles-François Natali60713592011-05-20 16:55:06 +02005814 for (i = 0; ni[i].if_index != 0 && i < INT_MAX; i++) {
5815 PyObject *ni_tuple = Py_BuildValue("IO&",
5816 ni[i].if_index, PyUnicode_DecodeFSDefault, ni[i].if_name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005817
5818 if (ni_tuple == NULL || PyList_Append(list, ni_tuple) == -1) {
5819 Py_XDECREF(ni_tuple);
Charles-François Natali60713592011-05-20 16:55:06 +02005820 Py_DECREF(list);
5821 if_freenameindex(ni);
5822 return NULL;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005823 }
5824 Py_DECREF(ni_tuple);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005825 }
5826
5827 if_freenameindex(ni);
5828 return list;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005829}
5830
5831PyDoc_STRVAR(if_nameindex_doc,
5832"if_nameindex()\n\
5833\n\
5834Returns a list of network interface information (index, name) tuples.");
5835
Charles-François Natali60713592011-05-20 16:55:06 +02005836static PyObject *
5837socket_if_nametoindex(PyObject *self, PyObject *args)
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005838{
Charles-François Natali60713592011-05-20 16:55:06 +02005839 PyObject *oname;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005840 unsigned long index;
5841
Charles-François Natali60713592011-05-20 16:55:06 +02005842 if (!PyArg_ParseTuple(args, "O&:if_nametoindex",
5843 PyUnicode_FSConverter, &oname))
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005844 return NULL;
5845
Charles-François Natali60713592011-05-20 16:55:06 +02005846 index = if_nametoindex(PyBytes_AS_STRING(oname));
5847 Py_DECREF(oname);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005848 if (index == 0) {
Charles-François Natali60713592011-05-20 16:55:06 +02005849 /* if_nametoindex() doesn't set errno */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005850 PyErr_SetString(PyExc_OSError, "no interface with this name");
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005851 return NULL;
5852 }
5853
5854 return PyLong_FromUnsignedLong(index);
5855}
5856
5857PyDoc_STRVAR(if_nametoindex_doc,
5858"if_nametoindex(if_name)\n\
5859\n\
5860Returns the interface index corresponding to the interface name if_name.");
5861
Charles-François Natali60713592011-05-20 16:55:06 +02005862static PyObject *
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005863socket_if_indextoname(PyObject *self, PyObject *arg)
5864{
Charles-François Natali60713592011-05-20 16:55:06 +02005865 unsigned long index;
5866 char name[IF_NAMESIZE + 1];
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005867
Charles-François Natali60713592011-05-20 16:55:06 +02005868 index = PyLong_AsUnsignedLong(arg);
5869 if (index == (unsigned long) -1)
5870 return NULL;
5871
5872 if (if_indextoname(index, name) == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005873 PyErr_SetFromErrno(PyExc_OSError);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005874 return NULL;
5875 }
5876
Charles-François Natali60713592011-05-20 16:55:06 +02005877 return PyUnicode_DecodeFSDefault(name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005878}
5879
5880PyDoc_STRVAR(if_indextoname_doc,
5881"if_indextoname(if_index)\n\
5882\n\
5883Returns the interface name corresponding to the interface index if_index.");
5884
5885#endif /* HAVE_IF_NAMEINDEX */
5886
5887
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005888#ifdef CMSG_LEN
5889/* Python interface to CMSG_LEN(length). */
5890
5891static PyObject *
5892socket_CMSG_LEN(PyObject *self, PyObject *args)
5893{
5894 Py_ssize_t length;
5895 size_t result;
5896
5897 if (!PyArg_ParseTuple(args, "n:CMSG_LEN", &length))
5898 return NULL;
5899 if (length < 0 || !get_CMSG_LEN(length, &result)) {
5900 PyErr_Format(PyExc_OverflowError, "CMSG_LEN() argument out of range");
5901 return NULL;
5902 }
5903 return PyLong_FromSize_t(result);
5904}
5905
5906PyDoc_STRVAR(CMSG_LEN_doc,
5907"CMSG_LEN(length) -> control message length\n\
5908\n\
5909Return the total length, without trailing padding, of an ancillary\n\
5910data item with associated data of the given length. This value can\n\
5911often be used as the buffer size for recvmsg() to receive a single\n\
5912item of ancillary data, but RFC 3542 requires portable applications to\n\
5913use CMSG_SPACE() and thus include space for padding, even when the\n\
5914item will be the last in the buffer. Raises OverflowError if length\n\
5915is outside the permissible range of values.");
5916
5917
5918#ifdef CMSG_SPACE
5919/* Python interface to CMSG_SPACE(length). */
5920
5921static PyObject *
5922socket_CMSG_SPACE(PyObject *self, PyObject *args)
5923{
5924 Py_ssize_t length;
5925 size_t result;
5926
5927 if (!PyArg_ParseTuple(args, "n:CMSG_SPACE", &length))
5928 return NULL;
5929 if (length < 0 || !get_CMSG_SPACE(length, &result)) {
5930 PyErr_SetString(PyExc_OverflowError,
5931 "CMSG_SPACE() argument out of range");
5932 return NULL;
5933 }
5934 return PyLong_FromSize_t(result);
5935}
5936
5937PyDoc_STRVAR(CMSG_SPACE_doc,
5938"CMSG_SPACE(length) -> buffer size\n\
5939\n\
5940Return the buffer size needed for recvmsg() to receive an ancillary\n\
5941data item with associated data of the given length, along with any\n\
5942trailing padding. The buffer space needed to receive multiple items\n\
5943is the sum of the CMSG_SPACE() values for their associated data\n\
5944lengths. Raises OverflowError if length is outside the permissible\n\
5945range of values.");
5946#endif /* CMSG_SPACE */
5947#endif /* CMSG_LEN */
5948
5949
Guido van Rossum30a685f1991-06-27 15:51:29 +00005950/* List of functions exported by this module. */
5951
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005952static PyMethodDef socket_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005953 {"gethostbyname", socket_gethostbyname,
5954 METH_VARARGS, gethostbyname_doc},
5955 {"gethostbyname_ex", socket_gethostbyname_ex,
5956 METH_VARARGS, ghbn_ex_doc},
5957 {"gethostbyaddr", socket_gethostbyaddr,
5958 METH_VARARGS, gethostbyaddr_doc},
5959 {"gethostname", socket_gethostname,
5960 METH_NOARGS, gethostname_doc},
Antoine Pitrou061cfb52011-02-28 22:25:22 +00005961#ifdef HAVE_SETHOSTNAME
5962 {"sethostname", socket_sethostname,
5963 METH_VARARGS, sethostname_doc},
5964#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005965 {"getservbyname", socket_getservbyname,
5966 METH_VARARGS, getservbyname_doc},
5967 {"getservbyport", socket_getservbyport,
5968 METH_VARARGS, getservbyport_doc},
5969 {"getprotobyname", socket_getprotobyname,
5970 METH_VARARGS, getprotobyname_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005971#ifndef NO_DUP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005972 {"dup", socket_dup,
5973 METH_O, dup_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005974#endif
Dave Cole331708b2004-08-09 04:51:41 +00005975#ifdef HAVE_SOCKETPAIR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005976 {"socketpair", socket_socketpair,
5977 METH_VARARGS, socketpair_doc},
Dave Cole331708b2004-08-09 04:51:41 +00005978#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005979 {"ntohs", socket_ntohs,
5980 METH_VARARGS, ntohs_doc},
5981 {"ntohl", socket_ntohl,
5982 METH_O, ntohl_doc},
5983 {"htons", socket_htons,
5984 METH_VARARGS, htons_doc},
5985 {"htonl", socket_htonl,
5986 METH_O, htonl_doc},
5987 {"inet_aton", socket_inet_aton,
5988 METH_VARARGS, inet_aton_doc},
5989 {"inet_ntoa", socket_inet_ntoa,
5990 METH_VARARGS, inet_ntoa_doc},
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005991#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005992 {"inet_pton", socket_inet_pton,
5993 METH_VARARGS, inet_pton_doc},
5994 {"inet_ntop", socket_inet_ntop,
5995 METH_VARARGS, inet_ntop_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005996#endif
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005997 {"getaddrinfo", (PyCFunction)socket_getaddrinfo,
5998 METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005999 {"getnameinfo", socket_getnameinfo,
6000 METH_VARARGS, getnameinfo_doc},
6001 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
6002 METH_NOARGS, getdefaulttimeout_doc},
6003 {"setdefaulttimeout", socket_setdefaulttimeout,
6004 METH_O, setdefaulttimeout_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006005#ifdef HAVE_IF_NAMEINDEX
6006 {"if_nameindex", socket_if_nameindex,
6007 METH_NOARGS, if_nameindex_doc},
6008 {"if_nametoindex", socket_if_nametoindex,
Charles-François Natali60713592011-05-20 16:55:06 +02006009 METH_VARARGS, if_nametoindex_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006010 {"if_indextoname", socket_if_indextoname,
6011 METH_O, if_indextoname_doc},
6012#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006013#ifdef CMSG_LEN
6014 {"CMSG_LEN", socket_CMSG_LEN,
6015 METH_VARARGS, CMSG_LEN_doc},
6016#ifdef CMSG_SPACE
6017 {"CMSG_SPACE", socket_CMSG_SPACE,
6018 METH_VARARGS, CMSG_SPACE_doc},
6019#endif
6020#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006021 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00006022};
6023
Guido van Rossum30a685f1991-06-27 15:51:29 +00006024
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006025#ifdef MS_WINDOWS
6026#define OS_INIT_DEFINED
6027
6028/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006029
6030static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006031os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00006032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006033 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00006034}
6035
6036static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006037os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00006038{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006039 WSADATA WSAData;
6040 int ret;
6041 ret = WSAStartup(0x0101, &WSAData);
6042 switch (ret) {
6043 case 0: /* No error */
6044 Py_AtExit(os_cleanup);
6045 return 1; /* Success */
6046 case WSASYSNOTREADY:
6047 PyErr_SetString(PyExc_ImportError,
6048 "WSAStartup failed: network not ready");
6049 break;
6050 case WSAVERNOTSUPPORTED:
6051 case WSAEINVAL:
6052 PyErr_SetString(
6053 PyExc_ImportError,
6054 "WSAStartup failed: requested version not supported");
6055 break;
6056 default:
6057 PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
6058 break;
6059 }
6060 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006061}
6062
Guido van Rossum8d665e61996-06-26 18:22:49 +00006063#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006064
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00006065
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006066
6067#ifndef OS_INIT_DEFINED
6068static int
6069os_init(void)
6070{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006071 return 1; /* Success */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006072}
6073#endif
6074
6075
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006076/* C API table - always add new things to the end for binary
6077 compatibility. */
6078static
6079PySocketModule_APIObject PySocketModuleAPI =
6080{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006081 &sock_type,
Antoine Pitrouc4df7842010-12-03 19:59:41 +00006082 NULL,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006083 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006084};
6085
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006086
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006087/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006088
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006089 This module is actually called "_socket", and there's a wrapper
Guido van Rossum7d0a8262007-05-21 23:13:11 +00006090 "socket.py" which implements some additional functionality.
6091 The import of "_socket" may fail with an ImportError exception if
6092 os-specific initialization fails. On Windows, this does WINSOCK
Ezio Melotti13925002011-03-16 11:05:33 +02006093 initialization. When WINSOCK is initialized successfully, a call to
Guido van Rossum7d0a8262007-05-21 23:13:11 +00006094 WSACleanup() is scheduled to be made at exit time.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006095*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006096
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006097PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00006098"Implementation module for socket operations.\n\
6099\n\
6100See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00006101
Martin v. Löwis1a214512008-06-11 05:26:20 +00006102static struct PyModuleDef socketmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006103 PyModuleDef_HEAD_INIT,
6104 PySocket_MODULE_NAME,
6105 socket_doc,
6106 -1,
6107 socket_methods,
6108 NULL,
6109 NULL,
6110 NULL,
6111 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00006112};
6113
Mark Hammondfe51c6d2002-08-02 02:27:13 +00006114PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00006115PyInit__socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00006116{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006117 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00006118
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006119 if (!os_init())
6120 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006121
Victor Stinnerdaf45552013-08-28 00:53:59 +02006122#ifdef MS_WINDOWS
6123 if (support_wsa_no_inherit == -1) {
Steve Dower65e4cb12014-11-22 12:54:57 -08006124#if defined(_MSC_VER) && _MSC_VER >= 1800
6125 support_wsa_no_inherit = IsWindows7SP1OrGreater();
6126#else
Victor Stinnerdaf45552013-08-28 00:53:59 +02006127 DWORD version = GetVersion();
6128 DWORD major = (DWORD)LOBYTE(LOWORD(version));
6129 DWORD minor = (DWORD)HIBYTE(LOWORD(version));
6130 /* need Windows 7 SP1, 2008 R2 SP1 or later */
Steve Dower65e4cb12014-11-22 12:54:57 -08006131 support_wsa_no_inherit = major > 6 || (major == 6 && minor >= 1);
6132#endif
Victor Stinnerdaf45552013-08-28 00:53:59 +02006133 }
6134#endif
6135
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006136 Py_TYPE(&sock_type) = &PyType_Type;
6137 m = PyModule_Create(&socketmodule);
6138 if (m == NULL)
6139 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006140
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006141 Py_INCREF(PyExc_OSError);
6142 PySocketModuleAPI.error = PyExc_OSError;
6143 Py_INCREF(PyExc_OSError);
6144 PyModule_AddObject(m, "error", PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006145 socket_herror = PyErr_NewException("socket.herror",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006146 PyExc_OSError, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006147 if (socket_herror == NULL)
6148 return NULL;
6149 Py_INCREF(socket_herror);
6150 PyModule_AddObject(m, "herror", socket_herror);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006151 socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006152 NULL);
6153 if (socket_gaierror == NULL)
6154 return NULL;
6155 Py_INCREF(socket_gaierror);
6156 PyModule_AddObject(m, "gaierror", socket_gaierror);
6157 socket_timeout = PyErr_NewException("socket.timeout",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006158 PyExc_OSError, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006159 if (socket_timeout == NULL)
6160 return NULL;
Antoine Pitrouc4df7842010-12-03 19:59:41 +00006161 PySocketModuleAPI.timeout_error = socket_timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006162 Py_INCREF(socket_timeout);
6163 PyModule_AddObject(m, "timeout", socket_timeout);
6164 Py_INCREF((PyObject *)&sock_type);
6165 if (PyModule_AddObject(m, "SocketType",
6166 (PyObject *)&sock_type) != 0)
6167 return NULL;
6168 Py_INCREF((PyObject *)&sock_type);
6169 if (PyModule_AddObject(m, "socket",
6170 (PyObject *)&sock_type) != 0)
6171 return NULL;
Guido van Rossum09be4091999-08-09 14:40:40 +00006172
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006173#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006174 has_ipv6 = Py_True;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006175#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006176 has_ipv6 = Py_False;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006177#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006178 Py_INCREF(has_ipv6);
6179 PyModule_AddObject(m, "has_ipv6", has_ipv6);
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006180
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006181 /* Export C API */
6182 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
6183 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
6184 ) != 0)
6185 return NULL;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006186
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006187 /* Address families (we only support AF_INET and AF_UNIX) */
Guido van Rossum09be4091999-08-09 14:40:40 +00006188#ifdef AF_UNSPEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006189 PyModule_AddIntMacro(m, AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00006190#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006191 PyModule_AddIntMacro(m, AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006192#ifdef AF_INET6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006193 PyModule_AddIntMacro(m, AF_INET6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006194#endif /* AF_INET6 */
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00006195#if defined(AF_UNIX)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006196 PyModule_AddIntMacro(m, AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00006197#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00006198#ifdef AF_AX25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006199 /* Amateur Radio AX.25 */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006200 PyModule_AddIntMacro(m, AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00006201#endif
6202#ifdef AF_IPX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006203 PyModule_AddIntMacro(m, AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00006204#endif
6205#ifdef AF_APPLETALK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006206 /* Appletalk DDP */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006207 PyModule_AddIntMacro(m, AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00006208#endif
6209#ifdef AF_NETROM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006210 /* Amateur radio NetROM */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006211 PyModule_AddIntMacro(m, AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00006212#endif
6213#ifdef AF_BRIDGE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006214 /* Multiprotocol bridge */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006215 PyModule_AddIntMacro(m, AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006216#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006217#ifdef AF_ATMPVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006218 /* ATM PVCs */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006219 PyModule_AddIntMacro(m, AF_ATMPVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006220#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006221#ifdef AF_AAL5
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006222 /* Reserved for Werner's ATM */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006223 PyModule_AddIntMacro(m, AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00006224#endif
6225#ifdef AF_X25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006226 /* Reserved for X.25 project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006227 PyModule_AddIntMacro(m, AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00006228#endif
6229#ifdef AF_INET6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006230 PyModule_AddIntMacro(m, AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00006231#endif
6232#ifdef AF_ROSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006233 /* Amateur Radio X.25 PLP */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006234 PyModule_AddIntMacro(m, AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006235#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006236#ifdef AF_DECnet
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006237 /* Reserved for DECnet project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006238 PyModule_AddIntMacro(m, AF_DECnet);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006239#endif
6240#ifdef AF_NETBEUI
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006241 /* Reserved for 802.2LLC project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006242 PyModule_AddIntMacro(m, AF_NETBEUI);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006243#endif
6244#ifdef AF_SECURITY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006245 /* Security callback pseudo AF */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006246 PyModule_AddIntMacro(m, AF_SECURITY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006247#endif
6248#ifdef AF_KEY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006249 /* PF_KEY key management API */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006250 PyModule_AddIntMacro(m, AF_KEY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006251#endif
6252#ifdef AF_NETLINK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006253 /* */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006254 PyModule_AddIntMacro(m, AF_NETLINK);
6255 PyModule_AddIntMacro(m, NETLINK_ROUTE);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006256#ifdef NETLINK_SKIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006257 PyModule_AddIntMacro(m, NETLINK_SKIP);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006258#endif
6259#ifdef NETLINK_W1
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006260 PyModule_AddIntMacro(m, NETLINK_W1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006261#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006262 PyModule_AddIntMacro(m, NETLINK_USERSOCK);
6263 PyModule_AddIntMacro(m, NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006264#ifdef NETLINK_TCPDIAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006265 PyModule_AddIntMacro(m, NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006266#endif
6267#ifdef NETLINK_NFLOG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006268 PyModule_AddIntMacro(m, NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006269#endif
Neal Norwitz65851662006-01-16 04:31:40 +00006270#ifdef NETLINK_XFRM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006271 PyModule_AddIntMacro(m, NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00006272#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006273#ifdef NETLINK_ARPD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006274 PyModule_AddIntMacro(m, NETLINK_ARPD);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006275#endif
6276#ifdef NETLINK_ROUTE6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006277 PyModule_AddIntMacro(m, NETLINK_ROUTE6);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006278#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006279 PyModule_AddIntMacro(m, NETLINK_IP6_FW);
Thomas Wouterscf297e42007-02-23 15:07:44 +00006280#ifdef NETLINK_DNRTMSG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006281 PyModule_AddIntMacro(m, NETLINK_DNRTMSG);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00006282#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006283#ifdef NETLINK_TAPBASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006284 PyModule_AddIntMacro(m, NETLINK_TAPBASE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006285#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006286#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006287#ifdef AF_ROUTE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006288 /* Alias to emulate 4.4BSD */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006289 PyModule_AddIntMacro(m, AF_ROUTE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006290#endif
Giampaolo Rodola'80e1c432013-05-21 21:02:04 +02006291#ifdef AF_LINK
6292 PyModule_AddIntMacro(m, AF_LINK);
6293#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006294#ifdef AF_ASH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006295 /* Ash */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006296 PyModule_AddIntMacro(m, AF_ASH);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006297#endif
6298#ifdef AF_ECONET
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006299 /* Acorn Econet */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006300 PyModule_AddIntMacro(m, AF_ECONET);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006301#endif
6302#ifdef AF_ATMSVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006303 /* ATM SVCs */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006304 PyModule_AddIntMacro(m, AF_ATMSVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006305#endif
6306#ifdef AF_SNA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006307 /* Linux SNA Project (nutters!) */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006308 PyModule_AddIntMacro(m, AF_SNA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006309#endif
6310#ifdef AF_IRDA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006311 /* IRDA sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006312 PyModule_AddIntMacro(m, AF_IRDA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006313#endif
6314#ifdef AF_PPPOX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006315 /* PPPoX sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006316 PyModule_AddIntMacro(m, AF_PPPOX);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006317#endif
6318#ifdef AF_WANPIPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006319 /* Wanpipe API Sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006320 PyModule_AddIntMacro(m, AF_WANPIPE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006321#endif
6322#ifdef AF_LLC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006323 /* Linux LLC */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006324 PyModule_AddIntMacro(m, AF_LLC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006325#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00006326
Hye-Shik Chang81268602004-02-02 06:05:24 +00006327#ifdef USE_BLUETOOTH
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006328 PyModule_AddIntMacro(m, AF_BLUETOOTH);
6329 PyModule_AddIntMacro(m, BTPROTO_L2CAP);
6330 PyModule_AddIntMacro(m, BTPROTO_HCI);
6331 PyModule_AddIntMacro(m, SOL_HCI);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006332#if !defined(__NetBSD__) && !defined(__DragonFly__)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006333 PyModule_AddIntMacro(m, HCI_FILTER);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006334#endif
Hye-Shik Chang81268602004-02-02 06:05:24 +00006335#if !defined(__FreeBSD__)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006336#if !defined(__NetBSD__) && !defined(__DragonFly__)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006337 PyModule_AddIntMacro(m, HCI_TIME_STAMP);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006338#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006339 PyModule_AddIntMacro(m, HCI_DATA_DIR);
6340 PyModule_AddIntMacro(m, BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00006341#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006342 PyModule_AddIntMacro(m, BTPROTO_RFCOMM);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006343 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
6344 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
Martin v. Löwis12af0482004-01-31 12:34:17 +00006345#endif
6346
Charles-François Natali47413c12011-10-06 19:47:44 +02006347#ifdef AF_CAN
6348 /* Controller Area Network */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006349 PyModule_AddIntMacro(m, AF_CAN);
Charles-François Natali47413c12011-10-06 19:47:44 +02006350#endif
6351#ifdef PF_CAN
6352 /* Controller Area Network */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006353 PyModule_AddIntMacro(m, PF_CAN);
Charles-François Natali47413c12011-10-06 19:47:44 +02006354#endif
6355
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006356/* Reliable Datagram Sockets */
6357#ifdef AF_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006358 PyModule_AddIntMacro(m, AF_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006359#endif
6360#ifdef PF_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006361 PyModule_AddIntMacro(m, PF_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006362#endif
6363
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006364/* Kernel event messages */
6365#ifdef PF_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006366 PyModule_AddIntMacro(m, PF_SYSTEM);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006367#endif
6368#ifdef AF_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006369 PyModule_AddIntMacro(m, AF_SYSTEM);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006370#endif
6371
Antoine Pitroub156a462010-10-27 20:13:57 +00006372#ifdef AF_PACKET
6373 PyModule_AddIntMacro(m, AF_PACKET);
6374#endif
6375#ifdef PF_PACKET
6376 PyModule_AddIntMacro(m, PF_PACKET);
6377#endif
6378#ifdef PACKET_HOST
6379 PyModule_AddIntMacro(m, PACKET_HOST);
6380#endif
6381#ifdef PACKET_BROADCAST
6382 PyModule_AddIntMacro(m, PACKET_BROADCAST);
6383#endif
6384#ifdef PACKET_MULTICAST
6385 PyModule_AddIntMacro(m, PACKET_MULTICAST);
6386#endif
6387#ifdef PACKET_OTHERHOST
6388 PyModule_AddIntMacro(m, PACKET_OTHERHOST);
6389#endif
6390#ifdef PACKET_OUTGOING
6391 PyModule_AddIntMacro(m, PACKET_OUTGOING);
6392#endif
6393#ifdef PACKET_LOOPBACK
6394 PyModule_AddIntMacro(m, PACKET_LOOPBACK);
6395#endif
6396#ifdef PACKET_FASTROUTE
6397 PyModule_AddIntMacro(m, PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00006398#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006399
Christian Heimes043d6f62008-01-07 17:19:16 +00006400#ifdef HAVE_LINUX_TIPC_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006401 PyModule_AddIntMacro(m, AF_TIPC);
Christian Heimes043d6f62008-01-07 17:19:16 +00006402
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006403 /* for addresses */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006404 PyModule_AddIntMacro(m, TIPC_ADDR_NAMESEQ);
6405 PyModule_AddIntMacro(m, TIPC_ADDR_NAME);
6406 PyModule_AddIntMacro(m, TIPC_ADDR_ID);
Christian Heimes043d6f62008-01-07 17:19:16 +00006407
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006408 PyModule_AddIntMacro(m, TIPC_ZONE_SCOPE);
6409 PyModule_AddIntMacro(m, TIPC_CLUSTER_SCOPE);
6410 PyModule_AddIntMacro(m, TIPC_NODE_SCOPE);
Christian Heimes043d6f62008-01-07 17:19:16 +00006411
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006412 /* for setsockopt() */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006413 PyModule_AddIntMacro(m, SOL_TIPC);
6414 PyModule_AddIntMacro(m, TIPC_IMPORTANCE);
6415 PyModule_AddIntMacro(m, TIPC_SRC_DROPPABLE);
6416 PyModule_AddIntMacro(m, TIPC_DEST_DROPPABLE);
6417 PyModule_AddIntMacro(m, TIPC_CONN_TIMEOUT);
Christian Heimes043d6f62008-01-07 17:19:16 +00006418
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006419 PyModule_AddIntMacro(m, TIPC_LOW_IMPORTANCE);
6420 PyModule_AddIntMacro(m, TIPC_MEDIUM_IMPORTANCE);
6421 PyModule_AddIntMacro(m, TIPC_HIGH_IMPORTANCE);
6422 PyModule_AddIntMacro(m, TIPC_CRITICAL_IMPORTANCE);
Christian Heimes043d6f62008-01-07 17:19:16 +00006423
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006424 /* for subscriptions */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006425 PyModule_AddIntMacro(m, TIPC_SUB_PORTS);
6426 PyModule_AddIntMacro(m, TIPC_SUB_SERVICE);
Christian Heimes25bb7832008-01-11 16:17:00 +00006427#ifdef TIPC_SUB_CANCEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006428 /* doesn't seem to be available everywhere */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006429 PyModule_AddIntMacro(m, TIPC_SUB_CANCEL);
Christian Heimes25bb7832008-01-11 16:17:00 +00006430#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006431 PyModule_AddIntMacro(m, TIPC_WAIT_FOREVER);
6432 PyModule_AddIntMacro(m, TIPC_PUBLISHED);
6433 PyModule_AddIntMacro(m, TIPC_WITHDRAWN);
6434 PyModule_AddIntMacro(m, TIPC_SUBSCR_TIMEOUT);
6435 PyModule_AddIntMacro(m, TIPC_CFG_SRV);
6436 PyModule_AddIntMacro(m, TIPC_TOP_SRV);
Christian Heimes043d6f62008-01-07 17:19:16 +00006437#endif
6438
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006439 /* Socket types */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006440 PyModule_AddIntMacro(m, SOCK_STREAM);
6441 PyModule_AddIntMacro(m, SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00006442/* We have incomplete socket support. */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006443 PyModule_AddIntMacro(m, SOCK_RAW);
6444 PyModule_AddIntMacro(m, SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00006445#if defined(SOCK_RDM)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006446 PyModule_AddIntMacro(m, SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00006447#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +00006448#ifdef SOCK_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006449 PyModule_AddIntMacro(m, SOCK_CLOEXEC);
Antoine Pitroub1c54962010-10-14 15:05:38 +00006450#endif
6451#ifdef SOCK_NONBLOCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006452 PyModule_AddIntMacro(m, SOCK_NONBLOCK);
Antoine Pitroub1c54962010-10-14 15:05:38 +00006453#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006454
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006455#ifdef SO_DEBUG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006456 PyModule_AddIntMacro(m, SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006457#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006458#ifdef SO_ACCEPTCONN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006459 PyModule_AddIntMacro(m, SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006460#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006461#ifdef SO_REUSEADDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006462 PyModule_AddIntMacro(m, SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006463#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00006464#ifdef SO_EXCLUSIVEADDRUSE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006465 PyModule_AddIntMacro(m, SO_EXCLUSIVEADDRUSE);
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00006466#endif
6467
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006468#ifdef SO_KEEPALIVE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006469 PyModule_AddIntMacro(m, SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006470#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006471#ifdef SO_DONTROUTE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006472 PyModule_AddIntMacro(m, SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006473#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006474#ifdef SO_BROADCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006475 PyModule_AddIntMacro(m, SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006476#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006477#ifdef SO_USELOOPBACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006478 PyModule_AddIntMacro(m, SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006479#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006480#ifdef SO_LINGER
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006481 PyModule_AddIntMacro(m, SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006482#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006483#ifdef SO_OOBINLINE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006484 PyModule_AddIntMacro(m, SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006485#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006486#ifdef SO_REUSEPORT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006487 PyModule_AddIntMacro(m, SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006488#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006489#ifdef SO_SNDBUF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006490 PyModule_AddIntMacro(m, SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006491#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006492#ifdef SO_RCVBUF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006493 PyModule_AddIntMacro(m, SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006494#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006495#ifdef SO_SNDLOWAT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006496 PyModule_AddIntMacro(m, SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006497#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006498#ifdef SO_RCVLOWAT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006499 PyModule_AddIntMacro(m, SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006500#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006501#ifdef SO_SNDTIMEO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006502 PyModule_AddIntMacro(m, SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006503#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006504#ifdef SO_RCVTIMEO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006505 PyModule_AddIntMacro(m, SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006506#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006507#ifdef SO_ERROR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006508 PyModule_AddIntMacro(m, SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006509#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006510#ifdef SO_TYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006511 PyModule_AddIntMacro(m, SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006512#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006513#ifdef SO_SETFIB
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006514 PyModule_AddIntMacro(m, SO_SETFIB);
Larry Hastingsf0f37952010-04-02 11:47:10 +00006515#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006516#ifdef SO_PASSCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006517 PyModule_AddIntMacro(m, SO_PASSCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006518#endif
6519#ifdef SO_PEERCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006520 PyModule_AddIntMacro(m, SO_PEERCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006521#endif
6522#ifdef LOCAL_PEERCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006523 PyModule_AddIntMacro(m, LOCAL_PEERCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006524#endif
Victor Stinnercb98bed2011-10-25 13:45:48 +02006525#ifdef SO_BINDTODEVICE
6526 PyModule_AddIntMacro(m, SO_BINDTODEVICE);
6527#endif
Benjamin Peterson1314ef72013-11-27 09:18:54 -06006528#ifdef SO_PRIORITY
6529 PyModule_AddIntMacro(m, SO_PRIORITY);
6530#endif
Charles-François Nataliea07eb92014-09-18 23:18:46 +01006531#ifdef SO_MARK
6532 PyModule_AddIntMacro(m, SO_MARK);
6533#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006535 /* Maximum number of connections for "listen" */
6536#ifdef SOMAXCONN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006537 PyModule_AddIntMacro(m, SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006538#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006539 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006540#endif
6541
Martin Panter0be894b2016-09-07 12:03:06 +00006542 /* Ancillary message types */
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006543#ifdef SCM_RIGHTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006544 PyModule_AddIntMacro(m, SCM_RIGHTS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006545#endif
6546#ifdef SCM_CREDENTIALS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006547 PyModule_AddIntMacro(m, SCM_CREDENTIALS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006548#endif
6549#ifdef SCM_CREDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006550 PyModule_AddIntMacro(m, SCM_CREDS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006551#endif
6552
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006553 /* Flags for send, recv */
6554#ifdef MSG_OOB
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006555 PyModule_AddIntMacro(m, MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006556#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006557#ifdef MSG_PEEK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006558 PyModule_AddIntMacro(m, MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006559#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006560#ifdef MSG_DONTROUTE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006561 PyModule_AddIntMacro(m, MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006562#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006563#ifdef MSG_DONTWAIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006564 PyModule_AddIntMacro(m, MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00006565#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006566#ifdef MSG_EOR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006567 PyModule_AddIntMacro(m, MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006568#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006569#ifdef MSG_TRUNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006570 PyModule_AddIntMacro(m, MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006571#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006572#ifdef MSG_CTRUNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006573 PyModule_AddIntMacro(m, MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006574#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006575#ifdef MSG_WAITALL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006576 PyModule_AddIntMacro(m, MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006577#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006578#ifdef MSG_BTAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006579 PyModule_AddIntMacro(m, MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006580#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006581#ifdef MSG_ETAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006582 PyModule_AddIntMacro(m, MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006583#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006584#ifdef MSG_NOSIGNAL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006585 PyModule_AddIntMacro(m, MSG_NOSIGNAL);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006586#endif
6587#ifdef MSG_NOTIFICATION
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006588 PyModule_AddIntMacro(m, MSG_NOTIFICATION);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006589#endif
6590#ifdef MSG_CMSG_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006591 PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006592#endif
6593#ifdef MSG_ERRQUEUE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006594 PyModule_AddIntMacro(m, MSG_ERRQUEUE);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006595#endif
6596#ifdef MSG_CONFIRM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006597 PyModule_AddIntMacro(m, MSG_CONFIRM);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006598#endif
6599#ifdef MSG_MORE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006600 PyModule_AddIntMacro(m, MSG_MORE);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006601#endif
6602#ifdef MSG_EOF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006603 PyModule_AddIntMacro(m, MSG_EOF);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006604#endif
6605#ifdef MSG_BCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006606 PyModule_AddIntMacro(m, MSG_BCAST);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006607#endif
6608#ifdef MSG_MCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006609 PyModule_AddIntMacro(m, MSG_MCAST);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006610#endif
Benjamin Peterson57b66722012-12-12 22:24:47 -05006611#ifdef MSG_FASTOPEN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006612 PyModule_AddIntMacro(m, MSG_FASTOPEN);
Benjamin Peterson57b66722012-12-12 22:24:47 -05006613#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006614
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006615 /* Protocol level and numbers, usable for [gs]etsockopt */
6616#ifdef SOL_SOCKET
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006617 PyModule_AddIntMacro(m, SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006618#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006619#ifdef SOL_IP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006620 PyModule_AddIntMacro(m, SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00006621#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006622 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00006623#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006624#ifdef SOL_IPX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006625 PyModule_AddIntMacro(m, SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00006626#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006627#ifdef SOL_AX25
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006628 PyModule_AddIntMacro(m, SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00006629#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006630#ifdef SOL_ATALK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006631 PyModule_AddIntMacro(m, SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00006632#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006633#ifdef SOL_NETROM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006634 PyModule_AddIntMacro(m, SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00006635#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006636#ifdef SOL_ROSE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006637 PyModule_AddIntMacro(m, SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006638#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006639#ifdef SOL_TCP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006640 PyModule_AddIntMacro(m, SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00006641#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006642 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00006643#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006644#ifdef SOL_UDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006645 PyModule_AddIntMacro(m, SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00006646#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006647 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00006648#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02006649#ifdef SOL_CAN_BASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006650 PyModule_AddIntMacro(m, SOL_CAN_BASE);
Charles-François Natali47413c12011-10-06 19:47:44 +02006651#endif
6652#ifdef SOL_CAN_RAW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006653 PyModule_AddIntMacro(m, SOL_CAN_RAW);
6654 PyModule_AddIntMacro(m, CAN_RAW);
Charles-François Natali47413c12011-10-06 19:47:44 +02006655#endif
6656#ifdef HAVE_LINUX_CAN_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006657 PyModule_AddIntMacro(m, CAN_EFF_FLAG);
6658 PyModule_AddIntMacro(m, CAN_RTR_FLAG);
6659 PyModule_AddIntMacro(m, CAN_ERR_FLAG);
Charles-François Natali47413c12011-10-06 19:47:44 +02006660
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006661 PyModule_AddIntMacro(m, CAN_SFF_MASK);
6662 PyModule_AddIntMacro(m, CAN_EFF_MASK);
6663 PyModule_AddIntMacro(m, CAN_ERR_MASK);
Charles-François Natali47413c12011-10-06 19:47:44 +02006664#endif
6665#ifdef HAVE_LINUX_CAN_RAW_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006666 PyModule_AddIntMacro(m, CAN_RAW_FILTER);
6667 PyModule_AddIntMacro(m, CAN_RAW_ERR_FILTER);
6668 PyModule_AddIntMacro(m, CAN_RAW_LOOPBACK);
6669 PyModule_AddIntMacro(m, CAN_RAW_RECV_OWN_MSGS);
Charles-François Natali47413c12011-10-06 19:47:44 +02006670#endif
Larry Hastingsa6cc5512015-04-13 17:48:40 -04006671#ifdef HAVE_LINUX_CAN_RAW_FD_FRAMES
6672 PyModule_AddIntMacro(m, CAN_RAW_FD_FRAMES);
6673#endif
Charles-François Natali773e42d2013-02-05 19:42:01 +01006674#ifdef HAVE_LINUX_CAN_BCM_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006675 PyModule_AddIntMacro(m, CAN_BCM);
Charles-François Natali773e42d2013-02-05 19:42:01 +01006676 PyModule_AddIntConstant(m, "CAN_BCM_TX_SETUP", TX_SETUP);
6677 PyModule_AddIntConstant(m, "CAN_BCM_TX_DELETE", TX_DELETE);
6678 PyModule_AddIntConstant(m, "CAN_BCM_TX_READ", TX_READ);
6679 PyModule_AddIntConstant(m, "CAN_BCM_TX_SEND", TX_SEND);
6680 PyModule_AddIntConstant(m, "CAN_BCM_RX_SETUP", RX_SETUP);
6681 PyModule_AddIntConstant(m, "CAN_BCM_RX_DELETE", RX_DELETE);
6682 PyModule_AddIntConstant(m, "CAN_BCM_RX_READ", RX_READ);
6683 PyModule_AddIntConstant(m, "CAN_BCM_TX_STATUS", TX_STATUS);
6684 PyModule_AddIntConstant(m, "CAN_BCM_TX_EXPIRED", TX_EXPIRED);
6685 PyModule_AddIntConstant(m, "CAN_BCM_RX_STATUS", RX_STATUS);
6686 PyModule_AddIntConstant(m, "CAN_BCM_RX_TIMEOUT", RX_TIMEOUT);
6687 PyModule_AddIntConstant(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
6688#endif
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006689#ifdef SOL_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006690 PyModule_AddIntMacro(m, SOL_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006691#endif
6692#ifdef RDS_CANCEL_SENT_TO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006693 PyModule_AddIntMacro(m, RDS_CANCEL_SENT_TO);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006694#endif
6695#ifdef RDS_GET_MR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006696 PyModule_AddIntMacro(m, RDS_GET_MR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006697#endif
6698#ifdef RDS_FREE_MR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006699 PyModule_AddIntMacro(m, RDS_FREE_MR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006700#endif
6701#ifdef RDS_RECVERR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006702 PyModule_AddIntMacro(m, RDS_RECVERR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006703#endif
6704#ifdef RDS_CONG_MONITOR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006705 PyModule_AddIntMacro(m, RDS_CONG_MONITOR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006706#endif
6707#ifdef RDS_GET_MR_FOR_DEST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006708 PyModule_AddIntMacro(m, RDS_GET_MR_FOR_DEST);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006709#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006710#ifdef IPPROTO_IP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006711 PyModule_AddIntMacro(m, IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00006712#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006713 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006714#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006715#ifdef IPPROTO_HOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006716 PyModule_AddIntMacro(m, IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006717#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006718#ifdef IPPROTO_ICMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006719 PyModule_AddIntMacro(m, IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00006720#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006721 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006722#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006723#ifdef IPPROTO_IGMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006724 PyModule_AddIntMacro(m, IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006725#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006726#ifdef IPPROTO_GGP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006727 PyModule_AddIntMacro(m, IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006728#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006729#ifdef IPPROTO_IPV4
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006730 PyModule_AddIntMacro(m, IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006731#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006732#ifdef IPPROTO_IPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006733 PyModule_AddIntMacro(m, IPPROTO_IPV6);
Martin v. Löwisa0f17342003-10-03 13:56:20 +00006734#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006735#ifdef IPPROTO_IPIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006736 PyModule_AddIntMacro(m, IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006737#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006738#ifdef IPPROTO_TCP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006739 PyModule_AddIntMacro(m, IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00006740#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006741 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006742#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006743#ifdef IPPROTO_EGP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006744 PyModule_AddIntMacro(m, IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006745#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006746#ifdef IPPROTO_PUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006747 PyModule_AddIntMacro(m, IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006748#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006749#ifdef IPPROTO_UDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006750 PyModule_AddIntMacro(m, IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00006751#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006752 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006753#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006754#ifdef IPPROTO_IDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006755 PyModule_AddIntMacro(m, IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006756#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006757#ifdef IPPROTO_HELLO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006758 PyModule_AddIntMacro(m, IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006759#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006760#ifdef IPPROTO_ND
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006761 PyModule_AddIntMacro(m, IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006762#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006763#ifdef IPPROTO_TP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006764 PyModule_AddIntMacro(m, IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006765#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006766#ifdef IPPROTO_IPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006767 PyModule_AddIntMacro(m, IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006768#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006769#ifdef IPPROTO_ROUTING
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006770 PyModule_AddIntMacro(m, IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006771#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006772#ifdef IPPROTO_FRAGMENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006773 PyModule_AddIntMacro(m, IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006774#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006775#ifdef IPPROTO_RSVP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006776 PyModule_AddIntMacro(m, IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006777#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006778#ifdef IPPROTO_GRE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006779 PyModule_AddIntMacro(m, IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006780#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006781#ifdef IPPROTO_ESP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006782 PyModule_AddIntMacro(m, IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006783#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006784#ifdef IPPROTO_AH
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006785 PyModule_AddIntMacro(m, IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006786#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006787#ifdef IPPROTO_MOBILE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006788 PyModule_AddIntMacro(m, IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006789#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006790#ifdef IPPROTO_ICMPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006791 PyModule_AddIntMacro(m, IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006792#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006793#ifdef IPPROTO_NONE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006794 PyModule_AddIntMacro(m, IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006795#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006796#ifdef IPPROTO_DSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006797 PyModule_AddIntMacro(m, IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006798#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006799#ifdef IPPROTO_XTP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006800 PyModule_AddIntMacro(m, IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006801#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006802#ifdef IPPROTO_EON
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006803 PyModule_AddIntMacro(m, IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006804#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006805#ifdef IPPROTO_PIM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006806 PyModule_AddIntMacro(m, IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006807#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006808#ifdef IPPROTO_IPCOMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006809 PyModule_AddIntMacro(m, IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006810#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006811#ifdef IPPROTO_VRRP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006812 PyModule_AddIntMacro(m, IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006813#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006814#ifdef IPPROTO_SCTP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006815 PyModule_AddIntMacro(m, IPPROTO_SCTP);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006816#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006817#ifdef IPPROTO_BIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006818 PyModule_AddIntMacro(m, IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006819#endif
6820/**/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006821#ifdef IPPROTO_RAW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006822 PyModule_AddIntMacro(m, IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00006823#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006824 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006825#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006826#ifdef IPPROTO_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006827 PyModule_AddIntMacro(m, IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006828#endif
6829
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006830#ifdef SYSPROTO_CONTROL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006831 PyModule_AddIntMacro(m, SYSPROTO_CONTROL);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006832#endif
6833
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006834 /* Some port configuration */
6835#ifdef IPPORT_RESERVED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006836 PyModule_AddIntMacro(m, IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006837#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006838 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006839#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006840#ifdef IPPORT_USERRESERVED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006841 PyModule_AddIntMacro(m, IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006842#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006843 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006844#endif
6845
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006846 /* Some reserved IP v.4 addresses */
6847#ifdef INADDR_ANY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006848 PyModule_AddIntMacro(m, INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006849#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006850 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006851#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006852#ifdef INADDR_BROADCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006853 PyModule_AddIntMacro(m, INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006854#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006855 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006856#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006857#ifdef INADDR_LOOPBACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006858 PyModule_AddIntMacro(m, INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006859#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006860 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006861#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006862#ifdef INADDR_UNSPEC_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006863 PyModule_AddIntMacro(m, INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006864#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006865 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006866#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006867#ifdef INADDR_ALLHOSTS_GROUP
6868 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
6869 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006870#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006871 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006872#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006873#ifdef INADDR_MAX_LOCAL_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006874 PyModule_AddIntMacro(m, INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006875#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006876 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006877#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006878#ifdef INADDR_NONE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006879 PyModule_AddIntMacro(m, INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006880#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006881 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00006882#endif
6883
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006884 /* IPv4 [gs]etsockopt options */
6885#ifdef IP_OPTIONS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006886 PyModule_AddIntMacro(m, IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006887#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006888#ifdef IP_HDRINCL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006889 PyModule_AddIntMacro(m, IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006890#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006891#ifdef IP_TOS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006892 PyModule_AddIntMacro(m, IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006893#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006894#ifdef IP_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006895 PyModule_AddIntMacro(m, IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006896#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006897#ifdef IP_RECVOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006898 PyModule_AddIntMacro(m, IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006899#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006900#ifdef IP_RECVRETOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006901 PyModule_AddIntMacro(m, IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006902#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006903#ifdef IP_RECVDSTADDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006904 PyModule_AddIntMacro(m, IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006905#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006906#ifdef IP_RETOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006907 PyModule_AddIntMacro(m, IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006908#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006909#ifdef IP_MULTICAST_IF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006910 PyModule_AddIntMacro(m, IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006911#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006912#ifdef IP_MULTICAST_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006913 PyModule_AddIntMacro(m, IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006914#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006915#ifdef IP_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006916 PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006917#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006918#ifdef IP_ADD_MEMBERSHIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006919 PyModule_AddIntMacro(m, IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006920#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006921#ifdef IP_DROP_MEMBERSHIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006922 PyModule_AddIntMacro(m, IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006923#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006924#ifdef IP_DEFAULT_MULTICAST_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006925 PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00006926#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006927#ifdef IP_DEFAULT_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006928 PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00006929#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006930#ifdef IP_MAX_MEMBERSHIPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006931 PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00006932#endif
Charles-François Natali564a42c2011-12-17 14:59:56 +01006933#ifdef IP_TRANSPARENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006934 PyModule_AddIntMacro(m, IP_TRANSPARENT);
Charles-François Natali564a42c2011-12-17 14:59:56 +01006935#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006936
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006937 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
6938#ifdef IPV6_JOIN_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006939 PyModule_AddIntMacro(m, IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006940#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006941#ifdef IPV6_LEAVE_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006942 PyModule_AddIntMacro(m, IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006943#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006944#ifdef IPV6_MULTICAST_HOPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006945 PyModule_AddIntMacro(m, IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006946#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006947#ifdef IPV6_MULTICAST_IF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006948 PyModule_AddIntMacro(m, IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006949#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006950#ifdef IPV6_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006951 PyModule_AddIntMacro(m, IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006952#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006953#ifdef IPV6_UNICAST_HOPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006954 PyModule_AddIntMacro(m, IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006955#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006956 /* Additional IPV6 socket options, defined in RFC 3493 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00006957#ifdef IPV6_V6ONLY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006958 PyModule_AddIntMacro(m, IPV6_V6ONLY);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006959#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006960 /* Advanced IPV6 socket options, from RFC 3542 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00006961#ifdef IPV6_CHECKSUM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006962 PyModule_AddIntMacro(m, IPV6_CHECKSUM);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006963#endif
6964#ifdef IPV6_DONTFRAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006965 PyModule_AddIntMacro(m, IPV6_DONTFRAG);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006966#endif
6967#ifdef IPV6_DSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006968 PyModule_AddIntMacro(m, IPV6_DSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006969#endif
6970#ifdef IPV6_HOPLIMIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006971 PyModule_AddIntMacro(m, IPV6_HOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006972#endif
6973#ifdef IPV6_HOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006974 PyModule_AddIntMacro(m, IPV6_HOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006975#endif
6976#ifdef IPV6_NEXTHOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006977 PyModule_AddIntMacro(m, IPV6_NEXTHOP);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006978#endif
6979#ifdef IPV6_PATHMTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006980 PyModule_AddIntMacro(m, IPV6_PATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006981#endif
6982#ifdef IPV6_PKTINFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006983 PyModule_AddIntMacro(m, IPV6_PKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006984#endif
6985#ifdef IPV6_RECVDSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006986 PyModule_AddIntMacro(m, IPV6_RECVDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006987#endif
6988#ifdef IPV6_RECVHOPLIMIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006989 PyModule_AddIntMacro(m, IPV6_RECVHOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006990#endif
6991#ifdef IPV6_RECVHOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006992 PyModule_AddIntMacro(m, IPV6_RECVHOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006993#endif
6994#ifdef IPV6_RECVPKTINFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006995 PyModule_AddIntMacro(m, IPV6_RECVPKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006996#endif
6997#ifdef IPV6_RECVRTHDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006998 PyModule_AddIntMacro(m, IPV6_RECVRTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006999#endif
7000#ifdef IPV6_RECVTCLASS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007001 PyModule_AddIntMacro(m, IPV6_RECVTCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007002#endif
7003#ifdef IPV6_RTHDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007004 PyModule_AddIntMacro(m, IPV6_RTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007005#endif
7006#ifdef IPV6_RTHDRDSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007007 PyModule_AddIntMacro(m, IPV6_RTHDRDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007008#endif
7009#ifdef IPV6_RTHDR_TYPE_0
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007010 PyModule_AddIntMacro(m, IPV6_RTHDR_TYPE_0);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007011#endif
7012#ifdef IPV6_RECVPATHMTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007013 PyModule_AddIntMacro(m, IPV6_RECVPATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007014#endif
7015#ifdef IPV6_TCLASS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007016 PyModule_AddIntMacro(m, IPV6_TCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007017#endif
7018#ifdef IPV6_USE_MIN_MTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007019 PyModule_AddIntMacro(m, IPV6_USE_MIN_MTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007020#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007022 /* TCP options */
7023#ifdef TCP_NODELAY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007024 PyModule_AddIntMacro(m, TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00007025#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007026#ifdef TCP_MAXSEG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007027 PyModule_AddIntMacro(m, TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00007028#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007029#ifdef TCP_CORK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007030 PyModule_AddIntMacro(m, TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007031#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007032#ifdef TCP_KEEPIDLE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007033 PyModule_AddIntMacro(m, TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007034#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007035#ifdef TCP_KEEPINTVL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007036 PyModule_AddIntMacro(m, TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007037#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007038#ifdef TCP_KEEPCNT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007039 PyModule_AddIntMacro(m, TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007040#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007041#ifdef TCP_SYNCNT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007042 PyModule_AddIntMacro(m, TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007043#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007044#ifdef TCP_LINGER2
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007045 PyModule_AddIntMacro(m, TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007046#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007047#ifdef TCP_DEFER_ACCEPT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007048 PyModule_AddIntMacro(m, TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007049#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007050#ifdef TCP_WINDOW_CLAMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007051 PyModule_AddIntMacro(m, TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007052#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007053#ifdef TCP_INFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007054 PyModule_AddIntMacro(m, TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007055#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007056#ifdef TCP_QUICKACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007057 PyModule_AddIntMacro(m, TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007058#endif
Benjamin Peterson57b66722012-12-12 22:24:47 -05007059#ifdef TCP_FASTOPEN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007060 PyModule_AddIntMacro(m, TCP_FASTOPEN);
Benjamin Peterson57b66722012-12-12 22:24:47 -05007061#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00007062
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007063 /* IPX options */
7064#ifdef IPX_TYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007065 PyModule_AddIntMacro(m, IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00007066#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00007067
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007068/* Reliable Datagram Sockets */
7069#ifdef RDS_CMSG_RDMA_ARGS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007070 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_ARGS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007071#endif
7072#ifdef RDS_CMSG_RDMA_DEST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007073 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_DEST);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007074#endif
7075#ifdef RDS_CMSG_RDMA_MAP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007076 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_MAP);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007077#endif
7078#ifdef RDS_CMSG_RDMA_STATUS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007079 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_STATUS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007080#endif
7081#ifdef RDS_CMSG_RDMA_UPDATE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007082 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_UPDATE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007083#endif
7084#ifdef RDS_RDMA_READWRITE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007085 PyModule_AddIntMacro(m, RDS_RDMA_READWRITE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007086#endif
7087#ifdef RDS_RDMA_FENCE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007088 PyModule_AddIntMacro(m, RDS_RDMA_FENCE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007089#endif
7090#ifdef RDS_RDMA_INVALIDATE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007091 PyModule_AddIntMacro(m, RDS_RDMA_INVALIDATE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007092#endif
7093#ifdef RDS_RDMA_USE_ONCE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007094 PyModule_AddIntMacro(m, RDS_RDMA_USE_ONCE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007095#endif
7096#ifdef RDS_RDMA_DONTWAIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007097 PyModule_AddIntMacro(m, RDS_RDMA_DONTWAIT);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007098#endif
7099#ifdef RDS_RDMA_NOTIFY_ME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007100 PyModule_AddIntMacro(m, RDS_RDMA_NOTIFY_ME);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007101#endif
7102#ifdef RDS_RDMA_SILENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007103 PyModule_AddIntMacro(m, RDS_RDMA_SILENT);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007104#endif
7105
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007106 /* get{addr,name}info parameters */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007107#ifdef EAI_ADDRFAMILY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007108 PyModule_AddIntMacro(m, EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007109#endif
7110#ifdef EAI_AGAIN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007111 PyModule_AddIntMacro(m, EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007112#endif
7113#ifdef EAI_BADFLAGS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007114 PyModule_AddIntMacro(m, EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007115#endif
7116#ifdef EAI_FAIL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007117 PyModule_AddIntMacro(m, EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007118#endif
7119#ifdef EAI_FAMILY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007120 PyModule_AddIntMacro(m, EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007121#endif
7122#ifdef EAI_MEMORY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007123 PyModule_AddIntMacro(m, EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007124#endif
7125#ifdef EAI_NODATA
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007126 PyModule_AddIntMacro(m, EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007127#endif
7128#ifdef EAI_NONAME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007129 PyModule_AddIntMacro(m, EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007130#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00007131#ifdef EAI_OVERFLOW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007132 PyModule_AddIntMacro(m, EAI_OVERFLOW);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007133#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007134#ifdef EAI_SERVICE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007135 PyModule_AddIntMacro(m, EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007136#endif
7137#ifdef EAI_SOCKTYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007138 PyModule_AddIntMacro(m, EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007139#endif
7140#ifdef EAI_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007141 PyModule_AddIntMacro(m, EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007142#endif
7143#ifdef EAI_BADHINTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007144 PyModule_AddIntMacro(m, EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007145#endif
7146#ifdef EAI_PROTOCOL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007147 PyModule_AddIntMacro(m, EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007148#endif
7149#ifdef EAI_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007150 PyModule_AddIntMacro(m, EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007151#endif
7152#ifdef AI_PASSIVE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007153 PyModule_AddIntMacro(m, AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007154#endif
7155#ifdef AI_CANONNAME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007156 PyModule_AddIntMacro(m, AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007157#endif
7158#ifdef AI_NUMERICHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007159 PyModule_AddIntMacro(m, AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007160#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00007161#ifdef AI_NUMERICSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007162 PyModule_AddIntMacro(m, AI_NUMERICSERV);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007163#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007164#ifdef AI_MASK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007165 PyModule_AddIntMacro(m, AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007166#endif
7167#ifdef AI_ALL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007168 PyModule_AddIntMacro(m, AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007169#endif
7170#ifdef AI_V4MAPPED_CFG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007171 PyModule_AddIntMacro(m, AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007172#endif
7173#ifdef AI_ADDRCONFIG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007174 PyModule_AddIntMacro(m, AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007175#endif
7176#ifdef AI_V4MAPPED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007177 PyModule_AddIntMacro(m, AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007178#endif
7179#ifdef AI_DEFAULT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007180 PyModule_AddIntMacro(m, AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007181#endif
7182#ifdef NI_MAXHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007183 PyModule_AddIntMacro(m, NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007184#endif
7185#ifdef NI_MAXSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007186 PyModule_AddIntMacro(m, NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007187#endif
7188#ifdef NI_NOFQDN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007189 PyModule_AddIntMacro(m, NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007190#endif
7191#ifdef NI_NUMERICHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007192 PyModule_AddIntMacro(m, NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007193#endif
7194#ifdef NI_NAMEREQD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007195 PyModule_AddIntMacro(m, NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007196#endif
7197#ifdef NI_NUMERICSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007198 PyModule_AddIntMacro(m, NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007199#endif
7200#ifdef NI_DGRAM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007201 PyModule_AddIntMacro(m, NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007202#endif
7203
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007204 /* shutdown() parameters */
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007205#ifdef SHUT_RD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007206 PyModule_AddIntMacro(m, SHUT_RD);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007207#elif defined(SD_RECEIVE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007208 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007209#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007210 PyModule_AddIntConstant(m, "SHUT_RD", 0);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007211#endif
7212#ifdef SHUT_WR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007213 PyModule_AddIntMacro(m, SHUT_WR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007214#elif defined(SD_SEND)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007215 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007216#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007217 PyModule_AddIntConstant(m, "SHUT_WR", 1);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007218#endif
7219#ifdef SHUT_RDWR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007220 PyModule_AddIntMacro(m, SHUT_RDWR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007221#elif defined(SD_BOTH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007222 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007223#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007224 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007225#endif
7226
Christian Heimesfaf2f632008-01-06 16:59:19 +00007227#ifdef SIO_RCVALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007228 {
7229 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
7230 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
7231 int i;
Victor Stinner63941882011-09-29 00:42:28 +02007232 for(i = 0; i<Py_ARRAY_LENGTH(codes); ++i) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007233 PyObject *tmp;
7234 tmp = PyLong_FromUnsignedLong(codes[i]);
7235 if (tmp == NULL)
7236 return NULL;
7237 PyModule_AddObject(m, names[i], tmp);
7238 }
7239 }
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007240 PyModule_AddIntMacro(m, RCVALL_OFF);
7241 PyModule_AddIntMacro(m, RCVALL_ON);
7242 PyModule_AddIntMacro(m, RCVALL_SOCKETLEVELONLY);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007243#ifdef RCVALL_IPLEVEL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007244 PyModule_AddIntMacro(m, RCVALL_IPLEVEL);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007245#endif
7246#ifdef RCVALL_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007247 PyModule_AddIntMacro(m, RCVALL_MAX);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007248#endif
Christian Heimesfaf2f632008-01-06 16:59:19 +00007249#endif /* _MSTCPIP_ */
7250
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007251 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00007252#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007253 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00007254#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007255 return m;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00007256}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007257
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007258
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007259#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +00007260#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007261
7262/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00007263/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007264
Guido van Rossum3eede5a2002-06-07 02:08:35 +00007265int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007266inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007267{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007268 if (af == AF_INET) {
Benjamin Petersonf91df042009-02-13 02:50:59 +00007269#if (SIZEOF_INT != 4)
7270#error "Not sure if in_addr_t exists and int is not 32-bits."
7271#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007272 unsigned int packed_addr;
7273 packed_addr = inet_addr(src);
7274 if (packed_addr == INADDR_NONE)
7275 return 0;
7276 memcpy(dst, &packed_addr, 4);
7277 return 1;
7278 }
7279 /* Should set errno to EAFNOSUPPORT */
7280 return -1;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007281}
7282
Martin v. Löwisc925b1532001-07-21 09:42:15 +00007283const char *
7284inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007285{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007286 if (af == AF_INET) {
7287 struct in_addr packed_addr;
7288 if (size < 16)
7289 /* Should set errno to ENOSPC. */
7290 return NULL;
7291 memcpy(&packed_addr, src, sizeof(packed_addr));
7292 return strncpy(dst, inet_ntoa(packed_addr), size);
7293 }
7294 /* Should set errno to EAFNOSUPPORT */
7295 return NULL;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007296}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007297
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007298#endif
Christian Heimesb6150692007-11-15 23:37:07 +00007299#endif