blob: 687d964886898909f23ba8d4d20e28cfc420a3d1 [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)
Guido van Rossum6574b3e1991-06-25 21:36:08 +000045- an Internet socket address is a pair (hostname, port)
46 where hostname can be anything recognized by gethostbyname()
47 (including the dd.dd.dd.dd notation) and port is in host byte order
48- where a hostname is returned, the dd.dd.dd.dd notation is used
Guido van Rossum27e177d1995-03-16 15:43:47 +000049- a UNIX domain socket address is a string specifying the pathname
Jeremy Hylton22308652001-02-02 03:23:09 +000050- an AF_PACKET socket address is a tuple containing a string
51 specifying the ethernet interface and an integer specifying
52 the Ethernet protocol number to be received. For example:
Jeremy Hyltondbfb6622001-02-02 19:55:17 +000053 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
Andrew M. Kuchlingb8e17172004-07-10 23:39:35 +000054 specify packet-type and ha-type/addr.
Christian Heimes043d6f62008-01-07 17:19:16 +000055- an AF_TIPC socket address is expressed as
56 (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000057 TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
Christian Heimes043d6f62008-01-07 17:19:16 +000058 and scope can be one of:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000059 TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
Christian Heimes043d6f62008-01-07 17:19:16 +000060 The meaning of v1, v2 and v3 depends on the value of addr_type:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000061 if addr_type is TIPC_ADDR_NAME:
62 v1 is the server type
63 v2 is the port identifier
64 v3 is ignored
65 if addr_type is TIPC_ADDR_NAMESEQ:
66 v1 is the server type
67 v2 is the lower port number
68 v3 is the upper port number
69 if addr_type is TIPC_ADDR_ID:
70 v1 is the node
71 v2 is the ref
72 v3 is ignored
Christian Heimes043d6f62008-01-07 17:19:16 +000073
Guido van Rossum6574b3e1991-06-25 21:36:08 +000074
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000075Local naming conventions:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000076
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000077- names starting with sock_ are socket object methods
78- names starting with socket_ are module-level functions
79- names starting with PySocket are exported through socketmodule.h
Guido van Rossum30a685f1991-06-27 15:51:29 +000080
Guido van Rossum6574b3e1991-06-25 21:36:08 +000081*/
82
Thomas Wouters477c8d52006-05-27 19:21:47 +000083#ifdef __APPLE__
84 /*
85 * inet_aton is not available on OSX 10.3, yet we want to use a binary
86 * that was build on 10.4 or later to work on that release, weak linking
87 * comes to the rescue.
88 */
89# pragma weak inet_aton
90#endif
91
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000092#include "Python.h"
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000093#include "structmember.h"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000094
Guido van Rossum47dfa4a2003-04-25 05:48:32 +000095#undef MAX
96#define MAX(x, y) ((x) < (y) ? (y) : (x))
97
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000098/* Socket object documentation */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000099PyDoc_STRVAR(sock_doc,
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000100"socket([family[, type[, proto]]]) -> socket object\n\
101\n\
102Open a socket of the given type. The family argument specifies the\n\
103address family; it defaults to AF_INET. The type argument specifies\n\
104whether this is a stream (SOCK_STREAM, this is the default)\n\
105or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
106specifying the default protocol. Keyword arguments are accepted.\n\
107\n\
108A socket object represents one endpoint of a network connection.\n\
109\n\
110Methods of socket objects (keyword arguments not allowed):\n\
111\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000112_accept() -- accept connection, returning new socket fd and client address\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000113bind(addr) -- bind the socket to a local address\n\
114close() -- close the socket\n\
115connect(addr) -- connect the socket to a remote address\n\
116connect_ex(addr) -- connect, return an error code instead of an exception\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000117_dup() -- return a new socket fd duplicated from fileno()\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000118fileno() -- return underlying file descriptor\n\
119getpeername() -- return remote address [*]\n\
120getsockname() -- return local address\n\
121getsockopt(level, optname[, buflen]) -- get socket options\n\
122gettimeout() -- return timeout or None\n\
123listen(n) -- start listening for incoming connections\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000124recv(buflen[, flags]) -- receive data\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000125recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000126recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +0000127recvfrom_into(buffer[, nbytes, [, flags])\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +0000128 -- receive data and sender\'s address (into a buffer)\n\
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000129sendall(data[, flags]) -- send all data\n\
130send(data[, flags]) -- send data, may not send all of it\n\
131sendto(data[, flags], addr) -- send data to a given address\n\
132setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
133setsockopt(level, optname, value) -- set socket options\n\
134settimeout(None | float) -- set or clear the timeout\n\
135shutdown(how) -- shut down traffic in one or both directions\n\
136\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000137 [*] not available on all platforms!");
Guido van Rossum3baaa131999-03-22 21:44:51 +0000138
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000139/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000140 I hope some day someone can clean this up please... */
141
Guido van Rossum9376b741999-09-15 22:01:40 +0000142/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
143 script doesn't get this right, so we hardcode some platform checks below.
144 On the other hand, not all Linux versions agree, so there the settings
145 computed by the configure script are needed! */
146
147#ifndef linux
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000148# undef HAVE_GETHOSTBYNAME_R_3_ARG
149# undef HAVE_GETHOSTBYNAME_R_5_ARG
150# undef HAVE_GETHOSTBYNAME_R_6_ARG
Guido van Rossum9376b741999-09-15 22:01:40 +0000151#endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000152
Guido van Rossum7a122991999-04-13 04:07:32 +0000153#ifndef WITH_THREAD
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000154# undef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +0000155#endif
156
Guido van Rossume7de2061999-03-24 17:24:33 +0000157#ifdef HAVE_GETHOSTBYNAME_R
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000158# if defined(_AIX) || defined(__osf__)
159# define HAVE_GETHOSTBYNAME_R_3_ARG
160# elif defined(__sun) || defined(__sgi)
161# define HAVE_GETHOSTBYNAME_R_5_ARG
162# elif defined(linux)
Guido van Rossum9376b741999-09-15 22:01:40 +0000163/* Rely on the configure script */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000164# else
165# undef HAVE_GETHOSTBYNAME_R
166# endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000167#endif
168
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000169#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
170 !defined(MS_WINDOWS)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000171# define USE_GETHOSTBYNAME_LOCK
Guido van Rossum3baaa131999-03-22 21:44:51 +0000172#endif
173
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000174/* To use __FreeBSD_version */
175#ifdef HAVE_SYS_PARAM_H
176#include <sys/param.h>
177#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000178/* On systems on which getaddrinfo() is believed to not be thread-safe,
Just van Rossum09aecd72003-05-09 08:03:44 +0000179 (this includes the getaddrinfo emulation) protect access with a lock. */
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000180#if defined(WITH_THREAD) && (defined(__APPLE__) || \
181 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000182 defined(__OpenBSD__) || defined(__NetBSD__) || \
183 defined(__VMS) || !defined(HAVE_GETADDRINFO))
Just van Rossum1040d2c2003-05-09 07:53:18 +0000184#define USE_GETADDRINFO_LOCK
185#endif
186
187#ifdef USE_GETADDRINFO_LOCK
188#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
189#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
190#else
191#define ACQUIRE_GETADDRINFO_LOCK
192#define RELEASE_GETADDRINFO_LOCK
193#endif
194
195#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000196# include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000197#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000198
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000199#if defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000200# include <types.h>
201# include <io.h>
202# include <sys/ioctl.h>
203# include <utils.h>
204# include <ctype.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000205#endif
206
Martin v. Löwis9e437302002-12-06 12:57:26 +0000207#if defined(__VMS)
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000208# include <ioctl.h>
209#endif
210
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000211#if defined(PYOS_OS2)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000212# define INCL_DOS
213# define INCL_DOSERRORS
214# define INCL_NOPMAPI
215# include <os2.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000216#endif
217
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000218#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000219/* make sure that the reentrant (gethostbyaddr_r etc)
220 functions are declared correctly if compiling with
221 MIPSPro 7.x in ANSI C mode (default) */
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000222
Thomas Wouters477c8d52006-05-27 19:21:47 +0000223/* XXX Using _SGIAPI is the wrong thing,
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000224 but I don't know what the right thing is. */
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000225#undef _SGIAPI /* to avoid warning */
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000226#define _SGIAPI 1
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000227
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000228#undef _XOPEN_SOURCE
229#include <sys/socket.h>
230#include <sys/types.h>
231#include <netinet/in.h>
232#ifdef _SS_ALIGNSIZE
233#define HAVE_GETADDRINFO 1
234#define HAVE_GETNAMEINFO 1
235#endif
236
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000237#define HAVE_INET_PTON
238#include <netdb.h>
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000239#endif
240
Thomas Wouters477c8d52006-05-27 19:21:47 +0000241/* Irix 6.5 fails to define this variable at all. This is needed
242 for both GCC and SGI's compiler. I'd say that the SGI headers
Georg Brandldbd83392006-02-20 09:42:33 +0000243 are just busted. Same thing for Solaris. */
244#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000245#define INET_ADDRSTRLEN 16
246#endif
247
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000248/* Generic includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000249#ifdef HAVE_SYS_TYPES_H
Guido van Rossumb6775db1994-08-01 11:34:53 +0000250#include <sys/types.h>
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000251#endif
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000252
Marc-André Lemburg976ade62002-02-16 18:47:07 +0000253/* Generic socket object definitions and includes */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000254#define PySocket_BUILDING_SOCKET
Marc-André Lemburgbb8b78b2002-02-16 18:44:52 +0000255#include "socketmodule.h"
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000256
257/* Addressing includes */
258
Guido van Rossum6f489d91996-06-28 20:15:15 +0000259#ifndef MS_WINDOWS
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000260
261/* Non-MS WINDOWS includes */
262# include <netdb.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000263
Guido van Rossum9376b741999-09-15 22:01:40 +0000264/* Headers needed for inet_ntoa() and inet_addr() */
Skip Montanaroeb33e5a2007-08-17 12:57:41 +0000265# if defined(PYOS_OS2) && defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000266# include <netdb.h>
Tim Peters603c6832001-11-05 02:45:59 +0000267typedef size_t socklen_t;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000268# else
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000269# include <arpa/inet.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000270# endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000271
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000272# include <fcntl.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000273
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000274#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000275
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000276/* MS_WINDOWS includes */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000277# ifdef HAVE_FCNTL_H
278# include <fcntl.h>
279# endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000280
Jeremy Hylton22308652001-02-02 03:23:09 +0000281#endif
282
Skip Montanaro7befb992004-02-10 16:50:21 +0000283#include <stddef.h>
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000284
285#ifndef offsetof
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000286# define offsetof(type, member) ((size_t)(&((type *)0)->member))
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000287#endif
288
Neal Norwitz39d22e52002-11-02 19:55:21 +0000289#ifndef O_NONBLOCK
290# define O_NONBLOCK O_NDELAY
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000291#endif
292
Trent Micka708d6e2004-09-07 17:48:26 +0000293/* include Python's addrinfo.h unless it causes trouble */
294#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
295 /* Do not include addinfo.h on some newer IRIX versions.
296 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
297 * for example, but not by 6.5.10.
298 */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000299#elif defined(_MSC_VER) && _MSC_VER>1201
Trent Micka708d6e2004-09-07 17:48:26 +0000300 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
301 * EAI_* constants are defined in (the already included) ws2tcpip.h.
302 */
303#else
304# include "addrinfo.h"
305#endif
Jason Tishlerc246cb72004-08-09 13:25:59 +0000306
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000307#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +0000308#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000309int inet_pton(int af, const char *src, void *dst);
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000310const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000311#endif
Christian Heimesb6150692007-11-15 23:37:07 +0000312#endif
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000313
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000314#ifdef __APPLE__
315/* On OS X, getaddrinfo returns no error indication of lookup
316 failure, so we must use the emulation instead of the libinfo
317 implementation. Unfortunately, performing an autoconf test
318 for this bug would require DNS access for the machine performing
319 the configuration, which is not acceptable. Therefore, we
320 determine the bug just by checking for __APPLE__. If this bug
321 gets ever fixed, perhaps checking for sys/version.h would be
322 appropriate, which is 10/0 on the system with the bug. */
Jack Jansen84262fb2002-07-02 14:40:42 +0000323#ifndef HAVE_GETNAMEINFO
324/* This bug seems to be fixed in Jaguar. Ths easiest way I could
325 Find to check for Jaguar is that it has getnameinfo(), which
326 older releases don't have */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000327#undef HAVE_GETADDRINFO
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000328#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000329
330#ifdef HAVE_INET_ATON
331#define USE_INET_ATON_WEAKLINK
332#endif
333
Jack Jansen84262fb2002-07-02 14:40:42 +0000334#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000335
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000336/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000337#if !defined(HAVE_GETADDRINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000338/* avoid clashes with the C library definition of the symbol. */
339#define getaddrinfo fake_getaddrinfo
340#define gai_strerror fake_gai_strerror
341#define freeaddrinfo fake_freeaddrinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000342#include "getaddrinfo.c"
343#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000344#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000345#define getnameinfo fake_getnameinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000346#include "getnameinfo.c"
347#endif
348
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000349#ifdef MS_WINDOWS
350/* On Windows a socket is really a handle not an fd */
351static SOCKET
352dup_socket(SOCKET handle)
353{
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000354 WSAPROTOCOL_INFO info;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000355
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000356 if (WSADuplicateSocket(handle, GetCurrentProcessId(), &info))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000357 return INVALID_SOCKET;
Daniel Stutzbach6c765282010-09-03 12:38:33 +0000358
359 return WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
360 FROM_PROTOCOL_INFO, &info, 0, 0);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000361}
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000362#define SOCKETCLOSE closesocket
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000363#else
364/* On Unix we can use dup to duplicate the file descriptor of a socket*/
365#define dup_socket(fd) dup(fd)
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000366#endif
367
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000368#ifdef MS_WIN32
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000369#define EAFNOSUPPORT WSAEAFNOSUPPORT
370#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000371#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000372
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000373#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000374#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000375#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000376#endif
377
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000378#ifndef SOCKETCLOSE
379#define SOCKETCLOSE close
380#endif
381
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000382#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000383#define USE_BLUETOOTH 1
384#if defined(__FreeBSD__)
385#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
386#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
Thomas Wouterscf297e42007-02-23 15:07:44 +0000387#define BTPROTO_HCI BLUETOOTH_PROTO_HCI
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000388#define SOL_HCI SOL_HCI_RAW
389#define HCI_FILTER SO_HCI_RAW_FILTER
Hye-Shik Chang81268602004-02-02 06:05:24 +0000390#define sockaddr_l2 sockaddr_l2cap
391#define sockaddr_rc sockaddr_rfcomm
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000392#define hci_dev hci_node
Hye-Shik Chang81268602004-02-02 06:05:24 +0000393#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
394#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000395#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000396#elif defined(__NetBSD__) || defined(__DragonFly__)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000397#define sockaddr_l2 sockaddr_bt
398#define sockaddr_rc sockaddr_bt
Thomas Wouterscf297e42007-02-23 15:07:44 +0000399#define sockaddr_hci sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000400#define sockaddr_sco sockaddr_bt
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +0000401#define SOL_HCI BTPROTO_HCI
402#define HCI_DATA_DIR SO_HCI_DIRECTION
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000403#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
404#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000405#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000406#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000407#else
Hye-Shik Chang81268602004-02-02 06:05:24 +0000408#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
409#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000410#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000411#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
412#endif
413#endif
414
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000415#ifdef __VMS
416/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
417#define SEGMENT_SIZE (32 * 1024 -1)
418#endif
419
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000420#define SAS2SA(x) ((struct sockaddr *)(x))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000421
Martin v. Löwise9416172003-05-03 10:12:45 +0000422/*
423 * Constants for getnameinfo()
424 */
425#if !defined(NI_MAXHOST)
426#define NI_MAXHOST 1025
427#endif
428#if !defined(NI_MAXSERV)
429#define NI_MAXSERV 32
430#endif
431
Guido van Rossum7d0a8262007-05-21 23:13:11 +0000432#ifndef INVALID_SOCKET /* MS defines this */
433#define INVALID_SOCKET (-1)
434#endif
435
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000436/* XXX There's a problem here: *static* functions are not supposed to have
437 a Py prefix (or use CapitalizedWords). Later... */
438
Guido van Rossum30a685f1991-06-27 15:51:29 +0000439/* Global variable holding the exception type for errors detected
440 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000441static PyObject *socket_error;
442static PyObject *socket_herror;
443static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000444static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000445
Tim Peters643a7fc2002-02-17 04:13:21 +0000446/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000447 The sock_type variable contains pointers to various functions,
448 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000449 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000450static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000451
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000452#if defined(HAVE_POLL_H)
453#include <poll.h>
454#elif defined(HAVE_SYS_POLL_H)
455#include <sys/poll.h>
456#endif
457
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000458#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
459/* Platform can select file descriptors beyond FD_SETSIZE */
460#define IS_SELECTABLE(s) 1
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000461#elif defined(HAVE_POLL)
462/* Instead of select(), we'll use poll() since poll() works on any fd. */
463#define IS_SELECTABLE(s) 1
464/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000465#else
466/* POSIX says selecting file descriptors beyond FD_SETSIZE
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000467 has undefined behaviour. If there's no timeout left, we don't have to
468 call select, so it's a safe, little white lie. */
469#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000470#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000471
472static PyObject*
473select_error(void)
474{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000475 PyErr_SetString(socket_error, "unable to select on socket");
476 return NULL;
Neal Norwitz082b2df2006-02-07 07:04:46 +0000477}
478
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000479#ifdef MS_WINDOWS
Antoine Pitrouc8f01962010-09-28 22:03:27 +0000480#ifndef WSAEAGAIN
481#define WSAEAGAIN WSAEWOULDBLOCK
482#endif
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000483#define CHECK_ERRNO(expected) \
484 (WSAGetLastError() == WSA ## expected)
485#else
486#define CHECK_ERRNO(expected) \
487 (errno == expected)
488#endif
489
Guido van Rossum30a685f1991-06-27 15:51:29 +0000490/* Convenience function to raise an error according to errno
491 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000492
Guido van Rossum73624e91994-10-10 17:59:00 +0000493static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000494set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000495{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000496#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000497 int err_no = WSAGetLastError();
498 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
499 recognizes the error codes used by both GetLastError() and
500 WSAGetLastError */
501 if (err_no)
502 return PyErr_SetExcFromWindowsErr(socket_error, err_no);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000503#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000504
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000505#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000506 if (sock_errno() != NO_ERROR) {
507 APIRET rc;
508 ULONG msglen;
509 char outbuf[100];
510 int myerrorcode = sock_errno();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000511
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000512 /* Retrieve socket-related error message from MPTN.MSG file */
513 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
514 myerrorcode - SOCBASEERR + 26,
515 "mptn.msg",
516 &msglen);
517 if (rc == NO_ERROR) {
518 PyObject *v;
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000519
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000520 /* OS/2 doesn't guarantee a terminator */
521 outbuf[msglen] = '\0';
522 if (strlen(outbuf) > 0) {
523 /* If non-empty msg, trim CRLF */
524 char *lastc = &outbuf[ strlen(outbuf)-1 ];
525 while (lastc > outbuf &&
526 isspace(Py_CHARMASK(*lastc))) {
527 /* Trim trailing whitespace (CRLF) */
528 *lastc-- = '\0';
529 }
530 }
531 v = Py_BuildValue("(is)", myerrorcode, outbuf);
532 if (v != NULL) {
533 PyErr_SetObject(socket_error, v);
534 Py_DECREF(v);
535 }
536 return NULL;
537 }
538 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000539#endif
540
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 return PyErr_SetFromErrno(socket_error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000542}
543
Guido van Rossum30a685f1991-06-27 15:51:29 +0000544
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000545static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000546set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000547{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000548 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000549
550#ifdef HAVE_HSTRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000551 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000552#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000553 v = Py_BuildValue("(is)", h_error, "host not found");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000554#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000555 if (v != NULL) {
556 PyErr_SetObject(socket_herror, v);
557 Py_DECREF(v);
558 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000560 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000561}
562
563
564static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000565set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000566{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000567 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000568
Martin v. Löwis272cb402002-03-01 08:31:07 +0000569#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000570 /* EAI_SYSTEM is not available on Windows XP. */
571 if (error == EAI_SYSTEM)
572 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000573#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000574
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000575#ifdef HAVE_GAI_STRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000576 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000577#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000578 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000579#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000580 if (v != NULL) {
581 PyErr_SetObject(socket_gaierror, v);
582 Py_DECREF(v);
583 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000584
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000585 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000586}
587
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000588#ifdef __VMS
589/* Function to send in segments */
590static int
591sendsegmented(int sock_fd, char *buf, int len, int flags)
592{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000593 int n = 0;
594 int remaining = len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000595
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000596 while (remaining > 0) {
597 unsigned int segment;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000598
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000599 segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
600 n = send(sock_fd, buf, segment, flags);
601 if (n < 0) {
602 return n;
603 }
604 remaining -= segment;
605 buf += segment;
606 } /* end while */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000607
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000608 return len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000609}
610#endif
611
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000612/* Function to perform the setting of socket blocking mode
613 internally. block = (1 | 0). */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000614static int
615internal_setblocking(PySocketSockObject *s, int block)
616{
Guido van Rossum67f7a382002-06-06 21:08:16 +0000617#ifndef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000618 int delay_flag;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000619#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +0000620#ifdef SOCK_NONBLOCK
621 if (block)
622 s->sock_type &= (~SOCK_NONBLOCK);
623 else
624 s->sock_type |= SOCK_NONBLOCK;
625#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000626
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000627 Py_BEGIN_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000628#ifndef MS_WINDOWS
629#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000630 block = !block;
631 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000632#elif defined(__VMS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000633 block = !block;
634 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000635#else /* !PYOS_OS2 && !__VMS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000636 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
637 if (block)
638 delay_flag &= (~O_NONBLOCK);
639 else
640 delay_flag |= O_NONBLOCK;
641 fcntl(s->sock_fd, F_SETFL, delay_flag);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000642#endif /* !PYOS_OS2 */
643#else /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000644 block = !block;
645 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000646#endif /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000647 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000648
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000649 /* Since these don't return anything */
650 return 1;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000651}
652
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000653/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
Guido van Rossum11ba0942002-06-13 15:07:44 +0000654 The argument writing indicates the direction.
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000655 This does not raise an exception; we'll let our caller do that
656 after they've reacquired the interpreter lock.
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000657 Returns 1 on timeout, -1 on error, 0 otherwise. */
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000658static int
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000659internal_select_ex(PySocketSockObject *s, int writing, double interval)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000660{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000661 int n;
Guido van Rossum11ba0942002-06-13 15:07:44 +0000662
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000663 /* Nothing to do unless we're in timeout mode (not non-blocking) */
664 if (s->sock_timeout <= 0.0)
665 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000667 /* Guard against closed socket */
668 if (s->sock_fd < 0)
669 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000670
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000671 /* Handling this condition here simplifies the select loops */
672 if (interval < 0.0)
673 return 1;
674
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000675 /* Prefer poll, if available, since you can poll() any fd
676 * which can't be done with select(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000677#ifdef HAVE_POLL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000678 {
679 struct pollfd pollfd;
680 int timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000681
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000682 pollfd.fd = s->sock_fd;
683 pollfd.events = writing ? POLLOUT : POLLIN;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000684
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000685 /* s->sock_timeout is in seconds, timeout in ms */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000686 timeout = (int)(interval * 1000 + 0.5);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000687 n = poll(&pollfd, 1, timeout);
688 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000689#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000690 {
691 /* Construct the arguments to select */
692 fd_set fds;
693 struct timeval tv;
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000694 tv.tv_sec = (int)interval;
695 tv.tv_usec = (int)((interval - tv.tv_sec) * 1e6);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000696 FD_ZERO(&fds);
697 FD_SET(s->sock_fd, &fds);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000698
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000699 /* See if the socket is ready */
700 if (writing)
Antoine Pitrou19467d22010-08-17 19:33:30 +0000701 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
702 NULL, &fds, NULL, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000703 else
Antoine Pitrou19467d22010-08-17 19:33:30 +0000704 n = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
705 &fds, NULL, NULL, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000707#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000708
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000709 if (n < 0)
710 return -1;
711 if (n == 0)
712 return 1;
713 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000714}
715
Antoine Pitrou3e1fd272010-09-28 21:23:11 +0000716static int
717internal_select(PySocketSockObject *s, int writing)
718{
719 return internal_select_ex(s, writing, s->sock_timeout);
720}
721
722/*
723 Two macros for automatic retry of select() in case of false positives
724 (for example, select() could indicate a socket is ready for reading
725 but the data then discarded by the OS because of a wrong checksum).
726 Here is an example of use:
727
728 BEGIN_SELECT_LOOP(s)
729 Py_BEGIN_ALLOW_THREADS
730 timeout = internal_select_ex(s, 0, interval);
731 if (!timeout)
732 outlen = recv(s->sock_fd, cbuf, len, flags);
733 Py_END_ALLOW_THREADS
734 if (timeout == 1) {
735 PyErr_SetString(socket_timeout, "timed out");
736 return -1;
737 }
738 END_SELECT_LOOP(s)
739*/
740
741#define BEGIN_SELECT_LOOP(s) \
742 { \
743 _PyTime_timeval now, deadline = {0, 0}; \
744 double interval = s->sock_timeout; \
745 int has_timeout = s->sock_timeout > 0.0; \
746 if (has_timeout) { \
747 _PyTime_gettimeofday(&now); \
748 deadline = now; \
749 _PyTime_ADD_SECONDS(deadline, s->sock_timeout); \
750 } \
751 while (1) { \
752 errno = 0; \
753
754#define END_SELECT_LOOP(s) \
755 if (!has_timeout || \
756 (!CHECK_ERRNO(EWOULDBLOCK) && !CHECK_ERRNO(EAGAIN))) \
757 break; \
758 _PyTime_gettimeofday(&now); \
759 interval = _PyTime_INTERVAL(now, deadline); \
760 } \
761 } \
762
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000763/* Initialize a new socket object. */
764
Tim Petersa12b4cf2002-07-18 22:38:44 +0000765static double defaulttimeout = -1.0; /* Default timeout for new sockets */
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000766
Martin v. Löwis1a214512008-06-11 05:26:20 +0000767static void
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000768init_sockobject(PySocketSockObject *s,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000769 SOCKET_T fd, int family, int type, int proto)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000770{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000771 s->sock_fd = fd;
772 s->sock_family = family;
773 s->sock_type = type;
774 s->sock_proto = proto;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000775
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000776 s->errorhandler = &set_error;
Antoine Pitroub1c54962010-10-14 15:05:38 +0000777#ifdef SOCK_NONBLOCK
778 if (type & SOCK_NONBLOCK)
779 s->sock_timeout = 0.0;
780 else
781#endif
782 {
783 s->sock_timeout = defaulttimeout;
784 if (defaulttimeout >= 0.0)
785 internal_setblocking(s, 0);
786 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000787
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000788}
789
790
Guido van Rossum30a685f1991-06-27 15:51:29 +0000791/* Create a new socket object.
792 This just creates the object and initializes it.
793 If the creation fails, return NULL and set an exception (implicit
794 in NEWOBJ()). */
795
Guido van Rossum73624e91994-10-10 17:59:00 +0000796static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000797new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000798{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000799 PySocketSockObject *s;
800 s = (PySocketSockObject *)
801 PyType_GenericNew(&sock_type, NULL, NULL);
802 if (s != NULL)
803 init_sockobject(s, fd, family, type, proto);
804 return s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000805}
806
Guido van Rossum30a685f1991-06-27 15:51:29 +0000807
Guido van Rossum48a680c2001-03-02 06:34:14 +0000808/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000809 thread to be in gethostbyname or getaddrinfo */
810#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
811PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000812#endif
813
814
Guido van Rossum30a685f1991-06-27 15:51:29 +0000815/* Convert a string specifying a host name or one of a few symbolic
816 names to a numeric IP address. This usually calls gethostbyname()
817 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000818 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000819 an error occurred; then an exception is raised. */
820
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000821static int
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000822setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000823{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000824 struct addrinfo hints, *res;
825 int error;
826 int d1, d2, d3, d4;
827 char ch;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000828
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000829 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
830 if (name[0] == '\0') {
831 int siz;
832 memset(&hints, 0, sizeof(hints));
833 hints.ai_family = af;
834 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
835 hints.ai_flags = AI_PASSIVE;
836 Py_BEGIN_ALLOW_THREADS
837 ACQUIRE_GETADDRINFO_LOCK
838 error = getaddrinfo(NULL, "0", &hints, &res);
839 Py_END_ALLOW_THREADS
840 /* We assume that those thread-unsafe getaddrinfo() versions
841 *are* safe regarding their return value, ie. that a
842 subsequent call to getaddrinfo() does not destroy the
843 outcome of the first call. */
844 RELEASE_GETADDRINFO_LOCK
845 if (error) {
846 set_gaierror(error);
847 return -1;
848 }
849 switch (res->ai_family) {
850 case AF_INET:
851 siz = 4;
852 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000853#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000854 case AF_INET6:
855 siz = 16;
856 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000857#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000858 default:
859 freeaddrinfo(res);
860 PyErr_SetString(socket_error,
861 "unsupported address family");
862 return -1;
863 }
864 if (res->ai_next) {
865 freeaddrinfo(res);
866 PyErr_SetString(socket_error,
867 "wildcard resolved to multiple address");
868 return -1;
869 }
870 if (res->ai_addrlen < addr_ret_size)
871 addr_ret_size = res->ai_addrlen;
872 memcpy(addr_ret, res->ai_addr, addr_ret_size);
873 freeaddrinfo(res);
874 return siz;
875 }
876 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
877 struct sockaddr_in *sin;
878 if (af != AF_INET && af != AF_UNSPEC) {
879 PyErr_SetString(socket_error,
880 "address family mismatched");
881 return -1;
882 }
883 sin = (struct sockaddr_in *)addr_ret;
884 memset((void *) sin, '\0', sizeof(*sin));
885 sin->sin_family = AF_INET;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000886#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000887 sin->sin_len = sizeof(*sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000888#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000889 sin->sin_addr.s_addr = INADDR_BROADCAST;
890 return sizeof(sin->sin_addr);
891 }
892 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
893 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
894 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
895 struct sockaddr_in *sin;
896 sin = (struct sockaddr_in *)addr_ret;
897 sin->sin_addr.s_addr = htonl(
898 ((long) d1 << 24) | ((long) d2 << 16) |
899 ((long) d3 << 8) | ((long) d4 << 0));
900 sin->sin_family = AF_INET;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000901#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000902 sin->sin_len = sizeof(*sin);
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000903#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000904 return 4;
905 }
906 memset(&hints, 0, sizeof(hints));
907 hints.ai_family = af;
908 Py_BEGIN_ALLOW_THREADS
909 ACQUIRE_GETADDRINFO_LOCK
910 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000911#if defined(__digital__) && defined(__unix__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000912 if (error == EAI_NONAME && af == AF_UNSPEC) {
913 /* On Tru64 V5.1, numeric-to-addr conversion fails
914 if no address family is given. Assume IPv4 for now.*/
915 hints.ai_family = AF_INET;
916 error = getaddrinfo(name, NULL, &hints, &res);
917 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000918#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000919 Py_END_ALLOW_THREADS
920 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
921 if (error) {
922 set_gaierror(error);
923 return -1;
924 }
925 if (res->ai_addrlen < addr_ret_size)
926 addr_ret_size = res->ai_addrlen;
927 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
928 freeaddrinfo(res);
929 switch (addr_ret->sa_family) {
930 case AF_INET:
931 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000932#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000933 case AF_INET6:
934 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000935#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000936 default:
937 PyErr_SetString(socket_error, "unknown address family");
938 return -1;
939 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000940}
941
Guido van Rossum30a685f1991-06-27 15:51:29 +0000942
Guido van Rossum30a685f1991-06-27 15:51:29 +0000943/* Create a string object representing an IP address.
944 This is always a string of the form 'dd.dd.dd.dd' (with variable
945 size numbers). */
946
Guido van Rossum73624e91994-10-10 17:59:00 +0000947static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000948makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000949{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000950 char buf[NI_MAXHOST];
951 int error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000952
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000953 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
954 NI_NUMERICHOST);
955 if (error) {
956 set_gaierror(error);
957 return NULL;
958 }
959 return PyUnicode_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000960}
961
962
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000963#ifdef USE_BLUETOOTH
964/* Convert a string representation of a Bluetooth address into a numeric
965 address. Returns the length (6), or raises an exception and returns -1 if
966 an error occurred. */
967
968static int
969setbdaddr(char *name, bdaddr_t *bdaddr)
970{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000971 unsigned int b0, b1, b2, b3, b4, b5;
972 char ch;
973 int n;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000974
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000975 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
976 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
977 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
978 bdaddr->b[0] = b0;
979 bdaddr->b[1] = b1;
980 bdaddr->b[2] = b2;
981 bdaddr->b[3] = b3;
982 bdaddr->b[4] = b4;
983 bdaddr->b[5] = b5;
984 return 6;
985 } else {
986 PyErr_SetString(socket_error, "bad bluetooth address");
987 return -1;
988 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000989}
990
991/* Create a string representation of the Bluetooth address. This is always a
992 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
993 value (zero padded if necessary). */
994
995static PyObject *
996makebdaddr(bdaddr_t *bdaddr)
997{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000998 char buf[(6 * 2) + 5 + 1];
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000999
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001000 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1001 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1002 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1003 return PyUnicode_FromString(buf);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001004}
1005#endif
1006
1007
Guido van Rossum30a685f1991-06-27 15:51:29 +00001008/* Create an object representing the given socket address,
1009 suitable for passing it back to bind(), connect() etc.
1010 The family field of the sockaddr structure is inspected
1011 to determine what kind of address it really is. */
1012
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001013/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001014static PyObject *
Antoine Pitrou19467d22010-08-17 19:33:30 +00001015makesockaddr(SOCKET_T sockfd, struct sockaddr *addr, size_t addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001016{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001017 if (addrlen == 0) {
1018 /* No address -- may be recvfrom() from known socket */
1019 Py_INCREF(Py_None);
1020 return Py_None;
1021 }
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001022
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001023 switch (addr->sa_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001024
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001025 case AF_INET:
1026 {
1027 struct sockaddr_in *a;
1028 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1029 PyObject *ret = NULL;
1030 if (addrobj) {
1031 a = (struct sockaddr_in *)addr;
1032 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1033 Py_DECREF(addrobj);
1034 }
1035 return ret;
1036 }
Guido van Rossum30a685f1991-06-27 15:51:29 +00001037
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001038#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001039 case AF_UNIX:
1040 {
1041 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001042#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001043 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
1044 addrlen -= offsetof(struct sockaddr_un, sun_path);
1045 return PyBytes_FromStringAndSize(a->sun_path, addrlen);
1046 }
1047 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001048#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001049 {
1050 /* regular NULL-terminated string */
1051 return PyUnicode_FromString(a->sun_path);
1052 }
1053 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001054#endif /* AF_UNIX */
1055
Martin v. Löwis11017b12006-01-14 18:12:57 +00001056#if defined(AF_NETLINK)
1057 case AF_NETLINK:
1058 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001059 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1060 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +00001061 }
1062#endif /* AF_NETLINK */
1063
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001064#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001065 case AF_INET6:
1066 {
1067 struct sockaddr_in6 *a;
1068 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1069 PyObject *ret = NULL;
1070 if (addrobj) {
1071 a = (struct sockaddr_in6 *)addr;
1072 ret = Py_BuildValue("Oiii",
1073 addrobj,
1074 ntohs(a->sin6_port),
1075 a->sin6_flowinfo,
1076 a->sin6_scope_id);
1077 Py_DECREF(addrobj);
1078 }
1079 return ret;
1080 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001081#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001082
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001083#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001084 case AF_BLUETOOTH:
1085 switch (proto) {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001086
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001087 case BTPROTO_L2CAP:
1088 {
1089 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1090 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1091 PyObject *ret = NULL;
1092 if (addrobj) {
1093 ret = Py_BuildValue("Oi",
1094 addrobj,
1095 _BT_L2_MEMB(a, psm));
1096 Py_DECREF(addrobj);
1097 }
1098 return ret;
1099 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001100
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001101 case BTPROTO_RFCOMM:
1102 {
1103 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1104 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1105 PyObject *ret = NULL;
1106 if (addrobj) {
1107 ret = Py_BuildValue("Oi",
1108 addrobj,
1109 _BT_RC_MEMB(a, channel));
1110 Py_DECREF(addrobj);
1111 }
1112 return ret;
1113 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001114
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001115 case BTPROTO_HCI:
1116 {
1117 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001118#if defined(__NetBSD__) || defined(__DragonFly__)
1119 return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));
1120#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001121 PyObject *ret = NULL;
1122 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1123 return ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001124#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001125 }
Thomas Wouterscf297e42007-02-23 15:07:44 +00001126
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001127#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001128 case BTPROTO_SCO:
1129 {
1130 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1131 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1132 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001133#endif
1134
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001135 default:
1136 PyErr_SetString(PyExc_ValueError,
1137 "Unknown Bluetooth protocol");
1138 return NULL;
1139 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001140#endif
1141
Antoine Pitroub156a462010-10-27 20:13:57 +00001142#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001143 case AF_PACKET:
1144 {
1145 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1146 char *ifname = "";
1147 struct ifreq ifr;
1148 /* need to look up interface name give index */
1149 if (a->sll_ifindex) {
1150 ifr.ifr_ifindex = a->sll_ifindex;
1151 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1152 ifname = ifr.ifr_name;
1153 }
1154 return Py_BuildValue("shbhy#",
1155 ifname,
1156 ntohs(a->sll_protocol),
1157 a->sll_pkttype,
1158 a->sll_hatype,
1159 a->sll_addr,
1160 a->sll_halen);
1161 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001162#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001163
Christian Heimes043d6f62008-01-07 17:19:16 +00001164#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001165 case AF_TIPC:
1166 {
1167 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1168 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1169 return Py_BuildValue("IIIII",
1170 a->addrtype,
1171 a->addr.nameseq.type,
1172 a->addr.nameseq.lower,
1173 a->addr.nameseq.upper,
1174 a->scope);
1175 } else if (a->addrtype == TIPC_ADDR_NAME) {
1176 return Py_BuildValue("IIIII",
1177 a->addrtype,
1178 a->addr.name.name.type,
1179 a->addr.name.name.instance,
1180 a->addr.name.name.instance,
1181 a->scope);
1182 } else if (a->addrtype == TIPC_ADDR_ID) {
1183 return Py_BuildValue("IIIII",
1184 a->addrtype,
1185 a->addr.id.node,
1186 a->addr.id.ref,
1187 0,
1188 a->scope);
1189 } else {
1190 PyErr_SetString(PyExc_ValueError,
1191 "Invalid address type");
1192 return NULL;
1193 }
1194 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001195#endif
1196
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001197 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001198
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001199 default:
1200 /* If we don't know the address family, don't raise an
1201 exception -- return it as an (int, bytes) tuple. */
1202 return Py_BuildValue("iy#",
1203 addr->sa_family,
1204 addr->sa_data,
1205 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001206
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001207 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001208}
1209
Guido van Rossum30a685f1991-06-27 15:51:29 +00001210
1211/* Parse a socket address argument according to the socket object's
1212 address family. Return 1 if the address was in the proper format,
1213 0 of not. The address is returned through addr_ret, its length
1214 through len_ret. */
1215
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001216static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001217getsockaddrarg(PySocketSockObject *s, PyObject *args,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001218 struct sockaddr *addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001219{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001220 switch (s->sock_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001221
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001222#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001223 case AF_UNIX:
1224 {
1225 struct sockaddr_un* addr;
1226 char *path;
1227 int len;
1228 if (!PyArg_Parse(args, "s#", &path, &len))
1229 return 0;
Thomas Wouters89f507f2006-12-13 04:49:30 +00001230
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001231 addr = (struct sockaddr_un*)addr_ret;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001232#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001233 if (len > 0 && path[0] == 0) {
1234 /* Linux abstract namespace extension */
1235 if (len > sizeof addr->sun_path) {
1236 PyErr_SetString(socket_error,
1237 "AF_UNIX path too long");
1238 return 0;
1239 }
1240 }
1241 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001242#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001243 {
1244 /* regular NULL-terminated string */
1245 if (len >= sizeof addr->sun_path) {
1246 PyErr_SetString(socket_error,
1247 "AF_UNIX path too long");
1248 return 0;
1249 }
1250 addr->sun_path[len] = 0;
1251 }
1252 addr->sun_family = s->sock_family;
1253 memcpy(addr->sun_path, path, len);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001254#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001255 *len_ret = sizeof(*addr);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001256#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001257 *len_ret = len + offsetof(struct sockaddr_un, sun_path);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001258#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001259 return 1;
1260 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001261#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001262
Martin v. Löwis11017b12006-01-14 18:12:57 +00001263#if defined(AF_NETLINK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001264 case AF_NETLINK:
1265 {
1266 struct sockaddr_nl* addr;
1267 int pid, groups;
1268 addr = (struct sockaddr_nl *)addr_ret;
1269 if (!PyTuple_Check(args)) {
1270 PyErr_Format(
1271 PyExc_TypeError,
1272 "getsockaddrarg: "
1273 "AF_NETLINK address must be tuple, not %.500s",
1274 Py_TYPE(args)->tp_name);
1275 return 0;
1276 }
1277 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1278 return 0;
1279 addr->nl_family = AF_NETLINK;
1280 addr->nl_pid = pid;
1281 addr->nl_groups = groups;
1282 *len_ret = sizeof(*addr);
1283 return 1;
1284 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001285#endif
1286
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 case AF_INET:
1288 {
1289 struct sockaddr_in* addr;
1290 char *host;
1291 int port, result;
1292 if (!PyTuple_Check(args)) {
1293 PyErr_Format(
1294 PyExc_TypeError,
1295 "getsockaddrarg: "
1296 "AF_INET address must be tuple, not %.500s",
1297 Py_TYPE(args)->tp_name);
1298 return 0;
1299 }
1300 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1301 "idna", &host, &port))
1302 return 0;
1303 addr=(struct sockaddr_in*)addr_ret;
1304 result = setipaddr(host, (struct sockaddr *)addr,
1305 sizeof(*addr), AF_INET);
1306 PyMem_Free(host);
1307 if (result < 0)
1308 return 0;
1309 if (port < 0 || port > 0xffff) {
1310 PyErr_SetString(
1311 PyExc_OverflowError,
1312 "getsockaddrarg: port must be 0-65535.");
1313 return 0;
1314 }
1315 addr->sin_family = AF_INET;
1316 addr->sin_port = htons((short)port);
1317 *len_ret = sizeof *addr;
1318 return 1;
1319 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001320
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001321#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001322 case AF_INET6:
1323 {
1324 struct sockaddr_in6* addr;
1325 char *host;
1326 int port, flowinfo, scope_id, result;
1327 flowinfo = scope_id = 0;
1328 if (!PyTuple_Check(args)) {
1329 PyErr_Format(
1330 PyExc_TypeError,
1331 "getsockaddrarg: "
1332 "AF_INET6 address must be tuple, not %.500s",
1333 Py_TYPE(args)->tp_name);
1334 return 0;
1335 }
1336 if (!PyArg_ParseTuple(args, "eti|ii",
1337 "idna", &host, &port, &flowinfo,
1338 &scope_id)) {
1339 return 0;
1340 }
1341 addr = (struct sockaddr_in6*)addr_ret;
1342 result = setipaddr(host, (struct sockaddr *)addr,
1343 sizeof(*addr), AF_INET6);
1344 PyMem_Free(host);
1345 if (result < 0)
1346 return 0;
1347 if (port < 0 || port > 0xffff) {
1348 PyErr_SetString(
1349 PyExc_OverflowError,
1350 "getsockaddrarg: port must be 0-65535.");
1351 return 0;
1352 }
1353 addr->sin6_family = s->sock_family;
1354 addr->sin6_port = htons((short)port);
1355 addr->sin6_flowinfo = flowinfo;
1356 addr->sin6_scope_id = scope_id;
1357 *len_ret = sizeof *addr;
1358 return 1;
1359 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001360#endif
1361
Hye-Shik Chang81268602004-02-02 06:05:24 +00001362#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001363 case AF_BLUETOOTH:
1364 {
1365 switch (s->sock_proto) {
1366 case BTPROTO_L2CAP:
1367 {
1368 struct sockaddr_l2 *addr;
1369 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001371 addr = (struct sockaddr_l2 *)addr_ret;
1372 memset(addr, 0, sizeof(struct sockaddr_l2));
1373 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1374 if (!PyArg_ParseTuple(args, "si", &straddr,
1375 &_BT_L2_MEMB(addr, psm))) {
1376 PyErr_SetString(socket_error, "getsockaddrarg: "
1377 "wrong format");
1378 return 0;
1379 }
1380 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1381 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001382
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001383 *len_ret = sizeof *addr;
1384 return 1;
1385 }
1386 case BTPROTO_RFCOMM:
1387 {
1388 struct sockaddr_rc *addr;
1389 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001390
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001391 addr = (struct sockaddr_rc *)addr_ret;
1392 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1393 if (!PyArg_ParseTuple(args, "si", &straddr,
1394 &_BT_RC_MEMB(addr, channel))) {
1395 PyErr_SetString(socket_error, "getsockaddrarg: "
1396 "wrong format");
1397 return 0;
1398 }
1399 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1400 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001401
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001402 *len_ret = sizeof *addr;
1403 return 1;
1404 }
1405 case BTPROTO_HCI:
1406 {
1407 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001408#if defined(__NetBSD__) || defined(__DragonFly__)
Alexander Belopolskye239d232010-12-08 23:31:48 +00001409 char *straddr = PyBytes_AS_STRING(args);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001410
Alexander Belopolskye239d232010-12-08 23:31:48 +00001411 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001412 if (straddr == NULL) {
1413 PyErr_SetString(socket_error, "getsockaddrarg: "
1414 "wrong format");
1415 return 0;
1416 }
1417 if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)
1418 return 0;
1419#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001420 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1421 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
1422 PyErr_SetString(socket_error, "getsockaddrarg: "
1423 "wrong format");
1424 return 0;
1425 }
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00001426#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001427 *len_ret = sizeof *addr;
1428 return 1;
1429 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001430#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001431 case BTPROTO_SCO:
1432 {
1433 struct sockaddr_sco *addr;
1434 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001435
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001436 addr = (struct sockaddr_sco *)addr_ret;
1437 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1438 if (!PyBytes_Check(args)) {
1439 PyErr_SetString(socket_error, "getsockaddrarg: "
1440 "wrong format");
1441 return 0;
1442 }
1443 straddr = PyBytes_AS_STRING(args);
1444 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1445 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001446
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001447 *len_ret = sizeof *addr;
1448 return 1;
1449 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001450#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001451 default:
1452 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1453 return 0;
1454 }
1455 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001456#endif
1457
Antoine Pitroub156a462010-10-27 20:13:57 +00001458#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001459 case AF_PACKET:
1460 {
1461 struct sockaddr_ll* addr;
1462 struct ifreq ifr;
1463 char *interfaceName;
1464 int protoNumber;
1465 int hatype = 0;
1466 int pkttype = 0;
1467 char *haddr = NULL;
1468 unsigned int halen = 0;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001469
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001470 if (!PyTuple_Check(args)) {
1471 PyErr_Format(
1472 PyExc_TypeError,
1473 "getsockaddrarg: "
1474 "AF_PACKET address must be tuple, not %.500s",
1475 Py_TYPE(args)->tp_name);
1476 return 0;
1477 }
1478 if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
1479 &protoNumber, &pkttype, &hatype,
1480 &haddr, &halen))
1481 return 0;
1482 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1483 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1484 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1485 s->errorhandler();
1486 return 0;
1487 }
1488 if (halen > 8) {
1489 PyErr_SetString(PyExc_ValueError,
1490 "Hardware address must be 8 bytes or less");
1491 return 0;
1492 }
1493 if (protoNumber < 0 || protoNumber > 0xffff) {
1494 PyErr_SetString(
1495 PyExc_OverflowError,
1496 "getsockaddrarg: protoNumber must be 0-65535.");
1497 return 0;
1498 }
1499 addr = (struct sockaddr_ll*)addr_ret;
1500 addr->sll_family = AF_PACKET;
1501 addr->sll_protocol = htons((short)protoNumber);
1502 addr->sll_ifindex = ifr.ifr_ifindex;
1503 addr->sll_pkttype = pkttype;
1504 addr->sll_hatype = hatype;
1505 if (halen != 0) {
1506 memcpy(&addr->sll_addr, haddr, halen);
1507 }
1508 addr->sll_halen = halen;
1509 *len_ret = sizeof *addr;
1510 return 1;
1511 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001512#endif
1513
Christian Heimes043d6f62008-01-07 17:19:16 +00001514#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001515 case AF_TIPC:
1516 {
1517 unsigned int atype, v1, v2, v3;
1518 unsigned int scope = TIPC_CLUSTER_SCOPE;
1519 struct sockaddr_tipc *addr;
Christian Heimes043d6f62008-01-07 17:19:16 +00001520
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001521 if (!PyTuple_Check(args)) {
1522 PyErr_Format(
1523 PyExc_TypeError,
1524 "getsockaddrarg: "
1525 "AF_TIPC address must be tuple, not %.500s",
1526 Py_TYPE(args)->tp_name);
1527 return 0;
1528 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001529
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001530 if (!PyArg_ParseTuple(args,
1531 "IIII|I;Invalid TIPC address format",
1532 &atype, &v1, &v2, &v3, &scope))
1533 return 0;
Christian Heimes043d6f62008-01-07 17:19:16 +00001534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001535 addr = (struct sockaddr_tipc *) addr_ret;
1536 memset(addr, 0, sizeof(struct sockaddr_tipc));
Christian Heimes043d6f62008-01-07 17:19:16 +00001537
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001538 addr->family = AF_TIPC;
1539 addr->scope = scope;
1540 addr->addrtype = atype;
Christian Heimes043d6f62008-01-07 17:19:16 +00001541
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001542 if (atype == TIPC_ADDR_NAMESEQ) {
1543 addr->addr.nameseq.type = v1;
1544 addr->addr.nameseq.lower = v2;
1545 addr->addr.nameseq.upper = v3;
1546 } else if (atype == TIPC_ADDR_NAME) {
1547 addr->addr.name.name.type = v1;
1548 addr->addr.name.name.instance = v2;
1549 } else if (atype == TIPC_ADDR_ID) {
1550 addr->addr.id.node = v1;
1551 addr->addr.id.ref = v2;
1552 } else {
1553 /* Shouldn't happen */
1554 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1555 return 0;
1556 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001557
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001558 *len_ret = sizeof(*addr);
Christian Heimes043d6f62008-01-07 17:19:16 +00001559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001560 return 1;
1561 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001562#endif
1563
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001564 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001565
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001566 default:
1567 PyErr_SetString(socket_error, "getsockaddrarg: bad family");
1568 return 0;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001569
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001570 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001571}
1572
Guido van Rossum30a685f1991-06-27 15:51:29 +00001573
Guido van Rossum48a680c2001-03-02 06:34:14 +00001574/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00001575 Return 1 if the family is known, 0 otherwise. The length is returned
1576 through len_ret. */
1577
1578static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00001579getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001580{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001581 switch (s->sock_family) {
Guido van Rossum710e1df1992-06-12 10:39:36 +00001582
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001583#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001584 case AF_UNIX:
1585 {
1586 *len_ret = sizeof (struct sockaddr_un);
1587 return 1;
1588 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001589#endif /* AF_UNIX */
Martin v. Löwis11017b12006-01-14 18:12:57 +00001590#if defined(AF_NETLINK)
1591 case AF_NETLINK:
1592 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001593 *len_ret = sizeof (struct sockaddr_nl);
1594 return 1;
Martin v. Löwis11017b12006-01-14 18:12:57 +00001595 }
1596#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00001597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001598 case AF_INET:
1599 {
1600 *len_ret = sizeof (struct sockaddr_in);
1601 return 1;
1602 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001603
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001604#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001605 case AF_INET6:
1606 {
1607 *len_ret = sizeof (struct sockaddr_in6);
1608 return 1;
1609 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001610#endif
1611
Hye-Shik Chang81268602004-02-02 06:05:24 +00001612#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001613 case AF_BLUETOOTH:
1614 {
1615 switch(s->sock_proto)
1616 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001617
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001618 case BTPROTO_L2CAP:
1619 *len_ret = sizeof (struct sockaddr_l2);
1620 return 1;
1621 case BTPROTO_RFCOMM:
1622 *len_ret = sizeof (struct sockaddr_rc);
1623 return 1;
1624 case BTPROTO_HCI:
1625 *len_ret = sizeof (struct sockaddr_hci);
1626 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001627#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001628 case BTPROTO_SCO:
1629 *len_ret = sizeof (struct sockaddr_sco);
1630 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001631#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001632 default:
1633 PyErr_SetString(socket_error, "getsockaddrlen: "
1634 "unknown BT protocol");
1635 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001636
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001637 }
1638 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001639#endif
1640
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001641#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001642 case AF_PACKET:
1643 {
1644 *len_ret = sizeof (struct sockaddr_ll);
1645 return 1;
1646 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001647#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001648
Christian Heimes043d6f62008-01-07 17:19:16 +00001649#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001650 case AF_TIPC:
1651 {
1652 *len_ret = sizeof (struct sockaddr_tipc);
1653 return 1;
1654 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001655#endif
1656
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001657 /* More cases here... */
Guido van Rossum710e1df1992-06-12 10:39:36 +00001658
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001659 default:
1660 PyErr_SetString(socket_error, "getsockaddrlen: bad family");
1661 return 0;
Guido van Rossum710e1df1992-06-12 10:39:36 +00001662
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001663 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001664}
1665
1666
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001667/* s._accept() -> (fd, address) */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001668
Guido van Rossum73624e91994-10-10 17:59:00 +00001669static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001670sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001671{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001672 sock_addr_t addrbuf;
1673 SOCKET_T newfd = INVALID_SOCKET;
1674 socklen_t addrlen;
1675 PyObject *sock = NULL;
1676 PyObject *addr = NULL;
1677 PyObject *res = NULL;
1678 int timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001679 if (!getsockaddrlen(s, &addrlen))
1680 return NULL;
1681 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001682
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001683 if (!IS_SELECTABLE(s))
1684 return select_error();
Neal Norwitz082b2df2006-02-07 07:04:46 +00001685
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001686 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001687 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001688 timeout = internal_select_ex(s, 0, interval);
Antoine Pitroub1c54962010-10-14 15:05:38 +00001689 if (!timeout) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001690 newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
Antoine Pitroub1c54962010-10-14 15:05:38 +00001691 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001692 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001693
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001694 if (timeout == 1) {
1695 PyErr_SetString(socket_timeout, "timed out");
1696 return NULL;
1697 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00001698 END_SELECT_LOOP(s)
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001699
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001700 if (newfd == INVALID_SOCKET)
1701 return s->errorhandler();
Barry Warsaw752300b1997-01-03 17:18:10 +00001702
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001703 sock = PyLong_FromSocket_t(newfd);
1704 if (sock == NULL) {
1705 SOCKETCLOSE(newfd);
1706 goto finally;
1707 }
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001708
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001709 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
1710 addrlen, s->sock_proto);
1711 if (addr == NULL)
1712 goto finally;
Barry Warsaw752300b1997-01-03 17:18:10 +00001713
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001714 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001715
Guido van Rossum67f7a382002-06-06 21:08:16 +00001716finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001717 Py_XDECREF(sock);
1718 Py_XDECREF(addr);
1719 return res;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001720}
1721
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001722PyDoc_STRVAR(accept_doc,
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001723"_accept() -> (integer, address info)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00001724\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001725Wait for an incoming connection. Return a new socket file descriptor\n\
1726representing the connection, and the address of the client.\n\
1727For IP sockets, the address info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001728
Guido van Rossum11ba0942002-06-13 15:07:44 +00001729/* s.setblocking(flag) method. Argument:
1730 False -- non-blocking mode; same as settimeout(0)
1731 True -- blocking mode; same as settimeout(None)
1732*/
Guido van Rossume4485b01994-09-07 14:32:49 +00001733
Guido van Rossum73624e91994-10-10 17:59:00 +00001734static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001735sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00001736{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001737 int block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001738
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001739 block = PyLong_AsLong(arg);
1740 if (block == -1 && PyErr_Occurred())
1741 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001742
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001743 s->sock_timeout = block ? -1.0 : 0.0;
1744 internal_setblocking(s, block);
Guido van Rossume4485b01994-09-07 14:32:49 +00001745
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001746 Py_INCREF(Py_None);
1747 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001748}
Guido van Rossume4485b01994-09-07 14:32:49 +00001749
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001750PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001751"setblocking(flag)\n\
1752\n\
1753Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001754setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001755setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001756
Guido van Rossum11ba0942002-06-13 15:07:44 +00001757/* s.settimeout(timeout) method. Argument:
1758 None -- no timeout, blocking mode; same as setblocking(True)
1759 0.0 -- non-blocking mode; same as setblocking(False)
1760 > 0 -- timeout mode; operations time out after timeout seconds
1761 < 0 -- illegal; raises an exception
1762*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00001763static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001764sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001765{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001766 double timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001767
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001768 if (arg == Py_None)
1769 timeout = -1.0;
1770 else {
1771 timeout = PyFloat_AsDouble(arg);
1772 if (timeout < 0.0) {
1773 if (!PyErr_Occurred())
1774 PyErr_SetString(PyExc_ValueError,
1775 "Timeout value out of range");
1776 return NULL;
1777 }
1778 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00001779
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001780 s->sock_timeout = timeout;
1781 internal_setblocking(s, timeout < 0.0);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001782
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001783 Py_INCREF(Py_None);
1784 return Py_None;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001785}
1786
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001787PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001788"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001789\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001790Set a timeout on socket operations. 'timeout' can be a float,\n\
1791giving in seconds, or None. Setting a timeout of None disables\n\
1792the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001793Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00001794
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001795/* s.gettimeout() method.
1796 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00001797static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001798sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001799{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001800 if (s->sock_timeout < 0.0) {
1801 Py_INCREF(Py_None);
1802 return Py_None;
1803 }
1804 else
1805 return PyFloat_FromDouble(s->sock_timeout);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001806}
1807
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001808PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00001809"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001810\n\
1811Returns the timeout in floating seconds associated with socket \n\
1812operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001813operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00001814
Guido van Rossumaee08791992-09-08 09:05:33 +00001815/* s.setsockopt() method.
1816 With an integer third argument, sets an integer option.
1817 With a string third argument, sets an option from a buffer;
1818 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001819
Guido van Rossum73624e91994-10-10 17:59:00 +00001820static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001821sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001822{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001823 int level;
1824 int optname;
1825 int res;
1826 char *buf;
1827 int buflen;
1828 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001829
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001830 if (PyArg_ParseTuple(args, "iii:setsockopt",
1831 &level, &optname, &flag)) {
1832 buf = (char *) &flag;
1833 buflen = sizeof flag;
1834 }
1835 else {
1836 PyErr_Clear();
1837 if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
1838 &level, &optname, &buf, &buflen))
1839 return NULL;
1840 }
1841 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
1842 if (res < 0)
1843 return s->errorhandler();
1844 Py_INCREF(Py_None);
1845 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001846}
1847
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001848PyDoc_STRVAR(setsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001849"setsockopt(level, option, value)\n\
1850\n\
1851Set a socket option. See the Unix manual for level and option.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001852The value argument can either be an integer or a string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001853
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001854
Guido van Rossumaee08791992-09-08 09:05:33 +00001855/* s.getsockopt() method.
1856 With two arguments, retrieves an integer option.
1857 With a third integer argument, retrieves a string buffer of that size;
1858 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001859
Guido van Rossum73624e91994-10-10 17:59:00 +00001860static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001861sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001862{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001863 int level;
1864 int optname;
1865 int res;
1866 PyObject *buf;
1867 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001868
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001869 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1870 &level, &optname, &buflen))
1871 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001872
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001873 if (buflen == 0) {
1874 int flag = 0;
1875 socklen_t flagsize = sizeof flag;
1876 res = getsockopt(s->sock_fd, level, optname,
1877 (void *)&flag, &flagsize);
1878 if (res < 0)
1879 return s->errorhandler();
1880 return PyLong_FromLong(flag);
1881 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001882#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001883 /* socklen_t is unsigned so no negative test is needed,
1884 test buflen == 0 is previously done */
1885 if (buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001886#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001887 if (buflen <= 0 || buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001888#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001889 PyErr_SetString(socket_error,
1890 "getsockopt buflen out of range");
1891 return NULL;
1892 }
1893 buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
1894 if (buf == NULL)
1895 return NULL;
1896 res = getsockopt(s->sock_fd, level, optname,
1897 (void *)PyBytes_AS_STRING(buf), &buflen);
1898 if (res < 0) {
1899 Py_DECREF(buf);
1900 return s->errorhandler();
1901 }
1902 _PyBytes_Resize(&buf, buflen);
1903 return buf;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001904}
1905
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001906PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001907"getsockopt(level, option[, buffersize]) -> value\n\
1908\n\
1909Get a socket option. See the Unix manual for level and option.\n\
1910If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001911string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001912
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001913
Fred Drake728819a2000-07-01 03:40:12 +00001914/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001915
Guido van Rossum73624e91994-10-10 17:59:00 +00001916static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001917sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001918{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001919 sock_addr_t addrbuf;
1920 int addrlen;
1921 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001922
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001923 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
1924 return NULL;
1925 Py_BEGIN_ALLOW_THREADS
1926 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
1927 Py_END_ALLOW_THREADS
1928 if (res < 0)
1929 return s->errorhandler();
1930 Py_INCREF(Py_None);
1931 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001932}
1933
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001934PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001935"bind(address)\n\
1936\n\
1937Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00001938pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001939sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001940
Guido van Rossum30a685f1991-06-27 15:51:29 +00001941
1942/* s.close() method.
1943 Set the file descriptor to -1 so operations tried subsequently
1944 will surely fail. */
1945
Guido van Rossum73624e91994-10-10 17:59:00 +00001946static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001947sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001948{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001949 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001950
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001951 if ((fd = s->sock_fd) != -1) {
1952 s->sock_fd = -1;
1953 Py_BEGIN_ALLOW_THREADS
1954 (void) SOCKETCLOSE(fd);
1955 Py_END_ALLOW_THREADS
1956 }
1957 Py_INCREF(Py_None);
1958 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001959}
1960
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001961PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001962"close()\n\
1963\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001964Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001965
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001966static PyObject *
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001967sock_detach(PySocketSockObject *s)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001968{
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001969 SOCKET_T fd = s->sock_fd;
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001970 s->sock_fd = -1;
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001971 return PyLong_FromSocket_t(fd);
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001972}
1973
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001974PyDoc_STRVAR(detach_doc,
1975"detach()\n\
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001976\n\
1977Close the socket object without closing the underlying file descriptor.\
1978The object cannot be used after this call, but the file descriptor\
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001979can be reused for other purposes. The file descriptor is returned.");
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001980
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001981static int
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001982internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001983 int *timeoutp)
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001984{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001985 int res, timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001986
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001987 timeout = 0;
1988 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001989
1990#ifdef MS_WINDOWS
1991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001992 if (s->sock_timeout > 0.0) {
1993 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
1994 IS_SELECTABLE(s)) {
1995 /* This is a mess. Best solution: trust select */
1996 fd_set fds;
1997 fd_set fds_exc;
1998 struct timeval tv;
1999 tv.tv_sec = (int)s->sock_timeout;
2000 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
2001 FD_ZERO(&fds);
2002 FD_SET(s->sock_fd, &fds);
2003 FD_ZERO(&fds_exc);
2004 FD_SET(s->sock_fd, &fds_exc);
Antoine Pitrou19467d22010-08-17 19:33:30 +00002005 res = select(Py_SAFE_DOWNCAST(s->sock_fd+1, SOCKET_T, int),
2006 NULL, &fds, &fds_exc, &tv);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002007 if (res == 0) {
2008 res = WSAEWOULDBLOCK;
2009 timeout = 1;
2010 } else if (res > 0) {
2011 if (FD_ISSET(s->sock_fd, &fds))
2012 /* The socket is in the writable set - this
2013 means connected */
2014 res = 0;
2015 else {
2016 /* As per MS docs, we need to call getsockopt()
2017 to get the underlying error */
2018 int res_size = sizeof res;
2019 /* It must be in the exception set */
2020 assert(FD_ISSET(s->sock_fd, &fds_exc));
2021 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
2022 (char *)&res, &res_size))
2023 /* getsockopt also clears WSAGetLastError,
2024 so reset it back. */
2025 WSASetLastError(res);
2026 else
2027 res = WSAGetLastError();
2028 }
2029 }
2030 /* else if (res < 0) an error occurred */
2031 }
2032 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002033
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002034 if (res < 0)
2035 res = WSAGetLastError();
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002036
2037#else
2038
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002039 if (s->sock_timeout > 0.0) {
2040 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
2041 timeout = internal_select(s, 1);
2042 if (timeout == 0) {
2043 /* Bug #1019808: in case of an EINPROGRESS,
2044 use getsockopt(SO_ERROR) to get the real
2045 error. */
2046 socklen_t res_size = sizeof res;
2047 (void)getsockopt(s->sock_fd, SOL_SOCKET,
2048 SO_ERROR, &res, &res_size);
2049 if (res == EISCONN)
2050 res = 0;
2051 errno = res;
2052 }
2053 else if (timeout == -1) {
2054 res = errno; /* had error */
2055 }
2056 else
2057 res = EWOULDBLOCK; /* timed out */
2058 }
2059 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002060
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002061 if (res < 0)
2062 res = errno;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002063
2064#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002065 *timeoutp = timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002066
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002067 return res;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00002068}
Guido van Rossum30a685f1991-06-27 15:51:29 +00002069
Fred Drake728819a2000-07-01 03:40:12 +00002070/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002071
Guido van Rossum73624e91994-10-10 17:59:00 +00002072static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002073sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002074{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002075 sock_addr_t addrbuf;
2076 int addrlen;
2077 int res;
2078 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002079
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002080 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2081 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002082
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002083 Py_BEGIN_ALLOW_THREADS
2084 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2085 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002086
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002087 if (timeout == 1) {
2088 PyErr_SetString(socket_timeout, "timed out");
2089 return NULL;
2090 }
2091 if (res != 0)
2092 return s->errorhandler();
2093 Py_INCREF(Py_None);
2094 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002095}
2096
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002097PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002098"connect(address)\n\
2099\n\
2100Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002101is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002102
Guido van Rossum30a685f1991-06-27 15:51:29 +00002103
Fred Drake728819a2000-07-01 03:40:12 +00002104/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002105
2106static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002107sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002108{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002109 sock_addr_t addrbuf;
2110 int addrlen;
2111 int res;
2112 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002113
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002114 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2115 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002116
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002117 Py_BEGIN_ALLOW_THREADS
2118 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2119 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002120
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002121 /* Signals are not errors (though they may raise exceptions). Adapted
2122 from PyErr_SetFromErrnoWithFilenameObject(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002123#ifdef EINTR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002124 if (res == EINTR && PyErr_CheckSignals())
2125 return NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002126#endif
2127
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002128 return PyLong_FromLong((long) res);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002129}
2130
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002131PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002132"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002133\n\
2134This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002135instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002136
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002137
Guido van Rossumed233a51992-06-23 09:07:03 +00002138/* s.fileno() method */
2139
Guido van Rossum73624e91994-10-10 17:59:00 +00002140static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002141sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00002142{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002143 return PyLong_FromSocket_t(s->sock_fd);
Guido van Rossumed233a51992-06-23 09:07:03 +00002144}
2145
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002146PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002147"fileno() -> integer\n\
2148\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002149Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002150
Guido van Rossumed233a51992-06-23 09:07:03 +00002151
Guido van Rossumc89705d1992-11-26 08:54:07 +00002152/* s.getsockname() method */
2153
Guido van Rossum73624e91994-10-10 17:59:00 +00002154static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002155sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002156{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002157 sock_addr_t addrbuf;
2158 int res;
2159 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002160
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002161 if (!getsockaddrlen(s, &addrlen))
2162 return NULL;
2163 memset(&addrbuf, 0, addrlen);
2164 Py_BEGIN_ALLOW_THREADS
2165 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2166 Py_END_ALLOW_THREADS
2167 if (res < 0)
2168 return s->errorhandler();
2169 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2170 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002171}
2172
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002173PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002174"getsockname() -> address info\n\
2175\n\
2176Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002177info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002178
Guido van Rossumc89705d1992-11-26 08:54:07 +00002179
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002180#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002181/* s.getpeername() method */
2182
Guido van Rossum73624e91994-10-10 17:59:00 +00002183static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002184sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002185{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002186 sock_addr_t addrbuf;
2187 int res;
2188 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002189
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002190 if (!getsockaddrlen(s, &addrlen))
2191 return NULL;
2192 memset(&addrbuf, 0, addrlen);
2193 Py_BEGIN_ALLOW_THREADS
2194 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2195 Py_END_ALLOW_THREADS
2196 if (res < 0)
2197 return s->errorhandler();
2198 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2199 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002200}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002201
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002202PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002203"getpeername() -> address info\n\
2204\n\
2205Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002206info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002207
Guido van Rossumb6775db1994-08-01 11:34:53 +00002208#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002209
2210
Guido van Rossum30a685f1991-06-27 15:51:29 +00002211/* s.listen(n) method */
2212
Guido van Rossum73624e91994-10-10 17:59:00 +00002213static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002214sock_listen(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002215{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002216 int backlog;
2217 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002218
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002219 backlog = PyLong_AsLong(arg);
2220 if (backlog == -1 && PyErr_Occurred())
2221 return NULL;
2222 Py_BEGIN_ALLOW_THREADS
2223 if (backlog < 1)
2224 backlog = 1;
2225 res = listen(s->sock_fd, backlog);
2226 Py_END_ALLOW_THREADS
2227 if (res < 0)
2228 return s->errorhandler();
2229 Py_INCREF(Py_None);
2230 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002231}
2232
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002233PyDoc_STRVAR(listen_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002234"listen(backlog)\n\
2235\n\
2236Enable a server to accept connections. The backlog argument must be at\n\
2237least 1; it specifies the number of unaccepted connection that the system\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002238will allow before refusing new connections.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002239
2240
Thomas Wouters477c8d52006-05-27 19:21:47 +00002241/*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002242 * This is the guts of the recv() and recv_into() methods, which reads into a
Thomas Wouters902d6eb2007-01-09 23:18:33 +00002243 * char buffer. If you have any inc/dec ref to do to the objects that contain
Thomas Wouters477c8d52006-05-27 19:21:47 +00002244 * the buffer, do it in the caller. This function returns the number of bytes
2245 * succesfully read. If there was an error, it returns -1. Note that it is
2246 * also possible that we return a number of bytes smaller than the request
2247 * bytes.
2248 */
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002249
Antoine Pitrou19467d22010-08-17 19:33:30 +00002250static Py_ssize_t
2251sock_recv_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002252{
Antoine Pitrou19467d22010-08-17 19:33:30 +00002253 Py_ssize_t outlen = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002254 int timeout;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002255#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002256 int remaining;
2257 char *read_buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002258#endif
2259
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002260 if (!IS_SELECTABLE(s)) {
2261 select_error();
2262 return -1;
2263 }
2264 if (len == 0) {
2265 /* If 0 bytes were requested, do nothing. */
2266 return 0;
2267 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002268
2269#ifndef __VMS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002270 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002271 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002272 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002273 if (!timeout)
2274 outlen = recv(s->sock_fd, cbuf, len, flags);
2275 Py_END_ALLOW_THREADS
Thomas Wouters477c8d52006-05-27 19:21:47 +00002276
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002277 if (timeout == 1) {
2278 PyErr_SetString(socket_timeout, "timed out");
2279 return -1;
2280 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002281 END_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002282 if (outlen < 0) {
2283 /* Note: the call to errorhandler() ALWAYS indirectly returned
2284 NULL, so ignore its return value */
2285 s->errorhandler();
2286 return -1;
2287 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002288#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002289 read_buf = cbuf;
2290 remaining = len;
2291 while (remaining != 0) {
2292 unsigned int segment;
2293 int nread = -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002294
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002295 segment = remaining /SEGMENT_SIZE;
2296 if (segment != 0) {
2297 segment = SEGMENT_SIZE;
2298 }
2299 else {
2300 segment = remaining;
2301 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002302
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002303 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002304 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002305 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002306 if (!timeout)
2307 nread = recv(s->sock_fd, read_buf, segment, flags);
2308 Py_END_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002309 if (timeout == 1) {
2310 PyErr_SetString(socket_timeout, "timed out");
2311 return -1;
2312 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002313 END_SELECT_LOOP(s)
2314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002315 if (nread < 0) {
2316 s->errorhandler();
2317 return -1;
2318 }
2319 if (nread != remaining) {
2320 read_buf += nread;
2321 break;
2322 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002323
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002324 remaining -= segment;
2325 read_buf += segment;
2326 }
2327 outlen = read_buf - cbuf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002328#endif /* !__VMS */
2329
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002330 return outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002331}
2332
Guido van Rossum48a680c2001-03-02 06:34:14 +00002333
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002334/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002335
Guido van Rossum73624e91994-10-10 17:59:00 +00002336static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002337sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002338{
Antoine Pitrou19467d22010-08-17 19:33:30 +00002339 Py_ssize_t recvlen, outlen;
2340 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002341 PyObject *buf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002342
Antoine Pitrou19467d22010-08-17 19:33:30 +00002343 if (!PyArg_ParseTuple(args, "n|i:recv", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002344 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002345
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002346 if (recvlen < 0) {
2347 PyErr_SetString(PyExc_ValueError,
2348 "negative buffersize in recv");
2349 return NULL;
2350 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002351
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002352 /* Allocate a new string. */
2353 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2354 if (buf == NULL)
2355 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002356
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002357 /* Call the guts */
2358 outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
2359 if (outlen < 0) {
2360 /* An error occurred, release the string and return an
2361 error. */
2362 Py_DECREF(buf);
2363 return NULL;
2364 }
2365 if (outlen != recvlen) {
2366 /* We did not read as many bytes as we anticipated, resize the
2367 string if possible and be successful. */
2368 _PyBytes_Resize(&buf, outlen);
2369 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002371 return buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002372}
2373
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002374PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002375"recv(buffersize[, flags]) -> data\n\
2376\n\
2377Receive up to buffersize bytes from the socket. For the optional flags\n\
2378argument, see the Unix manual. When no data is available, block until\n\
2379at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002380the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002381
Guido van Rossum30a685f1991-06-27 15:51:29 +00002382
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002383/* s.recv_into(buffer, [nbytes [,flags]]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002384
Thomas Wouters477c8d52006-05-27 19:21:47 +00002385static PyObject*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002386sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002387{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002388 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002389
Antoine Pitrou19467d22010-08-17 19:33:30 +00002390 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002391 Py_buffer pbuf;
2392 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002393 Py_ssize_t buflen, readlen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002394
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002395 /* Get the buffer's memory */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002396 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recv_into", kwlist,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002397 &pbuf, &recvlen, &flags))
2398 return NULL;
2399 buf = pbuf.buf;
2400 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002401
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002402 if (recvlen < 0) {
2403 PyBuffer_Release(&pbuf);
2404 PyErr_SetString(PyExc_ValueError,
2405 "negative buffersize in recv_into");
2406 return NULL;
2407 }
2408 if (recvlen == 0) {
2409 /* If nbytes was not specified, use the buffer's length */
2410 recvlen = buflen;
2411 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002412
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002413 /* Check if the buffer is large enough */
2414 if (buflen < recvlen) {
2415 PyBuffer_Release(&pbuf);
2416 PyErr_SetString(PyExc_ValueError,
2417 "buffer too small for requested bytes");
2418 return NULL;
2419 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002421 /* Call the guts */
2422 readlen = sock_recv_guts(s, buf, recvlen, flags);
2423 if (readlen < 0) {
2424 /* Return an error. */
2425 PyBuffer_Release(&pbuf);
2426 return NULL;
2427 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002428
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002429 PyBuffer_Release(&pbuf);
2430 /* Return the number of bytes read. Note that we do not do anything
2431 special here in the case that readlen < recvlen. */
2432 return PyLong_FromSsize_t(readlen);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002433}
2434
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002435PyDoc_STRVAR(recv_into_doc,
2436"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002437\n\
2438A version of recv() that stores its data into a buffer rather than creating \n\
2439a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
2440is not specified (or 0), receive up to the size available in the given buffer.\n\
2441\n\
2442See recv() for documentation about the flags.");
2443
2444
2445/*
Christian Heimes99170a52007-12-19 02:07:34 +00002446 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
2447 * into a char buffer. If you have any inc/def ref to do to the objects that
2448 * contain the buffer, do it in the caller. This function returns the number
2449 * of bytes succesfully read. If there was an error, it returns -1. Note
2450 * that it is also possible that we return a number of bytes smaller than the
2451 * request bytes.
Thomas Wouters477c8d52006-05-27 19:21:47 +00002452 *
2453 * 'addr' is a return value for the address object. Note that you must decref
2454 * it yourself.
2455 */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002456static Py_ssize_t
2457sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, Py_ssize_t len, int flags,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002458 PyObject** addr)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002459{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002460 sock_addr_t addrbuf;
2461 int timeout;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002462 Py_ssize_t n = -1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002463 socklen_t addrlen;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002464
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002465 *addr = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002466
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002467 if (!getsockaddrlen(s, &addrlen))
2468 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002469
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002470 if (!IS_SELECTABLE(s)) {
2471 select_error();
2472 return -1;
2473 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002474
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002475 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002476 Py_BEGIN_ALLOW_THREADS
2477 memset(&addrbuf, 0, addrlen);
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002478 timeout = internal_select_ex(s, 0, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002479 if (!timeout) {
Guido van Rossum8d665e61996-06-26 18:22:49 +00002480#ifndef MS_WINDOWS
Andrew MacIntyreba43e872002-03-03 03:03:52 +00002481#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002482 n = recvfrom(s->sock_fd, cbuf, len, flags,
2483 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002484#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002485 n = recvfrom(s->sock_fd, cbuf, len, flags,
2486 (void *) &addrbuf, &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002487#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002488#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002489 n = recvfrom(s->sock_fd, cbuf, len, flags,
2490 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002491#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002492 }
2493 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002494
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002495 if (timeout == 1) {
2496 PyErr_SetString(socket_timeout, "timed out");
2497 return -1;
2498 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002499 END_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002500 if (n < 0) {
2501 s->errorhandler();
2502 return -1;
2503 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002504
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002505 if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2506 addrlen, s->sock_proto)))
2507 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002508
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002509 return n;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002510}
2511
2512/* s.recvfrom(nbytes [,flags]) method */
2513
2514static PyObject *
2515sock_recvfrom(PySocketSockObject *s, PyObject *args)
2516{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002517 PyObject *buf = NULL;
2518 PyObject *addr = NULL;
2519 PyObject *ret = NULL;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002520 int flags = 0;
2521 Py_ssize_t recvlen, outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002522
Antoine Pitrou19467d22010-08-17 19:33:30 +00002523 if (!PyArg_ParseTuple(args, "n|i:recvfrom", &recvlen, &flags))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002524 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002525
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002526 if (recvlen < 0) {
2527 PyErr_SetString(PyExc_ValueError,
2528 "negative buffersize in recvfrom");
2529 return NULL;
2530 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002531
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002532 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2533 if (buf == NULL)
2534 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002535
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002536 outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
2537 recvlen, flags, &addr);
2538 if (outlen < 0) {
2539 goto finally;
2540 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002541
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002542 if (outlen != recvlen) {
2543 /* We did not read as many bytes as we anticipated, resize the
2544 string if possible and be succesful. */
2545 if (_PyBytes_Resize(&buf, outlen) < 0)
2546 /* Oopsy, not so succesful after all. */
2547 goto finally;
2548 }
Barry Warsaw752300b1997-01-03 17:18:10 +00002549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002550 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002551
2552finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002553 Py_XDECREF(buf);
2554 Py_XDECREF(addr);
2555 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002556}
2557
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002558PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002559"recvfrom(buffersize[, flags]) -> (data, address info)\n\
2560\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002561Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002562
Thomas Wouters477c8d52006-05-27 19:21:47 +00002563
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002564/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002565
2566static PyObject *
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002567sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002568{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002569 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002570
Antoine Pitrou19467d22010-08-17 19:33:30 +00002571 int flags = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002572 Py_buffer pbuf;
2573 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002574 Py_ssize_t readlen, buflen, recvlen = 0;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002575
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002576 PyObject *addr = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002577
Antoine Pitrou19467d22010-08-17 19:33:30 +00002578 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ni:recvfrom_into",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002579 kwlist, &pbuf,
2580 &recvlen, &flags))
2581 return NULL;
2582 buf = pbuf.buf;
2583 buflen = pbuf.len;
2584 assert(buf != 0 && buflen > 0);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002585
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002586 if (recvlen < 0) {
2587 PyBuffer_Release(&pbuf);
2588 PyErr_SetString(PyExc_ValueError,
2589 "negative buffersize in recvfrom_into");
2590 return NULL;
2591 }
2592 if (recvlen == 0) {
2593 /* If nbytes was not specified, use the buffer's length */
2594 recvlen = buflen;
2595 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002596
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002597 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
2598 if (readlen < 0) {
2599 PyBuffer_Release(&pbuf);
2600 /* Return an error */
2601 Py_XDECREF(addr);
2602 return NULL;
2603 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002604
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002605 PyBuffer_Release(&pbuf);
2606 /* Return the number of bytes read and the address. Note that we do
2607 not do anything special here in the case that readlen < recvlen. */
Antoine Pitrou19467d22010-08-17 19:33:30 +00002608 return Py_BuildValue("nN", readlen, addr);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002609}
2610
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002611PyDoc_STRVAR(recvfrom_into_doc,
2612"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002613\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002614Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00002615
2616
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002617/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002618
Guido van Rossum73624e91994-10-10 17:59:00 +00002619static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002620sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002621{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002622 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002623 Py_ssize_t len, n = -1;
2624 int flags = 0, timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002625 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002626
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002627 if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
2628 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002629
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002630 if (!IS_SELECTABLE(s)) {
2631 PyBuffer_Release(&pbuf);
2632 return select_error();
2633 }
2634 buf = pbuf.buf;
2635 len = pbuf.len;
Neal Norwitz082b2df2006-02-07 07:04:46 +00002636
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002637 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002638 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002639 timeout = internal_select_ex(s, 1, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002640 if (!timeout)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002641#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002642 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002643#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002644 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002645#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002646 Py_END_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002647 if (timeout == 1) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002648 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002649 PyErr_SetString(socket_timeout, "timed out");
2650 return NULL;
2651 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002652 END_SELECT_LOOP(s)
2653
2654 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002655 if (n < 0)
2656 return s->errorhandler();
Antoine Pitrou19467d22010-08-17 19:33:30 +00002657 return PyLong_FromSsize_t(n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00002658}
2659
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002660PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002661"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002662\n\
2663Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002664argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002665sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002666
2667
2668/* s.sendall(data [,flags]) method */
2669
2670static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002671sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002672{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002673 char *buf;
Antoine Pitrou19467d22010-08-17 19:33:30 +00002674 Py_ssize_t len, n = -1;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002675 int flags = 0, timeout, saved_errno;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002676 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002677
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002678 if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
2679 return NULL;
2680 buf = pbuf.buf;
2681 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002682
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002683 if (!IS_SELECTABLE(s)) {
2684 PyBuffer_Release(&pbuf);
2685 return select_error();
2686 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002687
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002688 do {
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002689 Py_BEGIN_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002690 timeout = internal_select(s, 1);
2691 n = -1;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002692 if (!timeout) {
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002693#ifdef __VMS
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002694 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002695#else
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002696 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002697#endif
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002698 }
2699 Py_END_ALLOW_THREADS
2700 if (timeout == 1) {
2701 PyBuffer_Release(&pbuf);
2702 PyErr_SetString(socket_timeout, "timed out");
2703 return NULL;
2704 }
2705 /* PyErr_CheckSignals() might change errno */
2706 saved_errno = errno;
2707 /* We must run our signal handlers before looping again.
2708 send() can return a successful partial write when it is
2709 interrupted, so we can't restrict ourselves to EINTR. */
2710 if (PyErr_CheckSignals()) {
2711 PyBuffer_Release(&pbuf);
2712 return NULL;
2713 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002714 if (n < 0) {
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002715 /* If interrupted, try again */
2716 if (saved_errno == EINTR)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002717 continue;
Antoine Pitrou6d7df632010-09-27 17:52:25 +00002718 else
2719 break;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002720 }
2721 buf += n;
2722 len -= n;
2723 } while (len > 0);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002724 PyBuffer_Release(&pbuf);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002725
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002726 if (n < 0)
2727 return s->errorhandler();
Guido van Rossum67f7a382002-06-06 21:08:16 +00002728
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002729 Py_INCREF(Py_None);
2730 return Py_None;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002731}
2732
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002733PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002734"sendall(data[, flags])\n\
2735\n\
2736Send a data string to the socket. For the optional flags\n\
2737argument, see the Unix manual. This calls send() repeatedly\n\
2738until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002739to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002740
Guido van Rossum30a685f1991-06-27 15:51:29 +00002741
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002742/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002743
Guido van Rossum73624e91994-10-10 17:59:00 +00002744static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002745sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002746{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002747 Py_buffer pbuf;
2748 PyObject *addro;
2749 char *buf;
2750 Py_ssize_t len;
2751 sock_addr_t addrbuf;
2752 int addrlen, n = -1, flags, timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002753
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002754 flags = 0;
2755 if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
2756 PyErr_Clear();
2757 if (!PyArg_ParseTuple(args, "y*iO:sendto",
2758 &pbuf, &flags, &addro))
2759 return NULL;
2760 }
2761 buf = pbuf.buf;
2762 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002763
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002764 if (!IS_SELECTABLE(s)) {
2765 PyBuffer_Release(&pbuf);
2766 return select_error();
2767 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002768
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002769 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
2770 PyBuffer_Release(&pbuf);
2771 return NULL;
2772 }
Thomas Wouters89f507f2006-12-13 04:49:30 +00002773
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002774 BEGIN_SELECT_LOOP(s)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002775 Py_BEGIN_ALLOW_THREADS
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002776 timeout = internal_select_ex(s, 1, interval);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002777 if (!timeout)
2778 n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
2779 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002780
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002781 if (timeout == 1) {
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002782 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002783 PyErr_SetString(socket_timeout, "timed out");
2784 return NULL;
2785 }
Antoine Pitrou3e1fd272010-09-28 21:23:11 +00002786 END_SELECT_LOOP(s)
2787 PyBuffer_Release(&pbuf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002788 if (n < 0)
2789 return s->errorhandler();
Antoine Pitrou19467d22010-08-17 19:33:30 +00002790 return PyLong_FromSsize_t(n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002791}
2792
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002793PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002794"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002795\n\
2796Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002797For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002798
Guido van Rossum30a685f1991-06-27 15:51:29 +00002799
2800/* s.shutdown(how) method */
2801
Guido van Rossum73624e91994-10-10 17:59:00 +00002802static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002803sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002804{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002805 int how;
2806 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002807
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002808 how = PyLong_AsLong(arg);
2809 if (how == -1 && PyErr_Occurred())
2810 return NULL;
2811 Py_BEGIN_ALLOW_THREADS
2812 res = shutdown(s->sock_fd, how);
2813 Py_END_ALLOW_THREADS
2814 if (res < 0)
2815 return s->errorhandler();
2816 Py_INCREF(Py_None);
2817 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002818}
2819
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002820PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002821"shutdown(flag)\n\
2822\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00002823Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
2824of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002825
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00002826#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Christian Heimesfaf2f632008-01-06 16:59:19 +00002827static PyObject*
2828sock_ioctl(PySocketSockObject *s, PyObject *arg)
2829{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002830 unsigned long cmd = SIO_RCVALL;
2831 PyObject *argO;
2832 DWORD recv;
Christian Heimesfaf2f632008-01-06 16:59:19 +00002833
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002834 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
2835 return NULL;
Christian Heimesfaf2f632008-01-06 16:59:19 +00002836
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002837 switch (cmd) {
2838 case SIO_RCVALL: {
2839 unsigned int option = RCVALL_ON;
2840 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
2841 return NULL;
2842 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
2843 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
2844 return set_error();
2845 }
2846 return PyLong_FromUnsignedLong(recv); }
2847 case SIO_KEEPALIVE_VALS: {
2848 struct tcp_keepalive ka;
2849 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
2850 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
2851 return NULL;
2852 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
2853 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
2854 return set_error();
2855 }
2856 return PyLong_FromUnsignedLong(recv); }
2857 default:
2858 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
2859 return NULL;
2860 }
Christian Heimesfaf2f632008-01-06 16:59:19 +00002861}
2862PyDoc_STRVAR(sock_ioctl_doc,
2863"ioctl(cmd, option) -> long\n\
2864\n\
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00002865Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
2866SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
2867SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).");
Christian Heimesfaf2f632008-01-06 16:59:19 +00002868
2869#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00002870
2871/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002872
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002873static PyMethodDef sock_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002874 {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
2875 accept_doc},
2876 {"bind", (PyCFunction)sock_bind, METH_O,
2877 bind_doc},
2878 {"close", (PyCFunction)sock_close, METH_NOARGS,
2879 close_doc},
2880 {"connect", (PyCFunction)sock_connect, METH_O,
2881 connect_doc},
2882 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
2883 connect_ex_doc},
Antoine Pitrou6e451df2010-08-09 20:39:54 +00002884 {"detach", (PyCFunction)sock_detach, METH_NOARGS,
2885 detach_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002886 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
2887 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00002888#ifdef HAVE_GETPEERNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002889 {"getpeername", (PyCFunction)sock_getpeername,
2890 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00002891#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002892 {"getsockname", (PyCFunction)sock_getsockname,
2893 METH_NOARGS, getsockname_doc},
2894 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
2895 getsockopt_doc},
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00002896#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002897 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
2898 sock_ioctl_doc},
Christian Heimesfaf2f632008-01-06 16:59:19 +00002899#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002900 {"listen", (PyCFunction)sock_listen, METH_O,
2901 listen_doc},
2902 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
2903 recv_doc},
2904 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
2905 recv_into_doc},
2906 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
2907 recvfrom_doc},
2908 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
2909 recvfrom_into_doc},
2910 {"send", (PyCFunction)sock_send, METH_VARARGS,
2911 send_doc},
2912 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
2913 sendall_doc},
2914 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
2915 sendto_doc},
2916 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
2917 setblocking_doc},
2918 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
2919 settimeout_doc},
2920 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
2921 gettimeout_doc},
2922 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
2923 setsockopt_doc},
2924 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
2925 shutdown_doc},
2926 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002927};
2928
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002929/* SockObject members */
2930static PyMemberDef sock_memberlist[] = {
2931 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
2932 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
2933 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
2934 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
2935 {0},
2936};
Guido van Rossum30a685f1991-06-27 15:51:29 +00002937
Guido van Rossum73624e91994-10-10 17:59:00 +00002938/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00002939 First close the file description. */
2940
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002941static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002942sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002943{
Antoine Pitroue033e062010-10-29 10:38:18 +00002944 if (s->sock_fd != -1) {
2945 PyObject *exc, *val, *tb;
2946 Py_ssize_t old_refcount = Py_REFCNT(s);
2947 ++Py_REFCNT(s);
2948 PyErr_Fetch(&exc, &val, &tb);
2949 if (PyErr_WarnFormat(PyExc_ResourceWarning, 1,
2950 "unclosed %R", s))
2951 /* Spurious errors can appear at shutdown */
2952 if (PyErr_ExceptionMatches(PyExc_Warning))
2953 PyErr_WriteUnraisable((PyObject *) s);
2954 PyErr_Restore(exc, val, tb);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002955 (void) SOCKETCLOSE(s->sock_fd);
Antoine Pitroue033e062010-10-29 10:38:18 +00002956 Py_REFCNT(s) = old_refcount;
2957 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002958 Py_TYPE(s)->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002959}
2960
Guido van Rossum30a685f1991-06-27 15:51:29 +00002961
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002962static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002963sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002964{
Fred Drakea04eaad2000-06-30 02:46:07 +00002965#if SIZEOF_SOCKET_T > SIZEOF_LONG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002966 if (s->sock_fd > LONG_MAX) {
2967 /* this can occur on Win64, and actually there is a special
2968 ugly printf formatter for decimal pointer length integer
2969 printing, only bother if necessary*/
2970 PyErr_SetString(PyExc_OverflowError,
2971 "no printf formatter to display "
2972 "the socket descriptor in decimal");
2973 return NULL;
2974 }
Fred Drakea04eaad2000-06-30 02:46:07 +00002975#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002976 return PyUnicode_FromFormat(
2977 "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
2978 (long)s->sock_fd, s->sock_family,
2979 s->sock_type,
2980 s->sock_proto);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002981}
2982
2983
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002984/* Create a new, uninitialized socket object. */
2985
2986static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002987sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002988{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002989 PyObject *new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002990
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002991 new = type->tp_alloc(type, 0);
2992 if (new != NULL) {
2993 ((PySocketSockObject *)new)->sock_fd = -1;
2994 ((PySocketSockObject *)new)->sock_timeout = -1.0;
2995 ((PySocketSockObject *)new)->errorhandler = &set_error;
2996 }
2997 return new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002998}
2999
3000
3001/* Initialize a new socket object. */
3002
3003/*ARGSUSED*/
3004static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00003005sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003006{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003007 PySocketSockObject *s = (PySocketSockObject *)self;
3008 PyObject *fdobj = NULL;
3009 SOCKET_T fd = INVALID_SOCKET;
3010 int family = AF_INET, type = SOCK_STREAM, proto = 0;
3011 static char *keywords[] = {"family", "type", "proto", "fileno", 0};
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003012
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003013 if (!PyArg_ParseTupleAndKeywords(args, kwds,
3014 "|iiiO:socket", keywords,
3015 &family, &type, &proto, &fdobj))
3016 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003017
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003018 if (fdobj != NULL && fdobj != Py_None) {
3019 fd = PyLong_AsSocket_t(fdobj);
3020 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
3021 return -1;
3022 if (fd == INVALID_SOCKET) {
3023 PyErr_SetString(PyExc_ValueError,
3024 "can't use invalid socket value");
3025 return -1;
3026 }
3027 }
3028 else {
3029 Py_BEGIN_ALLOW_THREADS
3030 fd = socket(family, type, proto);
3031 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00003032
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003033 if (fd == INVALID_SOCKET) {
3034 set_error();
3035 return -1;
3036 }
3037 }
3038 init_sockobject(s, fd, family, type, proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003039
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003040 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003041
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003042}
3043
3044
Guido van Rossumb6775db1994-08-01 11:34:53 +00003045/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00003046
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003047static PyTypeObject sock_type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003048 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
3049 "_socket.socket", /* tp_name */
3050 sizeof(PySocketSockObject), /* tp_basicsize */
3051 0, /* tp_itemsize */
3052 (destructor)sock_dealloc, /* tp_dealloc */
3053 0, /* tp_print */
3054 0, /* tp_getattr */
3055 0, /* tp_setattr */
3056 0, /* tp_reserved */
3057 (reprfunc)sock_repr, /* tp_repr */
3058 0, /* tp_as_number */
3059 0, /* tp_as_sequence */
3060 0, /* tp_as_mapping */
3061 0, /* tp_hash */
3062 0, /* tp_call */
3063 0, /* tp_str */
3064 PyObject_GenericGetAttr, /* tp_getattro */
3065 0, /* tp_setattro */
3066 0, /* tp_as_buffer */
3067 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
3068 sock_doc, /* tp_doc */
3069 0, /* tp_traverse */
3070 0, /* tp_clear */
3071 0, /* tp_richcompare */
3072 0, /* tp_weaklistoffset */
3073 0, /* tp_iter */
3074 0, /* tp_iternext */
3075 sock_methods, /* tp_methods */
3076 sock_memberlist, /* tp_members */
3077 0, /* tp_getset */
3078 0, /* tp_base */
3079 0, /* tp_dict */
3080 0, /* tp_descr_get */
3081 0, /* tp_descr_set */
3082 0, /* tp_dictoffset */
3083 sock_initobj, /* tp_init */
3084 PyType_GenericAlloc, /* tp_alloc */
3085 sock_new, /* tp_new */
3086 PyObject_Del, /* tp_free */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003087};
3088
Guido van Rossum30a685f1991-06-27 15:51:29 +00003089
Guido van Rossum81194471991-07-27 21:42:02 +00003090/* Python interface to gethostname(). */
3091
3092/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003093static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00003094socket_gethostname(PyObject *self, PyObject *unused)
Guido van Rossum81194471991-07-27 21:42:02 +00003095{
Martin v. Löwis72f48422010-10-29 18:20:08 +00003096#ifdef MS_WINDOWS
3097 /* Don't use winsock's gethostname, as this returns the ANSI
3098 version of the hostname, whereas we need a Unicode string.
3099 Otherwise, gethostname apparently also returns the DNS name. */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003100 wchar_t buf[MAX_COMPUTERNAME_LENGTH + 1];
3101 DWORD size = sizeof(buf) / sizeof(wchar_t);
3102 PyObject *result;
Martin v. Löwis72f48422010-10-29 18:20:08 +00003103 if (!GetComputerNameExW(ComputerNamePhysicalDnsHostname, buf, &size)) {
3104 if (GetLastError() == ERROR_MORE_DATA) {
3105 /* MSDN says this may occur "because DNS allows longer names */
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003106 if (size == 0) /* XXX: I'm not sure how to handle this */
3107 return PyUnicode_FromUnicode(NULL, 0);
3108 result = PyUnicode_FromUnicode(NULL, size - 1);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003109 if (!result)
3110 return NULL;
Hirokazu Yamamoto09fff7a2010-11-05 17:24:13 +00003111 if (GetComputerNameExW(ComputerNamePhysicalDnsHostname,
3112 PyUnicode_AS_UNICODE(result),
3113 &size))
Martin v. Löwis72f48422010-10-29 18:20:08 +00003114 return result;
Benjamin Petersone857b292010-10-29 21:37:26 +00003115 Py_DECREF(result);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003116 }
3117 return PyErr_SetExcFromWindowsErr(PyExc_WindowsError, GetLastError());
3118 }
3119 return PyUnicode_FromUnicode(buf, size);
3120#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003121 char buf[1024];
3122 int res;
3123 Py_BEGIN_ALLOW_THREADS
3124 res = gethostname(buf, (int) sizeof buf - 1);
3125 Py_END_ALLOW_THREADS
3126 if (res < 0)
3127 return set_error();
3128 buf[sizeof buf - 1] = '\0';
3129 return PyUnicode_FromString(buf);
Martin v. Löwis72f48422010-10-29 18:20:08 +00003130#endif
Guido van Rossum81194471991-07-27 21:42:02 +00003131}
Guido van Rossumff4949e1992-08-05 19:58:53 +00003132
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003133PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003134"gethostname() -> string\n\
3135\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003136Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003137
Antoine Pitrou061cfb52011-02-28 22:25:22 +00003138#ifdef HAVE_SETHOSTNAME
3139PyDoc_STRVAR(sethostname_doc,
3140"sethostname(name)\n\n\
3141Sets the hostname to name.");
3142
3143static PyObject *
3144socket_sethostname(PyObject *self, PyObject *args)
3145{
3146 PyObject *hnobj;
3147 Py_buffer buf;
3148 int res, flag = 0;
3149
3150 if (!PyArg_ParseTuple(args, "S:sethostname", &hnobj)) {
3151 PyErr_Clear();
3152 if (!PyArg_ParseTuple(args, "O&:sethostname",
3153 PyUnicode_FSConverter, &hnobj))
3154 return NULL;
3155 flag = 1;
3156 }
3157 res = PyObject_GetBuffer(hnobj, &buf, PyBUF_SIMPLE);
3158 if (!res) {
3159 res = sethostname(buf.buf, buf.len);
3160 PyBuffer_Release(&buf);
3161 }
3162 if (flag)
3163 Py_DECREF(hnobj);
3164 if (res)
3165 return set_error();
3166 Py_RETURN_NONE;
3167}
3168#endif
Guido van Rossumff4949e1992-08-05 19:58:53 +00003169
Guido van Rossum30a685f1991-06-27 15:51:29 +00003170/* Python interface to gethostbyname(name). */
3171
3172/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003173static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003174socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003175{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003176 char *name;
3177 sock_addr_t addrbuf;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003178 PyObject *ret = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003179
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003180 if (!PyArg_ParseTuple(args, "et:gethostbyname", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003181 return NULL;
3182 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003183 goto finally;
3184 ret = makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
3185finally:
3186 PyMem_Free(name);
3187 return ret;
Guido van Rossum30a685f1991-06-27 15:51:29 +00003188}
3189
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003190PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003191"gethostbyname(host) -> address\n\
3192\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003193Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003194
3195
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003196/* Convenience function common to gethostbyname_ex and gethostbyaddr */
3197
3198static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003199gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003200{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003201 char **pch;
3202 PyObject *rtn_tuple = (PyObject *)NULL;
3203 PyObject *name_list = (PyObject *)NULL;
3204 PyObject *addr_list = (PyObject *)NULL;
3205 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003206
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003207 if (h == NULL) {
3208 /* Let's get real error message to return */
3209 set_herror(h_errno);
3210 return NULL;
3211 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003212
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003213 if (h->h_addrtype != af) {
3214 /* Let's get real error message to return */
3215 PyErr_SetString(socket_error,
3216 (char *)strerror(EAFNOSUPPORT));
Christian Heimesada8c3b2008-03-18 18:26:33 +00003217
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003218 return NULL;
3219 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003220
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003221 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003222
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003223 case AF_INET:
3224 if (alen < sizeof(struct sockaddr_in))
3225 return NULL;
3226 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003227
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003228#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003229 case AF_INET6:
3230 if (alen < sizeof(struct sockaddr_in6))
3231 return NULL;
3232 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003233#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00003234
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003235 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003236
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003237 if ((name_list = PyList_New(0)) == NULL)
3238 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003239
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003240 if ((addr_list = PyList_New(0)) == NULL)
3241 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003242
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003243 /* SF #1511317: h_aliases can be NULL */
3244 if (h->h_aliases) {
3245 for (pch = h->h_aliases; *pch != NULL; pch++) {
3246 int status;
3247 tmp = PyUnicode_FromString(*pch);
3248 if (tmp == NULL)
3249 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003250
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003251 status = PyList_Append(name_list, tmp);
3252 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003253
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003254 if (status)
3255 goto err;
3256 }
3257 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003258
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003259 for (pch = h->h_addr_list; *pch != NULL; pch++) {
3260 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003261
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003262 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003263
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003264 case AF_INET:
3265 {
3266 struct sockaddr_in sin;
3267 memset(&sin, 0, sizeof(sin));
3268 sin.sin_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003269#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003270 sin.sin_len = sizeof(sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003271#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003272 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
3273 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00003274
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003275 if (pch == h->h_addr_list && alen >= sizeof(sin))
3276 memcpy((char *) addr, &sin, sizeof(sin));
3277 break;
3278 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003279
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003280#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003281 case AF_INET6:
3282 {
3283 struct sockaddr_in6 sin6;
3284 memset(&sin6, 0, sizeof(sin6));
3285 sin6.sin6_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003286#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003287 sin6.sin6_len = sizeof(sin6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003288#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003289 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
3290 tmp = makeipaddr((struct sockaddr *)&sin6,
3291 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00003292
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003293 if (pch == h->h_addr_list && alen >= sizeof(sin6))
3294 memcpy((char *) addr, &sin6, sizeof(sin6));
3295 break;
3296 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003297#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00003298
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003299 default: /* can't happen */
3300 PyErr_SetString(socket_error,
3301 "unsupported address family");
3302 return NULL;
3303 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003304
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003305 if (tmp == NULL)
3306 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003307
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003308 status = PyList_Append(addr_list, tmp);
3309 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003310
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003311 if (status)
3312 goto err;
3313 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003315 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003316
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003317 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003318 Py_XDECREF(name_list);
3319 Py_XDECREF(addr_list);
3320 return rtn_tuple;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003321}
3322
3323
3324/* Python interface to gethostbyname_ex(name). */
3325
3326/*ARGSUSED*/
3327static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003328socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003329{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003330 char *name;
3331 struct hostent *h;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003332#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003333 struct sockaddr_storage addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003334#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003335 struct sockaddr_in addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003336#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003337 struct sockaddr *sa;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003338 PyObject *ret = NULL;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003339#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003340 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003341#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003342 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003343#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003344 char buf[16384];
3345 int buf_len = (sizeof buf) - 1;
3346 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003347#endif
3348#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003349 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003350#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003351#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003352
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003353 if (!PyArg_ParseTuple(args, "et:gethostbyname_ex", "idna", &name))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003354 return NULL;
3355 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003356 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003357 Py_BEGIN_ALLOW_THREADS
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003358#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003359#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003360 result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
3361 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003362#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003363 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003364#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003365 memset((void *) &data, '\0', sizeof(data));
3366 result = gethostbyname_r(name, &hp_allocated, &data);
3367 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003368#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003369#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003370#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003371 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003372#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003373 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003374#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003375 Py_END_ALLOW_THREADS
3376 /* Some C libraries would require addr.__ss_family instead of
3377 addr.ss_family.
3378 Therefore, we cast the sockaddr_storage into sockaddr to
3379 access sa_family. */
3380 sa = (struct sockaddr*)&addr;
3381 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
3382 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003383#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003384 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00003385#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003386finally:
3387 PyMem_Free(name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003388 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003389}
3390
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003391PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003392"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
3393\n\
3394Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003395for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003396
3397
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003398/* Python interface to gethostbyaddr(IP). */
3399
3400/*ARGSUSED*/
3401static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003402socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003403{
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003404#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003405 struct sockaddr_storage addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003406#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003407 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003408#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003409 struct sockaddr *sa = (struct sockaddr *)&addr;
3410 char *ip_num;
3411 struct hostent *h;
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003412 PyObject *ret = NULL;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003413#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003414 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003415#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003416 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003417#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003418 /* glibcs up to 2.10 assume that the buf argument to
3419 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
3420 does not ensure. The attribute below instructs the compiler
3421 to maintain this alignment. */
3422 char buf[16384] Py_ALIGNED(8);
3423 int buf_len = (sizeof buf) - 1;
3424 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003425#endif
3426#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003427 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003428#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003429#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003430 char *ap;
3431 int al;
3432 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003433
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003434 if (!PyArg_ParseTuple(args, "et:gethostbyaddr", "idna", &ip_num))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003435 return NULL;
3436 af = AF_UNSPEC;
3437 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003438 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003439 af = sa->sa_family;
3440 ap = NULL;
Brett Cannonb94767f2011-02-22 20:15:44 +00003441 /* al = 0; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003442 switch (af) {
3443 case AF_INET:
3444 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
3445 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
3446 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003447#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003448 case AF_INET6:
3449 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
3450 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
3451 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003452#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003453 default:
3454 PyErr_SetString(socket_error, "unsupported address family");
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003455 goto finally;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003456 }
3457 Py_BEGIN_ALLOW_THREADS
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003458#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003459#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003460 result = gethostbyaddr_r(ap, al, af,
3461 &hp_allocated, buf, buf_len,
3462 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003463#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003464 h = gethostbyaddr_r(ap, al, af,
3465 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003466#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003467 memset((void *) &data, '\0', sizeof(data));
3468 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
3469 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003470#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003471#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003472#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003473 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003474#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003475 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003476#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003477 Py_END_ALLOW_THREADS
3478 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003479#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003480 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003481#endif
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00003482finally:
3483 PyMem_Free(ip_num);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003484 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003485}
3486
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003487PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003488"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
3489\n\
3490Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003491for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003492
Guido van Rossum30a685f1991-06-27 15:51:29 +00003493
3494/* Python interface to getservbyname(name).
3495 This only returns the port number, since the other info is already
3496 known or not useful (like the list of aliases). */
3497
3498/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003499static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003500socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003501{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003502 char *name, *proto=NULL;
3503 struct servent *sp;
3504 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
3505 return NULL;
3506 Py_BEGIN_ALLOW_THREADS
3507 sp = getservbyname(name, proto);
3508 Py_END_ALLOW_THREADS
3509 if (sp == NULL) {
3510 PyErr_SetString(socket_error, "service/proto not found");
3511 return NULL;
3512 }
3513 return PyLong_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00003514}
3515
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003516PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00003517"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003518\n\
3519Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00003520The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3521otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003522
Guido van Rossum30a685f1991-06-27 15:51:29 +00003523
Barry Warsaw11b91a02004-06-28 00:50:43 +00003524/* Python interface to getservbyport(port).
3525 This only returns the service name, since the other info is already
3526 known or not useful (like the list of aliases). */
3527
3528/*ARGSUSED*/
3529static PyObject *
3530socket_getservbyport(PyObject *self, PyObject *args)
3531{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003532 int port;
3533 char *proto=NULL;
3534 struct servent *sp;
3535 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
3536 return NULL;
3537 if (port < 0 || port > 0xffff) {
3538 PyErr_SetString(
3539 PyExc_OverflowError,
3540 "getservbyport: port must be 0-65535.");
3541 return NULL;
3542 }
3543 Py_BEGIN_ALLOW_THREADS
3544 sp = getservbyport(htons((short)port), proto);
3545 Py_END_ALLOW_THREADS
3546 if (sp == NULL) {
3547 PyErr_SetString(socket_error, "port/proto not found");
3548 return NULL;
3549 }
3550 return PyUnicode_FromString(sp->s_name);
Barry Warsaw11b91a02004-06-28 00:50:43 +00003551}
3552
3553PyDoc_STRVAR(getservbyport_doc,
3554"getservbyport(port[, protocolname]) -> string\n\
3555\n\
3556Return the service name from a port number and protocol name.\n\
3557The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3558otherwise any protocol will match.");
3559
Guido van Rossum3901d851996-12-19 16:35:04 +00003560/* Python interface to getprotobyname(name).
3561 This only returns the protocol number, since the other info is
3562 already known or not useful (like the list of aliases). */
3563
3564/*ARGSUSED*/
3565static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003566socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00003567{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003568 char *name;
3569 struct protoent *sp;
3570 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
3571 return NULL;
3572 Py_BEGIN_ALLOW_THREADS
3573 sp = getprotobyname(name);
3574 Py_END_ALLOW_THREADS
3575 if (sp == NULL) {
3576 PyErr_SetString(socket_error, "protocol not found");
3577 return NULL;
3578 }
3579 return PyLong_FromLong((long) sp->p_proto);
Guido van Rossum3901d851996-12-19 16:35:04 +00003580}
3581
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003582PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003583"getprotobyname(name) -> integer\n\
3584\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003585Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003586
Guido van Rossum3901d851996-12-19 16:35:04 +00003587
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003588#ifndef NO_DUP
3589/* dup() function for socket fds */
3590
3591static PyObject *
3592socket_dup(PyObject *self, PyObject *fdobj)
3593{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003594 SOCKET_T fd, newfd;
3595 PyObject *newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003596
3597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003598 fd = PyLong_AsSocket_t(fdobj);
3599 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
3600 return NULL;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003601
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003602 newfd = dup_socket(fd);
3603 if (newfd == INVALID_SOCKET)
3604 return set_error();
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003606 newfdobj = PyLong_FromSocket_t(newfd);
3607 if (newfdobj == NULL)
3608 SOCKETCLOSE(newfd);
3609 return newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003610}
3611
3612PyDoc_STRVAR(dup_doc,
3613"dup(integer) -> integer\n\
3614\n\
3615Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
3616sockets; on some platforms os.dup() won't work for socket file descriptors.");
3617#endif
3618
3619
Dave Cole331708b2004-08-09 04:51:41 +00003620#ifdef HAVE_SOCKETPAIR
3621/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00003622 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00003623 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00003624
3625/*ARGSUSED*/
3626static PyObject *
3627socket_socketpair(PyObject *self, PyObject *args)
3628{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003629 PySocketSockObject *s0 = NULL, *s1 = NULL;
3630 SOCKET_T sv[2];
3631 int family, type = SOCK_STREAM, proto = 0;
3632 PyObject *res = NULL;
Dave Cole331708b2004-08-09 04:51:41 +00003633
3634#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003635 family = AF_UNIX;
Dave Cole331708b2004-08-09 04:51:41 +00003636#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003637 family = AF_INET;
Dave Cole331708b2004-08-09 04:51:41 +00003638#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003639 if (!PyArg_ParseTuple(args, "|iii:socketpair",
3640 &family, &type, &proto))
3641 return NULL;
3642 /* Create a pair of socket fds */
3643 if (socketpair(family, type, proto, sv) < 0)
3644 return set_error();
3645 s0 = new_sockobject(sv[0], family, type, proto);
3646 if (s0 == NULL)
3647 goto finally;
3648 s1 = new_sockobject(sv[1], family, type, proto);
3649 if (s1 == NULL)
3650 goto finally;
3651 res = PyTuple_Pack(2, s0, s1);
Dave Cole331708b2004-08-09 04:51:41 +00003652
3653finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003654 if (res == NULL) {
3655 if (s0 == NULL)
3656 SOCKETCLOSE(sv[0]);
3657 if (s1 == NULL)
3658 SOCKETCLOSE(sv[1]);
3659 }
3660 Py_XDECREF(s0);
3661 Py_XDECREF(s1);
3662 return res;
Dave Cole331708b2004-08-09 04:51:41 +00003663}
3664
3665PyDoc_STRVAR(socketpair_doc,
3666"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
3667\n\
3668Create a pair of socket objects from the sockets returned by the platform\n\
3669socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00003670The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00003671AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00003672
3673#endif /* HAVE_SOCKETPAIR */
3674
3675
Guido van Rossum006bf911996-06-12 04:04:55 +00003676static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003677socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003678{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003679 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00003680
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003681 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
3682 return NULL;
3683 }
3684 if (x1 < 0) {
3685 PyErr_SetString(PyExc_OverflowError,
3686 "can't convert negative number to unsigned long");
3687 return NULL;
3688 }
3689 x2 = (unsigned int)ntohs((unsigned short)x1);
3690 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00003691}
3692
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003693PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003694"ntohs(integer) -> integer\n\
3695\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003696Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003697
3698
Guido van Rossum006bf911996-06-12 04:04:55 +00003699static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003700socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003701{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003702 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003703
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003704 if (PyLong_Check(arg)) {
3705 x = PyLong_AsUnsignedLong(arg);
3706 if (x == (unsigned long) -1 && PyErr_Occurred())
3707 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003708#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003709 {
3710 unsigned long y;
3711 /* only want the trailing 32 bits */
3712 y = x & 0xFFFFFFFFUL;
3713 if (y ^ x)
3714 return PyErr_Format(PyExc_OverflowError,
3715 "long int larger than 32 bits");
3716 x = y;
3717 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003718#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003719 }
3720 else
3721 return PyErr_Format(PyExc_TypeError,
3722 "expected int/long, %s found",
3723 Py_TYPE(arg)->tp_name);
3724 if (x == (unsigned long) -1 && PyErr_Occurred())
3725 return NULL;
3726 return PyLong_FromUnsignedLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003727}
3728
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003729PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003730"ntohl(integer) -> integer\n\
3731\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003732Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003733
3734
Guido van Rossum006bf911996-06-12 04:04:55 +00003735static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003736socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003737{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003738 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00003739
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003740 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
3741 return NULL;
3742 }
3743 if (x1 < 0) {
3744 PyErr_SetString(PyExc_OverflowError,
3745 "can't convert negative number to unsigned long");
3746 return NULL;
3747 }
3748 x2 = (unsigned int)htons((unsigned short)x1);
3749 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00003750}
3751
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003752PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003753"htons(integer) -> integer\n\
3754\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003755Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003756
3757
Guido van Rossum006bf911996-06-12 04:04:55 +00003758static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003759socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003760{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003761 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003762
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003763 if (PyLong_Check(arg)) {
3764 x = PyLong_AsUnsignedLong(arg);
3765 if (x == (unsigned long) -1 && PyErr_Occurred())
3766 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003767#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003768 {
3769 unsigned long y;
3770 /* only want the trailing 32 bits */
3771 y = x & 0xFFFFFFFFUL;
3772 if (y ^ x)
3773 return PyErr_Format(PyExc_OverflowError,
3774 "long int larger than 32 bits");
3775 x = y;
3776 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003777#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003778 }
3779 else
3780 return PyErr_Format(PyExc_TypeError,
3781 "expected int/long, %s found",
3782 Py_TYPE(arg)->tp_name);
3783 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003784}
3785
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003786PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003787"htonl(integer) -> integer\n\
3788\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003789Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003790
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003791/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003792
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003793PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum7d0a8262007-05-21 23:13:11 +00003794"inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003795\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003796Convert 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 +00003797binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003798
3799static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003800socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003801{
Guido van Rossuma2e48551999-09-09 15:42:59 +00003802#ifndef INADDR_NONE
3803#define INADDR_NONE (-1)
3804#endif
Neal Norwitz88f115b2003-02-13 02:15:42 +00003805#ifdef HAVE_INET_ATON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003806 struct in_addr buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003807#endif
3808
3809#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
Benjamin Petersonf91df042009-02-13 02:50:59 +00003810#if (SIZEOF_INT != 4)
3811#error "Not sure if in_addr_t exists and int is not 32-bits."
3812#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003813 /* Have to use inet_addr() instead */
3814 unsigned int packed_addr;
Tim Peters1df9fdd2003-02-13 03:13:40 +00003815#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003816 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003817
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003818 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
3819 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003820
Tim Peters1df9fdd2003-02-13 03:13:40 +00003821
3822#ifdef HAVE_INET_ATON
Thomas Wouters477c8d52006-05-27 19:21:47 +00003823
3824#ifdef USE_INET_ATON_WEAKLINK
3825 if (inet_aton != NULL) {
3826#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003827 if (inet_aton(ip_addr, &buf))
3828 return PyBytes_FromStringAndSize((char *)(&buf),
3829 sizeof(buf));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003830
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003831 PyErr_SetString(socket_error,
3832 "illegal IP address string passed to inet_aton");
3833 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003834
Thomas Wouters477c8d52006-05-27 19:21:47 +00003835#ifdef USE_INET_ATON_WEAKLINK
3836 } else {
3837#endif
3838
3839#endif
3840
3841#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3842
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003843 /* special-case this address as inet_addr might return INADDR_NONE
3844 * for this */
3845 if (strcmp(ip_addr, "255.255.255.255") == 0) {
3846 packed_addr = 0xFFFFFFFF;
3847 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00003848
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003849 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003850
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003851 if (packed_addr == INADDR_NONE) { /* invalid address */
3852 PyErr_SetString(socket_error,
3853 "illegal IP address string passed to inet_aton");
3854 return NULL;
3855 }
3856 }
3857 return PyBytes_FromStringAndSize((char *) &packed_addr,
3858 sizeof(packed_addr));
Thomas Wouters477c8d52006-05-27 19:21:47 +00003859
3860#ifdef USE_INET_ATON_WEAKLINK
3861 }
3862#endif
3863
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003864#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003865}
3866
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003867PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00003868"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003869\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003870Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003871
3872static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003873socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003874{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003875 char *packed_str;
3876 int addr_len;
3877 struct in_addr packed_addr;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003878
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003879 if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
3880 return NULL;
3881 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00003882
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003883 if (addr_len != sizeof(packed_addr)) {
3884 PyErr_SetString(socket_error,
3885 "packed IP wrong length for inet_ntoa");
3886 return NULL;
3887 }
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003888
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003889 memcpy(&packed_addr, packed_str, addr_len);
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003890
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003891 return PyUnicode_FromString(inet_ntoa(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003892}
Guido van Rossum82a5c661998-07-07 20:45:43 +00003893
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003894#ifdef HAVE_INET_PTON
3895
3896PyDoc_STRVAR(inet_pton_doc,
3897"inet_pton(af, ip) -> packed IP address string\n\
3898\n\
3899Convert an IP address from string format to a packed string suitable\n\
3900for use with low-level network functions.");
3901
3902static PyObject *
3903socket_inet_pton(PyObject *self, PyObject *args)
3904{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003905 int af;
3906 char* ip;
3907 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003908#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003909 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003910#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003911 char packed[sizeof(struct in_addr)];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003912#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003913 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
3914 return NULL;
3915 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003916
Martin v. Löwis04697e82004-06-02 12:35:29 +00003917#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003918 if(af == AF_INET6) {
3919 PyErr_SetString(socket_error,
3920 "can't use AF_INET6, IPv6 is disabled");
3921 return NULL;
3922 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003923#endif
Martin v. Löwis10649092003-08-05 06:25:06 +00003924
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003925 retval = inet_pton(af, ip, packed);
3926 if (retval < 0) {
3927 PyErr_SetFromErrno(socket_error);
3928 return NULL;
3929 } else if (retval == 0) {
3930 PyErr_SetString(socket_error,
3931 "illegal IP address string passed to inet_pton");
3932 return NULL;
3933 } else if (af == AF_INET) {
3934 return PyBytes_FromStringAndSize(packed,
3935 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003936#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003937 } else if (af == AF_INET6) {
3938 return PyBytes_FromStringAndSize(packed,
3939 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003940#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003941 } else {
3942 PyErr_SetString(socket_error, "unknown address family");
3943 return NULL;
3944 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003945}
Thomas Wouters477c8d52006-05-27 19:21:47 +00003946
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003947PyDoc_STRVAR(inet_ntop_doc,
3948"inet_ntop(af, packed_ip) -> string formatted IP address\n\
3949\n\
3950Convert a packed IP address of the given family to string format.");
3951
3952static PyObject *
3953socket_inet_ntop(PyObject *self, PyObject *args)
3954{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003955 int af;
3956 char* packed;
3957 int len;
3958 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003959#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003960 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003961#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003962 char ip[INET_ADDRSTRLEN + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003963#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00003964
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003965 /* Guarantee NUL-termination for PyUnicode_FromString() below */
3966 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003967
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003968 if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
3969 return NULL;
3970 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003971
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003972 if (af == AF_INET) {
3973 if (len != sizeof(struct in_addr)) {
3974 PyErr_SetString(PyExc_ValueError,
3975 "invalid length of packed IP address string");
3976 return NULL;
3977 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003978#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003979 } else if (af == AF_INET6) {
3980 if (len != sizeof(struct in6_addr)) {
3981 PyErr_SetString(PyExc_ValueError,
3982 "invalid length of packed IP address string");
3983 return NULL;
3984 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003985#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003986 } else {
3987 PyErr_Format(PyExc_ValueError,
3988 "unknown address family %d", af);
3989 return NULL;
3990 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003992 retval = inet_ntop(af, packed, ip, sizeof(ip));
3993 if (!retval) {
3994 PyErr_SetFromErrno(socket_error);
3995 return NULL;
3996 } else {
3997 return PyUnicode_FromString(retval);
3998 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003999
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004000 /* NOTREACHED */
4001 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
4002 return NULL;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004003}
4004
4005#endif /* HAVE_INET_PTON */
4006
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004007/* Python interface to getaddrinfo(host, port). */
4008
4009/*ARGSUSED*/
4010static PyObject *
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004011socket_getaddrinfo(PyObject *self, PyObject *args, PyObject* kwargs)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004012{
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004013 static char* kwnames[] = {"host", "port", "family", "type", "proto",
4014 "flags", 0};
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004015 struct addrinfo hints, *res;
4016 struct addrinfo *res0 = NULL;
4017 PyObject *hobj = NULL;
4018 PyObject *pobj = (PyObject *)NULL;
4019 char pbuf[30];
4020 char *hptr, *pptr;
4021 int family, socktype, protocol, flags;
4022 int error;
4023 PyObject *all = (PyObject *)NULL;
4024 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004025
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004026 family = socktype = protocol = flags = 0;
4027 family = AF_UNSPEC;
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004028 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|iiii:getaddrinfo",
4029 kwnames, &hobj, &pobj, &family, &socktype,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004030 &protocol, &flags)) {
4031 return NULL;
4032 }
4033 if (hobj == Py_None) {
4034 hptr = NULL;
4035 } else if (PyUnicode_Check(hobj)) {
4036 idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
4037 if (!idna)
4038 return NULL;
4039 assert(PyBytes_Check(idna));
4040 hptr = PyBytes_AS_STRING(idna);
4041 } else if (PyBytes_Check(hobj)) {
4042 hptr = PyBytes_AsString(hobj);
4043 } else {
4044 PyErr_SetString(PyExc_TypeError,
4045 "getaddrinfo() argument 1 must be string or None");
4046 return NULL;
4047 }
4048 if (PyLong_CheckExact(pobj)) {
4049 long value = PyLong_AsLong(pobj);
4050 if (value == -1 && PyErr_Occurred())
4051 goto err;
4052 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
4053 pptr = pbuf;
4054 } else if (PyUnicode_Check(pobj)) {
4055 pptr = _PyUnicode_AsString(pobj);
Alexander Belopolskye239d232010-12-08 23:31:48 +00004056 if (pptr == NULL)
4057 goto err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004058 } else if (PyBytes_Check(pobj)) {
Alexander Belopolskye239d232010-12-08 23:31:48 +00004059 pptr = PyBytes_AS_STRING(pobj);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004060 } else if (pobj == Py_None) {
4061 pptr = (char *)NULL;
4062 } else {
4063 PyErr_SetString(socket_error, "Int or String expected");
4064 goto err;
4065 }
4066 memset(&hints, 0, sizeof(hints));
4067 hints.ai_family = family;
4068 hints.ai_socktype = socktype;
4069 hints.ai_protocol = protocol;
4070 hints.ai_flags = flags;
4071 Py_BEGIN_ALLOW_THREADS
4072 ACQUIRE_GETADDRINFO_LOCK
4073 error = getaddrinfo(hptr, pptr, &hints, &res0);
4074 Py_END_ALLOW_THREADS
4075 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
4076 if (error) {
4077 set_gaierror(error);
4078 goto err;
4079 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004080
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004081 if ((all = PyList_New(0)) == NULL)
4082 goto err;
4083 for (res = res0; res; res = res->ai_next) {
4084 PyObject *single;
4085 PyObject *addr =
4086 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
4087 if (addr == NULL)
4088 goto err;
4089 single = Py_BuildValue("iiisO", res->ai_family,
4090 res->ai_socktype, res->ai_protocol,
4091 res->ai_canonname ? res->ai_canonname : "",
4092 addr);
4093 Py_DECREF(addr);
4094 if (single == NULL)
4095 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004096
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004097 if (PyList_Append(all, single))
4098 goto err;
4099 Py_XDECREF(single);
4100 }
4101 Py_XDECREF(idna);
4102 if (res0)
4103 freeaddrinfo(res0);
4104 return all;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004105 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004106 Py_XDECREF(all);
4107 Py_XDECREF(idna);
4108 if (res0)
4109 freeaddrinfo(res0);
4110 return (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004111}
4112
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004113PyDoc_STRVAR(getaddrinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004114"getaddrinfo(host, port [, family, socktype, proto, flags])\n\
4115 -> list of (family, socktype, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004116\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004117Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004118
4119/* Python interface to getnameinfo(sa, flags). */
4120
4121/*ARGSUSED*/
4122static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004123socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004124{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004125 PyObject *sa = (PyObject *)NULL;
4126 int flags;
4127 char *hostp;
4128 int port, flowinfo, scope_id;
4129 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
4130 struct addrinfo hints, *res = NULL;
4131 int error;
4132 PyObject *ret = (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004133
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004134 flags = flowinfo = scope_id = 0;
4135 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
4136 return NULL;
4137 if (!PyTuple_Check(sa)) {
4138 PyErr_SetString(PyExc_TypeError,
4139 "getnameinfo() argument 1 must be a tuple");
4140 return NULL;
4141 }
4142 if (!PyArg_ParseTuple(sa, "si|ii",
4143 &hostp, &port, &flowinfo, &scope_id))
4144 return NULL;
4145 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
4146 memset(&hints, 0, sizeof(hints));
4147 hints.ai_family = AF_UNSPEC;
4148 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Martin v. Löwis112c0f32010-08-25 07:38:15 +00004149 hints.ai_flags = AI_NUMERICHOST; /* don't do any name resolution */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004150 Py_BEGIN_ALLOW_THREADS
4151 ACQUIRE_GETADDRINFO_LOCK
4152 error = getaddrinfo(hostp, pbuf, &hints, &res);
4153 Py_END_ALLOW_THREADS
4154 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
4155 if (error) {
4156 set_gaierror(error);
4157 goto fail;
4158 }
4159 if (res->ai_next) {
4160 PyErr_SetString(socket_error,
4161 "sockaddr resolved to multiple addresses");
4162 goto fail;
4163 }
4164 switch (res->ai_family) {
4165 case AF_INET:
4166 {
4167 if (PyTuple_GET_SIZE(sa) != 2) {
4168 PyErr_SetString(socket_error,
4169 "IPv4 sockaddr must be 2 tuple");
4170 goto fail;
4171 }
4172 break;
4173 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00004174#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004175 case AF_INET6:
4176 {
4177 struct sockaddr_in6 *sin6;
4178 sin6 = (struct sockaddr_in6 *)res->ai_addr;
4179 sin6->sin6_flowinfo = flowinfo;
4180 sin6->sin6_scope_id = scope_id;
4181 break;
4182 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004183#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004184 }
Antoine Pitrou19467d22010-08-17 19:33:30 +00004185 error = getnameinfo(res->ai_addr, (socklen_t) res->ai_addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004186 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
4187 if (error) {
4188 set_gaierror(error);
4189 goto fail;
4190 }
4191 ret = Py_BuildValue("ss", hbuf, pbuf);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004192
4193fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004194 if (res)
4195 freeaddrinfo(res);
4196 return ret;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004197}
4198
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004199PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004200"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004201\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004202Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004203
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004204
4205/* Python API to getting and setting the default timeout value. */
4206
4207static PyObject *
4208socket_getdefaulttimeout(PyObject *self)
4209{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004210 if (defaulttimeout < 0.0) {
4211 Py_INCREF(Py_None);
4212 return Py_None;
4213 }
4214 else
4215 return PyFloat_FromDouble(defaulttimeout);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004216}
4217
4218PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004219"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004220\n\
4221Returns the default timeout in floating seconds for new socket objects.\n\
4222A value of None indicates that new socket objects have no timeout.\n\
4223When the socket module is first imported, the default is None.");
4224
4225static PyObject *
4226socket_setdefaulttimeout(PyObject *self, PyObject *arg)
4227{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004228 double timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004229
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004230 if (arg == Py_None)
4231 timeout = -1.0;
4232 else {
4233 timeout = PyFloat_AsDouble(arg);
4234 if (timeout < 0.0) {
4235 if (!PyErr_Occurred())
4236 PyErr_SetString(PyExc_ValueError,
4237 "Timeout value out of range");
4238 return NULL;
4239 }
4240 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004241
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004242 defaulttimeout = timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004243
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004244 Py_INCREF(Py_None);
4245 return Py_None;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004246}
4247
4248PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004249"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004250\n\
4251Set the default timeout in floating seconds for new socket objects.\n\
4252A value of None indicates that new socket objects have no timeout.\n\
4253When the socket module is first imported, the default is None.");
4254
4255
Guido van Rossum30a685f1991-06-27 15:51:29 +00004256/* List of functions exported by this module. */
4257
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004258static PyMethodDef socket_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004259 {"gethostbyname", socket_gethostbyname,
4260 METH_VARARGS, gethostbyname_doc},
4261 {"gethostbyname_ex", socket_gethostbyname_ex,
4262 METH_VARARGS, ghbn_ex_doc},
4263 {"gethostbyaddr", socket_gethostbyaddr,
4264 METH_VARARGS, gethostbyaddr_doc},
4265 {"gethostname", socket_gethostname,
4266 METH_NOARGS, gethostname_doc},
Antoine Pitrou061cfb52011-02-28 22:25:22 +00004267#ifdef HAVE_SETHOSTNAME
4268 {"sethostname", socket_sethostname,
4269 METH_VARARGS, sethostname_doc},
4270#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004271 {"getservbyname", socket_getservbyname,
4272 METH_VARARGS, getservbyname_doc},
4273 {"getservbyport", socket_getservbyport,
4274 METH_VARARGS, getservbyport_doc},
4275 {"getprotobyname", socket_getprotobyname,
4276 METH_VARARGS, getprotobyname_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004277#ifndef NO_DUP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004278 {"dup", socket_dup,
4279 METH_O, dup_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004280#endif
Dave Cole331708b2004-08-09 04:51:41 +00004281#ifdef HAVE_SOCKETPAIR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004282 {"socketpair", socket_socketpair,
4283 METH_VARARGS, socketpair_doc},
Dave Cole331708b2004-08-09 04:51:41 +00004284#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004285 {"ntohs", socket_ntohs,
4286 METH_VARARGS, ntohs_doc},
4287 {"ntohl", socket_ntohl,
4288 METH_O, ntohl_doc},
4289 {"htons", socket_htons,
4290 METH_VARARGS, htons_doc},
4291 {"htonl", socket_htonl,
4292 METH_O, htonl_doc},
4293 {"inet_aton", socket_inet_aton,
4294 METH_VARARGS, inet_aton_doc},
4295 {"inet_ntoa", socket_inet_ntoa,
4296 METH_VARARGS, inet_ntoa_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004297#ifdef HAVE_INET_PTON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004298 {"inet_pton", socket_inet_pton,
4299 METH_VARARGS, inet_pton_doc},
4300 {"inet_ntop", socket_inet_ntop,
4301 METH_VARARGS, inet_ntop_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004302#endif
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00004303 {"getaddrinfo", (PyCFunction)socket_getaddrinfo,
4304 METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004305 {"getnameinfo", socket_getnameinfo,
4306 METH_VARARGS, getnameinfo_doc},
4307 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
4308 METH_NOARGS, getdefaulttimeout_doc},
4309 {"setdefaulttimeout", socket_setdefaulttimeout,
4310 METH_O, setdefaulttimeout_doc},
4311 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004312};
4313
Guido van Rossum30a685f1991-06-27 15:51:29 +00004314
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004315#ifdef MS_WINDOWS
4316#define OS_INIT_DEFINED
4317
4318/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004319
4320static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004321os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00004322{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004323 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00004324}
4325
4326static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004327os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00004328{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004329 WSADATA WSAData;
4330 int ret;
4331 ret = WSAStartup(0x0101, &WSAData);
4332 switch (ret) {
4333 case 0: /* No error */
4334 Py_AtExit(os_cleanup);
4335 return 1; /* Success */
4336 case WSASYSNOTREADY:
4337 PyErr_SetString(PyExc_ImportError,
4338 "WSAStartup failed: network not ready");
4339 break;
4340 case WSAVERNOTSUPPORTED:
4341 case WSAEINVAL:
4342 PyErr_SetString(
4343 PyExc_ImportError,
4344 "WSAStartup failed: requested version not supported");
4345 break;
4346 default:
4347 PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
4348 break;
4349 }
4350 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004351}
4352
Guido van Rossum8d665e61996-06-26 18:22:49 +00004353#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004354
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004355
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004356#ifdef PYOS_OS2
4357#define OS_INIT_DEFINED
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004358
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004359/* Additional initialization for OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004360
4361static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004362os_init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004363{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004364#ifndef PYCC_GCC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004365 int rc = sock_init();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004366
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004367 if (rc == 0) {
4368 return 1; /* Success */
4369 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004371 PyErr_Format(PyExc_ImportError, "OS/2 TCP/IP Error# %d", sock_errno());
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004372
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004373 return 0; /* Failure */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00004374#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004375 /* No need to initialise sockets with GCC/EMX */
4376 return 1; /* Success */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00004377#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004378}
4379
4380#endif /* PYOS_OS2 */
4381
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004382
4383#ifndef OS_INIT_DEFINED
4384static int
4385os_init(void)
4386{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004387 return 1; /* Success */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004388}
4389#endif
4390
4391
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004392/* C API table - always add new things to the end for binary
4393 compatibility. */
4394static
4395PySocketModule_APIObject PySocketModuleAPI =
4396{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004397 &sock_type,
Antoine Pitrouc4df7842010-12-03 19:59:41 +00004398 NULL,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004399 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004400};
4401
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004402
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004403/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004404
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004405 This module is actually called "_socket", and there's a wrapper
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004406 "socket.py" which implements some additional functionality.
4407 The import of "_socket" may fail with an ImportError exception if
4408 os-specific initialization fails. On Windows, this does WINSOCK
4409 initialization. When WINSOCK is initialized succesfully, a call to
4410 WSACleanup() is scheduled to be made at exit time.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004411*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004412
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004413PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004414"Implementation module for socket operations.\n\
4415\n\
4416See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004417
Martin v. Löwis1a214512008-06-11 05:26:20 +00004418static struct PyModuleDef socketmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004419 PyModuleDef_HEAD_INIT,
4420 PySocket_MODULE_NAME,
4421 socket_doc,
4422 -1,
4423 socket_methods,
4424 NULL,
4425 NULL,
4426 NULL,
4427 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00004428};
4429
Mark Hammondfe51c6d2002-08-02 02:27:13 +00004430PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00004431PyInit__socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004432{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004433 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00004434
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004435 if (!os_init())
4436 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004437
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004438 Py_TYPE(&sock_type) = &PyType_Type;
4439 m = PyModule_Create(&socketmodule);
4440 if (m == NULL)
4441 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004443 socket_error = PyErr_NewException("socket.error",
4444 PyExc_IOError, NULL);
4445 if (socket_error == NULL)
4446 return NULL;
4447 PySocketModuleAPI.error = socket_error;
4448 Py_INCREF(socket_error);
4449 PyModule_AddObject(m, "error", socket_error);
4450 socket_herror = PyErr_NewException("socket.herror",
4451 socket_error, NULL);
4452 if (socket_herror == NULL)
4453 return NULL;
4454 Py_INCREF(socket_herror);
4455 PyModule_AddObject(m, "herror", socket_herror);
4456 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
4457 NULL);
4458 if (socket_gaierror == NULL)
4459 return NULL;
4460 Py_INCREF(socket_gaierror);
4461 PyModule_AddObject(m, "gaierror", socket_gaierror);
4462 socket_timeout = PyErr_NewException("socket.timeout",
4463 socket_error, NULL);
4464 if (socket_timeout == NULL)
4465 return NULL;
Antoine Pitrouc4df7842010-12-03 19:59:41 +00004466 PySocketModuleAPI.timeout_error = socket_timeout;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004467 Py_INCREF(socket_timeout);
4468 PyModule_AddObject(m, "timeout", socket_timeout);
4469 Py_INCREF((PyObject *)&sock_type);
4470 if (PyModule_AddObject(m, "SocketType",
4471 (PyObject *)&sock_type) != 0)
4472 return NULL;
4473 Py_INCREF((PyObject *)&sock_type);
4474 if (PyModule_AddObject(m, "socket",
4475 (PyObject *)&sock_type) != 0)
4476 return NULL;
Guido van Rossum09be4091999-08-09 14:40:40 +00004477
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004478#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004479 has_ipv6 = Py_True;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004480#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004481 has_ipv6 = Py_False;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004482#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004483 Py_INCREF(has_ipv6);
4484 PyModule_AddObject(m, "has_ipv6", has_ipv6);
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004485
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004486 /* Export C API */
4487 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
4488 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
4489 ) != 0)
4490 return NULL;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004491
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004492 /* Address families (we only support AF_INET and AF_UNIX) */
Guido van Rossum09be4091999-08-09 14:40:40 +00004493#ifdef AF_UNSPEC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004494 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00004495#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004496 PyModule_AddIntConstant(m, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004497#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004498 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004499#endif /* AF_INET6 */
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00004500#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004501 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00004502#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00004503#ifdef AF_AX25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004504 /* Amateur Radio AX.25 */
4505 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004506#endif
4507#ifdef AF_IPX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004508 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00004509#endif
4510#ifdef AF_APPLETALK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004511 /* Appletalk DDP */
4512 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00004513#endif
4514#ifdef AF_NETROM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004515 /* Amateur radio NetROM */
4516 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00004517#endif
4518#ifdef AF_BRIDGE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004519 /* Multiprotocol bridge */
4520 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004521#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004522#ifdef AF_ATMPVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004523 /* ATM PVCs */
4524 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004525#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004526#ifdef AF_AAL5
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004527 /* Reserved for Werner's ATM */
4528 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00004529#endif
4530#ifdef AF_X25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004531 /* Reserved for X.25 project */
4532 PyModule_AddIntConstant(m, "AF_X25", AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004533#endif
4534#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004535 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00004536#endif
4537#ifdef AF_ROSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004538 /* Amateur Radio X.25 PLP */
4539 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004540#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004541#ifdef AF_DECnet
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004542 /* Reserved for DECnet project */
4543 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004544#endif
4545#ifdef AF_NETBEUI
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004546 /* Reserved for 802.2LLC project */
4547 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004548#endif
4549#ifdef AF_SECURITY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004550 /* Security callback pseudo AF */
4551 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004552#endif
4553#ifdef AF_KEY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004554 /* PF_KEY key management API */
4555 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004556#endif
4557#ifdef AF_NETLINK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004558 /* */
4559 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
4560 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004561#ifdef NETLINK_SKIP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004562 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004563#endif
4564#ifdef NETLINK_W1
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004565 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004566#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004567 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
4568 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004569#ifdef NETLINK_TCPDIAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004570 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004571#endif
4572#ifdef NETLINK_NFLOG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004573 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004574#endif
Neal Norwitz65851662006-01-16 04:31:40 +00004575#ifdef NETLINK_XFRM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004576 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00004577#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004578#ifdef NETLINK_ARPD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004579 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004580#endif
4581#ifdef NETLINK_ROUTE6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004582 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004583#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004584 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
Thomas Wouterscf297e42007-02-23 15:07:44 +00004585#ifdef NETLINK_DNRTMSG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004586 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004587#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004588#ifdef NETLINK_TAPBASE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004589 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004590#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004591#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004592#ifdef AF_ROUTE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004593 /* Alias to emulate 4.4BSD */
4594 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004595#endif
4596#ifdef AF_ASH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004597 /* Ash */
4598 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004599#endif
4600#ifdef AF_ECONET
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004601 /* Acorn Econet */
4602 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004603#endif
4604#ifdef AF_ATMSVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004605 /* ATM SVCs */
4606 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004607#endif
4608#ifdef AF_SNA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004609 /* Linux SNA Project (nutters!) */
4610 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004611#endif
4612#ifdef AF_IRDA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004613 /* IRDA sockets */
4614 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004615#endif
4616#ifdef AF_PPPOX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004617 /* PPPoX sockets */
4618 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004619#endif
4620#ifdef AF_WANPIPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004621 /* Wanpipe API Sockets */
4622 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004623#endif
4624#ifdef AF_LLC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004625 /* Linux LLC */
4626 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004627#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00004628
Hye-Shik Chang81268602004-02-02 06:05:24 +00004629#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004630 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
4631 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
4632 PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
4633 PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00004634#if !defined(__NetBSD__) && !defined(__DragonFly__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004635 PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00004636#endif
Hye-Shik Chang81268602004-02-02 06:05:24 +00004637#if !defined(__FreeBSD__)
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00004638#if !defined(__NetBSD__) && !defined(__DragonFly__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004639 PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
Gregory P. Smith3e85dfd2010-10-17 00:43:10 +00004640#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004641 PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
4642 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00004643#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004644 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
4645 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
4646 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
Martin v. Löwis12af0482004-01-31 12:34:17 +00004647#endif
4648
Antoine Pitroub156a462010-10-27 20:13:57 +00004649#ifdef AF_PACKET
4650 PyModule_AddIntMacro(m, AF_PACKET);
4651#endif
4652#ifdef PF_PACKET
4653 PyModule_AddIntMacro(m, PF_PACKET);
4654#endif
4655#ifdef PACKET_HOST
4656 PyModule_AddIntMacro(m, PACKET_HOST);
4657#endif
4658#ifdef PACKET_BROADCAST
4659 PyModule_AddIntMacro(m, PACKET_BROADCAST);
4660#endif
4661#ifdef PACKET_MULTICAST
4662 PyModule_AddIntMacro(m, PACKET_MULTICAST);
4663#endif
4664#ifdef PACKET_OTHERHOST
4665 PyModule_AddIntMacro(m, PACKET_OTHERHOST);
4666#endif
4667#ifdef PACKET_OUTGOING
4668 PyModule_AddIntMacro(m, PACKET_OUTGOING);
4669#endif
4670#ifdef PACKET_LOOPBACK
4671 PyModule_AddIntMacro(m, PACKET_LOOPBACK);
4672#endif
4673#ifdef PACKET_FASTROUTE
4674 PyModule_AddIntMacro(m, PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00004675#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004676
Christian Heimes043d6f62008-01-07 17:19:16 +00004677#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004678 PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
Christian Heimes043d6f62008-01-07 17:19:16 +00004679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004680 /* for addresses */
4681 PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
4682 PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
4683 PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
Christian Heimes043d6f62008-01-07 17:19:16 +00004684
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004685 PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
4686 PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
4687 PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
Christian Heimes043d6f62008-01-07 17:19:16 +00004688
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004689 /* for setsockopt() */
4690 PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
4691 PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
4692 PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
4693 PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
4694 TIPC_DEST_DROPPABLE);
4695 PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
Christian Heimes043d6f62008-01-07 17:19:16 +00004696
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004697 PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
4698 TIPC_LOW_IMPORTANCE);
4699 PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
4700 TIPC_MEDIUM_IMPORTANCE);
4701 PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
4702 TIPC_HIGH_IMPORTANCE);
4703 PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
4704 TIPC_CRITICAL_IMPORTANCE);
Christian Heimes043d6f62008-01-07 17:19:16 +00004705
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004706 /* for subscriptions */
4707 PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
4708 PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
Christian Heimes25bb7832008-01-11 16:17:00 +00004709#ifdef TIPC_SUB_CANCEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004710 /* doesn't seem to be available everywhere */
4711 PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
Christian Heimes25bb7832008-01-11 16:17:00 +00004712#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004713 PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
4714 PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
4715 PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
4716 PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
4717 PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
4718 PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
Christian Heimes043d6f62008-01-07 17:19:16 +00004719#endif
4720
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004721 /* Socket types */
4722 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
4723 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004724/* We have incomplete socket support. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004725 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
4726 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00004727#if defined(SOCK_RDM)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004728 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004729#endif
Antoine Pitroub1c54962010-10-14 15:05:38 +00004730#ifdef SOCK_CLOEXEC
4731 PyModule_AddIntConstant(m, "SOCK_CLOEXEC", SOCK_CLOEXEC);
4732#endif
4733#ifdef SOCK_NONBLOCK
4734 PyModule_AddIntConstant(m, "SOCK_NONBLOCK", SOCK_NONBLOCK);
4735#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004736
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004737#ifdef SO_DEBUG
4738 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004739#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004740#ifdef SO_ACCEPTCONN
4741 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004742#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004743#ifdef SO_REUSEADDR
4744 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004745#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00004746#ifdef SO_EXCLUSIVEADDRUSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004747 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00004748#endif
4749
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004750#ifdef SO_KEEPALIVE
4751 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004752#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004753#ifdef SO_DONTROUTE
4754 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004755#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004756#ifdef SO_BROADCAST
4757 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004758#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004759#ifdef SO_USELOOPBACK
4760 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004761#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004762#ifdef SO_LINGER
4763 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004764#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004765#ifdef SO_OOBINLINE
4766 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004767#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004768#ifdef SO_REUSEPORT
4769 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004770#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004771#ifdef SO_SNDBUF
4772 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004773#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004774#ifdef SO_RCVBUF
4775 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004776#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004777#ifdef SO_SNDLOWAT
4778 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004779#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004780#ifdef SO_RCVLOWAT
4781 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004782#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004783#ifdef SO_SNDTIMEO
4784 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004785#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004786#ifdef SO_RCVTIMEO
4787 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004788#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004789#ifdef SO_ERROR
4790 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004791#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004792#ifdef SO_TYPE
4793 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004794#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004795#ifdef SO_SETFIB
4796 PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
Larry Hastingsf0f37952010-04-02 11:47:10 +00004797#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004798
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004799 /* Maximum number of connections for "listen" */
4800#ifdef SOMAXCONN
4801 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004802#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004803 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004804#endif
4805
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004806 /* Flags for send, recv */
4807#ifdef MSG_OOB
4808 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004809#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004810#ifdef MSG_PEEK
4811 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004812#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004813#ifdef MSG_DONTROUTE
4814 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004815#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004816#ifdef MSG_DONTWAIT
4817 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00004818#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004819#ifdef MSG_EOR
4820 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004821#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004822#ifdef MSG_TRUNC
4823 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004824#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004825#ifdef MSG_CTRUNC
4826 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004827#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004828#ifdef MSG_WAITALL
4829 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004830#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004831#ifdef MSG_BTAG
4832 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004833#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004834#ifdef MSG_ETAG
4835 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004836#endif
4837
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004838 /* Protocol level and numbers, usable for [gs]etsockopt */
4839#ifdef SOL_SOCKET
4840 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004841#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004842#ifdef SOL_IP
4843 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004844#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004845 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00004846#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004847#ifdef SOL_IPX
4848 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00004849#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004850#ifdef SOL_AX25
4851 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004852#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004853#ifdef SOL_ATALK
4854 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00004855#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004856#ifdef SOL_NETROM
4857 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00004858#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004859#ifdef SOL_ROSE
4860 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004861#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004862#ifdef SOL_TCP
4863 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004864#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004865 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00004866#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004867#ifdef SOL_UDP
4868 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004869#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004870 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00004871#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004872#ifdef IPPROTO_IP
4873 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00004874#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004875 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004876#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004877#ifdef IPPROTO_HOPOPTS
4878 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004879#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004880#ifdef IPPROTO_ICMP
4881 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00004882#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004883 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004884#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004885#ifdef IPPROTO_IGMP
4886 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004887#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004888#ifdef IPPROTO_GGP
4889 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004890#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004891#ifdef IPPROTO_IPV4
4892 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004893#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004894#ifdef IPPROTO_IPV6
4895 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisa0f17342003-10-03 13:56:20 +00004896#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004897#ifdef IPPROTO_IPIP
4898 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004899#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004900#ifdef IPPROTO_TCP
4901 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00004902#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004903 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004904#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004905#ifdef IPPROTO_EGP
4906 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004907#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004908#ifdef IPPROTO_PUP
4909 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004910#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004911#ifdef IPPROTO_UDP
4912 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00004913#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004914 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004915#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004916#ifdef IPPROTO_IDP
4917 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004918#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004919#ifdef IPPROTO_HELLO
4920 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004921#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004922#ifdef IPPROTO_ND
4923 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004924#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004925#ifdef IPPROTO_TP
4926 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004927#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004928#ifdef IPPROTO_IPV6
4929 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004930#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004931#ifdef IPPROTO_ROUTING
4932 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004933#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004934#ifdef IPPROTO_FRAGMENT
4935 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004936#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004937#ifdef IPPROTO_RSVP
4938 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004939#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004940#ifdef IPPROTO_GRE
4941 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004942#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004943#ifdef IPPROTO_ESP
4944 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004945#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004946#ifdef IPPROTO_AH
4947 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004948#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004949#ifdef IPPROTO_MOBILE
4950 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004951#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004952#ifdef IPPROTO_ICMPV6
4953 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004954#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004955#ifdef IPPROTO_NONE
4956 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004957#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004958#ifdef IPPROTO_DSTOPTS
4959 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004960#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004961#ifdef IPPROTO_XTP
4962 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004963#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004964#ifdef IPPROTO_EON
4965 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004966#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004967#ifdef IPPROTO_PIM
4968 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004969#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004970#ifdef IPPROTO_IPCOMP
4971 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004972#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004973#ifdef IPPROTO_VRRP
4974 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004975#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004976#ifdef IPPROTO_BIP
4977 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004978#endif
4979/**/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004980#ifdef IPPROTO_RAW
4981 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00004982#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004983 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004984#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004985#ifdef IPPROTO_MAX
4986 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004987#endif
4988
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004989 /* Some port configuration */
4990#ifdef IPPORT_RESERVED
4991 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004992#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004993 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004994#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004995#ifdef IPPORT_USERRESERVED
4996 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004997#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004998 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004999#endif
5000
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005001 /* Some reserved IP v.4 addresses */
5002#ifdef INADDR_ANY
5003 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005004#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005005 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005006#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005007#ifdef INADDR_BROADCAST
5008 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005009#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005010 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005011#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005012#ifdef INADDR_LOOPBACK
5013 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005014#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005015 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005016#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005017#ifdef INADDR_UNSPEC_GROUP
5018 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005019#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005020 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005021#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005022#ifdef INADDR_ALLHOSTS_GROUP
5023 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
5024 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005025#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005026 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005027#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005028#ifdef INADDR_MAX_LOCAL_GROUP
5029 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
5030 INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005031#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005032 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005033#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005034#ifdef INADDR_NONE
5035 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005036#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005037 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00005038#endif
5039
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005040 /* IPv4 [gs]etsockopt options */
5041#ifdef IP_OPTIONS
5042 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005043#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005044#ifdef IP_HDRINCL
5045 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005046#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005047#ifdef IP_TOS
5048 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005049#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005050#ifdef IP_TTL
5051 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005052#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005053#ifdef IP_RECVOPTS
5054 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005055#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005056#ifdef IP_RECVRETOPTS
5057 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005058#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005059#ifdef IP_RECVDSTADDR
5060 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005061#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005062#ifdef IP_RETOPTS
5063 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005064#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005065#ifdef IP_MULTICAST_IF
5066 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005067#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005068#ifdef IP_MULTICAST_TTL
5069 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005070#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005071#ifdef IP_MULTICAST_LOOP
5072 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005073#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005074#ifdef IP_ADD_MEMBERSHIP
5075 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005076#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005077#ifdef IP_DROP_MEMBERSHIP
5078 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00005079#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005080#ifdef IP_DEFAULT_MULTICAST_TTL
5081 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
5082 IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00005083#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005084#ifdef IP_DEFAULT_MULTICAST_LOOP
5085 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
5086 IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00005087#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005088#ifdef IP_MAX_MEMBERSHIPS
5089 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00005090#endif
5091
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005092 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
5093#ifdef IPV6_JOIN_GROUP
5094 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005095#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005096#ifdef IPV6_LEAVE_GROUP
5097 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005098#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005099#ifdef IPV6_MULTICAST_HOPS
5100 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005101#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005102#ifdef IPV6_MULTICAST_IF
5103 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005104#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005105#ifdef IPV6_MULTICAST_LOOP
5106 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005107#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005108#ifdef IPV6_UNICAST_HOPS
5109 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005110#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005111 /* Additional IPV6 socket options, defined in RFC 3493 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00005112#ifdef IPV6_V6ONLY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005113 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005114#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005115 /* Advanced IPV6 socket options, from RFC 3542 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00005116#ifdef IPV6_CHECKSUM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005117 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005118#endif
5119#ifdef IPV6_DONTFRAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005120 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005121#endif
5122#ifdef IPV6_DSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005123 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005124#endif
5125#ifdef IPV6_HOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005126 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005127#endif
5128#ifdef IPV6_HOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005129 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005130#endif
5131#ifdef IPV6_NEXTHOP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005132 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005133#endif
5134#ifdef IPV6_PATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005135 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005136#endif
5137#ifdef IPV6_PKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005138 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005139#endif
5140#ifdef IPV6_RECVDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005141 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005142#endif
5143#ifdef IPV6_RECVHOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005144 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005145#endif
5146#ifdef IPV6_RECVHOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005147 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005148#endif
5149#ifdef IPV6_RECVPKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005150 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005151#endif
5152#ifdef IPV6_RECVRTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005153 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005154#endif
5155#ifdef IPV6_RECVTCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005156 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005157#endif
5158#ifdef IPV6_RTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005159 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005160#endif
5161#ifdef IPV6_RTHDRDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005162 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005163#endif
5164#ifdef IPV6_RTHDR_TYPE_0
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005165 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005166#endif
5167#ifdef IPV6_RECVPATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005168 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005169#endif
5170#ifdef IPV6_TCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005171 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005172#endif
5173#ifdef IPV6_USE_MIN_MTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005174 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005175#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00005176
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005177 /* TCP options */
5178#ifdef TCP_NODELAY
5179 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00005180#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005181#ifdef TCP_MAXSEG
5182 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00005183#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005184#ifdef TCP_CORK
5185 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005186#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005187#ifdef TCP_KEEPIDLE
5188 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005189#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005190#ifdef TCP_KEEPINTVL
5191 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005192#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005193#ifdef TCP_KEEPCNT
5194 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005195#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005196#ifdef TCP_SYNCNT
5197 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005198#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005199#ifdef TCP_LINGER2
5200 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005201#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005202#ifdef TCP_DEFER_ACCEPT
5203 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005204#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005205#ifdef TCP_WINDOW_CLAMP
5206 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005207#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005208#ifdef TCP_INFO
5209 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005210#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005211#ifdef TCP_QUICKACK
5212 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00005213#endif
5214
Guido van Rossum09be4091999-08-09 14:40:40 +00005215
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005216 /* IPX options */
5217#ifdef IPX_TYPE
5218 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00005219#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005220
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005221 /* get{addr,name}info parameters */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005222#ifdef EAI_ADDRFAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005223 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005224#endif
5225#ifdef EAI_AGAIN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005226 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005227#endif
5228#ifdef EAI_BADFLAGS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005229 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005230#endif
5231#ifdef EAI_FAIL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005232 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005233#endif
5234#ifdef EAI_FAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005235 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005236#endif
5237#ifdef EAI_MEMORY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005238 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005239#endif
5240#ifdef EAI_NODATA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005241 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005242#endif
5243#ifdef EAI_NONAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005244 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005245#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00005246#ifdef EAI_OVERFLOW
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005247 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005248#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005249#ifdef EAI_SERVICE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005250 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005251#endif
5252#ifdef EAI_SOCKTYPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005253 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005254#endif
5255#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005256 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005257#endif
5258#ifdef EAI_BADHINTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005259 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005260#endif
5261#ifdef EAI_PROTOCOL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005262 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005263#endif
5264#ifdef EAI_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005265 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005266#endif
5267#ifdef AI_PASSIVE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005268 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005269#endif
5270#ifdef AI_CANONNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005271 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005272#endif
5273#ifdef AI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005274 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005275#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00005276#ifdef AI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005277 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005278#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005279#ifdef AI_MASK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005280 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005281#endif
5282#ifdef AI_ALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005283 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005284#endif
5285#ifdef AI_V4MAPPED_CFG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005286 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005287#endif
5288#ifdef AI_ADDRCONFIG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005289 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005290#endif
5291#ifdef AI_V4MAPPED
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005292 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005293#endif
5294#ifdef AI_DEFAULT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005295 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005296#endif
5297#ifdef NI_MAXHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005298 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005299#endif
5300#ifdef NI_MAXSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005301 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005302#endif
5303#ifdef NI_NOFQDN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005304 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005305#endif
5306#ifdef NI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005307 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005308#endif
5309#ifdef NI_NAMEREQD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005310 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005311#endif
5312#ifdef NI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005313 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005314#endif
5315#ifdef NI_DGRAM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005316 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005317#endif
5318
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005319 /* shutdown() parameters */
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005320#ifdef SHUT_RD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005321 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005322#elif defined(SD_RECEIVE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005323 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005324#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005325 PyModule_AddIntConstant(m, "SHUT_RD", 0);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005326#endif
5327#ifdef SHUT_WR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005328 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005329#elif defined(SD_SEND)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005330 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005331#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005332 PyModule_AddIntConstant(m, "SHUT_WR", 1);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005333#endif
5334#ifdef SHUT_RDWR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005335 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005336#elif defined(SD_BOTH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005337 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005338#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005339 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005340#endif
5341
Christian Heimesfaf2f632008-01-06 16:59:19 +00005342#ifdef SIO_RCVALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005343 {
5344 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
5345 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
5346 int i;
5347 for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {
5348 PyObject *tmp;
5349 tmp = PyLong_FromUnsignedLong(codes[i]);
5350 if (tmp == NULL)
5351 return NULL;
5352 PyModule_AddObject(m, names[i], tmp);
5353 }
5354 }
5355 PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
5356 PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
5357 PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005358#ifdef RCVALL_IPLEVEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005359 PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005360#endif
5361#ifdef RCVALL_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005362 PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005363#endif
Christian Heimesfaf2f632008-01-06 16:59:19 +00005364#endif /* _MSTCPIP_ */
5365
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005366 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00005367#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005368 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005369#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005370 return m;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005371}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005372
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005373
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005374#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +00005375#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005376
5377/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005378/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005379
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005380int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005381inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005382{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005383 if (af == AF_INET) {
Benjamin Petersonf91df042009-02-13 02:50:59 +00005384#if (SIZEOF_INT != 4)
5385#error "Not sure if in_addr_t exists and int is not 32-bits."
5386#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005387 unsigned int packed_addr;
5388 packed_addr = inet_addr(src);
5389 if (packed_addr == INADDR_NONE)
5390 return 0;
5391 memcpy(dst, &packed_addr, 4);
5392 return 1;
5393 }
5394 /* Should set errno to EAFNOSUPPORT */
5395 return -1;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005396}
5397
Martin v. Löwisc925b1532001-07-21 09:42:15 +00005398const char *
5399inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005400{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005401 if (af == AF_INET) {
5402 struct in_addr packed_addr;
5403 if (size < 16)
5404 /* Should set errno to ENOSPC. */
5405 return NULL;
5406 memcpy(&packed_addr, src, sizeof(packed_addr));
5407 return strncpy(dst, inet_ntoa(packed_addr), size);
5408 }
5409 /* Should set errno to EAFNOSUPPORT */
5410 return NULL;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005411}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005412
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005413#endif
Christian Heimesb6150692007-11-15 23:37:07 +00005414#endif