blob: 2620d5673bd37963740030d713a75ba3e28cd6fb [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\
Christian Heimesdffa3942016-09-05 23:54:41 +0200139setsockopt(level, optname, value[, optlen]) -- set socket options\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000140settimeout(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
Benjamin Petersonb6c34582016-09-07 14:08:34 -0700156#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
Stefan Krah1f9eb872016-05-22 17:35:34 +0200166#if !defined(WITH_THREAD)
167# undef HAVE_GETHOSTBYNAME_R
168#endif
169
170#if defined(__ANDROID__) && __ANDROID_API__ < 23
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000171# undef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +0000172#endif
173
Guido van Rossume7de2061999-03-24 17:24:33 +0000174#ifdef HAVE_GETHOSTBYNAME_R
Jesus Cea736e7fc2011-03-14 17:36:54 +0100175# if defined(_AIX)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000176# define HAVE_GETHOSTBYNAME_R_3_ARG
177# elif defined(__sun) || defined(__sgi)
178# define HAVE_GETHOSTBYNAME_R_5_ARG
Benjamin Petersonb6c34582016-09-07 14:08:34 -0700179# elif defined(__linux__)
Guido van Rossum9376b741999-09-15 22:01:40 +0000180/* Rely on the configure script */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000181# else
182# undef HAVE_GETHOSTBYNAME_R
183# endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000184#endif
185
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000186#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
187 !defined(MS_WINDOWS)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000188# define USE_GETHOSTBYNAME_LOCK
Guido van Rossum3baaa131999-03-22 21:44:51 +0000189#endif
190
Ned Deilye1d4e582016-02-23 22:05:29 +1100191/* To use __FreeBSD_version, __OpenBSD__, and __NetBSD_Version__ */
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000192#ifdef HAVE_SYS_PARAM_H
193#include <sys/param.h>
194#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000195/* On systems on which getaddrinfo() is believed to not be thread-safe,
Ned Deily47299fd2016-02-15 16:54:08 +1100196 (this includes the getaddrinfo emulation) protect access with a lock.
197
198 getaddrinfo is thread-safe on Mac OS X 10.5 and later. Originally it was
199 a mix of code including an unsafe implementation from an old BSD's
200 libresolv. In 10.5 Apple reimplemented it as a safe IPC call to the
201 mDNSResponder process. 10.5 is the first be UNIX '03 certified, which
Ned Deilye1d4e582016-02-23 22:05:29 +1100202 includes the requirement that getaddrinfo be thread-safe. See issue #25924.
Ned Deily47299fd2016-02-15 16:54:08 +1100203
Ned Deilye1d4e582016-02-23 22:05:29 +1100204 It's thread-safe in OpenBSD starting with 5.4, released Nov 2013:
205 http://www.openbsd.org/plus54.html
206
207 It's thread-safe in NetBSD starting with 4.0, released Dec 2007:
208
209http://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 +1100210 */
211#if defined(WITH_THREAD) && ( \
212 (defined(__APPLE__) && \
213 MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5) || \
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000214 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
Ned Deilye1d4e582016-02-23 22:05:29 +1100215 (defined(__OpenBSD__) && OpenBSD+0 < 201311) || \
216 (defined(__NetBSD__) && __NetBSD_Version__+0 < 400000000) || \
Christian Heimesaf01f662013-12-21 16:19:10 +0100217 !defined(HAVE_GETADDRINFO))
Just van Rossum1040d2c2003-05-09 07:53:18 +0000218#define USE_GETADDRINFO_LOCK
219#endif
220
221#ifdef USE_GETADDRINFO_LOCK
222#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
223#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
224#else
225#define ACQUIRE_GETADDRINFO_LOCK
226#define RELEASE_GETADDRINFO_LOCK
227#endif
228
229#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000230# include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000231#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000232
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000233#if defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000234# include <types.h>
235# include <io.h>
236# include <sys/ioctl.h>
237# include <utils.h>
238# include <ctype.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000239#endif
240
Martin v. Löwis9d6c6692012-02-03 17:44:58 +0100241#ifdef __APPLE__
242# include <sys/ioctl.h>
243#endif
244
245
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000246#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000247/* make sure that the reentrant (gethostbyaddr_r etc)
248 functions are declared correctly if compiling with
249 MIPSPro 7.x in ANSI C mode (default) */
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000250
Thomas Wouters477c8d52006-05-27 19:21:47 +0000251/* XXX Using _SGIAPI is the wrong thing,
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000252 but I don't know what the right thing is. */
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000253#undef _SGIAPI /* to avoid warning */
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000254#define _SGIAPI 1
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000255
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000256#undef _XOPEN_SOURCE
257#include <sys/socket.h>
258#include <sys/types.h>
259#include <netinet/in.h>
260#ifdef _SS_ALIGNSIZE
261#define HAVE_GETADDRINFO 1
262#define HAVE_GETNAMEINFO 1
263#endif
264
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000265#define HAVE_INET_PTON
266#include <netdb.h>
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000267#endif
268
Thomas Wouters477c8d52006-05-27 19:21:47 +0000269/* Irix 6.5 fails to define this variable at all. This is needed
270 for both GCC and SGI's compiler. I'd say that the SGI headers
Georg Brandldbd83392006-02-20 09:42:33 +0000271 are just busted. Same thing for Solaris. */
272#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000273#define INET_ADDRSTRLEN 16
274#endif
275
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000276/* Generic includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000277#ifdef HAVE_SYS_TYPES_H
Guido van Rossumb6775db1994-08-01 11:34:53 +0000278#include <sys/types.h>
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000279#endif
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000280
Gregory P. Smith3b1f2c32011-05-15 12:18:23 -0700281#ifdef HAVE_SYS_SOCKET_H
282#include <sys/socket.h>
283#endif
284
285#ifdef HAVE_NET_IF_H
286#include <net/if.h>
287#endif
288
Christian Heimesdffa3942016-09-05 23:54:41 +0200289#ifdef HAVE_SOCKADDR_ALG
290#include <linux/if_alg.h>
291#ifndef AF_ALG
292#define AF_ALG 38
293#endif
294#ifndef SOL_ALG
295#define SOL_ALG 279
296#endif
297
298/* Linux 3.19 */
299#ifndef ALG_SET_AEAD_ASSOCLEN
300#define ALG_SET_AEAD_ASSOCLEN 4
301#endif
302#ifndef ALG_SET_AEAD_AUTHSIZE
303#define ALG_SET_AEAD_AUTHSIZE 5
304#endif
305/* Linux 4.8 */
306#ifndef ALG_SET_PUBKEY
307#define ALG_SET_PUBKEY 6
308#endif
309
310#ifndef ALG_OP_SIGN
311#define ALG_OP_SIGN 2
312#endif
313#ifndef ALG_OP_VERIFY
314#define ALG_OP_VERIFY 3
315#endif
316
317#endif /* HAVE_SOCKADDR_ALG */
318
Marc-André Lemburg976ade62002-02-16 18:47:07 +0000319/* Generic socket object definitions and includes */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000320#define PySocket_BUILDING_SOCKET
Marc-André Lemburgbb8b78b2002-02-16 18:44:52 +0000321#include "socketmodule.h"
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000322
323/* Addressing includes */
324
Guido van Rossum6f489d91996-06-28 20:15:15 +0000325#ifndef MS_WINDOWS
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000326
327/* Non-MS WINDOWS includes */
328# include <netdb.h>
Nick Coghlan4ecf6cf2011-08-22 15:45:19 +1000329# include <unistd.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000330
Guido van Rossum9376b741999-09-15 22:01:40 +0000331/* Headers needed for inet_ntoa() and inet_addr() */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000332# include <arpa/inet.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000333
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000334# include <fcntl.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000335
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000336#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000337
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000338/* MS_WINDOWS includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000339# ifdef HAVE_FCNTL_H
340# include <fcntl.h>
341# endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000342
Steve Dower65e4cb12014-11-22 12:54:57 -0800343#if defined(_MSC_VER) && _MSC_VER >= 1800
344/* Provides the IsWindows7SP1OrGreater() function */
345#include <VersionHelpers.h>
346#endif
347
Jeremy Hylton22308652001-02-02 03:23:09 +0000348#endif
349
Skip Montanaro7befb992004-02-10 16:50:21 +0000350#include <stddef.h>
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000351
Neal Norwitz39d22e52002-11-02 19:55:21 +0000352#ifndef O_NONBLOCK
353# define O_NONBLOCK O_NDELAY
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000354#endif
355
Trent Micka708d6e2004-09-07 17:48:26 +0000356/* include Python's addrinfo.h unless it causes trouble */
357#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
358 /* Do not include addinfo.h on some newer IRIX versions.
359 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
360 * for example, but not by 6.5.10.
361 */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000362#elif defined(_MSC_VER) && _MSC_VER>1201
Trent Micka708d6e2004-09-07 17:48:26 +0000363 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
364 * EAI_* constants are defined in (the already included) ws2tcpip.h.
365 */
366#else
367# include "addrinfo.h"
368#endif
Jason Tishlerc246cb72004-08-09 13:25:59 +0000369
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000370#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +0000371#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000372int inet_pton(int af, const char *src, void *dst);
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000373const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000374#endif
Christian Heimesb6150692007-11-15 23:37:07 +0000375#endif
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000376
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000377#ifdef __APPLE__
378/* On OS X, getaddrinfo returns no error indication of lookup
379 failure, so we must use the emulation instead of the libinfo
380 implementation. Unfortunately, performing an autoconf test
381 for this bug would require DNS access for the machine performing
382 the configuration, which is not acceptable. Therefore, we
383 determine the bug just by checking for __APPLE__. If this bug
384 gets ever fixed, perhaps checking for sys/version.h would be
385 appropriate, which is 10/0 on the system with the bug. */
Jack Jansen84262fb2002-07-02 14:40:42 +0000386#ifndef HAVE_GETNAMEINFO
387/* This bug seems to be fixed in Jaguar. Ths easiest way I could
388 Find to check for Jaguar is that it has getnameinfo(), which
389 older releases don't have */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000390#undef HAVE_GETADDRINFO
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000391#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000392
393#ifdef HAVE_INET_ATON
394#define USE_INET_ATON_WEAKLINK
395#endif
396
Jack Jansen84262fb2002-07-02 14:40:42 +0000397#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000398
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000399/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000400#if !defined(HAVE_GETADDRINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000401/* avoid clashes with the C library definition of the symbol. */
402#define getaddrinfo fake_getaddrinfo
403#define gai_strerror fake_gai_strerror
404#define freeaddrinfo fake_freeaddrinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000405#include "getaddrinfo.c"
406#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000407#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000408#define getnameinfo fake_getnameinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000409#include "getnameinfo.c"
410#endif
411
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000412#ifdef MS_WINDOWS
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000413#define SOCKETCLOSE closesocket
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000414#endif
415
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000416#ifdef MS_WIN32
Kristján Valur Jónsson310052c2012-03-31 13:35:00 +0000417#undef EAFNOSUPPORT
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000418#define EAFNOSUPPORT WSAEAFNOSUPPORT
419#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000420#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000421
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000422#ifndef SOCKETCLOSE
423#define SOCKETCLOSE close
424#endif
425
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000426#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000427#define USE_BLUETOOTH 1
428#if defined(__FreeBSD__)
429#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
430#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
Thomas Wouterscf297e42007-02-23 15:07:44 +0000431#define BTPROTO_HCI BLUETOOTH_PROTO_HCI
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000432#define SOL_HCI SOL_HCI_RAW
433#define HCI_FILTER SO_HCI_RAW_FILTER
Hye-Shik Chang81268602004-02-02 06:05:24 +0000434#define sockaddr_l2 sockaddr_l2cap
435#define sockaddr_rc sockaddr_rfcomm
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000436#define hci_dev hci_node
Hye-Shik Chang81268602004-02-02 06:05:24 +0000437#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
438#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000439#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000440#elif defined(__NetBSD__) || defined(__DragonFly__)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000441#define sockaddr_l2 sockaddr_bt
442#define sockaddr_rc sockaddr_bt
Thomas Wouterscf297e42007-02-23 15:07:44 +0000443#define sockaddr_hci sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000444#define sockaddr_sco sockaddr_bt
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000445#define SOL_HCI BTPROTO_HCI
446#define HCI_DATA_DIR SO_HCI_DIRECTION
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000447#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
448#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000449#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000450#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000451#else
Hye-Shik Chang81268602004-02-02 06:05:24 +0000452#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
453#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000454#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000455#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
456#endif
457#endif
458
Charles-François Natali8b759652011-12-23 16:44:51 +0100459/* Convert "sock_addr_t *" to "struct sockaddr *". */
460#define SAS2SA(x) (&((x)->sa))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000461
Martin v. Löwise9416172003-05-03 10:12:45 +0000462/*
463 * Constants for getnameinfo()
464 */
465#if !defined(NI_MAXHOST)
466#define NI_MAXHOST 1025
467#endif
468#if !defined(NI_MAXSERV)
469#define NI_MAXSERV 32
470#endif
471
Guido van Rossum7d0a8262007-05-21 23:13:11 +0000472#ifndef INVALID_SOCKET /* MS defines this */
473#define INVALID_SOCKET (-1)
474#endif
475
Charles-François Natali0cc86852013-09-13 19:53:08 +0200476#ifndef INADDR_NONE
477#define INADDR_NONE (-1)
478#endif
479
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000480/* XXX There's a problem here: *static* functions are not supposed to have
481 a Py prefix (or use CapitalizedWords). Later... */
482
Guido van Rossum30a685f1991-06-27 15:51:29 +0000483/* Global variable holding the exception type for errors detected
484 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000485static PyObject *socket_herror;
486static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000487static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000488
Tim Peters643a7fc2002-02-17 04:13:21 +0000489/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000490 The sock_type variable contains pointers to various functions,
491 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000492 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000493static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000494
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000495#if defined(HAVE_POLL_H)
496#include <poll.h>
497#elif defined(HAVE_SYS_POLL_H)
498#include <sys/poll.h>
499#endif
500
Nick Coghlan96fe56a2011-08-22 11:55:57 +1000501/* Largest value to try to store in a socklen_t (used when handling
502 ancillary data). POSIX requires socklen_t to hold at least
503 (2**31)-1 and recommends against storing larger values, but
504 socklen_t was originally int in the BSD interface, so to be on the
505 safe side we use the smaller of (2**31)-1 and INT_MAX. */
506#if INT_MAX > 0x7fffffff
507#define SOCKLEN_T_LIMIT 0x7fffffff
508#else
509#define SOCKLEN_T_LIMIT INT_MAX
510#endif
511
Charles-François Nataliaa26b272011-08-28 17:51:43 +0200512#ifdef HAVE_POLL
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000513/* Instead of select(), we'll use poll() since poll() works on any fd. */
514#define IS_SELECTABLE(s) 1
515/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000516#else
Charles-François Nataliaa26b272011-08-28 17:51:43 +0200517/* If there's no timeout left, we don't have to call select, so it's a safe,
518 * little white lie. */
Victor Stinner71694d52015-03-28 01:18:54 +0100519#define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000520#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000521
522static PyObject*
523select_error(void)
524{
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200525 PyErr_SetString(PyExc_OSError, "unable to select on socket");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000526 return NULL;
Neal Norwitz082b2df2006-02-07 07:04:46 +0000527}
528
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000529#ifdef MS_WINDOWS
Antoine Pitrouc8f01962010-09-28 22:03:27 +0000530#ifndef WSAEAGAIN
531#define WSAEAGAIN WSAEWOULDBLOCK
532#endif
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000533#define CHECK_ERRNO(expected) \
534 (WSAGetLastError() == WSA ## expected)
535#else
536#define CHECK_ERRNO(expected) \
537 (errno == expected)
538#endif
539
Victor Stinnerdaf45552013-08-28 00:53:59 +0200540#ifdef MS_WINDOWS
Victor Stinner81c41db2015-04-02 11:50:57 +0200541# define GET_SOCK_ERROR WSAGetLastError()
542# define SET_SOCK_ERROR(err) WSASetLastError(err)
543# define SOCK_TIMEOUT_ERR WSAEWOULDBLOCK
544# define SOCK_INPROGRESS_ERR WSAEWOULDBLOCK
545#else
546# define GET_SOCK_ERROR errno
547# define SET_SOCK_ERROR(err) do { errno = err; } while (0)
548# define SOCK_TIMEOUT_ERR EWOULDBLOCK
549# define SOCK_INPROGRESS_ERR EINPROGRESS
550#endif
551
552
553#ifdef MS_WINDOWS
Victor Stinnerdaf45552013-08-28 00:53:59 +0200554/* Does WSASocket() support the WSA_FLAG_NO_HANDLE_INHERIT flag? */
555static int support_wsa_no_inherit = -1;
556#endif
557
Guido van Rossum30a685f1991-06-27 15:51:29 +0000558/* Convenience function to raise an error according to errno
559 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000560
Guido van Rossum73624e91994-10-10 17:59:00 +0000561static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000562set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000563{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000564#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000565 int err_no = WSAGetLastError();
566 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
567 recognizes the error codes used by both GetLastError() and
568 WSAGetLastError */
569 if (err_no)
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200570 return PyErr_SetExcFromWindowsErr(PyExc_OSError, err_no);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000571#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000572
Antoine Pitrou6b4883d2011-10-12 02:54:14 +0200573 return PyErr_SetFromErrno(PyExc_OSError);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000574}
575
Guido van Rossum30a685f1991-06-27 15:51:29 +0000576
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000577static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000578set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000579{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000580 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000581
582#ifdef HAVE_HSTRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000583 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000584#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000585 v = Py_BuildValue("(is)", h_error, "host not found");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000586#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000587 if (v != NULL) {
588 PyErr_SetObject(socket_herror, v);
589 Py_DECREF(v);
590 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000591
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000592 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000593}
594
595
596static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000597set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000598{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000599 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000600
Martin v. Löwis272cb402002-03-01 08:31:07 +0000601#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000602 /* EAI_SYSTEM is not available on Windows XP. */
603 if (error == EAI_SYSTEM)
604 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000605#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000606
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000607#ifdef HAVE_GAI_STRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000608 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000609#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000610 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000611#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000612 if (v != NULL) {
613 PyErr_SetObject(socket_gaierror, v);
614 Py_DECREF(v);
615 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000616
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000617 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000618}
619
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000620/* Function to perform the setting of socket blocking mode
621 internally. block = (1 | 0). */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000622static int
623internal_setblocking(PySocketSockObject *s, int block)
624{
Yury Selivanovfa22b292016-10-18 16:03:52 -0400625 int result = -1;
Victor Stinnerb6dab6b2014-07-23 22:56:55 +0200626#ifdef MS_WINDOWS
627 u_long arg;
628#endif
Victor Stinner9a954832013-12-04 00:41:24 +0100629#if !defined(MS_WINDOWS) \
Christian Heimesaf01f662013-12-21 16:19:10 +0100630 && !((defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO)))
Victor Stinner9a954832013-12-04 00:41:24 +0100631 int delay_flag, new_delay_flag;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000632#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +0000633#ifdef SOCK_NONBLOCK
634 if (block)
635 s->sock_type &= (~SOCK_NONBLOCK);
636 else
637 s->sock_type |= SOCK_NONBLOCK;
638#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000640 Py_BEGIN_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000641#ifndef MS_WINDOWS
Christian Heimesaf01f662013-12-21 16:19:10 +0100642#if (defined(HAVE_SYS_IOCTL_H) && defined(FIONBIO))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000643 block = !block;
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200644 if (ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block) == -1)
Yury Selivanovfa22b292016-10-18 16:03:52 -0400645 goto done;
Victor Stinner9a954832013-12-04 00:41:24 +0100646#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000647 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200648 if (delay_flag == -1)
Yury Selivanovfa22b292016-10-18 16:03:52 -0400649 goto done;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000650 if (block)
Victor Stinner9a954832013-12-04 00:41:24 +0100651 new_delay_flag = delay_flag & (~O_NONBLOCK);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000652 else
Victor Stinner9a954832013-12-04 00:41:24 +0100653 new_delay_flag = delay_flag | O_NONBLOCK;
654 if (new_delay_flag != delay_flag)
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200655 if (fcntl(s->sock_fd, F_SETFL, new_delay_flag) == -1)
Yury Selivanovfa22b292016-10-18 16:03:52 -0400656 goto done;
Victor Stinner9a954832013-12-04 00:41:24 +0100657#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000658#else /* MS_WINDOWS */
Victor Stinnerb6dab6b2014-07-23 22:56:55 +0200659 arg = !block;
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200660 if (ioctlsocket(s->sock_fd, FIONBIO, &arg) != 0)
Yury Selivanovfa22b292016-10-18 16:03:52 -0400661 goto done;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000662#endif /* MS_WINDOWS */
Yury Selivanovfa22b292016-10-18 16:03:52 -0400663
664 result = 0;
665
666 done:
Martin Panterfa27d5f2016-10-20 00:48:23 +0000667 ; /* necessary for --without-threads flag */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000668 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000669
Yury Selivanovfa22b292016-10-18 16:03:52 -0400670 if (result) {
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200671#ifndef MS_WINDOWS
Yury Selivanovfa22b292016-10-18 16:03:52 -0400672 PyErr_SetFromErrno(PyExc_OSError);
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200673#else
Yury Selivanovfa22b292016-10-18 16:03:52 -0400674 PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200675#endif
Yury Selivanovfa22b292016-10-18 16:03:52 -0400676 }
677
678 return result;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000679}
680
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000681static int
Victor Stinner81c41db2015-04-02 11:50:57 +0200682internal_select(PySocketSockObject *s, int writing, _PyTime_t interval,
683 int connect)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000684{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000685 int n;
Victor Stinner71694d52015-03-28 01:18:54 +0100686#ifdef HAVE_POLL
687 struct pollfd pollfd;
Victor Stinnere6951c62015-03-31 13:50:44 +0200688 _PyTime_t ms;
Victor Stinner71694d52015-03-28 01:18:54 +0100689#else
Victor Stinner416f2e62015-03-31 13:56:29 +0200690 fd_set fds, efds;
Victor Stinnerced11742015-04-09 10:27:25 +0200691 struct timeval tv, *tvp;
Victor Stinner71694d52015-03-28 01:18:54 +0100692#endif
Guido van Rossum11ba0942002-06-13 15:07:44 +0000693
Victor Stinnerb7df3142015-03-27 22:59:32 +0100694#ifdef WITH_THREAD
695 /* must be called with the GIL held */
696 assert(PyGILState_Check());
697#endif
698
Victor Stinner416f2e62015-03-31 13:56:29 +0200699 /* Error condition is for output only */
Victor Stinner81c41db2015-04-02 11:50:57 +0200700 assert(!(connect && !writing));
Guido van Rossum67f7a382002-06-06 21:08:16 +0000701
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000702 /* Guard against closed socket */
Victor Stinner0cec8772016-07-22 17:26:53 +0200703 if (s->sock_fd == INVALID_SOCKET)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000704 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000705
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 /* Prefer poll, if available, since you can poll() any fd
707 * which can't be done with select(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000708#ifdef HAVE_POLL
Victor Stinner71694d52015-03-28 01:18:54 +0100709 pollfd.fd = s->sock_fd;
710 pollfd.events = writing ? POLLOUT : POLLIN;
Victor Stinner81c41db2015-04-02 11:50:57 +0200711 if (connect) {
712 /* On Windows, the socket becomes writable on connection success,
713 but a connection failure is notified as an error. On POSIX, the
714 socket becomes writable on connection success or on connection
715 failure. */
Victor Stinner416f2e62015-03-31 13:56:29 +0200716 pollfd.events |= POLLERR;
Victor Stinner81c41db2015-04-02 11:50:57 +0200717 }
Guido van Rossum67f7a382002-06-06 21:08:16 +0000718
Victor Stinner71694d52015-03-28 01:18:54 +0100719 /* s->sock_timeout is in seconds, timeout in ms */
Victor Stinner10550cd2015-04-03 13:22:27 +0200720 ms = _PyTime_AsMilliseconds(interval, _PyTime_ROUND_CEILING);
Victor Stinnere6951c62015-03-31 13:50:44 +0200721 assert(ms <= INT_MAX);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000722
Victor Stinner71694d52015-03-28 01:18:54 +0100723 Py_BEGIN_ALLOW_THREADS;
Victor Stinnere6951c62015-03-31 13:50:44 +0200724 n = poll(&pollfd, 1, (int)ms);
Victor Stinner71694d52015-03-28 01:18:54 +0100725 Py_END_ALLOW_THREADS;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000726#else
Victor Stinnerced11742015-04-09 10:27:25 +0200727 if (interval >= 0) {
728 _PyTime_AsTimeval_noraise(interval, &tv, _PyTime_ROUND_CEILING);
729 tvp = &tv;
730 }
731 else
732 tvp = NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000733
Victor Stinner71694d52015-03-28 01:18:54 +0100734 FD_ZERO(&fds);
735 FD_SET(s->sock_fd, &fds);
Victor Stinner416f2e62015-03-31 13:56:29 +0200736 FD_ZERO(&efds);
Victor Stinner81c41db2015-04-02 11:50:57 +0200737 if (connect) {
738 /* On Windows, the socket becomes writable on connection success,
739 but a connection failure is notified as an error. On POSIX, the
740 socket becomes writable on connection success or on connection
741 failure. */
Victor Stinner416f2e62015-03-31 13:56:29 +0200742 FD_SET(s->sock_fd, &efds);
Victor Stinner81c41db2015-04-02 11:50:57 +0200743 }
Victor Stinner71694d52015-03-28 01:18:54 +0100744
745 /* See if the socket is ready */
746 Py_BEGIN_ALLOW_THREADS;
747 if (writing)
748 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
Victor Stinnerced11742015-04-09 10:27:25 +0200749 NULL, &fds, &efds, tvp);
Victor Stinner71694d52015-03-28 01:18:54 +0100750 else
751 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
Victor Stinnerced11742015-04-09 10:27:25 +0200752 &fds, NULL, &efds, tvp);
Victor Stinner71694d52015-03-28 01:18:54 +0100753 Py_END_ALLOW_THREADS;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000754#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000755
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000756 if (n < 0)
757 return -1;
758 if (n == 0)
759 return 1;
760 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000761}
762
Victor Stinner31bf2d52015-04-01 21:57:09 +0200763/* Call a socket function.
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000764
Victor Stinner81c41db2015-04-02 11:50:57 +0200765 On error, raise an exception and return -1 if err is set, or fill err and
766 return -1 otherwise. If a signal was received and the signal handler raised
767 an exception, return -1, and set err to -1 if err is set.
768
769 On success, return 0, and set err to 0 if err is set.
Victor Stinnerb7df3142015-03-27 22:59:32 +0100770
Victor Stinner31bf2d52015-04-01 21:57:09 +0200771 If the socket has a timeout, wait until the socket is ready before calling
772 the function: wait until the socket is writable if writing is nonzero, wait
773 until the socket received data otherwise.
Victor Stinnerb7df3142015-03-27 22:59:32 +0100774
Victor Stinner81c41db2015-04-02 11:50:57 +0200775 If the socket function is interrupted by a signal (failed with EINTR): retry
Victor Stinner31bf2d52015-04-01 21:57:09 +0200776 the function, except if the signal handler raised an exception (PEP 475).
777
778 When the function is retried, recompute the timeout using a monotonic clock.
779
Victor Stinner81c41db2015-04-02 11:50:57 +0200780 sock_call_ex() must be called with the GIL held. The socket function is
781 called with the GIL released. */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200782static int
Victor Stinner81c41db2015-04-02 11:50:57 +0200783sock_call_ex(PySocketSockObject *s,
784 int writing,
785 int (*sock_func) (PySocketSockObject *s, void *data),
786 void *data,
787 int connect,
Victor Stinner8912d142015-04-06 23:16:34 +0200788 int *err,
789 _PyTime_t timeout)
Victor Stinner31bf2d52015-04-01 21:57:09 +0200790{
Victor Stinner8912d142015-04-06 23:16:34 +0200791 int has_timeout = (timeout > 0);
Victor Stinner31bf2d52015-04-01 21:57:09 +0200792 _PyTime_t deadline = 0;
793 int deadline_initialized = 0;
794 int res;
795
Victor Stinner92f01132015-10-11 09:54:42 +0200796#ifdef WITH_THREAD
Victor Stinner31bf2d52015-04-01 21:57:09 +0200797 /* sock_call() must be called with the GIL held. */
798 assert(PyGILState_Check());
Victor Stinner92f01132015-10-11 09:54:42 +0200799#endif
Victor Stinner31bf2d52015-04-01 21:57:09 +0200800
801 /* outer loop to retry select() when select() is interrupted by a signal
Victor Stinner81c41db2015-04-02 11:50:57 +0200802 or to retry select()+sock_func() on false positive (see above) */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200803 while (1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200804 /* For connect(), poll even for blocking socket. The connection
805 runs asynchronously. */
806 if (has_timeout || connect) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200807 if (has_timeout) {
Victor Stinner10550cd2015-04-03 13:22:27 +0200808 _PyTime_t interval;
809
Victor Stinner81c41db2015-04-02 11:50:57 +0200810 if (deadline_initialized) {
811 /* recompute the timeout */
812 interval = deadline - _PyTime_GetMonotonicClock();
813 }
814 else {
815 deadline_initialized = 1;
Victor Stinner8912d142015-04-06 23:16:34 +0200816 deadline = _PyTime_GetMonotonicClock() + timeout;
817 interval = timeout;
Victor Stinner81c41db2015-04-02 11:50:57 +0200818 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200819
Victor Stinner10550cd2015-04-03 13:22:27 +0200820 if (interval >= 0)
821 res = internal_select(s, writing, interval, connect);
822 else
823 res = 1;
824 }
825 else {
Victor Stinner222dfc72015-04-06 22:30:41 +0200826 res = internal_select(s, writing, timeout, connect);
Victor Stinner10550cd2015-04-03 13:22:27 +0200827 }
828
Victor Stinner31bf2d52015-04-01 21:57:09 +0200829 if (res == -1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200830 if (err)
831 *err = GET_SOCK_ERROR;
832
Victor Stinner31bf2d52015-04-01 21:57:09 +0200833 if (CHECK_ERRNO(EINTR)) {
834 /* select() was interrupted by a signal */
Victor Stinner81c41db2015-04-02 11:50:57 +0200835 if (PyErr_CheckSignals()) {
836 if (err)
837 *err = -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200838 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +0200839 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200840
841 /* retry select() */
842 continue;
843 }
844
845 /* select() failed */
846 s->errorhandler();
847 return -1;
848 }
849
850 if (res == 1) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200851 if (err)
852 *err = SOCK_TIMEOUT_ERR;
853 else
854 PyErr_SetString(socket_timeout, "timed out");
Victor Stinner31bf2d52015-04-01 21:57:09 +0200855 return -1;
856 }
857
858 /* the socket is ready */
859 }
860
Victor Stinner81c41db2015-04-02 11:50:57 +0200861 /* inner loop to retry sock_func() when sock_func() is interrupted
862 by a signal */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200863 while (1) {
864 Py_BEGIN_ALLOW_THREADS
Victor Stinner81c41db2015-04-02 11:50:57 +0200865 res = sock_func(s, data);
Victor Stinner31bf2d52015-04-01 21:57:09 +0200866 Py_END_ALLOW_THREADS
867
868 if (res) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200869 /* sock_func() succeeded */
870 if (err)
871 *err = 0;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200872 return 0;
873 }
874
Victor Stinner81c41db2015-04-02 11:50:57 +0200875 if (err)
876 *err = GET_SOCK_ERROR;
877
Victor Stinner31bf2d52015-04-01 21:57:09 +0200878 if (!CHECK_ERRNO(EINTR))
879 break;
880
Victor Stinner81c41db2015-04-02 11:50:57 +0200881 /* sock_func() was interrupted by a signal */
882 if (PyErr_CheckSignals()) {
883 if (err)
884 *err = -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +0200885 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +0200886 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200887
Victor Stinner81c41db2015-04-02 11:50:57 +0200888 /* retry sock_func() */
Victor Stinner31bf2d52015-04-01 21:57:09 +0200889 }
890
891 if (s->sock_timeout > 0
892 && (CHECK_ERRNO(EWOULDBLOCK) || CHECK_ERRNO(EAGAIN))) {
Victor Stinner81c41db2015-04-02 11:50:57 +0200893 /* False positive: sock_func() failed with EWOULDBLOCK or EAGAIN.
Victor Stinner31bf2d52015-04-01 21:57:09 +0200894
895 For example, select() could indicate a socket is ready for
896 reading, but the data then discarded by the OS because of a
897 wrong checksum.
898
899 Loop on select() to recheck for socket readyness. */
900 continue;
901 }
902
Victor Stinner81c41db2015-04-02 11:50:57 +0200903 /* sock_func() failed */
904 if (!err)
905 s->errorhandler();
906 /* else: err was already set before */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000907 return -1;
908 }
Victor Stinner31bf2d52015-04-01 21:57:09 +0200909}
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000910
Victor Stinner81c41db2015-04-02 11:50:57 +0200911static int
912sock_call(PySocketSockObject *s,
913 int writing,
914 int (*func) (PySocketSockObject *s, void *data),
915 void *data)
916{
Victor Stinner8912d142015-04-06 23:16:34 +0200917 return sock_call_ex(s, writing, func, data, 0, NULL, s->sock_timeout);
Victor Stinner81c41db2015-04-02 11:50:57 +0200918}
919
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000920
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000921/* Initialize a new socket object. */
922
Victor Stinner88ed6402015-04-09 10:23:12 +0200923/* Default timeout for new sockets */
924static _PyTime_t defaulttimeout = _PYTIME_FROMSECONDS(-1);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000925
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200926static int
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000927init_sockobject(PySocketSockObject *s,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000928 SOCKET_T fd, int family, int type, int proto)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000929{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000930 s->sock_fd = fd;
931 s->sock_family = family;
932 s->sock_type = type;
933 s->sock_proto = proto;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000934
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000935 s->errorhandler = &set_error;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000936#ifdef SOCK_NONBLOCK
937 if (type & SOCK_NONBLOCK)
Victor Stinner71694d52015-03-28 01:18:54 +0100938 s->sock_timeout = 0;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000939 else
940#endif
941 {
942 s->sock_timeout = defaulttimeout;
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200943 if (defaulttimeout >= 0) {
944 if (internal_setblocking(s, 0) == -1) {
945 return -1;
946 }
947 }
Antoine Pitroub1c54962010-10-14 15:05:38 +0000948 }
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200949 return 0;
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000950}
951
952
Guido van Rossum30a685f1991-06-27 15:51:29 +0000953/* Create a new socket object.
954 This just creates the object and initializes it.
955 If the creation fails, return NULL and set an exception (implicit
956 in NEWOBJ()). */
957
Guido van Rossum73624e91994-10-10 17:59:00 +0000958static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000959new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000960{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000961 PySocketSockObject *s;
962 s = (PySocketSockObject *)
963 PyType_GenericNew(&sock_type, NULL, NULL);
Christian Heimes0b9d64e2016-09-09 00:28:57 +0200964 if (s == NULL)
965 return NULL;
966 if (init_sockobject(s, fd, family, type, proto) == -1) {
967 Py_DECREF(s);
968 return NULL;
969 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000970 return s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000971}
972
Guido van Rossum30a685f1991-06-27 15:51:29 +0000973
Guido van Rossum48a680c2001-03-02 06:34:14 +0000974/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000975 thread to be in gethostbyname or getaddrinfo */
976#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Matthias Klosed182a6c2012-08-14 17:29:04 +0200977static PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000978#endif
979
980
Guido van Rossum30a685f1991-06-27 15:51:29 +0000981/* Convert a string specifying a host name or one of a few symbolic
982 names to a numeric IP address. This usually calls gethostbyname()
983 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000984 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000985 an error occurred; then an exception is raised. */
986
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000987static int
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200988setipaddr(const char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000989{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000990 struct addrinfo hints, *res;
991 int error;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000992
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000993 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
994 if (name[0] == '\0') {
995 int siz;
996 memset(&hints, 0, sizeof(hints));
997 hints.ai_family = af;
998 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
999 hints.ai_flags = AI_PASSIVE;
1000 Py_BEGIN_ALLOW_THREADS
1001 ACQUIRE_GETADDRINFO_LOCK
1002 error = getaddrinfo(NULL, "0", &hints, &res);
1003 Py_END_ALLOW_THREADS
1004 /* We assume that those thread-unsafe getaddrinfo() versions
1005 *are* safe regarding their return value, ie. that a
1006 subsequent call to getaddrinfo() does not destroy the
1007 outcome of the first call. */
1008 RELEASE_GETADDRINFO_LOCK
1009 if (error) {
1010 set_gaierror(error);
1011 return -1;
1012 }
1013 switch (res->ai_family) {
1014 case AF_INET:
1015 siz = 4;
1016 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001017#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001018 case AF_INET6:
1019 siz = 16;
1020 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001021#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001022 default:
1023 freeaddrinfo(res);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001024 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001025 "unsupported address family");
1026 return -1;
1027 }
1028 if (res->ai_next) {
1029 freeaddrinfo(res);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001030 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001031 "wildcard resolved to multiple address");
1032 return -1;
1033 }
1034 if (res->ai_addrlen < addr_ret_size)
1035 addr_ret_size = res->ai_addrlen;
1036 memcpy(addr_ret, res->ai_addr, addr_ret_size);
1037 freeaddrinfo(res);
1038 return siz;
1039 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001040 /* special-case broadcast - inet_addr() below can return INADDR_NONE for
Victor Stinnere990c6e2013-11-16 00:18:58 +01001041 * this */
Charles-François Natali0cc86852013-09-13 19:53:08 +02001042 if (strcmp(name, "255.255.255.255") == 0 ||
1043 strcmp(name, "<broadcast>") == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001044 struct sockaddr_in *sin;
1045 if (af != AF_INET && af != AF_UNSPEC) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001046 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001047 "address family mismatched");
1048 return -1;
1049 }
1050 sin = (struct sockaddr_in *)addr_ret;
1051 memset((void *) sin, '\0', sizeof(*sin));
1052 sin->sin_family = AF_INET;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001053#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001054 sin->sin_len = sizeof(*sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001055#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 sin->sin_addr.s_addr = INADDR_BROADCAST;
1057 return sizeof(sin->sin_addr);
1058 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001059
1060 /* avoid a name resolution in case of numeric address */
1061#ifdef HAVE_INET_PTON
1062 /* check for an IPv4 address */
1063 if (af == AF_UNSPEC || af == AF_INET) {
1064 struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1065 memset(sin, 0, sizeof(*sin));
1066 if (inet_pton(AF_INET, name, &sin->sin_addr) > 0) {
1067 sin->sin_family = AF_INET;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +00001068#ifdef HAVE_SOCKADDR_SA_LEN
Charles-François Natali0cc86852013-09-13 19:53:08 +02001069 sin->sin_len = sizeof(*sin);
Anthony Baxter0e85f9d2003-05-02 15:40:46 +00001070#endif
Charles-François Natali0cc86852013-09-13 19:53:08 +02001071 return 4;
1072 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001073 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001074#ifdef ENABLE_IPV6
1075 /* check for an IPv6 address - if the address contains a scope ID, we
1076 * fallback to getaddrinfo(), which can handle translation from interface
1077 * name to interface index */
1078 if ((af == AF_UNSPEC || af == AF_INET6) && !strchr(name, '%')) {
1079 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)addr_ret;
1080 memset(sin, 0, sizeof(*sin));
1081 if (inet_pton(AF_INET6, name, &sin->sin6_addr) > 0) {
1082 sin->sin6_family = AF_INET6;
1083#ifdef HAVE_SOCKADDR_SA_LEN
1084 sin->sin6_len = sizeof(*sin);
1085#endif
1086 return 16;
1087 }
1088 }
1089#endif /* ENABLE_IPV6 */
1090#else /* HAVE_INET_PTON */
1091 /* check for an IPv4 address */
1092 if (af == AF_INET || af == AF_UNSPEC) {
1093 struct sockaddr_in *sin = (struct sockaddr_in *)addr_ret;
1094 memset(sin, 0, sizeof(*sin));
1095 if ((sin->sin_addr.s_addr = inet_addr(name)) != INADDR_NONE) {
1096 sin->sin_family = AF_INET;
1097#ifdef HAVE_SOCKADDR_SA_LEN
1098 sin->sin_len = sizeof(*sin);
1099#endif
1100 return 4;
1101 }
Victor Stinnere990c6e2013-11-16 00:18:58 +01001102 }
Charles-François Natali0cc86852013-09-13 19:53:08 +02001103#endif /* HAVE_INET_PTON */
1104
1105 /* perform a name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001106 memset(&hints, 0, sizeof(hints));
1107 hints.ai_family = af;
1108 Py_BEGIN_ALLOW_THREADS
1109 ACQUIRE_GETADDRINFO_LOCK
1110 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +00001111#if defined(__digital__) && defined(__unix__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001112 if (error == EAI_NONAME && af == AF_UNSPEC) {
1113 /* On Tru64 V5.1, numeric-to-addr conversion fails
1114 if no address family is given. Assume IPv4 for now.*/
1115 hints.ai_family = AF_INET;
1116 error = getaddrinfo(name, NULL, &hints, &res);
1117 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +00001118#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001119 Py_END_ALLOW_THREADS
1120 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
1121 if (error) {
1122 set_gaierror(error);
1123 return -1;
1124 }
1125 if (res->ai_addrlen < addr_ret_size)
1126 addr_ret_size = res->ai_addrlen;
1127 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
1128 freeaddrinfo(res);
1129 switch (addr_ret->sa_family) {
1130 case AF_INET:
1131 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001132#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001133 case AF_INET6:
1134 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +00001135#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001136 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001137 PyErr_SetString(PyExc_OSError, "unknown address family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001138 return -1;
1139 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001140}
1141
Guido van Rossum30a685f1991-06-27 15:51:29 +00001142
Guido van Rossum30a685f1991-06-27 15:51:29 +00001143/* Create a string object representing an IP address.
1144 This is always a string of the form 'dd.dd.dd.dd' (with variable
1145 size numbers). */
1146
Guido van Rossum73624e91994-10-10 17:59:00 +00001147static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001148makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001149{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001150 char buf[NI_MAXHOST];
1151 int error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001152
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001153 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
1154 NI_NUMERICHOST);
1155 if (error) {
1156 set_gaierror(error);
1157 return NULL;
1158 }
1159 return PyUnicode_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +00001160}
1161
1162
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001163#ifdef USE_BLUETOOTH
1164/* Convert a string representation of a Bluetooth address into a numeric
1165 address. Returns the length (6), or raises an exception and returns -1 if
1166 an error occurred. */
1167
1168static int
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001169setbdaddr(const char *name, bdaddr_t *bdaddr)
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001170{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001171 unsigned int b0, b1, b2, b3, b4, b5;
1172 char ch;
1173 int n;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001174
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001175 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
1176 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
1177 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
1178 bdaddr->b[0] = b0;
1179 bdaddr->b[1] = b1;
1180 bdaddr->b[2] = b2;
1181 bdaddr->b[3] = b3;
1182 bdaddr->b[4] = b4;
1183 bdaddr->b[5] = b5;
1184 return 6;
1185 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001186 PyErr_SetString(PyExc_OSError, "bad bluetooth address");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001187 return -1;
1188 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001189}
1190
1191/* Create a string representation of the Bluetooth address. This is always a
1192 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
1193 value (zero padded if necessary). */
1194
1195static PyObject *
1196makebdaddr(bdaddr_t *bdaddr)
1197{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001198 char buf[(6 * 2) + 5 + 1];
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001199
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001200 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1201 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1202 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1203 return PyUnicode_FromString(buf);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001204}
1205#endif
1206
1207
Guido van Rossum30a685f1991-06-27 15:51:29 +00001208/* Create an object representing the given socket address,
1209 suitable for passing it back to bind(), connect() etc.
1210 The family field of the sockaddr structure is inspected
1211 to determine what kind of address it really is. */
1212
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001213/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001214static PyObject *
Antoine Pitrou19467d22010-08-17 19:33:30 +00001215makesockaddr(SOCKET_T sockfd, struct sockaddr *addr, size_t addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001216{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001217 if (addrlen == 0) {
1218 /* No address -- may be recvfrom() from known socket */
1219 Py_INCREF(Py_None);
1220 return Py_None;
1221 }
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001223 switch (addr->sa_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001224
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001225 case AF_INET:
1226 {
1227 struct sockaddr_in *a;
1228 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1229 PyObject *ret = NULL;
1230 if (addrobj) {
1231 a = (struct sockaddr_in *)addr;
1232 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1233 Py_DECREF(addrobj);
1234 }
1235 return ret;
1236 }
Guido van Rossum30a685f1991-06-27 15:51:29 +00001237
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001238#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001239 case AF_UNIX:
1240 {
1241 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Benjamin Petersonb6c34582016-09-07 14:08:34 -07001242#ifdef __linux__
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001243 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
1244 addrlen -= offsetof(struct sockaddr_un, sun_path);
Charles-François Natalib10c71d2013-05-21 10:45:46 +02001245 return PyBytes_FromStringAndSize(a->sun_path, addrlen);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001246 }
1247 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001248#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001249 {
1250 /* regular NULL-terminated string */
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001251 return PyUnicode_DecodeFSDefault(a->sun_path);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001252 }
1253 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001254#endif /* AF_UNIX */
1255
Martin v. Löwis11017b12006-01-14 18:12:57 +00001256#if defined(AF_NETLINK)
1257 case AF_NETLINK:
1258 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001259 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1260 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +00001261 }
1262#endif /* AF_NETLINK */
1263
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001264#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001265 case AF_INET6:
1266 {
1267 struct sockaddr_in6 *a;
1268 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1269 PyObject *ret = NULL;
1270 if (addrobj) {
1271 a = (struct sockaddr_in6 *)addr;
Charles-François Natali366999a2012-01-02 15:47:29 +01001272 ret = Py_BuildValue("OiII",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001273 addrobj,
1274 ntohs(a->sin6_port),
Charles-François Natali366999a2012-01-02 15:47:29 +01001275 ntohl(a->sin6_flowinfo),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001276 a->sin6_scope_id);
1277 Py_DECREF(addrobj);
1278 }
1279 return ret;
1280 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001281#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001282
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001283#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001284 case AF_BLUETOOTH:
1285 switch (proto) {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001286
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 case BTPROTO_L2CAP:
1288 {
1289 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1290 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1291 PyObject *ret = NULL;
1292 if (addrobj) {
1293 ret = Py_BuildValue("Oi",
1294 addrobj,
1295 _BT_L2_MEMB(a, psm));
1296 Py_DECREF(addrobj);
1297 }
1298 return ret;
1299 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001300
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001301 case BTPROTO_RFCOMM:
1302 {
1303 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1304 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1305 PyObject *ret = NULL;
1306 if (addrobj) {
1307 ret = Py_BuildValue("Oi",
1308 addrobj,
1309 _BT_RC_MEMB(a, channel));
1310 Py_DECREF(addrobj);
1311 }
1312 return ret;
1313 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001315 case BTPROTO_HCI:
1316 {
1317 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001318#if defined(__NetBSD__) || defined(__DragonFly__)
1319 return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));
1320#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001321 PyObject *ret = NULL;
1322 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1323 return ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001324#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001325 }
Thomas Wouterscf297e42007-02-23 15:07:44 +00001326
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001327#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001328 case BTPROTO_SCO:
1329 {
1330 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1331 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1332 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001333#endif
1334
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001335 default:
1336 PyErr_SetString(PyExc_ValueError,
1337 "Unknown Bluetooth protocol");
1338 return NULL;
1339 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001340#endif
1341
Antoine Pitroub156a462010-10-27 20:13:57 +00001342#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001343 case AF_PACKET:
1344 {
1345 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1346 char *ifname = "";
1347 struct ifreq ifr;
1348 /* need to look up interface name give index */
1349 if (a->sll_ifindex) {
1350 ifr.ifr_ifindex = a->sll_ifindex;
1351 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1352 ifname = ifr.ifr_name;
1353 }
1354 return Py_BuildValue("shbhy#",
1355 ifname,
1356 ntohs(a->sll_protocol),
1357 a->sll_pkttype,
1358 a->sll_hatype,
1359 a->sll_addr,
1360 a->sll_halen);
1361 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001362#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001363
Christian Heimes043d6f62008-01-07 17:19:16 +00001364#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001365 case AF_TIPC:
1366 {
1367 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1368 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1369 return Py_BuildValue("IIIII",
1370 a->addrtype,
1371 a->addr.nameseq.type,
1372 a->addr.nameseq.lower,
1373 a->addr.nameseq.upper,
1374 a->scope);
1375 } else if (a->addrtype == TIPC_ADDR_NAME) {
1376 return Py_BuildValue("IIIII",
1377 a->addrtype,
1378 a->addr.name.name.type,
1379 a->addr.name.name.instance,
1380 a->addr.name.name.instance,
1381 a->scope);
1382 } else if (a->addrtype == TIPC_ADDR_ID) {
1383 return Py_BuildValue("IIIII",
1384 a->addrtype,
1385 a->addr.id.node,
1386 a->addr.id.ref,
1387 0,
1388 a->scope);
1389 } else {
1390 PyErr_SetString(PyExc_ValueError,
1391 "Invalid address type");
1392 return NULL;
1393 }
1394 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001395#endif
1396
Vinay Sajipecfc98c2014-03-20 12:42:42 +00001397#ifdef AF_CAN
Charles-François Natali47413c12011-10-06 19:47:44 +02001398 case AF_CAN:
1399 {
1400 struct sockaddr_can *a = (struct sockaddr_can *)addr;
1401 char *ifname = "";
1402 struct ifreq ifr;
1403 /* need to look up interface name given index */
1404 if (a->can_ifindex) {
1405 ifr.ifr_ifindex = a->can_ifindex;
1406 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1407 ifname = ifr.ifr_name;
1408 }
1409
1410 return Py_BuildValue("O&h", PyUnicode_DecodeFSDefault,
1411 ifname,
1412 a->can_family);
1413 }
1414#endif
1415
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001416#ifdef PF_SYSTEM
1417 case PF_SYSTEM:
1418 switch(proto) {
1419#ifdef SYSPROTO_CONTROL
1420 case SYSPROTO_CONTROL:
1421 {
1422 struct sockaddr_ctl *a = (struct sockaddr_ctl *)addr;
1423 return Py_BuildValue("(II)", a->sc_id, a->sc_unit);
1424 }
1425#endif
1426 default:
1427 PyErr_SetString(PyExc_ValueError,
1428 "Invalid address type");
1429 return 0;
1430 }
1431#endif
1432
Christian Heimesdffa3942016-09-05 23:54:41 +02001433#ifdef HAVE_SOCKADDR_ALG
1434 case AF_ALG:
1435 {
1436 struct sockaddr_alg *a = (struct sockaddr_alg *)addr;
1437 return Py_BuildValue("s#s#HH",
1438 a->salg_type,
1439 strnlen((const char*)a->salg_type,
1440 sizeof(a->salg_type)),
1441 a->salg_name,
1442 strnlen((const char*)a->salg_name,
1443 sizeof(a->salg_name)),
1444 a->salg_feat,
1445 a->salg_mask);
1446 }
1447#endif
1448
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001449 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001450
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001451 default:
1452 /* If we don't know the address family, don't raise an
1453 exception -- return it as an (int, bytes) tuple. */
1454 return Py_BuildValue("iy#",
1455 addr->sa_family,
1456 addr->sa_data,
1457 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001458
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001459 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001460}
1461
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001462/* Helper for getsockaddrarg: bypass IDNA for ASCII-only host names
1463 (in particular, numeric IP addresses). */
1464struct maybe_idna {
1465 PyObject *obj;
1466 char *buf;
1467};
1468
1469static void
1470idna_cleanup(struct maybe_idna *data)
1471{
1472 Py_CLEAR(data->obj);
1473}
1474
1475static int
1476idna_converter(PyObject *obj, struct maybe_idna *data)
1477{
1478 size_t len;
Serhiy Storchaka21a663e2016-04-13 15:37:23 +03001479 PyObject *obj2;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001480 if (obj == NULL) {
1481 idna_cleanup(data);
1482 return 1;
1483 }
1484 data->obj = NULL;
1485 len = -1;
1486 if (PyBytes_Check(obj)) {
1487 data->buf = PyBytes_AsString(obj);
1488 len = PyBytes_Size(obj);
1489 }
1490 else if (PyByteArray_Check(obj)) {
1491 data->buf = PyByteArray_AsString(obj);
1492 len = PyByteArray_Size(obj);
1493 }
Serhiy Storchaka21a663e2016-04-13 15:37:23 +03001494 else if (PyUnicode_Check(obj)) {
1495 if (PyUnicode_READY(obj) == 0 && PyUnicode_IS_COMPACT_ASCII(obj)) {
1496 data->buf = PyUnicode_DATA(obj);
1497 len = PyUnicode_GET_LENGTH(obj);
1498 }
1499 else {
1500 obj2 = PyUnicode_AsEncodedString(obj, "idna", NULL);
1501 if (!obj2) {
1502 PyErr_SetString(PyExc_TypeError, "encoding of hostname failed");
1503 return 0;
1504 }
1505 assert(PyBytes_Check(obj2));
1506 data->obj = obj2;
1507 data->buf = PyBytes_AS_STRING(obj2);
1508 len = PyBytes_GET_SIZE(obj2);
1509 }
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001510 }
1511 else {
Serhiy Storchaka21a663e2016-04-13 15:37:23 +03001512 PyErr_Format(PyExc_TypeError, "str, bytes or bytearray expected, not %s",
1513 obj->ob_type->tp_name);
1514 return 0;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001515 }
1516 if (strlen(data->buf) != len) {
1517 Py_CLEAR(data->obj);
Serhiy Storchakad8a14472014-09-06 20:07:17 +03001518 PyErr_SetString(PyExc_TypeError, "host name must not contain null character");
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001519 return 0;
1520 }
1521 return Py_CLEANUP_SUPPORTED;
Victor Stinner1a62a682014-08-17 19:33:28 +02001522}
Guido van Rossum30a685f1991-06-27 15:51:29 +00001523
1524/* Parse a socket address argument according to the socket object's
1525 address family. Return 1 if the address was in the proper format,
1526 0 of not. The address is returned through addr_ret, its length
1527 through len_ret. */
1528
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001529static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001530getsockaddrarg(PySocketSockObject *s, PyObject *args,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001531 struct sockaddr *addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001532{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001533 switch (s->sock_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001534
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001535#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001536 case AF_UNIX:
1537 {
1538 struct sockaddr_un* addr;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001539 Py_buffer path;
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001540 int retval = 0;
1541
1542 /* PEP 383. Not using PyUnicode_FSConverter since we need to
1543 allow embedded nulls on Linux. */
1544 if (PyUnicode_Check(args)) {
1545 if ((args = PyUnicode_EncodeFSDefault(args)) == NULL)
1546 return 0;
1547 }
1548 else
1549 Py_INCREF(args);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001550 if (!PyArg_Parse(args, "y*", &path)) {
1551 Py_DECREF(args);
1552 return retval;
1553 }
1554 assert(path.len >= 0);
Thomas Wouters89f507f2006-12-13 04:49:30 +00001555
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001556 addr = (struct sockaddr_un*)addr_ret;
Benjamin Petersonb6c34582016-09-07 14:08:34 -07001557#ifdef __linux__
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001558 if (path.len > 0 && *(const char *)path.buf == 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001559 /* Linux abstract namespace extension */
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001560 if ((size_t)path.len > sizeof addr->sun_path) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001561 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001562 "AF_UNIX path too long");
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001563 goto unix_out;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001564 }
1565 }
1566 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001567#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001568 {
1569 /* regular NULL-terminated string */
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001570 if ((size_t)path.len >= sizeof addr->sun_path) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001571 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001572 "AF_UNIX path too long");
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001573 goto unix_out;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001574 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001575 addr->sun_path[path.len] = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001576 }
1577 addr->sun_family = s->sock_family;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001578 memcpy(addr->sun_path, path.buf, path.len);
1579 *len_ret = path.len + offsetof(struct sockaddr_un, sun_path);
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001580 retval = 1;
1581 unix_out:
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001582 PyBuffer_Release(&path);
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01001583 Py_DECREF(args);
1584 return retval;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001585 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001586#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001587
Martin v. Löwis11017b12006-01-14 18:12:57 +00001588#if defined(AF_NETLINK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001589 case AF_NETLINK:
1590 {
1591 struct sockaddr_nl* addr;
1592 int pid, groups;
1593 addr = (struct sockaddr_nl *)addr_ret;
1594 if (!PyTuple_Check(args)) {
1595 PyErr_Format(
1596 PyExc_TypeError,
1597 "getsockaddrarg: "
1598 "AF_NETLINK address must be tuple, not %.500s",
1599 Py_TYPE(args)->tp_name);
1600 return 0;
1601 }
1602 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1603 return 0;
1604 addr->nl_family = AF_NETLINK;
1605 addr->nl_pid = pid;
1606 addr->nl_groups = groups;
1607 *len_ret = sizeof(*addr);
1608 return 1;
1609 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001610#endif
1611
Charles-François Natali10b8cf42011-11-10 19:21:37 +01001612#ifdef AF_RDS
1613 case AF_RDS:
1614 /* RDS sockets use sockaddr_in: fall-through */
1615#endif
1616
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001617 case AF_INET:
1618 {
1619 struct sockaddr_in* addr;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001620 struct maybe_idna host = {NULL, NULL};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001621 int port, result;
1622 if (!PyTuple_Check(args)) {
1623 PyErr_Format(
1624 PyExc_TypeError,
1625 "getsockaddrarg: "
1626 "AF_INET address must be tuple, not %.500s",
1627 Py_TYPE(args)->tp_name);
1628 return 0;
1629 }
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001630 if (!PyArg_ParseTuple(args, "O&i:getsockaddrarg",
1631 idna_converter, &host, &port))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001632 return 0;
1633 addr=(struct sockaddr_in*)addr_ret;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001634 result = setipaddr(host.buf, (struct sockaddr *)addr,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001635 sizeof(*addr), AF_INET);
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001636 idna_cleanup(&host);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001637 if (result < 0)
1638 return 0;
1639 if (port < 0 || port > 0xffff) {
1640 PyErr_SetString(
1641 PyExc_OverflowError,
1642 "getsockaddrarg: port must be 0-65535.");
1643 return 0;
1644 }
1645 addr->sin_family = AF_INET;
1646 addr->sin_port = htons((short)port);
1647 *len_ret = sizeof *addr;
1648 return 1;
1649 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001650
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001651#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001652 case AF_INET6:
1653 {
1654 struct sockaddr_in6* addr;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001655 struct maybe_idna host = {NULL, NULL};
Charles-François Natali366999a2012-01-02 15:47:29 +01001656 int port, result;
1657 unsigned int flowinfo, scope_id;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001658 flowinfo = scope_id = 0;
1659 if (!PyTuple_Check(args)) {
1660 PyErr_Format(
1661 PyExc_TypeError,
1662 "getsockaddrarg: "
1663 "AF_INET6 address must be tuple, not %.500s",
1664 Py_TYPE(args)->tp_name);
1665 return 0;
1666 }
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001667 if (!PyArg_ParseTuple(args, "O&i|II",
1668 idna_converter, &host, &port, &flowinfo,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001669 &scope_id)) {
1670 return 0;
1671 }
1672 addr = (struct sockaddr_in6*)addr_ret;
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001673 result = setipaddr(host.buf, (struct sockaddr *)addr,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001674 sizeof(*addr), AF_INET6);
Martin v. Löwiseb1c28a2014-08-05 16:10:38 +02001675 idna_cleanup(&host);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001676 if (result < 0)
1677 return 0;
1678 if (port < 0 || port > 0xffff) {
1679 PyErr_SetString(
1680 PyExc_OverflowError,
1681 "getsockaddrarg: port must be 0-65535.");
1682 return 0;
1683 }
Charles-François Natali9b0c0062012-06-23 10:17:05 +02001684 if (flowinfo > 0xfffff) {
Charles-François Natali366999a2012-01-02 15:47:29 +01001685 PyErr_SetString(
1686 PyExc_OverflowError,
1687 "getsockaddrarg: flowinfo must be 0-1048575.");
1688 return 0;
1689 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001690 addr->sin6_family = s->sock_family;
1691 addr->sin6_port = htons((short)port);
Charles-François Natali366999a2012-01-02 15:47:29 +01001692 addr->sin6_flowinfo = htonl(flowinfo);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 addr->sin6_scope_id = scope_id;
1694 *len_ret = sizeof *addr;
1695 return 1;
1696 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001697#endif
1698
Hye-Shik Chang81268602004-02-02 06:05:24 +00001699#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001700 case AF_BLUETOOTH:
1701 {
1702 switch (s->sock_proto) {
1703 case BTPROTO_L2CAP:
1704 {
1705 struct sockaddr_l2 *addr;
1706 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001707
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001708 addr = (struct sockaddr_l2 *)addr_ret;
1709 memset(addr, 0, sizeof(struct sockaddr_l2));
1710 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1711 if (!PyArg_ParseTuple(args, "si", &straddr,
1712 &_BT_L2_MEMB(addr, psm))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001713 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001714 "wrong format");
1715 return 0;
1716 }
1717 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1718 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001719
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001720 *len_ret = sizeof *addr;
1721 return 1;
1722 }
1723 case BTPROTO_RFCOMM:
1724 {
1725 struct sockaddr_rc *addr;
1726 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001727
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001728 addr = (struct sockaddr_rc *)addr_ret;
1729 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1730 if (!PyArg_ParseTuple(args, "si", &straddr,
1731 &_BT_RC_MEMB(addr, channel))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001732 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001733 "wrong format");
1734 return 0;
1735 }
1736 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1737 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001738
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001739 *len_ret = sizeof *addr;
1740 return 1;
1741 }
1742 case BTPROTO_HCI:
1743 {
1744 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001745#if defined(__NetBSD__) || defined(__DragonFly__)
Alexander Belopolskye239d232010-12-08 23:31:48 +00001746 char *straddr = PyBytes_AS_STRING(args);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001747
Alexander Belopolskye239d232010-12-08 23:31:48 +00001748 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001749 if (straddr == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001750 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001751 "wrong format");
1752 return 0;
1753 }
1754 if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)
1755 return 0;
1756#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001757 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1758 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001759 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001760 "wrong format");
1761 return 0;
1762 }
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001763#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001764 *len_ret = sizeof *addr;
1765 return 1;
1766 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001767#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001768 case BTPROTO_SCO:
1769 {
1770 struct sockaddr_sco *addr;
1771 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001772
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001773 addr = (struct sockaddr_sco *)addr_ret;
1774 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1775 if (!PyBytes_Check(args)) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001776 PyErr_SetString(PyExc_OSError, "getsockaddrarg: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001777 "wrong format");
1778 return 0;
1779 }
1780 straddr = PyBytes_AS_STRING(args);
1781 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1782 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001783
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001784 *len_ret = sizeof *addr;
1785 return 1;
1786 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001787#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001788 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001789 PyErr_SetString(PyExc_OSError, "getsockaddrarg: unknown Bluetooth protocol");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001790 return 0;
1791 }
1792 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001793#endif
1794
Antoine Pitroub156a462010-10-27 20:13:57 +00001795#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001796 case AF_PACKET:
1797 {
1798 struct sockaddr_ll* addr;
1799 struct ifreq ifr;
1800 char *interfaceName;
1801 int protoNumber;
1802 int hatype = 0;
1803 int pkttype = 0;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001804 Py_buffer haddr = {NULL, NULL};
Guido van Rossum48a680c2001-03-02 06:34:14 +00001805
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001806 if (!PyTuple_Check(args)) {
1807 PyErr_Format(
1808 PyExc_TypeError,
1809 "getsockaddrarg: "
1810 "AF_PACKET address must be tuple, not %.500s",
1811 Py_TYPE(args)->tp_name);
1812 return 0;
1813 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001814 if (!PyArg_ParseTuple(args, "si|iiy*", &interfaceName,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001815 &protoNumber, &pkttype, &hatype,
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001816 &haddr))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001817 return 0;
1818 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1819 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1820 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1821 s->errorhandler();
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001822 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001823 return 0;
1824 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001825 if (haddr.buf && haddr.len > 8) {
1826 PyErr_SetString(PyExc_ValueError,
1827 "Hardware address must be 8 bytes or less");
1828 PyBuffer_Release(&haddr);
1829 return 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001830 }
1831 if (protoNumber < 0 || protoNumber > 0xffff) {
1832 PyErr_SetString(
1833 PyExc_OverflowError,
1834 "getsockaddrarg: protoNumber must be 0-65535.");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001835 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001836 return 0;
1837 }
1838 addr = (struct sockaddr_ll*)addr_ret;
1839 addr->sll_family = AF_PACKET;
1840 addr->sll_protocol = htons((short)protoNumber);
1841 addr->sll_ifindex = ifr.ifr_ifindex;
1842 addr->sll_pkttype = pkttype;
1843 addr->sll_hatype = hatype;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001844 if (haddr.buf) {
1845 memcpy(&addr->sll_addr, haddr.buf, haddr.len);
1846 addr->sll_halen = haddr.len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001847 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001848 else
1849 addr->sll_halen = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001850 *len_ret = sizeof *addr;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02001851 PyBuffer_Release(&haddr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001852 return 1;
1853 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001854#endif
1855
Christian Heimes043d6f62008-01-07 17:19:16 +00001856#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001857 case AF_TIPC:
1858 {
1859 unsigned int atype, v1, v2, v3;
1860 unsigned int scope = TIPC_CLUSTER_SCOPE;
1861 struct sockaddr_tipc *addr;
Christian Heimes043d6f62008-01-07 17:19:16 +00001862
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001863 if (!PyTuple_Check(args)) {
1864 PyErr_Format(
1865 PyExc_TypeError,
1866 "getsockaddrarg: "
1867 "AF_TIPC address must be tuple, not %.500s",
1868 Py_TYPE(args)->tp_name);
1869 return 0;
1870 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001871
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001872 if (!PyArg_ParseTuple(args,
1873 "IIII|I;Invalid TIPC address format",
1874 &atype, &v1, &v2, &v3, &scope))
1875 return 0;
Christian Heimes043d6f62008-01-07 17:19:16 +00001876
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001877 addr = (struct sockaddr_tipc *) addr_ret;
1878 memset(addr, 0, sizeof(struct sockaddr_tipc));
Christian Heimes043d6f62008-01-07 17:19:16 +00001879
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001880 addr->family = AF_TIPC;
1881 addr->scope = scope;
1882 addr->addrtype = atype;
Christian Heimes043d6f62008-01-07 17:19:16 +00001883
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001884 if (atype == TIPC_ADDR_NAMESEQ) {
1885 addr->addr.nameseq.type = v1;
1886 addr->addr.nameseq.lower = v2;
1887 addr->addr.nameseq.upper = v3;
1888 } else if (atype == TIPC_ADDR_NAME) {
1889 addr->addr.name.name.type = v1;
1890 addr->addr.name.name.instance = v2;
1891 } else if (atype == TIPC_ADDR_ID) {
1892 addr->addr.id.node = v1;
1893 addr->addr.id.ref = v2;
1894 } else {
1895 /* Shouldn't happen */
1896 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1897 return 0;
1898 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001899
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001900 *len_ret = sizeof(*addr);
Christian Heimes043d6f62008-01-07 17:19:16 +00001901
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001902 return 1;
1903 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001904#endif
1905
Vinay Sajiped6783f2014-03-21 11:44:32 +00001906#if defined(AF_CAN) && defined(CAN_RAW) && defined(CAN_BCM)
Charles-François Natali47413c12011-10-06 19:47:44 +02001907 case AF_CAN:
1908 switch (s->sock_proto) {
1909 case CAN_RAW:
Charles-François Natali773e42d2013-02-05 19:42:01 +01001910 /* fall-through */
1911 case CAN_BCM:
Charles-François Natali47413c12011-10-06 19:47:44 +02001912 {
1913 struct sockaddr_can *addr;
1914 PyObject *interfaceName;
1915 struct ifreq ifr;
Charles-François Natali47413c12011-10-06 19:47:44 +02001916 Py_ssize_t len;
1917
Benjamin Peterson18b71912013-05-16 15:29:44 -05001918 addr = (struct sockaddr_can *)addr_ret;
1919
Charles-François Natali47413c12011-10-06 19:47:44 +02001920 if (!PyArg_ParseTuple(args, "O&", PyUnicode_FSConverter,
1921 &interfaceName))
1922 return 0;
1923
1924 len = PyBytes_GET_SIZE(interfaceName);
1925
1926 if (len == 0) {
1927 ifr.ifr_ifindex = 0;
Victor Stinner1a62a682014-08-17 19:33:28 +02001928 } else if ((size_t)len < sizeof(ifr.ifr_name)) {
Christian Heimes15b68852012-09-10 01:25:50 +02001929 strncpy(ifr.ifr_name, PyBytes_AS_STRING(interfaceName), sizeof(ifr.ifr_name));
1930 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
Charles-François Natali47413c12011-10-06 19:47:44 +02001931 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1932 s->errorhandler();
1933 Py_DECREF(interfaceName);
1934 return 0;
1935 }
1936 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001937 PyErr_SetString(PyExc_OSError,
Charles-François Natali47413c12011-10-06 19:47:44 +02001938 "AF_CAN interface name too long");
1939 Py_DECREF(interfaceName);
1940 return 0;
1941 }
1942
1943 addr->can_family = AF_CAN;
1944 addr->can_ifindex = ifr.ifr_ifindex;
1945
1946 *len_ret = sizeof(*addr);
1947 Py_DECREF(interfaceName);
1948 return 1;
1949 }
1950 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02001951 PyErr_SetString(PyExc_OSError,
Charles-François Natali47413c12011-10-06 19:47:44 +02001952 "getsockaddrarg: unsupported CAN protocol");
1953 return 0;
1954 }
1955#endif
Victor Stinnera534fc42013-06-03 22:07:27 +02001956
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001957#ifdef PF_SYSTEM
1958 case PF_SYSTEM:
1959 switch (s->sock_proto) {
1960#ifdef SYSPROTO_CONTROL
1961 case SYSPROTO_CONTROL:
1962 {
1963 struct sockaddr_ctl *addr;
Victor Stinnera534fc42013-06-03 22:07:27 +02001964
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001965 addr = (struct sockaddr_ctl *)addr_ret;
1966 addr->sc_family = AF_SYSTEM;
Victor Stinnera534fc42013-06-03 22:07:27 +02001967 addr->ss_sysaddr = AF_SYS_CONTROL;
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001968
1969 if (PyUnicode_Check(args)) {
1970 struct ctl_info info;
1971 PyObject *ctl_name;
1972
1973 if (!PyArg_Parse(args, "O&",
1974 PyUnicode_FSConverter, &ctl_name)) {
1975 return 0;
1976 }
1977
Victor Stinnerf50e1872015-03-20 11:32:24 +01001978 if (PyBytes_GET_SIZE(ctl_name) > (Py_ssize_t)sizeof(info.ctl_name)) {
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001979 PyErr_SetString(PyExc_ValueError,
1980 "provided string is too long");
1981 Py_DECREF(ctl_name);
1982 return 0;
1983 }
1984 strncpy(info.ctl_name, PyBytes_AS_STRING(ctl_name),
1985 sizeof(info.ctl_name));
1986 Py_DECREF(ctl_name);
1987
1988 if (ioctl(s->sock_fd, CTLIOCGINFO, &info)) {
1989 PyErr_SetString(PyExc_OSError,
1990 "cannot find kernel control with provided name");
1991 return 0;
1992 }
Victor Stinnera534fc42013-06-03 22:07:27 +02001993
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01001994 addr->sc_id = info.ctl_id;
1995 addr->sc_unit = 0;
1996 } else if (!PyArg_ParseTuple(args, "II",
1997 &(addr->sc_id), &(addr->sc_unit))) {
1998 PyErr_SetString(PyExc_TypeError, "getsockaddrarg: "
1999 "expected str or tuple of two ints");
Victor Stinnera534fc42013-06-03 22:07:27 +02002000
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01002001 return 0;
2002 }
Victor Stinnera534fc42013-06-03 22:07:27 +02002003
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01002004 *len_ret = sizeof(*addr);
2005 return 1;
2006 }
2007#endif
2008 default:
2009 PyErr_SetString(PyExc_OSError,
2010 "getsockaddrarg: unsupported PF_SYSTEM protocol");
2011 return 0;
2012 }
2013#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02002014#ifdef HAVE_SOCKADDR_ALG
2015 case AF_ALG:
2016 {
2017 struct sockaddr_alg *sa;
2018 char *type;
2019 char *name;
2020 sa = (struct sockaddr_alg *)addr_ret;
2021
2022 memset(sa, 0, sizeof(*sa));
2023 sa->salg_family = AF_ALG;
2024
2025 if (!PyArg_ParseTuple(args, "ss|HH:getsockaddrarg",
2026 &type, &name, &sa->salg_feat, &sa->salg_mask))
2027 return 0;
2028 /* sockaddr_alg has fixed-sized char arrays for type and name */
2029 if (strlen(type) > sizeof(sa->salg_type)) {
2030 PyErr_SetString(PyExc_ValueError, "AF_ALG type too long.");
2031 return 0;
2032 }
2033 strncpy((char *)sa->salg_type, type, sizeof(sa->salg_type));
2034 if (strlen(name) > sizeof(sa->salg_name)) {
2035 PyErr_SetString(PyExc_ValueError, "AF_ALG name too long.");
2036 return 0;
2037 }
2038 strncpy((char *)sa->salg_name, name, sizeof(sa->salg_name));
2039
2040 *len_ret = sizeof(*sa);
2041 return 1;
2042 }
2043#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02002044
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002045 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002046
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002047 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002048 PyErr_SetString(PyExc_OSError, "getsockaddrarg: bad family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002049 return 0;
Guido van Rossum30a685f1991-06-27 15:51:29 +00002050
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002051 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002052}
2053
Guido van Rossum30a685f1991-06-27 15:51:29 +00002054
Guido van Rossum48a680c2001-03-02 06:34:14 +00002055/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00002056 Return 1 if the family is known, 0 otherwise. The length is returned
2057 through len_ret. */
2058
2059static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00002060getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00002061{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002062 switch (s->sock_family) {
Guido van Rossum710e1df1992-06-12 10:39:36 +00002063
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00002064#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002065 case AF_UNIX:
2066 {
2067 *len_ret = sizeof (struct sockaddr_un);
2068 return 1;
2069 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00002070#endif /* AF_UNIX */
Martin Panter6d57fe12016-09-17 03:26:16 +00002071
Martin v. Löwis11017b12006-01-14 18:12:57 +00002072#if defined(AF_NETLINK)
Martin Panter6d57fe12016-09-17 03:26:16 +00002073 case AF_NETLINK:
2074 {
2075 *len_ret = sizeof (struct sockaddr_nl);
2076 return 1;
2077 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00002078#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00002079
Charles-François Natali10b8cf42011-11-10 19:21:37 +01002080#ifdef AF_RDS
2081 case AF_RDS:
2082 /* RDS sockets use sockaddr_in: fall-through */
2083#endif
2084
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002085 case AF_INET:
2086 {
2087 *len_ret = sizeof (struct sockaddr_in);
2088 return 1;
2089 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00002090
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00002091#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002092 case AF_INET6:
2093 {
2094 *len_ret = sizeof (struct sockaddr_in6);
2095 return 1;
2096 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002097#endif
2098
Hye-Shik Chang81268602004-02-02 06:05:24 +00002099#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002100 case AF_BLUETOOTH:
2101 {
2102 switch(s->sock_proto)
2103 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00002104
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002105 case BTPROTO_L2CAP:
2106 *len_ret = sizeof (struct sockaddr_l2);
2107 return 1;
2108 case BTPROTO_RFCOMM:
2109 *len_ret = sizeof (struct sockaddr_rc);
2110 return 1;
2111 case BTPROTO_HCI:
2112 *len_ret = sizeof (struct sockaddr_hci);
2113 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00002114#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002115 case BTPROTO_SCO:
2116 *len_ret = sizeof (struct sockaddr_sco);
2117 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00002118#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002119 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002120 PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002121 "unknown BT protocol");
2122 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00002123
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002124 }
2125 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00002126#endif
2127
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00002128#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002129 case AF_PACKET:
2130 {
2131 *len_ret = sizeof (struct sockaddr_ll);
2132 return 1;
2133 }
Jeremy Hylton22308652001-02-02 03:23:09 +00002134#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00002135
Christian Heimes043d6f62008-01-07 17:19:16 +00002136#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002137 case AF_TIPC:
2138 {
2139 *len_ret = sizeof (struct sockaddr_tipc);
2140 return 1;
2141 }
Christian Heimes043d6f62008-01-07 17:19:16 +00002142#endif
2143
Vinay Sajipecfc98c2014-03-20 12:42:42 +00002144#ifdef AF_CAN
Charles-François Natali47413c12011-10-06 19:47:44 +02002145 case AF_CAN:
2146 {
2147 *len_ret = sizeof (struct sockaddr_can);
2148 return 1;
2149 }
2150#endif
Victor Stinnera534fc42013-06-03 22:07:27 +02002151
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01002152#ifdef PF_SYSTEM
2153 case PF_SYSTEM:
2154 switch(s->sock_proto) {
2155#ifdef SYSPROTO_CONTROL
2156 case SYSPROTO_CONTROL:
2157 *len_ret = sizeof (struct sockaddr_ctl);
2158 return 1;
2159#endif
2160 default:
2161 PyErr_SetString(PyExc_OSError, "getsockaddrlen: "
2162 "unknown PF_SYSTEM protocol");
2163 return 0;
2164 }
2165#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02002166#ifdef HAVE_SOCKADDR_ALG
2167 case AF_ALG:
2168 {
2169 *len_ret = sizeof (struct sockaddr_alg);
2170 return 1;
2171 }
2172#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02002173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002174 /* More cases here... */
Guido van Rossum710e1df1992-06-12 10:39:36 +00002175
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002176 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002177 PyErr_SetString(PyExc_OSError, "getsockaddrlen: bad family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002178 return 0;
Guido van Rossum710e1df1992-06-12 10:39:36 +00002179
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002180 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00002181}
2182
2183
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002184/* Support functions for the sendmsg() and recvmsg[_into]() methods.
2185 Currently, these methods are only compiled if the RFC 2292/3542
2186 CMSG_LEN() macro is available. Older systems seem to have used
2187 sizeof(struct cmsghdr) + (length) where CMSG_LEN() is used now, so
2188 it may be possible to define CMSG_LEN() that way if it's not
2189 provided. Some architectures might need extra padding after the
2190 cmsghdr, however, and CMSG_LEN() would have to take account of
2191 this. */
2192#ifdef CMSG_LEN
2193/* If length is in range, set *result to CMSG_LEN(length) and return
2194 true; otherwise, return false. */
2195static int
2196get_CMSG_LEN(size_t length, size_t *result)
2197{
2198 size_t tmp;
2199
2200 if (length > (SOCKLEN_T_LIMIT - CMSG_LEN(0)))
2201 return 0;
2202 tmp = CMSG_LEN(length);
2203 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2204 return 0;
2205 *result = tmp;
2206 return 1;
2207}
2208
2209#ifdef CMSG_SPACE
2210/* If length is in range, set *result to CMSG_SPACE(length) and return
2211 true; otherwise, return false. */
2212static int
2213get_CMSG_SPACE(size_t length, size_t *result)
2214{
2215 size_t tmp;
2216
2217 /* Use CMSG_SPACE(1) here in order to take account of the padding
2218 necessary before *and* after the data. */
2219 if (length > (SOCKLEN_T_LIMIT - CMSG_SPACE(1)))
2220 return 0;
2221 tmp = CMSG_SPACE(length);
2222 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
2223 return 0;
2224 *result = tmp;
2225 return 1;
2226}
2227#endif
2228
2229/* Return true iff msg->msg_controllen is valid, cmsgh is a valid
2230 pointer in msg->msg_control with at least "space" bytes after it,
2231 and its cmsg_len member inside the buffer. */
2232static int
2233cmsg_min_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t space)
2234{
2235 size_t cmsg_offset;
2236 static const size_t cmsg_len_end = (offsetof(struct cmsghdr, cmsg_len) +
2237 sizeof(cmsgh->cmsg_len));
2238
Charles-François Natali466517d2011-08-28 18:23:43 +02002239 /* Note that POSIX allows msg_controllen to be of signed type. */
Brett Cannonb05cbe62014-01-07 17:01:01 -05002240 if (cmsgh == NULL || msg->msg_control == NULL)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002241 return 0;
Brett Cannonb05cbe62014-01-07 17:01:01 -05002242 /* Note that POSIX allows msg_controllen to be of a signed type. This is
2243 annoying under OS X as it's unsigned there and so it triggers a
2244 tautological comparison warning under Clang when compared against 0.
2245 Since the check is valid on other platforms, silence the warning under
2246 Clang. */
2247 #ifdef __clang__
2248 #pragma clang diagnostic push
2249 #pragma clang diagnostic ignored "-Wtautological-compare"
2250 #endif
Serhiy Storchakacaa01f82015-03-05 23:42:24 +02002251 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +02002252 #pragma GCC diagnostic push
2253 #pragma GCC diagnostic ignored "-Wtype-limits"
2254 #endif
Brett Cannonb05cbe62014-01-07 17:01:01 -05002255 if (msg->msg_controllen < 0)
2256 return 0;
Serhiy Storchakacaa01f82015-03-05 23:42:24 +02002257 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +02002258 #pragma GCC diagnostic pop
2259 #endif
Brett Cannonb05cbe62014-01-07 17:01:01 -05002260 #ifdef __clang__
2261 #pragma clang diagnostic pop
2262 #endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002263 if (space < cmsg_len_end)
2264 space = cmsg_len_end;
2265 cmsg_offset = (char *)cmsgh - (char *)msg->msg_control;
2266 return (cmsg_offset <= (size_t)-1 - space &&
2267 cmsg_offset + space <= msg->msg_controllen);
2268}
2269
2270/* If pointer CMSG_DATA(cmsgh) is in buffer msg->msg_control, set
2271 *space to number of bytes following it in the buffer and return
2272 true; otherwise, return false. Assumes cmsgh, msg->msg_control and
2273 msg->msg_controllen are valid. */
2274static int
2275get_cmsg_data_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *space)
2276{
2277 size_t data_offset;
2278 char *data_ptr;
2279
2280 if ((data_ptr = (char *)CMSG_DATA(cmsgh)) == NULL)
2281 return 0;
2282 data_offset = data_ptr - (char *)msg->msg_control;
2283 if (data_offset > msg->msg_controllen)
2284 return 0;
2285 *space = msg->msg_controllen - data_offset;
2286 return 1;
2287}
2288
2289/* If cmsgh is invalid or not contained in the buffer pointed to by
2290 msg->msg_control, return -1. If cmsgh is valid and its associated
2291 data is entirely contained in the buffer, set *data_len to the
2292 length of the associated data and return 0. If only part of the
2293 associated data is contained in the buffer but cmsgh is otherwise
2294 valid, set *data_len to the length contained in the buffer and
2295 return 1. */
2296static int
2297get_cmsg_data_len(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *data_len)
2298{
2299 size_t space, cmsg_data_len;
2300
2301 if (!cmsg_min_space(msg, cmsgh, CMSG_LEN(0)) ||
2302 cmsgh->cmsg_len < CMSG_LEN(0))
2303 return -1;
2304 cmsg_data_len = cmsgh->cmsg_len - CMSG_LEN(0);
2305 if (!get_cmsg_data_space(msg, cmsgh, &space))
2306 return -1;
2307 if (space >= cmsg_data_len) {
2308 *data_len = cmsg_data_len;
2309 return 0;
2310 }
2311 *data_len = space;
2312 return 1;
2313}
2314#endif /* CMSG_LEN */
2315
2316
Victor Stinner31bf2d52015-04-01 21:57:09 +02002317struct sock_accept {
2318 socklen_t *addrlen;
2319 sock_addr_t *addrbuf;
2320 SOCKET_T result;
2321};
2322
2323#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2324/* accept4() is available on Linux 2.6.28+ and glibc 2.10 */
2325static int accept4_works = -1;
2326#endif
2327
2328static int
2329sock_accept_impl(PySocketSockObject *s, void *data)
2330{
2331 struct sock_accept *ctx = data;
Christian Heimesdffa3942016-09-05 23:54:41 +02002332 struct sockaddr *addr = SAS2SA(ctx->addrbuf);
2333 socklen_t *paddrlen = ctx->addrlen;
2334#ifdef HAVE_SOCKADDR_ALG
2335 /* AF_ALG does not support accept() with addr and raises
2336 * ECONNABORTED instead. */
2337 if (s->sock_family == AF_ALG) {
2338 addr = NULL;
2339 paddrlen = NULL;
2340 *ctx->addrlen = 0;
2341 }
2342#endif
Victor Stinner31bf2d52015-04-01 21:57:09 +02002343
2344#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2345 if (accept4_works != 0) {
Christian Heimesdffa3942016-09-05 23:54:41 +02002346 ctx->result = accept4(s->sock_fd, addr, paddrlen,
Victor Stinner31bf2d52015-04-01 21:57:09 +02002347 SOCK_CLOEXEC);
2348 if (ctx->result == INVALID_SOCKET && accept4_works == -1) {
2349 /* On Linux older than 2.6.28, accept4() fails with ENOSYS */
2350 accept4_works = (errno != ENOSYS);
2351 }
2352 }
2353 if (accept4_works == 0)
Christian Heimesdffa3942016-09-05 23:54:41 +02002354 ctx->result = accept(s->sock_fd, addr, paddrlen);
Victor Stinner31bf2d52015-04-01 21:57:09 +02002355#else
Christian Heimesdffa3942016-09-05 23:54:41 +02002356 ctx->result = accept(s->sock_fd, addr, paddrlen);
Victor Stinner31bf2d52015-04-01 21:57:09 +02002357#endif
Victor Stinnerbea232a2015-07-27 23:37:11 +02002358
2359#ifdef MS_WINDOWS
2360 return (ctx->result != INVALID_SOCKET);
2361#else
Victor Stinner31bf2d52015-04-01 21:57:09 +02002362 return (ctx->result >= 0);
Victor Stinnerbea232a2015-07-27 23:37:11 +02002363#endif
Victor Stinner31bf2d52015-04-01 21:57:09 +02002364}
2365
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002366/* s._accept() -> (fd, address) */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002367
Guido van Rossum73624e91994-10-10 17:59:00 +00002368static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002369sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002370{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002371 sock_addr_t addrbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002372 SOCKET_T newfd;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002373 socklen_t addrlen;
2374 PyObject *sock = NULL;
2375 PyObject *addr = NULL;
2376 PyObject *res = NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002377 struct sock_accept ctx;
Victor Stinnerdaf45552013-08-28 00:53:59 +02002378
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002379 if (!getsockaddrlen(s, &addrlen))
2380 return NULL;
2381 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002382
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002383 if (!IS_SELECTABLE(s))
2384 return select_error();
Neal Norwitz082b2df2006-02-07 07:04:46 +00002385
Victor Stinner31bf2d52015-04-01 21:57:09 +02002386 ctx.addrlen = &addrlen;
2387 ctx.addrbuf = &addrbuf;
2388 if (sock_call(s, 0, sock_accept_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002389 return NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02002390 newfd = ctx.result;
Barry Warsaw752300b1997-01-03 17:18:10 +00002391
Victor Stinnerdaf45552013-08-28 00:53:59 +02002392#ifdef MS_WINDOWS
2393 if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
2394 PyErr_SetFromWindowsErr(0);
2395 SOCKETCLOSE(newfd);
2396 goto finally;
2397 }
2398#else
2399
2400#if defined(HAVE_ACCEPT4) && defined(SOCK_CLOEXEC)
2401 if (!accept4_works)
2402#endif
2403 {
2404 if (_Py_set_inheritable(newfd, 0, NULL) < 0) {
2405 SOCKETCLOSE(newfd);
2406 goto finally;
2407 }
2408 }
2409#endif
2410
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002411 sock = PyLong_FromSocket_t(newfd);
2412 if (sock == NULL) {
2413 SOCKETCLOSE(newfd);
2414 goto finally;
2415 }
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002416
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002417 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2418 addrlen, s->sock_proto);
2419 if (addr == NULL)
2420 goto finally;
Barry Warsaw752300b1997-01-03 17:18:10 +00002421
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002422 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00002423
Guido van Rossum67f7a382002-06-06 21:08:16 +00002424finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002425 Py_XDECREF(sock);
2426 Py_XDECREF(addr);
2427 return res;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002428}
2429
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002430PyDoc_STRVAR(accept_doc,
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002431"_accept() -> (integer, address info)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002432\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00002433Wait for an incoming connection. Return a new socket file descriptor\n\
2434representing the connection, and the address of the client.\n\
2435For IP sockets, the address info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002436
Guido van Rossum11ba0942002-06-13 15:07:44 +00002437/* s.setblocking(flag) method. Argument:
2438 False -- non-blocking mode; same as settimeout(0)
2439 True -- blocking mode; same as settimeout(None)
2440*/
Guido van Rossume4485b01994-09-07 14:32:49 +00002441
Guido van Rossum73624e91994-10-10 17:59:00 +00002442static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002443sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00002444{
Serhiy Storchaka78980432013-01-15 01:12:17 +02002445 long block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002446
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002447 block = PyLong_AsLong(arg);
2448 if (block == -1 && PyErr_Occurred())
2449 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002450
Victor Stinner9001d802015-04-06 23:06:01 +02002451 s->sock_timeout = _PyTime_FromSeconds(block ? -1 : 0);
Christian Heimes0b9d64e2016-09-09 00:28:57 +02002452 if (internal_setblocking(s, block) == -1) {
2453 return NULL;
2454 }
2455 Py_RETURN_NONE;
Guido van Rossume4485b01994-09-07 14:32:49 +00002456}
Guido van Rossume4485b01994-09-07 14:32:49 +00002457
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002458PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002459"setblocking(flag)\n\
2460\n\
2461Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00002462setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002463setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002464
Victor Stinner71694d52015-03-28 01:18:54 +01002465static int
2466socket_parse_timeout(_PyTime_t *timeout, PyObject *timeout_obj)
2467{
2468#ifdef MS_WINDOWS
2469 struct timeval tv;
2470#endif
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002471#ifndef HAVE_POLL
2472 _PyTime_t ms;
2473#endif
Victor Stinner71694d52015-03-28 01:18:54 +01002474 int overflow = 0;
2475
2476 if (timeout_obj == Py_None) {
Victor Stinner10550cd2015-04-03 13:22:27 +02002477 *timeout = _PyTime_FromSeconds(-1);
Victor Stinner71694d52015-03-28 01:18:54 +01002478 return 0;
2479 }
2480
Victor Stinner869e1772015-03-30 03:49:14 +02002481 if (_PyTime_FromSecondsObject(timeout,
2482 timeout_obj, _PyTime_ROUND_CEILING) < 0)
Victor Stinner71694d52015-03-28 01:18:54 +01002483 return -1;
2484
2485 if (*timeout < 0) {
2486 PyErr_SetString(PyExc_ValueError, "Timeout value out of range");
2487 return -1;
2488 }
2489
2490#ifdef MS_WINDOWS
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002491 overflow |= (_PyTime_AsTimeval(*timeout, &tv, _PyTime_ROUND_CEILING) < 0);
Victor Stinner71694d52015-03-28 01:18:54 +01002492#endif
2493#ifndef HAVE_POLL
Victor Stinner1bb0aef2015-03-31 16:31:19 +02002494 ms = _PyTime_AsMilliseconds(*timeout, _PyTime_ROUND_CEILING);
2495 overflow |= (ms > INT_MAX);
Victor Stinner71694d52015-03-28 01:18:54 +01002496#endif
2497 if (overflow) {
2498 PyErr_SetString(PyExc_OverflowError,
2499 "timeout doesn't fit into C timeval");
2500 return -1;
2501 }
2502
2503 return 0;
2504}
2505
Guido van Rossum11ba0942002-06-13 15:07:44 +00002506/* s.settimeout(timeout) method. Argument:
2507 None -- no timeout, blocking mode; same as setblocking(True)
2508 0.0 -- non-blocking mode; same as setblocking(False)
2509 > 0 -- timeout mode; operations time out after timeout seconds
2510 < 0 -- illegal; raises an exception
2511*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00002512static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002513sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00002514{
Victor Stinner71694d52015-03-28 01:18:54 +01002515 _PyTime_t timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002516
Victor Stinner71694d52015-03-28 01:18:54 +01002517 if (socket_parse_timeout(&timeout, arg) < 0)
2518 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002519
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002520 s->sock_timeout = timeout;
Christian Heimes0b9d64e2016-09-09 00:28:57 +02002521 if (internal_setblocking(s, timeout < 0) == -1) {
2522 return NULL;
2523 }
2524 Py_RETURN_NONE;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002525}
2526
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002527PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002528"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002529\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00002530Set a timeout on socket operations. 'timeout' can be a float,\n\
2531giving in seconds, or None. Setting a timeout of None disables\n\
2532the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002533Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00002534
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002535/* s.gettimeout() method.
2536 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00002537static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002538sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00002539{
Victor Stinner71694d52015-03-28 01:18:54 +01002540 if (s->sock_timeout < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002541 Py_INCREF(Py_None);
2542 return Py_None;
2543 }
Victor Stinner71694d52015-03-28 01:18:54 +01002544 else {
2545 double seconds = _PyTime_AsSecondsDouble(s->sock_timeout);
2546 return PyFloat_FromDouble(seconds);
2547 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002548}
2549
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002550PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002551"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002552\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03002553Returns the timeout in seconds (float) associated with socket \n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00002554operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002555operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00002556
Guido van Rossumaee08791992-09-08 09:05:33 +00002557/* s.setsockopt() method.
Christian Heimesdffa3942016-09-05 23:54:41 +02002558 With an integer third argument, sets an integer optval with optlen=4.
2559 With None as third argument and an integer fourth argument, set
2560 optval=NULL with unsigned int as optlen.
Guido van Rossumaee08791992-09-08 09:05:33 +00002561 With a string third argument, sets an option from a buffer;
Christian Heimesdffa3942016-09-05 23:54:41 +02002562 use optional built-in module 'struct' to encode the string.
2563*/
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002564
Guido van Rossum73624e91994-10-10 17:59:00 +00002565static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002566sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002567{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002568 int level;
2569 int optname;
2570 int res;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02002571 Py_buffer optval;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002572 int flag;
Christian Heimesdffa3942016-09-05 23:54:41 +02002573 unsigned int optlen;
2574 PyObject *none;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002575
Christian Heimesdffa3942016-09-05 23:54:41 +02002576 /* setsockopt(level, opt, flag) */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002577 if (PyArg_ParseTuple(args, "iii:setsockopt",
2578 &level, &optname, &flag)) {
Victor Stinnerb6c15bc2015-03-31 16:35:35 +02002579 res = setsockopt(s->sock_fd, level, optname,
2580 (char*)&flag, sizeof flag);
Christian Heimesdffa3942016-09-05 23:54:41 +02002581 goto done;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002582 }
Christian Heimesdffa3942016-09-05 23:54:41 +02002583
2584 PyErr_Clear();
Christian Heimes8c21ab02016-09-06 00:07:02 +02002585 /* setsockopt(level, opt, None, flag) */
Christian Heimesdffa3942016-09-05 23:54:41 +02002586 if (PyArg_ParseTuple(args, "iiO!I:setsockopt",
2587 &level, &optname, Py_TYPE(Py_None), &none, &optlen)) {
2588 assert(sizeof(socklen_t) >= sizeof(unsigned int));
Victor Stinnercc739322016-03-23 21:35:29 +01002589 res = setsockopt(s->sock_fd, level, optname,
Christian Heimesdffa3942016-09-05 23:54:41 +02002590 NULL, (socklen_t)optlen);
2591 goto done;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002592 }
Christian Heimesdffa3942016-09-05 23:54:41 +02002593
2594 PyErr_Clear();
2595 /* setsockopt(level, opt, buffer) */
2596 if (!PyArg_ParseTuple(args, "iiy*:setsockopt",
2597 &level, &optname, &optval))
2598 return NULL;
2599
2600#ifdef MS_WINDOWS
2601 if (optval.len > INT_MAX) {
2602 PyBuffer_Release(&optval);
2603 PyErr_Format(PyExc_OverflowError,
2604 "socket option is larger than %i bytes",
2605 INT_MAX);
2606 return NULL;
2607 }
2608 res = setsockopt(s->sock_fd, level, optname,
2609 optval.buf, (int)optval.len);
2610#else
2611 res = setsockopt(s->sock_fd, level, optname, optval.buf, optval.len);
2612#endif
2613 PyBuffer_Release(&optval);
2614
2615done:
Victor Stinnercc739322016-03-23 21:35:29 +01002616 if (res < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002617 return s->errorhandler();
Victor Stinnercc739322016-03-23 21:35:29 +01002618 }
2619
2620 Py_RETURN_NONE;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002621}
2622
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002623PyDoc_STRVAR(setsockopt_doc,
Christian Heimesdffa3942016-09-05 23:54:41 +02002624"setsockopt(level, option, value: int)\n\
2625setsockopt(level, option, value: buffer)\n\
2626setsockopt(level, option, None, optlen: int)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002627\n\
2628Set a socket option. See the Unix manual for level and option.\n\
Christian Heimesdffa3942016-09-05 23:54:41 +02002629The value argument can either be an integer, a string buffer, or \n\
2630None, optlen.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002631
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002632
Guido van Rossumaee08791992-09-08 09:05:33 +00002633/* s.getsockopt() method.
2634 With two arguments, retrieves an integer option.
2635 With a third integer argument, retrieves a string buffer of that size;
2636 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002637
Guido van Rossum73624e91994-10-10 17:59:00 +00002638static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002639sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002640{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002641 int level;
2642 int optname;
2643 int res;
2644 PyObject *buf;
2645 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002646
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002647 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
2648 &level, &optname, &buflen))
2649 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002650
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002651 if (buflen == 0) {
2652 int flag = 0;
2653 socklen_t flagsize = sizeof flag;
2654 res = getsockopt(s->sock_fd, level, optname,
2655 (void *)&flag, &flagsize);
2656 if (res < 0)
2657 return s->errorhandler();
2658 return PyLong_FromLong(flag);
2659 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002660 if (buflen <= 0 || buflen > 1024) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02002661 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002662 "getsockopt buflen out of range");
2663 return NULL;
2664 }
2665 buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
2666 if (buf == NULL)
2667 return NULL;
2668 res = getsockopt(s->sock_fd, level, optname,
2669 (void *)PyBytes_AS_STRING(buf), &buflen);
2670 if (res < 0) {
2671 Py_DECREF(buf);
2672 return s->errorhandler();
2673 }
2674 _PyBytes_Resize(&buf, buflen);
2675 return buf;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002676}
2677
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002678PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002679"getsockopt(level, option[, buffersize]) -> value\n\
2680\n\
2681Get a socket option. See the Unix manual for level and option.\n\
2682If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002683string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002684
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002685
Fred Drake728819a2000-07-01 03:40:12 +00002686/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002687
Guido van Rossum73624e91994-10-10 17:59:00 +00002688static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002689sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002690{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002691 sock_addr_t addrbuf;
2692 int addrlen;
2693 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002694
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002695 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2696 return NULL;
2697 Py_BEGIN_ALLOW_THREADS
2698 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
2699 Py_END_ALLOW_THREADS
2700 if (res < 0)
2701 return s->errorhandler();
2702 Py_INCREF(Py_None);
2703 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002704}
2705
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002706PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002707"bind(address)\n\
2708\n\
2709Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00002710pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002711sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002712
Guido van Rossum30a685f1991-06-27 15:51:29 +00002713
2714/* s.close() method.
2715 Set the file descriptor to -1 so operations tried subsequently
2716 will surely fail. */
2717
Guido van Rossum73624e91994-10-10 17:59:00 +00002718static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002719sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002720{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002721 SOCKET_T fd;
Martin Panter50ab1a32016-04-11 00:38:12 +00002722 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002723
Victor Stinner19a8e842016-03-21 16:36:48 +01002724 fd = s->sock_fd;
Victor Stinner524714e2016-07-22 17:43:59 +02002725 if (fd != INVALID_SOCKET) {
2726 s->sock_fd = INVALID_SOCKET;
Victor Stinner19a8e842016-03-21 16:36:48 +01002727
2728 /* We do not want to retry upon EINTR: see
2729 http://lwn.net/Articles/576478/ and
2730 http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
2731 for more details. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002732 Py_BEGIN_ALLOW_THREADS
Martin Panter50ab1a32016-04-11 00:38:12 +00002733 res = SOCKETCLOSE(fd);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002734 Py_END_ALLOW_THREADS
Martin Panter50ab1a32016-04-11 00:38:12 +00002735 if (res < 0) {
2736 return s->errorhandler();
2737 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002738 }
2739 Py_INCREF(Py_None);
2740 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002741}
2742
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002743PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002744"close()\n\
2745\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002746Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002747
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002748static PyObject *
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002749sock_detach(PySocketSockObject *s)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002750{
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002751 SOCKET_T fd = s->sock_fd;
Victor Stinner524714e2016-07-22 17:43:59 +02002752 s->sock_fd = INVALID_SOCKET;
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002753 return PyLong_FromSocket_t(fd);
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002754}
2755
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002756PyDoc_STRVAR(detach_doc,
2757"detach()\n\
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002758\n\
Guido van Rossum638aebd2013-12-04 11:50:09 -08002759Close the socket object without closing the underlying file descriptor.\n\
2760The object cannot be used after this call, but the file descriptor\n\
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002761can be reused for other purposes. The file descriptor is returned.");
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002762
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002763static int
Victor Stinner81c41db2015-04-02 11:50:57 +02002764sock_connect_impl(PySocketSockObject *s, void* Py_UNUSED(data))
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002765{
Victor Stinner81c41db2015-04-02 11:50:57 +02002766 int err;
2767 socklen_t size = sizeof err;
Victor Stinnerb6c15bc2015-03-31 16:35:35 +02002768
Victor Stinner81c41db2015-04-02 11:50:57 +02002769 if (getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR, (void *)&err, &size)) {
2770 /* getsockopt() failed */
2771 return 0;
2772 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002773
Victor Stinner81c41db2015-04-02 11:50:57 +02002774 if (err == EISCONN)
2775 return 1;
Victor Stinner38aec752015-04-02 14:37:20 +02002776 if (err != 0) {
2777 /* sock_call_ex() uses GET_SOCK_ERROR() to get the error code */
2778 SET_SOCK_ERROR(err);
Victor Stinner38aec752015-04-02 14:37:20 +02002779 return 0;
2780 }
2781 return 1;
Victor Stinner81c41db2015-04-02 11:50:57 +02002782}
2783
2784static int
2785internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
2786 int raise)
2787{
2788 int res, err, wait_connect;
Victor Stinnerb7df3142015-03-27 22:59:32 +01002789
2790 Py_BEGIN_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002791 res = connect(s->sock_fd, addr, addrlen);
Victor Stinnerb7df3142015-03-27 22:59:32 +01002792 Py_END_ALLOW_THREADS
2793
Victor Stinner70a46f62015-03-31 22:03:59 +02002794 if (!res) {
2795 /* connect() succeeded, the socket is connected */
2796 return 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002797 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002798
Victor Stinner81c41db2015-04-02 11:50:57 +02002799 /* connect() failed */
Victor Stinneree699e92015-03-31 21:28:42 +02002800
Victor Stinner81c41db2015-04-02 11:50:57 +02002801 /* save error, PyErr_CheckSignals() can replace it */
2802 err = GET_SOCK_ERROR;
2803 if (CHECK_ERRNO(EINTR)) {
2804 if (PyErr_CheckSignals())
Victor Stinner70a46f62015-03-31 22:03:59 +02002805 return -1;
Victor Stinner81c41db2015-04-02 11:50:57 +02002806
2807 /* Issue #23618: when connect() fails with EINTR, the connection is
2808 running asynchronously.
2809
2810 If the socket is blocking or has a timeout, wait until the
2811 connection completes, fails or timed out using select(), and then
2812 get the connection status using getsockopt(SO_ERROR).
2813
2814 If the socket is non-blocking, raise InterruptedError. The caller is
2815 responsible to wait until the connection completes, fails or timed
2816 out (it's the case in asyncio for example). */
2817 wait_connect = (s->sock_timeout != 0 && IS_SELECTABLE(s));
2818 }
2819 else {
2820 wait_connect = (s->sock_timeout > 0 && err == SOCK_INPROGRESS_ERR
2821 && IS_SELECTABLE(s));
Victor Stinner70a46f62015-03-31 22:03:59 +02002822 }
2823
Victor Stinner81c41db2015-04-02 11:50:57 +02002824 if (!wait_connect) {
2825 if (raise) {
2826 /* restore error, maybe replaced by PyErr_CheckSignals() */
2827 SET_SOCK_ERROR(err);
2828 s->errorhandler();
2829 return -1;
2830 }
2831 else
2832 return err;
Victor Stinner70a46f62015-03-31 22:03:59 +02002833 }
2834
Victor Stinner81c41db2015-04-02 11:50:57 +02002835 if (raise) {
2836 /* socket.connect() raises an exception on error */
Victor Stinner8912d142015-04-06 23:16:34 +02002837 if (sock_call_ex(s, 1, sock_connect_impl, NULL,
2838 1, NULL, s->sock_timeout) < 0)
Victor Stinner81c41db2015-04-02 11:50:57 +02002839 return -1;
Victor Stinner70a46f62015-03-31 22:03:59 +02002840 }
Victor Stinner81c41db2015-04-02 11:50:57 +02002841 else {
2842 /* socket.connect_ex() returns the error code on error */
Victor Stinner8912d142015-04-06 23:16:34 +02002843 if (sock_call_ex(s, 1, sock_connect_impl, NULL,
2844 1, &err, s->sock_timeout) < 0)
Victor Stinner81c41db2015-04-02 11:50:57 +02002845 return err;
2846 }
2847 return 0;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002848}
Guido van Rossum30a685f1991-06-27 15:51:29 +00002849
Fred Drake728819a2000-07-01 03:40:12 +00002850/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002851
Guido van Rossum73624e91994-10-10 17:59:00 +00002852static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002853sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002854{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002855 sock_addr_t addrbuf;
2856 int addrlen;
2857 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002858
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002859 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2860 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002861
Victor Stinner81c41db2015-04-02 11:50:57 +02002862 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 1);
Victor Stinneree699e92015-03-31 21:28:42 +02002863 if (res < 0)
2864 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002865
Victor Stinneree699e92015-03-31 21:28:42 +02002866 Py_RETURN_NONE;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002867}
2868
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002869PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002870"connect(address)\n\
2871\n\
2872Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002873is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002874
Guido van Rossum30a685f1991-06-27 15:51:29 +00002875
Fred Drake728819a2000-07-01 03:40:12 +00002876/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002877
2878static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002879sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002880{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002881 sock_addr_t addrbuf;
2882 int addrlen;
2883 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002884
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002885 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2886 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002887
Victor Stinner81c41db2015-04-02 11:50:57 +02002888 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, 0);
Victor Stinner71694d52015-03-28 01:18:54 +01002889 if (res < 0)
2890 return NULL;
2891
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002892 return PyLong_FromLong((long) res);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002893}
2894
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002895PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002896"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002897\n\
2898This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002899instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002900
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002901
Guido van Rossumed233a51992-06-23 09:07:03 +00002902/* s.fileno() method */
2903
Guido van Rossum73624e91994-10-10 17:59:00 +00002904static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002905sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00002906{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002907 return PyLong_FromSocket_t(s->sock_fd);
Guido van Rossumed233a51992-06-23 09:07:03 +00002908}
2909
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002910PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002911"fileno() -> integer\n\
2912\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002913Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002914
Guido van Rossumed233a51992-06-23 09:07:03 +00002915
Guido van Rossumc89705d1992-11-26 08:54:07 +00002916/* s.getsockname() method */
2917
Guido van Rossum73624e91994-10-10 17:59:00 +00002918static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002919sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002920{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002921 sock_addr_t addrbuf;
2922 int res;
2923 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002924
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002925 if (!getsockaddrlen(s, &addrlen))
2926 return NULL;
2927 memset(&addrbuf, 0, addrlen);
2928 Py_BEGIN_ALLOW_THREADS
2929 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2930 Py_END_ALLOW_THREADS
2931 if (res < 0)
2932 return s->errorhandler();
2933 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2934 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002935}
2936
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002937PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002938"getsockname() -> address info\n\
2939\n\
2940Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002941info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002942
Guido van Rossumc89705d1992-11-26 08:54:07 +00002943
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002944#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002945/* s.getpeername() method */
2946
Guido van Rossum73624e91994-10-10 17:59:00 +00002947static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002948sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002949{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002950 sock_addr_t addrbuf;
2951 int res;
2952 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002953
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002954 if (!getsockaddrlen(s, &addrlen))
2955 return NULL;
2956 memset(&addrbuf, 0, addrlen);
2957 Py_BEGIN_ALLOW_THREADS
2958 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2959 Py_END_ALLOW_THREADS
2960 if (res < 0)
2961 return s->errorhandler();
2962 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2963 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002964}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002965
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002966PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002967"getpeername() -> address info\n\
2968\n\
2969Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002970info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002971
Guido van Rossumb6775db1994-08-01 11:34:53 +00002972#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002973
2974
Guido van Rossum30a685f1991-06-27 15:51:29 +00002975/* s.listen(n) method */
2976
Guido van Rossum73624e91994-10-10 17:59:00 +00002977static PyObject *
Charles-François Natali644b8f52014-05-22 19:45:39 +01002978sock_listen(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002979{
Charles-François Natali644b8f52014-05-22 19:45:39 +01002980 /* We try to choose a default backlog high enough to avoid connection drops
2981 * for common workloads, yet not too high to limit resource usage. */
2982 int backlog = Py_MIN(SOMAXCONN, 128);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002983 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002984
Charles-François Natali644b8f52014-05-22 19:45:39 +01002985 if (!PyArg_ParseTuple(args, "|i:listen", &backlog))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002986 return NULL;
Charles-François Natali644b8f52014-05-22 19:45:39 +01002987
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002988 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou1be815a2011-05-10 19:16:29 +02002989 /* To avoid problems on systems that don't allow a negative backlog
2990 * (which doesn't make sense anyway) we force a minimum value of 0. */
2991 if (backlog < 0)
2992 backlog = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002993 res = listen(s->sock_fd, backlog);
2994 Py_END_ALLOW_THREADS
2995 if (res < 0)
2996 return s->errorhandler();
2997 Py_INCREF(Py_None);
2998 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002999}
3000
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003001PyDoc_STRVAR(listen_doc,
Charles-François Natali644b8f52014-05-22 19:45:39 +01003002"listen([backlog])\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003003\n\
Charles-François Natali644b8f52014-05-22 19:45:39 +01003004Enable a server to accept connections. If backlog is specified, it must be\n\
3005at least 0 (if it is lower, it is set to 0); it specifies the number of\n\
Antoine Pitrou1be815a2011-05-10 19:16:29 +02003006unaccepted connections that the system will allow before refusing new\n\
Charles-François Natali644b8f52014-05-22 19:45:39 +01003007connections. If not specified, a default reasonable value is chosen.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003008
Victor Stinner31bf2d52015-04-01 21:57:09 +02003009struct sock_recv {
3010 char *cbuf;
3011 Py_ssize_t len;
3012 int flags;
3013 Py_ssize_t result;
3014};
3015
3016static int
3017sock_recv_impl(PySocketSockObject *s, void *data)
3018{
3019 struct sock_recv *ctx = data;
3020
3021#ifdef MS_WINDOWS
3022 if (ctx->len > INT_MAX)
3023 ctx->len = INT_MAX;
3024 ctx->result = recv(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags);
3025#else
3026 ctx->result = recv(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags);
3027#endif
3028 return (ctx->result >= 0);
3029}
3030
Guido van Rossum82a5c661998-07-07 20:45:43 +00003031
Thomas Wouters477c8d52006-05-27 19:21:47 +00003032/*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003033 * This is the guts of the recv() and recv_into() methods, which reads into a
Thomas Wouters902d6eb2007-01-09 23:18:33 +00003034 * char buffer. If you have any inc/dec ref to do to the objects that contain
Thomas Wouters477c8d52006-05-27 19:21:47 +00003035 * the buffer, do it in the caller. This function returns the number of bytes
Ezio Melotti13925002011-03-16 11:05:33 +02003036 * successfully read. If there was an error, it returns -1. Note that it is
Thomas Wouters477c8d52006-05-27 19:21:47 +00003037 * also possible that we return a number of bytes smaller than the request
3038 * bytes.
3039 */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003040
Antoine Pitrou19467d22010-08-17 19:33:30 +00003041static Py_ssize_t
3042sock_recv_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags)
Thomas Wouters477c8d52006-05-27 19:21:47 +00003043{
Victor Stinner31bf2d52015-04-01 21:57:09 +02003044 struct sock_recv ctx;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003045
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003046 if (!IS_SELECTABLE(s)) {
3047 select_error();
3048 return -1;
3049 }
3050 if (len == 0) {
3051 /* If 0 bytes were requested, do nothing. */
3052 return 0;
3053 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003054
Victor Stinner31bf2d52015-04-01 21:57:09 +02003055 ctx.cbuf = cbuf;
3056 ctx.len = len;
3057 ctx.flags = flags;
3058 if (sock_call(s, 0, sock_recv_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003059 return -1;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003060
3061 return ctx.result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003062}
3063
Guido van Rossum48a680c2001-03-02 06:34:14 +00003064
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003065/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003066
Guido van Rossum73624e91994-10-10 17:59:00 +00003067static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003068sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003069{
Antoine Pitrou19467d22010-08-17 19:33:30 +00003070 Py_ssize_t recvlen, outlen;
3071 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003072 PyObject *buf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003073
Antoine Pitrou19467d22010-08-17 19:33:30 +00003074 if (!PyArg_ParseTuple(args, "n|i:recv", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003075 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003076
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003077 if (recvlen < 0) {
3078 PyErr_SetString(PyExc_ValueError,
3079 "negative buffersize in recv");
3080 return NULL;
3081 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003082
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003083 /* Allocate a new string. */
3084 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
3085 if (buf == NULL)
3086 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003087
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003088 /* Call the guts */
3089 outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
3090 if (outlen < 0) {
3091 /* An error occurred, release the string and return an
3092 error. */
3093 Py_DECREF(buf);
3094 return NULL;
3095 }
3096 if (outlen != recvlen) {
3097 /* We did not read as many bytes as we anticipated, resize the
3098 string if possible and be successful. */
3099 _PyBytes_Resize(&buf, outlen);
3100 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00003101
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003102 return buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003103}
3104
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003105PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003106"recv(buffersize[, flags]) -> data\n\
3107\n\
3108Receive up to buffersize bytes from the socket. For the optional flags\n\
3109argument, see the Unix manual. When no data is available, block until\n\
3110at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003111the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003112
Guido van Rossum30a685f1991-06-27 15:51:29 +00003113
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003114/* s.recv_into(buffer, [nbytes [,flags]]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003115
Thomas Wouters477c8d52006-05-27 19:21:47 +00003116static PyObject*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003117sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00003118{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003119 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00003120
Antoine Pitrou19467d22010-08-17 19:33:30 +00003121 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003122 Py_buffer pbuf;
3123 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003124 Py_ssize_t buflen, readlen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003125
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003126 /* Get the buffer's memory */
Antoine Pitrou19467d22010-08-17 19:33:30 +00003127 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recv_into", kwlist,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003128 &pbuf, &recvlen, &flags))
3129 return NULL;
3130 buf = pbuf.buf;
3131 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003132
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003133 if (recvlen < 0) {
3134 PyBuffer_Release(&pbuf);
3135 PyErr_SetString(PyExc_ValueError,
3136 "negative buffersize in recv_into");
3137 return NULL;
3138 }
3139 if (recvlen == 0) {
3140 /* If nbytes was not specified, use the buffer's length */
3141 recvlen = buflen;
3142 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003143
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003144 /* Check if the buffer is large enough */
3145 if (buflen < recvlen) {
3146 PyBuffer_Release(&pbuf);
3147 PyErr_SetString(PyExc_ValueError,
3148 "buffer too small for requested bytes");
3149 return NULL;
3150 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003151
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003152 /* Call the guts */
3153 readlen = sock_recv_guts(s, buf, recvlen, flags);
3154 if (readlen < 0) {
3155 /* Return an error. */
3156 PyBuffer_Release(&pbuf);
3157 return NULL;
3158 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003160 PyBuffer_Release(&pbuf);
3161 /* Return the number of bytes read. Note that we do not do anything
3162 special here in the case that readlen < recvlen. */
3163 return PyLong_FromSsize_t(readlen);
Thomas Wouters477c8d52006-05-27 19:21:47 +00003164}
3165
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003166PyDoc_STRVAR(recv_into_doc,
3167"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00003168\n\
3169A version of recv() that stores its data into a buffer rather than creating \n\
3170a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
3171is not specified (or 0), receive up to the size available in the given buffer.\n\
3172\n\
3173See recv() for documentation about the flags.");
3174
Victor Stinner31bf2d52015-04-01 21:57:09 +02003175struct sock_recvfrom {
3176 char* cbuf;
3177 Py_ssize_t len;
3178 int flags;
3179 socklen_t *addrlen;
3180 sock_addr_t *addrbuf;
3181 Py_ssize_t result;
3182};
3183
3184static int
3185sock_recvfrom_impl(PySocketSockObject *s, void *data)
3186{
3187 struct sock_recvfrom *ctx = data;
3188
3189 memset(ctx->addrbuf, 0, *ctx->addrlen);
3190
3191#ifdef MS_WINDOWS
3192 if (ctx->len > INT_MAX)
3193 ctx->len = INT_MAX;
3194 ctx->result = recvfrom(s->sock_fd, ctx->cbuf, (int)ctx->len, ctx->flags,
3195 SAS2SA(ctx->addrbuf), ctx->addrlen);
3196#else
3197 ctx->result = recvfrom(s->sock_fd, ctx->cbuf, ctx->len, ctx->flags,
3198 SAS2SA(ctx->addrbuf), ctx->addrlen);
3199#endif
3200 return (ctx->result >= 0);
3201}
3202
Thomas Wouters477c8d52006-05-27 19:21:47 +00003203
3204/*
Christian Heimes99170a52007-12-19 02:07:34 +00003205 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
3206 * into a char buffer. If you have any inc/def ref to do to the objects that
3207 * contain the buffer, do it in the caller. This function returns the number
Ezio Melotti13925002011-03-16 11:05:33 +02003208 * of bytes successfully read. If there was an error, it returns -1. Note
Christian Heimes99170a52007-12-19 02:07:34 +00003209 * that it is also possible that we return a number of bytes smaller than the
3210 * request bytes.
Thomas Wouters477c8d52006-05-27 19:21:47 +00003211 *
3212 * 'addr' is a return value for the address object. Note that you must decref
3213 * it yourself.
3214 */
Antoine Pitrou19467d22010-08-17 19:33:30 +00003215static Py_ssize_t
3216sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003217 PyObject** addr)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003218{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003219 sock_addr_t addrbuf;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003220 socklen_t addrlen;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003221 struct sock_recvfrom ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003223 *addr = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003224
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003225 if (!getsockaddrlen(s, &addrlen))
3226 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003227
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003228 if (!IS_SELECTABLE(s)) {
3229 select_error();
3230 return -1;
3231 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003232
Victor Stinner31bf2d52015-04-01 21:57:09 +02003233 ctx.cbuf = cbuf;
3234 ctx.len = len;
3235 ctx.flags = flags;
3236 ctx.addrbuf = &addrbuf;
3237 ctx.addrlen = &addrlen;
3238 if (sock_call(s, 0, sock_recvfrom_impl, &ctx) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003239 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003240
Victor Stinner31bf2d52015-04-01 21:57:09 +02003241 *addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
3242 s->sock_proto);
3243 if (*addr == NULL)
3244 return -1;
3245
3246 return ctx.result;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003247}
3248
3249/* s.recvfrom(nbytes [,flags]) method */
3250
3251static PyObject *
3252sock_recvfrom(PySocketSockObject *s, PyObject *args)
3253{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003254 PyObject *buf = NULL;
3255 PyObject *addr = NULL;
3256 PyObject *ret = NULL;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003257 int flags = 0;
3258 Py_ssize_t recvlen, outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003259
Antoine Pitrou19467d22010-08-17 19:33:30 +00003260 if (!PyArg_ParseTuple(args, "n|i:recvfrom", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003261 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00003262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003263 if (recvlen < 0) {
3264 PyErr_SetString(PyExc_ValueError,
3265 "negative buffersize in recvfrom");
3266 return NULL;
3267 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00003268
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003269 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
3270 if (buf == NULL)
3271 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003272
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003273 outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
3274 recvlen, flags, &addr);
3275 if (outlen < 0) {
3276 goto finally;
3277 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003278
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003279 if (outlen != recvlen) {
3280 /* We did not read as many bytes as we anticipated, resize the
Ezio Melotti13925002011-03-16 11:05:33 +02003281 string if possible and be successful. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003282 if (_PyBytes_Resize(&buf, outlen) < 0)
Ezio Melotti13925002011-03-16 11:05:33 +02003283 /* Oopsy, not so successful after all. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003284 goto finally;
3285 }
Barry Warsaw752300b1997-01-03 17:18:10 +00003286
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003287 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003288
3289finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003290 Py_XDECREF(buf);
3291 Py_XDECREF(addr);
3292 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003293}
3294
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003295PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003296"recvfrom(buffersize[, flags]) -> (data, address info)\n\
3297\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003298Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003299
Thomas Wouters477c8d52006-05-27 19:21:47 +00003300
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003301/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
Thomas Wouters477c8d52006-05-27 19:21:47 +00003302
3303static PyObject *
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003304sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00003305{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003306 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00003307
Antoine Pitrou19467d22010-08-17 19:33:30 +00003308 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003309 Py_buffer pbuf;
3310 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003311 Py_ssize_t readlen, buflen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003312
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003313 PyObject *addr = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003314
Antoine Pitrou19467d22010-08-17 19:33:30 +00003315 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recvfrom_into",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003316 kwlist, &pbuf,
3317 &recvlen, &flags))
3318 return NULL;
3319 buf = pbuf.buf;
3320 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003321
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003322 if (recvlen < 0) {
3323 PyBuffer_Release(&pbuf);
3324 PyErr_SetString(PyExc_ValueError,
3325 "negative buffersize in recvfrom_into");
3326 return NULL;
3327 }
3328 if (recvlen == 0) {
3329 /* If nbytes was not specified, use the buffer's length */
3330 recvlen = buflen;
Benjamin Petersonc6b37e22014-01-13 23:14:42 -05003331 } else if (recvlen > buflen) {
3332 PyBuffer_Release(&pbuf);
3333 PyErr_SetString(PyExc_ValueError,
3334 "nbytes is greater than the length of the buffer");
3335 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003336 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003337
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003338 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
3339 if (readlen < 0) {
3340 PyBuffer_Release(&pbuf);
3341 /* Return an error */
3342 Py_XDECREF(addr);
3343 return NULL;
3344 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003345
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003346 PyBuffer_Release(&pbuf);
3347 /* Return the number of bytes read and the address. Note that we do
3348 not do anything special here in the case that readlen < recvlen. */
Antoine Pitrou19467d22010-08-17 19:33:30 +00003349 return Py_BuildValue("nN", readlen, addr);
Thomas Wouters477c8d52006-05-27 19:21:47 +00003350}
3351
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003352PyDoc_STRVAR(recvfrom_into_doc,
3353"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00003354\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00003355Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00003356
Victor Stinner35bee932015-04-02 12:28:07 +02003357/* The sendmsg() and recvmsg[_into]() methods require a working
3358 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3359#ifdef CMSG_LEN
Victor Stinner31bf2d52015-04-01 21:57:09 +02003360struct sock_recvmsg {
3361 struct msghdr *msg;
3362 int flags;
3363 ssize_t result;
3364};
3365
3366static int
3367sock_recvmsg_impl(PySocketSockObject *s, void *data)
3368{
3369 struct sock_recvmsg *ctx = data;
3370
3371 ctx->result = recvmsg(s->sock_fd, ctx->msg, ctx->flags);
3372 return (ctx->result >= 0);
3373}
3374
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003375/*
3376 * Call recvmsg() with the supplied iovec structures, flags, and
3377 * ancillary data buffer size (controllen). Returns the tuple return
3378 * value for recvmsg() or recvmsg_into(), with the first item provided
3379 * by the supplied makeval() function. makeval() will be called with
3380 * the length read and makeval_data as arguments, and must return a
3381 * new reference (which will be decrefed if there is a subsequent
3382 * error). On error, closes any file descriptors received via
3383 * SCM_RIGHTS.
3384 */
3385static PyObject *
3386sock_recvmsg_guts(PySocketSockObject *s, struct iovec *iov, int iovlen,
3387 int flags, Py_ssize_t controllen,
3388 PyObject *(*makeval)(ssize_t, void *), void *makeval_data)
3389{
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003390 sock_addr_t addrbuf;
3391 socklen_t addrbuflen;
Charles-François Natalie9e95ae2011-08-24 21:40:53 +02003392 struct msghdr msg = {0};
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003393 PyObject *cmsg_list = NULL, *retval = NULL;
3394 void *controlbuf = NULL;
3395 struct cmsghdr *cmsgh;
3396 size_t cmsgdatalen = 0;
3397 int cmsg_status;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003398 struct sock_recvmsg ctx;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003399
3400 /* XXX: POSIX says that msg_name and msg_namelen "shall be
3401 ignored" when the socket is connected (Linux fills them in
3402 anyway for AF_UNIX sockets at least). Normally msg_namelen
3403 seems to be set to 0 if there's no address, but try to
3404 initialize msg_name to something that won't be mistaken for a
3405 real address if that doesn't happen. */
3406 if (!getsockaddrlen(s, &addrbuflen))
3407 return NULL;
3408 memset(&addrbuf, 0, addrbuflen);
3409 SAS2SA(&addrbuf)->sa_family = AF_UNSPEC;
3410
3411 if (controllen < 0 || controllen > SOCKLEN_T_LIMIT) {
3412 PyErr_SetString(PyExc_ValueError,
3413 "invalid ancillary data buffer length");
3414 return NULL;
3415 }
3416 if (controllen > 0 && (controlbuf = PyMem_Malloc(controllen)) == NULL)
3417 return PyErr_NoMemory();
3418
3419 /* Make the system call. */
3420 if (!IS_SELECTABLE(s)) {
3421 select_error();
3422 goto finally;
3423 }
3424
Victor Stinner31bf2d52015-04-01 21:57:09 +02003425 msg.msg_name = SAS2SA(&addrbuf);
3426 msg.msg_namelen = addrbuflen;
3427 msg.msg_iov = iov;
3428 msg.msg_iovlen = iovlen;
3429 msg.msg_control = controlbuf;
3430 msg.msg_controllen = controllen;
Victor Stinnerb7df3142015-03-27 22:59:32 +01003431
Victor Stinner31bf2d52015-04-01 21:57:09 +02003432 ctx.msg = &msg;
3433 ctx.flags = flags;
3434 if (sock_call(s, 0, sock_recvmsg_impl, &ctx) < 0)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003435 goto finally;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003436
3437 /* Make list of (level, type, data) tuples from control messages. */
3438 if ((cmsg_list = PyList_New(0)) == NULL)
3439 goto err_closefds;
3440 /* Check for empty ancillary data as old CMSG_FIRSTHDR()
3441 implementations didn't do so. */
3442 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
3443 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
3444 PyObject *bytes, *tuple;
3445 int tmp;
3446
3447 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
3448 if (cmsg_status != 0) {
3449 if (PyErr_WarnEx(PyExc_RuntimeWarning,
3450 "received malformed or improperly-truncated "
3451 "ancillary data", 1) == -1)
3452 goto err_closefds;
3453 }
3454 if (cmsg_status < 0)
3455 break;
3456 if (cmsgdatalen > PY_SSIZE_T_MAX) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003457 PyErr_SetString(PyExc_OSError, "control message too long");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003458 goto err_closefds;
3459 }
3460
3461 bytes = PyBytes_FromStringAndSize((char *)CMSG_DATA(cmsgh),
3462 cmsgdatalen);
3463 tuple = Py_BuildValue("iiN", (int)cmsgh->cmsg_level,
3464 (int)cmsgh->cmsg_type, bytes);
3465 if (tuple == NULL)
3466 goto err_closefds;
3467 tmp = PyList_Append(cmsg_list, tuple);
3468 Py_DECREF(tuple);
3469 if (tmp != 0)
3470 goto err_closefds;
3471
3472 if (cmsg_status != 0)
3473 break;
3474 }
3475
3476 retval = Py_BuildValue("NOiN",
Victor Stinner31bf2d52015-04-01 21:57:09 +02003477 (*makeval)(ctx.result, makeval_data),
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003478 cmsg_list,
3479 (int)msg.msg_flags,
3480 makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
3481 ((msg.msg_namelen > addrbuflen) ?
3482 addrbuflen : msg.msg_namelen),
3483 s->sock_proto));
3484 if (retval == NULL)
3485 goto err_closefds;
3486
3487finally:
3488 Py_XDECREF(cmsg_list);
3489 PyMem_Free(controlbuf);
3490 return retval;
3491
3492err_closefds:
3493#ifdef SCM_RIGHTS
3494 /* Close all descriptors coming from SCM_RIGHTS, so they don't leak. */
3495 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
3496 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
3497 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
3498 if (cmsg_status < 0)
3499 break;
3500 if (cmsgh->cmsg_level == SOL_SOCKET &&
3501 cmsgh->cmsg_type == SCM_RIGHTS) {
3502 size_t numfds;
3503 int *fdp;
3504
3505 numfds = cmsgdatalen / sizeof(int);
3506 fdp = (int *)CMSG_DATA(cmsgh);
3507 while (numfds-- > 0)
3508 close(*fdp++);
3509 }
3510 if (cmsg_status != 0)
3511 break;
3512 }
3513#endif /* SCM_RIGHTS */
3514 goto finally;
3515}
3516
3517
3518static PyObject *
3519makeval_recvmsg(ssize_t received, void *data)
3520{
3521 PyObject **buf = data;
3522
3523 if (received < PyBytes_GET_SIZE(*buf))
3524 _PyBytes_Resize(buf, received);
3525 Py_XINCREF(*buf);
3526 return *buf;
3527}
3528
3529/* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
3530
3531static PyObject *
3532sock_recvmsg(PySocketSockObject *s, PyObject *args)
3533{
3534 Py_ssize_t bufsize, ancbufsize = 0;
3535 int flags = 0;
3536 struct iovec iov;
3537 PyObject *buf = NULL, *retval = NULL;
3538
3539 if (!PyArg_ParseTuple(args, "n|ni:recvmsg", &bufsize, &ancbufsize, &flags))
3540 return NULL;
3541
3542 if (bufsize < 0) {
3543 PyErr_SetString(PyExc_ValueError, "negative buffer size in recvmsg()");
3544 return NULL;
3545 }
3546 if ((buf = PyBytes_FromStringAndSize(NULL, bufsize)) == NULL)
3547 return NULL;
3548 iov.iov_base = PyBytes_AS_STRING(buf);
3549 iov.iov_len = bufsize;
3550
3551 /* Note that we're passing a pointer to *our pointer* to the bytes
3552 object here (&buf); makeval_recvmsg() may incref the object, or
3553 deallocate it and set our pointer to NULL. */
3554 retval = sock_recvmsg_guts(s, &iov, 1, flags, ancbufsize,
3555 &makeval_recvmsg, &buf);
3556 Py_XDECREF(buf);
3557 return retval;
3558}
3559
3560PyDoc_STRVAR(recvmsg_doc,
3561"recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\
3562\n\
3563Receive normal data (up to bufsize bytes) and ancillary data from the\n\
3564socket. The ancbufsize argument sets the size in bytes of the\n\
3565internal buffer used to receive the ancillary data; it defaults to 0,\n\
3566meaning that no ancillary data will be received. Appropriate buffer\n\
3567sizes for ancillary data can be calculated using CMSG_SPACE() or\n\
3568CMSG_LEN(), and items which do not fit into the buffer might be\n\
3569truncated or discarded. The flags argument defaults to 0 and has the\n\
3570same meaning as for recv().\n\
3571\n\
3572The return value is a 4-tuple: (data, ancdata, msg_flags, address).\n\
3573The data item is a bytes object holding the non-ancillary data\n\
3574received. The ancdata item is a list of zero or more tuples\n\
3575(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n\
3576(control messages) received: cmsg_level and cmsg_type are integers\n\
3577specifying the protocol level and protocol-specific type respectively,\n\
3578and cmsg_data is a bytes object holding the associated data. The\n\
3579msg_flags item is the bitwise OR of various flags indicating\n\
3580conditions on the received message; see your system documentation for\n\
3581details. If the receiving socket is unconnected, address is the\n\
3582address of the sending socket, if available; otherwise, its value is\n\
3583unspecified.\n\
3584\n\
3585If recvmsg() raises an exception after the system call returns, it\n\
3586will first attempt to close any file descriptors received via the\n\
3587SCM_RIGHTS mechanism.");
3588
3589
3590static PyObject *
3591makeval_recvmsg_into(ssize_t received, void *data)
3592{
3593 return PyLong_FromSsize_t(received);
3594}
3595
3596/* s.recvmsg_into(buffers[, ancbufsize[, flags]]) method */
3597
3598static PyObject *
3599sock_recvmsg_into(PySocketSockObject *s, PyObject *args)
3600{
3601 Py_ssize_t ancbufsize = 0;
3602 int flags = 0;
3603 struct iovec *iovs = NULL;
3604 Py_ssize_t i, nitems, nbufs = 0;
3605 Py_buffer *bufs = NULL;
3606 PyObject *buffers_arg, *fast, *retval = NULL;
3607
3608 if (!PyArg_ParseTuple(args, "O|ni:recvmsg_into",
3609 &buffers_arg, &ancbufsize, &flags))
3610 return NULL;
3611
3612 if ((fast = PySequence_Fast(buffers_arg,
3613 "recvmsg_into() argument 1 must be an "
3614 "iterable")) == NULL)
3615 return NULL;
3616 nitems = PySequence_Fast_GET_SIZE(fast);
3617 if (nitems > INT_MAX) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02003618 PyErr_SetString(PyExc_OSError, "recvmsg_into() argument 1 is too long");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003619 goto finally;
3620 }
3621
3622 /* Fill in an iovec for each item, and save the Py_buffer
3623 structs to release afterwards. */
3624 if (nitems > 0 && ((iovs = PyMem_New(struct iovec, nitems)) == NULL ||
3625 (bufs = PyMem_New(Py_buffer, nitems)) == NULL)) {
3626 PyErr_NoMemory();
3627 goto finally;
3628 }
3629 for (; nbufs < nitems; nbufs++) {
3630 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(fast, nbufs),
3631 "w*;recvmsg_into() argument 1 must be an iterable "
3632 "of single-segment read-write buffers",
3633 &bufs[nbufs]))
3634 goto finally;
3635 iovs[nbufs].iov_base = bufs[nbufs].buf;
3636 iovs[nbufs].iov_len = bufs[nbufs].len;
3637 }
3638
3639 retval = sock_recvmsg_guts(s, iovs, nitems, flags, ancbufsize,
3640 &makeval_recvmsg_into, NULL);
3641finally:
3642 for (i = 0; i < nbufs; i++)
3643 PyBuffer_Release(&bufs[i]);
3644 PyMem_Free(bufs);
3645 PyMem_Free(iovs);
3646 Py_DECREF(fast);
3647 return retval;
3648}
3649
3650PyDoc_STRVAR(recvmsg_into_doc,
3651"recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\
3652\n\
3653Receive normal data and ancillary data from the socket, scattering the\n\
3654non-ancillary data into a series of buffers. The buffers argument\n\
3655must be an iterable of objects that export writable buffers\n\
3656(e.g. bytearray objects); these will be filled with successive chunks\n\
3657of the non-ancillary data until it has all been written or there are\n\
3658no more buffers. The ancbufsize argument sets the size in bytes of\n\
3659the internal buffer used to receive the ancillary data; it defaults to\n\
36600, meaning that no ancillary data will be received. Appropriate\n\
3661buffer sizes for ancillary data can be calculated using CMSG_SPACE()\n\
3662or CMSG_LEN(), and items which do not fit into the buffer might be\n\
3663truncated or discarded. The flags argument defaults to 0 and has the\n\
3664same meaning as for recv().\n\
3665\n\
3666The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\n\
3667The nbytes item is the total number of bytes of non-ancillary data\n\
3668written into the buffers. The ancdata item is a list of zero or more\n\
3669tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\n\
3670data (control messages) received: cmsg_level and cmsg_type are\n\
3671integers specifying the protocol level and protocol-specific type\n\
3672respectively, and cmsg_data is a bytes object holding the associated\n\
3673data. The msg_flags item is the bitwise OR of various flags\n\
3674indicating conditions on the received message; see your system\n\
3675documentation for details. If the receiving socket is unconnected,\n\
3676address is the address of the sending socket, if available; otherwise,\n\
3677its value is unspecified.\n\
3678\n\
3679If recvmsg_into() raises an exception after the system call returns,\n\
3680it will first attempt to close any file descriptors received via the\n\
3681SCM_RIGHTS mechanism.");
3682#endif /* CMSG_LEN */
3683
3684
Victor Stinner31bf2d52015-04-01 21:57:09 +02003685struct sock_send {
3686 char *buf;
3687 Py_ssize_t len;
3688 int flags;
3689 Py_ssize_t result;
3690};
3691
3692static int
3693sock_send_impl(PySocketSockObject *s, void *data)
3694{
3695 struct sock_send *ctx = data;
3696
3697#ifdef MS_WINDOWS
3698 if (ctx->len > INT_MAX)
3699 ctx->len = INT_MAX;
3700 ctx->result = send(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags);
3701#else
3702 ctx->result = send(s->sock_fd, ctx->buf, ctx->len, ctx->flags);
3703#endif
3704 return (ctx->result >= 0);
3705}
3706
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003707/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003708
Guido van Rossum73624e91994-10-10 17:59:00 +00003709static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003710sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003711{
Victor Stinner31bf2d52015-04-01 21:57:09 +02003712 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003713 Py_buffer pbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003714 struct sock_send ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003715
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003716 if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
3717 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003718
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003719 if (!IS_SELECTABLE(s)) {
3720 PyBuffer_Release(&pbuf);
3721 return select_error();
3722 }
Victor Stinner31bf2d52015-04-01 21:57:09 +02003723 ctx.buf = pbuf.buf;
3724 ctx.len = pbuf.len;
3725 ctx.flags = flags;
3726 if (sock_call(s, 1, sock_send_impl, &ctx) < 0) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003727 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003728 return NULL;
3729 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003730 PyBuffer_Release(&pbuf);
Victor Stinner31bf2d52015-04-01 21:57:09 +02003731
3732 return PyLong_FromSsize_t(ctx.result);
Guido van Rossum30a685f1991-06-27 15:51:29 +00003733}
3734
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003735PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003736"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003737\n\
3738Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003739argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003740sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003741
3742
3743/* s.sendall(data [,flags]) method */
3744
3745static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003746sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003747{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003748 char *buf;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003749 Py_ssize_t len, n;
3750 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003751 Py_buffer pbuf;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003752 struct sock_send ctx;
Victor Stinner8912d142015-04-06 23:16:34 +02003753 int has_timeout = (s->sock_timeout > 0);
3754 _PyTime_t interval = s->sock_timeout;
3755 _PyTime_t deadline = 0;
3756 int deadline_initialized = 0;
3757 PyObject *res = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003758
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003759 if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
3760 return NULL;
3761 buf = pbuf.buf;
3762 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003763
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003764 if (!IS_SELECTABLE(s)) {
3765 PyBuffer_Release(&pbuf);
3766 return select_error();
3767 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003768
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003769 do {
Victor Stinner8912d142015-04-06 23:16:34 +02003770 if (has_timeout) {
3771 if (deadline_initialized) {
3772 /* recompute the timeout */
3773 interval = deadline - _PyTime_GetMonotonicClock();
3774 }
3775 else {
3776 deadline_initialized = 1;
3777 deadline = _PyTime_GetMonotonicClock() + s->sock_timeout;
3778 }
3779
3780 if (interval <= 0) {
3781 PyErr_SetString(socket_timeout, "timed out");
3782 goto done;
3783 }
3784 }
3785
Victor Stinner02f32ab2015-04-01 22:53:26 +02003786 ctx.buf = buf;
3787 ctx.len = len;
3788 ctx.flags = flags;
Victor Stinner8912d142015-04-06 23:16:34 +02003789 if (sock_call_ex(s, 1, sock_send_impl, &ctx, 0, NULL, interval) < 0)
3790 goto done;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003791 n = ctx.result;
3792 assert(n >= 0);
3793
3794 buf += n;
3795 len -= n;
3796
3797 /* We must run our signal handlers before looping again.
3798 send() can return a successful partial write when it is
3799 interrupted, so we can't restrict ourselves to EINTR. */
Victor Stinner8912d142015-04-06 23:16:34 +02003800 if (PyErr_CheckSignals())
3801 goto done;
Victor Stinner02f32ab2015-04-01 22:53:26 +02003802 } while (len > 0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003803 PyBuffer_Release(&pbuf);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003804
Victor Stinner8912d142015-04-06 23:16:34 +02003805 Py_INCREF(Py_None);
3806 res = Py_None;
3807
3808done:
3809 PyBuffer_Release(&pbuf);
3810 return res;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003811}
3812
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003813PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003814"sendall(data[, flags])\n\
3815\n\
3816Send a data string to the socket. For the optional flags\n\
3817argument, see the Unix manual. This calls send() repeatedly\n\
3818until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003819to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003820
Guido van Rossum30a685f1991-06-27 15:51:29 +00003821
Victor Stinner31bf2d52015-04-01 21:57:09 +02003822struct sock_sendto {
3823 char *buf;
3824 Py_ssize_t len;
3825 int flags;
3826 int addrlen;
3827 sock_addr_t *addrbuf;
3828 Py_ssize_t result;
3829};
3830
3831static int
3832sock_sendto_impl(PySocketSockObject *s, void *data)
3833{
3834 struct sock_sendto *ctx = data;
3835
3836#ifdef MS_WINDOWS
3837 if (ctx->len > INT_MAX)
3838 ctx->len = INT_MAX;
3839 ctx->result = sendto(s->sock_fd, ctx->buf, (int)ctx->len, ctx->flags,
3840 SAS2SA(ctx->addrbuf), ctx->addrlen);
3841#else
3842 ctx->result = sendto(s->sock_fd, ctx->buf, ctx->len, ctx->flags,
3843 SAS2SA(ctx->addrbuf), ctx->addrlen);
3844#endif
3845 return (ctx->result >= 0);
3846}
3847
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003848/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003849
Guido van Rossum73624e91994-10-10 17:59:00 +00003850static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003851sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003852{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003853 Py_buffer pbuf;
3854 PyObject *addro;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003855 Py_ssize_t arglen;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003856 sock_addr_t addrbuf;
Victor Stinner31bf2d52015-04-01 21:57:09 +02003857 int addrlen, flags;
3858 struct sock_sendto ctx;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003859
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003860 flags = 0;
Antoine Pitrou5e981412011-03-17 22:38:37 +01003861 arglen = PyTuple_Size(args);
3862 switch (arglen) {
3863 case 2:
3864 PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro);
3865 break;
3866 case 3:
3867 PyArg_ParseTuple(args, "y*iO:sendto",
3868 &pbuf, &flags, &addro);
3869 break;
3870 default:
3871 PyErr_Format(PyExc_TypeError,
3872 "sendto() takes 2 or 3 arguments (%d given)",
3873 arglen);
Victor Stinner77af1722011-05-26 14:05:59 +02003874 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003875 }
Antoine Pitrou5e981412011-03-17 22:38:37 +01003876 if (PyErr_Occurred())
3877 return NULL;
3878
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003879 if (!IS_SELECTABLE(s)) {
3880 PyBuffer_Release(&pbuf);
3881 return select_error();
3882 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003883
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003884 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
3885 PyBuffer_Release(&pbuf);
3886 return NULL;
3887 }
Thomas Wouters89f507f2006-12-13 04:49:30 +00003888
Victor Stinner31bf2d52015-04-01 21:57:09 +02003889 ctx.buf = pbuf.buf;
3890 ctx.len = pbuf.len;
3891 ctx.flags = flags;
3892 ctx.addrlen = addrlen;
3893 ctx.addrbuf = &addrbuf;
3894 if (sock_call(s, 1, sock_sendto_impl, &ctx) < 0) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003895 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003896 return NULL;
3897 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003898 PyBuffer_Release(&pbuf);
Victor Stinner31bf2d52015-04-01 21:57:09 +02003899
3900 return PyLong_FromSsize_t(ctx.result);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003901}
3902
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003903PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003904"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003905\n\
3906Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003907For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003908
Guido van Rossum30a685f1991-06-27 15:51:29 +00003909
Victor Stinner35bee932015-04-02 12:28:07 +02003910/* The sendmsg() and recvmsg[_into]() methods require a working
3911 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3912#ifdef CMSG_LEN
Victor Stinner31bf2d52015-04-01 21:57:09 +02003913struct sock_sendmsg {
3914 struct msghdr *msg;
3915 int flags;
3916 ssize_t result;
3917};
3918
3919static int
Christian Heimesdffa3942016-09-05 23:54:41 +02003920sock_sendmsg_iovec(PySocketSockObject *s, PyObject *data_arg,
3921 struct msghdr *msg,
3922 Py_buffer **databufsout, Py_ssize_t *ndatabufsout) {
3923 Py_ssize_t ndataparts, ndatabufs = 0;
3924 int result = -1;
3925 struct iovec *iovs = NULL;
3926 PyObject *data_fast = NULL;
3927 Py_buffer *databufs = NULL;
3928
3929 /* Fill in an iovec for each message part, and save the Py_buffer
3930 structs to release afterwards. */
Victor Stinner288b5bf2016-09-12 11:45:59 +02003931 data_fast = PySequence_Fast(data_arg,
3932 "sendmsg() argument 1 must be an "
3933 "iterable");
3934 if (data_fast == NULL) {
Christian Heimesdffa3942016-09-05 23:54:41 +02003935 goto finally;
Victor Stinner288b5bf2016-09-12 11:45:59 +02003936 }
3937
Christian Heimesdffa3942016-09-05 23:54:41 +02003938 ndataparts = PySequence_Fast_GET_SIZE(data_fast);
3939 if (ndataparts > INT_MAX) {
3940 PyErr_SetString(PyExc_OSError, "sendmsg() argument 1 is too long");
3941 goto finally;
3942 }
Victor Stinner288b5bf2016-09-12 11:45:59 +02003943
Christian Heimesdffa3942016-09-05 23:54:41 +02003944 msg->msg_iovlen = ndataparts;
Victor Stinner288b5bf2016-09-12 11:45:59 +02003945 if (ndataparts > 0) {
3946 iovs = PyMem_New(struct iovec, ndataparts);
3947 if (iovs == NULL) {
3948 PyErr_NoMemory();
3949 goto finally;
3950 }
3951 msg->msg_iov = iovs;
3952
3953 databufs = PyMem_New(Py_buffer, ndataparts);
Christian Heimesfaf2cea2016-09-13 10:07:16 +02003954 if (databufs == NULL) {
Victor Stinner288b5bf2016-09-12 11:45:59 +02003955 PyErr_NoMemory();
3956 goto finally;
3957 }
Christian Heimesdffa3942016-09-05 23:54:41 +02003958 }
3959 for (; ndatabufs < ndataparts; ndatabufs++) {
3960 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(data_fast, ndatabufs),
3961 "y*;sendmsg() argument 1 must be an iterable of "
3962 "bytes-like objects",
3963 &databufs[ndatabufs]))
3964 goto finally;
3965 iovs[ndatabufs].iov_base = databufs[ndatabufs].buf;
3966 iovs[ndatabufs].iov_len = databufs[ndatabufs].len;
3967 }
3968 result = 0;
3969 finally:
3970 *databufsout = databufs;
3971 *ndatabufsout = ndatabufs;
3972 Py_XDECREF(data_fast);
3973 return result;
3974}
3975
3976static int
Victor Stinner31bf2d52015-04-01 21:57:09 +02003977sock_sendmsg_impl(PySocketSockObject *s, void *data)
3978{
3979 struct sock_sendmsg *ctx = data;
3980
3981 ctx->result = sendmsg(s->sock_fd, ctx->msg, ctx->flags);
3982 return (ctx->result >= 0);
3983}
3984
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003985/* s.sendmsg(buffers[, ancdata[, flags[, address]]]) method */
3986
3987static PyObject *
3988sock_sendmsg(PySocketSockObject *s, PyObject *args)
3989{
Christian Heimesdffa3942016-09-05 23:54:41 +02003990 Py_ssize_t i, ndatabufs = 0, ncmsgs, ncmsgbufs = 0;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003991 Py_buffer *databufs = NULL;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003992 sock_addr_t addrbuf;
Victor Stinner288b5bf2016-09-12 11:45:59 +02003993 struct msghdr msg;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003994 struct cmsginfo {
3995 int level;
3996 int type;
3997 Py_buffer data;
3998 } *cmsgs = NULL;
3999 void *controlbuf = NULL;
4000 size_t controllen, controllen_last;
Victor Stinner31bf2d52015-04-01 21:57:09 +02004001 int addrlen, flags = 0;
Christian Heimesdffa3942016-09-05 23:54:41 +02004002 PyObject *data_arg, *cmsg_arg = NULL, *addr_arg = NULL,
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004003 *cmsg_fast = NULL, *retval = NULL;
Victor Stinner31bf2d52015-04-01 21:57:09 +02004004 struct sock_sendmsg ctx;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004005
4006 if (!PyArg_ParseTuple(args, "O|OiO:sendmsg",
Victor Stinner288b5bf2016-09-12 11:45:59 +02004007 &data_arg, &cmsg_arg, &flags, &addr_arg)) {
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004008 return NULL;
Victor Stinner288b5bf2016-09-12 11:45:59 +02004009 }
4010
4011 memset(&msg, 0, sizeof(msg));
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004012
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004013 /* Parse destination address. */
4014 if (addr_arg != NULL && addr_arg != Py_None) {
4015 if (!getsockaddrarg(s, addr_arg, SAS2SA(&addrbuf), &addrlen))
4016 goto finally;
4017 msg.msg_name = &addrbuf;
4018 msg.msg_namelen = addrlen;
4019 }
4020
4021 /* Fill in an iovec for each message part, and save the Py_buffer
4022 structs to release afterwards. */
Christian Heimesdffa3942016-09-05 23:54:41 +02004023 if (sock_sendmsg_iovec(s, data_arg, &msg, &databufs, &ndatabufs) == -1) {
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004024 goto finally;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004025 }
4026
4027 if (cmsg_arg == NULL)
4028 ncmsgs = 0;
4029 else {
4030 if ((cmsg_fast = PySequence_Fast(cmsg_arg,
4031 "sendmsg() argument 2 must be an "
4032 "iterable")) == NULL)
4033 goto finally;
4034 ncmsgs = PySequence_Fast_GET_SIZE(cmsg_fast);
4035 }
4036
4037#ifndef CMSG_SPACE
4038 if (ncmsgs > 1) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004039 PyErr_SetString(PyExc_OSError,
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004040 "sending multiple control messages is not supported "
4041 "on this system");
4042 goto finally;
4043 }
4044#endif
4045 /* Save level, type and Py_buffer for each control message,
4046 and calculate total size. */
4047 if (ncmsgs > 0 && (cmsgs = PyMem_New(struct cmsginfo, ncmsgs)) == NULL) {
4048 PyErr_NoMemory();
4049 goto finally;
4050 }
4051 controllen = controllen_last = 0;
4052 while (ncmsgbufs < ncmsgs) {
4053 size_t bufsize, space;
4054
4055 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(cmsg_fast, ncmsgbufs),
4056 "(iiy*):[sendmsg() ancillary data items]",
4057 &cmsgs[ncmsgbufs].level,
4058 &cmsgs[ncmsgbufs].type,
4059 &cmsgs[ncmsgbufs].data))
4060 goto finally;
4061 bufsize = cmsgs[ncmsgbufs++].data.len;
4062
4063#ifdef CMSG_SPACE
4064 if (!get_CMSG_SPACE(bufsize, &space)) {
4065#else
4066 if (!get_CMSG_LEN(bufsize, &space)) {
4067#endif
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004068 PyErr_SetString(PyExc_OSError, "ancillary data item too large");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004069 goto finally;
4070 }
4071 controllen += space;
4072 if (controllen > SOCKLEN_T_LIMIT || controllen < controllen_last) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02004073 PyErr_SetString(PyExc_OSError, "too much ancillary data");
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004074 goto finally;
4075 }
4076 controllen_last = controllen;
4077 }
4078
4079 /* Construct ancillary data block from control message info. */
4080 if (ncmsgbufs > 0) {
4081 struct cmsghdr *cmsgh = NULL;
4082
Victor Stinner52d61e42016-09-12 11:41:58 +02004083 controlbuf = PyMem_Malloc(controllen);
4084 if (controlbuf == NULL) {
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004085 PyErr_NoMemory();
4086 goto finally;
4087 }
Victor Stinner52d61e42016-09-12 11:41:58 +02004088 msg.msg_control = controlbuf;
4089
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004090 msg.msg_controllen = controllen;
4091
4092 /* Need to zero out the buffer as a workaround for glibc's
4093 CMSG_NXTHDR() implementation. After getting the pointer to
4094 the next header, it checks its (uninitialized) cmsg_len
4095 member to see if the "message" fits in the buffer, and
4096 returns NULL if it doesn't. Zero-filling the buffer
Terry Jan Reedy0f847642013-03-11 18:34:00 -04004097 ensures that this doesn't happen. */
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004098 memset(controlbuf, 0, controllen);
4099
4100 for (i = 0; i < ncmsgbufs; i++) {
4101 size_t msg_len, data_len = cmsgs[i].data.len;
4102 int enough_space = 0;
4103
4104 cmsgh = (i == 0) ? CMSG_FIRSTHDR(&msg) : CMSG_NXTHDR(&msg, cmsgh);
4105 if (cmsgh == NULL) {
4106 PyErr_Format(PyExc_RuntimeError,
4107 "unexpected NULL result from %s()",
4108 (i == 0) ? "CMSG_FIRSTHDR" : "CMSG_NXTHDR");
4109 goto finally;
4110 }
4111 if (!get_CMSG_LEN(data_len, &msg_len)) {
4112 PyErr_SetString(PyExc_RuntimeError,
4113 "item size out of range for CMSG_LEN()");
4114 goto finally;
4115 }
4116 if (cmsg_min_space(&msg, cmsgh, msg_len)) {
4117 size_t space;
4118
4119 cmsgh->cmsg_len = msg_len;
4120 if (get_cmsg_data_space(&msg, cmsgh, &space))
4121 enough_space = (space >= data_len);
4122 }
4123 if (!enough_space) {
4124 PyErr_SetString(PyExc_RuntimeError,
4125 "ancillary data does not fit in calculated "
4126 "space");
4127 goto finally;
4128 }
4129 cmsgh->cmsg_level = cmsgs[i].level;
4130 cmsgh->cmsg_type = cmsgs[i].type;
4131 memcpy(CMSG_DATA(cmsgh), cmsgs[i].data.buf, data_len);
4132 }
4133 }
4134
4135 /* Make the system call. */
4136 if (!IS_SELECTABLE(s)) {
4137 select_error();
4138 goto finally;
4139 }
4140
Victor Stinner31bf2d52015-04-01 21:57:09 +02004141 ctx.msg = &msg;
4142 ctx.flags = flags;
4143 if (sock_call(s, 1, sock_sendmsg_impl, &ctx) < 0)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004144 goto finally;
Victor Stinner31bf2d52015-04-01 21:57:09 +02004145
4146 retval = PyLong_FromSsize_t(ctx.result);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004147
4148finally:
4149 PyMem_Free(controlbuf);
4150 for (i = 0; i < ncmsgbufs; i++)
4151 PyBuffer_Release(&cmsgs[i].data);
4152 PyMem_Free(cmsgs);
4153 Py_XDECREF(cmsg_fast);
Victor Stinner52d61e42016-09-12 11:41:58 +02004154 PyMem_Free(msg.msg_iov);
4155 for (i = 0; i < ndatabufs; i++) {
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004156 PyBuffer_Release(&databufs[i]);
Victor Stinner52d61e42016-09-12 11:41:58 +02004157 }
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004158 PyMem_Free(databufs);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004159 return retval;
4160}
4161
4162PyDoc_STRVAR(sendmsg_doc,
4163"sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\
4164\n\
4165Send normal and ancillary data to the socket, gathering the\n\
4166non-ancillary data from a series of buffers and concatenating it into\n\
4167a single message. The buffers argument specifies the non-ancillary\n\
Serhiy Storchakab757c832014-12-05 22:25:22 +02004168data as an iterable of bytes-like objects (e.g. bytes objects).\n\
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004169The ancdata argument specifies the ancillary data (control messages)\n\
4170as an iterable of zero or more tuples (cmsg_level, cmsg_type,\n\
4171cmsg_data), where cmsg_level and cmsg_type are integers specifying the\n\
4172protocol level and protocol-specific type respectively, and cmsg_data\n\
Serhiy Storchakab757c832014-12-05 22:25:22 +02004173is a bytes-like object holding the associated data. The flags\n\
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004174argument defaults to 0 and has the same meaning as for send(). If\n\
4175address is supplied and not None, it sets a destination address for\n\
4176the message. The return value is the number of bytes of non-ancillary\n\
4177data sent.");
4178#endif /* CMSG_LEN */
4179
Christian Heimesdffa3942016-09-05 23:54:41 +02004180#ifdef HAVE_SOCKADDR_ALG
4181static PyObject*
4182sock_sendmsg_afalg(PySocketSockObject *self, PyObject *args, PyObject *kwds)
4183{
4184 PyObject *retval = NULL;
4185
4186 Py_ssize_t i, ndatabufs = 0;
4187 Py_buffer *databufs = NULL;
4188 PyObject *data_arg = NULL;
4189
4190 Py_buffer iv = {NULL, NULL};
4191
4192 PyObject *opobj = NULL;
4193 int op = -1;
4194
4195 PyObject *assoclenobj = NULL;
4196 int assoclen = -1;
4197
4198 unsigned int *uiptr;
4199 int flags = 0;
4200
4201 struct msghdr msg;
4202 struct cmsghdr *header = NULL;
4203 struct af_alg_iv *alg_iv = NULL;
4204 struct sock_sendmsg ctx;
4205 Py_ssize_t controllen;
4206 void *controlbuf = NULL;
4207 static char *keywords[] = {"msg", "op", "iv", "assoclen", "flags", 0};
4208
4209 if (self->sock_family != AF_ALG) {
4210 PyErr_SetString(PyExc_OSError,
4211 "algset is only supported for AF_ALG");
4212 return NULL;
4213 }
4214
4215 if (!PyArg_ParseTupleAndKeywords(args, kwds,
4216 "|O$O!y*O!i:sendmsg_afalg", keywords,
4217 &data_arg,
4218 &PyLong_Type, &opobj, &iv,
Victor Stinner288b5bf2016-09-12 11:45:59 +02004219 &PyLong_Type, &assoclenobj, &flags)) {
Christian Heimesdffa3942016-09-05 23:54:41 +02004220 return NULL;
Victor Stinner288b5bf2016-09-12 11:45:59 +02004221 }
4222
4223 memset(&msg, 0, sizeof(msg));
Christian Heimesdffa3942016-09-05 23:54:41 +02004224
4225 /* op is a required, keyword-only argument >= 0 */
4226 if (opobj != NULL) {
4227 op = _PyLong_AsInt(opobj);
4228 }
4229 if (op < 0) {
4230 /* override exception from _PyLong_AsInt() */
4231 PyErr_SetString(PyExc_TypeError,
4232 "Invalid or missing argument 'op'");
4233 goto finally;
4234 }
4235 /* assoclen is optional but must be >= 0 */
4236 if (assoclenobj != NULL) {
4237 assoclen = _PyLong_AsInt(assoclenobj);
4238 if (assoclen == -1 && PyErr_Occurred()) {
4239 goto finally;
4240 }
4241 if (assoclen < 0) {
4242 PyErr_SetString(PyExc_TypeError,
4243 "assoclen must be positive");
4244 goto finally;
4245 }
4246 }
4247
4248 controllen = CMSG_SPACE(4);
4249 if (iv.buf != NULL) {
4250 controllen += CMSG_SPACE(sizeof(*alg_iv) + iv.len);
4251 }
4252 if (assoclen >= 0) {
4253 controllen += CMSG_SPACE(4);
4254 }
4255
4256 controlbuf = PyMem_Malloc(controllen);
4257 if (controlbuf == NULL) {
Victor Stinner52d61e42016-09-12 11:41:58 +02004258 PyErr_NoMemory();
4259 goto finally;
Christian Heimesdffa3942016-09-05 23:54:41 +02004260 }
4261 memset(controlbuf, 0, controllen);
4262
Christian Heimesdffa3942016-09-05 23:54:41 +02004263 msg.msg_controllen = controllen;
4264 msg.msg_control = controlbuf;
4265
4266 /* Fill in an iovec for each message part, and save the Py_buffer
4267 structs to release afterwards. */
4268 if (data_arg != NULL) {
4269 if (sock_sendmsg_iovec(self, data_arg, &msg, &databufs, &ndatabufs) == -1) {
4270 goto finally;
4271 }
4272 }
4273
4274 /* set operation to encrypt or decrypt */
4275 header = CMSG_FIRSTHDR(&msg);
4276 if (header == NULL) {
4277 PyErr_SetString(PyExc_RuntimeError,
4278 "unexpected NULL result from CMSG_FIRSTHDR");
4279 goto finally;
4280 }
4281 header->cmsg_level = SOL_ALG;
4282 header->cmsg_type = ALG_SET_OP;
4283 header->cmsg_len = CMSG_LEN(4);
4284 uiptr = (void*)CMSG_DATA(header);
4285 *uiptr = (unsigned int)op;
4286
4287 /* set initialization vector */
4288 if (iv.buf != NULL) {
4289 header = CMSG_NXTHDR(&msg, header);
4290 if (header == NULL) {
4291 PyErr_SetString(PyExc_RuntimeError,
4292 "unexpected NULL result from CMSG_NXTHDR(iv)");
4293 goto finally;
4294 }
4295 header->cmsg_level = SOL_ALG;
4296 header->cmsg_type = ALG_SET_IV;
4297 header->cmsg_len = CMSG_SPACE(sizeof(*alg_iv) + iv.len);
4298 alg_iv = (void*)CMSG_DATA(header);
4299 alg_iv->ivlen = iv.len;
4300 memcpy(alg_iv->iv, iv.buf, iv.len);
4301 }
4302
4303 /* set length of associated data for AEAD */
4304 if (assoclen >= 0) {
4305 header = CMSG_NXTHDR(&msg, header);
4306 if (header == NULL) {
4307 PyErr_SetString(PyExc_RuntimeError,
4308 "unexpected NULL result from CMSG_NXTHDR(assoc)");
4309 goto finally;
4310 }
4311 header->cmsg_level = SOL_ALG;
4312 header->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
4313 header->cmsg_len = CMSG_LEN(4);
4314 uiptr = (void*)CMSG_DATA(header);
4315 *uiptr = (unsigned int)assoclen;
4316 }
4317
4318 ctx.msg = &msg;
4319 ctx.flags = flags;
Victor Stinner288b5bf2016-09-12 11:45:59 +02004320 if (sock_call(self, 1, sock_sendmsg_impl, &ctx) < 0) {
Christian Heimesdffa3942016-09-05 23:54:41 +02004321 goto finally;
Victor Stinner288b5bf2016-09-12 11:45:59 +02004322 }
Christian Heimesdffa3942016-09-05 23:54:41 +02004323
4324 retval = PyLong_FromSsize_t(ctx.result);
4325
4326 finally:
4327 PyMem_Free(controlbuf);
4328 if (iv.buf != NULL) {
4329 PyBuffer_Release(&iv);
4330 }
Victor Stinner52d61e42016-09-12 11:41:58 +02004331 PyMem_Free(msg.msg_iov);
4332 for (i = 0; i < ndatabufs; i++) {
Christian Heimesdffa3942016-09-05 23:54:41 +02004333 PyBuffer_Release(&databufs[i]);
Victor Stinner52d61e42016-09-12 11:41:58 +02004334 }
Christian Heimesdffa3942016-09-05 23:54:41 +02004335 PyMem_Free(databufs);
4336 return retval;
4337}
4338
4339PyDoc_STRVAR(sendmsg_afalg_doc,
4340"sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])\n\
4341\n\
4342Set operation mode, IV and length of associated data for an AF_ALG\n\
4343operation socket.");
4344#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004345
Guido van Rossum30a685f1991-06-27 15:51:29 +00004346/* s.shutdown(how) method */
4347
Guido van Rossum73624e91994-10-10 17:59:00 +00004348static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004349sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004350{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004351 int how;
4352 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00004353
Serhiy Storchaka78980432013-01-15 01:12:17 +02004354 how = _PyLong_AsInt(arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004355 if (how == -1 && PyErr_Occurred())
4356 return NULL;
4357 Py_BEGIN_ALLOW_THREADS
4358 res = shutdown(s->sock_fd, how);
4359 Py_END_ALLOW_THREADS
4360 if (res < 0)
4361 return s->errorhandler();
4362 Py_INCREF(Py_None);
4363 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004364}
4365
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004366PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004367"shutdown(flag)\n\
4368\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00004369Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
4370of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004371
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00004372#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Christian Heimesfaf2f632008-01-06 16:59:19 +00004373static PyObject*
4374sock_ioctl(PySocketSockObject *s, PyObject *arg)
4375{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004376 unsigned long cmd = SIO_RCVALL;
4377 PyObject *argO;
4378 DWORD recv;
Christian Heimesfaf2f632008-01-06 16:59:19 +00004379
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004380 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
4381 return NULL;
Christian Heimesfaf2f632008-01-06 16:59:19 +00004382
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004383 switch (cmd) {
4384 case SIO_RCVALL: {
4385 unsigned int option = RCVALL_ON;
4386 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
4387 return NULL;
4388 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
4389 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4390 return set_error();
4391 }
4392 return PyLong_FromUnsignedLong(recv); }
4393 case SIO_KEEPALIVE_VALS: {
4394 struct tcp_keepalive ka;
4395 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
4396 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
4397 return NULL;
4398 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
4399 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4400 return set_error();
4401 }
4402 return PyLong_FromUnsignedLong(recv); }
Steve Dowerea93ac02016-06-17 12:52:18 -07004403#if defined(SIO_LOOPBACK_FAST_PATH)
4404 case SIO_LOOPBACK_FAST_PATH: {
4405 unsigned int option;
4406 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
4407 return NULL;
4408 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
4409 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
4410 return set_error();
4411 }
4412 return PyLong_FromUnsignedLong(recv); }
4413#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004414 default:
4415 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
4416 return NULL;
4417 }
Christian Heimesfaf2f632008-01-06 16:59:19 +00004418}
4419PyDoc_STRVAR(sock_ioctl_doc,
4420"ioctl(cmd, option) -> long\n\
4421\n\
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00004422Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
4423SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
Steve Dowerea93ac02016-06-17 12:52:18 -07004424SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).\n\
4425SIO_LOOPBACK_FAST_PATH: 'option' is a boolean value, and is disabled by default");
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004426#endif
4427
4428#if defined(MS_WINDOWS)
4429static PyObject*
4430sock_share(PySocketSockObject *s, PyObject *arg)
4431{
4432 WSAPROTOCOL_INFO info;
4433 DWORD processId;
4434 int result;
4435
4436 if (!PyArg_ParseTuple(arg, "I", &processId))
4437 return NULL;
4438
4439 Py_BEGIN_ALLOW_THREADS
4440 result = WSADuplicateSocket(s->sock_fd, processId, &info);
4441 Py_END_ALLOW_THREADS
4442 if (result == SOCKET_ERROR)
4443 return set_error();
4444 return PyBytes_FromStringAndSize((const char*)&info, sizeof(info));
4445}
4446PyDoc_STRVAR(sock_share_doc,
4447"share(process_id) -> bytes\n\
4448\n\
4449Share the socket with another process. The target process id\n\
4450must be provided and the resulting bytes object passed to the target\n\
4451process. There the shared socket can be instantiated by calling\n\
4452socket.fromshare().");
4453
Christian Heimesfaf2f632008-01-06 16:59:19 +00004454
4455#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00004456
4457/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004458
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004459static PyMethodDef sock_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004460 {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
4461 accept_doc},
4462 {"bind", (PyCFunction)sock_bind, METH_O,
4463 bind_doc},
4464 {"close", (PyCFunction)sock_close, METH_NOARGS,
4465 close_doc},
4466 {"connect", (PyCFunction)sock_connect, METH_O,
4467 connect_doc},
4468 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
4469 connect_ex_doc},
Antoine Pitrou6e451df2010-08-09 20:39:54 +00004470 {"detach", (PyCFunction)sock_detach, METH_NOARGS,
4471 detach_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004472 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
4473 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00004474#ifdef HAVE_GETPEERNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004475 {"getpeername", (PyCFunction)sock_getpeername,
4476 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00004477#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004478 {"getsockname", (PyCFunction)sock_getsockname,
4479 METH_NOARGS, getsockname_doc},
4480 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
4481 getsockopt_doc},
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00004482#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004483 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
4484 sock_ioctl_doc},
Christian Heimesfaf2f632008-01-06 16:59:19 +00004485#endif
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004486#if defined(MS_WINDOWS)
4487 {"share", (PyCFunction)sock_share, METH_VARARGS,
4488 sock_share_doc},
4489#endif
Charles-François Natali644b8f52014-05-22 19:45:39 +01004490 {"listen", (PyCFunction)sock_listen, METH_VARARGS,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004491 listen_doc},
4492 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
4493 recv_doc},
4494 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
4495 recv_into_doc},
4496 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
4497 recvfrom_doc},
4498 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
4499 recvfrom_into_doc},
4500 {"send", (PyCFunction)sock_send, METH_VARARGS,
4501 send_doc},
4502 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
4503 sendall_doc},
4504 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
4505 sendto_doc},
4506 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
4507 setblocking_doc},
4508 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
4509 settimeout_doc},
4510 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
4511 gettimeout_doc},
4512 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
4513 setsockopt_doc},
4514 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
4515 shutdown_doc},
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004516#ifdef CMSG_LEN
4517 {"recvmsg", (PyCFunction)sock_recvmsg, METH_VARARGS,
4518 recvmsg_doc},
4519 {"recvmsg_into", (PyCFunction)sock_recvmsg_into, METH_VARARGS,
4520 recvmsg_into_doc,},
4521 {"sendmsg", (PyCFunction)sock_sendmsg, METH_VARARGS,
4522 sendmsg_doc},
4523#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02004524#ifdef HAVE_SOCKADDR_ALG
4525 {"sendmsg_afalg", (PyCFunction)sock_sendmsg_afalg, METH_VARARGS | METH_KEYWORDS,
4526 sendmsg_afalg_doc},
4527#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004528 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004529};
4530
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004531/* SockObject members */
4532static PyMemberDef sock_memberlist[] = {
4533 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
4534 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
4535 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004536 {0},
4537};
Guido van Rossum30a685f1991-06-27 15:51:29 +00004538
Victor Stinner71694d52015-03-28 01:18:54 +01004539static PyGetSetDef sock_getsetlist[] = {
4540 {"timeout", (getter)sock_gettimeout, NULL, PyDoc_STR("the socket timeout")},
4541 {NULL} /* sentinel */
4542};
4543
Guido van Rossum73624e91994-10-10 17:59:00 +00004544/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00004545 First close the file description. */
4546
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004547static void
Victor Stinner19a8e842016-03-21 16:36:48 +01004548sock_finalize(PySocketSockObject *s)
4549{
4550 SOCKET_T fd;
4551 PyObject *error_type, *error_value, *error_traceback;
4552
4553 /* Save the current exception, if any. */
4554 PyErr_Fetch(&error_type, &error_value, &error_traceback);
4555
Victor Stinnerd3afb622016-07-22 17:47:09 +02004556 if (s->sock_fd != INVALID_SOCKET) {
Victor Stinner19a8e842016-03-21 16:36:48 +01004557 if (PyErr_ResourceWarning((PyObject *)s, 1, "unclosed %R", s)) {
4558 /* Spurious errors can appear at shutdown */
4559 if (PyErr_ExceptionMatches(PyExc_Warning)) {
4560 PyErr_WriteUnraisable((PyObject *)s);
4561 }
4562 }
4563
4564 /* Only close the socket *after* logging the ResourceWarning warning
4565 to allow the logger to call socket methods like
4566 socket.getsockname(). If the socket is closed before, socket
4567 methods fails with the EBADF error. */
4568 fd = s->sock_fd;
Victor Stinnerd3afb622016-07-22 17:47:09 +02004569 s->sock_fd = INVALID_SOCKET;
Victor Stinner19a8e842016-03-21 16:36:48 +01004570
4571 /* We do not want to retry upon EINTR: see sock_close() */
4572 Py_BEGIN_ALLOW_THREADS
4573 (void) SOCKETCLOSE(fd);
4574 Py_END_ALLOW_THREADS
4575 }
4576
4577 /* Restore the saved exception. */
4578 PyErr_Restore(error_type, error_value, error_traceback);
4579}
4580
4581static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004582sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004583{
Victor Stinner19a8e842016-03-21 16:36:48 +01004584 if (PyObject_CallFinalizerFromDealloc((PyObject *)s) < 0)
4585 return;
4586
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004587 Py_TYPE(s)->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004588}
4589
Guido van Rossum30a685f1991-06-27 15:51:29 +00004590
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004591static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004592sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004593{
Victor Stinnere254e532014-07-26 14:36:55 +02004594 long sock_fd;
4595 /* On Windows, this test is needed because SOCKET_T is unsigned */
4596 if (s->sock_fd == INVALID_SOCKET) {
4597 sock_fd = -1;
4598 }
Fred Drakea04eaad2000-06-30 02:46:07 +00004599#if SIZEOF_SOCKET_T > SIZEOF_LONG
Victor Stinnere254e532014-07-26 14:36:55 +02004600 else if (s->sock_fd > LONG_MAX) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004601 /* this can occur on Win64, and actually there is a special
4602 ugly printf formatter for decimal pointer length integer
4603 printing, only bother if necessary*/
4604 PyErr_SetString(PyExc_OverflowError,
4605 "no printf formatter to display "
4606 "the socket descriptor in decimal");
4607 return NULL;
4608 }
Fred Drakea04eaad2000-06-30 02:46:07 +00004609#endif
Victor Stinnere254e532014-07-26 14:36:55 +02004610 else
4611 sock_fd = (long)s->sock_fd;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004612 return PyUnicode_FromFormat(
4613 "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
Victor Stinnere254e532014-07-26 14:36:55 +02004614 sock_fd, s->sock_family,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004615 s->sock_type,
4616 s->sock_proto);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004617}
4618
4619
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004620/* Create a new, uninitialized socket object. */
4621
4622static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004623sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004624{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004625 PyObject *new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004626
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004627 new = type->tp_alloc(type, 0);
4628 if (new != NULL) {
Victor Stinner524714e2016-07-22 17:43:59 +02004629 ((PySocketSockObject *)new)->sock_fd = INVALID_SOCKET;
Victor Stinner9001d802015-04-06 23:06:01 +02004630 ((PySocketSockObject *)new)->sock_timeout = _PyTime_FromSeconds(-1);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004631 ((PySocketSockObject *)new)->errorhandler = &set_error;
4632 }
4633 return new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004634}
4635
4636
4637/* Initialize a new socket object. */
4638
Victor Stinnerdaf45552013-08-28 00:53:59 +02004639#ifdef SOCK_CLOEXEC
4640/* socket() and socketpair() fail with EINVAL on Linux kernel older
4641 * than 2.6.27 if SOCK_CLOEXEC flag is set in the socket type. */
4642static int sock_cloexec_works = -1;
4643#endif
4644
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004645/*ARGSUSED*/
4646static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00004647sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004648{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004649 PySocketSockObject *s = (PySocketSockObject *)self;
4650 PyObject *fdobj = NULL;
4651 SOCKET_T fd = INVALID_SOCKET;
4652 int family = AF_INET, type = SOCK_STREAM, proto = 0;
4653 static char *keywords[] = {"family", "type", "proto", "fileno", 0};
Victor Stinnerdaf45552013-08-28 00:53:59 +02004654#ifndef MS_WINDOWS
4655#ifdef SOCK_CLOEXEC
4656 int *atomic_flag_works = &sock_cloexec_works;
4657#else
4658 int *atomic_flag_works = NULL;
4659#endif
4660#endif
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004661
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004662 if (!PyArg_ParseTupleAndKeywords(args, kwds,
4663 "|iiiO:socket", keywords,
4664 &family, &type, &proto, &fdobj))
4665 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004667 if (fdobj != NULL && fdobj != Py_None) {
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004668#ifdef MS_WINDOWS
4669 /* recreate a socket that was duplicated */
4670 if (PyBytes_Check(fdobj)) {
4671 WSAPROTOCOL_INFO info;
4672 if (PyBytes_GET_SIZE(fdobj) != sizeof(info)) {
4673 PyErr_Format(PyExc_ValueError,
4674 "socket descriptor string has wrong size, "
4675 "should be %zu bytes.", sizeof(info));
4676 return -1;
4677 }
4678 memcpy(&info, PyBytes_AS_STRING(fdobj), sizeof(info));
4679 Py_BEGIN_ALLOW_THREADS
4680 fd = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
4681 FROM_PROTOCOL_INFO, &info, 0, WSA_FLAG_OVERLAPPED);
4682 Py_END_ALLOW_THREADS
4683 if (fd == INVALID_SOCKET) {
4684 set_error();
4685 return -1;
4686 }
4687 family = info.iAddressFamily;
4688 type = info.iSocketType;
4689 proto = info.iProtocol;
4690 }
4691 else
4692#endif
4693 {
4694 fd = PyLong_AsSocket_t(fdobj);
4695 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
4696 return -1;
4697 if (fd == INVALID_SOCKET) {
4698 PyErr_SetString(PyExc_ValueError,
4699 "can't use invalid socket value");
4700 return -1;
4701 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004702 }
4703 }
4704 else {
Victor Stinnerdaf45552013-08-28 00:53:59 +02004705#ifdef MS_WINDOWS
4706 /* Windows implementation */
4707#ifndef WSA_FLAG_NO_HANDLE_INHERIT
4708#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
4709#endif
4710
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004711 Py_BEGIN_ALLOW_THREADS
Victor Stinnerdaf45552013-08-28 00:53:59 +02004712 if (support_wsa_no_inherit) {
4713 fd = WSASocket(family, type, proto,
4714 NULL, 0,
4715 WSA_FLAG_OVERLAPPED | WSA_FLAG_NO_HANDLE_INHERIT);
4716 if (fd == INVALID_SOCKET) {
4717 /* Windows 7 or Windows 2008 R2 without SP1 or the hotfix */
4718 support_wsa_no_inherit = 0;
4719 fd = socket(family, type, proto);
4720 }
4721 }
4722 else {
4723 fd = socket(family, type, proto);
4724 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004725 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00004726
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004727 if (fd == INVALID_SOCKET) {
4728 set_error();
4729 return -1;
4730 }
Victor Stinnerdaf45552013-08-28 00:53:59 +02004731
4732 if (!support_wsa_no_inherit) {
4733 if (!SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0)) {
4734 closesocket(fd);
4735 PyErr_SetFromWindowsErr(0);
4736 return -1;
4737 }
4738 }
4739#else
4740 /* UNIX */
4741 Py_BEGIN_ALLOW_THREADS
4742#ifdef SOCK_CLOEXEC
4743 if (sock_cloexec_works != 0) {
4744 fd = socket(family, type | SOCK_CLOEXEC, proto);
4745 if (sock_cloexec_works == -1) {
4746 if (fd >= 0) {
4747 sock_cloexec_works = 1;
4748 }
4749 else if (errno == EINVAL) {
4750 /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
4751 sock_cloexec_works = 0;
4752 fd = socket(family, type, proto);
4753 }
4754 }
4755 }
4756 else
4757#endif
4758 {
4759 fd = socket(family, type, proto);
4760 }
4761 Py_END_ALLOW_THREADS
4762
4763 if (fd == INVALID_SOCKET) {
4764 set_error();
4765 return -1;
4766 }
4767
4768 if (_Py_set_inheritable(fd, 0, atomic_flag_works) < 0) {
4769 SOCKETCLOSE(fd);
4770 return -1;
4771 }
4772#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004773 }
Christian Heimes0b9d64e2016-09-09 00:28:57 +02004774 if (init_sockobject(s, fd, family, type, proto) == -1) {
4775 SOCKETCLOSE(fd);
4776 return -1;
4777 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004778
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004779 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004780
Guido van Rossum384ca9c2001-10-27 22:20:47 +00004781}
4782
4783
Guido van Rossumb6775db1994-08-01 11:34:53 +00004784/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00004785
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004786static PyTypeObject sock_type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004787 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
4788 "_socket.socket", /* tp_name */
4789 sizeof(PySocketSockObject), /* tp_basicsize */
4790 0, /* tp_itemsize */
4791 (destructor)sock_dealloc, /* tp_dealloc */
4792 0, /* tp_print */
4793 0, /* tp_getattr */
4794 0, /* tp_setattr */
4795 0, /* tp_reserved */
4796 (reprfunc)sock_repr, /* tp_repr */
4797 0, /* tp_as_number */
4798 0, /* tp_as_sequence */
4799 0, /* tp_as_mapping */
4800 0, /* tp_hash */
4801 0, /* tp_call */
4802 0, /* tp_str */
4803 PyObject_GenericGetAttr, /* tp_getattro */
4804 0, /* tp_setattro */
4805 0, /* tp_as_buffer */
Victor Stinner19a8e842016-03-21 16:36:48 +01004806 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
4807 | Py_TPFLAGS_HAVE_FINALIZE, /* tp_flags */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004808 sock_doc, /* tp_doc */
4809 0, /* tp_traverse */
4810 0, /* tp_clear */
4811 0, /* tp_richcompare */
4812 0, /* tp_weaklistoffset */
4813 0, /* tp_iter */
4814 0, /* tp_iternext */
4815 sock_methods, /* tp_methods */
4816 sock_memberlist, /* tp_members */
Victor Stinner71694d52015-03-28 01:18:54 +01004817 sock_getsetlist, /* tp_getset */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004818 0, /* tp_base */
4819 0, /* tp_dict */
4820 0, /* tp_descr_get */
4821 0, /* tp_descr_set */
4822 0, /* tp_dictoffset */
4823 sock_initobj, /* tp_init */
4824 PyType_GenericAlloc, /* tp_alloc */
4825 sock_new, /* tp_new */
4826 PyObject_Del, /* tp_free */
Victor Stinner19a8e842016-03-21 16:36:48 +01004827 0, /* tp_is_gc */
4828 0, /* tp_bases */
4829 0, /* tp_mro */
4830 0, /* tp_cache */
4831 0, /* tp_subclasses */
4832 0, /* tp_weaklist */
4833 0, /* tp_del */
4834 0, /* tp_version_tag */
4835 (destructor)sock_finalize, /* tp_finalize */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004836};
4837
Guido van Rossum30a685f1991-06-27 15:51:29 +00004838
Guido van Rossum81194471991-07-27 21:42:02 +00004839/* Python interface to gethostname(). */
4840
4841/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004842static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00004843socket_gethostname(PyObject *self, PyObject *unused)
Guido van Rossum81194471991-07-27 21:42:02 +00004844{
Martin v. Löwis72f48422010-10-29 18:20:08 +00004845#ifdef MS_WINDOWS
4846 /* Don't use winsock's gethostname, as this returns the ANSI
4847 version of the hostname, whereas we need a Unicode string.
4848 Otherwise, gethostname apparently also returns the DNS name. */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00004849 wchar_t buf[MAX_COMPUTERNAME_LENGTH + 1];
Victor Stinner63941882011-09-29 00:42:28 +02004850 DWORD size = Py_ARRAY_LENGTH(buf);
Victor Stinner74168972011-11-17 01:11:36 +01004851 wchar_t *name;
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00004852 PyObject *result;
Victor Stinner74168972011-11-17 01:11:36 +01004853
4854 if (GetComputerNameExW(ComputerNamePhysicalDnsHostname, buf, &size))
Victor Stinner9d3b93b2011-11-22 02:27:30 +01004855 return PyUnicode_FromWideChar(buf, size);
Victor Stinner74168972011-11-17 01:11:36 +01004856
4857 if (GetLastError() != ERROR_MORE_DATA)
4858 return PyErr_SetFromWindowsErr(0);
4859
4860 if (size == 0)
4861 return PyUnicode_New(0, 0);
4862
4863 /* MSDN says ERROR_MORE_DATA may occur because DNS allows longer
4864 names */
Serhiy Storchaka1a1ff292015-02-16 13:28:22 +02004865 name = PyMem_New(wchar_t, size);
4866 if (!name) {
4867 PyErr_NoMemory();
Victor Stinner74168972011-11-17 01:11:36 +01004868 return NULL;
Serhiy Storchaka1a1ff292015-02-16 13:28:22 +02004869 }
Victor Stinner74168972011-11-17 01:11:36 +01004870 if (!GetComputerNameExW(ComputerNamePhysicalDnsHostname,
4871 name,
4872 &size))
4873 {
4874 PyMem_Free(name);
4875 return PyErr_SetFromWindowsErr(0);
Martin v. Löwis72f48422010-10-29 18:20:08 +00004876 }
Victor Stinner74168972011-11-17 01:11:36 +01004877
4878 result = PyUnicode_FromWideChar(name, size);
4879 PyMem_Free(name);
4880 return result;
Martin v. Löwis72f48422010-10-29 18:20:08 +00004881#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004882 char buf[1024];
4883 int res;
4884 Py_BEGIN_ALLOW_THREADS
4885 res = gethostname(buf, (int) sizeof buf - 1);
4886 Py_END_ALLOW_THREADS
4887 if (res < 0)
4888 return set_error();
4889 buf[sizeof buf - 1] = '\0';
Victor Stinnera534fc42013-06-03 22:07:27 +02004890 return PyUnicode_DecodeFSDefault(buf);
Martin v. Löwis72f48422010-10-29 18:20:08 +00004891#endif
Guido van Rossum81194471991-07-27 21:42:02 +00004892}
Guido van Rossumff4949e1992-08-05 19:58:53 +00004893
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004894PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004895"gethostname() -> string\n\
4896\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004897Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004898
Antoine Pitrou061cfb52011-02-28 22:25:22 +00004899#ifdef HAVE_SETHOSTNAME
4900PyDoc_STRVAR(sethostname_doc,
4901"sethostname(name)\n\n\
4902Sets the hostname to name.");
4903
4904static PyObject *
4905socket_sethostname(PyObject *self, PyObject *args)
4906{
4907 PyObject *hnobj;
4908 Py_buffer buf;
4909 int res, flag = 0;
4910
Christian Heimesd2774c72013-06-19 02:06:29 +02004911#ifdef _AIX
4912/* issue #18259, not declared in any useful header file */
4913extern int sethostname(const char *, size_t);
4914#endif
4915
Antoine Pitrou061cfb52011-02-28 22:25:22 +00004916 if (!PyArg_ParseTuple(args, "S:sethostname", &hnobj)) {
4917 PyErr_Clear();
4918 if (!PyArg_ParseTuple(args, "O&:sethostname",
4919 PyUnicode_FSConverter, &hnobj))
4920 return NULL;
4921 flag = 1;
4922 }
4923 res = PyObject_GetBuffer(hnobj, &buf, PyBUF_SIMPLE);
4924 if (!res) {
4925 res = sethostname(buf.buf, buf.len);
4926 PyBuffer_Release(&buf);
4927 }
4928 if (flag)
4929 Py_DECREF(hnobj);
4930 if (res)
4931 return set_error();
4932 Py_RETURN_NONE;
4933}
4934#endif
Guido van Rossumff4949e1992-08-05 19:58:53 +00004935
Guido van Rossum30a685f1991-06-27 15:51:29 +00004936/* Python interface to gethostbyname(name). */
4937
4938/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004939static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004940socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00004941{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004942 char *name;
4943 sock_addr_t addrbuf;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004944 PyObject *ret = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004945
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004946 if (!PyArg_ParseTuple(args, "et:gethostbyname", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004947 return NULL;
4948 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004949 goto finally;
4950 ret = makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
4951finally:
4952 PyMem_Free(name);
4953 return ret;
Guido van Rossum30a685f1991-06-27 15:51:29 +00004954}
4955
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004956PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004957"gethostbyname(host) -> address\n\
4958\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004959Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004960
4961
Victor Stinner72400302016-01-28 15:41:01 +01004962static PyObject*
4963sock_decode_hostname(const char *name)
4964{
4965#ifdef MS_WINDOWS
4966 /* Issue #26227: gethostbyaddr() returns a string encoded
4967 * to the ANSI code page */
4968 return PyUnicode_DecodeFSDefault(name);
4969#else
4970 /* Decode from UTF-8 */
4971 return PyUnicode_FromString(name);
4972#endif
4973}
4974
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004975/* Convenience function common to gethostbyname_ex and gethostbyaddr */
4976
4977static PyObject *
Victor Stinner1a62a682014-08-17 19:33:28 +02004978gethost_common(struct hostent *h, struct sockaddr *addr, size_t alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004979{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004980 char **pch;
4981 PyObject *rtn_tuple = (PyObject *)NULL;
4982 PyObject *name_list = (PyObject *)NULL;
4983 PyObject *addr_list = (PyObject *)NULL;
4984 PyObject *tmp;
Victor Stinner72400302016-01-28 15:41:01 +01004985 PyObject *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004986
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004987 if (h == NULL) {
4988 /* Let's get real error message to return */
4989 set_herror(h_errno);
4990 return NULL;
4991 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004992
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004993 if (h->h_addrtype != af) {
4994 /* Let's get real error message to return */
Victor Stinner1f33f2b2011-12-17 04:45:09 +01004995 errno = EAFNOSUPPORT;
4996 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004997 return NULL;
4998 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004999
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005000 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00005001
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005002 case AF_INET:
5003 if (alen < sizeof(struct sockaddr_in))
5004 return NULL;
5005 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005006
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00005007#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005008 case AF_INET6:
5009 if (alen < sizeof(struct sockaddr_in6))
5010 return NULL;
5011 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005012#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00005013
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005014 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00005015
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005016 if ((name_list = PyList_New(0)) == NULL)
5017 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005018
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005019 if ((addr_list = PyList_New(0)) == NULL)
5020 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005022 /* SF #1511317: h_aliases can be NULL */
5023 if (h->h_aliases) {
5024 for (pch = h->h_aliases; *pch != NULL; pch++) {
5025 int status;
5026 tmp = PyUnicode_FromString(*pch);
5027 if (tmp == NULL)
5028 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005029
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005030 status = PyList_Append(name_list, tmp);
5031 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00005032
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005033 if (status)
5034 goto err;
5035 }
5036 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00005037
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005038 for (pch = h->h_addr_list; *pch != NULL; pch++) {
5039 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005040
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005041 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00005042
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005043 case AF_INET:
5044 {
5045 struct sockaddr_in sin;
5046 memset(&sin, 0, sizeof(sin));
5047 sin.sin_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005048#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005049 sin.sin_len = sizeof(sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005050#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005051 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
5052 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00005053
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005054 if (pch == h->h_addr_list && alen >= sizeof(sin))
5055 memcpy((char *) addr, &sin, sizeof(sin));
5056 break;
5057 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00005058
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00005059#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005060 case AF_INET6:
5061 {
5062 struct sockaddr_in6 sin6;
5063 memset(&sin6, 0, sizeof(sin6));
5064 sin6.sin6_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005065#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005066 sin6.sin6_len = sizeof(sin6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005067#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005068 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
5069 tmp = makeipaddr((struct sockaddr *)&sin6,
5070 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00005071
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005072 if (pch == h->h_addr_list && alen >= sizeof(sin6))
5073 memcpy((char *) addr, &sin6, sizeof(sin6));
5074 break;
5075 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005076#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00005077
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005078 default: /* can't happen */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005079 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005080 "unsupported address family");
5081 return NULL;
5082 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00005083
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005084 if (tmp == NULL)
5085 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00005086
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005087 status = PyList_Append(addr_list, tmp);
5088 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00005089
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005090 if (status)
5091 goto err;
5092 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00005093
Victor Stinner72400302016-01-28 15:41:01 +01005094 name = sock_decode_hostname(h->h_name);
5095 if (name == NULL)
5096 goto err;
5097 rtn_tuple = Py_BuildValue("NOO", name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00005098
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005099 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005100 Py_XDECREF(name_list);
5101 Py_XDECREF(addr_list);
5102 return rtn_tuple;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005103}
5104
5105
5106/* Python interface to gethostbyname_ex(name). */
5107
5108/*ARGSUSED*/
5109static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005110socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005111{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005112 char *name;
5113 struct hostent *h;
Charles-François Natali8b759652011-12-23 16:44:51 +01005114 sock_addr_t addr;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005115 struct sockaddr *sa;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005116 PyObject *ret = NULL;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005117#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005118 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005119#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005120 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005121#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005122 char buf[16384];
5123 int buf_len = (sizeof buf) - 1;
5124 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005125#endif
Ross Lagerwall8c159762012-03-06 21:36:18 +02005126#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005127 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00005128#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005129#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005130
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005131 if (!PyArg_ParseTuple(args, "et:gethostbyname_ex", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005132 return NULL;
Charles-François Natali8b759652011-12-23 16:44:51 +01005133 if (setipaddr(name, SAS2SA(&addr), sizeof(addr), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005134 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005135 Py_BEGIN_ALLOW_THREADS
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005136#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005137#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Ross Lagerwall8c159762012-03-06 21:36:18 +02005138 gethostbyname_r(name, &hp_allocated, buf, buf_len,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005139 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005140#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005141 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005142#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005143 memset((void *) &data, '\0', sizeof(data));
5144 result = gethostbyname_r(name, &hp_allocated, &data);
5145 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00005146#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005147#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00005148#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005149 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005150#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005151 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005152#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005153 Py_END_ALLOW_THREADS
5154 /* Some C libraries would require addr.__ss_family instead of
5155 addr.ss_family.
5156 Therefore, we cast the sockaddr_storage into sockaddr to
5157 access sa_family. */
Charles-François Natali8b759652011-12-23 16:44:51 +01005158 sa = SAS2SA(&addr);
5159 ret = gethost_common(h, SAS2SA(&addr), sizeof(addr),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005160 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00005161#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005162 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00005163#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005164finally:
5165 PyMem_Free(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005166 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005167}
5168
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005169PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005170"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
5171\n\
5172Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005173for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00005174
5175
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00005176/* Python interface to gethostbyaddr(IP). */
5177
5178/*ARGSUSED*/
5179static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005180socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00005181{
Charles-François Natali8b759652011-12-23 16:44:51 +01005182 sock_addr_t addr;
5183 struct sockaddr *sa = SAS2SA(&addr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005184 char *ip_num;
5185 struct hostent *h;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005186 PyObject *ret = NULL;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005187#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005188 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005189#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005190 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005191#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005192 /* glibcs up to 2.10 assume that the buf argument to
5193 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
5194 does not ensure. The attribute below instructs the compiler
5195 to maintain this alignment. */
5196 char buf[16384] Py_ALIGNED(8);
5197 int buf_len = (sizeof buf) - 1;
5198 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005199#endif
Ross Lagerwall8c159762012-03-06 21:36:18 +02005200#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005201 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00005202#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005203#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005204 char *ap;
5205 int al;
5206 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00005207
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005208 if (!PyArg_ParseTuple(args, "et:gethostbyaddr", "idna", &ip_num))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005209 return NULL;
5210 af = AF_UNSPEC;
5211 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005212 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005213 af = sa->sa_family;
5214 ap = NULL;
Brett Cannonb94767f2011-02-22 20:15:44 +00005215 /* al = 0; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005216 switch (af) {
5217 case AF_INET:
5218 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
5219 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
5220 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00005221#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005222 case AF_INET6:
5223 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
5224 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
5225 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005226#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005227 default:
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005228 PyErr_SetString(PyExc_OSError, "unsupported address family");
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005229 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005230 }
5231 Py_BEGIN_ALLOW_THREADS
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005232#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005233#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Ross Lagerwall8c159762012-03-06 21:36:18 +02005234 gethostbyaddr_r(ap, al, af,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005235 &hp_allocated, buf, buf_len,
5236 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005237#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005238 h = gethostbyaddr_r(ap, al, af,
5239 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00005240#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005241 memset((void *) &data, '\0', sizeof(data));
5242 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
5243 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00005244#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005245#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00005246#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005247 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005248#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005249 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005250#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005251 Py_END_ALLOW_THREADS
Charles-François Natali8b759652011-12-23 16:44:51 +01005252 ret = gethost_common(h, SAS2SA(&addr), sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00005253#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005254 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00005255#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00005256finally:
5257 PyMem_Free(ip_num);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005258 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00005259}
5260
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005261PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005262"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
5263\n\
5264Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005265for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005266
Guido van Rossum30a685f1991-06-27 15:51:29 +00005267
5268/* Python interface to getservbyname(name).
5269 This only returns the port number, since the other info is already
5270 known or not useful (like the list of aliases). */
5271
5272/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00005273static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005274socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00005275{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005276 char *name, *proto=NULL;
5277 struct servent *sp;
5278 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
5279 return NULL;
5280 Py_BEGIN_ALLOW_THREADS
5281 sp = getservbyname(name, proto);
5282 Py_END_ALLOW_THREADS
5283 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005284 PyErr_SetString(PyExc_OSError, "service/proto not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005285 return NULL;
5286 }
5287 return PyLong_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00005288}
5289
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005290PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00005291"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00005292\n\
5293Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00005294The optional protocol name, if given, should be 'tcp' or 'udp',\n\
5295otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005296
Guido van Rossum30a685f1991-06-27 15:51:29 +00005297
Barry Warsaw11b91a02004-06-28 00:50:43 +00005298/* Python interface to getservbyport(port).
5299 This only returns the service name, since the other info is already
5300 known or not useful (like the list of aliases). */
5301
5302/*ARGSUSED*/
5303static PyObject *
5304socket_getservbyport(PyObject *self, PyObject *args)
5305{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005306 int port;
5307 char *proto=NULL;
5308 struct servent *sp;
5309 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
5310 return NULL;
5311 if (port < 0 || port > 0xffff) {
5312 PyErr_SetString(
5313 PyExc_OverflowError,
5314 "getservbyport: port must be 0-65535.");
5315 return NULL;
5316 }
5317 Py_BEGIN_ALLOW_THREADS
5318 sp = getservbyport(htons((short)port), proto);
5319 Py_END_ALLOW_THREADS
5320 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005321 PyErr_SetString(PyExc_OSError, "port/proto not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005322 return NULL;
5323 }
5324 return PyUnicode_FromString(sp->s_name);
Barry Warsaw11b91a02004-06-28 00:50:43 +00005325}
5326
5327PyDoc_STRVAR(getservbyport_doc,
5328"getservbyport(port[, protocolname]) -> string\n\
5329\n\
5330Return the service name from a port number and protocol name.\n\
5331The optional protocol name, if given, should be 'tcp' or 'udp',\n\
5332otherwise any protocol will match.");
5333
Guido van Rossum3901d851996-12-19 16:35:04 +00005334/* Python interface to getprotobyname(name).
5335 This only returns the protocol number, since the other info is
5336 already known or not useful (like the list of aliases). */
5337
5338/*ARGSUSED*/
5339static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005340socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00005341{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005342 char *name;
5343 struct protoent *sp;
5344 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
5345 return NULL;
5346 Py_BEGIN_ALLOW_THREADS
5347 sp = getprotobyname(name);
5348 Py_END_ALLOW_THREADS
5349 if (sp == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005350 PyErr_SetString(PyExc_OSError, "protocol not found");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005351 return NULL;
5352 }
5353 return PyLong_FromLong((long) sp->p_proto);
Guido van Rossum3901d851996-12-19 16:35:04 +00005354}
5355
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005356PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005357"getprotobyname(name) -> integer\n\
5358\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005359Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005360
Guido van Rossum3901d851996-12-19 16:35:04 +00005361
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005362#ifndef NO_DUP
5363/* dup() function for socket fds */
5364
5365static PyObject *
5366socket_dup(PyObject *self, PyObject *fdobj)
5367{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005368 SOCKET_T fd, newfd;
5369 PyObject *newfdobj;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005370#ifdef MS_WINDOWS
5371 WSAPROTOCOL_INFO info;
5372#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005373
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005374 fd = PyLong_AsSocket_t(fdobj);
5375 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
5376 return NULL;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005377
Victor Stinnerdaf45552013-08-28 00:53:59 +02005378#ifdef MS_WINDOWS
5379 if (WSADuplicateSocket(fd, GetCurrentProcessId(), &info))
5380 return set_error();
5381
5382 newfd = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
5383 FROM_PROTOCOL_INFO,
5384 &info, 0, WSA_FLAG_OVERLAPPED);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005385 if (newfd == INVALID_SOCKET)
5386 return set_error();
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005387
Victor Stinnerdaf45552013-08-28 00:53:59 +02005388 if (!SetHandleInformation((HANDLE)newfd, HANDLE_FLAG_INHERIT, 0)) {
5389 closesocket(newfd);
5390 PyErr_SetFromWindowsErr(0);
5391 return NULL;
5392 }
5393#else
5394 /* On UNIX, dup can be used to duplicate the file descriptor of a socket */
5395 newfd = _Py_dup(fd);
5396 if (newfd == INVALID_SOCKET)
Victor Stinnere990c6e2013-11-16 00:18:58 +01005397 return NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005398#endif
5399
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005400 newfdobj = PyLong_FromSocket_t(newfd);
5401 if (newfdobj == NULL)
5402 SOCKETCLOSE(newfd);
5403 return newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005404}
5405
5406PyDoc_STRVAR(dup_doc,
5407"dup(integer) -> integer\n\
5408\n\
5409Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
5410sockets; on some platforms os.dup() won't work for socket file descriptors.");
5411#endif
5412
5413
Dave Cole331708b2004-08-09 04:51:41 +00005414#ifdef HAVE_SOCKETPAIR
5415/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00005416 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00005417 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00005418
5419/*ARGSUSED*/
5420static PyObject *
5421socket_socketpair(PyObject *self, PyObject *args)
5422{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005423 PySocketSockObject *s0 = NULL, *s1 = NULL;
5424 SOCKET_T sv[2];
5425 int family, type = SOCK_STREAM, proto = 0;
5426 PyObject *res = NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005427#ifdef SOCK_CLOEXEC
5428 int *atomic_flag_works = &sock_cloexec_works;
5429#else
5430 int *atomic_flag_works = NULL;
5431#endif
5432 int ret;
Dave Cole331708b2004-08-09 04:51:41 +00005433
5434#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005435 family = AF_UNIX;
Dave Cole331708b2004-08-09 04:51:41 +00005436#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005437 family = AF_INET;
Dave Cole331708b2004-08-09 04:51:41 +00005438#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005439 if (!PyArg_ParseTuple(args, "|iii:socketpair",
5440 &family, &type, &proto))
5441 return NULL;
Victor Stinnerdaf45552013-08-28 00:53:59 +02005442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005443 /* Create a pair of socket fds */
Victor Stinnerdaf45552013-08-28 00:53:59 +02005444 Py_BEGIN_ALLOW_THREADS
5445#ifdef SOCK_CLOEXEC
5446 if (sock_cloexec_works != 0) {
5447 ret = socketpair(family, type | SOCK_CLOEXEC, proto, sv);
5448 if (sock_cloexec_works == -1) {
5449 if (ret >= 0) {
5450 sock_cloexec_works = 1;
5451 }
5452 else if (errno == EINVAL) {
5453 /* Linux older than 2.6.27 does not support SOCK_CLOEXEC */
5454 sock_cloexec_works = 0;
5455 ret = socketpair(family, type, proto, sv);
5456 }
5457 }
5458 }
5459 else
5460#endif
5461 {
5462 ret = socketpair(family, type, proto, sv);
5463 }
5464 Py_END_ALLOW_THREADS
5465
5466 if (ret < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005467 return set_error();
Victor Stinnerdaf45552013-08-28 00:53:59 +02005468
5469 if (_Py_set_inheritable(sv[0], 0, atomic_flag_works) < 0)
5470 goto finally;
5471 if (_Py_set_inheritable(sv[1], 0, atomic_flag_works) < 0)
5472 goto finally;
5473
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005474 s0 = new_sockobject(sv[0], family, type, proto);
5475 if (s0 == NULL)
5476 goto finally;
5477 s1 = new_sockobject(sv[1], family, type, proto);
5478 if (s1 == NULL)
5479 goto finally;
5480 res = PyTuple_Pack(2, s0, s1);
Dave Cole331708b2004-08-09 04:51:41 +00005481
5482finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005483 if (res == NULL) {
5484 if (s0 == NULL)
5485 SOCKETCLOSE(sv[0]);
5486 if (s1 == NULL)
5487 SOCKETCLOSE(sv[1]);
5488 }
5489 Py_XDECREF(s0);
5490 Py_XDECREF(s1);
5491 return res;
Dave Cole331708b2004-08-09 04:51:41 +00005492}
5493
5494PyDoc_STRVAR(socketpair_doc,
Victor Stinnerdaf45552013-08-28 00:53:59 +02005495"socketpair([family[, type [, proto]]]) -> (socket object, socket object)\n\
Dave Cole331708b2004-08-09 04:51:41 +00005496\n\
5497Create a pair of socket objects from the sockets returned by the platform\n\
5498socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00005499The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00005500AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00005501
5502#endif /* HAVE_SOCKETPAIR */
5503
5504
Guido van Rossum006bf911996-06-12 04:04:55 +00005505static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005506socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00005507{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005508 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00005509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005510 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
5511 return NULL;
5512 }
5513 if (x1 < 0) {
5514 PyErr_SetString(PyExc_OverflowError,
5515 "can't convert negative number to unsigned long");
5516 return NULL;
5517 }
5518 x2 = (unsigned int)ntohs((unsigned short)x1);
5519 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00005520}
5521
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005522PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005523"ntohs(integer) -> integer\n\
5524\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005525Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005526
5527
Guido van Rossum006bf911996-06-12 04:04:55 +00005528static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005529socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00005530{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005531 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00005532
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005533 if (PyLong_Check(arg)) {
5534 x = PyLong_AsUnsignedLong(arg);
5535 if (x == (unsigned long) -1 && PyErr_Occurred())
5536 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005537#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005538 {
5539 unsigned long y;
5540 /* only want the trailing 32 bits */
5541 y = x & 0xFFFFFFFFUL;
5542 if (y ^ x)
5543 return PyErr_Format(PyExc_OverflowError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005544 "int larger than 32 bits");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005545 x = y;
5546 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005547#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005548 }
5549 else
5550 return PyErr_Format(PyExc_TypeError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005551 "expected int, %s found",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005552 Py_TYPE(arg)->tp_name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005553 return PyLong_FromUnsignedLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00005554}
5555
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005556PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005557"ntohl(integer) -> integer\n\
5558\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005559Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005560
5561
Guido van Rossum006bf911996-06-12 04:04:55 +00005562static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005563socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00005564{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005565 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00005566
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005567 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
5568 return NULL;
5569 }
5570 if (x1 < 0) {
5571 PyErr_SetString(PyExc_OverflowError,
5572 "can't convert negative number to unsigned long");
5573 return NULL;
5574 }
5575 x2 = (unsigned int)htons((unsigned short)x1);
5576 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00005577}
5578
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005579PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005580"htons(integer) -> integer\n\
5581\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005582Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005583
5584
Guido van Rossum006bf911996-06-12 04:04:55 +00005585static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005586socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00005587{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005588 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00005589
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005590 if (PyLong_Check(arg)) {
5591 x = PyLong_AsUnsignedLong(arg);
5592 if (x == (unsigned long) -1 && PyErr_Occurred())
5593 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005594#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005595 {
5596 unsigned long y;
5597 /* only want the trailing 32 bits */
5598 y = x & 0xFFFFFFFFUL;
5599 if (y ^ x)
5600 return PyErr_Format(PyExc_OverflowError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005601 "int larger than 32 bits");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005602 x = y;
5603 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00005604#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005605 }
5606 else
5607 return PyErr_Format(PyExc_TypeError,
Serhiy Storchaka95949422013-08-27 19:40:23 +03005608 "expected int, %s found",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005609 Py_TYPE(arg)->tp_name);
5610 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
Guido van Rossum006bf911996-06-12 04:04:55 +00005611}
5612
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005613PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00005614"htonl(integer) -> integer\n\
5615\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005616Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005617
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005618/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005619
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005620PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum7d0a8262007-05-21 23:13:11 +00005621"inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005622\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005623Convert 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 +00005624binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005625
5626static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005627socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005628{
Neal Norwitz88f115b2003-02-13 02:15:42 +00005629#ifdef HAVE_INET_ATON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005630 struct in_addr buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00005631#endif
5632
5633#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
Benjamin Petersonf91df042009-02-13 02:50:59 +00005634#if (SIZEOF_INT != 4)
5635#error "Not sure if in_addr_t exists and int is not 32-bits."
5636#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005637 /* Have to use inet_addr() instead */
5638 unsigned int packed_addr;
Tim Peters1df9fdd2003-02-13 03:13:40 +00005639#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005640 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005641
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005642 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
5643 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005644
Tim Peters1df9fdd2003-02-13 03:13:40 +00005645
5646#ifdef HAVE_INET_ATON
Thomas Wouters477c8d52006-05-27 19:21:47 +00005647
5648#ifdef USE_INET_ATON_WEAKLINK
5649 if (inet_aton != NULL) {
5650#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005651 if (inet_aton(ip_addr, &buf))
5652 return PyBytes_FromStringAndSize((char *)(&buf),
5653 sizeof(buf));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005654
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005655 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005656 "illegal IP address string passed to inet_aton");
5657 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005658
Thomas Wouters477c8d52006-05-27 19:21:47 +00005659#ifdef USE_INET_ATON_WEAKLINK
5660 } else {
5661#endif
5662
5663#endif
5664
5665#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
5666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005667 /* special-case this address as inet_addr might return INADDR_NONE
5668 * for this */
5669 if (strcmp(ip_addr, "255.255.255.255") == 0) {
Charles-François Natali24aa0412013-08-31 14:48:25 +02005670 packed_addr = INADDR_BROADCAST;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005671 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00005672
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005673 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00005674
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005675 if (packed_addr == INADDR_NONE) { /* invalid address */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005676 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005677 "illegal IP address string passed to inet_aton");
5678 return NULL;
5679 }
5680 }
5681 return PyBytes_FromStringAndSize((char *) &packed_addr,
5682 sizeof(packed_addr));
Thomas Wouters477c8d52006-05-27 19:21:47 +00005683
5684#ifdef USE_INET_ATON_WEAKLINK
5685 }
5686#endif
5687
Guido van Rossumad05cdf2003-02-12 23:08:22 +00005688#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005689}
5690
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005691PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00005692"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005693\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005694Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005695
5696static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005697socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005698{
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005699 Py_buffer packed_ip;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005700 struct in_addr packed_addr;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005701
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005702 if (!PyArg_ParseTuple(args, "y*:inet_ntoa", &packed_ip)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005703 return NULL;
5704 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00005705
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005706 if (packed_ip.len != sizeof(packed_addr)) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005707 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005708 "packed IP wrong length for inet_ntoa");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005709 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005710 return NULL;
5711 }
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005712
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005713 memcpy(&packed_addr, packed_ip.buf, packed_ip.len);
5714 PyBuffer_Release(&packed_ip);
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005715
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005716 return PyUnicode_FromString(inet_ntoa(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00005717}
Guido van Rossum82a5c661998-07-07 20:45:43 +00005718
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005719#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005720
5721PyDoc_STRVAR(inet_pton_doc,
5722"inet_pton(af, ip) -> packed IP address string\n\
5723\n\
5724Convert an IP address from string format to a packed string suitable\n\
5725for use with low-level network functions.");
5726
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005727#endif
5728
5729#ifdef HAVE_INET_PTON
5730
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005731static PyObject *
5732socket_inet_pton(PyObject *self, PyObject *args)
5733{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005734 int af;
5735 char* ip;
5736 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005737#ifdef ENABLE_IPV6
Victor Stinner640c35c2013-06-04 23:14:37 +02005738 char packed[Py_MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005739#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005740 char packed[sizeof(struct in_addr)];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005741#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005742 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
5743 return NULL;
5744 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005745
Martin v. Löwis04697e82004-06-02 12:35:29 +00005746#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005747 if(af == AF_INET6) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005748 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005749 "can't use AF_INET6, IPv6 is disabled");
5750 return NULL;
5751 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00005752#endif
Martin v. Löwis10649092003-08-05 06:25:06 +00005753
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005754 retval = inet_pton(af, ip, packed);
5755 if (retval < 0) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005756 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005757 return NULL;
5758 } else if (retval == 0) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005759 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005760 "illegal IP address string passed to inet_pton");
5761 return NULL;
5762 } else if (af == AF_INET) {
5763 return PyBytes_FromStringAndSize(packed,
5764 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005765#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005766 } else if (af == AF_INET6) {
5767 return PyBytes_FromStringAndSize(packed,
5768 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005769#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005770 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005771 PyErr_SetString(PyExc_OSError, "unknown address family");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005772 return NULL;
5773 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005774}
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005775#elif defined(MS_WINDOWS)
5776
5777static PyObject *
5778socket_inet_pton(PyObject *self, PyObject *args)
5779{
5780 int af;
5781 char* ip;
5782 struct sockaddr_in6 addr;
5783 INT ret, size;
5784
5785 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
5786 return NULL;
5787 }
5788
Victor Stinnere990c6e2013-11-16 00:18:58 +01005789 size = sizeof(addr);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005790 ret = WSAStringToAddressA(ip, af, NULL, (LPSOCKADDR)&addr, &size);
5791
5792 if (ret) {
5793 PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
5794 return NULL;
5795 } else if(af == AF_INET) {
5796 struct sockaddr_in *addr4 = (struct sockaddr_in*)&addr;
Victor Stinnere990c6e2013-11-16 00:18:58 +01005797 return PyBytes_FromStringAndSize((const char *)&(addr4->sin_addr),
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005798 sizeof(addr4->sin_addr));
5799 } else if (af == AF_INET6) {
Victor Stinnere990c6e2013-11-16 00:18:58 +01005800 return PyBytes_FromStringAndSize((const char *)&(addr.sin6_addr),
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005801 sizeof(addr.sin6_addr));
5802 } else {
5803 PyErr_SetString(PyExc_OSError, "unknown address family");
5804 return NULL;
5805 }
5806}
5807
5808#endif
5809
5810#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Thomas Wouters477c8d52006-05-27 19:21:47 +00005811
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005812PyDoc_STRVAR(inet_ntop_doc,
5813"inet_ntop(af, packed_ip) -> string formatted IP address\n\
5814\n\
5815Convert a packed IP address of the given family to string format.");
5816
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005817#endif
5818
5819
5820#ifdef HAVE_INET_PTON
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005821static PyObject *
5822socket_inet_ntop(PyObject *self, PyObject *args)
5823{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005824 int af;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005825 Py_buffer packed_ip;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005826 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005827#ifdef ENABLE_IPV6
Victor Stinner640c35c2013-06-04 23:14:37 +02005828 char ip[Py_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005829#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005830 char ip[INET_ADDRSTRLEN + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005831#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00005832
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005833 /* Guarantee NUL-termination for PyUnicode_FromString() below */
5834 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005835
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005836 if (!PyArg_ParseTuple(args, "iy*:inet_ntop", &af, &packed_ip)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005837 return NULL;
5838 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005839
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005840 if (af == AF_INET) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005841 if (packed_ip.len != sizeof(struct in_addr)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005842 PyErr_SetString(PyExc_ValueError,
5843 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005844 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005845 return NULL;
5846 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005847#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005848 } else if (af == AF_INET6) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005849 if (packed_ip.len != sizeof(struct in6_addr)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005850 PyErr_SetString(PyExc_ValueError,
5851 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005852 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005853 return NULL;
5854 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00005855#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005856 } else {
5857 PyErr_Format(PyExc_ValueError,
5858 "unknown address family %d", af);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005859 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005860 return NULL;
5861 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005862
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005863 retval = inet_ntop(af, packed_ip.buf, ip, sizeof(ip));
5864 PyBuffer_Release(&packed_ip);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005865 if (!retval) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005866 PyErr_SetFromErrno(PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005867 return NULL;
5868 } else {
5869 return PyUnicode_FromString(retval);
5870 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005871}
5872
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005873#elif defined(MS_WINDOWS)
5874
5875static PyObject *
5876socket_inet_ntop(PyObject *self, PyObject *args)
5877{
5878 int af;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005879 Py_buffer packed_ip;
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005880 struct sockaddr_in6 addr;
5881 DWORD addrlen, ret, retlen;
Jason R. Coombs8ec784c2013-11-10 13:43:22 -05005882#ifdef ENABLE_IPV6
5883 char ip[Py_MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
5884#else
5885 char ip[INET_ADDRSTRLEN + 1];
5886#endif
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005887
5888 /* Guarantee NUL-termination for PyUnicode_FromString() below */
5889 memset((void *) &ip[0], '\0', sizeof(ip));
5890
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005891 if (!PyArg_ParseTuple(args, "iy*:inet_ntop", &af, &packed_ip)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005892 return NULL;
5893 }
5894
5895 if (af == AF_INET) {
5896 struct sockaddr_in * addr4 = (struct sockaddr_in *)&addr;
5897
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005898 if (packed_ip.len != sizeof(struct in_addr)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005899 PyErr_SetString(PyExc_ValueError,
5900 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005901 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005902 return NULL;
5903 }
5904 memset(addr4, 0, sizeof(struct sockaddr_in));
5905 addr4->sin_family = AF_INET;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005906 memcpy(&(addr4->sin_addr), packed_ip.buf, sizeof(addr4->sin_addr));
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005907 addrlen = sizeof(struct sockaddr_in);
5908 } else if (af == AF_INET6) {
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005909 if (packed_ip.len != sizeof(struct in6_addr)) {
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005910 PyErr_SetString(PyExc_ValueError,
5911 "invalid length of packed IP address string");
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005912 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005913 return NULL;
5914 }
5915
5916 memset(&addr, 0, sizeof(addr));
5917 addr.sin6_family = AF_INET6;
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005918 memcpy(&(addr.sin6_addr), packed_ip.buf, sizeof(addr.sin6_addr));
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005919 addrlen = sizeof(addr);
5920 } else {
5921 PyErr_Format(PyExc_ValueError,
5922 "unknown address family %d", af);
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005923 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005924 return NULL;
5925 }
Serhiy Storchaka8490f5a2015-03-20 09:00:36 +02005926 PyBuffer_Release(&packed_ip);
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005927
5928 retlen = sizeof(ip);
Victor Stinnere990c6e2013-11-16 00:18:58 +01005929 ret = WSAAddressToStringA((struct sockaddr*)&addr, addrlen, NULL,
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09005930 ip, &retlen);
5931
5932 if (ret) {
5933 PyErr_SetExcFromWindowsErr(PyExc_OSError, WSAGetLastError());
5934 return NULL;
5935 } else {
5936 return PyUnicode_FromString(ip);
5937 }
5938}
5939
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005940#endif /* HAVE_INET_PTON */
5941
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005942/* Python interface to getaddrinfo(host, port). */
5943
5944/*ARGSUSED*/
5945static PyObject *
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005946socket_getaddrinfo(PyObject *self, PyObject *args, PyObject* kwargs)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005947{
Victor Stinner77af1722011-05-26 14:05:59 +02005948 static char* kwnames[] = {"host", "port", "family", "type", "proto",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005949 "flags", 0};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005950 struct addrinfo hints, *res;
5951 struct addrinfo *res0 = NULL;
5952 PyObject *hobj = NULL;
5953 PyObject *pobj = (PyObject *)NULL;
5954 char pbuf[30];
5955 char *hptr, *pptr;
5956 int family, socktype, protocol, flags;
5957 int error;
5958 PyObject *all = (PyObject *)NULL;
5959 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005960
Georg Brandl6083a4b2013-10-14 06:51:46 +02005961 socktype = protocol = flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005962 family = AF_UNSPEC;
Victor Stinner77af1722011-05-26 14:05:59 +02005963 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iiii:getaddrinfo",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005964 kwnames, &hobj, &pobj, &family, &socktype,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005965 &protocol, &flags)) {
5966 return NULL;
5967 }
5968 if (hobj == Py_None) {
5969 hptr = NULL;
5970 } else if (PyUnicode_Check(hobj)) {
Victor Stinnerec1a4982015-09-11 12:37:30 +02005971 idna = PyUnicode_AsEncodedString(hobj, "idna", NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005972 if (!idna)
5973 return NULL;
5974 assert(PyBytes_Check(idna));
5975 hptr = PyBytes_AS_STRING(idna);
5976 } else if (PyBytes_Check(hobj)) {
5977 hptr = PyBytes_AsString(hobj);
5978 } else {
5979 PyErr_SetString(PyExc_TypeError,
5980 "getaddrinfo() argument 1 must be string or None");
5981 return NULL;
5982 }
5983 if (PyLong_CheckExact(pobj)) {
5984 long value = PyLong_AsLong(pobj);
5985 if (value == -1 && PyErr_Occurred())
5986 goto err;
5987 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
5988 pptr = pbuf;
5989 } else if (PyUnicode_Check(pobj)) {
5990 pptr = _PyUnicode_AsString(pobj);
Alexander Belopolskye239d232010-12-08 23:31:48 +00005991 if (pptr == NULL)
5992 goto err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005993 } else if (PyBytes_Check(pobj)) {
Alexander Belopolskye239d232010-12-08 23:31:48 +00005994 pptr = PyBytes_AS_STRING(pobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005995 } else if (pobj == Py_None) {
5996 pptr = (char *)NULL;
5997 } else {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02005998 PyErr_SetString(PyExc_OSError, "Int or String expected");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005999 goto err;
6000 }
Ronald Oussorena822d3662013-06-10 10:36:28 +02006001#if defined(__APPLE__) && defined(AI_NUMERICSERV)
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02006002 if ((flags & AI_NUMERICSERV) && (pptr == NULL || (pptr[0] == '0' && pptr[1] == 0))) {
6003 /* On OSX upto at least OSX 10.8 getaddrinfo crashes
Christian Heimesaf01f662013-12-21 16:19:10 +01006004 * if AI_NUMERICSERV is set and the servname is NULL or "0".
6005 * This workaround avoids a segfault in libsystem.
6006 */
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02006007 pptr = "00";
6008 }
6009#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006010 memset(&hints, 0, sizeof(hints));
6011 hints.ai_family = family;
6012 hints.ai_socktype = socktype;
6013 hints.ai_protocol = protocol;
6014 hints.ai_flags = flags;
6015 Py_BEGIN_ALLOW_THREADS
6016 ACQUIRE_GETADDRINFO_LOCK
6017 error = getaddrinfo(hptr, pptr, &hints, &res0);
6018 Py_END_ALLOW_THREADS
6019 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
6020 if (error) {
6021 set_gaierror(error);
6022 goto err;
6023 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006024
Benjamin Peterson4fd929b2015-04-01 11:16:40 -04006025 all = PyList_New(0);
6026 if (all == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006027 goto err;
6028 for (res = res0; res; res = res->ai_next) {
6029 PyObject *single;
6030 PyObject *addr =
6031 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
6032 if (addr == NULL)
6033 goto err;
6034 single = Py_BuildValue("iiisO", res->ai_family,
6035 res->ai_socktype, res->ai_protocol,
6036 res->ai_canonname ? res->ai_canonname : "",
6037 addr);
6038 Py_DECREF(addr);
6039 if (single == NULL)
6040 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006041
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006042 if (PyList_Append(all, single))
6043 goto err;
6044 Py_XDECREF(single);
6045 }
6046 Py_XDECREF(idna);
6047 if (res0)
6048 freeaddrinfo(res0);
6049 return all;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006050 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006051 Py_XDECREF(all);
6052 Py_XDECREF(idna);
6053 if (res0)
6054 freeaddrinfo(res0);
6055 return (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006056}
6057
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006058PyDoc_STRVAR(getaddrinfo_doc,
Berker Peksaga6ec5ee2014-06-30 11:28:40 +03006059"getaddrinfo(host, port [, family, type, proto, flags])\n\
6060 -> list of (family, type, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006061\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006062Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006063
6064/* Python interface to getnameinfo(sa, flags). */
6065
6066/*ARGSUSED*/
6067static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006068socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006069{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006070 PyObject *sa = (PyObject *)NULL;
6071 int flags;
6072 char *hostp;
Charles-François Natali366999a2012-01-02 15:47:29 +01006073 int port;
6074 unsigned int flowinfo, scope_id;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006075 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
6076 struct addrinfo hints, *res = NULL;
6077 int error;
6078 PyObject *ret = (PyObject *)NULL;
Victor Stinner72400302016-01-28 15:41:01 +01006079 PyObject *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006080
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006081 flags = flowinfo = scope_id = 0;
6082 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
6083 return NULL;
6084 if (!PyTuple_Check(sa)) {
6085 PyErr_SetString(PyExc_TypeError,
6086 "getnameinfo() argument 1 must be a tuple");
6087 return NULL;
6088 }
Charles-François Natali366999a2012-01-02 15:47:29 +01006089 if (!PyArg_ParseTuple(sa, "si|II",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006090 &hostp, &port, &flowinfo, &scope_id))
6091 return NULL;
Charles-François Natali9b0c0062012-06-23 10:17:05 +02006092 if (flowinfo > 0xfffff) {
Charles-François Natali366999a2012-01-02 15:47:29 +01006093 PyErr_SetString(PyExc_OverflowError,
6094 "getsockaddrarg: flowinfo must be 0-1048575.");
6095 return NULL;
6096 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006097 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
6098 memset(&hints, 0, sizeof(hints));
6099 hints.ai_family = AF_UNSPEC;
6100 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Martin v. Löwis112c0f32010-08-25 07:38:15 +00006101 hints.ai_flags = AI_NUMERICHOST; /* don't do any name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006102 Py_BEGIN_ALLOW_THREADS
6103 ACQUIRE_GETADDRINFO_LOCK
6104 error = getaddrinfo(hostp, pbuf, &hints, &res);
6105 Py_END_ALLOW_THREADS
6106 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
6107 if (error) {
6108 set_gaierror(error);
6109 goto fail;
6110 }
6111 if (res->ai_next) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006112 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006113 "sockaddr resolved to multiple addresses");
6114 goto fail;
6115 }
6116 switch (res->ai_family) {
6117 case AF_INET:
6118 {
6119 if (PyTuple_GET_SIZE(sa) != 2) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006120 PyErr_SetString(PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006121 "IPv4 sockaddr must be 2 tuple");
6122 goto fail;
6123 }
6124 break;
6125 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00006126#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006127 case AF_INET6:
6128 {
6129 struct sockaddr_in6 *sin6;
6130 sin6 = (struct sockaddr_in6 *)res->ai_addr;
Charles-François Natali366999a2012-01-02 15:47:29 +01006131 sin6->sin6_flowinfo = htonl(flowinfo);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006132 sin6->sin6_scope_id = scope_id;
6133 break;
6134 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006135#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006136 }
Antoine Pitrou19467d22010-08-17 19:33:30 +00006137 error = getnameinfo(res->ai_addr, (socklen_t) res->ai_addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006138 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
6139 if (error) {
6140 set_gaierror(error);
6141 goto fail;
6142 }
Victor Stinner72400302016-01-28 15:41:01 +01006143
6144 name = sock_decode_hostname(hbuf);
6145 if (name == NULL)
6146 goto fail;
6147 ret = Py_BuildValue("Ns", name, pbuf);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006148
6149fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006150 if (res)
6151 freeaddrinfo(res);
6152 return ret;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006153}
6154
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006155PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00006156"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006157\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006158Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006159
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006160
6161/* Python API to getting and setting the default timeout value. */
6162
6163static PyObject *
6164socket_getdefaulttimeout(PyObject *self)
6165{
Victor Stinner71694d52015-03-28 01:18:54 +01006166 if (defaulttimeout < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006167 Py_INCREF(Py_None);
6168 return Py_None;
6169 }
Victor Stinner71694d52015-03-28 01:18:54 +01006170 else {
6171 double seconds = _PyTime_AsSecondsDouble(defaulttimeout);
6172 return PyFloat_FromDouble(seconds);
6173 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006174}
6175
6176PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00006177"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006178\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03006179Returns the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006180A value of None indicates that new socket objects have no timeout.\n\
6181When the socket module is first imported, the default is None.");
6182
6183static PyObject *
6184socket_setdefaulttimeout(PyObject *self, PyObject *arg)
6185{
Victor Stinner71694d52015-03-28 01:18:54 +01006186 _PyTime_t timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006187
Victor Stinner71694d52015-03-28 01:18:54 +01006188 if (socket_parse_timeout(&timeout, arg) < 0)
6189 return NULL;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006190
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006191 defaulttimeout = timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006192
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006193 Py_INCREF(Py_None);
6194 return Py_None;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006195}
6196
6197PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00006198"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006199\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03006200Set the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00006201A value of None indicates that new socket objects have no timeout.\n\
6202When the socket module is first imported, the default is None.");
6203
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006204#ifdef HAVE_IF_NAMEINDEX
6205/* Python API for getting interface indices and names */
6206
6207static PyObject *
6208socket_if_nameindex(PyObject *self, PyObject *arg)
6209{
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006210 PyObject *list;
Charles-François Natali60713592011-05-20 16:55:06 +02006211 int i;
6212 struct if_nameindex *ni;
Victor Stinner77af1722011-05-26 14:05:59 +02006213
Charles-François Natali60713592011-05-20 16:55:06 +02006214 ni = if_nameindex();
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006215 if (ni == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006216 PyErr_SetFromErrno(PyExc_OSError);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006217 return NULL;
6218 }
6219
6220 list = PyList_New(0);
6221 if (list == NULL) {
6222 if_freenameindex(ni);
6223 return NULL;
6224 }
6225
Charles-François Natali60713592011-05-20 16:55:06 +02006226 for (i = 0; ni[i].if_index != 0 && i < INT_MAX; i++) {
6227 PyObject *ni_tuple = Py_BuildValue("IO&",
6228 ni[i].if_index, PyUnicode_DecodeFSDefault, ni[i].if_name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006229
6230 if (ni_tuple == NULL || PyList_Append(list, ni_tuple) == -1) {
6231 Py_XDECREF(ni_tuple);
Charles-François Natali60713592011-05-20 16:55:06 +02006232 Py_DECREF(list);
6233 if_freenameindex(ni);
6234 return NULL;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006235 }
6236 Py_DECREF(ni_tuple);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006237 }
6238
6239 if_freenameindex(ni);
6240 return list;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006241}
6242
6243PyDoc_STRVAR(if_nameindex_doc,
6244"if_nameindex()\n\
6245\n\
6246Returns a list of network interface information (index, name) tuples.");
6247
Charles-François Natali60713592011-05-20 16:55:06 +02006248static PyObject *
6249socket_if_nametoindex(PyObject *self, PyObject *args)
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006250{
Charles-François Natali60713592011-05-20 16:55:06 +02006251 PyObject *oname;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006252 unsigned long index;
6253
Charles-François Natali60713592011-05-20 16:55:06 +02006254 if (!PyArg_ParseTuple(args, "O&:if_nametoindex",
6255 PyUnicode_FSConverter, &oname))
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006256 return NULL;
6257
Charles-François Natali60713592011-05-20 16:55:06 +02006258 index = if_nametoindex(PyBytes_AS_STRING(oname));
6259 Py_DECREF(oname);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006260 if (index == 0) {
Charles-François Natali60713592011-05-20 16:55:06 +02006261 /* if_nametoindex() doesn't set errno */
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006262 PyErr_SetString(PyExc_OSError, "no interface with this name");
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006263 return NULL;
6264 }
6265
6266 return PyLong_FromUnsignedLong(index);
6267}
6268
6269PyDoc_STRVAR(if_nametoindex_doc,
6270"if_nametoindex(if_name)\n\
6271\n\
6272Returns the interface index corresponding to the interface name if_name.");
6273
Charles-François Natali60713592011-05-20 16:55:06 +02006274static PyObject *
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006275socket_if_indextoname(PyObject *self, PyObject *arg)
6276{
Charles-François Natali60713592011-05-20 16:55:06 +02006277 unsigned long index;
6278 char name[IF_NAMESIZE + 1];
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006279
Charles-François Natali60713592011-05-20 16:55:06 +02006280 index = PyLong_AsUnsignedLong(arg);
6281 if (index == (unsigned long) -1)
6282 return NULL;
6283
6284 if (if_indextoname(index, name) == NULL) {
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006285 PyErr_SetFromErrno(PyExc_OSError);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006286 return NULL;
6287 }
6288
Charles-François Natali60713592011-05-20 16:55:06 +02006289 return PyUnicode_DecodeFSDefault(name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006290}
6291
6292PyDoc_STRVAR(if_indextoname_doc,
6293"if_indextoname(if_index)\n\
6294\n\
6295Returns the interface name corresponding to the interface index if_index.");
6296
6297#endif /* HAVE_IF_NAMEINDEX */
6298
6299
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006300#ifdef CMSG_LEN
6301/* Python interface to CMSG_LEN(length). */
6302
6303static PyObject *
6304socket_CMSG_LEN(PyObject *self, PyObject *args)
6305{
6306 Py_ssize_t length;
6307 size_t result;
6308
6309 if (!PyArg_ParseTuple(args, "n:CMSG_LEN", &length))
6310 return NULL;
6311 if (length < 0 || !get_CMSG_LEN(length, &result)) {
6312 PyErr_Format(PyExc_OverflowError, "CMSG_LEN() argument out of range");
6313 return NULL;
6314 }
6315 return PyLong_FromSize_t(result);
6316}
6317
6318PyDoc_STRVAR(CMSG_LEN_doc,
6319"CMSG_LEN(length) -> control message length\n\
6320\n\
6321Return the total length, without trailing padding, of an ancillary\n\
6322data item with associated data of the given length. This value can\n\
6323often be used as the buffer size for recvmsg() to receive a single\n\
6324item of ancillary data, but RFC 3542 requires portable applications to\n\
6325use CMSG_SPACE() and thus include space for padding, even when the\n\
6326item will be the last in the buffer. Raises OverflowError if length\n\
6327is outside the permissible range of values.");
6328
6329
6330#ifdef CMSG_SPACE
6331/* Python interface to CMSG_SPACE(length). */
6332
6333static PyObject *
6334socket_CMSG_SPACE(PyObject *self, PyObject *args)
6335{
6336 Py_ssize_t length;
6337 size_t result;
6338
6339 if (!PyArg_ParseTuple(args, "n:CMSG_SPACE", &length))
6340 return NULL;
6341 if (length < 0 || !get_CMSG_SPACE(length, &result)) {
6342 PyErr_SetString(PyExc_OverflowError,
6343 "CMSG_SPACE() argument out of range");
6344 return NULL;
6345 }
6346 return PyLong_FromSize_t(result);
6347}
6348
6349PyDoc_STRVAR(CMSG_SPACE_doc,
6350"CMSG_SPACE(length) -> buffer size\n\
6351\n\
6352Return the buffer size needed for recvmsg() to receive an ancillary\n\
6353data item with associated data of the given length, along with any\n\
6354trailing padding. The buffer space needed to receive multiple items\n\
6355is the sum of the CMSG_SPACE() values for their associated data\n\
6356lengths. Raises OverflowError if length is outside the permissible\n\
6357range of values.");
6358#endif /* CMSG_SPACE */
6359#endif /* CMSG_LEN */
6360
6361
Guido van Rossum30a685f1991-06-27 15:51:29 +00006362/* List of functions exported by this module. */
6363
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006364static PyMethodDef socket_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006365 {"gethostbyname", socket_gethostbyname,
6366 METH_VARARGS, gethostbyname_doc},
6367 {"gethostbyname_ex", socket_gethostbyname_ex,
6368 METH_VARARGS, ghbn_ex_doc},
6369 {"gethostbyaddr", socket_gethostbyaddr,
6370 METH_VARARGS, gethostbyaddr_doc},
6371 {"gethostname", socket_gethostname,
6372 METH_NOARGS, gethostname_doc},
Antoine Pitrou061cfb52011-02-28 22:25:22 +00006373#ifdef HAVE_SETHOSTNAME
6374 {"sethostname", socket_sethostname,
6375 METH_VARARGS, sethostname_doc},
6376#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006377 {"getservbyname", socket_getservbyname,
6378 METH_VARARGS, getservbyname_doc},
6379 {"getservbyport", socket_getservbyport,
6380 METH_VARARGS, getservbyport_doc},
6381 {"getprotobyname", socket_getprotobyname,
6382 METH_VARARGS, getprotobyname_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00006383#ifndef NO_DUP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006384 {"dup", socket_dup,
6385 METH_O, dup_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00006386#endif
Dave Cole331708b2004-08-09 04:51:41 +00006387#ifdef HAVE_SOCKETPAIR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006388 {"socketpair", socket_socketpair,
6389 METH_VARARGS, socketpair_doc},
Dave Cole331708b2004-08-09 04:51:41 +00006390#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006391 {"ntohs", socket_ntohs,
6392 METH_VARARGS, ntohs_doc},
6393 {"ntohl", socket_ntohl,
6394 METH_O, ntohl_doc},
6395 {"htons", socket_htons,
6396 METH_VARARGS, htons_doc},
6397 {"htonl", socket_htonl,
6398 METH_O, htonl_doc},
6399 {"inet_aton", socket_inet_aton,
6400 METH_VARARGS, inet_aton_doc},
6401 {"inet_ntoa", socket_inet_ntoa,
6402 METH_VARARGS, inet_ntoa_doc},
Atsuo Ishimotoda0fc142012-07-16 15:16:54 +09006403#if defined(HAVE_INET_PTON) || defined(MS_WINDOWS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006404 {"inet_pton", socket_inet_pton,
6405 METH_VARARGS, inet_pton_doc},
6406 {"inet_ntop", socket_inet_ntop,
6407 METH_VARARGS, inet_ntop_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006408#endif
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00006409 {"getaddrinfo", (PyCFunction)socket_getaddrinfo,
6410 METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006411 {"getnameinfo", socket_getnameinfo,
6412 METH_VARARGS, getnameinfo_doc},
6413 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
6414 METH_NOARGS, getdefaulttimeout_doc},
6415 {"setdefaulttimeout", socket_setdefaulttimeout,
6416 METH_O, setdefaulttimeout_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006417#ifdef HAVE_IF_NAMEINDEX
6418 {"if_nameindex", socket_if_nameindex,
6419 METH_NOARGS, if_nameindex_doc},
6420 {"if_nametoindex", socket_if_nametoindex,
Charles-François Natali60713592011-05-20 16:55:06 +02006421 METH_VARARGS, if_nametoindex_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07006422 {"if_indextoname", socket_if_indextoname,
6423 METH_O, if_indextoname_doc},
6424#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006425#ifdef CMSG_LEN
6426 {"CMSG_LEN", socket_CMSG_LEN,
6427 METH_VARARGS, CMSG_LEN_doc},
6428#ifdef CMSG_SPACE
6429 {"CMSG_SPACE", socket_CMSG_SPACE,
6430 METH_VARARGS, CMSG_SPACE_doc},
6431#endif
6432#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006433 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00006434};
6435
Guido van Rossum30a685f1991-06-27 15:51:29 +00006436
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006437#ifdef MS_WINDOWS
6438#define OS_INIT_DEFINED
6439
6440/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006441
6442static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006443os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00006444{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006445 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00006446}
6447
6448static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006449os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00006450{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006451 WSADATA WSAData;
6452 int ret;
6453 ret = WSAStartup(0x0101, &WSAData);
6454 switch (ret) {
6455 case 0: /* No error */
6456 Py_AtExit(os_cleanup);
6457 return 1; /* Success */
6458 case WSASYSNOTREADY:
6459 PyErr_SetString(PyExc_ImportError,
6460 "WSAStartup failed: network not ready");
6461 break;
6462 case WSAVERNOTSUPPORTED:
6463 case WSAEINVAL:
6464 PyErr_SetString(
6465 PyExc_ImportError,
6466 "WSAStartup failed: requested version not supported");
6467 break;
6468 default:
6469 PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
6470 break;
6471 }
6472 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006473}
6474
Guido van Rossum8d665e61996-06-26 18:22:49 +00006475#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00006476
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00006477
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006478
6479#ifndef OS_INIT_DEFINED
6480static int
6481os_init(void)
6482{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006483 return 1; /* Success */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006484}
6485#endif
6486
6487
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006488/* C API table - always add new things to the end for binary
6489 compatibility. */
6490static
6491PySocketModule_APIObject PySocketModuleAPI =
6492{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006493 &sock_type,
Antoine Pitrouc4df7842010-12-03 19:59:41 +00006494 NULL,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006495 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006496};
6497
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006498
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006499/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006500
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006501 This module is actually called "_socket", and there's a wrapper
Guido van Rossum7d0a8262007-05-21 23:13:11 +00006502 "socket.py" which implements some additional functionality.
6503 The import of "_socket" may fail with an ImportError exception if
6504 os-specific initialization fails. On Windows, this does WINSOCK
Ezio Melotti13925002011-03-16 11:05:33 +02006505 initialization. When WINSOCK is initialized successfully, a call to
Guido van Rossum7d0a8262007-05-21 23:13:11 +00006506 WSACleanup() is scheduled to be made at exit time.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006507*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006508
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00006509PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00006510"Implementation module for socket operations.\n\
6511\n\
6512See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00006513
Martin v. Löwis1a214512008-06-11 05:26:20 +00006514static struct PyModuleDef socketmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006515 PyModuleDef_HEAD_INIT,
6516 PySocket_MODULE_NAME,
6517 socket_doc,
6518 -1,
6519 socket_methods,
6520 NULL,
6521 NULL,
6522 NULL,
6523 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00006524};
6525
Mark Hammondfe51c6d2002-08-02 02:27:13 +00006526PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00006527PyInit__socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00006528{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006529 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00006530
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006531 if (!os_init())
6532 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006533
Victor Stinnerdaf45552013-08-28 00:53:59 +02006534#ifdef MS_WINDOWS
6535 if (support_wsa_no_inherit == -1) {
Steve Dower65e4cb12014-11-22 12:54:57 -08006536#if defined(_MSC_VER) && _MSC_VER >= 1800
6537 support_wsa_no_inherit = IsWindows7SP1OrGreater();
6538#else
Victor Stinnerdaf45552013-08-28 00:53:59 +02006539 DWORD version = GetVersion();
6540 DWORD major = (DWORD)LOBYTE(LOWORD(version));
6541 DWORD minor = (DWORD)HIBYTE(LOWORD(version));
6542 /* need Windows 7 SP1, 2008 R2 SP1 or later */
Steve Dower65e4cb12014-11-22 12:54:57 -08006543 support_wsa_no_inherit = major > 6 || (major == 6 && minor >= 1);
6544#endif
Victor Stinnerdaf45552013-08-28 00:53:59 +02006545 }
6546#endif
6547
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006548 Py_TYPE(&sock_type) = &PyType_Type;
6549 m = PyModule_Create(&socketmodule);
6550 if (m == NULL)
6551 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006552
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006553 Py_INCREF(PyExc_OSError);
6554 PySocketModuleAPI.error = PyExc_OSError;
6555 Py_INCREF(PyExc_OSError);
6556 PyModule_AddObject(m, "error", PyExc_OSError);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006557 socket_herror = PyErr_NewException("socket.herror",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006558 PyExc_OSError, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006559 if (socket_herror == NULL)
6560 return NULL;
6561 Py_INCREF(socket_herror);
6562 PyModule_AddObject(m, "herror", socket_herror);
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006563 socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006564 NULL);
6565 if (socket_gaierror == NULL)
6566 return NULL;
6567 Py_INCREF(socket_gaierror);
6568 PyModule_AddObject(m, "gaierror", socket_gaierror);
6569 socket_timeout = PyErr_NewException("socket.timeout",
Antoine Pitrou6b4883d2011-10-12 02:54:14 +02006570 PyExc_OSError, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006571 if (socket_timeout == NULL)
6572 return NULL;
Antoine Pitrouc4df7842010-12-03 19:59:41 +00006573 PySocketModuleAPI.timeout_error = socket_timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006574 Py_INCREF(socket_timeout);
6575 PyModule_AddObject(m, "timeout", socket_timeout);
6576 Py_INCREF((PyObject *)&sock_type);
6577 if (PyModule_AddObject(m, "SocketType",
6578 (PyObject *)&sock_type) != 0)
6579 return NULL;
6580 Py_INCREF((PyObject *)&sock_type);
6581 if (PyModule_AddObject(m, "socket",
6582 (PyObject *)&sock_type) != 0)
6583 return NULL;
Guido van Rossum09be4091999-08-09 14:40:40 +00006584
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006585#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006586 has_ipv6 = Py_True;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006587#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006588 has_ipv6 = Py_False;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006589#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006590 Py_INCREF(has_ipv6);
6591 PyModule_AddObject(m, "has_ipv6", has_ipv6);
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006592
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006593 /* Export C API */
6594 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
6595 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
6596 ) != 0)
6597 return NULL;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00006598
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006599 /* Address families (we only support AF_INET and AF_UNIX) */
Guido van Rossum09be4091999-08-09 14:40:40 +00006600#ifdef AF_UNSPEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006601 PyModule_AddIntMacro(m, AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00006602#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006603 PyModule_AddIntMacro(m, AF_INET);
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00006604#if defined(AF_UNIX)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006605 PyModule_AddIntMacro(m, AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00006606#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00006607#ifdef AF_AX25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006608 /* Amateur Radio AX.25 */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006609 PyModule_AddIntMacro(m, AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00006610#endif
6611#ifdef AF_IPX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006612 PyModule_AddIntMacro(m, AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00006613#endif
6614#ifdef AF_APPLETALK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006615 /* Appletalk DDP */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006616 PyModule_AddIntMacro(m, AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00006617#endif
6618#ifdef AF_NETROM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006619 /* Amateur radio NetROM */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006620 PyModule_AddIntMacro(m, AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00006621#endif
6622#ifdef AF_BRIDGE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006623 /* Multiprotocol bridge */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006624 PyModule_AddIntMacro(m, AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006625#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006626#ifdef AF_ATMPVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006627 /* ATM PVCs */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006628 PyModule_AddIntMacro(m, AF_ATMPVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006629#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006630#ifdef AF_AAL5
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006631 /* Reserved for Werner's ATM */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006632 PyModule_AddIntMacro(m, AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00006633#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02006634#ifdef HAVE_SOCKADDR_ALG
6635 PyModule_AddIntMacro(m, AF_ALG); /* Linux crypto */
6636#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006637#ifdef AF_X25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006638 /* Reserved for X.25 project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006639 PyModule_AddIntMacro(m, AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00006640#endif
6641#ifdef AF_INET6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006642 PyModule_AddIntMacro(m, AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00006643#endif
6644#ifdef AF_ROSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006645 /* Amateur Radio X.25 PLP */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006646 PyModule_AddIntMacro(m, AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006647#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006648#ifdef AF_DECnet
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006649 /* Reserved for DECnet project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006650 PyModule_AddIntMacro(m, AF_DECnet);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006651#endif
6652#ifdef AF_NETBEUI
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006653 /* Reserved for 802.2LLC project */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006654 PyModule_AddIntMacro(m, AF_NETBEUI);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006655#endif
6656#ifdef AF_SECURITY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006657 /* Security callback pseudo AF */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006658 PyModule_AddIntMacro(m, AF_SECURITY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006659#endif
6660#ifdef AF_KEY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006661 /* PF_KEY key management API */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006662 PyModule_AddIntMacro(m, AF_KEY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006663#endif
6664#ifdef AF_NETLINK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006665 /* */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006666 PyModule_AddIntMacro(m, AF_NETLINK);
6667 PyModule_AddIntMacro(m, NETLINK_ROUTE);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006668#ifdef NETLINK_SKIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006669 PyModule_AddIntMacro(m, NETLINK_SKIP);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006670#endif
6671#ifdef NETLINK_W1
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006672 PyModule_AddIntMacro(m, NETLINK_W1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006673#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006674 PyModule_AddIntMacro(m, NETLINK_USERSOCK);
6675 PyModule_AddIntMacro(m, NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006676#ifdef NETLINK_TCPDIAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006677 PyModule_AddIntMacro(m, NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006678#endif
6679#ifdef NETLINK_NFLOG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006680 PyModule_AddIntMacro(m, NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00006681#endif
Neal Norwitz65851662006-01-16 04:31:40 +00006682#ifdef NETLINK_XFRM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006683 PyModule_AddIntMacro(m, NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00006684#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006685#ifdef NETLINK_ARPD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006686 PyModule_AddIntMacro(m, NETLINK_ARPD);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006687#endif
6688#ifdef NETLINK_ROUTE6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006689 PyModule_AddIntMacro(m, NETLINK_ROUTE6);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006690#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006691 PyModule_AddIntMacro(m, NETLINK_IP6_FW);
Thomas Wouterscf297e42007-02-23 15:07:44 +00006692#ifdef NETLINK_DNRTMSG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006693 PyModule_AddIntMacro(m, NETLINK_DNRTMSG);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00006694#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006695#ifdef NETLINK_TAPBASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006696 PyModule_AddIntMacro(m, NETLINK_TAPBASE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006697#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02006698#ifdef NETLINK_CRYPTO
6699 PyModule_AddIntMacro(m, NETLINK_CRYPTO);
6700#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00006701#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006702#ifdef AF_ROUTE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006703 /* Alias to emulate 4.4BSD */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006704 PyModule_AddIntMacro(m, AF_ROUTE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006705#endif
Giampaolo Rodola'80e1c432013-05-21 21:02:04 +02006706#ifdef AF_LINK
6707 PyModule_AddIntMacro(m, AF_LINK);
6708#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006709#ifdef AF_ASH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006710 /* Ash */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006711 PyModule_AddIntMacro(m, AF_ASH);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006712#endif
6713#ifdef AF_ECONET
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006714 /* Acorn Econet */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006715 PyModule_AddIntMacro(m, AF_ECONET);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006716#endif
6717#ifdef AF_ATMSVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006718 /* ATM SVCs */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006719 PyModule_AddIntMacro(m, AF_ATMSVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006720#endif
6721#ifdef AF_SNA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006722 /* Linux SNA Project (nutters!) */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006723 PyModule_AddIntMacro(m, AF_SNA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006724#endif
6725#ifdef AF_IRDA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006726 /* IRDA sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006727 PyModule_AddIntMacro(m, AF_IRDA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006728#endif
6729#ifdef AF_PPPOX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006730 /* PPPoX sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006731 PyModule_AddIntMacro(m, AF_PPPOX);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006732#endif
6733#ifdef AF_WANPIPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006734 /* Wanpipe API Sockets */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006735 PyModule_AddIntMacro(m, AF_WANPIPE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006736#endif
6737#ifdef AF_LLC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006738 /* Linux LLC */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006739 PyModule_AddIntMacro(m, AF_LLC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00006740#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00006741
Hye-Shik Chang81268602004-02-02 06:05:24 +00006742#ifdef USE_BLUETOOTH
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006743 PyModule_AddIntMacro(m, AF_BLUETOOTH);
6744 PyModule_AddIntMacro(m, BTPROTO_L2CAP);
6745 PyModule_AddIntMacro(m, BTPROTO_HCI);
6746 PyModule_AddIntMacro(m, SOL_HCI);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006747#if !defined(__NetBSD__) && !defined(__DragonFly__)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006748 PyModule_AddIntMacro(m, HCI_FILTER);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006749#endif
Hye-Shik Chang81268602004-02-02 06:05:24 +00006750#if !defined(__FreeBSD__)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006751#if !defined(__NetBSD__) && !defined(__DragonFly__)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006752 PyModule_AddIntMacro(m, HCI_TIME_STAMP);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00006753#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006754 PyModule_AddIntMacro(m, HCI_DATA_DIR);
6755 PyModule_AddIntMacro(m, BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00006756#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006757 PyModule_AddIntMacro(m, BTPROTO_RFCOMM);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006758 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
6759 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
Martin v. Löwis12af0482004-01-31 12:34:17 +00006760#endif
6761
Charles-François Natali47413c12011-10-06 19:47:44 +02006762#ifdef AF_CAN
6763 /* Controller Area Network */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006764 PyModule_AddIntMacro(m, AF_CAN);
Charles-François Natali47413c12011-10-06 19:47:44 +02006765#endif
6766#ifdef PF_CAN
6767 /* Controller Area Network */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006768 PyModule_AddIntMacro(m, PF_CAN);
Charles-François Natali47413c12011-10-06 19:47:44 +02006769#endif
6770
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006771/* Reliable Datagram Sockets */
6772#ifdef AF_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006773 PyModule_AddIntMacro(m, AF_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006774#endif
6775#ifdef PF_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006776 PyModule_AddIntMacro(m, PF_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01006777#endif
6778
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006779/* Kernel event messages */
6780#ifdef PF_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006781 PyModule_AddIntMacro(m, PF_SYSTEM);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006782#endif
6783#ifdef AF_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006784 PyModule_AddIntMacro(m, AF_SYSTEM);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01006785#endif
6786
Antoine Pitroub156a462010-10-27 20:13:57 +00006787#ifdef AF_PACKET
6788 PyModule_AddIntMacro(m, AF_PACKET);
6789#endif
6790#ifdef PF_PACKET
6791 PyModule_AddIntMacro(m, PF_PACKET);
6792#endif
6793#ifdef PACKET_HOST
6794 PyModule_AddIntMacro(m, PACKET_HOST);
6795#endif
6796#ifdef PACKET_BROADCAST
6797 PyModule_AddIntMacro(m, PACKET_BROADCAST);
6798#endif
6799#ifdef PACKET_MULTICAST
6800 PyModule_AddIntMacro(m, PACKET_MULTICAST);
6801#endif
6802#ifdef PACKET_OTHERHOST
6803 PyModule_AddIntMacro(m, PACKET_OTHERHOST);
6804#endif
6805#ifdef PACKET_OUTGOING
6806 PyModule_AddIntMacro(m, PACKET_OUTGOING);
6807#endif
6808#ifdef PACKET_LOOPBACK
6809 PyModule_AddIntMacro(m, PACKET_LOOPBACK);
6810#endif
6811#ifdef PACKET_FASTROUTE
6812 PyModule_AddIntMacro(m, PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00006813#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00006814
Christian Heimes043d6f62008-01-07 17:19:16 +00006815#ifdef HAVE_LINUX_TIPC_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006816 PyModule_AddIntMacro(m, AF_TIPC);
Christian Heimes043d6f62008-01-07 17:19:16 +00006817
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006818 /* for addresses */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006819 PyModule_AddIntMacro(m, TIPC_ADDR_NAMESEQ);
6820 PyModule_AddIntMacro(m, TIPC_ADDR_NAME);
6821 PyModule_AddIntMacro(m, TIPC_ADDR_ID);
Christian Heimes043d6f62008-01-07 17:19:16 +00006822
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006823 PyModule_AddIntMacro(m, TIPC_ZONE_SCOPE);
6824 PyModule_AddIntMacro(m, TIPC_CLUSTER_SCOPE);
6825 PyModule_AddIntMacro(m, TIPC_NODE_SCOPE);
Christian Heimes043d6f62008-01-07 17:19:16 +00006826
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006827 /* for setsockopt() */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006828 PyModule_AddIntMacro(m, SOL_TIPC);
6829 PyModule_AddIntMacro(m, TIPC_IMPORTANCE);
6830 PyModule_AddIntMacro(m, TIPC_SRC_DROPPABLE);
6831 PyModule_AddIntMacro(m, TIPC_DEST_DROPPABLE);
6832 PyModule_AddIntMacro(m, TIPC_CONN_TIMEOUT);
Christian Heimes043d6f62008-01-07 17:19:16 +00006833
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006834 PyModule_AddIntMacro(m, TIPC_LOW_IMPORTANCE);
6835 PyModule_AddIntMacro(m, TIPC_MEDIUM_IMPORTANCE);
6836 PyModule_AddIntMacro(m, TIPC_HIGH_IMPORTANCE);
6837 PyModule_AddIntMacro(m, TIPC_CRITICAL_IMPORTANCE);
Christian Heimes043d6f62008-01-07 17:19:16 +00006838
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006839 /* for subscriptions */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006840 PyModule_AddIntMacro(m, TIPC_SUB_PORTS);
6841 PyModule_AddIntMacro(m, TIPC_SUB_SERVICE);
Christian Heimes25bb7832008-01-11 16:17:00 +00006842#ifdef TIPC_SUB_CANCEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006843 /* doesn't seem to be available everywhere */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006844 PyModule_AddIntMacro(m, TIPC_SUB_CANCEL);
Christian Heimes25bb7832008-01-11 16:17:00 +00006845#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006846 PyModule_AddIntMacro(m, TIPC_WAIT_FOREVER);
6847 PyModule_AddIntMacro(m, TIPC_PUBLISHED);
6848 PyModule_AddIntMacro(m, TIPC_WITHDRAWN);
6849 PyModule_AddIntMacro(m, TIPC_SUBSCR_TIMEOUT);
6850 PyModule_AddIntMacro(m, TIPC_CFG_SRV);
6851 PyModule_AddIntMacro(m, TIPC_TOP_SRV);
Christian Heimes043d6f62008-01-07 17:19:16 +00006852#endif
6853
Christian Heimesdffa3942016-09-05 23:54:41 +02006854#ifdef HAVE_SOCKADDR_ALG
6855 /* Socket options */
6856 PyModule_AddIntMacro(m, ALG_SET_KEY);
6857 PyModule_AddIntMacro(m, ALG_SET_IV);
6858 PyModule_AddIntMacro(m, ALG_SET_OP);
6859 PyModule_AddIntMacro(m, ALG_SET_AEAD_ASSOCLEN);
6860 PyModule_AddIntMacro(m, ALG_SET_AEAD_AUTHSIZE);
6861 PyModule_AddIntMacro(m, ALG_SET_PUBKEY);
6862
6863 /* Operations */
6864 PyModule_AddIntMacro(m, ALG_OP_DECRYPT);
6865 PyModule_AddIntMacro(m, ALG_OP_ENCRYPT);
6866 PyModule_AddIntMacro(m, ALG_OP_SIGN);
6867 PyModule_AddIntMacro(m, ALG_OP_VERIFY);
6868#endif
6869
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006870 /* Socket types */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006871 PyModule_AddIntMacro(m, SOCK_STREAM);
6872 PyModule_AddIntMacro(m, SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00006873/* We have incomplete socket support. */
Berker Peksag95e0df82016-08-08 14:07:05 +03006874#ifdef SOCK_RAW
6875 /* SOCK_RAW is marked as optional in the POSIX specification */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006876 PyModule_AddIntMacro(m, SOCK_RAW);
Berker Peksag95e0df82016-08-08 14:07:05 +03006877#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006878 PyModule_AddIntMacro(m, SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00006879#if defined(SOCK_RDM)
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006880 PyModule_AddIntMacro(m, SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00006881#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +00006882#ifdef SOCK_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006883 PyModule_AddIntMacro(m, SOCK_CLOEXEC);
Antoine Pitroub1c54962010-10-14 15:05:38 +00006884#endif
6885#ifdef SOCK_NONBLOCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006886 PyModule_AddIntMacro(m, SOCK_NONBLOCK);
Antoine Pitroub1c54962010-10-14 15:05:38 +00006887#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006888
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006889#ifdef SO_DEBUG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006890 PyModule_AddIntMacro(m, SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006891#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006892#ifdef SO_ACCEPTCONN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006893 PyModule_AddIntMacro(m, SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006894#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006895#ifdef SO_REUSEADDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006896 PyModule_AddIntMacro(m, SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006897#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00006898#ifdef SO_EXCLUSIVEADDRUSE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006899 PyModule_AddIntMacro(m, SO_EXCLUSIVEADDRUSE);
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00006900#endif
6901
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006902#ifdef SO_KEEPALIVE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006903 PyModule_AddIntMacro(m, SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006904#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006905#ifdef SO_DONTROUTE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006906 PyModule_AddIntMacro(m, SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006907#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006908#ifdef SO_BROADCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006909 PyModule_AddIntMacro(m, SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006910#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006911#ifdef SO_USELOOPBACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006912 PyModule_AddIntMacro(m, SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006913#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006914#ifdef SO_LINGER
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006915 PyModule_AddIntMacro(m, SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006916#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006917#ifdef SO_OOBINLINE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006918 PyModule_AddIntMacro(m, SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006919#endif
doko@ubuntu.comfcff4372016-06-13 16:33:04 +02006920#ifndef __GNU__
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006921#ifdef SO_REUSEPORT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006922 PyModule_AddIntMacro(m, SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006923#endif
doko@ubuntu.comfcff4372016-06-13 16:33:04 +02006924#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006925#ifdef SO_SNDBUF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006926 PyModule_AddIntMacro(m, SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006927#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006928#ifdef SO_RCVBUF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006929 PyModule_AddIntMacro(m, SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006930#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006931#ifdef SO_SNDLOWAT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006932 PyModule_AddIntMacro(m, SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006933#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006934#ifdef SO_RCVLOWAT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006935 PyModule_AddIntMacro(m, SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006936#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006937#ifdef SO_SNDTIMEO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006938 PyModule_AddIntMacro(m, SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006939#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006940#ifdef SO_RCVTIMEO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006941 PyModule_AddIntMacro(m, SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006942#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006943#ifdef SO_ERROR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006944 PyModule_AddIntMacro(m, SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006945#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006946#ifdef SO_TYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006947 PyModule_AddIntMacro(m, SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006948#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006949#ifdef SO_SETFIB
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006950 PyModule_AddIntMacro(m, SO_SETFIB);
Larry Hastingsf0f37952010-04-02 11:47:10 +00006951#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006952#ifdef SO_PASSCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006953 PyModule_AddIntMacro(m, SO_PASSCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006954#endif
6955#ifdef SO_PEERCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006956 PyModule_AddIntMacro(m, SO_PEERCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006957#endif
6958#ifdef LOCAL_PEERCRED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006959 PyModule_AddIntMacro(m, LOCAL_PEERCRED);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006960#endif
R David Murraybdfa0eb2016-08-23 21:12:40 -04006961#ifdef SO_PASSSEC
6962 PyModule_AddIntMacro(m, SO_PASSSEC);
6963#endif
6964#ifdef SO_PEERSEC
6965 PyModule_AddIntMacro(m, SO_PEERSEC);
6966#endif
Victor Stinnercb98bed2011-10-25 13:45:48 +02006967#ifdef SO_BINDTODEVICE
6968 PyModule_AddIntMacro(m, SO_BINDTODEVICE);
6969#endif
Benjamin Peterson1314ef72013-11-27 09:18:54 -06006970#ifdef SO_PRIORITY
6971 PyModule_AddIntMacro(m, SO_PRIORITY);
6972#endif
Charles-François Nataliea07eb92014-09-18 23:18:46 +01006973#ifdef SO_MARK
6974 PyModule_AddIntMacro(m, SO_MARK);
6975#endif
R David Murraybdfa0eb2016-08-23 21:12:40 -04006976#ifdef SO_DOMAIN
6977 PyModule_AddIntMacro(m, SO_DOMAIN);
6978#endif
6979#ifdef SO_PROTOCOL
6980 PyModule_AddIntMacro(m, SO_PROTOCOL);
6981#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006982
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006983 /* Maximum number of connections for "listen" */
6984#ifdef SOMAXCONN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006985 PyModule_AddIntMacro(m, SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006986#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006987 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006988#endif
6989
Raymond Hettinger15f44ab2016-08-30 10:47:49 -07006990 /* Ancillary message types */
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006991#ifdef SCM_RIGHTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006992 PyModule_AddIntMacro(m, SCM_RIGHTS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006993#endif
6994#ifdef SCM_CREDENTIALS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006995 PyModule_AddIntMacro(m, SCM_CREDENTIALS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006996#endif
6997#ifdef SCM_CREDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02006998 PyModule_AddIntMacro(m, SCM_CREDS);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10006999#endif
7000
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007001 /* Flags for send, recv */
7002#ifdef MSG_OOB
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007003 PyModule_AddIntMacro(m, MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007004#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007005#ifdef MSG_PEEK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007006 PyModule_AddIntMacro(m, MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007007#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007008#ifdef MSG_DONTROUTE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007009 PyModule_AddIntMacro(m, MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007010#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007011#ifdef MSG_DONTWAIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007012 PyModule_AddIntMacro(m, MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00007013#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007014#ifdef MSG_EOR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007015 PyModule_AddIntMacro(m, MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007016#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007017#ifdef MSG_TRUNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007018 PyModule_AddIntMacro(m, MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007019#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007020#ifdef MSG_CTRUNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007021 PyModule_AddIntMacro(m, MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007022#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007023#ifdef MSG_WAITALL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007024 PyModule_AddIntMacro(m, MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007025#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007026#ifdef MSG_BTAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007027 PyModule_AddIntMacro(m, MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007028#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007029#ifdef MSG_ETAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007030 PyModule_AddIntMacro(m, MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007031#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007032#ifdef MSG_NOSIGNAL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007033 PyModule_AddIntMacro(m, MSG_NOSIGNAL);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007034#endif
7035#ifdef MSG_NOTIFICATION
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007036 PyModule_AddIntMacro(m, MSG_NOTIFICATION);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007037#endif
7038#ifdef MSG_CMSG_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007039 PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007040#endif
7041#ifdef MSG_ERRQUEUE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007042 PyModule_AddIntMacro(m, MSG_ERRQUEUE);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007043#endif
7044#ifdef MSG_CONFIRM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007045 PyModule_AddIntMacro(m, MSG_CONFIRM);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007046#endif
7047#ifdef MSG_MORE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007048 PyModule_AddIntMacro(m, MSG_MORE);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007049#endif
7050#ifdef MSG_EOF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007051 PyModule_AddIntMacro(m, MSG_EOF);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007052#endif
7053#ifdef MSG_BCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007054 PyModule_AddIntMacro(m, MSG_BCAST);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007055#endif
7056#ifdef MSG_MCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007057 PyModule_AddIntMacro(m, MSG_MCAST);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007058#endif
Benjamin Peterson57b66722012-12-12 22:24:47 -05007059#ifdef MSG_FASTOPEN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007060 PyModule_AddIntMacro(m, MSG_FASTOPEN);
Benjamin Peterson57b66722012-12-12 22:24:47 -05007061#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007062
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007063 /* Protocol level and numbers, usable for [gs]etsockopt */
7064#ifdef SOL_SOCKET
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007065 PyModule_AddIntMacro(m, SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007066#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007067#ifdef SOL_IP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007068 PyModule_AddIntMacro(m, SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00007069#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007070 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00007071#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007072#ifdef SOL_IPX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007073 PyModule_AddIntMacro(m, SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00007074#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007075#ifdef SOL_AX25
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007076 PyModule_AddIntMacro(m, SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00007077#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007078#ifdef SOL_ATALK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007079 PyModule_AddIntMacro(m, SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00007080#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007081#ifdef SOL_NETROM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007082 PyModule_AddIntMacro(m, SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00007083#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007084#ifdef SOL_ROSE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007085 PyModule_AddIntMacro(m, SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00007086#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007087#ifdef SOL_TCP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007088 PyModule_AddIntMacro(m, SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00007089#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007090 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00007091#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007092#ifdef SOL_UDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007093 PyModule_AddIntMacro(m, SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00007094#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007095 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00007096#endif
Charles-François Natali47413c12011-10-06 19:47:44 +02007097#ifdef SOL_CAN_BASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007098 PyModule_AddIntMacro(m, SOL_CAN_BASE);
Charles-François Natali47413c12011-10-06 19:47:44 +02007099#endif
7100#ifdef SOL_CAN_RAW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007101 PyModule_AddIntMacro(m, SOL_CAN_RAW);
7102 PyModule_AddIntMacro(m, CAN_RAW);
Charles-François Natali47413c12011-10-06 19:47:44 +02007103#endif
7104#ifdef HAVE_LINUX_CAN_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007105 PyModule_AddIntMacro(m, CAN_EFF_FLAG);
7106 PyModule_AddIntMacro(m, CAN_RTR_FLAG);
7107 PyModule_AddIntMacro(m, CAN_ERR_FLAG);
Charles-François Natali47413c12011-10-06 19:47:44 +02007108
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007109 PyModule_AddIntMacro(m, CAN_SFF_MASK);
7110 PyModule_AddIntMacro(m, CAN_EFF_MASK);
7111 PyModule_AddIntMacro(m, CAN_ERR_MASK);
Charles-François Natali47413c12011-10-06 19:47:44 +02007112#endif
7113#ifdef HAVE_LINUX_CAN_RAW_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007114 PyModule_AddIntMacro(m, CAN_RAW_FILTER);
7115 PyModule_AddIntMacro(m, CAN_RAW_ERR_FILTER);
7116 PyModule_AddIntMacro(m, CAN_RAW_LOOPBACK);
7117 PyModule_AddIntMacro(m, CAN_RAW_RECV_OWN_MSGS);
Charles-François Natali47413c12011-10-06 19:47:44 +02007118#endif
Larry Hastingsa6cc5512015-04-13 17:48:40 -04007119#ifdef HAVE_LINUX_CAN_RAW_FD_FRAMES
7120 PyModule_AddIntMacro(m, CAN_RAW_FD_FRAMES);
7121#endif
Charles-François Natali773e42d2013-02-05 19:42:01 +01007122#ifdef HAVE_LINUX_CAN_BCM_H
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007123 PyModule_AddIntMacro(m, CAN_BCM);
Charles-François Natali773e42d2013-02-05 19:42:01 +01007124 PyModule_AddIntConstant(m, "CAN_BCM_TX_SETUP", TX_SETUP);
7125 PyModule_AddIntConstant(m, "CAN_BCM_TX_DELETE", TX_DELETE);
7126 PyModule_AddIntConstant(m, "CAN_BCM_TX_READ", TX_READ);
7127 PyModule_AddIntConstant(m, "CAN_BCM_TX_SEND", TX_SEND);
7128 PyModule_AddIntConstant(m, "CAN_BCM_RX_SETUP", RX_SETUP);
7129 PyModule_AddIntConstant(m, "CAN_BCM_RX_DELETE", RX_DELETE);
7130 PyModule_AddIntConstant(m, "CAN_BCM_RX_READ", RX_READ);
7131 PyModule_AddIntConstant(m, "CAN_BCM_TX_STATUS", TX_STATUS);
7132 PyModule_AddIntConstant(m, "CAN_BCM_TX_EXPIRED", TX_EXPIRED);
7133 PyModule_AddIntConstant(m, "CAN_BCM_RX_STATUS", RX_STATUS);
7134 PyModule_AddIntConstant(m, "CAN_BCM_RX_TIMEOUT", RX_TIMEOUT);
7135 PyModule_AddIntConstant(m, "CAN_BCM_RX_CHANGED", RX_CHANGED);
7136#endif
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007137#ifdef SOL_RDS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007138 PyModule_AddIntMacro(m, SOL_RDS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007139#endif
Christian Heimesdffa3942016-09-05 23:54:41 +02007140#ifdef HAVE_SOCKADDR_ALG
7141 PyModule_AddIntMacro(m, SOL_ALG);
7142#endif
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007143#ifdef RDS_CANCEL_SENT_TO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007144 PyModule_AddIntMacro(m, RDS_CANCEL_SENT_TO);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007145#endif
7146#ifdef RDS_GET_MR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007147 PyModule_AddIntMacro(m, RDS_GET_MR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007148#endif
7149#ifdef RDS_FREE_MR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007150 PyModule_AddIntMacro(m, RDS_FREE_MR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007151#endif
7152#ifdef RDS_RECVERR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007153 PyModule_AddIntMacro(m, RDS_RECVERR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007154#endif
7155#ifdef RDS_CONG_MONITOR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007156 PyModule_AddIntMacro(m, RDS_CONG_MONITOR);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007157#endif
7158#ifdef RDS_GET_MR_FOR_DEST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007159 PyModule_AddIntMacro(m, RDS_GET_MR_FOR_DEST);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007160#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007161#ifdef IPPROTO_IP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007162 PyModule_AddIntMacro(m, IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00007163#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007164 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007165#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007166#ifdef IPPROTO_HOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007167 PyModule_AddIntMacro(m, IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007168#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007169#ifdef IPPROTO_ICMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007170 PyModule_AddIntMacro(m, IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00007171#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007172 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007173#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007174#ifdef IPPROTO_IGMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007175 PyModule_AddIntMacro(m, IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007176#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007177#ifdef IPPROTO_GGP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007178 PyModule_AddIntMacro(m, IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007179#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007180#ifdef IPPROTO_IPV4
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007181 PyModule_AddIntMacro(m, IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007182#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007183#ifdef IPPROTO_IPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007184 PyModule_AddIntMacro(m, IPPROTO_IPV6);
Martin v. Löwisa0f17342003-10-03 13:56:20 +00007185#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007186#ifdef IPPROTO_IPIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007187 PyModule_AddIntMacro(m, IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007188#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007189#ifdef IPPROTO_TCP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007190 PyModule_AddIntMacro(m, IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00007191#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007192 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007193#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007194#ifdef IPPROTO_EGP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007195 PyModule_AddIntMacro(m, IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007196#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007197#ifdef IPPROTO_PUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007198 PyModule_AddIntMacro(m, IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007199#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007200#ifdef IPPROTO_UDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007201 PyModule_AddIntMacro(m, IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00007202#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007203 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007204#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007205#ifdef IPPROTO_IDP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007206 PyModule_AddIntMacro(m, IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007207#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007208#ifdef IPPROTO_HELLO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007209 PyModule_AddIntMacro(m, IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007210#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007211#ifdef IPPROTO_ND
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007212 PyModule_AddIntMacro(m, IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007213#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007214#ifdef IPPROTO_TP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007215 PyModule_AddIntMacro(m, IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007216#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007217#ifdef IPPROTO_IPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007218 PyModule_AddIntMacro(m, IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007219#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007220#ifdef IPPROTO_ROUTING
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007221 PyModule_AddIntMacro(m, IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007222#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007223#ifdef IPPROTO_FRAGMENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007224 PyModule_AddIntMacro(m, IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007225#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007226#ifdef IPPROTO_RSVP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007227 PyModule_AddIntMacro(m, IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007228#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007229#ifdef IPPROTO_GRE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007230 PyModule_AddIntMacro(m, IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007231#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007232#ifdef IPPROTO_ESP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007233 PyModule_AddIntMacro(m, IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007234#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007235#ifdef IPPROTO_AH
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007236 PyModule_AddIntMacro(m, IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007237#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007238#ifdef IPPROTO_MOBILE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007239 PyModule_AddIntMacro(m, IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007240#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007241#ifdef IPPROTO_ICMPV6
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007242 PyModule_AddIntMacro(m, IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007243#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007244#ifdef IPPROTO_NONE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007245 PyModule_AddIntMacro(m, IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007246#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007247#ifdef IPPROTO_DSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007248 PyModule_AddIntMacro(m, IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007249#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007250#ifdef IPPROTO_XTP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007251 PyModule_AddIntMacro(m, IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007252#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007253#ifdef IPPROTO_EON
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007254 PyModule_AddIntMacro(m, IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007255#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007256#ifdef IPPROTO_PIM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007257 PyModule_AddIntMacro(m, IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007258#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007259#ifdef IPPROTO_IPCOMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007260 PyModule_AddIntMacro(m, IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007261#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007262#ifdef IPPROTO_VRRP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007263 PyModule_AddIntMacro(m, IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007264#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007265#ifdef IPPROTO_SCTP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007266 PyModule_AddIntMacro(m, IPPROTO_SCTP);
Nick Coghlan96fe56a2011-08-22 11:55:57 +10007267#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007268#ifdef IPPROTO_BIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007269 PyModule_AddIntMacro(m, IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007270#endif
7271/**/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007272#ifdef IPPROTO_RAW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007273 PyModule_AddIntMacro(m, IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00007274#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007275 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007276#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007277#ifdef IPPROTO_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007278 PyModule_AddIntMacro(m, IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007279#endif
7280
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01007281#ifdef SYSPROTO_CONTROL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007282 PyModule_AddIntMacro(m, SYSPROTO_CONTROL);
Martin v. Löwis9d6c6692012-02-03 17:44:58 +01007283#endif
7284
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007285 /* Some port configuration */
7286#ifdef IPPORT_RESERVED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007287 PyModule_AddIntMacro(m, IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007288#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007289 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007290#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007291#ifdef IPPORT_USERRESERVED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007292 PyModule_AddIntMacro(m, IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007293#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007294 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007295#endif
7296
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007297 /* Some reserved IP v.4 addresses */
7298#ifdef INADDR_ANY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007299 PyModule_AddIntMacro(m, INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007300#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007301 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007302#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007303#ifdef INADDR_BROADCAST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007304 PyModule_AddIntMacro(m, INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007305#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007306 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007307#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007308#ifdef INADDR_LOOPBACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007309 PyModule_AddIntMacro(m, INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007310#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007311 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007312#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007313#ifdef INADDR_UNSPEC_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007314 PyModule_AddIntMacro(m, INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007315#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007316 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007317#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007318#ifdef INADDR_ALLHOSTS_GROUP
7319 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
7320 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007321#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007322 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007323#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007324#ifdef INADDR_MAX_LOCAL_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007325 PyModule_AddIntMacro(m, INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007326#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007327 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007328#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007329#ifdef INADDR_NONE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007330 PyModule_AddIntMacro(m, INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007331#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007332 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00007333#endif
7334
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007335 /* IPv4 [gs]etsockopt options */
7336#ifdef IP_OPTIONS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007337 PyModule_AddIntMacro(m, IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007338#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007339#ifdef IP_HDRINCL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007340 PyModule_AddIntMacro(m, IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007341#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007342#ifdef IP_TOS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007343 PyModule_AddIntMacro(m, IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007344#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007345#ifdef IP_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007346 PyModule_AddIntMacro(m, IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007347#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007348#ifdef IP_RECVOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007349 PyModule_AddIntMacro(m, IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007350#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007351#ifdef IP_RECVRETOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007352 PyModule_AddIntMacro(m, IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007353#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007354#ifdef IP_RECVDSTADDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007355 PyModule_AddIntMacro(m, IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007356#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007357#ifdef IP_RETOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007358 PyModule_AddIntMacro(m, IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007359#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007360#ifdef IP_MULTICAST_IF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007361 PyModule_AddIntMacro(m, IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007362#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007363#ifdef IP_MULTICAST_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007364 PyModule_AddIntMacro(m, IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007365#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007366#ifdef IP_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007367 PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007368#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007369#ifdef IP_ADD_MEMBERSHIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007370 PyModule_AddIntMacro(m, IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007371#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007372#ifdef IP_DROP_MEMBERSHIP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007373 PyModule_AddIntMacro(m, IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00007374#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007375#ifdef IP_DEFAULT_MULTICAST_TTL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007376 PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00007377#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007378#ifdef IP_DEFAULT_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007379 PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00007380#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007381#ifdef IP_MAX_MEMBERSHIPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007382 PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00007383#endif
Charles-François Natali564a42c2011-12-17 14:59:56 +01007384#ifdef IP_TRANSPARENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007385 PyModule_AddIntMacro(m, IP_TRANSPARENT);
Charles-François Natali564a42c2011-12-17 14:59:56 +01007386#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00007387
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007388 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
7389#ifdef IPV6_JOIN_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007390 PyModule_AddIntMacro(m, IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007391#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007392#ifdef IPV6_LEAVE_GROUP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007393 PyModule_AddIntMacro(m, IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007394#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007395#ifdef IPV6_MULTICAST_HOPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007396 PyModule_AddIntMacro(m, IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007397#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007398#ifdef IPV6_MULTICAST_IF
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007399 PyModule_AddIntMacro(m, IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007400#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007401#ifdef IPV6_MULTICAST_LOOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007402 PyModule_AddIntMacro(m, IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007403#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007404#ifdef IPV6_UNICAST_HOPS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007405 PyModule_AddIntMacro(m, IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007406#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007407 /* Additional IPV6 socket options, defined in RFC 3493 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00007408#ifdef IPV6_V6ONLY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007409 PyModule_AddIntMacro(m, IPV6_V6ONLY);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007410#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007411 /* Advanced IPV6 socket options, from RFC 3542 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00007412#ifdef IPV6_CHECKSUM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007413 PyModule_AddIntMacro(m, IPV6_CHECKSUM);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007414#endif
7415#ifdef IPV6_DONTFRAG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007416 PyModule_AddIntMacro(m, IPV6_DONTFRAG);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007417#endif
7418#ifdef IPV6_DSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007419 PyModule_AddIntMacro(m, IPV6_DSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007420#endif
7421#ifdef IPV6_HOPLIMIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007422 PyModule_AddIntMacro(m, IPV6_HOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007423#endif
7424#ifdef IPV6_HOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007425 PyModule_AddIntMacro(m, IPV6_HOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007426#endif
7427#ifdef IPV6_NEXTHOP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007428 PyModule_AddIntMacro(m, IPV6_NEXTHOP);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007429#endif
7430#ifdef IPV6_PATHMTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007431 PyModule_AddIntMacro(m, IPV6_PATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007432#endif
7433#ifdef IPV6_PKTINFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007434 PyModule_AddIntMacro(m, IPV6_PKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007435#endif
7436#ifdef IPV6_RECVDSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007437 PyModule_AddIntMacro(m, IPV6_RECVDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007438#endif
7439#ifdef IPV6_RECVHOPLIMIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007440 PyModule_AddIntMacro(m, IPV6_RECVHOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007441#endif
7442#ifdef IPV6_RECVHOPOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007443 PyModule_AddIntMacro(m, IPV6_RECVHOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007444#endif
7445#ifdef IPV6_RECVPKTINFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007446 PyModule_AddIntMacro(m, IPV6_RECVPKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007447#endif
7448#ifdef IPV6_RECVRTHDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007449 PyModule_AddIntMacro(m, IPV6_RECVRTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007450#endif
7451#ifdef IPV6_RECVTCLASS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007452 PyModule_AddIntMacro(m, IPV6_RECVTCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007453#endif
7454#ifdef IPV6_RTHDR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007455 PyModule_AddIntMacro(m, IPV6_RTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007456#endif
7457#ifdef IPV6_RTHDRDSTOPTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007458 PyModule_AddIntMacro(m, IPV6_RTHDRDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007459#endif
7460#ifdef IPV6_RTHDR_TYPE_0
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007461 PyModule_AddIntMacro(m, IPV6_RTHDR_TYPE_0);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007462#endif
7463#ifdef IPV6_RECVPATHMTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007464 PyModule_AddIntMacro(m, IPV6_RECVPATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007465#endif
7466#ifdef IPV6_TCLASS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007467 PyModule_AddIntMacro(m, IPV6_TCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007468#endif
7469#ifdef IPV6_USE_MIN_MTU
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007470 PyModule_AddIntMacro(m, IPV6_USE_MIN_MTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007471#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00007472
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007473 /* TCP options */
7474#ifdef TCP_NODELAY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007475 PyModule_AddIntMacro(m, TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00007476#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007477#ifdef TCP_MAXSEG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007478 PyModule_AddIntMacro(m, TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00007479#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007480#ifdef TCP_CORK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007481 PyModule_AddIntMacro(m, TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007482#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007483#ifdef TCP_KEEPIDLE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007484 PyModule_AddIntMacro(m, TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007485#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007486#ifdef TCP_KEEPINTVL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007487 PyModule_AddIntMacro(m, TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007488#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007489#ifdef TCP_KEEPCNT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007490 PyModule_AddIntMacro(m, TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007491#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007492#ifdef TCP_SYNCNT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007493 PyModule_AddIntMacro(m, TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007494#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007495#ifdef TCP_LINGER2
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007496 PyModule_AddIntMacro(m, TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007497#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007498#ifdef TCP_DEFER_ACCEPT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007499 PyModule_AddIntMacro(m, TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007500#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007501#ifdef TCP_WINDOW_CLAMP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007502 PyModule_AddIntMacro(m, TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007503#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007504#ifdef TCP_INFO
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007505 PyModule_AddIntMacro(m, TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007506#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007507#ifdef TCP_QUICKACK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007508 PyModule_AddIntMacro(m, TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00007509#endif
Benjamin Peterson57b66722012-12-12 22:24:47 -05007510#ifdef TCP_FASTOPEN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007511 PyModule_AddIntMacro(m, TCP_FASTOPEN);
Benjamin Peterson57b66722012-12-12 22:24:47 -05007512#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00007513
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007514 /* IPX options */
7515#ifdef IPX_TYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007516 PyModule_AddIntMacro(m, IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00007517#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00007518
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007519/* Reliable Datagram Sockets */
7520#ifdef RDS_CMSG_RDMA_ARGS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007521 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_ARGS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007522#endif
7523#ifdef RDS_CMSG_RDMA_DEST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007524 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_DEST);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007525#endif
7526#ifdef RDS_CMSG_RDMA_MAP
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007527 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_MAP);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007528#endif
7529#ifdef RDS_CMSG_RDMA_STATUS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007530 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_STATUS);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007531#endif
7532#ifdef RDS_CMSG_RDMA_UPDATE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007533 PyModule_AddIntMacro(m, RDS_CMSG_RDMA_UPDATE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007534#endif
7535#ifdef RDS_RDMA_READWRITE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007536 PyModule_AddIntMacro(m, RDS_RDMA_READWRITE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007537#endif
7538#ifdef RDS_RDMA_FENCE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007539 PyModule_AddIntMacro(m, RDS_RDMA_FENCE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007540#endif
7541#ifdef RDS_RDMA_INVALIDATE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007542 PyModule_AddIntMacro(m, RDS_RDMA_INVALIDATE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007543#endif
7544#ifdef RDS_RDMA_USE_ONCE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007545 PyModule_AddIntMacro(m, RDS_RDMA_USE_ONCE);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007546#endif
7547#ifdef RDS_RDMA_DONTWAIT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007548 PyModule_AddIntMacro(m, RDS_RDMA_DONTWAIT);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007549#endif
7550#ifdef RDS_RDMA_NOTIFY_ME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007551 PyModule_AddIntMacro(m, RDS_RDMA_NOTIFY_ME);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007552#endif
7553#ifdef RDS_RDMA_SILENT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007554 PyModule_AddIntMacro(m, RDS_RDMA_SILENT);
Charles-François Natali10b8cf42011-11-10 19:21:37 +01007555#endif
7556
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007557 /* get{addr,name}info parameters */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007558#ifdef EAI_ADDRFAMILY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007559 PyModule_AddIntMacro(m, EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007560#endif
7561#ifdef EAI_AGAIN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007562 PyModule_AddIntMacro(m, EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007563#endif
7564#ifdef EAI_BADFLAGS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007565 PyModule_AddIntMacro(m, EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007566#endif
7567#ifdef EAI_FAIL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007568 PyModule_AddIntMacro(m, EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007569#endif
7570#ifdef EAI_FAMILY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007571 PyModule_AddIntMacro(m, EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007572#endif
7573#ifdef EAI_MEMORY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007574 PyModule_AddIntMacro(m, EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007575#endif
7576#ifdef EAI_NODATA
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007577 PyModule_AddIntMacro(m, EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007578#endif
7579#ifdef EAI_NONAME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007580 PyModule_AddIntMacro(m, EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007581#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00007582#ifdef EAI_OVERFLOW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007583 PyModule_AddIntMacro(m, EAI_OVERFLOW);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007584#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007585#ifdef EAI_SERVICE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007586 PyModule_AddIntMacro(m, EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007587#endif
7588#ifdef EAI_SOCKTYPE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007589 PyModule_AddIntMacro(m, EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007590#endif
7591#ifdef EAI_SYSTEM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007592 PyModule_AddIntMacro(m, EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007593#endif
7594#ifdef EAI_BADHINTS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007595 PyModule_AddIntMacro(m, EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007596#endif
7597#ifdef EAI_PROTOCOL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007598 PyModule_AddIntMacro(m, EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007599#endif
7600#ifdef EAI_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007601 PyModule_AddIntMacro(m, EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007602#endif
7603#ifdef AI_PASSIVE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007604 PyModule_AddIntMacro(m, AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007605#endif
7606#ifdef AI_CANONNAME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007607 PyModule_AddIntMacro(m, AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007608#endif
7609#ifdef AI_NUMERICHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007610 PyModule_AddIntMacro(m, AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007611#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00007612#ifdef AI_NUMERICSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007613 PyModule_AddIntMacro(m, AI_NUMERICSERV);
Martin v. Löwisda91d022003-12-30 11:14:01 +00007614#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007615#ifdef AI_MASK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007616 PyModule_AddIntMacro(m, AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007617#endif
7618#ifdef AI_ALL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007619 PyModule_AddIntMacro(m, AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007620#endif
7621#ifdef AI_V4MAPPED_CFG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007622 PyModule_AddIntMacro(m, AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007623#endif
7624#ifdef AI_ADDRCONFIG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007625 PyModule_AddIntMacro(m, AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007626#endif
7627#ifdef AI_V4MAPPED
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007628 PyModule_AddIntMacro(m, AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007629#endif
7630#ifdef AI_DEFAULT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007631 PyModule_AddIntMacro(m, AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007632#endif
7633#ifdef NI_MAXHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007634 PyModule_AddIntMacro(m, NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007635#endif
7636#ifdef NI_MAXSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007637 PyModule_AddIntMacro(m, NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007638#endif
7639#ifdef NI_NOFQDN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007640 PyModule_AddIntMacro(m, NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007641#endif
7642#ifdef NI_NUMERICHOST
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007643 PyModule_AddIntMacro(m, NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007644#endif
7645#ifdef NI_NAMEREQD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007646 PyModule_AddIntMacro(m, NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007647#endif
7648#ifdef NI_NUMERICSERV
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007649 PyModule_AddIntMacro(m, NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007650#endif
7651#ifdef NI_DGRAM
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007652 PyModule_AddIntMacro(m, NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00007653#endif
7654
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007655 /* shutdown() parameters */
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007656#ifdef SHUT_RD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007657 PyModule_AddIntMacro(m, SHUT_RD);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007658#elif defined(SD_RECEIVE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007659 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007660#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007661 PyModule_AddIntConstant(m, "SHUT_RD", 0);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007662#endif
7663#ifdef SHUT_WR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007664 PyModule_AddIntMacro(m, SHUT_WR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007665#elif defined(SD_SEND)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007666 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007667#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007668 PyModule_AddIntConstant(m, "SHUT_WR", 1);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007669#endif
7670#ifdef SHUT_RDWR
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007671 PyModule_AddIntMacro(m, SHUT_RDWR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007672#elif defined(SD_BOTH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007673 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007674#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007675 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00007676#endif
7677
Christian Heimesfaf2f632008-01-06 16:59:19 +00007678#ifdef SIO_RCVALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007679 {
Steve Dowerea93ac02016-06-17 12:52:18 -07007680 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS,
7681#if defined(SIO_LOOPBACK_FAST_PATH)
Berker Peksag3583c3b2016-06-18 16:43:25 +03007682 SIO_LOOPBACK_FAST_PATH
Steve Dowerea93ac02016-06-17 12:52:18 -07007683#endif
Berker Peksag3583c3b2016-06-18 16:43:25 +03007684 };
Steve Dowerea93ac02016-06-17 12:52:18 -07007685 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS",
7686#if defined(SIO_LOOPBACK_FAST_PATH)
Berker Peksag3583c3b2016-06-18 16:43:25 +03007687 "SIO_LOOPBACK_FAST_PATH"
Steve Dowerea93ac02016-06-17 12:52:18 -07007688#endif
Berker Peksag3583c3b2016-06-18 16:43:25 +03007689 };
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007690 int i;
Victor Stinner63941882011-09-29 00:42:28 +02007691 for(i = 0; i<Py_ARRAY_LENGTH(codes); ++i) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007692 PyObject *tmp;
7693 tmp = PyLong_FromUnsignedLong(codes[i]);
7694 if (tmp == NULL)
7695 return NULL;
7696 PyModule_AddObject(m, names[i], tmp);
7697 }
7698 }
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007699 PyModule_AddIntMacro(m, RCVALL_OFF);
7700 PyModule_AddIntMacro(m, RCVALL_ON);
7701 PyModule_AddIntMacro(m, RCVALL_SOCKETLEVELONLY);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007702#ifdef RCVALL_IPLEVEL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007703 PyModule_AddIntMacro(m, RCVALL_IPLEVEL);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007704#endif
7705#ifdef RCVALL_MAX
Charles-Francois Natali74ca8862013-05-20 19:13:19 +02007706 PyModule_AddIntMacro(m, RCVALL_MAX);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00007707#endif
Christian Heimesfaf2f632008-01-06 16:59:19 +00007708#endif /* _MSTCPIP_ */
7709
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007710 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00007711#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007712 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00007713#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007714 return m;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00007715}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007716
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007717
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007718#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +00007719#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007720
7721/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00007722/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007723
Guido van Rossum3eede5a2002-06-07 02:08:35 +00007724int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007725inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007726{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007727 if (af == AF_INET) {
Benjamin Petersonf91df042009-02-13 02:50:59 +00007728#if (SIZEOF_INT != 4)
7729#error "Not sure if in_addr_t exists and int is not 32-bits."
7730#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007731 unsigned int packed_addr;
7732 packed_addr = inet_addr(src);
7733 if (packed_addr == INADDR_NONE)
7734 return 0;
7735 memcpy(dst, &packed_addr, 4);
7736 return 1;
7737 }
7738 /* Should set errno to EAFNOSUPPORT */
7739 return -1;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007740}
7741
Martin v. Löwisc925b1532001-07-21 09:42:15 +00007742const char *
7743inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007744{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00007745 if (af == AF_INET) {
7746 struct in_addr packed_addr;
7747 if (size < 16)
7748 /* Should set errno to ENOSPC. */
7749 return NULL;
7750 memcpy(&packed_addr, src, sizeof(packed_addr));
7751 return strncpy(dst, inet_ntoa(packed_addr), size);
7752 }
7753 /* Should set errno to EAFNOSUPPORT */
7754 return NULL;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007755}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00007756
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00007757#endif
Christian Heimesb6150692007-11-15 23:37:07 +00007758#endif