blob: 563bdeaa114b0e1dd9180790133fdcfb50489934 [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{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000354 HANDLE newhandle;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000355
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000356 if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)handle,
357 GetCurrentProcess(), &newhandle,
358 0, FALSE, DUPLICATE_SAME_ACCESS))
359 {
360 WSASetLastError(GetLastError());
361 return INVALID_SOCKET;
362 }
363 return (SOCKET)newhandle;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000364}
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000365#define SOCKETCLOSE closesocket
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000366#else
367/* On Unix we can use dup to duplicate the file descriptor of a socket*/
368#define dup_socket(fd) dup(fd)
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000369#endif
370
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000371#ifdef MS_WIN32
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000372#define EAFNOSUPPORT WSAEAFNOSUPPORT
373#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000374#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000375
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000376#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000377#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000378#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000379#endif
380
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000381#ifndef SOCKETCLOSE
382#define SOCKETCLOSE close
383#endif
384
Jesse Noller32d68c22009-03-31 18:48:42 +0000385#if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H) && !defined(__NetBSD__)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000386#define USE_BLUETOOTH 1
387#if defined(__FreeBSD__)
388#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
389#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
Thomas Wouterscf297e42007-02-23 15:07:44 +0000390#define BTPROTO_HCI BLUETOOTH_PROTO_HCI
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000391#define SOL_HCI SOL_HCI_RAW
392#define HCI_FILTER SO_HCI_RAW_FILTER
Hye-Shik Chang81268602004-02-02 06:05:24 +0000393#define sockaddr_l2 sockaddr_l2cap
394#define sockaddr_rc sockaddr_rfcomm
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000395#define hci_dev hci_node
Hye-Shik Chang81268602004-02-02 06:05:24 +0000396#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
397#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000398#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000399#elif defined(__NetBSD__)
400#define sockaddr_l2 sockaddr_bt
401#define sockaddr_rc sockaddr_bt
Thomas Wouterscf297e42007-02-23 15:07:44 +0000402#define sockaddr_hci sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000403#define sockaddr_sco sockaddr_bt
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000404#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
405#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000406#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000407#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000408#else
Hye-Shik Chang81268602004-02-02 06:05:24 +0000409#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
410#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000411#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000412#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
413#endif
414#endif
415
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000416#ifdef __VMS
417/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
418#define SEGMENT_SIZE (32 * 1024 -1)
419#endif
420
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000421#define SAS2SA(x) ((struct sockaddr *)(x))
Thomas Wouters89f507f2006-12-13 04:49:30 +0000422
Martin v. Löwise9416172003-05-03 10:12:45 +0000423/*
424 * Constants for getnameinfo()
425 */
426#if !defined(NI_MAXHOST)
427#define NI_MAXHOST 1025
428#endif
429#if !defined(NI_MAXSERV)
430#define NI_MAXSERV 32
431#endif
432
Guido van Rossum7d0a8262007-05-21 23:13:11 +0000433#ifndef INVALID_SOCKET /* MS defines this */
434#define INVALID_SOCKET (-1)
435#endif
436
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000437/* XXX There's a problem here: *static* functions are not supposed to have
438 a Py prefix (or use CapitalizedWords). Later... */
439
Guido van Rossum30a685f1991-06-27 15:51:29 +0000440/* Global variable holding the exception type for errors detected
441 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000442static PyObject *socket_error;
443static PyObject *socket_herror;
444static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000445static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000446
Tim Peters643a7fc2002-02-17 04:13:21 +0000447/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000448 The sock_type variable contains pointers to various functions,
449 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000450 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000451static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000452
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000453#if defined(HAVE_POLL_H)
454#include <poll.h>
455#elif defined(HAVE_SYS_POLL_H)
456#include <sys/poll.h>
457#endif
458
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000459#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
460/* Platform can select file descriptors beyond FD_SETSIZE */
461#define IS_SELECTABLE(s) 1
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000462#elif defined(HAVE_POLL)
463/* Instead of select(), we'll use poll() since poll() works on any fd. */
464#define IS_SELECTABLE(s) 1
465/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000466#else
467/* POSIX says selecting file descriptors beyond FD_SETSIZE
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000468 has undefined behaviour. If there's no timeout left, we don't have to
469 call select, so it's a safe, little white lie. */
470#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000471#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000472
473static PyObject*
474select_error(void)
475{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000476 PyErr_SetString(socket_error, "unable to select on socket");
477 return NULL;
Neal Norwitz082b2df2006-02-07 07:04:46 +0000478}
479
Guido van Rossum30a685f1991-06-27 15:51:29 +0000480/* Convenience function to raise an error according to errno
481 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000482
Guido van Rossum73624e91994-10-10 17:59:00 +0000483static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000484set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000485{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000486#ifdef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000487 int err_no = WSAGetLastError();
488 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
489 recognizes the error codes used by both GetLastError() and
490 WSAGetLastError */
491 if (err_no)
492 return PyErr_SetExcFromWindowsErr(socket_error, err_no);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000493#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000494
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000495#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000496 if (sock_errno() != NO_ERROR) {
497 APIRET rc;
498 ULONG msglen;
499 char outbuf[100];
500 int myerrorcode = sock_errno();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000501
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000502 /* Retrieve socket-related error message from MPTN.MSG file */
503 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
504 myerrorcode - SOCBASEERR + 26,
505 "mptn.msg",
506 &msglen);
507 if (rc == NO_ERROR) {
508 PyObject *v;
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000510 /* OS/2 doesn't guarantee a terminator */
511 outbuf[msglen] = '\0';
512 if (strlen(outbuf) > 0) {
513 /* If non-empty msg, trim CRLF */
514 char *lastc = &outbuf[ strlen(outbuf)-1 ];
515 while (lastc > outbuf &&
516 isspace(Py_CHARMASK(*lastc))) {
517 /* Trim trailing whitespace (CRLF) */
518 *lastc-- = '\0';
519 }
520 }
521 v = Py_BuildValue("(is)", myerrorcode, outbuf);
522 if (v != NULL) {
523 PyErr_SetObject(socket_error, v);
524 Py_DECREF(v);
525 }
526 return NULL;
527 }
528 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000529#endif
530
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000531 return PyErr_SetFromErrno(socket_error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000532}
533
Guido van Rossum30a685f1991-06-27 15:51:29 +0000534
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000535static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000536set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000537{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000538 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000539
540#ifdef HAVE_HSTRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000541 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000542#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000543 v = Py_BuildValue("(is)", h_error, "host not found");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000544#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000545 if (v != NULL) {
546 PyErr_SetObject(socket_herror, v);
547 Py_DECREF(v);
548 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000550 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000551}
552
553
554static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000555set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000556{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000557 PyObject *v;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000558
Martin v. Löwis272cb402002-03-01 08:31:07 +0000559#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000560 /* EAI_SYSTEM is not available on Windows XP. */
561 if (error == EAI_SYSTEM)
562 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000563#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000564
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000565#ifdef HAVE_GAI_STRERROR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000566 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000567#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000568 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000569#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000570 if (v != NULL) {
571 PyErr_SetObject(socket_gaierror, v);
572 Py_DECREF(v);
573 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000574
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000575 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000576}
577
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000578#ifdef __VMS
579/* Function to send in segments */
580static int
581sendsegmented(int sock_fd, char *buf, int len, int flags)
582{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000583 int n = 0;
584 int remaining = len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000585
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000586 while (remaining > 0) {
587 unsigned int segment;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000588
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000589 segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
590 n = send(sock_fd, buf, segment, flags);
591 if (n < 0) {
592 return n;
593 }
594 remaining -= segment;
595 buf += segment;
596 } /* end while */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000598 return len;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000599}
600#endif
601
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000602/* Function to perform the setting of socket blocking mode
603 internally. block = (1 | 0). */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000604static int
605internal_setblocking(PySocketSockObject *s, int block)
606{
Guido van Rossum67f7a382002-06-06 21:08:16 +0000607#ifndef MS_WINDOWS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000608 int delay_flag;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000609#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +0000610
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000611 Py_BEGIN_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000612#ifndef MS_WINDOWS
613#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000614 block = !block;
615 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000616#elif defined(__VMS)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000617 block = !block;
618 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000619#else /* !PYOS_OS2 && !__VMS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000620 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
621 if (block)
622 delay_flag &= (~O_NONBLOCK);
623 else
624 delay_flag |= O_NONBLOCK;
625 fcntl(s->sock_fd, F_SETFL, delay_flag);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000626#endif /* !PYOS_OS2 */
627#else /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000628 block = !block;
629 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000630#endif /* MS_WINDOWS */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000631 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +0000632
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000633 /* Since these don't return anything */
634 return 1;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000635}
636
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000637/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
Guido van Rossum11ba0942002-06-13 15:07:44 +0000638 The argument writing indicates the direction.
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000639 This does not raise an exception; we'll let our caller do that
640 after they've reacquired the interpreter lock.
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000641 Returns 1 on timeout, -1 on error, 0 otherwise. */
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000642static int
Guido van Rossumb9e916a2002-06-07 01:42:47 +0000643internal_select(PySocketSockObject *s, int writing)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000644{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000645 int n;
Guido van Rossum11ba0942002-06-13 15:07:44 +0000646
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000647 /* Nothing to do unless we're in timeout mode (not non-blocking) */
648 if (s->sock_timeout <= 0.0)
649 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000650
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000651 /* Guard against closed socket */
652 if (s->sock_fd < 0)
653 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000654
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000655 /* Prefer poll, if available, since you can poll() any fd
656 * which can't be done with select(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000657#ifdef HAVE_POLL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000658 {
659 struct pollfd pollfd;
660 int timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000661
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000662 pollfd.fd = s->sock_fd;
663 pollfd.events = writing ? POLLOUT : POLLIN;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000664
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000665 /* s->sock_timeout is in seconds, timeout in ms */
666 timeout = (int)(s->sock_timeout * 1000 + 0.5);
667 n = poll(&pollfd, 1, timeout);
668 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000669#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000670 {
671 /* Construct the arguments to select */
672 fd_set fds;
673 struct timeval tv;
674 tv.tv_sec = (int)s->sock_timeout;
675 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
676 FD_ZERO(&fds);
677 FD_SET(s->sock_fd, &fds);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000678
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000679 /* See if the socket is ready */
680 if (writing)
681 n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
682 else
683 n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
684 }
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000685#endif
Guido van Rossum39eb8fa2007-11-16 01:24:05 +0000686
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000687 if (n < 0)
688 return -1;
689 if (n == 0)
690 return 1;
691 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000692}
693
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000694/* Initialize a new socket object. */
695
Tim Petersa12b4cf2002-07-18 22:38:44 +0000696static double defaulttimeout = -1.0; /* Default timeout for new sockets */
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000697
Martin v. Löwis1a214512008-06-11 05:26:20 +0000698static void
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000699init_sockobject(PySocketSockObject *s,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000700 SOCKET_T fd, int family, int type, int proto)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000701{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000702 s->sock_fd = fd;
703 s->sock_family = family;
704 s->sock_type = type;
705 s->sock_proto = proto;
706 s->sock_timeout = defaulttimeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000707
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000708 s->errorhandler = &set_error;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000709
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000710 if (defaulttimeout >= 0.0)
711 internal_setblocking(s, 0);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000712
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000713}
714
715
Guido van Rossum30a685f1991-06-27 15:51:29 +0000716/* Create a new socket object.
717 This just creates the object and initializes it.
718 If the creation fails, return NULL and set an exception (implicit
719 in NEWOBJ()). */
720
Guido van Rossum73624e91994-10-10 17:59:00 +0000721static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000722new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000723{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000724 PySocketSockObject *s;
725 s = (PySocketSockObject *)
726 PyType_GenericNew(&sock_type, NULL, NULL);
727 if (s != NULL)
728 init_sockobject(s, fd, family, type, proto);
729 return s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000730}
731
Guido van Rossum30a685f1991-06-27 15:51:29 +0000732
Guido van Rossum48a680c2001-03-02 06:34:14 +0000733/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000734 thread to be in gethostbyname or getaddrinfo */
735#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
736PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000737#endif
738
739
Guido van Rossum30a685f1991-06-27 15:51:29 +0000740/* Convert a string specifying a host name or one of a few symbolic
741 names to a numeric IP address. This usually calls gethostbyname()
742 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000743 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000744 an error occurred; then an exception is raised. */
745
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000746static int
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000747setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000748{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000749 struct addrinfo hints, *res;
750 int error;
751 int d1, d2, d3, d4;
752 char ch;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000753
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000754 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
755 if (name[0] == '\0') {
756 int siz;
757 memset(&hints, 0, sizeof(hints));
758 hints.ai_family = af;
759 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
760 hints.ai_flags = AI_PASSIVE;
761 Py_BEGIN_ALLOW_THREADS
762 ACQUIRE_GETADDRINFO_LOCK
763 error = getaddrinfo(NULL, "0", &hints, &res);
764 Py_END_ALLOW_THREADS
765 /* We assume that those thread-unsafe getaddrinfo() versions
766 *are* safe regarding their return value, ie. that a
767 subsequent call to getaddrinfo() does not destroy the
768 outcome of the first call. */
769 RELEASE_GETADDRINFO_LOCK
770 if (error) {
771 set_gaierror(error);
772 return -1;
773 }
774 switch (res->ai_family) {
775 case AF_INET:
776 siz = 4;
777 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000778#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000779 case AF_INET6:
780 siz = 16;
781 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000782#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000783 default:
784 freeaddrinfo(res);
785 PyErr_SetString(socket_error,
786 "unsupported address family");
787 return -1;
788 }
789 if (res->ai_next) {
790 freeaddrinfo(res);
791 PyErr_SetString(socket_error,
792 "wildcard resolved to multiple address");
793 return -1;
794 }
795 if (res->ai_addrlen < addr_ret_size)
796 addr_ret_size = res->ai_addrlen;
797 memcpy(addr_ret, res->ai_addr, addr_ret_size);
798 freeaddrinfo(res);
799 return siz;
800 }
801 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
802 struct sockaddr_in *sin;
803 if (af != AF_INET && af != AF_UNSPEC) {
804 PyErr_SetString(socket_error,
805 "address family mismatched");
806 return -1;
807 }
808 sin = (struct sockaddr_in *)addr_ret;
809 memset((void *) sin, '\0', sizeof(*sin));
810 sin->sin_family = AF_INET;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000811#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000812 sin->sin_len = sizeof(*sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000813#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000814 sin->sin_addr.s_addr = INADDR_BROADCAST;
815 return sizeof(sin->sin_addr);
816 }
817 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
818 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
819 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
820 struct sockaddr_in *sin;
821 sin = (struct sockaddr_in *)addr_ret;
822 sin->sin_addr.s_addr = htonl(
823 ((long) d1 << 24) | ((long) d2 << 16) |
824 ((long) d3 << 8) | ((long) d4 << 0));
825 sin->sin_family = AF_INET;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000826#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000827 sin->sin_len = sizeof(*sin);
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000828#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000829 return 4;
830 }
831 memset(&hints, 0, sizeof(hints));
832 hints.ai_family = af;
833 Py_BEGIN_ALLOW_THREADS
834 ACQUIRE_GETADDRINFO_LOCK
835 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000836#if defined(__digital__) && defined(__unix__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000837 if (error == EAI_NONAME && af == AF_UNSPEC) {
838 /* On Tru64 V5.1, numeric-to-addr conversion fails
839 if no address family is given. Assume IPv4 for now.*/
840 hints.ai_family = AF_INET;
841 error = getaddrinfo(name, NULL, &hints, &res);
842 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000843#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000844 Py_END_ALLOW_THREADS
845 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
846 if (error) {
847 set_gaierror(error);
848 return -1;
849 }
850 if (res->ai_addrlen < addr_ret_size)
851 addr_ret_size = res->ai_addrlen;
852 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
853 freeaddrinfo(res);
854 switch (addr_ret->sa_family) {
855 case AF_INET:
856 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000857#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000858 case AF_INET6:
859 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000860#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000861 default:
862 PyErr_SetString(socket_error, "unknown address family");
863 return -1;
864 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000865}
866
Guido van Rossum30a685f1991-06-27 15:51:29 +0000867
Guido van Rossum30a685f1991-06-27 15:51:29 +0000868/* Create a string object representing an IP address.
869 This is always a string of the form 'dd.dd.dd.dd' (with variable
870 size numbers). */
871
Guido van Rossum73624e91994-10-10 17:59:00 +0000872static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000873makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000874{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000875 char buf[NI_MAXHOST];
876 int error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000877
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000878 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
879 NI_NUMERICHOST);
880 if (error) {
881 set_gaierror(error);
882 return NULL;
883 }
884 return PyUnicode_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000885}
886
887
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000888#ifdef USE_BLUETOOTH
889/* Convert a string representation of a Bluetooth address into a numeric
890 address. Returns the length (6), or raises an exception and returns -1 if
891 an error occurred. */
892
893static int
894setbdaddr(char *name, bdaddr_t *bdaddr)
895{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000896 unsigned int b0, b1, b2, b3, b4, b5;
897 char ch;
898 int n;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000899
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000900 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
901 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
902 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
903 bdaddr->b[0] = b0;
904 bdaddr->b[1] = b1;
905 bdaddr->b[2] = b2;
906 bdaddr->b[3] = b3;
907 bdaddr->b[4] = b4;
908 bdaddr->b[5] = b5;
909 return 6;
910 } else {
911 PyErr_SetString(socket_error, "bad bluetooth address");
912 return -1;
913 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000914}
915
916/* Create a string representation of the Bluetooth address. This is always a
917 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
918 value (zero padded if necessary). */
919
920static PyObject *
921makebdaddr(bdaddr_t *bdaddr)
922{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000923 char buf[(6 * 2) + 5 + 1];
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000924
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000925 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
926 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
927 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
928 return PyUnicode_FromString(buf);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000929}
930#endif
931
932
Guido van Rossum30a685f1991-06-27 15:51:29 +0000933/* Create an object representing the given socket address,
934 suitable for passing it back to bind(), connect() etc.
935 The family field of the sockaddr structure is inspected
936 to determine what kind of address it really is. */
937
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000938/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +0000939static PyObject *
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000940makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000941{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000942 if (addrlen == 0) {
943 /* No address -- may be recvfrom() from known socket */
944 Py_INCREF(Py_None);
945 return Py_None;
946 }
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000947
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000948 switch (addr->sa_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +0000949
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000950 case AF_INET:
951 {
952 struct sockaddr_in *a;
953 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
954 PyObject *ret = NULL;
955 if (addrobj) {
956 a = (struct sockaddr_in *)addr;
957 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
958 Py_DECREF(addrobj);
959 }
960 return ret;
961 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000962
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +0000963#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000964 case AF_UNIX:
965 {
966 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000967#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000968 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
969 addrlen -= offsetof(struct sockaddr_un, sun_path);
970 return PyBytes_FromStringAndSize(a->sun_path, addrlen);
971 }
972 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000973#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000974 {
975 /* regular NULL-terminated string */
976 return PyUnicode_FromString(a->sun_path);
977 }
978 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000979#endif /* AF_UNIX */
980
Martin v. Löwis11017b12006-01-14 18:12:57 +0000981#if defined(AF_NETLINK)
982 case AF_NETLINK:
983 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000984 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
985 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +0000986 }
987#endif /* AF_NETLINK */
988
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000989#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000990 case AF_INET6:
991 {
992 struct sockaddr_in6 *a;
993 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
994 PyObject *ret = NULL;
995 if (addrobj) {
996 a = (struct sockaddr_in6 *)addr;
997 ret = Py_BuildValue("Oiii",
998 addrobj,
999 ntohs(a->sin6_port),
1000 a->sin6_flowinfo,
1001 a->sin6_scope_id);
1002 Py_DECREF(addrobj);
1003 }
1004 return ret;
1005 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001006#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001007
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001008#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001009 case AF_BLUETOOTH:
1010 switch (proto) {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001011
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001012 case BTPROTO_L2CAP:
1013 {
1014 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1015 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1016 PyObject *ret = NULL;
1017 if (addrobj) {
1018 ret = Py_BuildValue("Oi",
1019 addrobj,
1020 _BT_L2_MEMB(a, psm));
1021 Py_DECREF(addrobj);
1022 }
1023 return ret;
1024 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001025
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001026 case BTPROTO_RFCOMM:
1027 {
1028 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1029 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1030 PyObject *ret = NULL;
1031 if (addrobj) {
1032 ret = Py_BuildValue("Oi",
1033 addrobj,
1034 _BT_RC_MEMB(a, channel));
1035 Py_DECREF(addrobj);
1036 }
1037 return ret;
1038 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001039
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001040 case BTPROTO_HCI:
1041 {
1042 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
1043 PyObject *ret = NULL;
1044 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1045 return ret;
1046 }
Thomas Wouterscf297e42007-02-23 15:07:44 +00001047
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001048#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001049 case BTPROTO_SCO:
1050 {
1051 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1052 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1053 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001054#endif
1055
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 default:
1057 PyErr_SetString(PyExc_ValueError,
1058 "Unknown Bluetooth protocol");
1059 return NULL;
1060 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001061#endif
1062
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001063#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001064 case AF_PACKET:
1065 {
1066 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1067 char *ifname = "";
1068 struct ifreq ifr;
1069 /* need to look up interface name give index */
1070 if (a->sll_ifindex) {
1071 ifr.ifr_ifindex = a->sll_ifindex;
1072 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1073 ifname = ifr.ifr_name;
1074 }
1075 return Py_BuildValue("shbhy#",
1076 ifname,
1077 ntohs(a->sll_protocol),
1078 a->sll_pkttype,
1079 a->sll_hatype,
1080 a->sll_addr,
1081 a->sll_halen);
1082 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001083#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001084
Christian Heimes043d6f62008-01-07 17:19:16 +00001085#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001086 case AF_TIPC:
1087 {
1088 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1089 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1090 return Py_BuildValue("IIIII",
1091 a->addrtype,
1092 a->addr.nameseq.type,
1093 a->addr.nameseq.lower,
1094 a->addr.nameseq.upper,
1095 a->scope);
1096 } else if (a->addrtype == TIPC_ADDR_NAME) {
1097 return Py_BuildValue("IIIII",
1098 a->addrtype,
1099 a->addr.name.name.type,
1100 a->addr.name.name.instance,
1101 a->addr.name.name.instance,
1102 a->scope);
1103 } else if (a->addrtype == TIPC_ADDR_ID) {
1104 return Py_BuildValue("IIIII",
1105 a->addrtype,
1106 a->addr.id.node,
1107 a->addr.id.ref,
1108 0,
1109 a->scope);
1110 } else {
1111 PyErr_SetString(PyExc_ValueError,
1112 "Invalid address type");
1113 return NULL;
1114 }
1115 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001116#endif
1117
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001118 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001119
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001120 default:
1121 /* If we don't know the address family, don't raise an
1122 exception -- return it as an (int, bytes) tuple. */
1123 return Py_BuildValue("iy#",
1124 addr->sa_family,
1125 addr->sa_data,
1126 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001127
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001128 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001129}
1130
Guido van Rossum30a685f1991-06-27 15:51:29 +00001131
1132/* Parse a socket address argument according to the socket object's
1133 address family. Return 1 if the address was in the proper format,
1134 0 of not. The address is returned through addr_ret, its length
1135 through len_ret. */
1136
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001137static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001138getsockaddrarg(PySocketSockObject *s, PyObject *args,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001139 struct sockaddr *addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001140{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001141 switch (s->sock_family) {
Guido van Rossum30a685f1991-06-27 15:51:29 +00001142
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001143#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001144 case AF_UNIX:
1145 {
1146 struct sockaddr_un* addr;
1147 char *path;
1148 int len;
1149 if (!PyArg_Parse(args, "s#", &path, &len))
1150 return 0;
Thomas Wouters89f507f2006-12-13 04:49:30 +00001151
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001152 addr = (struct sockaddr_un*)addr_ret;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001153#ifdef linux
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001154 if (len > 0 && path[0] == 0) {
1155 /* Linux abstract namespace extension */
1156 if (len > sizeof addr->sun_path) {
1157 PyErr_SetString(socket_error,
1158 "AF_UNIX path too long");
1159 return 0;
1160 }
1161 }
1162 else
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001163#endif /* linux */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001164 {
1165 /* regular NULL-terminated string */
1166 if (len >= sizeof addr->sun_path) {
1167 PyErr_SetString(socket_error,
1168 "AF_UNIX path too long");
1169 return 0;
1170 }
1171 addr->sun_path[len] = 0;
1172 }
1173 addr->sun_family = s->sock_family;
1174 memcpy(addr->sun_path, path, len);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001175#if defined(PYOS_OS2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001176 *len_ret = sizeof(*addr);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001177#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001178 *len_ret = len + offsetof(struct sockaddr_un, sun_path);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001179#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001180 return 1;
1181 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001182#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001183
Martin v. Löwis11017b12006-01-14 18:12:57 +00001184#if defined(AF_NETLINK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001185 case AF_NETLINK:
1186 {
1187 struct sockaddr_nl* addr;
1188 int pid, groups;
1189 addr = (struct sockaddr_nl *)addr_ret;
1190 if (!PyTuple_Check(args)) {
1191 PyErr_Format(
1192 PyExc_TypeError,
1193 "getsockaddrarg: "
1194 "AF_NETLINK address must be tuple, not %.500s",
1195 Py_TYPE(args)->tp_name);
1196 return 0;
1197 }
1198 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1199 return 0;
1200 addr->nl_family = AF_NETLINK;
1201 addr->nl_pid = pid;
1202 addr->nl_groups = groups;
1203 *len_ret = sizeof(*addr);
1204 return 1;
1205 }
Martin v. Löwis11017b12006-01-14 18:12:57 +00001206#endif
1207
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001208 case AF_INET:
1209 {
1210 struct sockaddr_in* addr;
1211 char *host;
1212 int port, result;
1213 if (!PyTuple_Check(args)) {
1214 PyErr_Format(
1215 PyExc_TypeError,
1216 "getsockaddrarg: "
1217 "AF_INET address must be tuple, not %.500s",
1218 Py_TYPE(args)->tp_name);
1219 return 0;
1220 }
1221 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1222 "idna", &host, &port))
1223 return 0;
1224 addr=(struct sockaddr_in*)addr_ret;
1225 result = setipaddr(host, (struct sockaddr *)addr,
1226 sizeof(*addr), AF_INET);
1227 PyMem_Free(host);
1228 if (result < 0)
1229 return 0;
1230 if (port < 0 || port > 0xffff) {
1231 PyErr_SetString(
1232 PyExc_OverflowError,
1233 "getsockaddrarg: port must be 0-65535.");
1234 return 0;
1235 }
1236 addr->sin_family = AF_INET;
1237 addr->sin_port = htons((short)port);
1238 *len_ret = sizeof *addr;
1239 return 1;
1240 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001241
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001242#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001243 case AF_INET6:
1244 {
1245 struct sockaddr_in6* addr;
1246 char *host;
1247 int port, flowinfo, scope_id, result;
1248 flowinfo = scope_id = 0;
1249 if (!PyTuple_Check(args)) {
1250 PyErr_Format(
1251 PyExc_TypeError,
1252 "getsockaddrarg: "
1253 "AF_INET6 address must be tuple, not %.500s",
1254 Py_TYPE(args)->tp_name);
1255 return 0;
1256 }
1257 if (!PyArg_ParseTuple(args, "eti|ii",
1258 "idna", &host, &port, &flowinfo,
1259 &scope_id)) {
1260 return 0;
1261 }
1262 addr = (struct sockaddr_in6*)addr_ret;
1263 result = setipaddr(host, (struct sockaddr *)addr,
1264 sizeof(*addr), AF_INET6);
1265 PyMem_Free(host);
1266 if (result < 0)
1267 return 0;
1268 if (port < 0 || port > 0xffff) {
1269 PyErr_SetString(
1270 PyExc_OverflowError,
1271 "getsockaddrarg: port must be 0-65535.");
1272 return 0;
1273 }
1274 addr->sin6_family = s->sock_family;
1275 addr->sin6_port = htons((short)port);
1276 addr->sin6_flowinfo = flowinfo;
1277 addr->sin6_scope_id = scope_id;
1278 *len_ret = sizeof *addr;
1279 return 1;
1280 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001281#endif
1282
Hye-Shik Chang81268602004-02-02 06:05:24 +00001283#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001284 case AF_BLUETOOTH:
1285 {
1286 switch (s->sock_proto) {
1287 case BTPROTO_L2CAP:
1288 {
1289 struct sockaddr_l2 *addr;
1290 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001291
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001292 addr = (struct sockaddr_l2 *)addr_ret;
1293 memset(addr, 0, sizeof(struct sockaddr_l2));
1294 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1295 if (!PyArg_ParseTuple(args, "si", &straddr,
1296 &_BT_L2_MEMB(addr, psm))) {
1297 PyErr_SetString(socket_error, "getsockaddrarg: "
1298 "wrong format");
1299 return 0;
1300 }
1301 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1302 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001303
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001304 *len_ret = sizeof *addr;
1305 return 1;
1306 }
1307 case BTPROTO_RFCOMM:
1308 {
1309 struct sockaddr_rc *addr;
1310 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001311
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001312 addr = (struct sockaddr_rc *)addr_ret;
1313 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1314 if (!PyArg_ParseTuple(args, "si", &straddr,
1315 &_BT_RC_MEMB(addr, channel))) {
1316 PyErr_SetString(socket_error, "getsockaddrarg: "
1317 "wrong format");
1318 return 0;
1319 }
1320 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1321 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001322
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001323 *len_ret = sizeof *addr;
1324 return 1;
1325 }
1326 case BTPROTO_HCI:
1327 {
1328 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
1329 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1330 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
1331 PyErr_SetString(socket_error, "getsockaddrarg: "
1332 "wrong format");
1333 return 0;
1334 }
1335 *len_ret = sizeof *addr;
1336 return 1;
1337 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001338#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001339 case BTPROTO_SCO:
1340 {
1341 struct sockaddr_sco *addr;
1342 char *straddr;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001343
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001344 addr = (struct sockaddr_sco *)addr_ret;
1345 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1346 if (!PyBytes_Check(args)) {
1347 PyErr_SetString(socket_error, "getsockaddrarg: "
1348 "wrong format");
1349 return 0;
1350 }
1351 straddr = PyBytes_AS_STRING(args);
1352 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1353 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001354
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001355 *len_ret = sizeof *addr;
1356 return 1;
1357 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001358#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001359 default:
1360 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1361 return 0;
1362 }
1363 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001364#endif
1365
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001366#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001367 case AF_PACKET:
1368 {
1369 struct sockaddr_ll* addr;
1370 struct ifreq ifr;
1371 char *interfaceName;
1372 int protoNumber;
1373 int hatype = 0;
1374 int pkttype = 0;
1375 char *haddr = NULL;
1376 unsigned int halen = 0;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001377
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001378 if (!PyTuple_Check(args)) {
1379 PyErr_Format(
1380 PyExc_TypeError,
1381 "getsockaddrarg: "
1382 "AF_PACKET address must be tuple, not %.500s",
1383 Py_TYPE(args)->tp_name);
1384 return 0;
1385 }
1386 if (!PyArg_ParseTuple(args, "si|iiy#", &interfaceName,
1387 &protoNumber, &pkttype, &hatype,
1388 &haddr, &halen))
1389 return 0;
1390 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1391 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1392 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1393 s->errorhandler();
1394 return 0;
1395 }
1396 if (halen > 8) {
1397 PyErr_SetString(PyExc_ValueError,
1398 "Hardware address must be 8 bytes or less");
1399 return 0;
1400 }
1401 if (protoNumber < 0 || protoNumber > 0xffff) {
1402 PyErr_SetString(
1403 PyExc_OverflowError,
1404 "getsockaddrarg: protoNumber must be 0-65535.");
1405 return 0;
1406 }
1407 addr = (struct sockaddr_ll*)addr_ret;
1408 addr->sll_family = AF_PACKET;
1409 addr->sll_protocol = htons((short)protoNumber);
1410 addr->sll_ifindex = ifr.ifr_ifindex;
1411 addr->sll_pkttype = pkttype;
1412 addr->sll_hatype = hatype;
1413 if (halen != 0) {
1414 memcpy(&addr->sll_addr, haddr, halen);
1415 }
1416 addr->sll_halen = halen;
1417 *len_ret = sizeof *addr;
1418 return 1;
1419 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001420#endif
1421
Christian Heimes043d6f62008-01-07 17:19:16 +00001422#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001423 case AF_TIPC:
1424 {
1425 unsigned int atype, v1, v2, v3;
1426 unsigned int scope = TIPC_CLUSTER_SCOPE;
1427 struct sockaddr_tipc *addr;
Christian Heimes043d6f62008-01-07 17:19:16 +00001428
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001429 if (!PyTuple_Check(args)) {
1430 PyErr_Format(
1431 PyExc_TypeError,
1432 "getsockaddrarg: "
1433 "AF_TIPC address must be tuple, not %.500s",
1434 Py_TYPE(args)->tp_name);
1435 return 0;
1436 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001437
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001438 if (!PyArg_ParseTuple(args,
1439 "IIII|I;Invalid TIPC address format",
1440 &atype, &v1, &v2, &v3, &scope))
1441 return 0;
Christian Heimes043d6f62008-01-07 17:19:16 +00001442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001443 addr = (struct sockaddr_tipc *) addr_ret;
1444 memset(addr, 0, sizeof(struct sockaddr_tipc));
Christian Heimes043d6f62008-01-07 17:19:16 +00001445
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001446 addr->family = AF_TIPC;
1447 addr->scope = scope;
1448 addr->addrtype = atype;
Christian Heimes043d6f62008-01-07 17:19:16 +00001449
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001450 if (atype == TIPC_ADDR_NAMESEQ) {
1451 addr->addr.nameseq.type = v1;
1452 addr->addr.nameseq.lower = v2;
1453 addr->addr.nameseq.upper = v3;
1454 } else if (atype == TIPC_ADDR_NAME) {
1455 addr->addr.name.name.type = v1;
1456 addr->addr.name.name.instance = v2;
1457 } else if (atype == TIPC_ADDR_ID) {
1458 addr->addr.id.node = v1;
1459 addr->addr.id.ref = v2;
1460 } else {
1461 /* Shouldn't happen */
1462 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1463 return 0;
1464 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001465
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001466 *len_ret = sizeof(*addr);
Christian Heimes043d6f62008-01-07 17:19:16 +00001467
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001468 return 1;
1469 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001470#endif
1471
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001472 /* More cases here... */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001473
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001474 default:
1475 PyErr_SetString(socket_error, "getsockaddrarg: bad family");
1476 return 0;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001477
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001478 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001479}
1480
Guido van Rossum30a685f1991-06-27 15:51:29 +00001481
Guido van Rossum48a680c2001-03-02 06:34:14 +00001482/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00001483 Return 1 if the family is known, 0 otherwise. The length is returned
1484 through len_ret. */
1485
1486static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00001487getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001488{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001489 switch (s->sock_family) {
Guido van Rossum710e1df1992-06-12 10:39:36 +00001490
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001491#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001492 case AF_UNIX:
1493 {
1494 *len_ret = sizeof (struct sockaddr_un);
1495 return 1;
1496 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001497#endif /* AF_UNIX */
Martin v. Löwis11017b12006-01-14 18:12:57 +00001498#if defined(AF_NETLINK)
1499 case AF_NETLINK:
1500 {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001501 *len_ret = sizeof (struct sockaddr_nl);
1502 return 1;
Martin v. Löwis11017b12006-01-14 18:12:57 +00001503 }
1504#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00001505
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001506 case AF_INET:
1507 {
1508 *len_ret = sizeof (struct sockaddr_in);
1509 return 1;
1510 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001511
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001512#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001513 case AF_INET6:
1514 {
1515 *len_ret = sizeof (struct sockaddr_in6);
1516 return 1;
1517 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001518#endif
1519
Hye-Shik Chang81268602004-02-02 06:05:24 +00001520#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001521 case AF_BLUETOOTH:
1522 {
1523 switch(s->sock_proto)
1524 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001525
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001526 case BTPROTO_L2CAP:
1527 *len_ret = sizeof (struct sockaddr_l2);
1528 return 1;
1529 case BTPROTO_RFCOMM:
1530 *len_ret = sizeof (struct sockaddr_rc);
1531 return 1;
1532 case BTPROTO_HCI:
1533 *len_ret = sizeof (struct sockaddr_hci);
1534 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001535#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001536 case BTPROTO_SCO:
1537 *len_ret = sizeof (struct sockaddr_sco);
1538 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001539#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001540 default:
1541 PyErr_SetString(socket_error, "getsockaddrlen: "
1542 "unknown BT protocol");
1543 return 0;
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001544
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001545 }
1546 }
Martin v. Löwis12af0482004-01-31 12:34:17 +00001547#endif
1548
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001549#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001550 case AF_PACKET:
1551 {
1552 *len_ret = sizeof (struct sockaddr_ll);
1553 return 1;
1554 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001555#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001556
Christian Heimes043d6f62008-01-07 17:19:16 +00001557#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001558 case AF_TIPC:
1559 {
1560 *len_ret = sizeof (struct sockaddr_tipc);
1561 return 1;
1562 }
Christian Heimes043d6f62008-01-07 17:19:16 +00001563#endif
1564
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001565 /* More cases here... */
Guido van Rossum710e1df1992-06-12 10:39:36 +00001566
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001567 default:
1568 PyErr_SetString(socket_error, "getsockaddrlen: bad family");
1569 return 0;
Guido van Rossum710e1df1992-06-12 10:39:36 +00001570
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001571 }
Guido van Rossum710e1df1992-06-12 10:39:36 +00001572}
1573
1574
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001575/* s._accept() -> (fd, address) */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001576
Guido van Rossum73624e91994-10-10 17:59:00 +00001577static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001578sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001579{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001580 sock_addr_t addrbuf;
1581 SOCKET_T newfd = INVALID_SOCKET;
1582 socklen_t addrlen;
1583 PyObject *sock = NULL;
1584 PyObject *addr = NULL;
1585 PyObject *res = NULL;
1586 int timeout;
Barry Warsaw752300b1997-01-03 17:18:10 +00001587
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001588 if (!getsockaddrlen(s, &addrlen))
1589 return NULL;
1590 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001591
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001592 if (!IS_SELECTABLE(s))
1593 return select_error();
Neal Norwitz082b2df2006-02-07 07:04:46 +00001594
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001595 Py_BEGIN_ALLOW_THREADS
1596 timeout = internal_select(s, 0);
1597 if (!timeout)
1598 newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
1599 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001600
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001601 if (timeout == 1) {
1602 PyErr_SetString(socket_timeout, "timed out");
1603 return NULL;
1604 }
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001606 if (newfd == INVALID_SOCKET)
1607 return s->errorhandler();
Barry Warsaw752300b1997-01-03 17:18:10 +00001608
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001609 sock = PyLong_FromSocket_t(newfd);
1610 if (sock == NULL) {
1611 SOCKETCLOSE(newfd);
1612 goto finally;
1613 }
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001614
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001615 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
1616 addrlen, s->sock_proto);
1617 if (addr == NULL)
1618 goto finally;
Barry Warsaw752300b1997-01-03 17:18:10 +00001619
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001620 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001621
Guido van Rossum67f7a382002-06-06 21:08:16 +00001622finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001623 Py_XDECREF(sock);
1624 Py_XDECREF(addr);
1625 return res;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001626}
1627
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001628PyDoc_STRVAR(accept_doc,
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001629"_accept() -> (integer, address info)\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00001630\n\
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001631Wait for an incoming connection. Return a new socket file descriptor\n\
1632representing the connection, and the address of the client.\n\
1633For IP sockets, the address info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001634
Guido van Rossum11ba0942002-06-13 15:07:44 +00001635/* s.setblocking(flag) method. Argument:
1636 False -- non-blocking mode; same as settimeout(0)
1637 True -- blocking mode; same as settimeout(None)
1638*/
Guido van Rossume4485b01994-09-07 14:32:49 +00001639
Guido van Rossum73624e91994-10-10 17:59:00 +00001640static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001641sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00001642{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001643 int block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001644
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001645 block = PyLong_AsLong(arg);
1646 if (block == -1 && PyErr_Occurred())
1647 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001648
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001649 s->sock_timeout = block ? -1.0 : 0.0;
1650 internal_setblocking(s, block);
Guido van Rossume4485b01994-09-07 14:32:49 +00001651
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001652 Py_INCREF(Py_None);
1653 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001654}
Guido van Rossume4485b01994-09-07 14:32:49 +00001655
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001656PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001657"setblocking(flag)\n\
1658\n\
1659Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001660setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001661setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001662
Guido van Rossum11ba0942002-06-13 15:07:44 +00001663/* s.settimeout(timeout) method. Argument:
1664 None -- no timeout, blocking mode; same as setblocking(True)
1665 0.0 -- non-blocking mode; same as setblocking(False)
1666 > 0 -- timeout mode; operations time out after timeout seconds
1667 < 0 -- illegal; raises an exception
1668*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00001669static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001670sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001671{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001672 double timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001673
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001674 if (arg == Py_None)
1675 timeout = -1.0;
1676 else {
1677 timeout = PyFloat_AsDouble(arg);
1678 if (timeout < 0.0) {
1679 if (!PyErr_Occurred())
1680 PyErr_SetString(PyExc_ValueError,
1681 "Timeout value out of range");
1682 return NULL;
1683 }
1684 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00001685
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001686 s->sock_timeout = timeout;
1687 internal_setblocking(s, timeout < 0.0);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001688
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001689 Py_INCREF(Py_None);
1690 return Py_None;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001691}
1692
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001693PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001694"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001695\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001696Set a timeout on socket operations. 'timeout' can be a float,\n\
1697giving in seconds, or None. Setting a timeout of None disables\n\
1698the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001699Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00001700
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001701/* s.gettimeout() method.
1702 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00001703static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001704sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001705{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001706 if (s->sock_timeout < 0.0) {
1707 Py_INCREF(Py_None);
1708 return Py_None;
1709 }
1710 else
1711 return PyFloat_FromDouble(s->sock_timeout);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001712}
1713
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001714PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00001715"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001716\n\
1717Returns the timeout in floating seconds associated with socket \n\
1718operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001719operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00001720
Guido van Rossumaee08791992-09-08 09:05:33 +00001721/* s.setsockopt() method.
1722 With an integer third argument, sets an integer option.
1723 With a string third argument, sets an option from a buffer;
1724 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001725
Guido van Rossum73624e91994-10-10 17:59:00 +00001726static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001727sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001728{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001729 int level;
1730 int optname;
1731 int res;
1732 char *buf;
1733 int buflen;
1734 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001735
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001736 if (PyArg_ParseTuple(args, "iii:setsockopt",
1737 &level, &optname, &flag)) {
1738 buf = (char *) &flag;
1739 buflen = sizeof flag;
1740 }
1741 else {
1742 PyErr_Clear();
1743 if (!PyArg_ParseTuple(args, "iiy#:setsockopt",
1744 &level, &optname, &buf, &buflen))
1745 return NULL;
1746 }
1747 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
1748 if (res < 0)
1749 return s->errorhandler();
1750 Py_INCREF(Py_None);
1751 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001752}
1753
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001754PyDoc_STRVAR(setsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001755"setsockopt(level, option, value)\n\
1756\n\
1757Set a socket option. See the Unix manual for level and option.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001758The value argument can either be an integer or a string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001759
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001760
Guido van Rossumaee08791992-09-08 09:05:33 +00001761/* s.getsockopt() method.
1762 With two arguments, retrieves an integer option.
1763 With a third integer argument, retrieves a string buffer of that size;
1764 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001765
Guido van Rossum73624e91994-10-10 17:59:00 +00001766static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001767sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001768{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001769 int level;
1770 int optname;
1771 int res;
1772 PyObject *buf;
1773 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001774
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001775 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1776 &level, &optname, &buflen))
1777 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001778
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001779 if (buflen == 0) {
1780 int flag = 0;
1781 socklen_t flagsize = sizeof flag;
1782 res = getsockopt(s->sock_fd, level, optname,
1783 (void *)&flag, &flagsize);
1784 if (res < 0)
1785 return s->errorhandler();
1786 return PyLong_FromLong(flag);
1787 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001788#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001789 /* socklen_t is unsigned so no negative test is needed,
1790 test buflen == 0 is previously done */
1791 if (buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001792#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001793 if (buflen <= 0 || buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001794#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001795 PyErr_SetString(socket_error,
1796 "getsockopt buflen out of range");
1797 return NULL;
1798 }
1799 buf = PyBytes_FromStringAndSize((char *)NULL, buflen);
1800 if (buf == NULL)
1801 return NULL;
1802 res = getsockopt(s->sock_fd, level, optname,
1803 (void *)PyBytes_AS_STRING(buf), &buflen);
1804 if (res < 0) {
1805 Py_DECREF(buf);
1806 return s->errorhandler();
1807 }
1808 _PyBytes_Resize(&buf, buflen);
1809 return buf;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001810}
1811
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001812PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001813"getsockopt(level, option[, buffersize]) -> value\n\
1814\n\
1815Get a socket option. See the Unix manual for level and option.\n\
1816If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001817string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001818
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001819
Fred Drake728819a2000-07-01 03:40:12 +00001820/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001821
Guido van Rossum73624e91994-10-10 17:59:00 +00001822static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001823sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001824{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001825 sock_addr_t addrbuf;
1826 int addrlen;
1827 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001828
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001829 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
1830 return NULL;
1831 Py_BEGIN_ALLOW_THREADS
1832 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
1833 Py_END_ALLOW_THREADS
1834 if (res < 0)
1835 return s->errorhandler();
1836 Py_INCREF(Py_None);
1837 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001838}
1839
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001840PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001841"bind(address)\n\
1842\n\
1843Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00001844pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001845sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001846
Guido van Rossum30a685f1991-06-27 15:51:29 +00001847
1848/* s.close() method.
1849 Set the file descriptor to -1 so operations tried subsequently
1850 will surely fail. */
1851
Guido van Rossum73624e91994-10-10 17:59:00 +00001852static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001853sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001854{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001855 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001856
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001857 if ((fd = s->sock_fd) != -1) {
1858 s->sock_fd = -1;
1859 Py_BEGIN_ALLOW_THREADS
1860 (void) SOCKETCLOSE(fd);
1861 Py_END_ALLOW_THREADS
1862 }
1863 Py_INCREF(Py_None);
1864 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001865}
1866
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001867PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001868"close()\n\
1869\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001870Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001871
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001872static int
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001873internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001874 int *timeoutp)
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001875{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001876 int res, timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001877
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001878 timeout = 0;
1879 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001880
1881#ifdef MS_WINDOWS
1882
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001883 if (s->sock_timeout > 0.0) {
1884 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
1885 IS_SELECTABLE(s)) {
1886 /* This is a mess. Best solution: trust select */
1887 fd_set fds;
1888 fd_set fds_exc;
1889 struct timeval tv;
1890 tv.tv_sec = (int)s->sock_timeout;
1891 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
1892 FD_ZERO(&fds);
1893 FD_SET(s->sock_fd, &fds);
1894 FD_ZERO(&fds_exc);
1895 FD_SET(s->sock_fd, &fds_exc);
1896 res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
1897 if (res == 0) {
1898 res = WSAEWOULDBLOCK;
1899 timeout = 1;
1900 } else if (res > 0) {
1901 if (FD_ISSET(s->sock_fd, &fds))
1902 /* The socket is in the writable set - this
1903 means connected */
1904 res = 0;
1905 else {
1906 /* As per MS docs, we need to call getsockopt()
1907 to get the underlying error */
1908 int res_size = sizeof res;
1909 /* It must be in the exception set */
1910 assert(FD_ISSET(s->sock_fd, &fds_exc));
1911 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
1912 (char *)&res, &res_size))
1913 /* getsockopt also clears WSAGetLastError,
1914 so reset it back. */
1915 WSASetLastError(res);
1916 else
1917 res = WSAGetLastError();
1918 }
1919 }
1920 /* else if (res < 0) an error occurred */
1921 }
1922 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001923
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001924 if (res < 0)
1925 res = WSAGetLastError();
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001926
1927#else
1928
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001929 if (s->sock_timeout > 0.0) {
1930 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
1931 timeout = internal_select(s, 1);
1932 if (timeout == 0) {
1933 /* Bug #1019808: in case of an EINPROGRESS,
1934 use getsockopt(SO_ERROR) to get the real
1935 error. */
1936 socklen_t res_size = sizeof res;
1937 (void)getsockopt(s->sock_fd, SOL_SOCKET,
1938 SO_ERROR, &res, &res_size);
1939 if (res == EISCONN)
1940 res = 0;
1941 errno = res;
1942 }
1943 else if (timeout == -1) {
1944 res = errno; /* had error */
1945 }
1946 else
1947 res = EWOULDBLOCK; /* timed out */
1948 }
1949 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001950
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001951 if (res < 0)
1952 res = errno;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001953
1954#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001955 *timeoutp = timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001956
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001957 return res;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001958}
Guido van Rossum30a685f1991-06-27 15:51:29 +00001959
Fred Drake728819a2000-07-01 03:40:12 +00001960/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001961
Guido van Rossum73624e91994-10-10 17:59:00 +00001962static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001963sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001964{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001965 sock_addr_t addrbuf;
1966 int addrlen;
1967 int res;
1968 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001969
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001970 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
1971 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001972
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001973 Py_BEGIN_ALLOW_THREADS
1974 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
1975 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001976
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001977 if (timeout == 1) {
1978 PyErr_SetString(socket_timeout, "timed out");
1979 return NULL;
1980 }
1981 if (res != 0)
1982 return s->errorhandler();
1983 Py_INCREF(Py_None);
1984 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001985}
1986
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001987PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001988"connect(address)\n\
1989\n\
1990Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001991is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001992
Guido van Rossum30a685f1991-06-27 15:51:29 +00001993
Fred Drake728819a2000-07-01 03:40:12 +00001994/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001995
1996static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001997sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001998{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001999 sock_addr_t addrbuf;
2000 int addrlen;
2001 int res;
2002 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002003
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002004 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2005 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002006
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002007 Py_BEGIN_ALLOW_THREADS
2008 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2009 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002010
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002011 /* Signals are not errors (though they may raise exceptions). Adapted
2012 from PyErr_SetFromErrnoWithFilenameObject(). */
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002013#ifdef EINTR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002014 if (res == EINTR && PyErr_CheckSignals())
2015 return NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002016#endif
2017
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002018 return PyLong_FromLong((long) res);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002019}
2020
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002021PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002022"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002023\n\
2024This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002025instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002026
Guido van Rossumfc4255d1997-11-19 18:57:13 +00002027
Guido van Rossumed233a51992-06-23 09:07:03 +00002028/* s.fileno() method */
2029
Guido van Rossum73624e91994-10-10 17:59:00 +00002030static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002031sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00002032{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002033 return PyLong_FromSocket_t(s->sock_fd);
Guido van Rossumed233a51992-06-23 09:07:03 +00002034}
2035
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002036PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002037"fileno() -> integer\n\
2038\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002039Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002040
Guido van Rossumed233a51992-06-23 09:07:03 +00002041
Guido van Rossumc89705d1992-11-26 08:54:07 +00002042/* s.getsockname() method */
2043
Guido van Rossum73624e91994-10-10 17:59:00 +00002044static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002045sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002047 sock_addr_t addrbuf;
2048 int res;
2049 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002050
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002051 if (!getsockaddrlen(s, &addrlen))
2052 return NULL;
2053 memset(&addrbuf, 0, addrlen);
2054 Py_BEGIN_ALLOW_THREADS
2055 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2056 Py_END_ALLOW_THREADS
2057 if (res < 0)
2058 return s->errorhandler();
2059 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2060 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002061}
2062
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002063PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002064"getsockname() -> address info\n\
2065\n\
2066Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002067info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002068
Guido van Rossumc89705d1992-11-26 08:54:07 +00002069
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002070#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002071/* s.getpeername() method */
2072
Guido van Rossum73624e91994-10-10 17:59:00 +00002073static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002074sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00002075{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002076 sock_addr_t addrbuf;
2077 int res;
2078 socklen_t addrlen;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002079
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002080 if (!getsockaddrlen(s, &addrlen))
2081 return NULL;
2082 memset(&addrbuf, 0, addrlen);
2083 Py_BEGIN_ALLOW_THREADS
2084 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2085 Py_END_ALLOW_THREADS
2086 if (res < 0)
2087 return s->errorhandler();
2088 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2089 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00002090}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002091
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002092PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002093"getpeername() -> address info\n\
2094\n\
2095Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002096info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002097
Guido van Rossumb6775db1994-08-01 11:34:53 +00002098#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00002099
2100
Guido van Rossum30a685f1991-06-27 15:51:29 +00002101/* s.listen(n) method */
2102
Guido van Rossum73624e91994-10-10 17:59:00 +00002103static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002104sock_listen(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002105{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002106 int backlog;
2107 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002108
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002109 backlog = PyLong_AsLong(arg);
2110 if (backlog == -1 && PyErr_Occurred())
2111 return NULL;
2112 Py_BEGIN_ALLOW_THREADS
2113 if (backlog < 1)
2114 backlog = 1;
2115 res = listen(s->sock_fd, backlog);
2116 Py_END_ALLOW_THREADS
2117 if (res < 0)
2118 return s->errorhandler();
2119 Py_INCREF(Py_None);
2120 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002121}
2122
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002123PyDoc_STRVAR(listen_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002124"listen(backlog)\n\
2125\n\
2126Enable a server to accept connections. The backlog argument must be at\n\
2127least 1; it specifies the number of unaccepted connection that the system\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002128will allow before refusing new connections.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002129
2130
Thomas Wouters477c8d52006-05-27 19:21:47 +00002131/*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002132 * This is the guts of the recv() and recv_into() methods, which reads into a
Thomas Wouters902d6eb2007-01-09 23:18:33 +00002133 * char buffer. If you have any inc/dec ref to do to the objects that contain
Thomas Wouters477c8d52006-05-27 19:21:47 +00002134 * the buffer, do it in the caller. This function returns the number of bytes
2135 * succesfully read. If there was an error, it returns -1. Note that it is
2136 * also possible that we return a number of bytes smaller than the request
2137 * bytes.
2138 */
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002139static ssize_t
Thomas Wouters477c8d52006-05-27 19:21:47 +00002140sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags)
2141{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002142 ssize_t outlen = -1;
2143 int timeout;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002144#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002145 int remaining;
2146 char *read_buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002147#endif
2148
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002149 if (!IS_SELECTABLE(s)) {
2150 select_error();
2151 return -1;
2152 }
2153 if (len == 0) {
2154 /* If 0 bytes were requested, do nothing. */
2155 return 0;
2156 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002157
2158#ifndef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002159 Py_BEGIN_ALLOW_THREADS
2160 timeout = internal_select(s, 0);
2161 if (!timeout)
2162 outlen = recv(s->sock_fd, cbuf, len, flags);
2163 Py_END_ALLOW_THREADS
Thomas Wouters477c8d52006-05-27 19:21:47 +00002164
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002165 if (timeout == 1) {
2166 PyErr_SetString(socket_timeout, "timed out");
2167 return -1;
2168 }
2169 if (outlen < 0) {
2170 /* Note: the call to errorhandler() ALWAYS indirectly returned
2171 NULL, so ignore its return value */
2172 s->errorhandler();
2173 return -1;
2174 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002175#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002176 read_buf = cbuf;
2177 remaining = len;
2178 while (remaining != 0) {
2179 unsigned int segment;
2180 int nread = -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002181
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002182 segment = remaining /SEGMENT_SIZE;
2183 if (segment != 0) {
2184 segment = SEGMENT_SIZE;
2185 }
2186 else {
2187 segment = remaining;
2188 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002189
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002190 Py_BEGIN_ALLOW_THREADS
2191 timeout = internal_select(s, 0);
2192 if (!timeout)
2193 nread = recv(s->sock_fd, read_buf, segment, flags);
2194 Py_END_ALLOW_THREADS
Thomas Wouters477c8d52006-05-27 19:21:47 +00002195
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002196 if (timeout == 1) {
2197 PyErr_SetString(socket_timeout, "timed out");
2198 return -1;
2199 }
2200 if (nread < 0) {
2201 s->errorhandler();
2202 return -1;
2203 }
2204 if (nread != remaining) {
2205 read_buf += nread;
2206 break;
2207 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002208
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002209 remaining -= segment;
2210 read_buf += segment;
2211 }
2212 outlen = read_buf - cbuf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002213#endif /* !__VMS */
2214
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002215 return outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002216}
2217
Guido van Rossum48a680c2001-03-02 06:34:14 +00002218
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002219/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002220
Guido van Rossum73624e91994-10-10 17:59:00 +00002221static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002222sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002223{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002224 int recvlen, flags = 0;
2225 ssize_t outlen;
2226 PyObject *buf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002227
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002228 if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
2229 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002230
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002231 if (recvlen < 0) {
2232 PyErr_SetString(PyExc_ValueError,
2233 "negative buffersize in recv");
2234 return NULL;
2235 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002236
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002237 /* Allocate a new string. */
2238 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2239 if (buf == NULL)
2240 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002241
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002242 /* Call the guts */
2243 outlen = sock_recv_guts(s, PyBytes_AS_STRING(buf), recvlen, flags);
2244 if (outlen < 0) {
2245 /* An error occurred, release the string and return an
2246 error. */
2247 Py_DECREF(buf);
2248 return NULL;
2249 }
2250 if (outlen != recvlen) {
2251 /* We did not read as many bytes as we anticipated, resize the
2252 string if possible and be successful. */
2253 _PyBytes_Resize(&buf, outlen);
2254 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002255
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002256 return buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002257}
2258
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002259PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002260"recv(buffersize[, flags]) -> data\n\
2261\n\
2262Receive up to buffersize bytes from the socket. For the optional flags\n\
2263argument, see the Unix manual. When no data is available, block until\n\
2264at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002265the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002266
Guido van Rossum30a685f1991-06-27 15:51:29 +00002267
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002268/* s.recv_into(buffer, [nbytes [,flags]]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002269
Thomas Wouters477c8d52006-05-27 19:21:47 +00002270static PyObject*
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002271sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002272{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002273 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002274
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002275 int recvlen = 0, flags = 0;
2276 ssize_t readlen;
2277 Py_buffer pbuf;
2278 char *buf;
2279 int buflen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002280
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002281 /* Get the buffer's memory */
2282 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,
2283 &pbuf, &recvlen, &flags))
2284 return NULL;
2285 buf = pbuf.buf;
2286 buflen = pbuf.len;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002287
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002288 if (recvlen < 0) {
2289 PyBuffer_Release(&pbuf);
2290 PyErr_SetString(PyExc_ValueError,
2291 "negative buffersize in recv_into");
2292 return NULL;
2293 }
2294 if (recvlen == 0) {
2295 /* If nbytes was not specified, use the buffer's length */
2296 recvlen = buflen;
2297 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002298
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002299 /* Check if the buffer is large enough */
2300 if (buflen < recvlen) {
2301 PyBuffer_Release(&pbuf);
2302 PyErr_SetString(PyExc_ValueError,
2303 "buffer too small for requested bytes");
2304 return NULL;
2305 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002306
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002307 /* Call the guts */
2308 readlen = sock_recv_guts(s, buf, recvlen, flags);
2309 if (readlen < 0) {
2310 /* Return an error. */
2311 PyBuffer_Release(&pbuf);
2312 return NULL;
2313 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002314
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002315 PyBuffer_Release(&pbuf);
2316 /* Return the number of bytes read. Note that we do not do anything
2317 special here in the case that readlen < recvlen. */
2318 return PyLong_FromSsize_t(readlen);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002319}
2320
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002321PyDoc_STRVAR(recv_into_doc,
2322"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002323\n\
2324A version of recv() that stores its data into a buffer rather than creating \n\
2325a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
2326is not specified (or 0), receive up to the size available in the given buffer.\n\
2327\n\
2328See recv() for documentation about the flags.");
2329
2330
2331/*
Christian Heimes99170a52007-12-19 02:07:34 +00002332 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
2333 * into a char buffer. If you have any inc/def ref to do to the objects that
2334 * contain the buffer, do it in the caller. This function returns the number
2335 * of bytes succesfully read. If there was an error, it returns -1. Note
2336 * that it is also possible that we return a number of bytes smaller than the
2337 * request bytes.
Thomas Wouters477c8d52006-05-27 19:21:47 +00002338 *
2339 * 'addr' is a return value for the address object. Note that you must decref
2340 * it yourself.
2341 */
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002342static ssize_t
Thomas Wouters477c8d52006-05-27 19:21:47 +00002343sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002344 PyObject** addr)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002345{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002346 sock_addr_t addrbuf;
2347 int timeout;
2348 ssize_t n = -1;
2349 socklen_t addrlen;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002350
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002351 *addr = NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002352
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002353 if (!getsockaddrlen(s, &addrlen))
2354 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002355
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002356 if (!IS_SELECTABLE(s)) {
2357 select_error();
2358 return -1;
2359 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002360
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002361 Py_BEGIN_ALLOW_THREADS
2362 memset(&addrbuf, 0, addrlen);
2363 timeout = internal_select(s, 0);
2364 if (!timeout) {
Guido van Rossum8d665e61996-06-26 18:22:49 +00002365#ifndef MS_WINDOWS
Andrew MacIntyreba43e872002-03-03 03:03:52 +00002366#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002367 n = recvfrom(s->sock_fd, cbuf, len, flags,
2368 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002369#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002370 n = recvfrom(s->sock_fd, cbuf, len, flags,
2371 (void *) &addrbuf, &addrlen);
Guido van Rossum32c575d1997-12-02 20:37:32 +00002372#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002373#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002374 n = recvfrom(s->sock_fd, cbuf, len, flags,
2375 SAS2SA(&addrbuf), &addrlen);
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002376#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002377 }
2378 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002379
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002380 if (timeout == 1) {
2381 PyErr_SetString(socket_timeout, "timed out");
2382 return -1;
2383 }
2384 if (n < 0) {
2385 s->errorhandler();
2386 return -1;
2387 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002388
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002389 if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2390 addrlen, s->sock_proto)))
2391 return -1;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002392
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002393 return n;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002394}
2395
2396/* s.recvfrom(nbytes [,flags]) method */
2397
2398static PyObject *
2399sock_recvfrom(PySocketSockObject *s, PyObject *args)
2400{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002401 PyObject *buf = NULL;
2402 PyObject *addr = NULL;
2403 PyObject *ret = NULL;
2404 int recvlen, flags = 0;
2405 ssize_t outlen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002406
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002407 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
2408 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002409
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002410 if (recvlen < 0) {
2411 PyErr_SetString(PyExc_ValueError,
2412 "negative buffersize in recvfrom");
2413 return NULL;
2414 }
Guido van Rossumd8faa362007-04-27 19:54:29 +00002415
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002416 buf = PyBytes_FromStringAndSize((char *) 0, recvlen);
2417 if (buf == NULL)
2418 return NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002419
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002420 outlen = sock_recvfrom_guts(s, PyBytes_AS_STRING(buf),
2421 recvlen, flags, &addr);
2422 if (outlen < 0) {
2423 goto finally;
2424 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002425
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002426 if (outlen != recvlen) {
2427 /* We did not read as many bytes as we anticipated, resize the
2428 string if possible and be succesful. */
2429 if (_PyBytes_Resize(&buf, outlen) < 0)
2430 /* Oopsy, not so succesful after all. */
2431 goto finally;
2432 }
Barry Warsaw752300b1997-01-03 17:18:10 +00002433
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002434 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002435
2436finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002437 Py_XDECREF(buf);
2438 Py_XDECREF(addr);
2439 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002440}
2441
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002442PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002443"recvfrom(buffersize[, flags]) -> (data, address info)\n\
2444\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002445Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002446
Thomas Wouters477c8d52006-05-27 19:21:47 +00002447
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002448/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002449
2450static PyObject *
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002451sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002452{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002453 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
Thomas Wouters477c8d52006-05-27 19:21:47 +00002454
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002455 int recvlen = 0, flags = 0;
2456 ssize_t readlen;
2457 Py_buffer pbuf;
2458 char *buf;
2459 int buflen;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002460
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002461 PyObject *addr = NULL;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002462
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002463 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",
2464 kwlist, &pbuf,
2465 &recvlen, &flags))
2466 return NULL;
2467 buf = pbuf.buf;
2468 buflen = pbuf.len;
2469 assert(buf != 0 && buflen > 0);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002470
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002471 if (recvlen < 0) {
2472 PyBuffer_Release(&pbuf);
2473 PyErr_SetString(PyExc_ValueError,
2474 "negative buffersize in recvfrom_into");
2475 return NULL;
2476 }
2477 if (recvlen == 0) {
2478 /* If nbytes was not specified, use the buffer's length */
2479 recvlen = buflen;
2480 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002481
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002482 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
2483 if (readlen < 0) {
2484 PyBuffer_Release(&pbuf);
2485 /* Return an error */
2486 Py_XDECREF(addr);
2487 return NULL;
2488 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00002489
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002490 PyBuffer_Release(&pbuf);
2491 /* Return the number of bytes read and the address. Note that we do
2492 not do anything special here in the case that readlen < recvlen. */
2493 return Py_BuildValue("lN", readlen, addr);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002494}
2495
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002496PyDoc_STRVAR(recvfrom_into_doc,
2497"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
Thomas Wouters477c8d52006-05-27 19:21:47 +00002498\n\
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00002499Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
Thomas Wouters477c8d52006-05-27 19:21:47 +00002500
2501
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002502/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002503
Guido van Rossum73624e91994-10-10 17:59:00 +00002504static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002505sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002506{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002507 char *buf;
2508 int len, n = -1, flags = 0, timeout;
2509 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002510
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002511 if (!PyArg_ParseTuple(args, "y*|i:send", &pbuf, &flags))
2512 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002513
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002514 if (!IS_SELECTABLE(s)) {
2515 PyBuffer_Release(&pbuf);
2516 return select_error();
2517 }
2518 buf = pbuf.buf;
2519 len = pbuf.len;
Neal Norwitz082b2df2006-02-07 07:04:46 +00002520
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002521 Py_BEGIN_ALLOW_THREADS
2522 timeout = internal_select(s, 1);
2523 if (!timeout)
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002524#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002525 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002526#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002527 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002528#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002529 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002530
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002531 PyBuffer_Release(&pbuf);
Martin v. Löwis423be952008-08-13 15:53:07 +00002532
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002533 if (timeout == 1) {
2534 PyErr_SetString(socket_timeout, "timed out");
2535 return NULL;
2536 }
2537 if (n < 0)
2538 return s->errorhandler();
2539 return PyLong_FromLong((long)n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00002540}
2541
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002542PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002543"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002544\n\
2545Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002546argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002547sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002548
2549
2550/* s.sendall(data [,flags]) method */
2551
2552static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002553sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002554{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002555 char *buf;
2556 int len, n = -1, flags = 0, timeout;
2557 Py_buffer pbuf;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002558
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002559 if (!PyArg_ParseTuple(args, "y*|i:sendall", &pbuf, &flags))
2560 return NULL;
2561 buf = pbuf.buf;
2562 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002563
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002564 if (!IS_SELECTABLE(s)) {
2565 PyBuffer_Release(&pbuf);
2566 return select_error();
2567 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002568
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002569 Py_BEGIN_ALLOW_THREADS
2570 do {
2571 timeout = internal_select(s, 1);
2572 n = -1;
2573 if (timeout)
2574 break;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002575#ifdef __VMS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002576 n = sendsegmented(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002577#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002578 n = send(s->sock_fd, buf, len, flags);
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002579#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002580 if (n < 0) {
Gregory P. Smithb585a0f2010-01-04 03:29:50 +00002581#ifdef EINTR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002582 /* We must handle EINTR here as there is no way for
2583 * the caller to know how much was sent otherwise. */
2584 if (errno == EINTR) {
2585 /* Run signal handlers. If an exception was
2586 * raised, abort and leave this socket in
2587 * an unknown state. */
2588 if (PyErr_CheckSignals())
2589 return NULL;
2590 continue;
2591 }
Gregory P. Smithb585a0f2010-01-04 03:29:50 +00002592#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002593 break;
2594 }
2595 buf += n;
2596 len -= n;
2597 } while (len > 0);
2598 Py_END_ALLOW_THREADS
2599 PyBuffer_Release(&pbuf);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002600
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002601 if (timeout == 1) {
2602 PyErr_SetString(socket_timeout, "timed out");
2603 return NULL;
2604 }
2605 if (n < 0)
2606 return s->errorhandler();
Guido van Rossum67f7a382002-06-06 21:08:16 +00002607
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002608 Py_INCREF(Py_None);
2609 return Py_None;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002610}
2611
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002612PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002613"sendall(data[, flags])\n\
2614\n\
2615Send a data string to the socket. For the optional flags\n\
2616argument, see the Unix manual. This calls send() repeatedly\n\
2617until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002618to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002619
Guido van Rossum30a685f1991-06-27 15:51:29 +00002620
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002621/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002622
Guido van Rossum73624e91994-10-10 17:59:00 +00002623static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002624sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002625{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002626 Py_buffer pbuf;
2627 PyObject *addro;
2628 char *buf;
2629 Py_ssize_t len;
2630 sock_addr_t addrbuf;
2631 int addrlen, n = -1, flags, timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002632
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002633 flags = 0;
2634 if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
2635 PyErr_Clear();
2636 if (!PyArg_ParseTuple(args, "y*iO:sendto",
2637 &pbuf, &flags, &addro))
2638 return NULL;
2639 }
2640 buf = pbuf.buf;
2641 len = pbuf.len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002642
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002643 if (!IS_SELECTABLE(s)) {
2644 PyBuffer_Release(&pbuf);
2645 return select_error();
2646 }
Neal Norwitz082b2df2006-02-07 07:04:46 +00002647
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002648 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {
2649 PyBuffer_Release(&pbuf);
2650 return NULL;
2651 }
Thomas Wouters89f507f2006-12-13 04:49:30 +00002652
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002653 Py_BEGIN_ALLOW_THREADS
2654 timeout = internal_select(s, 1);
2655 if (!timeout)
2656 n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
2657 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002658
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002659 PyBuffer_Release(&pbuf);
2660 if (timeout == 1) {
2661 PyErr_SetString(socket_timeout, "timed out");
2662 return NULL;
2663 }
2664 if (n < 0)
2665 return s->errorhandler();
2666 return PyLong_FromLong((long)n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002667}
2668
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002669PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002670"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002671\n\
2672Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002673For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002674
Guido van Rossum30a685f1991-06-27 15:51:29 +00002675
2676/* s.shutdown(how) method */
2677
Guido van Rossum73624e91994-10-10 17:59:00 +00002678static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002679sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002680{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002681 int how;
2682 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002683
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002684 how = PyLong_AsLong(arg);
2685 if (how == -1 && PyErr_Occurred())
2686 return NULL;
2687 Py_BEGIN_ALLOW_THREADS
2688 res = shutdown(s->sock_fd, how);
2689 Py_END_ALLOW_THREADS
2690 if (res < 0)
2691 return s->errorhandler();
2692 Py_INCREF(Py_None);
2693 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002694}
2695
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002696PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002697"shutdown(flag)\n\
2698\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00002699Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
2700of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002701
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00002702#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Christian Heimesfaf2f632008-01-06 16:59:19 +00002703static PyObject*
2704sock_ioctl(PySocketSockObject *s, PyObject *arg)
2705{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002706 unsigned long cmd = SIO_RCVALL;
2707 PyObject *argO;
2708 DWORD recv;
Christian Heimesfaf2f632008-01-06 16:59:19 +00002709
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002710 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))
2711 return NULL;
Christian Heimesfaf2f632008-01-06 16:59:19 +00002712
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 switch (cmd) {
2714 case SIO_RCVALL: {
2715 unsigned int option = RCVALL_ON;
2716 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
2717 return NULL;
2718 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
2719 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
2720 return set_error();
2721 }
2722 return PyLong_FromUnsignedLong(recv); }
2723 case SIO_KEEPALIVE_VALS: {
2724 struct tcp_keepalive ka;
2725 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,
2726 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))
2727 return NULL;
2728 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),
2729 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
2730 return set_error();
2731 }
2732 return PyLong_FromUnsignedLong(recv); }
2733 default:
2734 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);
2735 return NULL;
2736 }
Christian Heimesfaf2f632008-01-06 16:59:19 +00002737}
2738PyDoc_STRVAR(sock_ioctl_doc,
2739"ioctl(cmd, option) -> long\n\
2740\n\
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00002741Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\
2742SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\
2743SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).");
Christian Heimesfaf2f632008-01-06 16:59:19 +00002744
2745#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00002746
2747/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002748
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002749static PyMethodDef sock_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002750 {"_accept", (PyCFunction)sock_accept, METH_NOARGS,
2751 accept_doc},
2752 {"bind", (PyCFunction)sock_bind, METH_O,
2753 bind_doc},
2754 {"close", (PyCFunction)sock_close, METH_NOARGS,
2755 close_doc},
2756 {"connect", (PyCFunction)sock_connect, METH_O,
2757 connect_doc},
2758 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
2759 connect_ex_doc},
2760 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
2761 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00002762#ifdef HAVE_GETPEERNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002763 {"getpeername", (PyCFunction)sock_getpeername,
2764 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00002765#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002766 {"getsockname", (PyCFunction)sock_getsockname,
2767 METH_NOARGS, getsockname_doc},
2768 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
2769 getsockopt_doc},
Amaury Forgeot d'Arc3d17a5c2008-06-13 01:09:34 +00002770#if defined(MS_WINDOWS) && defined(SIO_RCVALL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002771 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
2772 sock_ioctl_doc},
Christian Heimesfaf2f632008-01-06 16:59:19 +00002773#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002774 {"listen", (PyCFunction)sock_listen, METH_O,
2775 listen_doc},
2776 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
2777 recv_doc},
2778 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
2779 recv_into_doc},
2780 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
2781 recvfrom_doc},
2782 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
2783 recvfrom_into_doc},
2784 {"send", (PyCFunction)sock_send, METH_VARARGS,
2785 send_doc},
2786 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
2787 sendall_doc},
2788 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
2789 sendto_doc},
2790 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
2791 setblocking_doc},
2792 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
2793 settimeout_doc},
2794 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
2795 gettimeout_doc},
2796 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
2797 setsockopt_doc},
2798 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
2799 shutdown_doc},
2800 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002801};
2802
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002803/* SockObject members */
2804static PyMemberDef sock_memberlist[] = {
2805 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
2806 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
2807 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
2808 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
2809 {0},
2810};
Guido van Rossum30a685f1991-06-27 15:51:29 +00002811
Guido van Rossum73624e91994-10-10 17:59:00 +00002812/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00002813 First close the file description. */
2814
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002815static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002816sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002817{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002818 if (s->sock_fd != -1)
2819 (void) SOCKETCLOSE(s->sock_fd);
2820 Py_TYPE(s)->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002821}
2822
Guido van Rossum30a685f1991-06-27 15:51:29 +00002823
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002824static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002825sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002826{
Fred Drakea04eaad2000-06-30 02:46:07 +00002827#if SIZEOF_SOCKET_T > SIZEOF_LONG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002828 if (s->sock_fd > LONG_MAX) {
2829 /* this can occur on Win64, and actually there is a special
2830 ugly printf formatter for decimal pointer length integer
2831 printing, only bother if necessary*/
2832 PyErr_SetString(PyExc_OverflowError,
2833 "no printf formatter to display "
2834 "the socket descriptor in decimal");
2835 return NULL;
2836 }
Fred Drakea04eaad2000-06-30 02:46:07 +00002837#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002838 return PyUnicode_FromFormat(
2839 "<socket object, fd=%ld, family=%d, type=%d, proto=%d>",
2840 (long)s->sock_fd, s->sock_family,
2841 s->sock_type,
2842 s->sock_proto);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002843}
2844
2845
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002846/* Create a new, uninitialized socket object. */
2847
2848static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002849sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002850{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002851 PyObject *new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002852
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002853 new = type->tp_alloc(type, 0);
2854 if (new != NULL) {
2855 ((PySocketSockObject *)new)->sock_fd = -1;
2856 ((PySocketSockObject *)new)->sock_timeout = -1.0;
2857 ((PySocketSockObject *)new)->errorhandler = &set_error;
2858 }
2859 return new;
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002860}
2861
2862
2863/* Initialize a new socket object. */
2864
2865/*ARGSUSED*/
2866static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00002867sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002868{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002869 PySocketSockObject *s = (PySocketSockObject *)self;
2870 PyObject *fdobj = NULL;
2871 SOCKET_T fd = INVALID_SOCKET;
2872 int family = AF_INET, type = SOCK_STREAM, proto = 0;
2873 static char *keywords[] = {"family", "type", "proto", "fileno", 0};
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002874
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002875 if (!PyArg_ParseTupleAndKeywords(args, kwds,
2876 "|iiiO:socket", keywords,
2877 &family, &type, &proto, &fdobj))
2878 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002879
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002880 if (fdobj != NULL && fdobj != Py_None) {
2881 fd = PyLong_AsSocket_t(fdobj);
2882 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
2883 return -1;
2884 if (fd == INVALID_SOCKET) {
2885 PyErr_SetString(PyExc_ValueError,
2886 "can't use invalid socket value");
2887 return -1;
2888 }
2889 }
2890 else {
2891 Py_BEGIN_ALLOW_THREADS
2892 fd = socket(family, type, proto);
2893 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002894
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002895 if (fd == INVALID_SOCKET) {
2896 set_error();
2897 return -1;
2898 }
2899 }
2900 init_sockobject(s, fd, family, type, proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002901
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002902 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002903
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002904}
2905
2906
Guido van Rossumb6775db1994-08-01 11:34:53 +00002907/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002908
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002909static PyTypeObject sock_type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002910 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
2911 "_socket.socket", /* tp_name */
2912 sizeof(PySocketSockObject), /* tp_basicsize */
2913 0, /* tp_itemsize */
2914 (destructor)sock_dealloc, /* tp_dealloc */
2915 0, /* tp_print */
2916 0, /* tp_getattr */
2917 0, /* tp_setattr */
2918 0, /* tp_reserved */
2919 (reprfunc)sock_repr, /* tp_repr */
2920 0, /* tp_as_number */
2921 0, /* tp_as_sequence */
2922 0, /* tp_as_mapping */
2923 0, /* tp_hash */
2924 0, /* tp_call */
2925 0, /* tp_str */
2926 PyObject_GenericGetAttr, /* tp_getattro */
2927 0, /* tp_setattro */
2928 0, /* tp_as_buffer */
2929 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2930 sock_doc, /* tp_doc */
2931 0, /* tp_traverse */
2932 0, /* tp_clear */
2933 0, /* tp_richcompare */
2934 0, /* tp_weaklistoffset */
2935 0, /* tp_iter */
2936 0, /* tp_iternext */
2937 sock_methods, /* tp_methods */
2938 sock_memberlist, /* tp_members */
2939 0, /* tp_getset */
2940 0, /* tp_base */
2941 0, /* tp_dict */
2942 0, /* tp_descr_get */
2943 0, /* tp_descr_set */
2944 0, /* tp_dictoffset */
2945 sock_initobj, /* tp_init */
2946 PyType_GenericAlloc, /* tp_alloc */
2947 sock_new, /* tp_new */
2948 PyObject_Del, /* tp_free */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002949};
2950
Guido van Rossum30a685f1991-06-27 15:51:29 +00002951
Guido van Rossum81194471991-07-27 21:42:02 +00002952/* Python interface to gethostname(). */
2953
2954/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002955static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +00002956socket_gethostname(PyObject *self, PyObject *unused)
Guido van Rossum81194471991-07-27 21:42:02 +00002957{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002958 char buf[1024];
2959 int res;
2960 Py_BEGIN_ALLOW_THREADS
2961 res = gethostname(buf, (int) sizeof buf - 1);
2962 Py_END_ALLOW_THREADS
2963 if (res < 0)
2964 return set_error();
2965 buf[sizeof buf - 1] = '\0';
2966 return PyUnicode_FromString(buf);
Guido van Rossum81194471991-07-27 21:42:02 +00002967}
Guido van Rossumff4949e1992-08-05 19:58:53 +00002968
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002969PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002970"gethostname() -> string\n\
2971\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002972Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002973
Guido van Rossumff4949e1992-08-05 19:58:53 +00002974
Guido van Rossum30a685f1991-06-27 15:51:29 +00002975/* Python interface to gethostbyname(name). */
2976
2977/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002978static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002979socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002980{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002981 char *name;
2982 sock_addr_t addrbuf;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002984 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
2985 return NULL;
2986 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
2987 return NULL;
2988 return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
Guido van Rossum30a685f1991-06-27 15:51:29 +00002989}
2990
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002991PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002992"gethostbyname(host) -> address\n\
2993\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002994Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002995
2996
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002997/* Convenience function common to gethostbyname_ex and gethostbyaddr */
2998
2999static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003000gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003001{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003002 char **pch;
3003 PyObject *rtn_tuple = (PyObject *)NULL;
3004 PyObject *name_list = (PyObject *)NULL;
3005 PyObject *addr_list = (PyObject *)NULL;
3006 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003007
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003008 if (h == NULL) {
3009 /* Let's get real error message to return */
3010 set_herror(h_errno);
3011 return NULL;
3012 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003013
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003014 if (h->h_addrtype != af) {
3015 /* Let's get real error message to return */
3016 PyErr_SetString(socket_error,
3017 (char *)strerror(EAFNOSUPPORT));
Christian Heimesada8c3b2008-03-18 18:26:33 +00003018
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003019 return NULL;
3020 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003022 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003023
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003024 case AF_INET:
3025 if (alen < sizeof(struct sockaddr_in))
3026 return NULL;
3027 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003028
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003029#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003030 case AF_INET6:
3031 if (alen < sizeof(struct sockaddr_in6))
3032 return NULL;
3033 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003034#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00003035
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003036 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003037
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003038 if ((name_list = PyList_New(0)) == NULL)
3039 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003040
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003041 if ((addr_list = PyList_New(0)) == NULL)
3042 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003043
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003044 /* SF #1511317: h_aliases can be NULL */
3045 if (h->h_aliases) {
3046 for (pch = h->h_aliases; *pch != NULL; pch++) {
3047 int status;
3048 tmp = PyUnicode_FromString(*pch);
3049 if (tmp == NULL)
3050 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003051
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003052 status = PyList_Append(name_list, tmp);
3053 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003054
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003055 if (status)
3056 goto err;
3057 }
3058 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003059
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003060 for (pch = h->h_addr_list; *pch != NULL; pch++) {
3061 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003062
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003063 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00003064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003065 case AF_INET:
3066 {
3067 struct sockaddr_in sin;
3068 memset(&sin, 0, sizeof(sin));
3069 sin.sin_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003070#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003071 sin.sin_len = sizeof(sin);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003072#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003073 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
3074 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00003075
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003076 if (pch == h->h_addr_list && alen >= sizeof(sin))
3077 memcpy((char *) addr, &sin, sizeof(sin));
3078 break;
3079 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003080
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003081#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003082 case AF_INET6:
3083 {
3084 struct sockaddr_in6 sin6;
3085 memset(&sin6, 0, sizeof(sin6));
3086 sin6.sin6_family = af;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003087#ifdef HAVE_SOCKADDR_SA_LEN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003088 sin6.sin6_len = sizeof(sin6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003089#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003090 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
3091 tmp = makeipaddr((struct sockaddr *)&sin6,
3092 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00003093
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003094 if (pch == h->h_addr_list && alen >= sizeof(sin6))
3095 memcpy((char *) addr, &sin6, sizeof(sin6));
3096 break;
3097 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003098#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00003099
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003100 default: /* can't happen */
3101 PyErr_SetString(socket_error,
3102 "unsupported address family");
3103 return NULL;
3104 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003105
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003106 if (tmp == NULL)
3107 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00003108
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003109 status = PyList_Append(addr_list, tmp);
3110 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003111
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003112 if (status)
3113 goto err;
3114 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00003115
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003116 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00003117
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003118 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003119 Py_XDECREF(name_list);
3120 Py_XDECREF(addr_list);
3121 return rtn_tuple;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003122}
3123
3124
3125/* Python interface to gethostbyname_ex(name). */
3126
3127/*ARGSUSED*/
3128static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003129socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003130{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003131 char *name;
3132 struct hostent *h;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003133#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003134 struct sockaddr_storage addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003135#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003136 struct sockaddr_in addr;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00003137#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003138 struct sockaddr *sa;
3139 PyObject *ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003140#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003141 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003142#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003143 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003144#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003145 char buf[16384];
3146 int buf_len = (sizeof buf) - 1;
3147 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003148#endif
3149#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003150 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003151#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003152#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003153
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003154 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
3155 return NULL;
3156 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
3157 return NULL;
3158 Py_BEGIN_ALLOW_THREADS
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003159#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003160#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003161 result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
3162 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003163#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003164 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003165#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003166 memset((void *) &data, '\0', sizeof(data));
3167 result = gethostbyname_r(name, &hp_allocated, &data);
3168 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003169#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003170#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003171#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003172 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003173#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003174 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003175#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003176 Py_END_ALLOW_THREADS
3177 /* Some C libraries would require addr.__ss_family instead of
3178 addr.ss_family.
3179 Therefore, we cast the sockaddr_storage into sockaddr to
3180 access sa_family. */
3181 sa = (struct sockaddr*)&addr;
3182 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
3183 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003184#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003185 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00003186#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003187 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003188}
3189
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003190PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003191"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
3192\n\
3193Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003194for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00003195
3196
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003197/* Python interface to gethostbyaddr(IP). */
3198
3199/*ARGSUSED*/
3200static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003201socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003202{
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003203#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003204 struct sockaddr_storage addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003205#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003206 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003207#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003208 struct sockaddr *sa = (struct sockaddr *)&addr;
3209 char *ip_num;
3210 struct hostent *h;
3211 PyObject *ret;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003212#ifdef HAVE_GETHOSTBYNAME_R
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003213 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003214#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003215 struct hostent_data data;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003216#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003217 /* glibcs up to 2.10 assume that the buf argument to
3218 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc
3219 does not ensure. The attribute below instructs the compiler
3220 to maintain this alignment. */
3221 char buf[16384] Py_ALIGNED(8);
3222 int buf_len = (sizeof buf) - 1;
3223 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003224#endif
3225#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003226 int result;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003227#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003228#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003229 char *ap;
3230 int al;
3231 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003232
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003233 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
3234 return NULL;
3235 af = AF_UNSPEC;
3236 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
3237 return NULL;
3238 af = sa->sa_family;
3239 ap = NULL;
3240 al = 0;
3241 switch (af) {
3242 case AF_INET:
3243 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
3244 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
3245 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003246#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003247 case AF_INET6:
3248 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
3249 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
3250 break;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003251#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003252 default:
3253 PyErr_SetString(socket_error, "unsupported address family");
3254 return NULL;
3255 }
3256 Py_BEGIN_ALLOW_THREADS
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003257#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003258#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003259 result = gethostbyaddr_r(ap, al, af,
3260 &hp_allocated, buf, buf_len,
3261 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003262#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003263 h = gethostbyaddr_r(ap, al, af,
3264 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00003265#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003266 memset((void *) &data, '\0', sizeof(data));
3267 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
3268 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00003269#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003270#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003271#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003272 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003273#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003274 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003275#endif /* HAVE_GETHOSTBYNAME_R */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003276 Py_END_ALLOW_THREADS
3277 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003278#ifdef USE_GETHOSTBYNAME_LOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003279 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00003280#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003281 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00003282}
3283
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003284PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003285"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
3286\n\
3287Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003288for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003289
Guido van Rossum30a685f1991-06-27 15:51:29 +00003290
3291/* Python interface to getservbyname(name).
3292 This only returns the port number, since the other info is already
3293 known or not useful (like the list of aliases). */
3294
3295/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003296static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003297socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003298{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003299 char *name, *proto=NULL;
3300 struct servent *sp;
3301 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
3302 return NULL;
3303 Py_BEGIN_ALLOW_THREADS
3304 sp = getservbyname(name, proto);
3305 Py_END_ALLOW_THREADS
3306 if (sp == NULL) {
3307 PyErr_SetString(socket_error, "service/proto not found");
3308 return NULL;
3309 }
3310 return PyLong_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00003311}
3312
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003313PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00003314"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003315\n\
3316Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00003317The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3318otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003319
Guido van Rossum30a685f1991-06-27 15:51:29 +00003320
Barry Warsaw11b91a02004-06-28 00:50:43 +00003321/* Python interface to getservbyport(port).
3322 This only returns the service name, since the other info is already
3323 known or not useful (like the list of aliases). */
3324
3325/*ARGSUSED*/
3326static PyObject *
3327socket_getservbyport(PyObject *self, PyObject *args)
3328{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003329 int port;
3330 char *proto=NULL;
3331 struct servent *sp;
3332 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))
3333 return NULL;
3334 if (port < 0 || port > 0xffff) {
3335 PyErr_SetString(
3336 PyExc_OverflowError,
3337 "getservbyport: port must be 0-65535.");
3338 return NULL;
3339 }
3340 Py_BEGIN_ALLOW_THREADS
3341 sp = getservbyport(htons((short)port), proto);
3342 Py_END_ALLOW_THREADS
3343 if (sp == NULL) {
3344 PyErr_SetString(socket_error, "port/proto not found");
3345 return NULL;
3346 }
3347 return PyUnicode_FromString(sp->s_name);
Barry Warsaw11b91a02004-06-28 00:50:43 +00003348}
3349
3350PyDoc_STRVAR(getservbyport_doc,
3351"getservbyport(port[, protocolname]) -> string\n\
3352\n\
3353Return the service name from a port number and protocol name.\n\
3354The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3355otherwise any protocol will match.");
3356
Guido van Rossum3901d851996-12-19 16:35:04 +00003357/* Python interface to getprotobyname(name).
3358 This only returns the protocol number, since the other info is
3359 already known or not useful (like the list of aliases). */
3360
3361/*ARGSUSED*/
3362static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003363socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00003364{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003365 char *name;
3366 struct protoent *sp;
3367 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
3368 return NULL;
3369 Py_BEGIN_ALLOW_THREADS
3370 sp = getprotobyname(name);
3371 Py_END_ALLOW_THREADS
3372 if (sp == NULL) {
3373 PyErr_SetString(socket_error, "protocol not found");
3374 return NULL;
3375 }
3376 return PyLong_FromLong((long) sp->p_proto);
Guido van Rossum3901d851996-12-19 16:35:04 +00003377}
3378
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003379PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003380"getprotobyname(name) -> integer\n\
3381\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003382Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003383
Guido van Rossum3901d851996-12-19 16:35:04 +00003384
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003385#ifndef NO_DUP
3386/* dup() function for socket fds */
3387
3388static PyObject *
3389socket_dup(PyObject *self, PyObject *fdobj)
3390{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003391 SOCKET_T fd, newfd;
3392 PyObject *newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003393
3394
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003395 fd = PyLong_AsSocket_t(fdobj);
3396 if (fd == (SOCKET_T)(-1) && PyErr_Occurred())
3397 return NULL;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003398
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003399 newfd = dup_socket(fd);
3400 if (newfd == INVALID_SOCKET)
3401 return set_error();
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003402
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003403 newfdobj = PyLong_FromSocket_t(newfd);
3404 if (newfdobj == NULL)
3405 SOCKETCLOSE(newfd);
3406 return newfdobj;
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00003407}
3408
3409PyDoc_STRVAR(dup_doc,
3410"dup(integer) -> integer\n\
3411\n\
3412Duplicate an integer socket file descriptor. This is like os.dup(), but for\n\
3413sockets; on some platforms os.dup() won't work for socket file descriptors.");
3414#endif
3415
3416
Dave Cole331708b2004-08-09 04:51:41 +00003417#ifdef HAVE_SOCKETPAIR
3418/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00003419 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00003420 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00003421
3422/*ARGSUSED*/
3423static PyObject *
3424socket_socketpair(PyObject *self, PyObject *args)
3425{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003426 PySocketSockObject *s0 = NULL, *s1 = NULL;
3427 SOCKET_T sv[2];
3428 int family, type = SOCK_STREAM, proto = 0;
3429 PyObject *res = NULL;
Dave Cole331708b2004-08-09 04:51:41 +00003430
3431#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003432 family = AF_UNIX;
Dave Cole331708b2004-08-09 04:51:41 +00003433#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003434 family = AF_INET;
Dave Cole331708b2004-08-09 04:51:41 +00003435#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003436 if (!PyArg_ParseTuple(args, "|iii:socketpair",
3437 &family, &type, &proto))
3438 return NULL;
3439 /* Create a pair of socket fds */
3440 if (socketpair(family, type, proto, sv) < 0)
3441 return set_error();
3442 s0 = new_sockobject(sv[0], family, type, proto);
3443 if (s0 == NULL)
3444 goto finally;
3445 s1 = new_sockobject(sv[1], family, type, proto);
3446 if (s1 == NULL)
3447 goto finally;
3448 res = PyTuple_Pack(2, s0, s1);
Dave Cole331708b2004-08-09 04:51:41 +00003449
3450finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003451 if (res == NULL) {
3452 if (s0 == NULL)
3453 SOCKETCLOSE(sv[0]);
3454 if (s1 == NULL)
3455 SOCKETCLOSE(sv[1]);
3456 }
3457 Py_XDECREF(s0);
3458 Py_XDECREF(s1);
3459 return res;
Dave Cole331708b2004-08-09 04:51:41 +00003460}
3461
3462PyDoc_STRVAR(socketpair_doc,
3463"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
3464\n\
3465Create a pair of socket objects from the sockets returned by the platform\n\
3466socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00003467The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00003468AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00003469
3470#endif /* HAVE_SOCKETPAIR */
3471
3472
Guido van Rossum006bf911996-06-12 04:04:55 +00003473static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003474socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003475{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003476 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00003477
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003478 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
3479 return NULL;
3480 }
3481 if (x1 < 0) {
3482 PyErr_SetString(PyExc_OverflowError,
3483 "can't convert negative number to unsigned long");
3484 return NULL;
3485 }
3486 x2 = (unsigned int)ntohs((unsigned short)x1);
3487 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00003488}
3489
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003490PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003491"ntohs(integer) -> integer\n\
3492\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003493Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003494
3495
Guido van Rossum006bf911996-06-12 04:04:55 +00003496static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003497socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003498{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003499 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003500
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003501 if (PyLong_Check(arg)) {
3502 x = PyLong_AsUnsignedLong(arg);
3503 if (x == (unsigned long) -1 && PyErr_Occurred())
3504 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003505#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003506 {
3507 unsigned long y;
3508 /* only want the trailing 32 bits */
3509 y = x & 0xFFFFFFFFUL;
3510 if (y ^ x)
3511 return PyErr_Format(PyExc_OverflowError,
3512 "long int larger than 32 bits");
3513 x = y;
3514 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003515#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003516 }
3517 else
3518 return PyErr_Format(PyExc_TypeError,
3519 "expected int/long, %s found",
3520 Py_TYPE(arg)->tp_name);
3521 if (x == (unsigned long) -1 && PyErr_Occurred())
3522 return NULL;
3523 return PyLong_FromUnsignedLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003524}
3525
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003526PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003527"ntohl(integer) -> integer\n\
3528\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003529Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003530
3531
Guido van Rossum006bf911996-06-12 04:04:55 +00003532static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003533socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003534{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003535 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00003536
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003537 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
3538 return NULL;
3539 }
3540 if (x1 < 0) {
3541 PyErr_SetString(PyExc_OverflowError,
3542 "can't convert negative number to unsigned long");
3543 return NULL;
3544 }
3545 x2 = (unsigned int)htons((unsigned short)x1);
3546 return PyLong_FromLong(x2);
Guido van Rossum006bf911996-06-12 04:04:55 +00003547}
3548
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003549PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003550"htons(integer) -> integer\n\
3551\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003552Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003553
3554
Guido van Rossum006bf911996-06-12 04:04:55 +00003555static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003556socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003557{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003558 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003559
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003560 if (PyLong_Check(arg)) {
3561 x = PyLong_AsUnsignedLong(arg);
3562 if (x == (unsigned long) -1 && PyErr_Occurred())
3563 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003564#if SIZEOF_LONG > 4
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003565 {
3566 unsigned long y;
3567 /* only want the trailing 32 bits */
3568 y = x & 0xFFFFFFFFUL;
3569 if (y ^ x)
3570 return PyErr_Format(PyExc_OverflowError,
3571 "long int larger than 32 bits");
3572 x = y;
3573 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003574#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003575 }
3576 else
3577 return PyErr_Format(PyExc_TypeError,
3578 "expected int/long, %s found",
3579 Py_TYPE(arg)->tp_name);
3580 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003581}
3582
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003583PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003584"htonl(integer) -> integer\n\
3585\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003586Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003587
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003588/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003589
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003590PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum7d0a8262007-05-21 23:13:11 +00003591"inet_aton(string) -> bytes giving packed 32-bit IP representation\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003592\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003593Convert 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 +00003594binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003595
3596static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003597socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003598{
Guido van Rossuma2e48551999-09-09 15:42:59 +00003599#ifndef INADDR_NONE
3600#define INADDR_NONE (-1)
3601#endif
Neal Norwitz88f115b2003-02-13 02:15:42 +00003602#ifdef HAVE_INET_ATON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003603 struct in_addr buf;
Thomas Wouters477c8d52006-05-27 19:21:47 +00003604#endif
3605
3606#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
Benjamin Petersonf91df042009-02-13 02:50:59 +00003607#if (SIZEOF_INT != 4)
3608#error "Not sure if in_addr_t exists and int is not 32-bits."
3609#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003610 /* Have to use inet_addr() instead */
3611 unsigned int packed_addr;
Tim Peters1df9fdd2003-02-13 03:13:40 +00003612#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003613 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003614
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003615 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
3616 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003617
Tim Peters1df9fdd2003-02-13 03:13:40 +00003618
3619#ifdef HAVE_INET_ATON
Thomas Wouters477c8d52006-05-27 19:21:47 +00003620
3621#ifdef USE_INET_ATON_WEAKLINK
3622 if (inet_aton != NULL) {
3623#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003624 if (inet_aton(ip_addr, &buf))
3625 return PyBytes_FromStringAndSize((char *)(&buf),
3626 sizeof(buf));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003627
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003628 PyErr_SetString(socket_error,
3629 "illegal IP address string passed to inet_aton");
3630 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003631
Thomas Wouters477c8d52006-05-27 19:21:47 +00003632#ifdef USE_INET_ATON_WEAKLINK
3633 } else {
3634#endif
3635
3636#endif
3637
3638#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003640 /* special-case this address as inet_addr might return INADDR_NONE
3641 * for this */
3642 if (strcmp(ip_addr, "255.255.255.255") == 0) {
3643 packed_addr = 0xFFFFFFFF;
3644 } else {
Thomas Wouters477c8d52006-05-27 19:21:47 +00003645
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003646 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003647
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003648 if (packed_addr == INADDR_NONE) { /* invalid address */
3649 PyErr_SetString(socket_error,
3650 "illegal IP address string passed to inet_aton");
3651 return NULL;
3652 }
3653 }
3654 return PyBytes_FromStringAndSize((char *) &packed_addr,
3655 sizeof(packed_addr));
Thomas Wouters477c8d52006-05-27 19:21:47 +00003656
3657#ifdef USE_INET_ATON_WEAKLINK
3658 }
3659#endif
3660
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003661#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003662}
3663
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003664PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00003665"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003666\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003667Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003668
3669static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003670socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003671{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003672 char *packed_str;
3673 int addr_len;
3674 struct in_addr packed_addr;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003675
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003676 if (!PyArg_ParseTuple(args, "y#:inet_ntoa", &packed_str, &addr_len)) {
3677 return NULL;
3678 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00003679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003680 if (addr_len != sizeof(packed_addr)) {
3681 PyErr_SetString(socket_error,
3682 "packed IP wrong length for inet_ntoa");
3683 return NULL;
3684 }
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003685
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003686 memcpy(&packed_addr, packed_str, addr_len);
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003687
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003688 return PyUnicode_FromString(inet_ntoa(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003689}
Guido van Rossum82a5c661998-07-07 20:45:43 +00003690
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003691#ifdef HAVE_INET_PTON
3692
3693PyDoc_STRVAR(inet_pton_doc,
3694"inet_pton(af, ip) -> packed IP address string\n\
3695\n\
3696Convert an IP address from string format to a packed string suitable\n\
3697for use with low-level network functions.");
3698
3699static PyObject *
3700socket_inet_pton(PyObject *self, PyObject *args)
3701{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003702 int af;
3703 char* ip;
3704 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003705#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003706 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003707#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003708 char packed[sizeof(struct in_addr)];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003709#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003710 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
3711 return NULL;
3712 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003713
Martin v. Löwis04697e82004-06-02 12:35:29 +00003714#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003715 if(af == AF_INET6) {
3716 PyErr_SetString(socket_error,
3717 "can't use AF_INET6, IPv6 is disabled");
3718 return NULL;
3719 }
Thomas Wouters477c8d52006-05-27 19:21:47 +00003720#endif
Martin v. Löwis10649092003-08-05 06:25:06 +00003721
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003722 retval = inet_pton(af, ip, packed);
3723 if (retval < 0) {
3724 PyErr_SetFromErrno(socket_error);
3725 return NULL;
3726 } else if (retval == 0) {
3727 PyErr_SetString(socket_error,
3728 "illegal IP address string passed to inet_pton");
3729 return NULL;
3730 } else if (af == AF_INET) {
3731 return PyBytes_FromStringAndSize(packed,
3732 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003733#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003734 } else if (af == AF_INET6) {
3735 return PyBytes_FromStringAndSize(packed,
3736 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003737#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003738 } else {
3739 PyErr_SetString(socket_error, "unknown address family");
3740 return NULL;
3741 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003742}
Thomas Wouters477c8d52006-05-27 19:21:47 +00003743
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003744PyDoc_STRVAR(inet_ntop_doc,
3745"inet_ntop(af, packed_ip) -> string formatted IP address\n\
3746\n\
3747Convert a packed IP address of the given family to string format.");
3748
3749static PyObject *
3750socket_inet_ntop(PyObject *self, PyObject *args)
3751{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003752 int af;
3753 char* packed;
3754 int len;
3755 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003756#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003757 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003758#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003759 char ip[INET_ADDRSTRLEN + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003760#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +00003761
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003762 /* Guarantee NUL-termination for PyUnicode_FromString() below */
3763 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003764
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003765 if (!PyArg_ParseTuple(args, "iy#:inet_ntop", &af, &packed, &len)) {
3766 return NULL;
3767 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003768
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003769 if (af == AF_INET) {
3770 if (len != sizeof(struct in_addr)) {
3771 PyErr_SetString(PyExc_ValueError,
3772 "invalid length of packed IP address string");
3773 return NULL;
3774 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003775#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003776 } else if (af == AF_INET6) {
3777 if (len != sizeof(struct in6_addr)) {
3778 PyErr_SetString(PyExc_ValueError,
3779 "invalid length of packed IP address string");
3780 return NULL;
3781 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003782#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003783 } else {
3784 PyErr_Format(PyExc_ValueError,
3785 "unknown address family %d", af);
3786 return NULL;
3787 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003788
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003789 retval = inet_ntop(af, packed, ip, sizeof(ip));
3790 if (!retval) {
3791 PyErr_SetFromErrno(socket_error);
3792 return NULL;
3793 } else {
3794 return PyUnicode_FromString(retval);
3795 }
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003796
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003797 /* NOTREACHED */
3798 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
3799 return NULL;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003800}
3801
3802#endif /* HAVE_INET_PTON */
3803
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003804/* Python interface to getaddrinfo(host, port). */
3805
3806/*ARGSUSED*/
3807static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003808socket_getaddrinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003809{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003810 struct addrinfo hints, *res;
3811 struct addrinfo *res0 = NULL;
3812 PyObject *hobj = NULL;
3813 PyObject *pobj = (PyObject *)NULL;
3814 char pbuf[30];
3815 char *hptr, *pptr;
3816 int family, socktype, protocol, flags;
3817 int error;
3818 PyObject *all = (PyObject *)NULL;
3819 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003820
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003821 family = socktype = protocol = flags = 0;
3822 family = AF_UNSPEC;
3823 if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
3824 &hobj, &pobj, &family, &socktype,
3825 &protocol, &flags)) {
3826 return NULL;
3827 }
3828 if (hobj == Py_None) {
3829 hptr = NULL;
3830 } else if (PyUnicode_Check(hobj)) {
3831 idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
3832 if (!idna)
3833 return NULL;
3834 assert(PyBytes_Check(idna));
3835 hptr = PyBytes_AS_STRING(idna);
3836 } else if (PyBytes_Check(hobj)) {
3837 hptr = PyBytes_AsString(hobj);
3838 } else {
3839 PyErr_SetString(PyExc_TypeError,
3840 "getaddrinfo() argument 1 must be string or None");
3841 return NULL;
3842 }
3843 if (PyLong_CheckExact(pobj)) {
3844 long value = PyLong_AsLong(pobj);
3845 if (value == -1 && PyErr_Occurred())
3846 goto err;
3847 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);
3848 pptr = pbuf;
3849 } else if (PyUnicode_Check(pobj)) {
3850 pptr = _PyUnicode_AsString(pobj);
3851 } else if (PyBytes_Check(pobj)) {
3852 pptr = PyBytes_AsString(pobj);
3853 } else if (pobj == Py_None) {
3854 pptr = (char *)NULL;
3855 } else {
3856 PyErr_SetString(socket_error, "Int or String expected");
3857 goto err;
3858 }
3859 memset(&hints, 0, sizeof(hints));
3860 hints.ai_family = family;
3861 hints.ai_socktype = socktype;
3862 hints.ai_protocol = protocol;
3863 hints.ai_flags = flags;
3864 Py_BEGIN_ALLOW_THREADS
3865 ACQUIRE_GETADDRINFO_LOCK
3866 error = getaddrinfo(hptr, pptr, &hints, &res0);
3867 Py_END_ALLOW_THREADS
3868 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
3869 if (error) {
3870 set_gaierror(error);
3871 goto err;
3872 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003873
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003874 if ((all = PyList_New(0)) == NULL)
3875 goto err;
3876 for (res = res0; res; res = res->ai_next) {
3877 PyObject *single;
3878 PyObject *addr =
3879 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
3880 if (addr == NULL)
3881 goto err;
3882 single = Py_BuildValue("iiisO", res->ai_family,
3883 res->ai_socktype, res->ai_protocol,
3884 res->ai_canonname ? res->ai_canonname : "",
3885 addr);
3886 Py_DECREF(addr);
3887 if (single == NULL)
3888 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003889
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003890 if (PyList_Append(all, single))
3891 goto err;
3892 Py_XDECREF(single);
3893 }
3894 Py_XDECREF(idna);
3895 if (res0)
3896 freeaddrinfo(res0);
3897 return all;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003898 err:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003899 Py_XDECREF(all);
3900 Py_XDECREF(idna);
3901 if (res0)
3902 freeaddrinfo(res0);
3903 return (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003904}
3905
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003906PyDoc_STRVAR(getaddrinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003907"getaddrinfo(host, port [, family, socktype, proto, flags])\n\
3908 -> list of (family, socktype, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003909\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003910Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003911
3912/* Python interface to getnameinfo(sa, flags). */
3913
3914/*ARGSUSED*/
3915static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003916socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003917{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003918 PyObject *sa = (PyObject *)NULL;
3919 int flags;
3920 char *hostp;
3921 int port, flowinfo, scope_id;
3922 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
3923 struct addrinfo hints, *res = NULL;
3924 int error;
3925 PyObject *ret = (PyObject *)NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003926
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003927 flags = flowinfo = scope_id = 0;
3928 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
3929 return NULL;
3930 if (!PyTuple_Check(sa)) {
3931 PyErr_SetString(PyExc_TypeError,
3932 "getnameinfo() argument 1 must be a tuple");
3933 return NULL;
3934 }
3935 if (!PyArg_ParseTuple(sa, "si|ii",
3936 &hostp, &port, &flowinfo, &scope_id))
3937 return NULL;
3938 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
3939 memset(&hints, 0, sizeof(hints));
3940 hints.ai_family = AF_UNSPEC;
3941 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
3942 Py_BEGIN_ALLOW_THREADS
3943 ACQUIRE_GETADDRINFO_LOCK
3944 error = getaddrinfo(hostp, pbuf, &hints, &res);
3945 Py_END_ALLOW_THREADS
3946 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
3947 if (error) {
3948 set_gaierror(error);
3949 goto fail;
3950 }
3951 if (res->ai_next) {
3952 PyErr_SetString(socket_error,
3953 "sockaddr resolved to multiple addresses");
3954 goto fail;
3955 }
3956 switch (res->ai_family) {
3957 case AF_INET:
3958 {
3959 if (PyTuple_GET_SIZE(sa) != 2) {
3960 PyErr_SetString(socket_error,
3961 "IPv4 sockaddr must be 2 tuple");
3962 goto fail;
3963 }
3964 break;
3965 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003966#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003967 case AF_INET6:
3968 {
3969 struct sockaddr_in6 *sin6;
3970 sin6 = (struct sockaddr_in6 *)res->ai_addr;
3971 sin6->sin6_flowinfo = flowinfo;
3972 sin6->sin6_scope_id = scope_id;
3973 break;
3974 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003975#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003976 }
3977 error = getnameinfo(res->ai_addr, res->ai_addrlen,
3978 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
3979 if (error) {
3980 set_gaierror(error);
3981 goto fail;
3982 }
3983 ret = Py_BuildValue("ss", hbuf, pbuf);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003984
3985fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003986 if (res)
3987 freeaddrinfo(res);
3988 return ret;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003989}
3990
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003991PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003992"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003993\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003994Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003995
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00003996
3997/* Python API to getting and setting the default timeout value. */
3998
3999static PyObject *
4000socket_getdefaulttimeout(PyObject *self)
4001{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004002 if (defaulttimeout < 0.0) {
4003 Py_INCREF(Py_None);
4004 return Py_None;
4005 }
4006 else
4007 return PyFloat_FromDouble(defaulttimeout);
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004008}
4009
4010PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004011"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004012\n\
4013Returns the default timeout in floating seconds for new socket objects.\n\
4014A value of None indicates that new socket objects have no timeout.\n\
4015When the socket module is first imported, the default is None.");
4016
4017static PyObject *
4018socket_setdefaulttimeout(PyObject *self, PyObject *arg)
4019{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004020 double timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004021
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004022 if (arg == Py_None)
4023 timeout = -1.0;
4024 else {
4025 timeout = PyFloat_AsDouble(arg);
4026 if (timeout < 0.0) {
4027 if (!PyErr_Occurred())
4028 PyErr_SetString(PyExc_ValueError,
4029 "Timeout value out of range");
4030 return NULL;
4031 }
4032 }
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004033
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004034 defaulttimeout = timeout;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004035
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004036 Py_INCREF(Py_None);
4037 return Py_None;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004038}
4039
4040PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004041"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00004042\n\
4043Set the default timeout in floating seconds for new socket objects.\n\
4044A value of None indicates that new socket objects have no timeout.\n\
4045When the socket module is first imported, the default is None.");
4046
4047
Guido van Rossum30a685f1991-06-27 15:51:29 +00004048/* List of functions exported by this module. */
4049
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004050static PyMethodDef socket_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004051 {"gethostbyname", socket_gethostbyname,
4052 METH_VARARGS, gethostbyname_doc},
4053 {"gethostbyname_ex", socket_gethostbyname_ex,
4054 METH_VARARGS, ghbn_ex_doc},
4055 {"gethostbyaddr", socket_gethostbyaddr,
4056 METH_VARARGS, gethostbyaddr_doc},
4057 {"gethostname", socket_gethostname,
4058 METH_NOARGS, gethostname_doc},
4059 {"getservbyname", socket_getservbyname,
4060 METH_VARARGS, getservbyname_doc},
4061 {"getservbyport", socket_getservbyport,
4062 METH_VARARGS, getservbyport_doc},
4063 {"getprotobyname", socket_getprotobyname,
4064 METH_VARARGS, getprotobyname_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004065#ifndef NO_DUP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004066 {"dup", socket_dup,
4067 METH_O, dup_doc},
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004068#endif
Dave Cole331708b2004-08-09 04:51:41 +00004069#ifdef HAVE_SOCKETPAIR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004070 {"socketpair", socket_socketpair,
4071 METH_VARARGS, socketpair_doc},
Dave Cole331708b2004-08-09 04:51:41 +00004072#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004073 {"ntohs", socket_ntohs,
4074 METH_VARARGS, ntohs_doc},
4075 {"ntohl", socket_ntohl,
4076 METH_O, ntohl_doc},
4077 {"htons", socket_htons,
4078 METH_VARARGS, htons_doc},
4079 {"htonl", socket_htonl,
4080 METH_O, htonl_doc},
4081 {"inet_aton", socket_inet_aton,
4082 METH_VARARGS, inet_aton_doc},
4083 {"inet_ntoa", socket_inet_ntoa,
4084 METH_VARARGS, inet_ntoa_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004085#ifdef HAVE_INET_PTON
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004086 {"inet_pton", socket_inet_pton,
4087 METH_VARARGS, inet_pton_doc},
4088 {"inet_ntop", socket_inet_ntop,
4089 METH_VARARGS, inet_ntop_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004090#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004091 {"getaddrinfo", socket_getaddrinfo,
4092 METH_VARARGS, getaddrinfo_doc},
4093 {"getnameinfo", socket_getnameinfo,
4094 METH_VARARGS, getnameinfo_doc},
4095 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
4096 METH_NOARGS, getdefaulttimeout_doc},
4097 {"setdefaulttimeout", socket_setdefaulttimeout,
4098 METH_O, setdefaulttimeout_doc},
4099 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004100};
4101
Guido van Rossum30a685f1991-06-27 15:51:29 +00004102
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004103#ifdef MS_WINDOWS
4104#define OS_INIT_DEFINED
4105
4106/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004107
4108static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004109os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00004110{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004111 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00004112}
4113
4114static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004115os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00004116{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004117 WSADATA WSAData;
4118 int ret;
4119 ret = WSAStartup(0x0101, &WSAData);
4120 switch (ret) {
4121 case 0: /* No error */
4122 Py_AtExit(os_cleanup);
4123 return 1; /* Success */
4124 case WSASYSNOTREADY:
4125 PyErr_SetString(PyExc_ImportError,
4126 "WSAStartup failed: network not ready");
4127 break;
4128 case WSAVERNOTSUPPORTED:
4129 case WSAEINVAL:
4130 PyErr_SetString(
4131 PyExc_ImportError,
4132 "WSAStartup failed: requested version not supported");
4133 break;
4134 default:
4135 PyErr_Format(PyExc_ImportError, "WSAStartup failed: error code %d", ret);
4136 break;
4137 }
4138 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004139}
4140
Guido van Rossum8d665e61996-06-26 18:22:49 +00004141#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00004142
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004143
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004144#ifdef PYOS_OS2
4145#define OS_INIT_DEFINED
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004146
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004147/* Additional initialization for OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004148
4149static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004150os_init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004151{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004152#ifndef PYCC_GCC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004153 int rc = sock_init();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004154
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004155 if (rc == 0) {
4156 return 1; /* Success */
4157 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004158
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004159 PyErr_Format(PyExc_ImportError, "OS/2 TCP/IP Error# %d", sock_errno());
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004160
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004161 return 0; /* Failure */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00004162#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004163 /* No need to initialise sockets with GCC/EMX */
4164 return 1; /* Success */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00004165#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00004166}
4167
4168#endif /* PYOS_OS2 */
4169
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004170
4171#ifndef OS_INIT_DEFINED
4172static int
4173os_init(void)
4174{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004175 return 1; /* Success */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004176}
4177#endif
4178
4179
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004180/* C API table - always add new things to the end for binary
4181 compatibility. */
4182static
4183PySocketModule_APIObject PySocketModuleAPI =
4184{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004185 &sock_type,
4186 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004187};
4188
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004189
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004190/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004191
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004192 This module is actually called "_socket", and there's a wrapper
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004193 "socket.py" which implements some additional functionality.
4194 The import of "_socket" may fail with an ImportError exception if
4195 os-specific initialization fails. On Windows, this does WINSOCK
4196 initialization. When WINSOCK is initialized succesfully, a call to
4197 WSACleanup() is scheduled to be made at exit time.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004198*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004199
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00004200PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00004201"Implementation module for socket operations.\n\
4202\n\
4203See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00004204
Martin v. Löwis1a214512008-06-11 05:26:20 +00004205static struct PyModuleDef socketmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004206 PyModuleDef_HEAD_INIT,
4207 PySocket_MODULE_NAME,
4208 socket_doc,
4209 -1,
4210 socket_methods,
4211 NULL,
4212 NULL,
4213 NULL,
4214 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00004215};
4216
Mark Hammondfe51c6d2002-08-02 02:27:13 +00004217PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00004218PyInit__socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004219{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004220 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00004221
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004222 if (!os_init())
4223 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004224
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004225 Py_TYPE(&sock_type) = &PyType_Type;
4226 m = PyModule_Create(&socketmodule);
4227 if (m == NULL)
4228 return NULL;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004229
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004230 socket_error = PyErr_NewException("socket.error",
4231 PyExc_IOError, NULL);
4232 if (socket_error == NULL)
4233 return NULL;
4234 PySocketModuleAPI.error = socket_error;
4235 Py_INCREF(socket_error);
4236 PyModule_AddObject(m, "error", socket_error);
4237 socket_herror = PyErr_NewException("socket.herror",
4238 socket_error, NULL);
4239 if (socket_herror == NULL)
4240 return NULL;
4241 Py_INCREF(socket_herror);
4242 PyModule_AddObject(m, "herror", socket_herror);
4243 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
4244 NULL);
4245 if (socket_gaierror == NULL)
4246 return NULL;
4247 Py_INCREF(socket_gaierror);
4248 PyModule_AddObject(m, "gaierror", socket_gaierror);
4249 socket_timeout = PyErr_NewException("socket.timeout",
4250 socket_error, NULL);
4251 if (socket_timeout == NULL)
4252 return NULL;
4253 Py_INCREF(socket_timeout);
4254 PyModule_AddObject(m, "timeout", socket_timeout);
4255 Py_INCREF((PyObject *)&sock_type);
4256 if (PyModule_AddObject(m, "SocketType",
4257 (PyObject *)&sock_type) != 0)
4258 return NULL;
4259 Py_INCREF((PyObject *)&sock_type);
4260 if (PyModule_AddObject(m, "socket",
4261 (PyObject *)&sock_type) != 0)
4262 return NULL;
Guido van Rossum09be4091999-08-09 14:40:40 +00004263
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004264#ifdef ENABLE_IPV6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004265 has_ipv6 = Py_True;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004266#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004267 has_ipv6 = Py_False;
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004268#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004269 Py_INCREF(has_ipv6);
4270 PyModule_AddObject(m, "has_ipv6", has_ipv6);
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004271
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004272 /* Export C API */
4273 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
4274 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)
4275 ) != 0)
4276 return NULL;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00004277
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004278 /* Address families (we only support AF_INET and AF_UNIX) */
Guido van Rossum09be4091999-08-09 14:40:40 +00004279#ifdef AF_UNSPEC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004280 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00004281#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004282 PyModule_AddIntConstant(m, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004283#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004284 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004285#endif /* AF_INET6 */
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00004286#if defined(AF_UNIX)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004287 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00004288#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00004289#ifdef AF_AX25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004290 /* Amateur Radio AX.25 */
4291 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004292#endif
4293#ifdef AF_IPX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004294 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00004295#endif
4296#ifdef AF_APPLETALK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004297 /* Appletalk DDP */
4298 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00004299#endif
4300#ifdef AF_NETROM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004301 /* Amateur radio NetROM */
4302 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00004303#endif
4304#ifdef AF_BRIDGE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004305 /* Multiprotocol bridge */
4306 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004307#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004308#ifdef AF_ATMPVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004309 /* ATM PVCs */
4310 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004311#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004312#ifdef AF_AAL5
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004313 /* Reserved for Werner's ATM */
4314 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00004315#endif
4316#ifdef AF_X25
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004317 /* Reserved for X.25 project */
4318 PyModule_AddIntConstant(m, "AF_X25", AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004319#endif
4320#ifdef AF_INET6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004321 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00004322#endif
4323#ifdef AF_ROSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004324 /* Amateur Radio X.25 PLP */
4325 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004326#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004327#ifdef AF_DECnet
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004328 /* Reserved for DECnet project */
4329 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004330#endif
4331#ifdef AF_NETBEUI
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004332 /* Reserved for 802.2LLC project */
4333 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004334#endif
4335#ifdef AF_SECURITY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004336 /* Security callback pseudo AF */
4337 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004338#endif
4339#ifdef AF_KEY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004340 /* PF_KEY key management API */
4341 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004342#endif
4343#ifdef AF_NETLINK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004344 /* */
4345 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
4346 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004347#ifdef NETLINK_SKIP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004348 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004349#endif
4350#ifdef NETLINK_W1
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004351 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004352#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004353 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
4354 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004355#ifdef NETLINK_TCPDIAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004356 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004357#endif
4358#ifdef NETLINK_NFLOG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004359 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004360#endif
Neal Norwitz65851662006-01-16 04:31:40 +00004361#ifdef NETLINK_XFRM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004362 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00004363#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004364#ifdef NETLINK_ARPD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004365 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004366#endif
4367#ifdef NETLINK_ROUTE6
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004368 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004369#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004370 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
Thomas Wouterscf297e42007-02-23 15:07:44 +00004371#ifdef NETLINK_DNRTMSG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004372 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00004373#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004374#ifdef NETLINK_TAPBASE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004375 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004376#endif
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004377#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004378#ifdef AF_ROUTE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004379 /* Alias to emulate 4.4BSD */
4380 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004381#endif
4382#ifdef AF_ASH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004383 /* Ash */
4384 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004385#endif
4386#ifdef AF_ECONET
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004387 /* Acorn Econet */
4388 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004389#endif
4390#ifdef AF_ATMSVC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004391 /* ATM SVCs */
4392 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004393#endif
4394#ifdef AF_SNA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004395 /* Linux SNA Project (nutters!) */
4396 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004397#endif
4398#ifdef AF_IRDA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004399 /* IRDA sockets */
4400 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004401#endif
4402#ifdef AF_PPPOX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004403 /* PPPoX sockets */
4404 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004405#endif
4406#ifdef AF_WANPIPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004407 /* Wanpipe API Sockets */
4408 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004409#endif
4410#ifdef AF_LLC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004411 /* Linux LLC */
4412 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004413#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00004414
Hye-Shik Chang81268602004-02-02 06:05:24 +00004415#ifdef USE_BLUETOOTH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004416 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
4417 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
4418 PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
4419 PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
4420 PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
Hye-Shik Chang81268602004-02-02 06:05:24 +00004421#if !defined(__FreeBSD__)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004422 PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
4423 PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
4424 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00004425#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004426 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
4427 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
4428 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
Martin v. Löwis12af0482004-01-31 12:34:17 +00004429#endif
4430
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00004431#ifdef HAVE_NETPACKET_PACKET_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004432 PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
4433 PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
4434 PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
4435 PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
4436 PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
4437 PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
4438 PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
4439 PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
4440 PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00004441#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004442
Christian Heimes043d6f62008-01-07 17:19:16 +00004443#ifdef HAVE_LINUX_TIPC_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004444 PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
Christian Heimes043d6f62008-01-07 17:19:16 +00004445
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004446 /* for addresses */
4447 PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
4448 PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
4449 PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
Christian Heimes043d6f62008-01-07 17:19:16 +00004450
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004451 PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
4452 PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
4453 PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
Christian Heimes043d6f62008-01-07 17:19:16 +00004454
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004455 /* for setsockopt() */
4456 PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
4457 PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
4458 PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
4459 PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
4460 TIPC_DEST_DROPPABLE);
4461 PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
Christian Heimes043d6f62008-01-07 17:19:16 +00004462
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004463 PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
4464 TIPC_LOW_IMPORTANCE);
4465 PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
4466 TIPC_MEDIUM_IMPORTANCE);
4467 PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
4468 TIPC_HIGH_IMPORTANCE);
4469 PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
4470 TIPC_CRITICAL_IMPORTANCE);
Christian Heimes043d6f62008-01-07 17:19:16 +00004471
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004472 /* for subscriptions */
4473 PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
4474 PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
Christian Heimes25bb7832008-01-11 16:17:00 +00004475#ifdef TIPC_SUB_CANCEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004476 /* doesn't seem to be available everywhere */
4477 PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
Christian Heimes25bb7832008-01-11 16:17:00 +00004478#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004479 PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
4480 PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
4481 PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
4482 PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
4483 PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
4484 PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
Christian Heimes043d6f62008-01-07 17:19:16 +00004485#endif
4486
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004487 /* Socket types */
4488 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
4489 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004490/* We have incomplete socket support. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004491 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
4492 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00004493#if defined(SOCK_RDM)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004494 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004495#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004496
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004497#ifdef SO_DEBUG
4498 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004499#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004500#ifdef SO_ACCEPTCONN
4501 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004502#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004503#ifdef SO_REUSEADDR
4504 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004505#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00004506#ifdef SO_EXCLUSIVEADDRUSE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004507 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00004508#endif
4509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004510#ifdef SO_KEEPALIVE
4511 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004512#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004513#ifdef SO_DONTROUTE
4514 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004515#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004516#ifdef SO_BROADCAST
4517 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004518#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004519#ifdef SO_USELOOPBACK
4520 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004521#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004522#ifdef SO_LINGER
4523 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004524#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004525#ifdef SO_OOBINLINE
4526 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004527#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004528#ifdef SO_REUSEPORT
4529 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004530#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004531#ifdef SO_SNDBUF
4532 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004533#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004534#ifdef SO_RCVBUF
4535 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004536#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004537#ifdef SO_SNDLOWAT
4538 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004539#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004540#ifdef SO_RCVLOWAT
4541 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004542#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004543#ifdef SO_SNDTIMEO
4544 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004545#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004546#ifdef SO_RCVTIMEO
4547 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004548#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004549#ifdef SO_ERROR
4550 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004551#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004552#ifdef SO_TYPE
4553 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004554#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004555#ifdef SO_SETFIB
4556 PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);
Larry Hastingsf0f37952010-04-02 11:47:10 +00004557#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004558
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004559 /* Maximum number of connections for "listen" */
4560#ifdef SOMAXCONN
4561 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004562#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004563 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004564#endif
4565
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004566 /* Flags for send, recv */
4567#ifdef MSG_OOB
4568 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004569#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004570#ifdef MSG_PEEK
4571 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004572#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004573#ifdef MSG_DONTROUTE
4574 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004575#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004576#ifdef MSG_DONTWAIT
4577 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00004578#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004579#ifdef MSG_EOR
4580 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004581#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004582#ifdef MSG_TRUNC
4583 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004584#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004585#ifdef MSG_CTRUNC
4586 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004587#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004588#ifdef MSG_WAITALL
4589 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004590#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004591#ifdef MSG_BTAG
4592 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004593#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004594#ifdef MSG_ETAG
4595 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004596#endif
4597
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004598 /* Protocol level and numbers, usable for [gs]etsockopt */
4599#ifdef SOL_SOCKET
4600 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004601#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004602#ifdef SOL_IP
4603 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004604#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004605 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00004606#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004607#ifdef SOL_IPX
4608 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00004609#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004610#ifdef SOL_AX25
4611 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004612#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004613#ifdef SOL_ATALK
4614 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00004615#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004616#ifdef SOL_NETROM
4617 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00004618#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004619#ifdef SOL_ROSE
4620 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004621#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004622#ifdef SOL_TCP
4623 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004624#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004625 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00004626#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004627#ifdef SOL_UDP
4628 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004629#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004630 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00004631#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004632#ifdef IPPROTO_IP
4633 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00004634#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004635 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004636#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004637#ifdef IPPROTO_HOPOPTS
4638 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004639#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004640#ifdef IPPROTO_ICMP
4641 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00004642#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004643 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004644#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004645#ifdef IPPROTO_IGMP
4646 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004647#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004648#ifdef IPPROTO_GGP
4649 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004650#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004651#ifdef IPPROTO_IPV4
4652 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004653#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004654#ifdef IPPROTO_IPV6
4655 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisa0f17342003-10-03 13:56:20 +00004656#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004657#ifdef IPPROTO_IPIP
4658 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004659#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004660#ifdef IPPROTO_TCP
4661 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00004662#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004663 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004664#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004665#ifdef IPPROTO_EGP
4666 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004667#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004668#ifdef IPPROTO_PUP
4669 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004670#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004671#ifdef IPPROTO_UDP
4672 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00004673#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004674 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004675#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004676#ifdef IPPROTO_IDP
4677 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004678#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004679#ifdef IPPROTO_HELLO
4680 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004681#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004682#ifdef IPPROTO_ND
4683 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004684#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004685#ifdef IPPROTO_TP
4686 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004687#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004688#ifdef IPPROTO_IPV6
4689 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004690#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004691#ifdef IPPROTO_ROUTING
4692 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004693#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004694#ifdef IPPROTO_FRAGMENT
4695 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004696#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004697#ifdef IPPROTO_RSVP
4698 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004699#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004700#ifdef IPPROTO_GRE
4701 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004702#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004703#ifdef IPPROTO_ESP
4704 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004705#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004706#ifdef IPPROTO_AH
4707 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004708#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004709#ifdef IPPROTO_MOBILE
4710 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004711#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004712#ifdef IPPROTO_ICMPV6
4713 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004714#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004715#ifdef IPPROTO_NONE
4716 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004717#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004718#ifdef IPPROTO_DSTOPTS
4719 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004720#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004721#ifdef IPPROTO_XTP
4722 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004723#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004724#ifdef IPPROTO_EON
4725 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004726#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004727#ifdef IPPROTO_PIM
4728 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004729#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004730#ifdef IPPROTO_IPCOMP
4731 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004732#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004733#ifdef IPPROTO_VRRP
4734 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004735#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004736#ifdef IPPROTO_BIP
4737 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004738#endif
4739/**/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004740#ifdef IPPROTO_RAW
4741 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00004742#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004743 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004744#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004745#ifdef IPPROTO_MAX
4746 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004747#endif
4748
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004749 /* Some port configuration */
4750#ifdef IPPORT_RESERVED
4751 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004752#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004753 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004754#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004755#ifdef IPPORT_USERRESERVED
4756 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004757#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004758 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004759#endif
4760
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004761 /* Some reserved IP v.4 addresses */
4762#ifdef INADDR_ANY
4763 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004764#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004765 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004766#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004767#ifdef INADDR_BROADCAST
4768 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004769#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004770 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004771#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004772#ifdef INADDR_LOOPBACK
4773 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004774#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004775 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004776#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004777#ifdef INADDR_UNSPEC_GROUP
4778 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004779#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004780 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004781#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004782#ifdef INADDR_ALLHOSTS_GROUP
4783 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
4784 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004785#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004786 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004787#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004788#ifdef INADDR_MAX_LOCAL_GROUP
4789 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
4790 INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004791#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004792 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004793#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004794#ifdef INADDR_NONE
4795 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004796#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004797 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004798#endif
4799
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004800 /* IPv4 [gs]etsockopt options */
4801#ifdef IP_OPTIONS
4802 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004803#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004804#ifdef IP_HDRINCL
4805 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004806#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004807#ifdef IP_TOS
4808 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004809#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004810#ifdef IP_TTL
4811 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004812#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004813#ifdef IP_RECVOPTS
4814 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004815#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004816#ifdef IP_RECVRETOPTS
4817 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004818#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004819#ifdef IP_RECVDSTADDR
4820 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004821#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004822#ifdef IP_RETOPTS
4823 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004824#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004825#ifdef IP_MULTICAST_IF
4826 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004827#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004828#ifdef IP_MULTICAST_TTL
4829 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004830#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004831#ifdef IP_MULTICAST_LOOP
4832 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004833#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004834#ifdef IP_ADD_MEMBERSHIP
4835 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004836#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004837#ifdef IP_DROP_MEMBERSHIP
4838 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004839#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004840#ifdef IP_DEFAULT_MULTICAST_TTL
4841 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
4842 IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00004843#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004844#ifdef IP_DEFAULT_MULTICAST_LOOP
4845 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
4846 IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004847#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004848#ifdef IP_MAX_MEMBERSHIPS
4849 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00004850#endif
4851
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004852 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
4853#ifdef IPV6_JOIN_GROUP
4854 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004855#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004856#ifdef IPV6_LEAVE_GROUP
4857 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004858#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004859#ifdef IPV6_MULTICAST_HOPS
4860 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004861#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004862#ifdef IPV6_MULTICAST_IF
4863 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004864#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004865#ifdef IPV6_MULTICAST_LOOP
4866 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004867#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004868#ifdef IPV6_UNICAST_HOPS
4869 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004870#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004871 /* Additional IPV6 socket options, defined in RFC 3493 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00004872#ifdef IPV6_V6ONLY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004873 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004874#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004875 /* Advanced IPV6 socket options, from RFC 3542 */
Martin v. Löwisda91d022003-12-30 11:14:01 +00004876#ifdef IPV6_CHECKSUM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004877 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004878#endif
4879#ifdef IPV6_DONTFRAG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004880 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004881#endif
4882#ifdef IPV6_DSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004883 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004884#endif
4885#ifdef IPV6_HOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004886 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004887#endif
4888#ifdef IPV6_HOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004889 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004890#endif
4891#ifdef IPV6_NEXTHOP
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004892 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004893#endif
4894#ifdef IPV6_PATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004895 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004896#endif
4897#ifdef IPV6_PKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004898 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004899#endif
4900#ifdef IPV6_RECVDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004901 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004902#endif
4903#ifdef IPV6_RECVHOPLIMIT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004904 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004905#endif
4906#ifdef IPV6_RECVHOPOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004907 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004908#endif
4909#ifdef IPV6_RECVPKTINFO
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004910 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004911#endif
4912#ifdef IPV6_RECVRTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004913 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004914#endif
4915#ifdef IPV6_RECVTCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004916 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004917#endif
4918#ifdef IPV6_RTHDR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004919 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004920#endif
4921#ifdef IPV6_RTHDRDSTOPTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004922 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004923#endif
4924#ifdef IPV6_RTHDR_TYPE_0
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004925 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004926#endif
4927#ifdef IPV6_RECVPATHMTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004928 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004929#endif
4930#ifdef IPV6_TCLASS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004931 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004932#endif
4933#ifdef IPV6_USE_MIN_MTU
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004934 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
Martin v. Löwisda91d022003-12-30 11:14:01 +00004935#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004936
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004937 /* TCP options */
4938#ifdef TCP_NODELAY
4939 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00004940#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004941#ifdef TCP_MAXSEG
4942 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00004943#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004944#ifdef TCP_CORK
4945 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004946#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004947#ifdef TCP_KEEPIDLE
4948 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004949#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004950#ifdef TCP_KEEPINTVL
4951 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004952#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004953#ifdef TCP_KEEPCNT
4954 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004955#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004956#ifdef TCP_SYNCNT
4957 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004958#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004959#ifdef TCP_LINGER2
4960 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004961#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004962#ifdef TCP_DEFER_ACCEPT
4963 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004964#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004965#ifdef TCP_WINDOW_CLAMP
4966 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004967#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004968#ifdef TCP_INFO
4969 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004970#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004971#ifdef TCP_QUICKACK
4972 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004973#endif
4974
Guido van Rossum09be4091999-08-09 14:40:40 +00004975
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004976 /* IPX options */
4977#ifdef IPX_TYPE
4978 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004979#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004980
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004981 /* get{addr,name}info parameters */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004982#ifdef EAI_ADDRFAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004983 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004984#endif
4985#ifdef EAI_AGAIN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004986 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004987#endif
4988#ifdef EAI_BADFLAGS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004989 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004990#endif
4991#ifdef EAI_FAIL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004992 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004993#endif
4994#ifdef EAI_FAMILY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004995 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004996#endif
4997#ifdef EAI_MEMORY
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004998 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004999#endif
5000#ifdef EAI_NODATA
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005001 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005002#endif
5003#ifdef EAI_NONAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005004 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005005#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00005006#ifdef EAI_OVERFLOW
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005007 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005008#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005009#ifdef EAI_SERVICE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005010 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005011#endif
5012#ifdef EAI_SOCKTYPE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005013 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005014#endif
5015#ifdef EAI_SYSTEM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005016 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005017#endif
5018#ifdef EAI_BADHINTS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005019 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005020#endif
5021#ifdef EAI_PROTOCOL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005022 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005023#endif
5024#ifdef EAI_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005025 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005026#endif
5027#ifdef AI_PASSIVE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005028 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005029#endif
5030#ifdef AI_CANONNAME
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005031 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005032#endif
5033#ifdef AI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005034 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005035#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00005036#ifdef AI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005037 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
Martin v. Löwisda91d022003-12-30 11:14:01 +00005038#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005039#ifdef AI_MASK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005040 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005041#endif
5042#ifdef AI_ALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005043 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005044#endif
5045#ifdef AI_V4MAPPED_CFG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005046 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005047#endif
5048#ifdef AI_ADDRCONFIG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005049 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005050#endif
5051#ifdef AI_V4MAPPED
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005052 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005053#endif
5054#ifdef AI_DEFAULT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005055 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005056#endif
5057#ifdef NI_MAXHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005058 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005059#endif
5060#ifdef NI_MAXSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005061 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005062#endif
5063#ifdef NI_NOFQDN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005064 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005065#endif
5066#ifdef NI_NUMERICHOST
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005067 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005068#endif
5069#ifdef NI_NAMEREQD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005070 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005071#endif
5072#ifdef NI_NUMERICSERV
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005073 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005074#endif
5075#ifdef NI_DGRAM
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005076 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00005077#endif
5078
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005079 /* shutdown() parameters */
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005080#ifdef SHUT_RD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005081 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005082#elif defined(SD_RECEIVE)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005083 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005084#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005085 PyModule_AddIntConstant(m, "SHUT_RD", 0);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005086#endif
5087#ifdef SHUT_WR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005088 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005089#elif defined(SD_SEND)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005090 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005091#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005092 PyModule_AddIntConstant(m, "SHUT_WR", 1);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005093#endif
5094#ifdef SHUT_RDWR
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005095 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005096#elif defined(SD_BOTH)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005097 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005098#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005099 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
Martin v. Löwis94681fc2003-11-27 19:40:22 +00005100#endif
5101
Christian Heimesfaf2f632008-01-06 16:59:19 +00005102#ifdef SIO_RCVALL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005103 {
5104 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};
5105 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};
5106 int i;
5107 for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {
5108 PyObject *tmp;
5109 tmp = PyLong_FromUnsignedLong(codes[i]);
5110 if (tmp == NULL)
5111 return NULL;
5112 PyModule_AddObject(m, names[i], tmp);
5113 }
5114 }
5115 PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
5116 PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
5117 PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005118#ifdef RCVALL_IPLEVEL
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005119 PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005120#endif
5121#ifdef RCVALL_MAX
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005122 PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
Amaury Forgeot d'Arc762681b2008-06-12 23:03:41 +00005123#endif
Christian Heimesfaf2f632008-01-06 16:59:19 +00005124#endif /* _MSTCPIP_ */
5125
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005126 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00005127#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005128 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00005129#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005130 return m;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005131}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005132
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005133
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005134#ifndef HAVE_INET_PTON
Christian Heimes96e7b3d2007-11-20 06:51:17 +00005135#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005136
5137/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00005138/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005139
Guido van Rossum3eede5a2002-06-07 02:08:35 +00005140int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005141inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005142{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005143 if (af == AF_INET) {
Benjamin Petersonf91df042009-02-13 02:50:59 +00005144#if (SIZEOF_INT != 4)
5145#error "Not sure if in_addr_t exists and int is not 32-bits."
5146#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005147 unsigned int packed_addr;
5148 packed_addr = inet_addr(src);
5149 if (packed_addr == INADDR_NONE)
5150 return 0;
5151 memcpy(dst, &packed_addr, 4);
5152 return 1;
5153 }
5154 /* Should set errno to EAFNOSUPPORT */
5155 return -1;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005156}
5157
Martin v. Löwisc925b1532001-07-21 09:42:15 +00005158const char *
5159inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005160{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00005161 if (af == AF_INET) {
5162 struct in_addr packed_addr;
5163 if (size < 16)
5164 /* Should set errno to ENOSPC. */
5165 return NULL;
5166 memcpy(&packed_addr, src, sizeof(packed_addr));
5167 return strncpy(dst, inet_ntoa(packed_addr), size);
5168 }
5169 /* Should set errno to EAFNOSUPPORT */
5170 return NULL;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005171}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00005172
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00005173#endif
Christian Heimesb6150692007-11-15 23:37:07 +00005174#endif