blob: 936a68dcd6edbf5ed67fdc5683dc865e2244eb80 [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
Guido van Rossum27e177d1995-03-16 15:43:47 +000018- socket.error: exception raised for socket specific errors
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
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000036- socket.getaddrinfo(host, port [, family, socktype, proto, flags])
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000037 --> List of (family, socktype, 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__
87 /*
88 * inet_aton is not available on OSX 10.3, yet we want to use a binary
89 * that was build on 10.4 or later to work on that release, weak linking
90 * comes to the rescue.
91 */
92# pragma weak inet_aton
93#endif
94
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000095#include "Python.h"
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000096#include "structmember.h"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000097
Guido van Rossum47dfa4a2003-04-25 05:48:32 +000098#undef MAX
99#define MAX(x, y) ((x) < (y) ? (y) : (x))
100
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000101/* Socket object documentation */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000102PyDoc_STRVAR(sock_doc,
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000103"socket([family[, type[, proto]]]) -> socket object\n\
104\n\
105Open a socket of the given type. The family argument specifies the\n\
106address family; it defaults to AF_INET. The type argument specifies\n\
107whether this is a stream (SOCK_STREAM, this is the default)\n\
108or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
109specifying the default protocol. Keyword arguments are accepted.\n\
110\n\
111A socket object represents one endpoint of a network connection.\n\
112\n\
113Methods of socket objects (keyword arguments not allowed):\n\
114\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000115_accept() -- accept connection, returning new socket fd and client address\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000116bind(addr) -- bind the socket to a local address\n\
117close() -- close the socket\n\
118connect(addr) -- connect the socket to a remote address\n\
119connect_ex(addr) -- connect, return an error code instead of an exception\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000120_dup() -- return a new socket fd duplicated from fileno()\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000121fileno() -- return underlying file descriptor\n\
122getpeername() -- return remote address [*]\n\
123getsockname() -- return local address\n\
124getsockopt(level, optname[, buflen]) -- get socket options\n\
125gettimeout() -- return timeout or None\n\
126listen(n) -- start listening for incoming connections\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000127recv(buflen[, flags]) -- receive data\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000128recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000129recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000130recvfrom_into(buffer[, nbytes, [, flags])\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000131 -- receive data and sender\'s address (into a buffer)\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000132sendall(data[, flags]) -- send all data\n\
133send(data[, flags]) -- send data, may not send all of it\n\
134sendto(data[, flags], addr) -- send data to a given address\n\
135setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
136setsockopt(level, optname, value) -- set socket options\n\
137settimeout(None | float) -- set or clear the timeout\n\
138shutdown(how) -- shut down traffic in one or both directions\n\
Gregory P. Smith5ed2e772011-05-15 00:26:45 -0700139if_nameindex() -- return all network interface indices and names\n\
Gregory P. Smithb6471db2011-05-22 22:47:55 -0700140if_nametoindex(name) -- return the corresponding interface index\n\
141if_indextoname(index) -- return the corresponding interface name\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000142\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000143 [*] not available on all platforms!");
Guido van Rossum3baaa131999-03-22 21:44:51 +0000144
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000145/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000146 I hope some day someone can clean this up please... */
147
Guido van Rossum9376b741999-09-15 22:01:40 +0000148/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
149 script doesn't get this right, so we hardcode some platform checks below.
150 On the other hand, not all Linux versions agree, so there the settings
151 computed by the configure script are needed! */
152
153#ifndef linux
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000154# undef HAVE_GETHOSTBYNAME_R_3_ARG
155# undef HAVE_GETHOSTBYNAME_R_5_ARG
156# undef HAVE_GETHOSTBYNAME_R_6_ARG
Guido van Rossum9376b741999-09-15 22:01:40 +0000157#endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000158
Victor Stinner710d27e2011-08-23 10:57:32 +0200159#if defined(__OpenBSD__)
160# include <sys/uio.h>
161#endif
162
Guido van Rossum7a122991999-04-13 04:07:32 +0000163#ifndef WITH_THREAD
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000164# undef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +0000165#endif
166
Guido van Rossume7de2061999-03-24 17:24:33 +0000167#ifdef HAVE_GETHOSTBYNAME_R
Jesus Cea736e7fc2011-03-14 17:36:54 +0100168# if defined(_AIX)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000169# define HAVE_GETHOSTBYNAME_R_3_ARG
170# elif defined(__sun) || defined(__sgi)
171# define HAVE_GETHOSTBYNAME_R_5_ARG
172# elif defined(linux)
Guido van Rossum9376b741999-09-15 22:01:40 +0000173/* Rely on the configure script */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000174# else
175# undef HAVE_GETHOSTBYNAME_R
176# endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000177#endif
178
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000179#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
180 !defined(MS_WINDOWS)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000181# define USE_GETHOSTBYNAME_LOCK
Guido van Rossum3baaa131999-03-22 21:44:51 +0000182#endif
183
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000184/* To use __FreeBSD_version */
185#ifdef HAVE_SYS_PARAM_H
186#include <sys/param.h>
187#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000188/* On systems on which getaddrinfo() is believed to not be thread-safe,
Just van Rossum09aecd72003-05-09 08:03:44 +0000189 (this includes the getaddrinfo emulation) protect access with a lock. */
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000190#if defined(WITH_THREAD) && (defined(__APPLE__) || \
191 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000192 defined(__OpenBSD__) || defined(__NetBSD__) || \
193 defined(__VMS) || !defined(HAVE_GETADDRINFO))
Just van Rossum1040d2c2003-05-09 07:53:18 +0000194#define USE_GETADDRINFO_LOCK
195#endif
196
197#ifdef USE_GETADDRINFO_LOCK
198#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
199#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
200#else
201#define ACQUIRE_GETADDRINFO_LOCK
202#define RELEASE_GETADDRINFO_LOCK
203#endif
204
205#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000206# include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000207#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000208
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000209#if defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000210# include <types.h>
211# include <io.h>
212# include <sys/ioctl.h>
213# include <utils.h>
214# include <ctype.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000215#endif
216
Martin v. Löwis9e437302002-12-06 12:57:26 +0000217#if defined(__VMS)
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000218# include <ioctl.h>
219#endif
220
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000221#if defined(PYOS_OS2)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000222# define INCL_DOS
223# define INCL_DOSERRORS
224# define INCL_NOPMAPI
225# include <os2.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000226#endif
227
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000228#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000229/* make sure that the reentrant (gethostbyaddr_r etc)
230 functions are declared correctly if compiling with
231 MIPSPro 7.x in ANSI C mode (default) */
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000232
Thomas Wouters477c8d52006-05-27 19:21:47 +0000233/* XXX Using _SGIAPI is the wrong thing,
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000234 but I don't know what the right thing is. */
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000235#undef _SGIAPI /* to avoid warning */
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000236#define _SGIAPI 1
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000237
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000238#undef _XOPEN_SOURCE
239#include <sys/socket.h>
240#include <sys/types.h>
241#include <netinet/in.h>
242#ifdef _SS_ALIGNSIZE
243#define HAVE_GETADDRINFO 1
244#define HAVE_GETNAMEINFO 1
245#endif
246
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000247#define HAVE_INET_PTON
248#include <netdb.h>
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000249#endif
250
Thomas Wouters477c8d52006-05-27 19:21:47 +0000251/* Irix 6.5 fails to define this variable at all. This is needed
252 for both GCC and SGI's compiler. I'd say that the SGI headers
Georg Brandldbd83392006-02-20 09:42:33 +0000253 are just busted. Same thing for Solaris. */
254#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000255#define INET_ADDRSTRLEN 16
256#endif
257
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000258/* Generic includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000259#ifdef HAVE_SYS_TYPES_H
Guido van Rossumb6775db1994-08-01 11:34:53 +0000260#include <sys/types.h>
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000261#endif
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000262
Gregory P. Smith3b1f2c32011-05-15 12:18:23 -0700263#ifdef HAVE_SYS_SOCKET_H
264#include <sys/socket.h>
265#endif
266
267#ifdef HAVE_NET_IF_H
268#include <net/if.h>
269#endif
270
Marc-André Lemburg976ade62002-02-16 18:47:07 +0000271/* Generic socket object definitions and includes */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000272#define PySocket_BUILDING_SOCKET
Marc-André Lemburgbb8b78b2002-02-16 18:44:52 +0000273#include "socketmodule.h"
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000274
275/* Addressing includes */
276
Guido van Rossum6f489d91996-06-28 20:15:15 +0000277#ifndef MS_WINDOWS
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000278
279/* Non-MS WINDOWS includes */
280# include <netdb.h>
Nick Coghlan4ecf6cf2011-08-22 15:45:19 +1000281# include <unistd.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000282
Guido van Rossum9376b741999-09-15 22:01:40 +0000283/* Headers needed for inet_ntoa() and inet_addr() */
Skip Montanaroeb33e5a2007-08-17 12:57:41 +0000284# if defined(PYOS_OS2) && defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000285# include <netdb.h>
Tim Peters603c6832001-11-05 02:45:59 +0000286typedef size_t socklen_t;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000287# else
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000288# include <arpa/inet.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000289# endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000290
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000291# include <fcntl.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000292
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000293#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000294
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000295/* MS_WINDOWS includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000296# ifdef HAVE_FCNTL_H
297# include <fcntl.h>
298# endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000299
Jeremy Hylton22308652001-02-02 03:23:09 +0000300#endif
301
Skip Montanaro7befb992004-02-10 16:50:21 +0000302#include <stddef.h>
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000303
304#ifndef offsetof
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000305# define offsetof(type, member) ((size_t)(&((type *)0)->member))
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000306#endif
307
Neal Norwitz39d22e52002-11-02 19:55:21 +0000308#ifndef O_NONBLOCK
309# define O_NONBLOCK O_NDELAY
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000310#endif
311
Trent Micka708d6e2004-09-07 17:48:26 +0000312/* include Python's addrinfo.h unless it causes trouble */
313#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
314 /* Do not include addinfo.h on some newer IRIX versions.
315 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
316 * for example, but not by 6.5.10.
317 */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000318#elif defined(_MSC_VER) && _MSC_VER>1201
Trent Micka708d6e2004-09-07 17:48:26 +0000319 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
320 * EAI_* constants are defined in (the already included) ws2tcpip.h.
321 */
322#else
323# include "addrinfo.h"
324#endif
Jason Tishlerc246cb72004-08-09 13:25:59 +0000325
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000326#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +0000327#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000328int inet_pton(int af, const char *src, void *dst);
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000329const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000330#endif
Christian Heimesb6150692007-11-15 23:37:07 +0000331#endif
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000332
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000333#ifdef __APPLE__
334/* On OS X, getaddrinfo returns no error indication of lookup
335 failure, so we must use the emulation instead of the libinfo
336 implementation. Unfortunately, performing an autoconf test
337 for this bug would require DNS access for the machine performing
338 the configuration, which is not acceptable. Therefore, we
339 determine the bug just by checking for __APPLE__. If this bug
340 gets ever fixed, perhaps checking for sys/version.h would be
341 appropriate, which is 10/0 on the system with the bug. */
Jack Jansen84262fb2002-07-02 14:40:42 +0000342#ifndef HAVE_GETNAMEINFO
343/* This bug seems to be fixed in Jaguar. Ths easiest way I could
344 Find to check for Jaguar is that it has getnameinfo(), which
345 older releases don't have */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000346#undef HAVE_GETADDRINFO
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000347#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000348
349#ifdef HAVE_INET_ATON
350#define USE_INET_ATON_WEAKLINK
351#endif
352
Jack Jansen84262fb2002-07-02 14:40:42 +0000353#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000354
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000355/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000356#if !defined(HAVE_GETADDRINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000357/* avoid clashes with the C library definition of the symbol. */
358#define getaddrinfo fake_getaddrinfo
359#define gai_strerror fake_gai_strerror
360#define freeaddrinfo fake_freeaddrinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000361#include "getaddrinfo.c"
362#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000363#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000364#define getnameinfo fake_getnameinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000365#include "getnameinfo.c"
366#endif
367
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000368#ifdef MS_WINDOWS
369/* On Windows a socket is really a handle not an fd */
370static SOCKET
371dup_socket(SOCKET handle)
372{
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000373 WSAPROTOCOL_INFO info;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000374
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000375 if (WSADuplicateSocket(handle, GetCurrentProcessId(), &info))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000376 return INVALID_SOCKET;
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000377
378 return WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
379 FROM_PROTOCOL_INFO, &info, 0, 0);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000380}
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000381#define SOCKETCLOSE closesocket
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000382#else
383/* On Unix we can use dup to duplicate the file descriptor of a socket*/
384#define dup_socket(fd) dup(fd)
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000385#endif
386
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000387#ifdef MS_WIN32
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000388#define EAFNOSUPPORT WSAEAFNOSUPPORT
389#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000390#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000391
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000392#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000393#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000394#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000395#endif
396
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000397#ifndef SOCKETCLOSE
398#define SOCKETCLOSE close
399#endif
400
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000401#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000402#define USE_BLUETOOTH 1
403#if defined(__FreeBSD__)
404#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
405#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
Thomas Wouterscf297e42007-02-23 15:07:44 +0000406#define BTPROTO_HCI BLUETOOTH_PROTO_HCI
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000407#define SOL_HCI SOL_HCI_RAW
408#define HCI_FILTER SO_HCI_RAW_FILTER
Hye-Shik Chang81268602004-02-02 06:05:24 +0000409#define sockaddr_l2 sockaddr_l2cap
410#define sockaddr_rc sockaddr_rfcomm
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000411#define hci_dev hci_node
Hye-Shik Chang81268602004-02-02 06:05:24 +0000412#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
413#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000414#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000415#elif defined(__NetBSD__) || defined(__DragonFly__)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000416#define sockaddr_l2 sockaddr_bt
417#define sockaddr_rc sockaddr_bt
Thomas Wouterscf297e42007-02-23 15:07:44 +0000418#define sockaddr_hci sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000419#define sockaddr_sco sockaddr_bt
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000420#define SOL_HCI BTPROTO_HCI
421#define HCI_DATA_DIR SO_HCI_DIRECTION
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000422#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
423#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000424#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000425#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000426#else
Hye-Shik Chang81268602004-02-02 06:05:24 +0000427#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
428#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000429#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000430#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
431#endif
432#endif
433
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000434#ifdef __VMS
435/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
436#define SEGMENT_SIZE (32 * 1024 -1)
437#endif
438
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000439#define SAS2SA(x) ((struct sockaddr *)(x))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000440
Martin v. Löwise9416172003-05-03 10:12:45 +0000441/*
442 * Constants for getnameinfo()
443 */
444#if !defined(NI_MAXHOST)
445#define NI_MAXHOST 1025
446#endif
447#if !defined(NI_MAXSERV)
448#define NI_MAXSERV 32
449#endif
450
Guido van Rossum7d0a8262007-05-21 23:13:11 +0000451#ifndef INVALID_SOCKET /* MS defines this */
452#define INVALID_SOCKET (-1)
453#endif
454
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000455/* XXX There's a problem here: *static* functions are not supposed to have
456 a Py prefix (or use CapitalizedWords). Later... */
457
Guido van Rossum30a685f1991-06-27 15:51:29 +0000458/* Global variable holding the exception type for errors detected
459 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000460static PyObject *socket_error;
461static PyObject *socket_herror;
462static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000463static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000464
Tim Peters643a7fc2002-02-17 04:13:21 +0000465/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000466 The sock_type variable contains pointers to various functions,
467 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000468 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000469static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000470
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000471#if defined(HAVE_POLL_H)
472#include <poll.h>
473#elif defined(HAVE_SYS_POLL_H)
474#include <sys/poll.h>
475#endif
476
Nick Coghlan96fe56a2011-08-22 11:55:57 +1000477/* Largest value to try to store in a socklen_t (used when handling
478 ancillary data). POSIX requires socklen_t to hold at least
479 (2**31)-1 and recommends against storing larger values, but
480 socklen_t was originally int in the BSD interface, so to be on the
481 safe side we use the smaller of (2**31)-1 and INT_MAX. */
482#if INT_MAX > 0x7fffffff
483#define SOCKLEN_T_LIMIT 0x7fffffff
484#else
485#define SOCKLEN_T_LIMIT INT_MAX
486#endif
487
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000488#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
489/* Platform can select file descriptors beyond FD_SETSIZE */
490#define IS_SELECTABLE(s) 1
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000491#elif defined(HAVE_POLL)
492/* Instead of select(), we'll use poll() since poll() works on any fd. */
493#define IS_SELECTABLE(s) 1
494/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000495#else
496/* POSIX says selecting file descriptors beyond FD_SETSIZE
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000497 has undefined behaviour. If there's no timeout left, we don't have to
498 call select, so it's a safe, little white lie. */
499#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000500#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000501
502static PyObject*
503select_error(void)
504{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000505 PyErr_SetString(socket_error, "unable to select on socket");
506 return NULL;
Neal Norwitz082b2df2006-02-07 07:04:46 +0000507}
508
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000509#ifdef MS_WINDOWS
Antoine Pitrouc8f01962010-09-28 22:03:27 +0000510#ifndef WSAEAGAIN
511#define WSAEAGAIN WSAEWOULDBLOCK
512#endif
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000513#define CHECK_ERRNO(expected) \
514 (WSAGetLastError() == WSA ## expected)
515#else
516#define CHECK_ERRNO(expected) \
517 (errno == expected)
518#endif
519
Guido van Rossum30a685f1991-06-27 15:51:29 +0000520/* Convenience function to raise an error according to errno
521 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000522
Guido van Rossum73624e91994-10-10 17:59:00 +0000523static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000524set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000525{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000526#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000527 int err_no = WSAGetLastError();
528 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
529 recognizes the error codes used by both GetLastError() and
530 WSAGetLastError */
531 if (err_no)
532 return PyErr_SetExcFromWindowsErr(socket_error, err_no);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000533#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000534
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000535#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000536 if (sock_errno() != NO_ERROR) {
537 APIRET rc;
538 ULONG msglen;
539 char outbuf[100];
540 int myerrorcode = sock_errno();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000541
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000542 /* Retrieve socket-related error message from MPTN.MSG file */
543 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
544 myerrorcode - SOCBASEERR + 26,
545 "mptn.msg",
546 &msglen);
547 if (rc == NO_ERROR) {
548 PyObject *v;
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000550 /* OS/2 doesn't guarantee a terminator */
551 outbuf[msglen] = '\0';
552 if (strlen(outbuf) > 0) {
553 /* If non-empty msg, trim CRLF */
554 char *lastc = &outbuf[ strlen(outbuf)-1 ];
555 while (lastc > outbuf &&
556 isspace(Py_CHARMASK(*lastc))) {
557 /* Trim trailing whitespace (CRLF) */
558 *lastc-- = '\0';
559 }
560 }
561 v = Py_BuildValue("(is)", myerrorcode, outbuf);
562 if (v != NULL) {
563 PyErr_SetObject(socket_error, v);
564 Py_DECREF(v);
565 }
566 return NULL;
567 }
568 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000569#endif
570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000571 return PyErr_SetFromErrno(socket_error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000572}
573
Guido van Rossum30a685f1991-06-27 15:51:29 +0000574
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000575static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000576set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000577{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000578 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000579
580#ifdef HAVE_HSTRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000581 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000582#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000583 v = Py_BuildValue("(is)", h_error, "host not found");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000584#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000585 if (v != NULL) {
586 PyErr_SetObject(socket_herror, v);
587 Py_DECREF(v);
588 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000589
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000590 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000591}
592
593
594static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000595set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000596{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000597 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000598
Martin v. Löwis272cb402002-03-01 08:31:07 +0000599#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000600 /* EAI_SYSTEM is not available on Windows XP. */
601 if (error == EAI_SYSTEM)
602 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000603#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000604
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000605#ifdef HAVE_GAI_STRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000606 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000607#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000608 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000609#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000610 if (v != NULL) {
611 PyErr_SetObject(socket_gaierror, v);
612 Py_DECREF(v);
613 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000614
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000615 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000616}
617
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000618#ifdef __VMS
619/* Function to send in segments */
620static int
621sendsegmented(int sock_fd, char *buf, int len, int flags)
622{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000623 int n = 0;
624 int remaining = len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000625
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000626 while (remaining > 0) {
627 unsigned int segment;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000628
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000629 segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
630 n = send(sock_fd, buf, segment, flags);
631 if (n < 0) {
632 return n;
633 }
634 remaining -= segment;
635 buf += segment;
636 } /* end while */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000637
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000638 return len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000639}
640#endif
641
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000642/* Function to perform the setting of socket blocking mode
643 internally. block = (1 | 0). */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000644static int
645internal_setblocking(PySocketSockObject *s, int block)
646{
Guido van Rossum67f7a382002-06-06 21:08:16 +0000647#ifndef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000648 int delay_flag;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000649#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +0000650#ifdef SOCK_NONBLOCK
651 if (block)
652 s->sock_type &= (~SOCK_NONBLOCK);
653 else
654 s->sock_type |= SOCK_NONBLOCK;
655#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000656
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000657 Py_BEGIN_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000658#ifndef MS_WINDOWS
659#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000660 block = !block;
661 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000662#elif defined(__VMS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000663 block = !block;
664 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000665#else /* !PYOS_OS2 && !__VMS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000666 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
667 if (block)
668 delay_flag &= (~O_NONBLOCK);
669 else
670 delay_flag |= O_NONBLOCK;
671 fcntl(s->sock_fd, F_SETFL, delay_flag);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000672#endif /* !PYOS_OS2 */
673#else /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000674 block = !block;
675 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000676#endif /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000677 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000678
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000679 /* Since these don't return anything */
680 return 1;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000681}
682
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000683/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
Guido van Rossum11ba0942002-06-13 15:07:44 +0000684 The argument writing indicates the direction.
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000685 This does not raise an exception; we'll let our caller do that
686 after they've reacquired the interpreter lock.
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000687 Returns 1 on timeout, -1 on error, 0 otherwise. */
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000688static int
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000689internal_select_ex(PySocketSockObject *s, int writing, double interval)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000690{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000691 int n;
Guido van Rossum11ba0942002-06-13 15:07:44 +0000692
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000693 /* Nothing to do unless we're in timeout mode (not non-blocking) */
694 if (s->sock_timeout <= 0.0)
695 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000696
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000697 /* Guard against closed socket */
698 if (s->sock_fd < 0)
699 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000700
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000701 /* Handling this condition here simplifies the select loops */
702 if (interval < 0.0)
703 return 1;
704
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000705 /* Prefer poll, if available, since you can poll() any fd
706 * which can't be done with select(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000707#ifdef HAVE_POLL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000708 {
709 struct pollfd pollfd;
710 int timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000711
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000712 pollfd.fd = s->sock_fd;
713 pollfd.events = writing ? POLLOUT : POLLIN;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000714
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000715 /* s->sock_timeout is in seconds, timeout in ms */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000716 timeout = (int)(interval * 1000 + 0.5);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000717 n = poll(&pollfd, 1, timeout);
718 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000719#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000720 {
721 /* Construct the arguments to select */
722 fd_set fds;
723 struct timeval tv;
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000724 tv.tv_sec = (int)interval;
725 tv.tv_usec = (int)((interval - tv.tv_sec) * 1e6);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000726 FD_ZERO(&fds);
727 FD_SET(s->sock_fd, &fds);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000728
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000729 /* See if the socket is ready */
730 if (writing)
Antoine Pitrou19467d22010-08-17 19:33:30 +0000731 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
732 NULL, &fds, NULL, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000733 else
Antoine Pitrou19467d22010-08-17 19:33:30 +0000734 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
735 &fds, NULL, NULL, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000736 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000737#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000738
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000739 if (n < 0)
740 return -1;
741 if (n == 0)
742 return 1;
743 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000744}
745
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000746static int
747internal_select(PySocketSockObject *s, int writing)
748{
749 return internal_select_ex(s, writing, s->sock_timeout);
750}
751
752/*
753 Two macros for automatic retry of select() in case of false positives
754 (for example, select() could indicate a socket is ready for reading
755 but the data then discarded by the OS because of a wrong checksum).
756 Here is an example of use:
757
758 BEGIN_SELECT_LOOP(s)
759 Py_BEGIN_ALLOW_THREADS
760 timeout = internal_select_ex(s, 0, interval);
761 if (!timeout)
762 outlen = recv(s->sock_fd, cbuf, len, flags);
763 Py_END_ALLOW_THREADS
764 if (timeout == 1) {
765 PyErr_SetString(socket_timeout, "timed out");
766 return -1;
767 }
768 END_SELECT_LOOP(s)
769*/
770
771#define BEGIN_SELECT_LOOP(s) \
772 { \
773 _PyTime_timeval now, deadline = {0, 0}; \
774 double interval = s->sock_timeout; \
775 int has_timeout = s->sock_timeout > 0.0; \
776 if (has_timeout) { \
777 _PyTime_gettimeofday(&now); \
778 deadline = now; \
779 _PyTime_ADD_SECONDS(deadline, s->sock_timeout); \
780 } \
781 while (1) { \
782 errno = 0; \
783
784#define END_SELECT_LOOP(s) \
785 if (!has_timeout || \
786 (!CHECK_ERRNO(EWOULDBLOCK) && !CHECK_ERRNO(EAGAIN))) \
787 break; \
788 _PyTime_gettimeofday(&now); \
789 interval = _PyTime_INTERVAL(now, deadline); \
790 } \
791 } \
792
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000793/* Initialize a new socket object. */
794
Tim Petersa12b4cf2002-07-18 22:38:44 +0000795static double defaulttimeout = -1.0; /* Default timeout for new sockets */
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000796
Martin v. Löwis1a214512008-06-11 05:26:20 +0000797static void
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000798init_sockobject(PySocketSockObject *s,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000799 SOCKET_T fd, int family, int type, int proto)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000800{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000801 s->sock_fd = fd;
802 s->sock_family = family;
803 s->sock_type = type;
804 s->sock_proto = proto;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000805
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000806 s->errorhandler = &set_error;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000807#ifdef SOCK_NONBLOCK
808 if (type & SOCK_NONBLOCK)
809 s->sock_timeout = 0.0;
810 else
811#endif
812 {
813 s->sock_timeout = defaulttimeout;
814 if (defaulttimeout >= 0.0)
815 internal_setblocking(s, 0);
816 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000817
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000818}
819
820
Guido van Rossum30a685f1991-06-27 15:51:29 +0000821/* Create a new socket object.
822 This just creates the object and initializes it.
823 If the creation fails, return NULL and set an exception (implicit
824 in NEWOBJ()). */
825
Guido van Rossum73624e91994-10-10 17:59:00 +0000826static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000827new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000828{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000829 PySocketSockObject *s;
830 s = (PySocketSockObject *)
831 PyType_GenericNew(&sock_type, NULL, NULL);
832 if (s != NULL)
833 init_sockobject(s, fd, family, type, proto);
834 return s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000835}
836
Guido van Rossum30a685f1991-06-27 15:51:29 +0000837
Guido van Rossum48a680c2001-03-02 06:34:14 +0000838/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000839 thread to be in gethostbyname or getaddrinfo */
840#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
841PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000842#endif
843
844
Guido van Rossum30a685f1991-06-27 15:51:29 +0000845/* Convert a string specifying a host name or one of a few symbolic
846 names to a numeric IP address. This usually calls gethostbyname()
847 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000848 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000849 an error occurred; then an exception is raised. */
850
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000851static int
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000852setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000853{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000854 struct addrinfo hints, *res;
855 int error;
856 int d1, d2, d3, d4;
857 char ch;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000858
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000859 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
860 if (name[0] == '\0') {
861 int siz;
862 memset(&hints, 0, sizeof(hints));
863 hints.ai_family = af;
864 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
865 hints.ai_flags = AI_PASSIVE;
866 Py_BEGIN_ALLOW_THREADS
867 ACQUIRE_GETADDRINFO_LOCK
868 error = getaddrinfo(NULL, "0", &hints, &res);
869 Py_END_ALLOW_THREADS
870 /* We assume that those thread-unsafe getaddrinfo() versions
871 *are* safe regarding their return value, ie. that a
872 subsequent call to getaddrinfo() does not destroy the
873 outcome of the first call. */
874 RELEASE_GETADDRINFO_LOCK
875 if (error) {
876 set_gaierror(error);
877 return -1;
878 }
879 switch (res->ai_family) {
880 case AF_INET:
881 siz = 4;
882 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000883#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000884 case AF_INET6:
885 siz = 16;
886 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000887#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000888 default:
889 freeaddrinfo(res);
890 PyErr_SetString(socket_error,
891 "unsupported address family");
892 return -1;
893 }
894 if (res->ai_next) {
895 freeaddrinfo(res);
896 PyErr_SetString(socket_error,
897 "wildcard resolved to multiple address");
898 return -1;
899 }
900 if (res->ai_addrlen < addr_ret_size)
901 addr_ret_size = res->ai_addrlen;
902 memcpy(addr_ret, res->ai_addr, addr_ret_size);
903 freeaddrinfo(res);
904 return siz;
905 }
906 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
907 struct sockaddr_in *sin;
908 if (af != AF_INET && af != AF_UNSPEC) {
909 PyErr_SetString(socket_error,
910 "address family mismatched");
911 return -1;
912 }
913 sin = (struct sockaddr_in *)addr_ret;
914 memset((void *) sin, '\0', sizeof(*sin));
915 sin->sin_family = AF_INET;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000916#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000917 sin->sin_len = sizeof(*sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000918#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000919 sin->sin_addr.s_addr = INADDR_BROADCAST;
920 return sizeof(sin->sin_addr);
921 }
922 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
923 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
924 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
925 struct sockaddr_in *sin;
926 sin = (struct sockaddr_in *)addr_ret;
927 sin->sin_addr.s_addr = htonl(
928 ((long) d1 << 24) | ((long) d2 << 16) |
929 ((long) d3 << 8) | ((long) d4 << 0));
930 sin->sin_family = AF_INET;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000931#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000932 sin->sin_len = sizeof(*sin);
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000933#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000934 return 4;
935 }
936 memset(&hints, 0, sizeof(hints));
937 hints.ai_family = af;
938 Py_BEGIN_ALLOW_THREADS
939 ACQUIRE_GETADDRINFO_LOCK
940 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000941#if defined(__digital__) && defined(__unix__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000942 if (error == EAI_NONAME && af == AF_UNSPEC) {
943 /* On Tru64 V5.1, numeric-to-addr conversion fails
944 if no address family is given. Assume IPv4 for now.*/
945 hints.ai_family = AF_INET;
946 error = getaddrinfo(name, NULL, &hints, &res);
947 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000948#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000949 Py_END_ALLOW_THREADS
950 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
951 if (error) {
952 set_gaierror(error);
953 return -1;
954 }
955 if (res->ai_addrlen < addr_ret_size)
956 addr_ret_size = res->ai_addrlen;
957 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
958 freeaddrinfo(res);
959 switch (addr_ret->sa_family) {
960 case AF_INET:
961 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000962#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000963 case AF_INET6:
964 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000965#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000966 default:
967 PyErr_SetString(socket_error, "unknown address family");
968 return -1;
969 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000970}
971
Guido van Rossum30a685f1991-06-27 15:51:29 +0000972
Guido van Rossum30a685f1991-06-27 15:51:29 +0000973/* Create a string object representing an IP address.
974 This is always a string of the form 'dd.dd.dd.dd' (with variable
975 size numbers). */
976
Guido van Rossum73624e91994-10-10 17:59:00 +0000977static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000978makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000979{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000980 char buf[NI_MAXHOST];
981 int error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000982
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000983 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
984 NI_NUMERICHOST);
985 if (error) {
986 set_gaierror(error);
987 return NULL;
988 }
989 return PyUnicode_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000990}
991
992
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000993#ifdef USE_BLUETOOTH
994/* Convert a string representation of a Bluetooth address into a numeric
995 address. Returns the length (6), or raises an exception and returns -1 if
996 an error occurred. */
997
998static int
999setbdaddr(char *name, bdaddr_t *bdaddr)
1000{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001001 unsigned int b0, b1, b2, b3, b4, b5;
1002 char ch;
1003 int n;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001004
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001005 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
1006 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
1007 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
1008 bdaddr->b[0] = b0;
1009 bdaddr->b[1] = b1;
1010 bdaddr->b[2] = b2;
1011 bdaddr->b[3] = b3;
1012 bdaddr->b[4] = b4;
1013 bdaddr->b[5] = b5;
1014 return 6;
1015 } else {
1016 PyErr_SetString(socket_error, "bad bluetooth address");
1017 return -1;
1018 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001019}
1020
1021/* Create a string representation of the Bluetooth address. This is always a
1022 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
1023 value (zero padded if necessary). */
1024
1025static PyObject *
1026makebdaddr(bdaddr_t *bdaddr)
1027{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001028 char buf[(6 * 2) + 5 + 1];
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001029
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001030 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1031 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1032 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1033 return PyUnicode_FromString(buf);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001034}
1035#endif
1036
1037
Guido van Rossum30a685f1991-06-27 15:51:29 +00001038/* Create an object representing the given socket address,
1039 suitable for passing it back to bind(), connect() etc.
1040 The family field of the sockaddr structure is inspected
1041 to determine what kind of address it really is. */
1042
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001043/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001044static PyObject *
Antoine Pitrou19467d22010-08-17 19:33:30 +00001045makesockaddr(SOCKET_T sockfd, struct sockaddr *addr, size_t addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001047 if (addrlen == 0) {
1048 /* No address -- may be recvfrom() from known socket */
1049 Py_INCREF(Py_None);
1050 return Py_None;
1051 }
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001052
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001053 switch (addr->sa_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001054
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001055 case AF_INET:
1056 {
1057 struct sockaddr_in *a;
1058 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1059 PyObject *ret = NULL;
1060 if (addrobj) {
1061 a = (struct sockaddr_in *)addr;
1062 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1063 Py_DECREF(addrobj);
1064 }
1065 return ret;
1066 }
Guido van Rossum30a685f1991-06-27 15:51:29 +00001067
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001068#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001069 case AF_UNIX:
1070 {
1071 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001072#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001073 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
1074 addrlen -= offsetof(struct sockaddr_un, sun_path);
1075 return PyBytes_FromStringAndSize(a->sun_path, addrlen);
1076 }
1077 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001078#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001079 {
1080 /* regular NULL-terminated string */
1081 return PyUnicode_FromString(a->sun_path);
1082 }
1083 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001084#endif /* AF_UNIX */
1085
Martin v. Löwis11017b12006-01-14 18:12:57 +00001086#if defined(AF_NETLINK)
1087 case AF_NETLINK:
1088 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001089 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1090 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +00001091 }
1092#endif /* AF_NETLINK */
1093
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001094#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001095 case AF_INET6:
1096 {
1097 struct sockaddr_in6 *a;
1098 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1099 PyObject *ret = NULL;
1100 if (addrobj) {
1101 a = (struct sockaddr_in6 *)addr;
1102 ret = Py_BuildValue("Oiii",
1103 addrobj,
1104 ntohs(a->sin6_port),
1105 a->sin6_flowinfo,
1106 a->sin6_scope_id);
1107 Py_DECREF(addrobj);
1108 }
1109 return ret;
1110 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001111#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001112
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001113#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001114 case AF_BLUETOOTH:
1115 switch (proto) {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001116
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001117 case BTPROTO_L2CAP:
1118 {
1119 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1120 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1121 PyObject *ret = NULL;
1122 if (addrobj) {
1123 ret = Py_BuildValue("Oi",
1124 addrobj,
1125 _BT_L2_MEMB(a, psm));
1126 Py_DECREF(addrobj);
1127 }
1128 return ret;
1129 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001130
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001131 case BTPROTO_RFCOMM:
1132 {
1133 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1134 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1135 PyObject *ret = NULL;
1136 if (addrobj) {
1137 ret = Py_BuildValue("Oi",
1138 addrobj,
1139 _BT_RC_MEMB(a, channel));
1140 Py_DECREF(addrobj);
1141 }
1142 return ret;
1143 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001144
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001145 case BTPROTO_HCI:
1146 {
1147 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001148#if defined(__NetBSD__) || defined(__DragonFly__)
1149 return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));
1150#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001151 PyObject *ret = NULL;
1152 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1153 return ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001154#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001155 }
Thomas Wouterscf297e42007-02-23 15:07:44 +00001156
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001157#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001158 case BTPROTO_SCO:
1159 {
1160 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1161 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1162 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001163#endif
1164
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001165 default:
1166 PyErr_SetString(PyExc_ValueError,
1167 "Unknown Bluetooth protocol");
1168 return NULL;
1169 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001170#endif
1171
Antoine Pitroub156a462010-10-27 20:13:57 +00001172#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001173 case AF_PACKET:
1174 {
1175 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1176 char *ifname = "";
1177 struct ifreq ifr;
1178 /* need to look up interface name give index */
1179 if (a->sll_ifindex) {
1180 ifr.ifr_ifindex = a->sll_ifindex;
1181 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1182 ifname = ifr.ifr_name;
1183 }
1184 return Py_BuildValue("shbhy#",
1185 ifname,
1186 ntohs(a->sll_protocol),
1187 a->sll_pkttype,
1188 a->sll_hatype,
1189 a->sll_addr,
1190 a->sll_halen);
1191 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001192#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001193
Christian Heimes043d6f62008-01-07 17:19:16 +00001194#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001195 case AF_TIPC:
1196 {
1197 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1198 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1199 return Py_BuildValue("IIIII",
1200 a->addrtype,
1201 a->addr.nameseq.type,
1202 a->addr.nameseq.lower,
1203 a->addr.nameseq.upper,
1204 a->scope);
1205 } else if (a->addrtype == TIPC_ADDR_NAME) {
1206 return Py_BuildValue("IIIII",
1207 a->addrtype,
1208 a->addr.name.name.type,
1209 a->addr.name.name.instance,
1210 a->addr.name.name.instance,
1211 a->scope);
1212 } else if (a->addrtype == TIPC_ADDR_ID) {
1213 return Py_BuildValue("IIIII",
1214 a->addrtype,
1215 a->addr.id.node,
1216 a->addr.id.ref,
1217 0,
1218 a->scope);
1219 } else {
1220 PyErr_SetString(PyExc_ValueError,
1221 "Invalid address type");
1222 return NULL;
1223 }
1224 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001225#endif
1226
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001227 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001228
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001229 default:
1230 /* If we don't know the address family, don't raise an
1231 exception -- return it as an (int, bytes) tuple. */
1232 return Py_BuildValue("iy#",
1233 addr->sa_family,
1234 addr->sa_data,
1235 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001236
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001237 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001238}
1239
Guido van Rossum30a685f1991-06-27 15:51:29 +00001240
1241/* Parse a socket address argument according to the socket object's
1242 address family. Return 1 if the address was in the proper format,
1243 0 of not. The address is returned through addr_ret, its length
1244 through len_ret. */
1245
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001246static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001247getsockaddrarg(PySocketSockObject *s, PyObject *args,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001248 struct sockaddr *addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001249{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001250 switch (s->sock_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001251
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001252#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001253 case AF_UNIX:
1254 {
1255 struct sockaddr_un* addr;
1256 char *path;
1257 int len;
1258 if (!PyArg_Parse(args, "s#", &path, &len))
1259 return 0;
Thomas Wouters89f507f2006-12-13 04:49:30 +00001260
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001261 addr = (struct sockaddr_un*)addr_ret;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001262#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 if (len > 0 && path[0] == 0) {
1264 /* Linux abstract namespace extension */
1265 if (len > sizeof addr->sun_path) {
1266 PyErr_SetString(socket_error,
1267 "AF_UNIX path too long");
1268 return 0;
1269 }
1270 }
1271 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001272#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001273 {
1274 /* regular NULL-terminated string */
1275 if (len >= sizeof addr->sun_path) {
1276 PyErr_SetString(socket_error,
1277 "AF_UNIX path too long");
1278 return 0;
1279 }
1280 addr->sun_path[len] = 0;
1281 }
1282 addr->sun_family = s->sock_family;
1283 memcpy(addr->sun_path, path, len);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001284#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001285 *len_ret = sizeof(*addr);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001286#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 *len_ret = len + offsetof(struct sockaddr_un, sun_path);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001288#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001289 return 1;
1290 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001291#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001292
Martin v. Löwis11017b12006-01-14 18:12:57 +00001293#if defined(AF_NETLINK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001294 case AF_NETLINK:
1295 {
1296 struct sockaddr_nl* addr;
1297 int pid, groups;
1298 addr = (struct sockaddr_nl *)addr_ret;
1299 if (!PyTuple_Check(args)) {
1300 PyErr_Format(
1301 PyExc_TypeError,
1302 "getsockaddrarg: "
1303 "AF_NETLINK address must be tuple, not %.500s",
1304 Py_TYPE(args)->tp_name);
1305 return 0;
1306 }
1307 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1308 return 0;
1309 addr->nl_family = AF_NETLINK;
1310 addr->nl_pid = pid;
1311 addr->nl_groups = groups;
1312 *len_ret = sizeof(*addr);
1313 return 1;
1314 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001315#endif
1316
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001317 case AF_INET:
1318 {
1319 struct sockaddr_in* addr;
1320 char *host;
1321 int port, result;
1322 if (!PyTuple_Check(args)) {
1323 PyErr_Format(
1324 PyExc_TypeError,
1325 "getsockaddrarg: "
1326 "AF_INET address must be tuple, not %.500s",
1327 Py_TYPE(args)->tp_name);
1328 return 0;
1329 }
1330 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1331 "idna", &host, &port))
1332 return 0;
1333 addr=(struct sockaddr_in*)addr_ret;
1334 result = setipaddr(host, (struct sockaddr *)addr,
1335 sizeof(*addr), AF_INET);
1336 PyMem_Free(host);
1337 if (result < 0)
1338 return 0;
1339 if (port < 0 || port > 0xffff) {
1340 PyErr_SetString(
1341 PyExc_OverflowError,
1342 "getsockaddrarg: port must be 0-65535.");
1343 return 0;
1344 }
1345 addr->sin_family = AF_INET;
1346 addr->sin_port = htons((short)port);
1347 *len_ret = sizeof *addr;
1348 return 1;
1349 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001350
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001351#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001352 case AF_INET6:
1353 {
1354 struct sockaddr_in6* addr;
1355 char *host;
1356 int port, flowinfo, scope_id, result;
1357 flowinfo = scope_id = 0;
1358 if (!PyTuple_Check(args)) {
1359 PyErr_Format(
1360 PyExc_TypeError,
1361 "getsockaddrarg: "
1362 "AF_INET6 address must be tuple, not %.500s",
1363 Py_TYPE(args)->tp_name);
1364 return 0;
1365 }
1366 if (!PyArg_ParseTuple(args, "eti|ii",
1367 "idna", &host, &port, &flowinfo,
1368 &scope_id)) {
1369 return 0;
1370 }
1371 addr = (struct sockaddr_in6*)addr_ret;
1372 result = setipaddr(host, (struct sockaddr *)addr,
1373 sizeof(*addr), AF_INET6);
1374 PyMem_Free(host);
1375 if (result < 0)
1376 return 0;
1377 if (port < 0 || port > 0xffff) {
1378 PyErr_SetString(
1379 PyExc_OverflowError,
1380 "getsockaddrarg: port must be 0-65535.");
1381 return 0;
1382 }
1383 addr->sin6_family = s->sock_family;
1384 addr->sin6_port = htons((short)port);
1385 addr->sin6_flowinfo = flowinfo;
1386 addr->sin6_scope_id = scope_id;
1387 *len_ret = sizeof *addr;
1388 return 1;
1389 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001390#endif
1391
Hye-Shik Chang81268602004-02-02 06:05:24 +00001392#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001393 case AF_BLUETOOTH:
1394 {
1395 switch (s->sock_proto) {
1396 case BTPROTO_L2CAP:
1397 {
1398 struct sockaddr_l2 *addr;
1399 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001400
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001401 addr = (struct sockaddr_l2 *)addr_ret;
1402 memset(addr, 0, sizeof(struct sockaddr_l2));
1403 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1404 if (!PyArg_ParseTuple(args, "si", &straddr,
1405 &_BT_L2_MEMB(addr, psm))) {
1406 PyErr_SetString(socket_error, "getsockaddrarg: "
1407 "wrong format");
1408 return 0;
1409 }
1410 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1411 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001412
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001413 *len_ret = sizeof *addr;
1414 return 1;
1415 }
1416 case BTPROTO_RFCOMM:
1417 {
1418 struct sockaddr_rc *addr;
1419 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001421 addr = (struct sockaddr_rc *)addr_ret;
1422 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1423 if (!PyArg_ParseTuple(args, "si", &straddr,
1424 &_BT_RC_MEMB(addr, channel))) {
1425 PyErr_SetString(socket_error, "getsockaddrarg: "
1426 "wrong format");
1427 return 0;
1428 }
1429 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1430 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001431
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001432 *len_ret = sizeof *addr;
1433 return 1;
1434 }
1435 case BTPROTO_HCI:
1436 {
1437 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001438#if defined(__NetBSD__) || defined(__DragonFly__)
Alexander Belopolskye239d232010-12-08 23:31:48 +00001439 char *straddr = PyBytes_AS_STRING(args);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001440
Alexander Belopolskye239d232010-12-08 23:31:48 +00001441 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001442 if (straddr == NULL) {
1443 PyErr_SetString(socket_error, "getsockaddrarg: "
1444 "wrong format");
1445 return 0;
1446 }
1447 if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)
1448 return 0;
1449#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001450 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1451 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
1452 PyErr_SetString(socket_error, "getsockaddrarg: "
1453 "wrong format");
1454 return 0;
1455 }
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001456#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001457 *len_ret = sizeof *addr;
1458 return 1;
1459 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001460#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001461 case BTPROTO_SCO:
1462 {
1463 struct sockaddr_sco *addr;
1464 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001465
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001466 addr = (struct sockaddr_sco *)addr_ret;
1467 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1468 if (!PyBytes_Check(args)) {
1469 PyErr_SetString(socket_error, "getsockaddrarg: "
1470 "wrong format");
1471 return 0;
1472 }
1473 straddr = PyBytes_AS_STRING(args);
1474 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1475 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001476
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001477 *len_ret = sizeof *addr;
1478 return 1;
1479 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001480#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001481 default:
1482 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1483 return 0;
1484 }
1485 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001486#endif
1487
Antoine Pitroub156a462010-10-27 20:13:57 +00001488#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001489 case AF_PACKET:
1490 {
1491 struct sockaddr_ll* addr;
1492 struct ifreq ifr;
1493 char *interfaceName;
1494 int protoNumber;
1495 int hatype = 0;
1496 int pkttype = 0;
1497 char *haddr = NULL;
1498 unsigned int halen = 0;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001499
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001500 if (!PyTuple_Check(args)) {
1501 PyErr_Format(
1502 PyExc_TypeError,
1503 "getsockaddrarg: "
1504 "AF_PACKET address must be tuple, not %.500s",
1505 Py_TYPE(args)->tp_name);
1506 return 0;
1507 }
1508 if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
1509 &protoNumber, &pkttype, &hatype,
1510 &haddr, &halen))
1511 return 0;
1512 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1513 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1514 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1515 s->errorhandler();
1516 return 0;
1517 }
1518 if (halen > 8) {
1519 PyErr_SetString(PyExc_ValueError,
1520 "Hardware address must be 8 bytes or less");
1521 return 0;
1522 }
1523 if (protoNumber < 0 || protoNumber > 0xffff) {
1524 PyErr_SetString(
1525 PyExc_OverflowError,
1526 "getsockaddrarg: protoNumber must be 0-65535.");
1527 return 0;
1528 }
1529 addr = (struct sockaddr_ll*)addr_ret;
1530 addr->sll_family = AF_PACKET;
1531 addr->sll_protocol = htons((short)protoNumber);
1532 addr->sll_ifindex = ifr.ifr_ifindex;
1533 addr->sll_pkttype = pkttype;
1534 addr->sll_hatype = hatype;
1535 if (halen != 0) {
1536 memcpy(&addr->sll_addr, haddr, halen);
1537 }
1538 addr->sll_halen = halen;
1539 *len_ret = sizeof *addr;
1540 return 1;
1541 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001542#endif
1543
Christian Heimes043d6f62008-01-07 17:19:16 +00001544#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001545 case AF_TIPC:
1546 {
1547 unsigned int atype, v1, v2, v3;
1548 unsigned int scope = TIPC_CLUSTER_SCOPE;
1549 struct sockaddr_tipc *addr;
Christian Heimes043d6f62008-01-07 17:19:16 +00001550
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001551 if (!PyTuple_Check(args)) {
1552 PyErr_Format(
1553 PyExc_TypeError,
1554 "getsockaddrarg: "
1555 "AF_TIPC address must be tuple, not %.500s",
1556 Py_TYPE(args)->tp_name);
1557 return 0;
1558 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001560 if (!PyArg_ParseTuple(args,
1561 "IIII|I;Invalid TIPC address format",
1562 &atype, &v1, &v2, &v3, &scope))
1563 return 0;
Christian Heimes043d6f62008-01-07 17:19:16 +00001564
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001565 addr = (struct sockaddr_tipc *) addr_ret;
1566 memset(addr, 0, sizeof(struct sockaddr_tipc));
Christian Heimes043d6f62008-01-07 17:19:16 +00001567
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001568 addr->family = AF_TIPC;
1569 addr->scope = scope;
1570 addr->addrtype = atype;
Christian Heimes043d6f62008-01-07 17:19:16 +00001571
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001572 if (atype == TIPC_ADDR_NAMESEQ) {
1573 addr->addr.nameseq.type = v1;
1574 addr->addr.nameseq.lower = v2;
1575 addr->addr.nameseq.upper = v3;
1576 } else if (atype == TIPC_ADDR_NAME) {
1577 addr->addr.name.name.type = v1;
1578 addr->addr.name.name.instance = v2;
1579 } else if (atype == TIPC_ADDR_ID) {
1580 addr->addr.id.node = v1;
1581 addr->addr.id.ref = v2;
1582 } else {
1583 /* Shouldn't happen */
1584 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1585 return 0;
1586 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001587
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001588 *len_ret = sizeof(*addr);
Christian Heimes043d6f62008-01-07 17:19:16 +00001589
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001590 return 1;
1591 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001592#endif
1593
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001594 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001595
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001596 default:
1597 PyErr_SetString(socket_error, "getsockaddrarg: bad family");
1598 return 0;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001600 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001601}
1602
Guido van Rossum30a685f1991-06-27 15:51:29 +00001603
Guido van Rossum48a680c2001-03-02 06:34:14 +00001604/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00001605 Return 1 if the family is known, 0 otherwise. The length is returned
1606 through len_ret. */
1607
1608static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00001609getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001610{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001611 switch (s->sock_family) {
Guido van Rossum710e1df1992-06-12 10:39:36 +00001612
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001613#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001614 case AF_UNIX:
1615 {
1616 *len_ret = sizeof (struct sockaddr_un);
1617 return 1;
1618 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001619#endif /* AF_UNIX */
Martin v. Löwis11017b12006-01-14 18:12:57 +00001620#if defined(AF_NETLINK)
1621 case AF_NETLINK:
1622 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001623 *len_ret = sizeof (struct sockaddr_nl);
1624 return 1;
Martin v. Löwis11017b12006-01-14 18:12:57 +00001625 }
1626#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00001627
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001628 case AF_INET:
1629 {
1630 *len_ret = sizeof (struct sockaddr_in);
1631 return 1;
1632 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001633
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001634#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001635 case AF_INET6:
1636 {
1637 *len_ret = sizeof (struct sockaddr_in6);
1638 return 1;
1639 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001640#endif
1641
Hye-Shik Chang81268602004-02-02 06:05:24 +00001642#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001643 case AF_BLUETOOTH:
1644 {
1645 switch(s->sock_proto)
1646 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001647
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001648 case BTPROTO_L2CAP:
1649 *len_ret = sizeof (struct sockaddr_l2);
1650 return 1;
1651 case BTPROTO_RFCOMM:
1652 *len_ret = sizeof (struct sockaddr_rc);
1653 return 1;
1654 case BTPROTO_HCI:
1655 *len_ret = sizeof (struct sockaddr_hci);
1656 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001657#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001658 case BTPROTO_SCO:
1659 *len_ret = sizeof (struct sockaddr_sco);
1660 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001661#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001662 default:
1663 PyErr_SetString(socket_error, "getsockaddrlen: "
1664 "unknown BT protocol");
1665 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001667 }
1668 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001669#endif
1670
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001671#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001672 case AF_PACKET:
1673 {
1674 *len_ret = sizeof (struct sockaddr_ll);
1675 return 1;
1676 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001677#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001678
Christian Heimes043d6f62008-01-07 17:19:16 +00001679#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001680 case AF_TIPC:
1681 {
1682 *len_ret = sizeof (struct sockaddr_tipc);
1683 return 1;
1684 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001685#endif
1686
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001687 /* More cases here... */
Guido van Rossum710e1df1992-06-12 10:39:36 +00001688
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001689 default:
1690 PyErr_SetString(socket_error, "getsockaddrlen: bad family");
1691 return 0;
Guido van Rossum710e1df1992-06-12 10:39:36 +00001692
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001694}
1695
1696
Nick Coghlan96fe56a2011-08-22 11:55:57 +10001697/* Support functions for the sendmsg() and recvmsg[_into]() methods.
1698 Currently, these methods are only compiled if the RFC 2292/3542
1699 CMSG_LEN() macro is available. Older systems seem to have used
1700 sizeof(struct cmsghdr) + (length) where CMSG_LEN() is used now, so
1701 it may be possible to define CMSG_LEN() that way if it's not
1702 provided. Some architectures might need extra padding after the
1703 cmsghdr, however, and CMSG_LEN() would have to take account of
1704 this. */
1705#ifdef CMSG_LEN
1706/* If length is in range, set *result to CMSG_LEN(length) and return
1707 true; otherwise, return false. */
1708static int
1709get_CMSG_LEN(size_t length, size_t *result)
1710{
1711 size_t tmp;
1712
1713 if (length > (SOCKLEN_T_LIMIT - CMSG_LEN(0)))
1714 return 0;
1715 tmp = CMSG_LEN(length);
1716 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
1717 return 0;
1718 *result = tmp;
1719 return 1;
1720}
1721
1722#ifdef CMSG_SPACE
1723/* If length is in range, set *result to CMSG_SPACE(length) and return
1724 true; otherwise, return false. */
1725static int
1726get_CMSG_SPACE(size_t length, size_t *result)
1727{
1728 size_t tmp;
1729
1730 /* Use CMSG_SPACE(1) here in order to take account of the padding
1731 necessary before *and* after the data. */
1732 if (length > (SOCKLEN_T_LIMIT - CMSG_SPACE(1)))
1733 return 0;
1734 tmp = CMSG_SPACE(length);
1735 if (tmp > SOCKLEN_T_LIMIT || tmp < length)
1736 return 0;
1737 *result = tmp;
1738 return 1;
1739}
1740#endif
1741
1742/* Return true iff msg->msg_controllen is valid, cmsgh is a valid
1743 pointer in msg->msg_control with at least "space" bytes after it,
1744 and its cmsg_len member inside the buffer. */
1745static int
1746cmsg_min_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t space)
1747{
1748 size_t cmsg_offset;
1749 static const size_t cmsg_len_end = (offsetof(struct cmsghdr, cmsg_len) +
1750 sizeof(cmsgh->cmsg_len));
1751
Charles-François Natalib09f25e2011-08-24 20:07:54 +02001752 if (cmsgh == NULL || msg->msg_control == NULL)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10001753 return 0;
1754 if (space < cmsg_len_end)
1755 space = cmsg_len_end;
1756 cmsg_offset = (char *)cmsgh - (char *)msg->msg_control;
1757 return (cmsg_offset <= (size_t)-1 - space &&
1758 cmsg_offset + space <= msg->msg_controllen);
1759}
1760
1761/* If pointer CMSG_DATA(cmsgh) is in buffer msg->msg_control, set
1762 *space to number of bytes following it in the buffer and return
1763 true; otherwise, return false. Assumes cmsgh, msg->msg_control and
1764 msg->msg_controllen are valid. */
1765static int
1766get_cmsg_data_space(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *space)
1767{
1768 size_t data_offset;
1769 char *data_ptr;
1770
1771 if ((data_ptr = (char *)CMSG_DATA(cmsgh)) == NULL)
1772 return 0;
1773 data_offset = data_ptr - (char *)msg->msg_control;
1774 if (data_offset > msg->msg_controllen)
1775 return 0;
1776 *space = msg->msg_controllen - data_offset;
1777 return 1;
1778}
1779
1780/* If cmsgh is invalid or not contained in the buffer pointed to by
1781 msg->msg_control, return -1. If cmsgh is valid and its associated
1782 data is entirely contained in the buffer, set *data_len to the
1783 length of the associated data and return 0. If only part of the
1784 associated data is contained in the buffer but cmsgh is otherwise
1785 valid, set *data_len to the length contained in the buffer and
1786 return 1. */
1787static int
1788get_cmsg_data_len(struct msghdr *msg, struct cmsghdr *cmsgh, size_t *data_len)
1789{
1790 size_t space, cmsg_data_len;
1791
1792 if (!cmsg_min_space(msg, cmsgh, CMSG_LEN(0)) ||
1793 cmsgh->cmsg_len < CMSG_LEN(0))
1794 return -1;
1795 cmsg_data_len = cmsgh->cmsg_len - CMSG_LEN(0);
1796 if (!get_cmsg_data_space(msg, cmsgh, &space))
1797 return -1;
1798 if (space >= cmsg_data_len) {
1799 *data_len = cmsg_data_len;
1800 return 0;
1801 }
1802 *data_len = space;
1803 return 1;
1804}
1805#endif /* CMSG_LEN */
1806
1807
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001808/* s._accept() -> (fd, address) */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001809
Guido van Rossum73624e91994-10-10 17:59:00 +00001810static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001811sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001812{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001813 sock_addr_t addrbuf;
1814 SOCKET_T newfd = INVALID_SOCKET;
1815 socklen_t addrlen;
1816 PyObject *sock = NULL;
1817 PyObject *addr = NULL;
1818 PyObject *res = NULL;
1819 int timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001820 if (!getsockaddrlen(s, &addrlen))
1821 return NULL;
1822 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001823
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001824 if (!IS_SELECTABLE(s))
1825 return select_error();
Neal Norwitz082b2df2006-02-07 07:04:46 +00001826
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001827 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001828 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001829 timeout = internal_select_ex(s, 0, interval);
Antoine Pitroub1c54962010-10-14 15:05:38 +00001830 if (!timeout) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001831 newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
Antoine Pitroub1c54962010-10-14 15:05:38 +00001832 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001833 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001834
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001835 if (timeout == 1) {
1836 PyErr_SetString(socket_timeout, "timed out");
1837 return NULL;
1838 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001839 END_SELECT_LOOP(s)
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001840
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001841 if (newfd == INVALID_SOCKET)
1842 return s->errorhandler();
Barry Warsaw752300b1997-01-03 17:18:10 +00001843
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001844 sock = PyLong_FromSocket_t(newfd);
1845 if (sock == NULL) {
1846 SOCKETCLOSE(newfd);
1847 goto finally;
1848 }
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001849
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001850 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
1851 addrlen, s->sock_proto);
1852 if (addr == NULL)
1853 goto finally;
Barry Warsaw752300b1997-01-03 17:18:10 +00001854
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001855 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001856
Guido van Rossum67f7a382002-06-06 21:08:16 +00001857finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001858 Py_XDECREF(sock);
1859 Py_XDECREF(addr);
1860 return res;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001861}
1862
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001863PyDoc_STRVAR(accept_doc,
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001864"_accept() -> (integer, address info)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00001865\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001866Wait for an incoming connection. Return a new socket file descriptor\n\
1867representing the connection, and the address of the client.\n\
1868For IP sockets, the address info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001869
Guido van Rossum11ba0942002-06-13 15:07:44 +00001870/* s.setblocking(flag) method. Argument:
1871 False -- non-blocking mode; same as settimeout(0)
1872 True -- blocking mode; same as settimeout(None)
1873*/
Guido van Rossume4485b01994-09-07 14:32:49 +00001874
Guido van Rossum73624e91994-10-10 17:59:00 +00001875static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001876sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00001877{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001878 int block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001879
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001880 block = PyLong_AsLong(arg);
1881 if (block == -1 && PyErr_Occurred())
1882 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001883
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001884 s->sock_timeout = block ? -1.0 : 0.0;
1885 internal_setblocking(s, block);
Guido van Rossume4485b01994-09-07 14:32:49 +00001886
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001887 Py_INCREF(Py_None);
1888 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001889}
Guido van Rossume4485b01994-09-07 14:32:49 +00001890
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001891PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001892"setblocking(flag)\n\
1893\n\
1894Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001895setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001896setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001897
Guido van Rossum11ba0942002-06-13 15:07:44 +00001898/* s.settimeout(timeout) method. Argument:
1899 None -- no timeout, blocking mode; same as setblocking(True)
1900 0.0 -- non-blocking mode; same as setblocking(False)
1901 > 0 -- timeout mode; operations time out after timeout seconds
1902 < 0 -- illegal; raises an exception
1903*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00001904static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001905sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001906{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001907 double timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001908
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001909 if (arg == Py_None)
1910 timeout = -1.0;
1911 else {
1912 timeout = PyFloat_AsDouble(arg);
1913 if (timeout < 0.0) {
1914 if (!PyErr_Occurred())
1915 PyErr_SetString(PyExc_ValueError,
1916 "Timeout value out of range");
1917 return NULL;
1918 }
1919 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00001920
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001921 s->sock_timeout = timeout;
1922 internal_setblocking(s, timeout < 0.0);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001923
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001924 Py_INCREF(Py_None);
1925 return Py_None;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001926}
1927
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001928PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001929"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001930\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001931Set a timeout on socket operations. 'timeout' can be a float,\n\
1932giving in seconds, or None. Setting a timeout of None disables\n\
1933the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001934Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00001935
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001936/* s.gettimeout() method.
1937 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00001938static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001939sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001940{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001941 if (s->sock_timeout < 0.0) {
1942 Py_INCREF(Py_None);
1943 return Py_None;
1944 }
1945 else
1946 return PyFloat_FromDouble(s->sock_timeout);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001947}
1948
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001949PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00001950"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001951\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03001952Returns the timeout in seconds (float) associated with socket \n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001953operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001954operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00001955
Guido van Rossumaee08791992-09-08 09:05:33 +00001956/* s.setsockopt() method.
1957 With an integer third argument, sets an integer option.
1958 With a string third argument, sets an option from a buffer;
1959 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001960
Guido van Rossum73624e91994-10-10 17:59:00 +00001961static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001962sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001963{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001964 int level;
1965 int optname;
1966 int res;
1967 char *buf;
1968 int buflen;
1969 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001970
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001971 if (PyArg_ParseTuple(args, "iii:setsockopt",
1972 &level, &optname, &flag)) {
1973 buf = (char *) &flag;
1974 buflen = sizeof flag;
1975 }
1976 else {
1977 PyErr_Clear();
1978 if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
1979 &level, &optname, &buf, &buflen))
1980 return NULL;
1981 }
1982 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
1983 if (res < 0)
1984 return s->errorhandler();
1985 Py_INCREF(Py_None);
1986 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001987}
1988
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001989PyDoc_STRVAR(setsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001990"setsockopt(level, option, value)\n\
1991\n\
1992Set a socket option. See the Unix manual for level and option.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001993The value argument can either be an integer or a string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001994
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001995
Guido van Rossumaee08791992-09-08 09:05:33 +00001996/* s.getsockopt() method.
1997 With two arguments, retrieves an integer option.
1998 With a third integer argument, retrieves a string buffer of that size;
1999 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002000
Guido van Rossum73624e91994-10-10 17:59:00 +00002001static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002002sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002003{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002004 int level;
2005 int optname;
2006 int res;
2007 PyObject *buf;
2008 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002009
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002010 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
2011 &level, &optname, &buflen))
2012 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002013
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002014 if (buflen == 0) {
2015 int flag = 0;
2016 socklen_t flagsize = sizeof flag;
2017 res = getsockopt(s->sock_fd, level, optname,
2018 (void *)&flag, &flagsize);
2019 if (res < 0)
2020 return s->errorhandler();
2021 return PyLong_FromLong(flag);
2022 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002023#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002024 /* socklen_t is unsigned so no negative test is needed,
2025 test buflen == 0 is previously done */
2026 if (buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002027#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002028 if (buflen <= 0 || buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002029#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002030 PyErr_SetString(socket_error,
2031 "getsockopt buflen out of range");
2032 return NULL;
2033 }
2034 buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
2035 if (buf == NULL)
2036 return NULL;
2037 res = getsockopt(s->sock_fd, level, optname,
2038 (void *)PyBytes_AS_STRING(buf), &buflen);
2039 if (res < 0) {
2040 Py_DECREF(buf);
2041 return s->errorhandler();
2042 }
2043 _PyBytes_Resize(&buf, buflen);
2044 return buf;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002045}
2046
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002047PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002048"getsockopt(level, option[, buffersize]) -> value\n\
2049\n\
2050Get a socket option. See the Unix manual for level and option.\n\
2051If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002052string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002053
Guido van Rossum0e69587d1992-06-05 15:11:30 +00002054
Fred Drake728819a2000-07-01 03:40:12 +00002055/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002056
Guido van Rossum73624e91994-10-10 17:59:00 +00002057static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002058sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002059{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002060 sock_addr_t addrbuf;
2061 int addrlen;
2062 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002063
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002064 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2065 return NULL;
2066 Py_BEGIN_ALLOW_THREADS
2067 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
2068 Py_END_ALLOW_THREADS
2069 if (res < 0)
2070 return s->errorhandler();
2071 Py_INCREF(Py_None);
2072 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002073}
2074
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002075PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002076"bind(address)\n\
2077\n\
2078Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00002079pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002080sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002081
Guido van Rossum30a685f1991-06-27 15:51:29 +00002082
2083/* s.close() method.
2084 Set the file descriptor to -1 so operations tried subsequently
2085 will surely fail. */
2086
Guido van Rossum73624e91994-10-10 17:59:00 +00002087static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002088sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002089{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002090 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002091
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002092 if ((fd = s->sock_fd) != -1) {
2093 s->sock_fd = -1;
2094 Py_BEGIN_ALLOW_THREADS
2095 (void) SOCKETCLOSE(fd);
2096 Py_END_ALLOW_THREADS
2097 }
2098 Py_INCREF(Py_None);
2099 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002100}
2101
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002102PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002103"close()\n\
2104\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002105Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002106
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002107static PyObject *
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002108sock_detach(PySocketSockObject *s)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002109{
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002110 SOCKET_T fd = s->sock_fd;
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002111 s->sock_fd = -1;
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002112 return PyLong_FromSocket_t(fd);
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002113}
2114
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002115PyDoc_STRVAR(detach_doc,
2116"detach()\n\
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002117\n\
2118Close the socket object without closing the underlying file descriptor.\
2119The object cannot be used after this call, but the file descriptor\
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002120can be reused for other purposes. The file descriptor is returned.");
Antoine Pitroue43f9d02010-08-08 23:24:50 +00002121
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002122static int
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002123internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002124 int *timeoutp)
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002125{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002126 int res, timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002127
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002128 timeout = 0;
2129 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002130
2131#ifdef MS_WINDOWS
2132
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002133 if (s->sock_timeout > 0.0) {
2134 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
2135 IS_SELECTABLE(s)) {
2136 /* This is a mess. Best solution: trust select */
2137 fd_set fds;
2138 fd_set fds_exc;
2139 struct timeval tv;
2140 tv.tv_sec = (int)s->sock_timeout;
2141 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
2142 FD_ZERO(&fds);
2143 FD_SET(s->sock_fd, &fds);
2144 FD_ZERO(&fds_exc);
2145 FD_SET(s->sock_fd, &fds_exc);
Antoine Pitrou19467d22010-08-17 19:33:30 +00002146 res = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
2147 NULL, &fds, &fds_exc, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002148 if (res == 0) {
2149 res = WSAEWOULDBLOCK;
2150 timeout = 1;
2151 } else if (res > 0) {
2152 if (FD_ISSET(s->sock_fd, &fds))
2153 /* The socket is in the writable set - this
2154 means connected */
2155 res = 0;
2156 else {
2157 /* As per MS docs, we need to call getsockopt()
2158 to get the underlying error */
2159 int res_size = sizeof res;
2160 /* It must be in the exception set */
2161 assert(FD_ISSET(s->sock_fd, &fds_exc));
2162 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
2163 (char *)&res, &res_size))
2164 /* getsockopt also clears WSAGetLastError,
2165 so reset it back. */
2166 WSASetLastError(res);
2167 else
2168 res = WSAGetLastError();
2169 }
2170 }
2171 /* else if (res < 0) an error occurred */
2172 }
2173 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002174
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002175 if (res < 0)
2176 res = WSAGetLastError();
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002177
2178#else
2179
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002180 if (s->sock_timeout > 0.0) {
2181 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
2182 timeout = internal_select(s, 1);
2183 if (timeout == 0) {
2184 /* Bug #1019808: in case of an EINPROGRESS,
2185 use getsockopt(SO_ERROR) to get the real
2186 error. */
2187 socklen_t res_size = sizeof res;
2188 (void)getsockopt(s->sock_fd, SOL_SOCKET,
2189 SO_ERROR, &res, &res_size);
2190 if (res == EISCONN)
2191 res = 0;
2192 errno = res;
2193 }
2194 else if (timeout == -1) {
2195 res = errno; /* had error */
2196 }
2197 else
2198 res = EWOULDBLOCK; /* timed out */
2199 }
2200 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002201
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002202 if (res < 0)
2203 res = errno;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002204
2205#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002206 *timeoutp = timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002208 return res;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002209}
Guido van Rossum30a685f1991-06-27 15:51:29 +00002210
Fred Drake728819a2000-07-01 03:40:12 +00002211/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002212
Guido van Rossum73624e91994-10-10 17:59:00 +00002213static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002214sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002215{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002216 sock_addr_t addrbuf;
2217 int addrlen;
2218 int res;
2219 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002220
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002221 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2222 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002223
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002224 Py_BEGIN_ALLOW_THREADS
2225 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2226 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002227
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002228 if (timeout == 1) {
2229 PyErr_SetString(socket_timeout, "timed out");
2230 return NULL;
2231 }
2232 if (res != 0)
2233 return s->errorhandler();
2234 Py_INCREF(Py_None);
2235 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002236}
2237
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002238PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002239"connect(address)\n\
2240\n\
2241Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002242is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002243
Guido van Rossum30a685f1991-06-27 15:51:29 +00002244
Fred Drake728819a2000-07-01 03:40:12 +00002245/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002246
2247static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002248sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002249{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002250 sock_addr_t addrbuf;
2251 int addrlen;
2252 int res;
2253 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002254
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002255 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2256 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002257
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002258 Py_BEGIN_ALLOW_THREADS
2259 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2260 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002261
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002262 /* Signals are not errors (though they may raise exceptions). Adapted
2263 from PyErr_SetFromErrnoWithFilenameObject(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002264#ifdef EINTR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002265 if (res == EINTR && PyErr_CheckSignals())
2266 return NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002267#endif
2268
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002269 return PyLong_FromLong((long) res);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002270}
2271
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002272PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002273"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002274\n\
2275This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002276instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002277
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002278
Guido van Rossumed233a51992-06-23 09:07:03 +00002279/* s.fileno() method */
2280
Guido van Rossum73624e91994-10-10 17:59:00 +00002281static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002282sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00002283{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002284 return PyLong_FromSocket_t(s->sock_fd);
Guido van Rossumed233a51992-06-23 09:07:03 +00002285}
2286
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002287PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002288"fileno() -> integer\n\
2289\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002290Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002291
Guido van Rossumed233a51992-06-23 09:07:03 +00002292
Guido van Rossumc89705d1992-11-26 08:54:07 +00002293/* s.getsockname() method */
2294
Guido van Rossum73624e91994-10-10 17:59:00 +00002295static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002296sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002297{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002298 sock_addr_t addrbuf;
2299 int res;
2300 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002301
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002302 if (!getsockaddrlen(s, &addrlen))
2303 return NULL;
2304 memset(&addrbuf, 0, addrlen);
2305 Py_BEGIN_ALLOW_THREADS
2306 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2307 Py_END_ALLOW_THREADS
2308 if (res < 0)
2309 return s->errorhandler();
2310 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2311 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002312}
2313
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002314PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002315"getsockname() -> address info\n\
2316\n\
2317Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002318info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002319
Guido van Rossumc89705d1992-11-26 08:54:07 +00002320
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002321#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002322/* s.getpeername() method */
2323
Guido van Rossum73624e91994-10-10 17:59:00 +00002324static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002325sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002326{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002327 sock_addr_t addrbuf;
2328 int res;
2329 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002330
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002331 if (!getsockaddrlen(s, &addrlen))
2332 return NULL;
2333 memset(&addrbuf, 0, addrlen);
2334 Py_BEGIN_ALLOW_THREADS
2335 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2336 Py_END_ALLOW_THREADS
2337 if (res < 0)
2338 return s->errorhandler();
2339 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2340 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002341}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002342
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002343PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002344"getpeername() -> address info\n\
2345\n\
2346Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002347info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002348
Guido van Rossumb6775db1994-08-01 11:34:53 +00002349#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002350
2351
Guido van Rossum30a685f1991-06-27 15:51:29 +00002352/* s.listen(n) method */
2353
Guido van Rossum73624e91994-10-10 17:59:00 +00002354static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002355sock_listen(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002356{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002357 int backlog;
2358 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002359
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002360 backlog = PyLong_AsLong(arg);
2361 if (backlog == -1 && PyErr_Occurred())
2362 return NULL;
2363 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou1be815a2011-05-10 19:16:29 +02002364 /* To avoid problems on systems that don't allow a negative backlog
2365 * (which doesn't make sense anyway) we force a minimum value of 0. */
2366 if (backlog < 0)
2367 backlog = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002368 res = listen(s->sock_fd, backlog);
2369 Py_END_ALLOW_THREADS
2370 if (res < 0)
2371 return s->errorhandler();
2372 Py_INCREF(Py_None);
2373 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002374}
2375
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002376PyDoc_STRVAR(listen_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002377"listen(backlog)\n\
2378\n\
2379Enable a server to accept connections. The backlog argument must be at\n\
Antoine Pitrou1be815a2011-05-10 19:16:29 +02002380least 0 (if it is lower, it is set to 0); it specifies the number of\n\
2381unaccepted connections that the system will allow before refusing new\n\
2382connections.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002383
2384
Thomas Wouters477c8d52006-05-27 19:21:47 +00002385/*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002386 * This is the guts of the recv() and recv_into() methods, which reads into a
Thomas Wouters902d6eb2007-01-09 23:18:33 +00002387 * char buffer. If you have any inc/dec ref to do to the objects that contain
Thomas Wouters477c8d52006-05-27 19:21:47 +00002388 * the buffer, do it in the caller. This function returns the number of bytes
Ezio Melotti13925002011-03-16 11:05:33 +02002389 * successfully read. If there was an error, it returns -1. Note that it is
Thomas Wouters477c8d52006-05-27 19:21:47 +00002390 * also possible that we return a number of bytes smaller than the request
2391 * bytes.
2392 */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002393
Antoine Pitrou19467d22010-08-17 19:33:30 +00002394static Py_ssize_t
2395sock_recv_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002396{
Antoine Pitrou19467d22010-08-17 19:33:30 +00002397 Py_ssize_t outlen = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002398 int timeout;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002399#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002400 int remaining;
2401 char *read_buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002402#endif
2403
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002404 if (!IS_SELECTABLE(s)) {
2405 select_error();
2406 return -1;
2407 }
2408 if (len == 0) {
2409 /* If 0 bytes were requested, do nothing. */
2410 return 0;
2411 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002412
2413#ifndef __VMS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002414 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002415 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002416 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002417 if (!timeout)
2418 outlen = recv(s->sock_fd, cbuf, len, flags);
2419 Py_END_ALLOW_THREADS
Thomas Wouters477c8d52006-05-27 19:21:47 +00002420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002421 if (timeout == 1) {
2422 PyErr_SetString(socket_timeout, "timed out");
2423 return -1;
2424 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002425 END_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002426 if (outlen < 0) {
2427 /* Note: the call to errorhandler() ALWAYS indirectly returned
2428 NULL, so ignore its return value */
2429 s->errorhandler();
2430 return -1;
2431 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002432#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002433 read_buf = cbuf;
2434 remaining = len;
2435 while (remaining != 0) {
2436 unsigned int segment;
2437 int nread = -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002438
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002439 segment = remaining /SEGMENT_SIZE;
2440 if (segment != 0) {
2441 segment = SEGMENT_SIZE;
2442 }
2443 else {
2444 segment = remaining;
2445 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002446
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002447 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002448 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002449 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002450 if (!timeout)
2451 nread = recv(s->sock_fd, read_buf, segment, flags);
2452 Py_END_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002453 if (timeout == 1) {
2454 PyErr_SetString(socket_timeout, "timed out");
2455 return -1;
2456 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002457 END_SELECT_LOOP(s)
2458
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002459 if (nread < 0) {
2460 s->errorhandler();
2461 return -1;
2462 }
2463 if (nread != remaining) {
2464 read_buf += nread;
2465 break;
2466 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002467
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002468 remaining -= segment;
2469 read_buf += segment;
2470 }
2471 outlen = read_buf - cbuf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002472#endif /* !__VMS */
2473
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002474 return outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002475}
2476
Guido van Rossum48a680c2001-03-02 06:34:14 +00002477
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002478/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002479
Guido van Rossum73624e91994-10-10 17:59:00 +00002480static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002481sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002482{
Antoine Pitrou19467d22010-08-17 19:33:30 +00002483 Py_ssize_t recvlen, outlen;
2484 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002485 PyObject *buf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002486
Antoine Pitrou19467d22010-08-17 19:33:30 +00002487 if (!PyArg_ParseTuple(args, "n|i:recv", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002488 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002490 if (recvlen < 0) {
2491 PyErr_SetString(PyExc_ValueError,
2492 "negative buffersize in recv");
2493 return NULL;
2494 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002495
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002496 /* Allocate a new string. */
2497 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2498 if (buf == NULL)
2499 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002500
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002501 /* Call the guts */
2502 outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
2503 if (outlen < 0) {
2504 /* An error occurred, release the string and return an
2505 error. */
2506 Py_DECREF(buf);
2507 return NULL;
2508 }
2509 if (outlen != recvlen) {
2510 /* We did not read as many bytes as we anticipated, resize the
2511 string if possible and be successful. */
2512 _PyBytes_Resize(&buf, outlen);
2513 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002514
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002515 return buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002516}
2517
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002518PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002519"recv(buffersize[, flags]) -> data\n\
2520\n\
2521Receive up to buffersize bytes from the socket. For the optional flags\n\
2522argument, see the Unix manual. When no data is available, block until\n\
2523at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002524the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002525
Guido van Rossum30a685f1991-06-27 15:51:29 +00002526
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002527/* s.recv_into(buffer, [nbytes [,flags]]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002528
Thomas Wouters477c8d52006-05-27 19:21:47 +00002529static PyObject*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002530sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002531{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002532 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002533
Antoine Pitrou19467d22010-08-17 19:33:30 +00002534 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002535 Py_buffer pbuf;
2536 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002537 Py_ssize_t buflen, readlen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002538
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002539 /* Get the buffer's memory */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002540 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recv_into", kwlist,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002541 &pbuf, &recvlen, &flags))
2542 return NULL;
2543 buf = pbuf.buf;
2544 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002545
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002546 if (recvlen < 0) {
2547 PyBuffer_Release(&pbuf);
2548 PyErr_SetString(PyExc_ValueError,
2549 "negative buffersize in recv_into");
2550 return NULL;
2551 }
2552 if (recvlen == 0) {
2553 /* If nbytes was not specified, use the buffer's length */
2554 recvlen = buflen;
2555 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002556
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002557 /* Check if the buffer is large enough */
2558 if (buflen < recvlen) {
2559 PyBuffer_Release(&pbuf);
2560 PyErr_SetString(PyExc_ValueError,
2561 "buffer too small for requested bytes");
2562 return NULL;
2563 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002564
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002565 /* Call the guts */
2566 readlen = sock_recv_guts(s, buf, recvlen, flags);
2567 if (readlen < 0) {
2568 /* Return an error. */
2569 PyBuffer_Release(&pbuf);
2570 return NULL;
2571 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002572
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002573 PyBuffer_Release(&pbuf);
2574 /* Return the number of bytes read. Note that we do not do anything
2575 special here in the case that readlen < recvlen. */
2576 return PyLong_FromSsize_t(readlen);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002577}
2578
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002579PyDoc_STRVAR(recv_into_doc,
2580"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002581\n\
2582A version of recv() that stores its data into a buffer rather than creating \n\
2583a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
2584is not specified (or 0), receive up to the size available in the given buffer.\n\
2585\n\
2586See recv() for documentation about the flags.");
2587
2588
2589/*
Christian Heimes99170a52007-12-19 02:07:34 +00002590 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
2591 * into a char buffer. If you have any inc/def ref to do to the objects that
2592 * contain the buffer, do it in the caller. This function returns the number
Ezio Melotti13925002011-03-16 11:05:33 +02002593 * of bytes successfully read. If there was an error, it returns -1. Note
Christian Heimes99170a52007-12-19 02:07:34 +00002594 * that it is also possible that we return a number of bytes smaller than the
2595 * request bytes.
Thomas Wouters477c8d52006-05-27 19:21:47 +00002596 *
2597 * 'addr' is a return value for the address object. Note that you must decref
2598 * it yourself.
2599 */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002600static Py_ssize_t
2601sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002602 PyObject** addr)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002603{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002604 sock_addr_t addrbuf;
2605 int timeout;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002606 Py_ssize_t n = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002607 socklen_t addrlen;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002608
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002609 *addr = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002610
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002611 if (!getsockaddrlen(s, &addrlen))
2612 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002613
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002614 if (!IS_SELECTABLE(s)) {
2615 select_error();
2616 return -1;
2617 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002618
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002619 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002620 Py_BEGIN_ALLOW_THREADS
2621 memset(&addrbuf, 0, addrlen);
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002622 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002623 if (!timeout) {
Guido van Rossum8d665e61996-06-26 18:22:49 +00002624#ifndef MS_WINDOWS
Andrew MacIntyreba43e872002-03-03 03:03:52 +00002625#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002626 n = recvfrom(s->sock_fd, cbuf, len, flags,
2627 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002628#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002629 n = recvfrom(s->sock_fd, cbuf, len, flags,
2630 (void *) &addrbuf, &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002631#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002632#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002633 n = recvfrom(s->sock_fd, cbuf, len, flags,
2634 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002635#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002636 }
2637 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002638
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002639 if (timeout == 1) {
2640 PyErr_SetString(socket_timeout, "timed out");
2641 return -1;
2642 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002643 END_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002644 if (n < 0) {
2645 s->errorhandler();
2646 return -1;
2647 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002648
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002649 if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2650 addrlen, s->sock_proto)))
2651 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002652
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002653 return n;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002654}
2655
2656/* s.recvfrom(nbytes [,flags]) method */
2657
2658static PyObject *
2659sock_recvfrom(PySocketSockObject *s, PyObject *args)
2660{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002661 PyObject *buf = NULL;
2662 PyObject *addr = NULL;
2663 PyObject *ret = NULL;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002664 int flags = 0;
2665 Py_ssize_t recvlen, outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002666
Antoine Pitrou19467d22010-08-17 19:33:30 +00002667 if (!PyArg_ParseTuple(args, "n|i:recvfrom", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002668 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002669
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002670 if (recvlen < 0) {
2671 PyErr_SetString(PyExc_ValueError,
2672 "negative buffersize in recvfrom");
2673 return NULL;
2674 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002675
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002676 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2677 if (buf == NULL)
2678 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002680 outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
2681 recvlen, flags, &addr);
2682 if (outlen < 0) {
2683 goto finally;
2684 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002685
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002686 if (outlen != recvlen) {
2687 /* We did not read as many bytes as we anticipated, resize the
Ezio Melotti13925002011-03-16 11:05:33 +02002688 string if possible and be successful. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002689 if (_PyBytes_Resize(&buf, outlen) < 0)
Ezio Melotti13925002011-03-16 11:05:33 +02002690 /* Oopsy, not so successful after all. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002691 goto finally;
2692 }
Barry Warsaw752300b1997-01-03 17:18:10 +00002693
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002694 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002695
2696finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002697 Py_XDECREF(buf);
2698 Py_XDECREF(addr);
2699 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002700}
2701
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002702PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002703"recvfrom(buffersize[, flags]) -> (data, address info)\n\
2704\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002705Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002706
Thomas Wouters477c8d52006-05-27 19:21:47 +00002707
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002708/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002709
2710static PyObject *
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002711sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002712{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002714
Antoine Pitrou19467d22010-08-17 19:33:30 +00002715 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002716 Py_buffer pbuf;
2717 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002718 Py_ssize_t readlen, buflen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002719
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002720 PyObject *addr = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002721
Antoine Pitrou19467d22010-08-17 19:33:30 +00002722 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recvfrom_into",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002723 kwlist, &pbuf,
2724 &recvlen, &flags))
2725 return NULL;
2726 buf = pbuf.buf;
2727 buflen = pbuf.len;
2728 assert(buf != 0 && buflen > 0);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002729
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002730 if (recvlen < 0) {
2731 PyBuffer_Release(&pbuf);
2732 PyErr_SetString(PyExc_ValueError,
2733 "negative buffersize in recvfrom_into");
2734 return NULL;
2735 }
2736 if (recvlen == 0) {
2737 /* If nbytes was not specified, use the buffer's length */
2738 recvlen = buflen;
2739 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002740
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002741 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
2742 if (readlen < 0) {
2743 PyBuffer_Release(&pbuf);
2744 /* Return an error */
2745 Py_XDECREF(addr);
2746 return NULL;
2747 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002748
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002749 PyBuffer_Release(&pbuf);
2750 /* Return the number of bytes read and the address. Note that we do
2751 not do anything special here in the case that readlen < recvlen. */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002752 return Py_BuildValue("nN", readlen, addr);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002753}
2754
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002755PyDoc_STRVAR(recvfrom_into_doc,
2756"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002757\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002758Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00002759
2760
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002761/* The sendmsg() and recvmsg[_into]() methods require a working
2762 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
2763#ifdef CMSG_LEN
2764/*
2765 * Call recvmsg() with the supplied iovec structures, flags, and
2766 * ancillary data buffer size (controllen). Returns the tuple return
2767 * value for recvmsg() or recvmsg_into(), with the first item provided
2768 * by the supplied makeval() function. makeval() will be called with
2769 * the length read and makeval_data as arguments, and must return a
2770 * new reference (which will be decrefed if there is a subsequent
2771 * error). On error, closes any file descriptors received via
2772 * SCM_RIGHTS.
2773 */
2774static PyObject *
2775sock_recvmsg_guts(PySocketSockObject *s, struct iovec *iov, int iovlen,
2776 int flags, Py_ssize_t controllen,
2777 PyObject *(*makeval)(ssize_t, void *), void *makeval_data)
2778{
2779 ssize_t bytes_received = -1;
2780 int timeout;
2781 sock_addr_t addrbuf;
2782 socklen_t addrbuflen;
Charles-François Natalie9e95ae2011-08-24 21:40:53 +02002783 struct msghdr msg = {0};
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002784 PyObject *cmsg_list = NULL, *retval = NULL;
2785 void *controlbuf = NULL;
2786 struct cmsghdr *cmsgh;
2787 size_t cmsgdatalen = 0;
2788 int cmsg_status;
2789
2790 /* XXX: POSIX says that msg_name and msg_namelen "shall be
2791 ignored" when the socket is connected (Linux fills them in
2792 anyway for AF_UNIX sockets at least). Normally msg_namelen
2793 seems to be set to 0 if there's no address, but try to
2794 initialize msg_name to something that won't be mistaken for a
2795 real address if that doesn't happen. */
2796 if (!getsockaddrlen(s, &addrbuflen))
2797 return NULL;
2798 memset(&addrbuf, 0, addrbuflen);
2799 SAS2SA(&addrbuf)->sa_family = AF_UNSPEC;
2800
2801 if (controllen < 0 || controllen > SOCKLEN_T_LIMIT) {
2802 PyErr_SetString(PyExc_ValueError,
2803 "invalid ancillary data buffer length");
2804 return NULL;
2805 }
2806 if (controllen > 0 && (controlbuf = PyMem_Malloc(controllen)) == NULL)
2807 return PyErr_NoMemory();
2808
2809 /* Make the system call. */
2810 if (!IS_SELECTABLE(s)) {
2811 select_error();
2812 goto finally;
2813 }
2814
2815 BEGIN_SELECT_LOOP(s)
2816 Py_BEGIN_ALLOW_THREADS;
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002817 msg.msg_name = SAS2SA(&addrbuf);
2818 msg.msg_namelen = addrbuflen;
2819 msg.msg_iov = iov;
2820 msg.msg_iovlen = iovlen;
2821 msg.msg_control = controlbuf;
2822 msg.msg_controllen = controllen;
2823 timeout = internal_select_ex(s, 0, interval);
2824 if (!timeout)
2825 bytes_received = recvmsg(s->sock_fd, &msg, flags);
2826 Py_END_ALLOW_THREADS;
2827 if (timeout == 1) {
2828 PyErr_SetString(socket_timeout, "timed out");
2829 goto finally;
2830 }
2831 END_SELECT_LOOP(s)
2832
2833 if (bytes_received < 0) {
2834 s->errorhandler();
2835 goto finally;
2836 }
2837
2838 /* Make list of (level, type, data) tuples from control messages. */
2839 if ((cmsg_list = PyList_New(0)) == NULL)
2840 goto err_closefds;
2841 /* Check for empty ancillary data as old CMSG_FIRSTHDR()
2842 implementations didn't do so. */
2843 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
2844 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
2845 PyObject *bytes, *tuple;
2846 int tmp;
2847
2848 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
2849 if (cmsg_status != 0) {
2850 if (PyErr_WarnEx(PyExc_RuntimeWarning,
2851 "received malformed or improperly-truncated "
2852 "ancillary data", 1) == -1)
2853 goto err_closefds;
2854 }
2855 if (cmsg_status < 0)
2856 break;
2857 if (cmsgdatalen > PY_SSIZE_T_MAX) {
2858 PyErr_SetString(socket_error, "control message too long");
2859 goto err_closefds;
2860 }
2861
2862 bytes = PyBytes_FromStringAndSize((char *)CMSG_DATA(cmsgh),
2863 cmsgdatalen);
2864 tuple = Py_BuildValue("iiN", (int)cmsgh->cmsg_level,
2865 (int)cmsgh->cmsg_type, bytes);
2866 if (tuple == NULL)
2867 goto err_closefds;
2868 tmp = PyList_Append(cmsg_list, tuple);
2869 Py_DECREF(tuple);
2870 if (tmp != 0)
2871 goto err_closefds;
2872
2873 if (cmsg_status != 0)
2874 break;
2875 }
2876
2877 retval = Py_BuildValue("NOiN",
2878 (*makeval)(bytes_received, makeval_data),
2879 cmsg_list,
2880 (int)msg.msg_flags,
2881 makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2882 ((msg.msg_namelen > addrbuflen) ?
2883 addrbuflen : msg.msg_namelen),
2884 s->sock_proto));
2885 if (retval == NULL)
2886 goto err_closefds;
2887
2888finally:
2889 Py_XDECREF(cmsg_list);
2890 PyMem_Free(controlbuf);
2891 return retval;
2892
2893err_closefds:
2894#ifdef SCM_RIGHTS
2895 /* Close all descriptors coming from SCM_RIGHTS, so they don't leak. */
2896 for (cmsgh = ((msg.msg_controllen > 0) ? CMSG_FIRSTHDR(&msg) : NULL);
2897 cmsgh != NULL; cmsgh = CMSG_NXTHDR(&msg, cmsgh)) {
2898 cmsg_status = get_cmsg_data_len(&msg, cmsgh, &cmsgdatalen);
2899 if (cmsg_status < 0)
2900 break;
2901 if (cmsgh->cmsg_level == SOL_SOCKET &&
2902 cmsgh->cmsg_type == SCM_RIGHTS) {
2903 size_t numfds;
2904 int *fdp;
2905
2906 numfds = cmsgdatalen / sizeof(int);
2907 fdp = (int *)CMSG_DATA(cmsgh);
2908 while (numfds-- > 0)
2909 close(*fdp++);
2910 }
2911 if (cmsg_status != 0)
2912 break;
2913 }
2914#endif /* SCM_RIGHTS */
2915 goto finally;
2916}
2917
2918
2919static PyObject *
2920makeval_recvmsg(ssize_t received, void *data)
2921{
2922 PyObject **buf = data;
2923
2924 if (received < PyBytes_GET_SIZE(*buf))
2925 _PyBytes_Resize(buf, received);
2926 Py_XINCREF(*buf);
2927 return *buf;
2928}
2929
2930/* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
2931
2932static PyObject *
2933sock_recvmsg(PySocketSockObject *s, PyObject *args)
2934{
2935 Py_ssize_t bufsize, ancbufsize = 0;
2936 int flags = 0;
2937 struct iovec iov;
2938 PyObject *buf = NULL, *retval = NULL;
2939
2940 if (!PyArg_ParseTuple(args, "n|ni:recvmsg", &bufsize, &ancbufsize, &flags))
2941 return NULL;
2942
2943 if (bufsize < 0) {
2944 PyErr_SetString(PyExc_ValueError, "negative buffer size in recvmsg()");
2945 return NULL;
2946 }
2947 if ((buf = PyBytes_FromStringAndSize(NULL, bufsize)) == NULL)
2948 return NULL;
2949 iov.iov_base = PyBytes_AS_STRING(buf);
2950 iov.iov_len = bufsize;
2951
2952 /* Note that we're passing a pointer to *our pointer* to the bytes
2953 object here (&buf); makeval_recvmsg() may incref the object, or
2954 deallocate it and set our pointer to NULL. */
2955 retval = sock_recvmsg_guts(s, &iov, 1, flags, ancbufsize,
2956 &makeval_recvmsg, &buf);
2957 Py_XDECREF(buf);
2958 return retval;
2959}
2960
2961PyDoc_STRVAR(recvmsg_doc,
2962"recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\
2963\n\
2964Receive normal data (up to bufsize bytes) and ancillary data from the\n\
2965socket. The ancbufsize argument sets the size in bytes of the\n\
2966internal buffer used to receive the ancillary data; it defaults to 0,\n\
2967meaning that no ancillary data will be received. Appropriate buffer\n\
2968sizes for ancillary data can be calculated using CMSG_SPACE() or\n\
2969CMSG_LEN(), and items which do not fit into the buffer might be\n\
2970truncated or discarded. The flags argument defaults to 0 and has the\n\
2971same meaning as for recv().\n\
2972\n\
2973The return value is a 4-tuple: (data, ancdata, msg_flags, address).\n\
2974The data item is a bytes object holding the non-ancillary data\n\
2975received. The ancdata item is a list of zero or more tuples\n\
2976(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n\
2977(control messages) received: cmsg_level and cmsg_type are integers\n\
2978specifying the protocol level and protocol-specific type respectively,\n\
2979and cmsg_data is a bytes object holding the associated data. The\n\
2980msg_flags item is the bitwise OR of various flags indicating\n\
2981conditions on the received message; see your system documentation for\n\
2982details. If the receiving socket is unconnected, address is the\n\
2983address of the sending socket, if available; otherwise, its value is\n\
2984unspecified.\n\
2985\n\
2986If recvmsg() raises an exception after the system call returns, it\n\
2987will first attempt to close any file descriptors received via the\n\
2988SCM_RIGHTS mechanism.");
2989
2990
2991static PyObject *
2992makeval_recvmsg_into(ssize_t received, void *data)
2993{
2994 return PyLong_FromSsize_t(received);
2995}
2996
2997/* s.recvmsg_into(buffers[, ancbufsize[, flags]]) method */
2998
2999static PyObject *
3000sock_recvmsg_into(PySocketSockObject *s, PyObject *args)
3001{
3002 Py_ssize_t ancbufsize = 0;
3003 int flags = 0;
3004 struct iovec *iovs = NULL;
3005 Py_ssize_t i, nitems, nbufs = 0;
3006 Py_buffer *bufs = NULL;
3007 PyObject *buffers_arg, *fast, *retval = NULL;
3008
3009 if (!PyArg_ParseTuple(args, "O|ni:recvmsg_into",
3010 &buffers_arg, &ancbufsize, &flags))
3011 return NULL;
3012
3013 if ((fast = PySequence_Fast(buffers_arg,
3014 "recvmsg_into() argument 1 must be an "
3015 "iterable")) == NULL)
3016 return NULL;
3017 nitems = PySequence_Fast_GET_SIZE(fast);
3018 if (nitems > INT_MAX) {
3019 PyErr_SetString(socket_error, "recvmsg_into() argument 1 is too long");
3020 goto finally;
3021 }
3022
3023 /* Fill in an iovec for each item, and save the Py_buffer
3024 structs to release afterwards. */
3025 if (nitems > 0 && ((iovs = PyMem_New(struct iovec, nitems)) == NULL ||
3026 (bufs = PyMem_New(Py_buffer, nitems)) == NULL)) {
3027 PyErr_NoMemory();
3028 goto finally;
3029 }
3030 for (; nbufs < nitems; nbufs++) {
3031 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(fast, nbufs),
3032 "w*;recvmsg_into() argument 1 must be an iterable "
3033 "of single-segment read-write buffers",
3034 &bufs[nbufs]))
3035 goto finally;
3036 iovs[nbufs].iov_base = bufs[nbufs].buf;
3037 iovs[nbufs].iov_len = bufs[nbufs].len;
3038 }
3039
3040 retval = sock_recvmsg_guts(s, iovs, nitems, flags, ancbufsize,
3041 &makeval_recvmsg_into, NULL);
3042finally:
3043 for (i = 0; i < nbufs; i++)
3044 PyBuffer_Release(&bufs[i]);
3045 PyMem_Free(bufs);
3046 PyMem_Free(iovs);
3047 Py_DECREF(fast);
3048 return retval;
3049}
3050
3051PyDoc_STRVAR(recvmsg_into_doc,
3052"recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\
3053\n\
3054Receive normal data and ancillary data from the socket, scattering the\n\
3055non-ancillary data into a series of buffers. The buffers argument\n\
3056must be an iterable of objects that export writable buffers\n\
3057(e.g. bytearray objects); these will be filled with successive chunks\n\
3058of the non-ancillary data until it has all been written or there are\n\
3059no more buffers. The ancbufsize argument sets the size in bytes of\n\
3060the internal buffer used to receive the ancillary data; it defaults to\n\
30610, meaning that no ancillary data will be received. Appropriate\n\
3062buffer sizes for ancillary data can be calculated using CMSG_SPACE()\n\
3063or CMSG_LEN(), and items which do not fit into the buffer might be\n\
3064truncated or discarded. The flags argument defaults to 0 and has the\n\
3065same meaning as for recv().\n\
3066\n\
3067The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\n\
3068The nbytes item is the total number of bytes of non-ancillary data\n\
3069written into the buffers. The ancdata item is a list of zero or more\n\
3070tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\n\
3071data (control messages) received: cmsg_level and cmsg_type are\n\
3072integers specifying the protocol level and protocol-specific type\n\
3073respectively, and cmsg_data is a bytes object holding the associated\n\
3074data. The msg_flags item is the bitwise OR of various flags\n\
3075indicating conditions on the received message; see your system\n\
3076documentation for details. If the receiving socket is unconnected,\n\
3077address is the address of the sending socket, if available; otherwise,\n\
3078its value is unspecified.\n\
3079\n\
3080If recvmsg_into() raises an exception after the system call returns,\n\
3081it will first attempt to close any file descriptors received via the\n\
3082SCM_RIGHTS mechanism.");
3083#endif /* CMSG_LEN */
3084
3085
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003086/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003087
Guido van Rossum73624e91994-10-10 17:59:00 +00003088static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003089sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003090{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003091 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003092 Py_ssize_t len, n = -1;
3093 int flags = 0, timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003094 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003095
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003096 if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
3097 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003098
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003099 if (!IS_SELECTABLE(s)) {
3100 PyBuffer_Release(&pbuf);
3101 return select_error();
3102 }
3103 buf = pbuf.buf;
3104 len = pbuf.len;
Neal Norwitz082b2df2006-02-07 07:04:46 +00003105
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003106 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003107 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003108 timeout = internal_select_ex(s, 1, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003109 if (!timeout)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003110#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003111 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003112#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003113 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003114#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003115 Py_END_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003116 if (timeout == 1) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003117 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003118 PyErr_SetString(socket_timeout, "timed out");
3119 return NULL;
3120 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003121 END_SELECT_LOOP(s)
3122
3123 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003124 if (n < 0)
3125 return s->errorhandler();
Antoine Pitrou19467d22010-08-17 19:33:30 +00003126 return PyLong_FromSsize_t(n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00003127}
3128
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003129PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003130"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003131\n\
3132Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003133argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003134sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003135
3136
3137/* s.sendall(data [,flags]) method */
3138
3139static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003140sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003141{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003142 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00003143 Py_ssize_t len, n = -1;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003144 int flags = 0, timeout, saved_errno;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003145 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003146
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003147 if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
3148 return NULL;
3149 buf = pbuf.buf;
3150 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003151
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003152 if (!IS_SELECTABLE(s)) {
3153 PyBuffer_Release(&pbuf);
3154 return select_error();
3155 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003156
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003157 do {
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003158 Py_BEGIN_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003159 timeout = internal_select(s, 1);
3160 n = -1;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003161 if (!timeout) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003162#ifdef __VMS
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003163 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003164#else
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003165 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003166#endif
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003167 }
3168 Py_END_ALLOW_THREADS
3169 if (timeout == 1) {
3170 PyBuffer_Release(&pbuf);
3171 PyErr_SetString(socket_timeout, "timed out");
3172 return NULL;
3173 }
3174 /* PyErr_CheckSignals() might change errno */
3175 saved_errno = errno;
3176 /* We must run our signal handlers before looping again.
3177 send() can return a successful partial write when it is
3178 interrupted, so we can't restrict ourselves to EINTR. */
3179 if (PyErr_CheckSignals()) {
3180 PyBuffer_Release(&pbuf);
3181 return NULL;
3182 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003183 if (n < 0) {
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003184 /* If interrupted, try again */
3185 if (saved_errno == EINTR)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003186 continue;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00003187 else
3188 break;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003189 }
3190 buf += n;
3191 len -= n;
3192 } while (len > 0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003193 PyBuffer_Release(&pbuf);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003194
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003195 if (n < 0)
3196 return s->errorhandler();
Guido van Rossum67f7a382002-06-06 21:08:16 +00003197
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003198 Py_INCREF(Py_None);
3199 return Py_None;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003200}
3201
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003202PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00003203"sendall(data[, flags])\n\
3204\n\
3205Send a data string to the socket. For the optional flags\n\
3206argument, see the Unix manual. This calls send() repeatedly\n\
3207until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003208to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003209
Guido van Rossum30a685f1991-06-27 15:51:29 +00003210
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00003211/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003212
Guido van Rossum73624e91994-10-10 17:59:00 +00003213static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003214sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003215{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003216 Py_buffer pbuf;
3217 PyObject *addro;
3218 char *buf;
Antoine Pitrou5e981412011-03-17 22:38:37 +01003219 Py_ssize_t len, arglen;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003220 sock_addr_t addrbuf;
3221 int addrlen, n = -1, flags, timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003223 flags = 0;
Antoine Pitrou5e981412011-03-17 22:38:37 +01003224 arglen = PyTuple_Size(args);
3225 switch (arglen) {
3226 case 2:
3227 PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro);
3228 break;
3229 case 3:
3230 PyArg_ParseTuple(args, "y*iO:sendto",
3231 &pbuf, &flags, &addro);
3232 break;
3233 default:
3234 PyErr_Format(PyExc_TypeError,
3235 "sendto() takes 2 or 3 arguments (%d given)",
3236 arglen);
Victor Stinner77af1722011-05-26 14:05:59 +02003237 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003238 }
Antoine Pitrou5e981412011-03-17 22:38:37 +01003239 if (PyErr_Occurred())
3240 return NULL;
3241
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003242 buf = pbuf.buf;
3243 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003244
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003245 if (!IS_SELECTABLE(s)) {
3246 PyBuffer_Release(&pbuf);
3247 return select_error();
3248 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00003249
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003250 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
3251 PyBuffer_Release(&pbuf);
3252 return NULL;
3253 }
Thomas Wouters89f507f2006-12-13 04:49:30 +00003254
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003255 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003256 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003257 timeout = internal_select_ex(s, 1, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003258 if (!timeout)
3259 n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
3260 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00003261
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003262 if (timeout == 1) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003263 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003264 PyErr_SetString(socket_timeout, "timed out");
3265 return NULL;
3266 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00003267 END_SELECT_LOOP(s)
3268 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003269 if (n < 0)
3270 return s->errorhandler();
Antoine Pitrou19467d22010-08-17 19:33:30 +00003271 return PyLong_FromSsize_t(n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003272}
3273
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003274PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003275"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003276\n\
3277Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003278For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003279
Guido van Rossum30a685f1991-06-27 15:51:29 +00003280
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003281/* The sendmsg() and recvmsg[_into]() methods require a working
3282 CMSG_LEN(). See the comment near get_CMSG_LEN(). */
3283#ifdef CMSG_LEN
3284/* s.sendmsg(buffers[, ancdata[, flags[, address]]]) method */
3285
3286static PyObject *
3287sock_sendmsg(PySocketSockObject *s, PyObject *args)
3288{
3289 Py_ssize_t i, ndataparts, ndatabufs = 0, ncmsgs, ncmsgbufs = 0;
3290 Py_buffer *databufs = NULL;
3291 struct iovec *iovs = NULL;
3292 sock_addr_t addrbuf;
Charles-François Natalie9e95ae2011-08-24 21:40:53 +02003293 struct msghdr msg = {0};
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003294 struct cmsginfo {
3295 int level;
3296 int type;
3297 Py_buffer data;
3298 } *cmsgs = NULL;
3299 void *controlbuf = NULL;
3300 size_t controllen, controllen_last;
3301 ssize_t bytes_sent = -1;
3302 int addrlen, timeout, flags = 0;
3303 PyObject *data_arg, *cmsg_arg = NULL, *addr_arg = NULL, *data_fast = NULL,
3304 *cmsg_fast = NULL, *retval = NULL;
3305
3306 if (!PyArg_ParseTuple(args, "O|OiO:sendmsg",
3307 &data_arg, &cmsg_arg, &flags, &addr_arg))
3308 return NULL;
3309
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003310 /* Parse destination address. */
3311 if (addr_arg != NULL && addr_arg != Py_None) {
3312 if (!getsockaddrarg(s, addr_arg, SAS2SA(&addrbuf), &addrlen))
3313 goto finally;
3314 msg.msg_name = &addrbuf;
3315 msg.msg_namelen = addrlen;
3316 }
3317
3318 /* Fill in an iovec for each message part, and save the Py_buffer
3319 structs to release afterwards. */
3320 if ((data_fast = PySequence_Fast(data_arg,
3321 "sendmsg() argument 1 must be an "
3322 "iterable")) == NULL)
3323 goto finally;
3324 ndataparts = PySequence_Fast_GET_SIZE(data_fast);
3325 if (ndataparts > INT_MAX) {
3326 PyErr_SetString(socket_error, "sendmsg() argument 1 is too long");
3327 goto finally;
3328 }
3329 msg.msg_iovlen = ndataparts;
3330 if (ndataparts > 0 &&
3331 ((msg.msg_iov = iovs = PyMem_New(struct iovec, ndataparts)) == NULL ||
3332 (databufs = PyMem_New(Py_buffer, ndataparts)) == NULL)) {
3333 PyErr_NoMemory();
3334 goto finally;
3335 }
3336 for (; ndatabufs < ndataparts; ndatabufs++) {
3337 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(data_fast, ndatabufs),
3338 "y*;sendmsg() argument 1 must be an iterable of "
3339 "buffer-compatible objects",
3340 &databufs[ndatabufs]))
3341 goto finally;
3342 iovs[ndatabufs].iov_base = databufs[ndatabufs].buf;
3343 iovs[ndatabufs].iov_len = databufs[ndatabufs].len;
3344 }
3345
3346 if (cmsg_arg == NULL)
3347 ncmsgs = 0;
3348 else {
3349 if ((cmsg_fast = PySequence_Fast(cmsg_arg,
3350 "sendmsg() argument 2 must be an "
3351 "iterable")) == NULL)
3352 goto finally;
3353 ncmsgs = PySequence_Fast_GET_SIZE(cmsg_fast);
3354 }
3355
3356#ifndef CMSG_SPACE
3357 if (ncmsgs > 1) {
3358 PyErr_SetString(socket_error,
3359 "sending multiple control messages is not supported "
3360 "on this system");
3361 goto finally;
3362 }
3363#endif
3364 /* Save level, type and Py_buffer for each control message,
3365 and calculate total size. */
3366 if (ncmsgs > 0 && (cmsgs = PyMem_New(struct cmsginfo, ncmsgs)) == NULL) {
3367 PyErr_NoMemory();
3368 goto finally;
3369 }
3370 controllen = controllen_last = 0;
3371 while (ncmsgbufs < ncmsgs) {
3372 size_t bufsize, space;
3373
3374 if (!PyArg_Parse(PySequence_Fast_GET_ITEM(cmsg_fast, ncmsgbufs),
3375 "(iiy*):[sendmsg() ancillary data items]",
3376 &cmsgs[ncmsgbufs].level,
3377 &cmsgs[ncmsgbufs].type,
3378 &cmsgs[ncmsgbufs].data))
3379 goto finally;
3380 bufsize = cmsgs[ncmsgbufs++].data.len;
3381
3382#ifdef CMSG_SPACE
3383 if (!get_CMSG_SPACE(bufsize, &space)) {
3384#else
3385 if (!get_CMSG_LEN(bufsize, &space)) {
3386#endif
3387 PyErr_SetString(socket_error, "ancillary data item too large");
3388 goto finally;
3389 }
3390 controllen += space;
3391 if (controllen > SOCKLEN_T_LIMIT || controllen < controllen_last) {
3392 PyErr_SetString(socket_error, "too much ancillary data");
3393 goto finally;
3394 }
3395 controllen_last = controllen;
3396 }
3397
3398 /* Construct ancillary data block from control message info. */
3399 if (ncmsgbufs > 0) {
3400 struct cmsghdr *cmsgh = NULL;
3401
3402 if ((msg.msg_control = controlbuf =
3403 PyMem_Malloc(controllen)) == NULL) {
3404 PyErr_NoMemory();
3405 goto finally;
3406 }
3407 msg.msg_controllen = controllen;
3408
3409 /* Need to zero out the buffer as a workaround for glibc's
3410 CMSG_NXTHDR() implementation. After getting the pointer to
3411 the next header, it checks its (uninitialized) cmsg_len
3412 member to see if the "message" fits in the buffer, and
3413 returns NULL if it doesn't. Zero-filling the buffer
3414 ensures that that doesn't happen. */
3415 memset(controlbuf, 0, controllen);
3416
3417 for (i = 0; i < ncmsgbufs; i++) {
3418 size_t msg_len, data_len = cmsgs[i].data.len;
3419 int enough_space = 0;
3420
3421 cmsgh = (i == 0) ? CMSG_FIRSTHDR(&msg) : CMSG_NXTHDR(&msg, cmsgh);
3422 if (cmsgh == NULL) {
3423 PyErr_Format(PyExc_RuntimeError,
3424 "unexpected NULL result from %s()",
3425 (i == 0) ? "CMSG_FIRSTHDR" : "CMSG_NXTHDR");
3426 goto finally;
3427 }
3428 if (!get_CMSG_LEN(data_len, &msg_len)) {
3429 PyErr_SetString(PyExc_RuntimeError,
3430 "item size out of range for CMSG_LEN()");
3431 goto finally;
3432 }
3433 if (cmsg_min_space(&msg, cmsgh, msg_len)) {
3434 size_t space;
3435
3436 cmsgh->cmsg_len = msg_len;
3437 if (get_cmsg_data_space(&msg, cmsgh, &space))
3438 enough_space = (space >= data_len);
3439 }
3440 if (!enough_space) {
3441 PyErr_SetString(PyExc_RuntimeError,
3442 "ancillary data does not fit in calculated "
3443 "space");
3444 goto finally;
3445 }
3446 cmsgh->cmsg_level = cmsgs[i].level;
3447 cmsgh->cmsg_type = cmsgs[i].type;
3448 memcpy(CMSG_DATA(cmsgh), cmsgs[i].data.buf, data_len);
3449 }
3450 }
3451
3452 /* Make the system call. */
3453 if (!IS_SELECTABLE(s)) {
3454 select_error();
3455 goto finally;
3456 }
3457
3458 BEGIN_SELECT_LOOP(s)
3459 Py_BEGIN_ALLOW_THREADS;
3460 timeout = internal_select_ex(s, 1, interval);
3461 if (!timeout)
3462 bytes_sent = sendmsg(s->sock_fd, &msg, flags);
3463 Py_END_ALLOW_THREADS;
3464 if (timeout == 1) {
3465 PyErr_SetString(socket_timeout, "timed out");
3466 goto finally;
3467 }
3468 END_SELECT_LOOP(s)
3469
3470 if (bytes_sent < 0) {
3471 s->errorhandler();
3472 goto finally;
3473 }
3474 retval = PyLong_FromSsize_t(bytes_sent);
3475
3476finally:
3477 PyMem_Free(controlbuf);
3478 for (i = 0; i < ncmsgbufs; i++)
3479 PyBuffer_Release(&cmsgs[i].data);
3480 PyMem_Free(cmsgs);
3481 Py_XDECREF(cmsg_fast);
3482 for (i = 0; i < ndatabufs; i++)
3483 PyBuffer_Release(&databufs[i]);
3484 PyMem_Free(databufs);
3485 PyMem_Free(iovs);
3486 Py_XDECREF(data_fast);
3487 return retval;
3488}
3489
3490PyDoc_STRVAR(sendmsg_doc,
3491"sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\
3492\n\
3493Send normal and ancillary data to the socket, gathering the\n\
3494non-ancillary data from a series of buffers and concatenating it into\n\
3495a single message. The buffers argument specifies the non-ancillary\n\
3496data as an iterable of buffer-compatible objects (e.g. bytes objects).\n\
3497The ancdata argument specifies the ancillary data (control messages)\n\
3498as an iterable of zero or more tuples (cmsg_level, cmsg_type,\n\
3499cmsg_data), where cmsg_level and cmsg_type are integers specifying the\n\
3500protocol level and protocol-specific type respectively, and cmsg_data\n\
3501is a buffer-compatible object holding the associated data. The flags\n\
3502argument defaults to 0 and has the same meaning as for send(). If\n\
3503address is supplied and not None, it sets a destination address for\n\
3504the message. The return value is the number of bytes of non-ancillary\n\
3505data sent.");
3506#endif /* CMSG_LEN */
3507
3508
Guido van Rossum30a685f1991-06-27 15:51:29 +00003509/* s.shutdown(how) method */
3510
Guido van Rossum73624e91994-10-10 17:59:00 +00003511static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003512sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003513{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003514 int how;
3515 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00003516
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003517 how = PyLong_AsLong(arg);
3518 if (how == -1 && PyErr_Occurred())
3519 return NULL;
3520 Py_BEGIN_ALLOW_THREADS
3521 res = shutdown(s->sock_fd, how);
3522 Py_END_ALLOW_THREADS
3523 if (res < 0)
3524 return s->errorhandler();
3525 Py_INCREF(Py_None);
3526 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003527}
3528
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003529PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003530"shutdown(flag)\n\
3531\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00003532Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
3533of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003534
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00003535#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Christian Heimesfaf2f632008-01-06 16:59:19 +00003536static PyObject*
3537sock_ioctl(PySocketSockObject *s, PyObject *arg)
3538{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003539 unsigned long cmd = SIO_RCVALL;
3540 PyObject *argO;
3541 DWORD recv;
Christian Heimesfaf2f632008-01-06 16:59:19 +00003542
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003543 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
3544 return NULL;
Christian Heimesfaf2f632008-01-06 16:59:19 +00003545
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003546 switch (cmd) {
3547 case SIO_RCVALL: {
3548 unsigned int option = RCVALL_ON;
3549 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
3550 return NULL;
3551 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
3552 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
3553 return set_error();
3554 }
3555 return PyLong_FromUnsignedLong(recv); }
3556 case SIO_KEEPALIVE_VALS: {
3557 struct tcp_keepalive ka;
3558 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
3559 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
3560 return NULL;
3561 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
3562 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
3563 return set_error();
3564 }
3565 return PyLong_FromUnsignedLong(recv); }
3566 default:
3567 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
3568 return NULL;
3569 }
Christian Heimesfaf2f632008-01-06 16:59:19 +00003570}
3571PyDoc_STRVAR(sock_ioctl_doc,
3572"ioctl(cmd, option) -> long\n\
3573\n\
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00003574Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
3575SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
3576SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).");
Christian Heimesfaf2f632008-01-06 16:59:19 +00003577
3578#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00003579
3580/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003581
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003582static PyMethodDef sock_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003583 {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
3584 accept_doc},
3585 {"bind", (PyCFunction)sock_bind, METH_O,
3586 bind_doc},
3587 {"close", (PyCFunction)sock_close, METH_NOARGS,
3588 close_doc},
3589 {"connect", (PyCFunction)sock_connect, METH_O,
3590 connect_doc},
3591 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
3592 connect_ex_doc},
Antoine Pitrou6e451df2010-08-09 20:39:54 +00003593 {"detach", (PyCFunction)sock_detach, METH_NOARGS,
3594 detach_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003595 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
3596 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00003597#ifdef HAVE_GETPEERNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003598 {"getpeername", (PyCFunction)sock_getpeername,
3599 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00003600#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003601 {"getsockname", (PyCFunction)sock_getsockname,
3602 METH_NOARGS, getsockname_doc},
3603 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
3604 getsockopt_doc},
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00003605#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003606 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
3607 sock_ioctl_doc},
Christian Heimesfaf2f632008-01-06 16:59:19 +00003608#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003609 {"listen", (PyCFunction)sock_listen, METH_O,
3610 listen_doc},
3611 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
3612 recv_doc},
3613 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
3614 recv_into_doc},
3615 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
3616 recvfrom_doc},
3617 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
3618 recvfrom_into_doc},
3619 {"send", (PyCFunction)sock_send, METH_VARARGS,
3620 send_doc},
3621 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
3622 sendall_doc},
3623 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
3624 sendto_doc},
3625 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
3626 setblocking_doc},
3627 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
3628 settimeout_doc},
3629 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
3630 gettimeout_doc},
3631 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
3632 setsockopt_doc},
3633 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
3634 shutdown_doc},
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003635#ifdef CMSG_LEN
3636 {"recvmsg", (PyCFunction)sock_recvmsg, METH_VARARGS,
3637 recvmsg_doc},
3638 {"recvmsg_into", (PyCFunction)sock_recvmsg_into, METH_VARARGS,
3639 recvmsg_into_doc,},
3640 {"sendmsg", (PyCFunction)sock_sendmsg, METH_VARARGS,
3641 sendmsg_doc},
3642#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003643 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003644};
3645
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00003646/* SockObject members */
3647static PyMemberDef sock_memberlist[] = {
3648 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
3649 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
3650 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
3651 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
3652 {0},
3653};
Guido van Rossum30a685f1991-06-27 15:51:29 +00003654
Guido van Rossum73624e91994-10-10 17:59:00 +00003655/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00003656 First close the file description. */
3657
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003658static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003659sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003660{
Antoine Pitroue033e062010-10-29 10:38:18 +00003661 if (s->sock_fd != -1) {
3662 PyObject *exc, *val, *tb;
3663 Py_ssize_t old_refcount = Py_REFCNT(s);
3664 ++Py_REFCNT(s);
3665 PyErr_Fetch(&exc, &val, &tb);
3666 if (PyErr_WarnFormat(PyExc_ResourceWarning, 1,
3667 "unclosed %R", s))
3668 /* Spurious errors can appear at shutdown */
3669 if (PyErr_ExceptionMatches(PyExc_Warning))
3670 PyErr_WriteUnraisable((PyObject *) s);
3671 PyErr_Restore(exc, val, tb);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003672 (void) SOCKETCLOSE(s->sock_fd);
Antoine Pitroue033e062010-10-29 10:38:18 +00003673 Py_REFCNT(s) = old_refcount;
3674 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003675 Py_TYPE(s)->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003676}
3677
Guido van Rossum30a685f1991-06-27 15:51:29 +00003678
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003679static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003680sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003681{
Fred Drakea04eaad2000-06-30 02:46:07 +00003682#if SIZEOF_SOCKET_T > SIZEOF_LONG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003683 if (s->sock_fd > LONG_MAX) {
3684 /* this can occur on Win64, and actually there is a special
3685 ugly printf formatter for decimal pointer length integer
3686 printing, only bother if necessary*/
3687 PyErr_SetString(PyExc_OverflowError,
3688 "no printf formatter to display "
3689 "the socket descriptor in decimal");
3690 return NULL;
3691 }
Fred Drakea04eaad2000-06-30 02:46:07 +00003692#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003693 return PyUnicode_FromFormat(
3694 "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
3695 (long)s->sock_fd, s->sock_family,
3696 s->sock_type,
3697 s->sock_proto);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003698}
3699
3700
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003701/* Create a new, uninitialized socket object. */
3702
3703static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003704sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003705{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003706 PyObject *new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003707
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003708 new = type->tp_alloc(type, 0);
3709 if (new != NULL) {
3710 ((PySocketSockObject *)new)->sock_fd = -1;
3711 ((PySocketSockObject *)new)->sock_timeout = -1.0;
3712 ((PySocketSockObject *)new)->errorhandler = &set_error;
3713 }
3714 return new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003715}
3716
3717
3718/* Initialize a new socket object. */
3719
3720/*ARGSUSED*/
3721static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00003722sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003723{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003724 PySocketSockObject *s = (PySocketSockObject *)self;
3725 PyObject *fdobj = NULL;
3726 SOCKET_T fd = INVALID_SOCKET;
3727 int family = AF_INET, type = SOCK_STREAM, proto = 0;
3728 static char *keywords[] = {"family", "type", "proto", "fileno", 0};
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003729
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003730 if (!PyArg_ParseTupleAndKeywords(args, kwds,
3731 "|iiiO:socket", keywords,
3732 &family, &type, &proto, &fdobj))
3733 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003734
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003735 if (fdobj != NULL && fdobj != Py_None) {
3736 fd = PyLong_AsSocket_t(fdobj);
3737 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
3738 return -1;
3739 if (fd == INVALID_SOCKET) {
3740 PyErr_SetString(PyExc_ValueError,
3741 "can't use invalid socket value");
3742 return -1;
3743 }
3744 }
3745 else {
3746 Py_BEGIN_ALLOW_THREADS
3747 fd = socket(family, type, proto);
3748 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00003749
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003750 if (fd == INVALID_SOCKET) {
3751 set_error();
3752 return -1;
3753 }
3754 }
3755 init_sockobject(s, fd, family, type, proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003756
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003757 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003758
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003759}
3760
3761
Guido van Rossumb6775db1994-08-01 11:34:53 +00003762/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003763
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003764static PyTypeObject sock_type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003765 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
3766 "_socket.socket", /* tp_name */
3767 sizeof(PySocketSockObject), /* tp_basicsize */
3768 0, /* tp_itemsize */
3769 (destructor)sock_dealloc, /* tp_dealloc */
3770 0, /* tp_print */
3771 0, /* tp_getattr */
3772 0, /* tp_setattr */
3773 0, /* tp_reserved */
3774 (reprfunc)sock_repr, /* tp_repr */
3775 0, /* tp_as_number */
3776 0, /* tp_as_sequence */
3777 0, /* tp_as_mapping */
3778 0, /* tp_hash */
3779 0, /* tp_call */
3780 0, /* tp_str */
3781 PyObject_GenericGetAttr, /* tp_getattro */
3782 0, /* tp_setattro */
3783 0, /* tp_as_buffer */
3784 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
3785 sock_doc, /* tp_doc */
3786 0, /* tp_traverse */
3787 0, /* tp_clear */
3788 0, /* tp_richcompare */
3789 0, /* tp_weaklistoffset */
3790 0, /* tp_iter */
3791 0, /* tp_iternext */
3792 sock_methods, /* tp_methods */
3793 sock_memberlist, /* tp_members */
3794 0, /* tp_getset */
3795 0, /* tp_base */
3796 0, /* tp_dict */
3797 0, /* tp_descr_get */
3798 0, /* tp_descr_set */
3799 0, /* tp_dictoffset */
3800 sock_initobj, /* tp_init */
3801 PyType_GenericAlloc, /* tp_alloc */
3802 sock_new, /* tp_new */
3803 PyObject_Del, /* tp_free */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003804};
3805
Guido van Rossum30a685f1991-06-27 15:51:29 +00003806
Guido van Rossum81194471991-07-27 21:42:02 +00003807/* Python interface to gethostname(). */
3808
3809/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003810static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00003811socket_gethostname(PyObject *self, PyObject *unused)
Guido van Rossum81194471991-07-27 21:42:02 +00003812{
Martin v. Löwis72f48422010-10-29 18:20:08 +00003813#ifdef MS_WINDOWS
3814 /* Don't use winsock's gethostname, as this returns the ANSI
3815 version of the hostname, whereas we need a Unicode string.
3816 Otherwise, gethostname apparently also returns the DNS name. */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003817 wchar_t buf[MAX_COMPUTERNAME_LENGTH + 1];
3818 DWORD size = sizeof(buf) / sizeof(wchar_t);
3819 PyObject *result;
Martin v. Löwis72f48422010-10-29 18:20:08 +00003820 if (!GetComputerNameExW(ComputerNamePhysicalDnsHostname, buf, &size)) {
3821 if (GetLastError() == ERROR_MORE_DATA) {
3822 /* MSDN says this may occur "because DNS allows longer names */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003823 if (size == 0) /* XXX: I'm not sure how to handle this */
3824 return PyUnicode_FromUnicode(NULL, 0);
3825 result = PyUnicode_FromUnicode(NULL, size - 1);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003826 if (!result)
3827 return NULL;
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003828 if (GetComputerNameExW(ComputerNamePhysicalDnsHostname,
3829 PyUnicode_AS_UNICODE(result),
3830 &size))
Martin v. Löwis72f48422010-10-29 18:20:08 +00003831 return result;
Benjamin Petersone857b292010-10-29 21:37:26 +00003832 Py_DECREF(result);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003833 }
3834 return PyErr_SetExcFromWindowsErr(PyExc_WindowsError, GetLastError());
3835 }
Victor Stinner77af1722011-05-26 14:05:59 +02003836 return PyUnicode_FromUnicode(buf, size);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003837#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003838 char buf[1024];
3839 int res;
3840 Py_BEGIN_ALLOW_THREADS
3841 res = gethostname(buf, (int) sizeof buf - 1);
3842 Py_END_ALLOW_THREADS
3843 if (res < 0)
3844 return set_error();
3845 buf[sizeof buf - 1] = '\0';
3846 return PyUnicode_FromString(buf);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003847#endif
Guido van Rossum81194471991-07-27 21:42:02 +00003848}
Guido van Rossumff4949e1992-08-05 19:58:53 +00003849
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003850PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003851"gethostname() -> string\n\
3852\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003853Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003854
Antoine Pitrou061cfb52011-02-28 22:25:22 +00003855#ifdef HAVE_SETHOSTNAME
3856PyDoc_STRVAR(sethostname_doc,
3857"sethostname(name)\n\n\
3858Sets the hostname to name.");
3859
3860static PyObject *
3861socket_sethostname(PyObject *self, PyObject *args)
3862{
3863 PyObject *hnobj;
3864 Py_buffer buf;
3865 int res, flag = 0;
3866
3867 if (!PyArg_ParseTuple(args, "S:sethostname", &hnobj)) {
3868 PyErr_Clear();
3869 if (!PyArg_ParseTuple(args, "O&:sethostname",
3870 PyUnicode_FSConverter, &hnobj))
3871 return NULL;
3872 flag = 1;
3873 }
3874 res = PyObject_GetBuffer(hnobj, &buf, PyBUF_SIMPLE);
3875 if (!res) {
3876 res = sethostname(buf.buf, buf.len);
3877 PyBuffer_Release(&buf);
3878 }
3879 if (flag)
3880 Py_DECREF(hnobj);
3881 if (res)
3882 return set_error();
3883 Py_RETURN_NONE;
3884}
3885#endif
Guido van Rossumff4949e1992-08-05 19:58:53 +00003886
Guido van Rossum30a685f1991-06-27 15:51:29 +00003887/* Python interface to gethostbyname(name). */
3888
3889/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003890static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003891socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003892{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003893 char *name;
3894 sock_addr_t addrbuf;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003895 PyObject *ret = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003896
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003897 if (!PyArg_ParseTuple(args, "et:gethostbyname", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003898 return NULL;
3899 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003900 goto finally;
3901 ret = makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
3902finally:
3903 PyMem_Free(name);
3904 return ret;
Guido van Rossum30a685f1991-06-27 15:51:29 +00003905}
3906
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003907PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003908"gethostbyname(host) -> address\n\
3909\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003910Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003911
3912
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003913/* Convenience function common to gethostbyname_ex and gethostbyaddr */
3914
3915static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003916gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003917{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003918 char **pch;
3919 PyObject *rtn_tuple = (PyObject *)NULL;
3920 PyObject *name_list = (PyObject *)NULL;
3921 PyObject *addr_list = (PyObject *)NULL;
3922 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003923
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003924 if (h == NULL) {
3925 /* Let's get real error message to return */
3926 set_herror(h_errno);
3927 return NULL;
3928 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003929
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003930 if (h->h_addrtype != af) {
3931 /* Let's get real error message to return */
3932 PyErr_SetString(socket_error,
3933 (char *)strerror(EAFNOSUPPORT));
Christian Heimesada8c3b2008-03-18 18:26:33 +00003934
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003935 return NULL;
3936 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003937
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003938 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003939
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003940 case AF_INET:
3941 if (alen < sizeof(struct sockaddr_in))
3942 return NULL;
3943 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003944
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003945#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003946 case AF_INET6:
3947 if (alen < sizeof(struct sockaddr_in6))
3948 return NULL;
3949 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003950#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00003951
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003952 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003953
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003954 if ((name_list = PyList_New(0)) == NULL)
3955 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003956
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003957 if ((addr_list = PyList_New(0)) == NULL)
3958 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003959
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003960 /* SF #1511317: h_aliases can be NULL */
3961 if (h->h_aliases) {
3962 for (pch = h->h_aliases; *pch != NULL; pch++) {
3963 int status;
3964 tmp = PyUnicode_FromString(*pch);
3965 if (tmp == NULL)
3966 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003967
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003968 status = PyList_Append(name_list, tmp);
3969 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003970
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003971 if (status)
3972 goto err;
3973 }
3974 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003975
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003976 for (pch = h->h_addr_list; *pch != NULL; pch++) {
3977 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003978
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003979 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003980
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003981 case AF_INET:
3982 {
3983 struct sockaddr_in sin;
3984 memset(&sin, 0, sizeof(sin));
3985 sin.sin_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003986#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003987 sin.sin_len = sizeof(sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003988#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003989 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
3990 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00003991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003992 if (pch == h->h_addr_list && alen >= sizeof(sin))
3993 memcpy((char *) addr, &sin, sizeof(sin));
3994 break;
3995 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003996
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003997#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003998 case AF_INET6:
3999 {
4000 struct sockaddr_in6 sin6;
4001 memset(&sin6, 0, sizeof(sin6));
4002 sin6.sin6_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004003#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004004 sin6.sin6_len = sizeof(sin6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004005#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004006 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
4007 tmp = makeipaddr((struct sockaddr *)&sin6,
4008 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00004009
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004010 if (pch == h->h_addr_list && alen >= sizeof(sin6))
4011 memcpy((char *) addr, &sin6, sizeof(sin6));
4012 break;
4013 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004014#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00004015
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004016 default: /* can't happen */
4017 PyErr_SetString(socket_error,
4018 "unsupported address family");
4019 return NULL;
4020 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004022 if (tmp == NULL)
4023 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00004024
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004025 status = PyList_Append(addr_list, tmp);
4026 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004027
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004028 if (status)
4029 goto err;
4030 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00004031
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004032 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00004033
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004034 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004035 Py_XDECREF(name_list);
4036 Py_XDECREF(addr_list);
4037 return rtn_tuple;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004038}
4039
4040
4041/* Python interface to gethostbyname_ex(name). */
4042
4043/*ARGSUSED*/
4044static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004045socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004047 char *name;
4048 struct hostent *h;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00004049#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004050 struct sockaddr_storage addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00004051#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004052 struct sockaddr_in addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00004053#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004054 struct sockaddr *sa;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004055 PyObject *ret = NULL;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004056#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004057 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004058#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004059 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004060#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004061 char buf[16384];
4062 int buf_len = (sizeof buf) - 1;
4063 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004064#endif
4065#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004066 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004067#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004068#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004069
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004070 if (!PyArg_ParseTuple(args, "et:gethostbyname_ex", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004071 return NULL;
4072 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004073 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004074 Py_BEGIN_ALLOW_THREADS
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004075#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004076#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004077 result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
4078 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004079#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004080 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004081#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004082 memset((void *) &data, '\0', sizeof(data));
4083 result = gethostbyname_r(name, &hp_allocated, &data);
4084 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004085#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004086#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00004087#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004088 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004089#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004090 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004091#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004092 Py_END_ALLOW_THREADS
4093 /* Some C libraries would require addr.__ss_family instead of
4094 addr.ss_family.
4095 Therefore, we cast the sockaddr_storage into sockaddr to
4096 access sa_family. */
4097 sa = (struct sockaddr*)&addr;
4098 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
4099 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004100#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004101 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00004102#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004103finally:
4104 PyMem_Free(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004105 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004106}
4107
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004108PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004109"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
4110\n\
4111Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004112for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00004113
4114
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004115/* Python interface to gethostbyaddr(IP). */
4116
4117/*ARGSUSED*/
4118static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004119socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004120{
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004121#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004122 struct sockaddr_storage addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004123#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004124 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004125#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004126 struct sockaddr *sa = (struct sockaddr *)&addr;
4127 char *ip_num;
4128 struct hostent *h;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004129 PyObject *ret = NULL;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004130#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004131 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004132#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004133 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004134#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004135 /* glibcs up to 2.10 assume that the buf argument to
4136 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
4137 does not ensure. The attribute below instructs the compiler
4138 to maintain this alignment. */
4139 char buf[16384] Py_ALIGNED(8);
4140 int buf_len = (sizeof buf) - 1;
4141 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004142#endif
4143#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004144 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004145#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004146#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004147 char *ap;
4148 int al;
4149 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004150
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004151 if (!PyArg_ParseTuple(args, "et:gethostbyaddr", "idna", &ip_num))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004152 return NULL;
4153 af = AF_UNSPEC;
4154 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004155 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004156 af = sa->sa_family;
4157 ap = NULL;
Brett Cannonb94767f2011-02-22 20:15:44 +00004158 /* al = 0; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004159 switch (af) {
4160 case AF_INET:
4161 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
4162 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
4163 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004164#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004165 case AF_INET6:
4166 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
4167 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
4168 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004169#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004170 default:
4171 PyErr_SetString(socket_error, "unsupported address family");
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004172 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004173 }
4174 Py_BEGIN_ALLOW_THREADS
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004175#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004176#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004177 result = gethostbyaddr_r(ap, al, af,
4178 &hp_allocated, buf, buf_len,
4179 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004180#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004181 h = gethostbyaddr_r(ap, al, af,
4182 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00004183#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004184 memset((void *) &data, '\0', sizeof(data));
4185 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
4186 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00004187#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004188#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00004189#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004190 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004191#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004192 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004193#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004194 Py_END_ALLOW_THREADS
4195 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004196#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004197 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00004198#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00004199finally:
4200 PyMem_Free(ip_num);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004201 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00004202}
4203
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004204PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004205"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
4206\n\
4207Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004208for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004209
Guido van Rossum30a685f1991-06-27 15:51:29 +00004210
4211/* Python interface to getservbyname(name).
4212 This only returns the port number, since the other info is already
4213 known or not useful (like the list of aliases). */
4214
4215/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00004216static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004217socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00004218{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004219 char *name, *proto=NULL;
4220 struct servent *sp;
4221 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
4222 return NULL;
4223 Py_BEGIN_ALLOW_THREADS
4224 sp = getservbyname(name, proto);
4225 Py_END_ALLOW_THREADS
4226 if (sp == NULL) {
4227 PyErr_SetString(socket_error, "service/proto not found");
4228 return NULL;
4229 }
4230 return PyLong_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00004231}
4232
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004233PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00004234"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00004235\n\
4236Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00004237The optional protocol name, if given, should be 'tcp' or 'udp',\n\
4238otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004239
Guido van Rossum30a685f1991-06-27 15:51:29 +00004240
Barry Warsaw11b91a02004-06-28 00:50:43 +00004241/* Python interface to getservbyport(port).
4242 This only returns the service name, since the other info is already
4243 known or not useful (like the list of aliases). */
4244
4245/*ARGSUSED*/
4246static PyObject *
4247socket_getservbyport(PyObject *self, PyObject *args)
4248{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004249 int port;
4250 char *proto=NULL;
4251 struct servent *sp;
4252 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
4253 return NULL;
4254 if (port < 0 || port > 0xffff) {
4255 PyErr_SetString(
4256 PyExc_OverflowError,
4257 "getservbyport: port must be 0-65535.");
4258 return NULL;
4259 }
4260 Py_BEGIN_ALLOW_THREADS
4261 sp = getservbyport(htons((short)port), proto);
4262 Py_END_ALLOW_THREADS
4263 if (sp == NULL) {
4264 PyErr_SetString(socket_error, "port/proto not found");
4265 return NULL;
4266 }
4267 return PyUnicode_FromString(sp->s_name);
Barry Warsaw11b91a02004-06-28 00:50:43 +00004268}
4269
4270PyDoc_STRVAR(getservbyport_doc,
4271"getservbyport(port[, protocolname]) -> string\n\
4272\n\
4273Return the service name from a port number and protocol name.\n\
4274The optional protocol name, if given, should be 'tcp' or 'udp',\n\
4275otherwise any protocol will match.");
4276
Guido van Rossum3901d851996-12-19 16:35:04 +00004277/* Python interface to getprotobyname(name).
4278 This only returns the protocol number, since the other info is
4279 already known or not useful (like the list of aliases). */
4280
4281/*ARGSUSED*/
4282static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004283socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00004284{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004285 char *name;
4286 struct protoent *sp;
4287 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
4288 return NULL;
4289 Py_BEGIN_ALLOW_THREADS
4290 sp = getprotobyname(name);
4291 Py_END_ALLOW_THREADS
4292 if (sp == NULL) {
4293 PyErr_SetString(socket_error, "protocol not found");
4294 return NULL;
4295 }
4296 return PyLong_FromLong((long) sp->p_proto);
Guido van Rossum3901d851996-12-19 16:35:04 +00004297}
4298
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004299PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004300"getprotobyname(name) -> integer\n\
4301\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004302Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004303
Guido van Rossum3901d851996-12-19 16:35:04 +00004304
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004305#ifndef NO_DUP
4306/* dup() function for socket fds */
4307
4308static PyObject *
4309socket_dup(PyObject *self, PyObject *fdobj)
4310{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004311 SOCKET_T fd, newfd;
4312 PyObject *newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004313
4314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004315 fd = PyLong_AsSocket_t(fdobj);
4316 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
4317 return NULL;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004318
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004319 newfd = dup_socket(fd);
4320 if (newfd == INVALID_SOCKET)
4321 return set_error();
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004322
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004323 newfdobj = PyLong_FromSocket_t(newfd);
4324 if (newfdobj == NULL)
4325 SOCKETCLOSE(newfd);
4326 return newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004327}
4328
4329PyDoc_STRVAR(dup_doc,
4330"dup(integer) -> integer\n\
4331\n\
4332Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
4333sockets; on some platforms os.dup() won't work for socket file descriptors.");
4334#endif
4335
4336
Dave Cole331708b2004-08-09 04:51:41 +00004337#ifdef HAVE_SOCKETPAIR
4338/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00004339 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00004340 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00004341
4342/*ARGSUSED*/
4343static PyObject *
4344socket_socketpair(PyObject *self, PyObject *args)
4345{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004346 PySocketSockObject *s0 = NULL, *s1 = NULL;
4347 SOCKET_T sv[2];
4348 int family, type = SOCK_STREAM, proto = 0;
4349 PyObject *res = NULL;
Dave Cole331708b2004-08-09 04:51:41 +00004350
4351#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004352 family = AF_UNIX;
Dave Cole331708b2004-08-09 04:51:41 +00004353#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004354 family = AF_INET;
Dave Cole331708b2004-08-09 04:51:41 +00004355#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004356 if (!PyArg_ParseTuple(args, "|iii:socketpair",
4357 &family, &type, &proto))
4358 return NULL;
4359 /* Create a pair of socket fds */
4360 if (socketpair(family, type, proto, sv) < 0)
4361 return set_error();
4362 s0 = new_sockobject(sv[0], family, type, proto);
4363 if (s0 == NULL)
4364 goto finally;
4365 s1 = new_sockobject(sv[1], family, type, proto);
4366 if (s1 == NULL)
4367 goto finally;
4368 res = PyTuple_Pack(2, s0, s1);
Dave Cole331708b2004-08-09 04:51:41 +00004369
4370finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004371 if (res == NULL) {
4372 if (s0 == NULL)
4373 SOCKETCLOSE(sv[0]);
4374 if (s1 == NULL)
4375 SOCKETCLOSE(sv[1]);
4376 }
4377 Py_XDECREF(s0);
4378 Py_XDECREF(s1);
4379 return res;
Dave Cole331708b2004-08-09 04:51:41 +00004380}
4381
4382PyDoc_STRVAR(socketpair_doc,
4383"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
4384\n\
4385Create a pair of socket objects from the sockets returned by the platform\n\
4386socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00004387The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00004388AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00004389
4390#endif /* HAVE_SOCKETPAIR */
4391
4392
Guido van Rossum006bf911996-06-12 04:04:55 +00004393static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004394socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00004395{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004396 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00004397
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004398 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
4399 return NULL;
4400 }
4401 if (x1 < 0) {
4402 PyErr_SetString(PyExc_OverflowError,
4403 "can't convert negative number to unsigned long");
4404 return NULL;
4405 }
4406 x2 = (unsigned int)ntohs((unsigned short)x1);
4407 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00004408}
4409
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004410PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004411"ntohs(integer) -> integer\n\
4412\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004413Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004414
4415
Guido van Rossum006bf911996-06-12 04:04:55 +00004416static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004417socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00004418{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004419 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00004420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004421 if (PyLong_Check(arg)) {
4422 x = PyLong_AsUnsignedLong(arg);
4423 if (x == (unsigned long) -1 && PyErr_Occurred())
4424 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004425#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004426 {
4427 unsigned long y;
4428 /* only want the trailing 32 bits */
4429 y = x & 0xFFFFFFFFUL;
4430 if (y ^ x)
4431 return PyErr_Format(PyExc_OverflowError,
4432 "long int larger than 32 bits");
4433 x = y;
4434 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004435#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004436 }
4437 else
4438 return PyErr_Format(PyExc_TypeError,
4439 "expected int/long, %s found",
4440 Py_TYPE(arg)->tp_name);
4441 if (x == (unsigned long) -1 && PyErr_Occurred())
4442 return NULL;
4443 return PyLong_FromUnsignedLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00004444}
4445
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004446PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004447"ntohl(integer) -> integer\n\
4448\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004449Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004450
4451
Guido van Rossum006bf911996-06-12 04:04:55 +00004452static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004453socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00004454{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004455 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00004456
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004457 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
4458 return NULL;
4459 }
4460 if (x1 < 0) {
4461 PyErr_SetString(PyExc_OverflowError,
4462 "can't convert negative number to unsigned long");
4463 return NULL;
4464 }
4465 x2 = (unsigned int)htons((unsigned short)x1);
4466 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00004467}
4468
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004469PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004470"htons(integer) -> integer\n\
4471\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004472Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004473
4474
Guido van Rossum006bf911996-06-12 04:04:55 +00004475static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004476socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00004477{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004478 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00004479
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004480 if (PyLong_Check(arg)) {
4481 x = PyLong_AsUnsignedLong(arg);
4482 if (x == (unsigned long) -1 && PyErr_Occurred())
4483 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004484#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004485 {
4486 unsigned long y;
4487 /* only want the trailing 32 bits */
4488 y = x & 0xFFFFFFFFUL;
4489 if (y ^ x)
4490 return PyErr_Format(PyExc_OverflowError,
4491 "long int larger than 32 bits");
4492 x = y;
4493 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00004494#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004495 }
4496 else
4497 return PyErr_Format(PyExc_TypeError,
4498 "expected int/long, %s found",
4499 Py_TYPE(arg)->tp_name);
4500 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
Guido van Rossum006bf911996-06-12 04:04:55 +00004501}
4502
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004503PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00004504"htonl(integer) -> integer\n\
4505\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004506Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004507
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004508/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004509
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004510PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004511"inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004512\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00004513Convert 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 +00004514binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004515
4516static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004517socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004518{
Guido van Rossuma2e48551999-09-09 15:42:59 +00004519#ifndef INADDR_NONE
4520#define INADDR_NONE (-1)
4521#endif
Neal Norwitz88f115b2003-02-13 02:15:42 +00004522#ifdef HAVE_INET_ATON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004523 struct in_addr buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00004524#endif
4525
4526#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
Benjamin Petersonf91df042009-02-13 02:50:59 +00004527#if (SIZEOF_INT != 4)
4528#error "Not sure if in_addr_t exists and int is not 32-bits."
4529#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004530 /* Have to use inet_addr() instead */
4531 unsigned int packed_addr;
Tim Peters1df9fdd2003-02-13 03:13:40 +00004532#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004533 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00004534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004535 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
4536 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00004537
Tim Peters1df9fdd2003-02-13 03:13:40 +00004538
4539#ifdef HAVE_INET_ATON
Thomas Wouters477c8d52006-05-27 19:21:47 +00004540
4541#ifdef USE_INET_ATON_WEAKLINK
4542 if (inet_aton != NULL) {
4543#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004544 if (inet_aton(ip_addr, &buf))
4545 return PyBytes_FromStringAndSize((char *)(&buf),
4546 sizeof(buf));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00004547
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004548 PyErr_SetString(socket_error,
4549 "illegal IP address string passed to inet_aton");
4550 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00004551
Thomas Wouters477c8d52006-05-27 19:21:47 +00004552#ifdef USE_INET_ATON_WEAKLINK
4553 } else {
4554#endif
4555
4556#endif
4557
4558#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
4559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004560 /* special-case this address as inet_addr might return INADDR_NONE
4561 * for this */
4562 if (strcmp(ip_addr, "255.255.255.255") == 0) {
4563 packed_addr = 0xFFFFFFFF;
4564 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00004565
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004566 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00004567
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004568 if (packed_addr == INADDR_NONE) { /* invalid address */
4569 PyErr_SetString(socket_error,
4570 "illegal IP address string passed to inet_aton");
4571 return NULL;
4572 }
4573 }
4574 return PyBytes_FromStringAndSize((char *) &packed_addr,
4575 sizeof(packed_addr));
Thomas Wouters477c8d52006-05-27 19:21:47 +00004576
4577#ifdef USE_INET_ATON_WEAKLINK
4578 }
4579#endif
4580
Guido van Rossumad05cdf2003-02-12 23:08:22 +00004581#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004582}
4583
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004584PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00004585"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004586\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004587Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004588
4589static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004590socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004591{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004592 char *packed_str;
4593 int addr_len;
4594 struct in_addr packed_addr;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004595
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004596 if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
4597 return NULL;
4598 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00004599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004600 if (addr_len != sizeof(packed_addr)) {
4601 PyErr_SetString(socket_error,
4602 "packed IP wrong length for inet_ntoa");
4603 return NULL;
4604 }
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004606 memcpy(&packed_addr, packed_str, addr_len);
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004607
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004608 return PyUnicode_FromString(inet_ntoa(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00004609}
Guido van Rossum82a5c661998-07-07 20:45:43 +00004610
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004611#ifdef HAVE_INET_PTON
4612
4613PyDoc_STRVAR(inet_pton_doc,
4614"inet_pton(af, ip) -> packed IP address string\n\
4615\n\
4616Convert an IP address from string format to a packed string suitable\n\
4617for use with low-level network functions.");
4618
4619static PyObject *
4620socket_inet_pton(PyObject *self, PyObject *args)
4621{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004622 int af;
4623 char* ip;
4624 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004625#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004626 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004627#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004628 char packed[sizeof(struct in_addr)];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004629#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004630 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
4631 return NULL;
4632 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004633
Martin v. Löwis04697e82004-06-02 12:35:29 +00004634#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004635 if(af == AF_INET6) {
4636 PyErr_SetString(socket_error,
4637 "can't use AF_INET6, IPv6 is disabled");
4638 return NULL;
4639 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00004640#endif
Martin v. Löwis10649092003-08-05 06:25:06 +00004641
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004642 retval = inet_pton(af, ip, packed);
4643 if (retval < 0) {
4644 PyErr_SetFromErrno(socket_error);
4645 return NULL;
4646 } else if (retval == 0) {
4647 PyErr_SetString(socket_error,
4648 "illegal IP address string passed to inet_pton");
4649 return NULL;
4650 } else if (af == AF_INET) {
4651 return PyBytes_FromStringAndSize(packed,
4652 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004653#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004654 } else if (af == AF_INET6) {
4655 return PyBytes_FromStringAndSize(packed,
4656 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004657#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004658 } else {
4659 PyErr_SetString(socket_error, "unknown address family");
4660 return NULL;
4661 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004662}
Thomas Wouters477c8d52006-05-27 19:21:47 +00004663
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004664PyDoc_STRVAR(inet_ntop_doc,
4665"inet_ntop(af, packed_ip) -> string formatted IP address\n\
4666\n\
4667Convert a packed IP address of the given family to string format.");
4668
4669static PyObject *
4670socket_inet_ntop(PyObject *self, PyObject *args)
4671{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004672 int af;
4673 char* packed;
4674 int len;
4675 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004676#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004677 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004678#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004679 char ip[INET_ADDRSTRLEN + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004680#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00004681
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004682 /* Guarantee NUL-termination for PyUnicode_FromString() below */
4683 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004684
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004685 if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
4686 return NULL;
4687 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004688
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004689 if (af == AF_INET) {
4690 if (len != sizeof(struct in_addr)) {
4691 PyErr_SetString(PyExc_ValueError,
4692 "invalid length of packed IP address string");
4693 return NULL;
4694 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004695#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004696 } else if (af == AF_INET6) {
4697 if (len != sizeof(struct in6_addr)) {
4698 PyErr_SetString(PyExc_ValueError,
4699 "invalid length of packed IP address string");
4700 return NULL;
4701 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00004702#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004703 } else {
4704 PyErr_Format(PyExc_ValueError,
4705 "unknown address family %d", af);
4706 return NULL;
4707 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004708
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004709 retval = inet_ntop(af, packed, ip, sizeof(ip));
4710 if (!retval) {
4711 PyErr_SetFromErrno(socket_error);
4712 return NULL;
4713 } else {
4714 return PyUnicode_FromString(retval);
4715 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004716
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004717 /* NOTREACHED */
4718 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
4719 return NULL;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004720}
4721
4722#endif /* HAVE_INET_PTON */
4723
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004724/* Python interface to getaddrinfo(host, port). */
4725
4726/*ARGSUSED*/
4727static PyObject *
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004728socket_getaddrinfo(PyObject *self, PyObject *args, PyObject* kwargs)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004729{
Victor Stinner77af1722011-05-26 14:05:59 +02004730 static char* kwnames[] = {"host", "port", "family", "type", "proto",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004731 "flags", 0};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004732 struct addrinfo hints, *res;
4733 struct addrinfo *res0 = NULL;
4734 PyObject *hobj = NULL;
4735 PyObject *pobj = (PyObject *)NULL;
4736 char pbuf[30];
4737 char *hptr, *pptr;
4738 int family, socktype, protocol, flags;
4739 int error;
4740 PyObject *all = (PyObject *)NULL;
4741 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004742
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004743 family = socktype = protocol = flags = 0;
4744 family = AF_UNSPEC;
Victor Stinner77af1722011-05-26 14:05:59 +02004745 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iiii:getaddrinfo",
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004746 kwnames, &hobj, &pobj, &family, &socktype,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004747 &protocol, &flags)) {
4748 return NULL;
4749 }
4750 if (hobj == Py_None) {
4751 hptr = NULL;
4752 } else if (PyUnicode_Check(hobj)) {
4753 idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
4754 if (!idna)
4755 return NULL;
4756 assert(PyBytes_Check(idna));
4757 hptr = PyBytes_AS_STRING(idna);
4758 } else if (PyBytes_Check(hobj)) {
4759 hptr = PyBytes_AsString(hobj);
4760 } else {
4761 PyErr_SetString(PyExc_TypeError,
4762 "getaddrinfo() argument 1 must be string or None");
4763 return NULL;
4764 }
4765 if (PyLong_CheckExact(pobj)) {
4766 long value = PyLong_AsLong(pobj);
4767 if (value == -1 && PyErr_Occurred())
4768 goto err;
4769 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
4770 pptr = pbuf;
4771 } else if (PyUnicode_Check(pobj)) {
4772 pptr = _PyUnicode_AsString(pobj);
Alexander Belopolskye239d232010-12-08 23:31:48 +00004773 if (pptr == NULL)
4774 goto err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004775 } else if (PyBytes_Check(pobj)) {
Alexander Belopolskye239d232010-12-08 23:31:48 +00004776 pptr = PyBytes_AS_STRING(pobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004777 } else if (pobj == Py_None) {
4778 pptr = (char *)NULL;
4779 } else {
4780 PyErr_SetString(socket_error, "Int or String expected");
4781 goto err;
4782 }
4783 memset(&hints, 0, sizeof(hints));
4784 hints.ai_family = family;
4785 hints.ai_socktype = socktype;
4786 hints.ai_protocol = protocol;
4787 hints.ai_flags = flags;
4788 Py_BEGIN_ALLOW_THREADS
4789 ACQUIRE_GETADDRINFO_LOCK
4790 error = getaddrinfo(hptr, pptr, &hints, &res0);
4791 Py_END_ALLOW_THREADS
4792 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
4793 if (error) {
4794 set_gaierror(error);
4795 goto err;
4796 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004797
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004798 if ((all = PyList_New(0)) == NULL)
4799 goto err;
4800 for (res = res0; res; res = res->ai_next) {
4801 PyObject *single;
4802 PyObject *addr =
4803 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
4804 if (addr == NULL)
4805 goto err;
4806 single = Py_BuildValue("iiisO", res->ai_family,
4807 res->ai_socktype, res->ai_protocol,
4808 res->ai_canonname ? res->ai_canonname : "",
4809 addr);
4810 Py_DECREF(addr);
4811 if (single == NULL)
4812 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004813
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004814 if (PyList_Append(all, single))
4815 goto err;
4816 Py_XDECREF(single);
4817 }
4818 Py_XDECREF(idna);
4819 if (res0)
4820 freeaddrinfo(res0);
4821 return all;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004822 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004823 Py_XDECREF(all);
4824 Py_XDECREF(idna);
4825 if (res0)
4826 freeaddrinfo(res0);
4827 return (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004828}
4829
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004830PyDoc_STRVAR(getaddrinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004831"getaddrinfo(host, port [, family, socktype, proto, flags])\n\
4832 -> list of (family, socktype, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004833\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004834Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004835
4836/* Python interface to getnameinfo(sa, flags). */
4837
4838/*ARGSUSED*/
4839static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004840socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004841{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004842 PyObject *sa = (PyObject *)NULL;
4843 int flags;
4844 char *hostp;
4845 int port, flowinfo, scope_id;
4846 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
4847 struct addrinfo hints, *res = NULL;
4848 int error;
4849 PyObject *ret = (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004850
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004851 flags = flowinfo = scope_id = 0;
4852 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
4853 return NULL;
4854 if (!PyTuple_Check(sa)) {
4855 PyErr_SetString(PyExc_TypeError,
4856 "getnameinfo() argument 1 must be a tuple");
4857 return NULL;
4858 }
4859 if (!PyArg_ParseTuple(sa, "si|ii",
4860 &hostp, &port, &flowinfo, &scope_id))
4861 return NULL;
4862 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
4863 memset(&hints, 0, sizeof(hints));
4864 hints.ai_family = AF_UNSPEC;
4865 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Martin v. Löwis112c0f32010-08-25 07:38:15 +00004866 hints.ai_flags = AI_NUMERICHOST; /* don't do any name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004867 Py_BEGIN_ALLOW_THREADS
4868 ACQUIRE_GETADDRINFO_LOCK
4869 error = getaddrinfo(hostp, pbuf, &hints, &res);
4870 Py_END_ALLOW_THREADS
4871 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
4872 if (error) {
4873 set_gaierror(error);
4874 goto fail;
4875 }
4876 if (res->ai_next) {
4877 PyErr_SetString(socket_error,
4878 "sockaddr resolved to multiple addresses");
4879 goto fail;
4880 }
4881 switch (res->ai_family) {
4882 case AF_INET:
4883 {
4884 if (PyTuple_GET_SIZE(sa) != 2) {
4885 PyErr_SetString(socket_error,
4886 "IPv4 sockaddr must be 2 tuple");
4887 goto fail;
4888 }
4889 break;
4890 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004891#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004892 case AF_INET6:
4893 {
4894 struct sockaddr_in6 *sin6;
4895 sin6 = (struct sockaddr_in6 *)res->ai_addr;
4896 sin6->sin6_flowinfo = flowinfo;
4897 sin6->sin6_scope_id = scope_id;
4898 break;
4899 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004900#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004901 }
Antoine Pitrou19467d22010-08-17 19:33:30 +00004902 error = getnameinfo(res->ai_addr, (socklen_t) res->ai_addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004903 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
4904 if (error) {
4905 set_gaierror(error);
4906 goto fail;
4907 }
4908 ret = Py_BuildValue("ss", hbuf, pbuf);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004909
4910fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004911 if (res)
4912 freeaddrinfo(res);
4913 return ret;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004914}
4915
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004916PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004917"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004918\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004919Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004920
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004921
4922/* Python API to getting and setting the default timeout value. */
4923
4924static PyObject *
4925socket_getdefaulttimeout(PyObject *self)
4926{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004927 if (defaulttimeout < 0.0) {
4928 Py_INCREF(Py_None);
4929 return Py_None;
4930 }
4931 else
4932 return PyFloat_FromDouble(defaulttimeout);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004933}
4934
4935PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004936"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004937\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03004938Returns the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004939A value of None indicates that new socket objects have no timeout.\n\
4940When the socket module is first imported, the default is None.");
4941
4942static PyObject *
4943socket_setdefaulttimeout(PyObject *self, PyObject *arg)
4944{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004945 double timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004946
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004947 if (arg == Py_None)
4948 timeout = -1.0;
4949 else {
4950 timeout = PyFloat_AsDouble(arg);
4951 if (timeout < 0.0) {
4952 if (!PyErr_Occurred())
4953 PyErr_SetString(PyExc_ValueError,
4954 "Timeout value out of range");
4955 return NULL;
4956 }
4957 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004958
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004959 defaulttimeout = timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004960
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004961 Py_INCREF(Py_None);
4962 return Py_None;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004963}
4964
4965PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004966"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004967\n\
Ezio Melotti388c9452011-08-14 08:28:57 +03004968Set the default timeout in seconds (float) for new socket objects.\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004969A value of None indicates that new socket objects have no timeout.\n\
4970When the socket module is first imported, the default is None.");
4971
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07004972#ifdef HAVE_IF_NAMEINDEX
4973/* Python API for getting interface indices and names */
4974
4975static PyObject *
4976socket_if_nameindex(PyObject *self, PyObject *arg)
4977{
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07004978 PyObject *list;
Charles-François Natali60713592011-05-20 16:55:06 +02004979 int i;
4980 struct if_nameindex *ni;
Victor Stinner77af1722011-05-26 14:05:59 +02004981
Charles-François Natali60713592011-05-20 16:55:06 +02004982 ni = if_nameindex();
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07004983 if (ni == NULL) {
Charles-François Natali60713592011-05-20 16:55:06 +02004984 PyErr_SetFromErrno(socket_error);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07004985 return NULL;
4986 }
4987
4988 list = PyList_New(0);
4989 if (list == NULL) {
4990 if_freenameindex(ni);
4991 return NULL;
4992 }
4993
Charles-François Natali60713592011-05-20 16:55:06 +02004994 for (i = 0; ni[i].if_index != 0 && i < INT_MAX; i++) {
4995 PyObject *ni_tuple = Py_BuildValue("IO&",
4996 ni[i].if_index, PyUnicode_DecodeFSDefault, ni[i].if_name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07004997
4998 if (ni_tuple == NULL || PyList_Append(list, ni_tuple) == -1) {
4999 Py_XDECREF(ni_tuple);
Charles-François Natali60713592011-05-20 16:55:06 +02005000 Py_DECREF(list);
5001 if_freenameindex(ni);
5002 return NULL;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005003 }
5004 Py_DECREF(ni_tuple);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005005 }
5006
5007 if_freenameindex(ni);
5008 return list;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005009}
5010
5011PyDoc_STRVAR(if_nameindex_doc,
5012"if_nameindex()\n\
5013\n\
5014Returns a list of network interface information (index, name) tuples.");
5015
Charles-François Natali60713592011-05-20 16:55:06 +02005016static PyObject *
5017socket_if_nametoindex(PyObject *self, PyObject *args)
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005018{
Charles-François Natali60713592011-05-20 16:55:06 +02005019 PyObject *oname;
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005020 unsigned long index;
5021
Charles-François Natali60713592011-05-20 16:55:06 +02005022 if (!PyArg_ParseTuple(args, "O&:if_nametoindex",
5023 PyUnicode_FSConverter, &oname))
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005024 return NULL;
5025
Charles-François Natali60713592011-05-20 16:55:06 +02005026 index = if_nametoindex(PyBytes_AS_STRING(oname));
5027 Py_DECREF(oname);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005028 if (index == 0) {
Charles-François Natali60713592011-05-20 16:55:06 +02005029 /* if_nametoindex() doesn't set errno */
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005030 PyErr_SetString(socket_error, "no interface with this name");
5031 return NULL;
5032 }
5033
5034 return PyLong_FromUnsignedLong(index);
5035}
5036
5037PyDoc_STRVAR(if_nametoindex_doc,
5038"if_nametoindex(if_name)\n\
5039\n\
5040Returns the interface index corresponding to the interface name if_name.");
5041
Charles-François Natali60713592011-05-20 16:55:06 +02005042static PyObject *
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005043socket_if_indextoname(PyObject *self, PyObject *arg)
5044{
Charles-François Natali60713592011-05-20 16:55:06 +02005045 unsigned long index;
5046 char name[IF_NAMESIZE + 1];
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005047
Charles-François Natali60713592011-05-20 16:55:06 +02005048 index = PyLong_AsUnsignedLong(arg);
5049 if (index == (unsigned long) -1)
5050 return NULL;
5051
5052 if (if_indextoname(index, name) == NULL) {
5053 PyErr_SetFromErrno(socket_error);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005054 return NULL;
5055 }
5056
Charles-François Natali60713592011-05-20 16:55:06 +02005057 return PyUnicode_DecodeFSDefault(name);
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005058}
5059
5060PyDoc_STRVAR(if_indextoname_doc,
5061"if_indextoname(if_index)\n\
5062\n\
5063Returns the interface name corresponding to the interface index if_index.");
5064
5065#endif /* HAVE_IF_NAMEINDEX */
5066
5067
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005068#ifdef CMSG_LEN
5069/* Python interface to CMSG_LEN(length). */
5070
5071static PyObject *
5072socket_CMSG_LEN(PyObject *self, PyObject *args)
5073{
5074 Py_ssize_t length;
5075 size_t result;
5076
5077 if (!PyArg_ParseTuple(args, "n:CMSG_LEN", &length))
5078 return NULL;
5079 if (length < 0 || !get_CMSG_LEN(length, &result)) {
5080 PyErr_Format(PyExc_OverflowError, "CMSG_LEN() argument out of range");
5081 return NULL;
5082 }
5083 return PyLong_FromSize_t(result);
5084}
5085
5086PyDoc_STRVAR(CMSG_LEN_doc,
5087"CMSG_LEN(length) -> control message length\n\
5088\n\
5089Return the total length, without trailing padding, of an ancillary\n\
5090data item with associated data of the given length. This value can\n\
5091often be used as the buffer size for recvmsg() to receive a single\n\
5092item of ancillary data, but RFC 3542 requires portable applications to\n\
5093use CMSG_SPACE() and thus include space for padding, even when the\n\
5094item will be the last in the buffer. Raises OverflowError if length\n\
5095is outside the permissible range of values.");
5096
5097
5098#ifdef CMSG_SPACE
5099/* Python interface to CMSG_SPACE(length). */
5100
5101static PyObject *
5102socket_CMSG_SPACE(PyObject *self, PyObject *args)
5103{
5104 Py_ssize_t length;
5105 size_t result;
5106
5107 if (!PyArg_ParseTuple(args, "n:CMSG_SPACE", &length))
5108 return NULL;
5109 if (length < 0 || !get_CMSG_SPACE(length, &result)) {
5110 PyErr_SetString(PyExc_OverflowError,
5111 "CMSG_SPACE() argument out of range");
5112 return NULL;
5113 }
5114 return PyLong_FromSize_t(result);
5115}
5116
5117PyDoc_STRVAR(CMSG_SPACE_doc,
5118"CMSG_SPACE(length) -> buffer size\n\
5119\n\
5120Return the buffer size needed for recvmsg() to receive an ancillary\n\
5121data item with associated data of the given length, along with any\n\
5122trailing padding. The buffer space needed to receive multiple items\n\
5123is the sum of the CMSG_SPACE() values for their associated data\n\
5124lengths. Raises OverflowError if length is outside the permissible\n\
5125range of values.");
5126#endif /* CMSG_SPACE */
5127#endif /* CMSG_LEN */
5128
5129
Guido van Rossum30a685f1991-06-27 15:51:29 +00005130/* List of functions exported by this module. */
5131
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005132static PyMethodDef socket_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005133 {"gethostbyname", socket_gethostbyname,
5134 METH_VARARGS, gethostbyname_doc},
5135 {"gethostbyname_ex", socket_gethostbyname_ex,
5136 METH_VARARGS, ghbn_ex_doc},
5137 {"gethostbyaddr", socket_gethostbyaddr,
5138 METH_VARARGS, gethostbyaddr_doc},
5139 {"gethostname", socket_gethostname,
5140 METH_NOARGS, gethostname_doc},
Antoine Pitrou061cfb52011-02-28 22:25:22 +00005141#ifdef HAVE_SETHOSTNAME
5142 {"sethostname", socket_sethostname,
5143 METH_VARARGS, sethostname_doc},
5144#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005145 {"getservbyname", socket_getservbyname,
5146 METH_VARARGS, getservbyname_doc},
5147 {"getservbyport", socket_getservbyport,
5148 METH_VARARGS, getservbyport_doc},
5149 {"getprotobyname", socket_getprotobyname,
5150 METH_VARARGS, getprotobyname_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005151#ifndef NO_DUP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005152 {"dup", socket_dup,
5153 METH_O, dup_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005154#endif
Dave Cole331708b2004-08-09 04:51:41 +00005155#ifdef HAVE_SOCKETPAIR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005156 {"socketpair", socket_socketpair,
5157 METH_VARARGS, socketpair_doc},
Dave Cole331708b2004-08-09 04:51:41 +00005158#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005159 {"ntohs", socket_ntohs,
5160 METH_VARARGS, ntohs_doc},
5161 {"ntohl", socket_ntohl,
5162 METH_O, ntohl_doc},
5163 {"htons", socket_htons,
5164 METH_VARARGS, htons_doc},
5165 {"htonl", socket_htonl,
5166 METH_O, htonl_doc},
5167 {"inet_aton", socket_inet_aton,
5168 METH_VARARGS, inet_aton_doc},
5169 {"inet_ntoa", socket_inet_ntoa,
5170 METH_VARARGS, inet_ntoa_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005171#ifdef HAVE_INET_PTON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005172 {"inet_pton", socket_inet_pton,
5173 METH_VARARGS, inet_pton_doc},
5174 {"inet_ntop", socket_inet_ntop,
5175 METH_VARARGS, inet_ntop_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005176#endif
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00005177 {"getaddrinfo", (PyCFunction)socket_getaddrinfo,
5178 METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005179 {"getnameinfo", socket_getnameinfo,
5180 METH_VARARGS, getnameinfo_doc},
5181 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
5182 METH_NOARGS, getdefaulttimeout_doc},
5183 {"setdefaulttimeout", socket_setdefaulttimeout,
5184 METH_O, setdefaulttimeout_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005185#ifdef HAVE_IF_NAMEINDEX
5186 {"if_nameindex", socket_if_nameindex,
5187 METH_NOARGS, if_nameindex_doc},
5188 {"if_nametoindex", socket_if_nametoindex,
Charles-François Natali60713592011-05-20 16:55:06 +02005189 METH_VARARGS, if_nametoindex_doc},
Gregory P. Smith5ed2e772011-05-15 00:26:45 -07005190 {"if_indextoname", socket_if_indextoname,
5191 METH_O, if_indextoname_doc},
5192#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005193#ifdef CMSG_LEN
5194 {"CMSG_LEN", socket_CMSG_LEN,
5195 METH_VARARGS, CMSG_LEN_doc},
5196#ifdef CMSG_SPACE
5197 {"CMSG_SPACE", socket_CMSG_SPACE,
5198 METH_VARARGS, CMSG_SPACE_doc},
5199#endif
5200#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005201 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005202};
5203
Guido van Rossum30a685f1991-06-27 15:51:29 +00005204
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005205#ifdef MS_WINDOWS
5206#define OS_INIT_DEFINED
5207
5208/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00005209
5210static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005211os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00005212{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005213 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00005214}
5215
5216static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005217os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00005218{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005219 WSADATA WSAData;
5220 int ret;
5221 ret = WSAStartup(0x0101, &WSAData);
5222 switch (ret) {
5223 case 0: /* No error */
5224 Py_AtExit(os_cleanup);
5225 return 1; /* Success */
5226 case WSASYSNOTREADY:
5227 PyErr_SetString(PyExc_ImportError,
5228 "WSAStartup failed: network not ready");
5229 break;
5230 case WSAVERNOTSUPPORTED:
5231 case WSAEINVAL:
5232 PyErr_SetString(
5233 PyExc_ImportError,
5234 "WSAStartup failed: requested version not supported");
5235 break;
5236 default:
5237 PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
5238 break;
5239 }
5240 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00005241}
5242
Guido van Rossum8d665e61996-06-26 18:22:49 +00005243#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00005244
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005245
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005246#ifdef PYOS_OS2
5247#define OS_INIT_DEFINED
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005248
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005249/* Additional initialization for OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005250
5251static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005252os_init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005253{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005254#ifndef PYCC_GCC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005255 int rc = sock_init();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005256
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005257 if (rc == 0) {
5258 return 1; /* Success */
5259 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005260
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005261 PyErr_Format(PyExc_ImportError, "OS/2 TCP/IP Error# %d", sock_errno());
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005263 return 0; /* Failure */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00005264#else
Ezio Melotti13925002011-03-16 11:05:33 +02005265 /* No need to initialize sockets with GCC/EMX */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005266 return 1; /* Success */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00005267#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00005268}
5269
5270#endif /* PYOS_OS2 */
5271
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005272
5273#ifndef OS_INIT_DEFINED
5274static int
5275os_init(void)
5276{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005277 return 1; /* Success */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005278}
5279#endif
5280
5281
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00005282/* C API table - always add new things to the end for binary
5283 compatibility. */
5284static
5285PySocketModule_APIObject PySocketModuleAPI =
5286{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005287 &sock_type,
Antoine Pitrouc4df7842010-12-03 19:59:41 +00005288 NULL,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005289 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00005290};
5291
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005292
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005293/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005294
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005295 This module is actually called "_socket", and there's a wrapper
Guido van Rossum7d0a8262007-05-21 23:13:11 +00005296 "socket.py" which implements some additional functionality.
5297 The import of "_socket" may fail with an ImportError exception if
5298 os-specific initialization fails. On Windows, this does WINSOCK
Ezio Melotti13925002011-03-16 11:05:33 +02005299 initialization. When WINSOCK is initialized successfully, a call to
Guido van Rossum7d0a8262007-05-21 23:13:11 +00005300 WSACleanup() is scheduled to be made at exit time.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005301*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005302
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00005303PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00005304"Implementation module for socket operations.\n\
5305\n\
5306See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00005307
Martin v. Löwis1a214512008-06-11 05:26:20 +00005308static struct PyModuleDef socketmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005309 PyModuleDef_HEAD_INIT,
5310 PySocket_MODULE_NAME,
5311 socket_doc,
5312 -1,
5313 socket_methods,
5314 NULL,
5315 NULL,
5316 NULL,
5317 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00005318};
5319
Mark Hammondfe51c6d2002-08-02 02:27:13 +00005320PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00005321PyInit__socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005322{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005323 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00005324
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005325 if (!os_init())
5326 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005327
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005328 Py_TYPE(&sock_type) = &PyType_Type;
5329 m = PyModule_Create(&socketmodule);
5330 if (m == NULL)
5331 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005332
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005333 socket_error = PyErr_NewException("socket.error",
5334 PyExc_IOError, NULL);
5335 if (socket_error == NULL)
5336 return NULL;
5337 PySocketModuleAPI.error = socket_error;
5338 Py_INCREF(socket_error);
5339 PyModule_AddObject(m, "error", socket_error);
5340 socket_herror = PyErr_NewException("socket.herror",
5341 socket_error, NULL);
5342 if (socket_herror == NULL)
5343 return NULL;
5344 Py_INCREF(socket_herror);
5345 PyModule_AddObject(m, "herror", socket_herror);
5346 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
5347 NULL);
5348 if (socket_gaierror == NULL)
5349 return NULL;
5350 Py_INCREF(socket_gaierror);
5351 PyModule_AddObject(m, "gaierror", socket_gaierror);
5352 socket_timeout = PyErr_NewException("socket.timeout",
5353 socket_error, NULL);
5354 if (socket_timeout == NULL)
5355 return NULL;
Antoine Pitrouc4df7842010-12-03 19:59:41 +00005356 PySocketModuleAPI.timeout_error = socket_timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005357 Py_INCREF(socket_timeout);
5358 PyModule_AddObject(m, "timeout", socket_timeout);
5359 Py_INCREF((PyObject *)&sock_type);
5360 if (PyModule_AddObject(m, "SocketType",
5361 (PyObject *)&sock_type) != 0)
5362 return NULL;
5363 Py_INCREF((PyObject *)&sock_type);
5364 if (PyModule_AddObject(m, "socket",
5365 (PyObject *)&sock_type) != 0)
5366 return NULL;
Guido van Rossum09be4091999-08-09 14:40:40 +00005367
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005368#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005369 has_ipv6 = Py_True;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005370#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005371 has_ipv6 = Py_False;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005372#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005373 Py_INCREF(has_ipv6);
5374 PyModule_AddObject(m, "has_ipv6", has_ipv6);
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005375
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005376 /* Export C API */
5377 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
5378 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
5379 ) != 0)
5380 return NULL;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00005381
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005382 /* Address families (we only support AF_INET and AF_UNIX) */
Guido van Rossum09be4091999-08-09 14:40:40 +00005383#ifdef AF_UNSPEC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005384 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00005385#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005386 PyModule_AddIntConstant(m, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005387#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005388 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005389#endif /* AF_INET6 */
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00005390#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005391 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00005392#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00005393#ifdef AF_AX25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005394 /* Amateur Radio AX.25 */
5395 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00005396#endif
5397#ifdef AF_IPX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005398 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00005399#endif
5400#ifdef AF_APPLETALK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005401 /* Appletalk DDP */
5402 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00005403#endif
5404#ifdef AF_NETROM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005405 /* Amateur radio NetROM */
5406 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00005407#endif
5408#ifdef AF_BRIDGE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005409 /* Multiprotocol bridge */
5410 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00005411#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005412#ifdef AF_ATMPVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005413 /* ATM PVCs */
5414 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005415#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00005416#ifdef AF_AAL5
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005417 /* Reserved for Werner's ATM */
5418 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00005419#endif
5420#ifdef AF_X25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005421 /* Reserved for X.25 project */
5422 PyModule_AddIntConstant(m, "AF_X25", AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00005423#endif
5424#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005425 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00005426#endif
5427#ifdef AF_ROSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005428 /* Amateur Radio X.25 PLP */
5429 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00005430#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005431#ifdef AF_DECnet
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005432 /* Reserved for DECnet project */
5433 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005434#endif
5435#ifdef AF_NETBEUI
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005436 /* Reserved for 802.2LLC project */
5437 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005438#endif
5439#ifdef AF_SECURITY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005440 /* Security callback pseudo AF */
5441 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005442#endif
5443#ifdef AF_KEY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005444 /* PF_KEY key management API */
5445 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005446#endif
5447#ifdef AF_NETLINK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005448 /* */
5449 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
5450 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005451#ifdef NETLINK_SKIP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005452 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005453#endif
5454#ifdef NETLINK_W1
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005455 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005456#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005457 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
5458 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00005459#ifdef NETLINK_TCPDIAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005460 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00005461#endif
5462#ifdef NETLINK_NFLOG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005463 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00005464#endif
Neal Norwitz65851662006-01-16 04:31:40 +00005465#ifdef NETLINK_XFRM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005466 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00005467#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005468#ifdef NETLINK_ARPD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005469 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005470#endif
5471#ifdef NETLINK_ROUTE6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005472 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005473#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005474 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
Thomas Wouterscf297e42007-02-23 15:07:44 +00005475#ifdef NETLINK_DNRTMSG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005476 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00005477#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005478#ifdef NETLINK_TAPBASE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005479 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005480#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00005481#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005482#ifdef AF_ROUTE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005483 /* Alias to emulate 4.4BSD */
5484 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005485#endif
5486#ifdef AF_ASH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005487 /* Ash */
5488 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005489#endif
5490#ifdef AF_ECONET
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005491 /* Acorn Econet */
5492 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005493#endif
5494#ifdef AF_ATMSVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005495 /* ATM SVCs */
5496 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005497#endif
5498#ifdef AF_SNA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005499 /* Linux SNA Project (nutters!) */
5500 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005501#endif
5502#ifdef AF_IRDA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005503 /* IRDA sockets */
5504 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005505#endif
5506#ifdef AF_PPPOX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005507 /* PPPoX sockets */
5508 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005509#endif
5510#ifdef AF_WANPIPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005511 /* Wanpipe API Sockets */
5512 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005513#endif
5514#ifdef AF_LLC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005515 /* Linux LLC */
5516 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00005517#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00005518
Hye-Shik Chang81268602004-02-02 06:05:24 +00005519#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005520 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
5521 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
5522 PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
5523 PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00005524#if !defined(__NetBSD__) && !defined(__DragonFly__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005525 PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00005526#endif
Hye-Shik Chang81268602004-02-02 06:05:24 +00005527#if !defined(__FreeBSD__)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00005528#if !defined(__NetBSD__) && !defined(__DragonFly__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005529 PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00005530#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005531 PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
5532 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00005533#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005534 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
5535 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
5536 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
Martin v. Löwis12af0482004-01-31 12:34:17 +00005537#endif
5538
Antoine Pitroub156a462010-10-27 20:13:57 +00005539#ifdef AF_PACKET
5540 PyModule_AddIntMacro(m, AF_PACKET);
5541#endif
5542#ifdef PF_PACKET
5543 PyModule_AddIntMacro(m, PF_PACKET);
5544#endif
5545#ifdef PACKET_HOST
5546 PyModule_AddIntMacro(m, PACKET_HOST);
5547#endif
5548#ifdef PACKET_BROADCAST
5549 PyModule_AddIntMacro(m, PACKET_BROADCAST);
5550#endif
5551#ifdef PACKET_MULTICAST
5552 PyModule_AddIntMacro(m, PACKET_MULTICAST);
5553#endif
5554#ifdef PACKET_OTHERHOST
5555 PyModule_AddIntMacro(m, PACKET_OTHERHOST);
5556#endif
5557#ifdef PACKET_OUTGOING
5558 PyModule_AddIntMacro(m, PACKET_OUTGOING);
5559#endif
5560#ifdef PACKET_LOOPBACK
5561 PyModule_AddIntMacro(m, PACKET_LOOPBACK);
5562#endif
5563#ifdef PACKET_FASTROUTE
5564 PyModule_AddIntMacro(m, PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00005565#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00005566
Christian Heimes043d6f62008-01-07 17:19:16 +00005567#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005568 PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
Christian Heimes043d6f62008-01-07 17:19:16 +00005569
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005570 /* for addresses */
5571 PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
5572 PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
5573 PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
Christian Heimes043d6f62008-01-07 17:19:16 +00005574
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005575 PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
5576 PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
5577 PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
Christian Heimes043d6f62008-01-07 17:19:16 +00005578
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005579 /* for setsockopt() */
5580 PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
5581 PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
5582 PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
5583 PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
5584 TIPC_DEST_DROPPABLE);
5585 PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
Christian Heimes043d6f62008-01-07 17:19:16 +00005586
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005587 PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
5588 TIPC_LOW_IMPORTANCE);
5589 PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
5590 TIPC_MEDIUM_IMPORTANCE);
5591 PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
5592 TIPC_HIGH_IMPORTANCE);
5593 PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
5594 TIPC_CRITICAL_IMPORTANCE);
Christian Heimes043d6f62008-01-07 17:19:16 +00005595
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005596 /* for subscriptions */
5597 PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
5598 PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
Christian Heimes25bb7832008-01-11 16:17:00 +00005599#ifdef TIPC_SUB_CANCEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005600 /* doesn't seem to be available everywhere */
5601 PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
Christian Heimes25bb7832008-01-11 16:17:00 +00005602#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005603 PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
5604 PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
5605 PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
5606 PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
5607 PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
5608 PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
Christian Heimes043d6f62008-01-07 17:19:16 +00005609#endif
5610
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005611 /* Socket types */
5612 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
5613 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00005614/* We have incomplete socket support. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005615 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
5616 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00005617#if defined(SOCK_RDM)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005618 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00005619#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +00005620#ifdef SOCK_CLOEXEC
5621 PyModule_AddIntConstant(m, "SOCK_CLOEXEC", SOCK_CLOEXEC);
5622#endif
5623#ifdef SOCK_NONBLOCK
5624 PyModule_AddIntConstant(m, "SOCK_NONBLOCK", SOCK_NONBLOCK);
5625#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005626
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005627#ifdef SO_DEBUG
5628 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005629#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005630#ifdef SO_ACCEPTCONN
5631 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005632#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005633#ifdef SO_REUSEADDR
5634 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005635#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00005636#ifdef SO_EXCLUSIVEADDRUSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005637 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00005638#endif
5639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005640#ifdef SO_KEEPALIVE
5641 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005642#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005643#ifdef SO_DONTROUTE
5644 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005645#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005646#ifdef SO_BROADCAST
5647 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005648#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005649#ifdef SO_USELOOPBACK
5650 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005651#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005652#ifdef SO_LINGER
5653 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005654#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005655#ifdef SO_OOBINLINE
5656 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005657#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005658#ifdef SO_REUSEPORT
5659 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005660#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005661#ifdef SO_SNDBUF
5662 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005663#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005664#ifdef SO_RCVBUF
5665 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005666#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005667#ifdef SO_SNDLOWAT
5668 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005669#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005670#ifdef SO_RCVLOWAT
5671 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005672#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005673#ifdef SO_SNDTIMEO
5674 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005675#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005676#ifdef SO_RCVTIMEO
5677 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005678#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005679#ifdef SO_ERROR
5680 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005681#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005682#ifdef SO_TYPE
5683 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005684#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005685#ifdef SO_SETFIB
5686 PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
Larry Hastingsf0f37952010-04-02 11:47:10 +00005687#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005688#ifdef SO_PASSCRED
5689 PyModule_AddIntConstant(m, "SO_PASSCRED", SO_PASSCRED);
5690#endif
5691#ifdef SO_PEERCRED
5692 PyModule_AddIntConstant(m, "SO_PEERCRED", SO_PEERCRED);
5693#endif
5694#ifdef LOCAL_PEERCRED
5695 PyModule_AddIntConstant(m, "LOCAL_PEERCRED", LOCAL_PEERCRED);
5696#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005697
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005698 /* Maximum number of connections for "listen" */
5699#ifdef SOMAXCONN
5700 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005701#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005702 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005703#endif
5704
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005705 /* Ancilliary message types */
5706#ifdef SCM_RIGHTS
5707 PyModule_AddIntConstant(m, "SCM_RIGHTS", SCM_RIGHTS);
5708#endif
5709#ifdef SCM_CREDENTIALS
5710 PyModule_AddIntConstant(m, "SCM_CREDENTIALS", SCM_CREDENTIALS);
5711#endif
5712#ifdef SCM_CREDS
5713 PyModule_AddIntConstant(m, "SCM_CREDS", SCM_CREDS);
5714#endif
5715
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005716 /* Flags for send, recv */
5717#ifdef MSG_OOB
5718 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005719#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005720#ifdef MSG_PEEK
5721 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005722#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005723#ifdef MSG_DONTROUTE
5724 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005725#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005726#ifdef MSG_DONTWAIT
5727 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00005728#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005729#ifdef MSG_EOR
5730 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005731#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005732#ifdef MSG_TRUNC
5733 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005734#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005735#ifdef MSG_CTRUNC
5736 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005737#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005738#ifdef MSG_WAITALL
5739 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005740#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005741#ifdef MSG_BTAG
5742 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005743#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005744#ifdef MSG_ETAG
5745 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005746#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005747#ifdef MSG_NOSIGNAL
5748 PyModule_AddIntConstant(m, "MSG_NOSIGNAL", MSG_NOSIGNAL);
5749#endif
5750#ifdef MSG_NOTIFICATION
5751 PyModule_AddIntConstant(m, "MSG_NOTIFICATION", MSG_NOTIFICATION);
5752#endif
5753#ifdef MSG_CMSG_CLOEXEC
5754 PyModule_AddIntConstant(m, "MSG_CMSG_CLOEXEC", MSG_CMSG_CLOEXEC);
5755#endif
5756#ifdef MSG_ERRQUEUE
5757 PyModule_AddIntConstant(m, "MSG_ERRQUEUE", MSG_ERRQUEUE);
5758#endif
5759#ifdef MSG_CONFIRM
5760 PyModule_AddIntConstant(m, "MSG_CONFIRM", MSG_CONFIRM);
5761#endif
5762#ifdef MSG_MORE
5763 PyModule_AddIntConstant(m, "MSG_MORE", MSG_MORE);
5764#endif
5765#ifdef MSG_EOF
5766 PyModule_AddIntConstant(m, "MSG_EOF", MSG_EOF);
5767#endif
5768#ifdef MSG_BCAST
5769 PyModule_AddIntConstant(m, "MSG_BCAST", MSG_BCAST);
5770#endif
5771#ifdef MSG_MCAST
5772 PyModule_AddIntConstant(m, "MSG_MCAST", MSG_MCAST);
5773#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005774
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005775 /* Protocol level and numbers, usable for [gs]etsockopt */
5776#ifdef SOL_SOCKET
5777 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005778#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005779#ifdef SOL_IP
5780 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00005781#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005782 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00005783#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005784#ifdef SOL_IPX
5785 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00005786#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005787#ifdef SOL_AX25
5788 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00005789#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005790#ifdef SOL_ATALK
5791 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00005792#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005793#ifdef SOL_NETROM
5794 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00005795#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005796#ifdef SOL_ROSE
5797 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00005798#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005799#ifdef SOL_TCP
5800 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00005801#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005802 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00005803#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005804#ifdef SOL_UDP
5805 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00005806#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005807 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00005808#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005809#ifdef IPPROTO_IP
5810 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00005811#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005812 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005813#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005814#ifdef IPPROTO_HOPOPTS
5815 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005816#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005817#ifdef IPPROTO_ICMP
5818 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00005819#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005820 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005821#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005822#ifdef IPPROTO_IGMP
5823 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005824#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005825#ifdef IPPROTO_GGP
5826 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005827#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005828#ifdef IPPROTO_IPV4
5829 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005830#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005831#ifdef IPPROTO_IPV6
5832 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisa0f17342003-10-03 13:56:20 +00005833#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005834#ifdef IPPROTO_IPIP
5835 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005836#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005837#ifdef IPPROTO_TCP
5838 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00005839#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005840 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005841#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005842#ifdef IPPROTO_EGP
5843 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005844#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005845#ifdef IPPROTO_PUP
5846 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005847#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005848#ifdef IPPROTO_UDP
5849 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00005850#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005851 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005852#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005853#ifdef IPPROTO_IDP
5854 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005855#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005856#ifdef IPPROTO_HELLO
5857 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005858#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005859#ifdef IPPROTO_ND
5860 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005861#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005862#ifdef IPPROTO_TP
5863 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005864#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005865#ifdef IPPROTO_IPV6
5866 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005867#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005868#ifdef IPPROTO_ROUTING
5869 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005870#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005871#ifdef IPPROTO_FRAGMENT
5872 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005873#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005874#ifdef IPPROTO_RSVP
5875 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005876#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005877#ifdef IPPROTO_GRE
5878 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005879#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005880#ifdef IPPROTO_ESP
5881 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005882#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005883#ifdef IPPROTO_AH
5884 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005885#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005886#ifdef IPPROTO_MOBILE
5887 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005888#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005889#ifdef IPPROTO_ICMPV6
5890 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005891#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005892#ifdef IPPROTO_NONE
5893 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005894#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005895#ifdef IPPROTO_DSTOPTS
5896 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005897#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005898#ifdef IPPROTO_XTP
5899 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005900#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005901#ifdef IPPROTO_EON
5902 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005903#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005904#ifdef IPPROTO_PIM
5905 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005906#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005907#ifdef IPPROTO_IPCOMP
5908 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005909#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005910#ifdef IPPROTO_VRRP
5911 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005912#endif
Nick Coghlan96fe56a2011-08-22 11:55:57 +10005913#ifdef IPPROTO_SCTP
5914 PyModule_AddIntConstant(m, "IPPROTO_SCTP", IPPROTO_SCTP);
5915#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005916#ifdef IPPROTO_BIP
5917 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005918#endif
5919/**/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005920#ifdef IPPROTO_RAW
5921 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00005922#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005923 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005924#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005925#ifdef IPPROTO_MAX
5926 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005927#endif
5928
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005929 /* Some port configuration */
5930#ifdef IPPORT_RESERVED
5931 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005932#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005933 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005934#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005935#ifdef IPPORT_USERRESERVED
5936 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005937#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005938 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005939#endif
5940
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005941 /* Some reserved IP v.4 addresses */
5942#ifdef INADDR_ANY
5943 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005944#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005945 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005946#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005947#ifdef INADDR_BROADCAST
5948 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005949#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005950 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005951#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005952#ifdef INADDR_LOOPBACK
5953 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005954#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005955 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005956#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005957#ifdef INADDR_UNSPEC_GROUP
5958 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005959#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005960 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005961#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005962#ifdef INADDR_ALLHOSTS_GROUP
5963 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
5964 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005965#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005966 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005967#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005968#ifdef INADDR_MAX_LOCAL_GROUP
5969 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
5970 INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005971#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005972 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005973#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005974#ifdef INADDR_NONE
5975 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005976#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005977 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005978#endif
5979
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005980 /* IPv4 [gs]etsockopt options */
5981#ifdef IP_OPTIONS
5982 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005983#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005984#ifdef IP_HDRINCL
5985 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005986#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005987#ifdef IP_TOS
5988 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005989#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005990#ifdef IP_TTL
5991 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005992#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005993#ifdef IP_RECVOPTS
5994 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005995#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005996#ifdef IP_RECVRETOPTS
5997 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005998#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005999#ifdef IP_RECVDSTADDR
6000 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006001#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006002#ifdef IP_RETOPTS
6003 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006004#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006005#ifdef IP_MULTICAST_IF
6006 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006007#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006008#ifdef IP_MULTICAST_TTL
6009 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006010#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006011#ifdef IP_MULTICAST_LOOP
6012 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006013#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006014#ifdef IP_ADD_MEMBERSHIP
6015 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006016#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006017#ifdef IP_DROP_MEMBERSHIP
6018 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00006019#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006020#ifdef IP_DEFAULT_MULTICAST_TTL
6021 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
6022 IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00006023#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006024#ifdef IP_DEFAULT_MULTICAST_LOOP
6025 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
6026 IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00006027#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006028#ifdef IP_MAX_MEMBERSHIPS
6029 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00006030#endif
6031
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006032 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
6033#ifdef IPV6_JOIN_GROUP
6034 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006035#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006036#ifdef IPV6_LEAVE_GROUP
6037 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006038#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006039#ifdef IPV6_MULTICAST_HOPS
6040 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006041#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006042#ifdef IPV6_MULTICAST_IF
6043 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006044#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006045#ifdef IPV6_MULTICAST_LOOP
6046 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006047#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006048#ifdef IPV6_UNICAST_HOPS
6049 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006050#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006051 /* Additional IPV6 socket options, defined in RFC 3493 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00006052#ifdef IPV6_V6ONLY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006053 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006054#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006055 /* Advanced IPV6 socket options, from RFC 3542 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00006056#ifdef IPV6_CHECKSUM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006057 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006058#endif
6059#ifdef IPV6_DONTFRAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006060 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006061#endif
6062#ifdef IPV6_DSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006063 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006064#endif
6065#ifdef IPV6_HOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006066 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006067#endif
6068#ifdef IPV6_HOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006069 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006070#endif
6071#ifdef IPV6_NEXTHOP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006072 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006073#endif
6074#ifdef IPV6_PATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006075 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006076#endif
6077#ifdef IPV6_PKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006078 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006079#endif
6080#ifdef IPV6_RECVDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006081 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006082#endif
6083#ifdef IPV6_RECVHOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006084 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006085#endif
6086#ifdef IPV6_RECVHOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006087 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006088#endif
6089#ifdef IPV6_RECVPKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006090 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006091#endif
6092#ifdef IPV6_RECVRTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006093 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006094#endif
6095#ifdef IPV6_RECVTCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006096 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006097#endif
6098#ifdef IPV6_RTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006099 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006100#endif
6101#ifdef IPV6_RTHDRDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006102 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006103#endif
6104#ifdef IPV6_RTHDR_TYPE_0
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006105 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006106#endif
6107#ifdef IPV6_RECVPATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006108 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006109#endif
6110#ifdef IPV6_TCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006111 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006112#endif
6113#ifdef IPV6_USE_MIN_MTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006114 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006115#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00006116
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006117 /* TCP options */
6118#ifdef TCP_NODELAY
6119 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00006120#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006121#ifdef TCP_MAXSEG
6122 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00006123#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006124#ifdef TCP_CORK
6125 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006126#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006127#ifdef TCP_KEEPIDLE
6128 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006129#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006130#ifdef TCP_KEEPINTVL
6131 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006132#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006133#ifdef TCP_KEEPCNT
6134 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006135#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006136#ifdef TCP_SYNCNT
6137 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006138#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006139#ifdef TCP_LINGER2
6140 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006141#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006142#ifdef TCP_DEFER_ACCEPT
6143 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006144#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006145#ifdef TCP_WINDOW_CLAMP
6146 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006147#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006148#ifdef TCP_INFO
6149 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006150#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006151#ifdef TCP_QUICKACK
6152 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00006153#endif
6154
Guido van Rossum09be4091999-08-09 14:40:40 +00006155
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006156 /* IPX options */
6157#ifdef IPX_TYPE
6158 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00006159#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00006160
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006161 /* get{addr,name}info parameters */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006162#ifdef EAI_ADDRFAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006163 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006164#endif
6165#ifdef EAI_AGAIN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006166 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006167#endif
6168#ifdef EAI_BADFLAGS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006169 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006170#endif
6171#ifdef EAI_FAIL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006172 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006173#endif
6174#ifdef EAI_FAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006175 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006176#endif
6177#ifdef EAI_MEMORY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006178 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006179#endif
6180#ifdef EAI_NODATA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006181 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006182#endif
6183#ifdef EAI_NONAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006184 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006185#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00006186#ifdef EAI_OVERFLOW
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006187 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006188#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006189#ifdef EAI_SERVICE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006190 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006191#endif
6192#ifdef EAI_SOCKTYPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006193 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006194#endif
6195#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006196 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006197#endif
6198#ifdef EAI_BADHINTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006199 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006200#endif
6201#ifdef EAI_PROTOCOL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006202 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006203#endif
6204#ifdef EAI_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006205 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006206#endif
6207#ifdef AI_PASSIVE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006208 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006209#endif
6210#ifdef AI_CANONNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006211 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006212#endif
6213#ifdef AI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006214 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006215#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00006216#ifdef AI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006217 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
Martin v. Löwisda91d022003-12-30 11:14:01 +00006218#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006219#ifdef AI_MASK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006220 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006221#endif
6222#ifdef AI_ALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006223 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006224#endif
6225#ifdef AI_V4MAPPED_CFG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006226 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006227#endif
6228#ifdef AI_ADDRCONFIG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006229 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006230#endif
6231#ifdef AI_V4MAPPED
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006232 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006233#endif
6234#ifdef AI_DEFAULT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006235 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006236#endif
6237#ifdef NI_MAXHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006238 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006239#endif
6240#ifdef NI_MAXSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006241 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006242#endif
6243#ifdef NI_NOFQDN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006244 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006245#endif
6246#ifdef NI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006247 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006248#endif
6249#ifdef NI_NAMEREQD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006250 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006251#endif
6252#ifdef NI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006253 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006254#endif
6255#ifdef NI_DGRAM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006256 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00006257#endif
6258
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006259 /* shutdown() parameters */
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006260#ifdef SHUT_RD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006261 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006262#elif defined(SD_RECEIVE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006263 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006264#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006265 PyModule_AddIntConstant(m, "SHUT_RD", 0);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006266#endif
6267#ifdef SHUT_WR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006268 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006269#elif defined(SD_SEND)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006270 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006271#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006272 PyModule_AddIntConstant(m, "SHUT_WR", 1);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006273#endif
6274#ifdef SHUT_RDWR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006275 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006276#elif defined(SD_BOTH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006277 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006278#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006279 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00006280#endif
6281
Christian Heimesfaf2f632008-01-06 16:59:19 +00006282#ifdef SIO_RCVALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006283 {
6284 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
6285 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
6286 int i;
6287 for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {
6288 PyObject *tmp;
6289 tmp = PyLong_FromUnsignedLong(codes[i]);
6290 if (tmp == NULL)
6291 return NULL;
6292 PyModule_AddObject(m, names[i], tmp);
6293 }
6294 }
6295 PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
6296 PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
6297 PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00006298#ifdef RCVALL_IPLEVEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006299 PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00006300#endif
6301#ifdef RCVALL_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006302 PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00006303#endif
Christian Heimesfaf2f632008-01-06 16:59:19 +00006304#endif /* _MSTCPIP_ */
6305
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006306 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00006307#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006308 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00006309#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006310 return m;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00006311}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006312
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006313
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006314#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +00006315#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006316
6317/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00006318/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006319
Guido van Rossum3eede5a2002-06-07 02:08:35 +00006320int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006321inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006322{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006323 if (af == AF_INET) {
Benjamin Petersonf91df042009-02-13 02:50:59 +00006324#if (SIZEOF_INT != 4)
6325#error "Not sure if in_addr_t exists and int is not 32-bits."
6326#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006327 unsigned int packed_addr;
6328 packed_addr = inet_addr(src);
6329 if (packed_addr == INADDR_NONE)
6330 return 0;
6331 memcpy(dst, &packed_addr, 4);
6332 return 1;
6333 }
6334 /* Should set errno to EAFNOSUPPORT */
6335 return -1;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006336}
6337
Martin v. Löwisc925b1532001-07-21 09:42:15 +00006338const char *
6339inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006340{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006341 if (af == AF_INET) {
6342 struct in_addr packed_addr;
6343 if (size < 16)
6344 /* Should set errno to ENOSPC. */
6345 return NULL;
6346 memcpy(&packed_addr, src, sizeof(packed_addr));
6347 return strncpy(dst, inet_ntoa(packed_addr), size);
6348 }
6349 /* Should set errno to EAFNOSUPPORT */
6350 return NULL;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006351}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00006352
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00006353#endif
Christian Heimesb6150692007-11-15 23:37:07 +00006354#endif