blob: c4b67c1ac752d81a60449dd4792232814d6da93b [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
Martin v. Löwis11017b12006-01-14 18:12:57 +000010 portable manner, though AF_PACKET and AF_NETLINK are supported under Linux.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000011- No read/write operations (use sendall/recv or makefile instead).
12- Additional restrictions apply on some non-Unix platforms (compensated
13 for by socket.py).
Guido van Rossum6574b3e1991-06-25 21:36:08 +000014
Guido van Rossum27e177d1995-03-16 15:43:47 +000015Module interface:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000016
Guido van Rossum27e177d1995-03-16 15:43:47 +000017- socket.error: exception raised for socket specific errors
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000018- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
19 a subclass of socket.error
20- socket.herror: exception raised for gethostby* errors,
21 a subclass of socket.error
Guido van Rossum83a072d2002-09-03 19:10:18 +000022- socket.fromfd(fd, family, type[, proto]) --> new socket object (created
23 from an existing file descriptor)
Guido van Rossum30a685f1991-06-27 15:51:29 +000024- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
Guido van Rossum3bbc62e1995-01-02 19:30:30 +000025- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
Guido van Rossum27e177d1995-03-16 15:43:47 +000026- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
Guido van Rossum25405c71996-12-19 16:42:52 +000027- socket.getprotobyname(protocolname) --> protocol number
Barry Warsaw11b91a02004-06-28 00:50:43 +000028- socket.getservbyname(servicename[, protocolname]) --> port number
29- socket.getservbyport(portnumber[, protocolname]) --> service name
Guido van Rossum83a072d2002-09-03 19:10:18 +000030- socket.socket([family[, type [, proto]]]) --> new socket object
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])
37 --> List of (family, socktype, proto, canonname, sockaddr)
38- 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.
Guido van Rossum6574b3e1991-06-25 21:36:08 +000055
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000056Local naming conventions:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000057
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000058- names starting with sock_ are socket object methods
59- names starting with socket_ are module-level functions
60- names starting with PySocket are exported through socketmodule.h
Guido van Rossum30a685f1991-06-27 15:51:29 +000061
Guido van Rossum6574b3e1991-06-25 21:36:08 +000062*/
63
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000064#include "Python.h"
Georg Brandlbc45a3f2006-03-17 19:17:34 +000065#include "structmember.h"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000066
Guido van Rossum47dfa4a2003-04-25 05:48:32 +000067#undef MAX
68#define MAX(x, y) ((x) < (y) ? (y) : (x))
69
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000070/* Socket object documentation */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000071PyDoc_STRVAR(sock_doc,
Guido van Rossumc4fcfa32002-06-07 03:19:37 +000072"socket([family[, type[, proto]]]) -> socket object\n\
73\n\
74Open a socket of the given type. The family argument specifies the\n\
75address family; it defaults to AF_INET. The type argument specifies\n\
76whether this is a stream (SOCK_STREAM, this is the default)\n\
77or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
78specifying the default protocol. Keyword arguments are accepted.\n\
79\n\
80A socket object represents one endpoint of a network connection.\n\
81\n\
82Methods of socket objects (keyword arguments not allowed):\n\
83\n\
84accept() -- accept a connection, returning new socket and client address\n\
85bind(addr) -- bind the socket to a local address\n\
86close() -- close the socket\n\
87connect(addr) -- connect the socket to a remote address\n\
88connect_ex(addr) -- connect, return an error code instead of an exception\n\
89dup() -- return a new socket object identical to the current one [*]\n\
90fileno() -- return underlying file descriptor\n\
91getpeername() -- return remote address [*]\n\
92getsockname() -- return local address\n\
93getsockopt(level, optname[, buflen]) -- get socket options\n\
94gettimeout() -- return timeout or None\n\
95listen(n) -- start listening for incoming connections\n\
96makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\
97recv(buflen[, flags]) -- receive data\n\
98recvfrom(buflen[, flags]) -- receive data and sender's address\n\
99sendall(data[, flags]) -- send all data\n\
100send(data[, flags]) -- send data, may not send all of it\n\
101sendto(data[, flags], addr) -- send data to a given address\n\
102setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
103setsockopt(level, optname, value) -- set socket options\n\
104settimeout(None | float) -- set or clear the timeout\n\
105shutdown(how) -- shut down traffic in one or both directions\n\
106\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000107 [*] not available on all platforms!");
Guido van Rossum3baaa131999-03-22 21:44:51 +0000108
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000109/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000110 I hope some day someone can clean this up please... */
111
Guido van Rossum9376b741999-09-15 22:01:40 +0000112/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
113 script doesn't get this right, so we hardcode some platform checks below.
114 On the other hand, not all Linux versions agree, so there the settings
115 computed by the configure script are needed! */
116
117#ifndef linux
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000118# undef HAVE_GETHOSTBYNAME_R_3_ARG
119# undef HAVE_GETHOSTBYNAME_R_5_ARG
120# undef HAVE_GETHOSTBYNAME_R_6_ARG
Guido van Rossum9376b741999-09-15 22:01:40 +0000121#endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000122
Guido van Rossum7a122991999-04-13 04:07:32 +0000123#ifndef WITH_THREAD
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000124# undef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +0000125#endif
126
Guido van Rossume7de2061999-03-24 17:24:33 +0000127#ifdef HAVE_GETHOSTBYNAME_R
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000128# if defined(_AIX) || defined(__osf__)
129# define HAVE_GETHOSTBYNAME_R_3_ARG
130# elif defined(__sun) || defined(__sgi)
131# define HAVE_GETHOSTBYNAME_R_5_ARG
132# elif defined(linux)
Guido van Rossum9376b741999-09-15 22:01:40 +0000133/* Rely on the configure script */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000134# else
135# undef HAVE_GETHOSTBYNAME_R
136# endif
Guido van Rossume7de2061999-03-24 17:24:33 +0000137#endif
138
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000139#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
140 !defined(MS_WINDOWS)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000141# define USE_GETHOSTBYNAME_LOCK
Guido van Rossum3baaa131999-03-22 21:44:51 +0000142#endif
143
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000144/* To use __FreeBSD_version */
145#ifdef HAVE_SYS_PARAM_H
146#include <sys/param.h>
147#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000148/* On systems on which getaddrinfo() is believed to not be thread-safe,
Just van Rossum09aecd72003-05-09 08:03:44 +0000149 (this includes the getaddrinfo emulation) protect access with a lock. */
Hye-Shik Chang9ceebd52005-09-24 14:58:47 +0000150#if defined(WITH_THREAD) && (defined(__APPLE__) || \
151 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
Just van Rossum16e426b2003-05-09 08:12:00 +0000152 defined(__OpenBSD__) || defined(__NetBSD__) || !defined(HAVE_GETADDRINFO))
Just van Rossum1040d2c2003-05-09 07:53:18 +0000153#define USE_GETADDRINFO_LOCK
154#endif
155
156#ifdef USE_GETADDRINFO_LOCK
157#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
158#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
159#else
160#define ACQUIRE_GETADDRINFO_LOCK
161#define RELEASE_GETADDRINFO_LOCK
162#endif
163
164#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000165# include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000166#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000167
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000168#if defined(PYCC_VACPP)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000169# include <types.h>
170# include <io.h>
171# include <sys/ioctl.h>
172# include <utils.h>
173# include <ctype.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000174#endif
175
Martin v. Löwis9e437302002-12-06 12:57:26 +0000176#if defined(__VMS)
177#if ! defined(_SOCKADDR_LEN)
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000178# ifdef getaddrinfo
179# undef getaddrinfo
180# endif
181# include "TCPIP_IOCTL_ROUTINE"
182#else
183# include <ioctl.h>
184#endif
Martin v. Löwis9e437302002-12-06 12:57:26 +0000185#endif
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000186
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000187#if defined(PYOS_OS2)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000188# define INCL_DOS
189# define INCL_DOSERRORS
190# define INCL_NOPMAPI
191# include <os2.h>
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000192#endif
193
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000194#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000195/* make sure that the reentrant (gethostbyaddr_r etc)
196 functions are declared correctly if compiling with
197 MIPSPro 7.x in ANSI C mode (default) */
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000198
199/* XXX Using _SGIAPI is the wrong thing,
200 but I don't know what the right thing is. */
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000201#undef _SGIAPI /* to avoid warning */
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000202#define _SGIAPI 1
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000203
Trent Mick8ea5bdf2004-09-13 17:48:41 +0000204#undef _XOPEN_SOURCE
205#include <sys/socket.h>
206#include <sys/types.h>
207#include <netinet/in.h>
208#ifdef _SS_ALIGNSIZE
209#define HAVE_GETADDRINFO 1
210#define HAVE_GETNAMEINFO 1
211#endif
212
Jeremy Hyltonfb509a32003-07-17 16:58:48 +0000213#define HAVE_INET_PTON
214#include <netdb.h>
Martin v. Löwis8eb92a02002-09-19 08:03:21 +0000215#endif
216
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000217/* Irix 6.5 fails to define this variable at all. This is needed
218 for both GCC and SGI's compiler. I'd say that the SGI headers
Georg Brandldbd83392006-02-20 09:42:33 +0000219 are just busted. Same thing for Solaris. */
220#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
Anthony Baxterbab23cf2003-10-04 08:00:49 +0000221#define INET_ADDRSTRLEN 16
222#endif
223
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000224/* Generic includes */
Guido van Rossumb6775db1994-08-01 11:34:53 +0000225#include <sys/types.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000226
Marc-André Lemburg976ade62002-02-16 18:47:07 +0000227/* Generic socket object definitions and includes */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000228#define PySocket_BUILDING_SOCKET
Marc-André Lemburgbb8b78b2002-02-16 18:44:52 +0000229#include "socketmodule.h"
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000230
231/* Addressing includes */
232
Guido van Rossum6f489d91996-06-28 20:15:15 +0000233#ifndef MS_WINDOWS
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000234
235/* Non-MS WINDOWS includes */
236# include <netdb.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000237
Guido van Rossum9376b741999-09-15 22:01:40 +0000238/* Headers needed for inet_ntoa() and inet_addr() */
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000239# ifdef __BEOS__
240# include <net/netdb.h>
241# elif defined(PYOS_OS2) && defined(PYCC_VACPP)
242# include <netdb.h>
Tim Peters603c6832001-11-05 02:45:59 +0000243typedef size_t socklen_t;
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000244# else
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000245# include <arpa/inet.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000246# endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000247
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000248# ifndef RISCOS
249# include <fcntl.h>
250# else
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000251# include <sys/ioctl.h>
252# include <socklib.h>
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000253# define NO_DUP
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000254int h_errno; /* not used */
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000255# define INET_ADDRSTRLEN 16
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000256# endif
257
Guido van Rossume2ae77b2001-10-24 20:42:55 +0000258#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000259
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000260/* MS_WINDOWS includes */
261# include <fcntl.h>
Guido van Rossum48a680c2001-03-02 06:34:14 +0000262
Jeremy Hylton22308652001-02-02 03:23:09 +0000263#endif
264
Skip Montanaro7befb992004-02-10 16:50:21 +0000265#include <stddef.h>
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000266
267#ifndef offsetof
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +0000268# define offsetof(type, member) ((size_t)(&((type *)0)->member))
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000269#endif
270
Neal Norwitz39d22e52002-11-02 19:55:21 +0000271#ifndef O_NONBLOCK
272# define O_NONBLOCK O_NDELAY
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000273#endif
274
Trent Micka708d6e2004-09-07 17:48:26 +0000275/* include Python's addrinfo.h unless it causes trouble */
276#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
277 /* Do not include addinfo.h on some newer IRIX versions.
278 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
279 * for example, but not by 6.5.10.
280 */
281#elif defined(_MSC_VER) && _MSC_VER>1200
282 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
283 * EAI_* constants are defined in (the already included) ws2tcpip.h.
284 */
285#else
286# include "addrinfo.h"
287#endif
Jason Tishlerc246cb72004-08-09 13:25:59 +0000288
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000289#ifndef HAVE_INET_PTON
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000290int inet_pton(int af, const char *src, void *dst);
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000291const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000292#endif
293
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000294#ifdef __APPLE__
295/* On OS X, getaddrinfo returns no error indication of lookup
296 failure, so we must use the emulation instead of the libinfo
297 implementation. Unfortunately, performing an autoconf test
298 for this bug would require DNS access for the machine performing
299 the configuration, which is not acceptable. Therefore, we
300 determine the bug just by checking for __APPLE__. If this bug
301 gets ever fixed, perhaps checking for sys/version.h would be
302 appropriate, which is 10/0 on the system with the bug. */
Jack Jansen84262fb2002-07-02 14:40:42 +0000303#ifndef HAVE_GETNAMEINFO
304/* This bug seems to be fixed in Jaguar. Ths easiest way I could
305 Find to check for Jaguar is that it has getnameinfo(), which
306 older releases don't have */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000307#undef HAVE_GETADDRINFO
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000308#endif
Jack Jansen84262fb2002-07-02 14:40:42 +0000309#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000310
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000311/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000312#if !defined(HAVE_GETADDRINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000313/* avoid clashes with the C library definition of the symbol. */
314#define getaddrinfo fake_getaddrinfo
315#define gai_strerror fake_gai_strerror
316#define freeaddrinfo fake_freeaddrinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000317#include "getaddrinfo.c"
318#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000319#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwisfccac2e2003-05-01 05:20:46 +0000320#define getnameinfo fake_getnameinfo
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000321#include "getnameinfo.c"
322#endif
323
Guido van Rossumbcc20741998-08-04 22:53:56 +0000324#if defined(MS_WINDOWS) || defined(__BEOS__)
325/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000326/* seem to be a few differences in the API */
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000327#define SOCKETCLOSE closesocket
Guido van Rossumbe32c891996-06-20 16:25:29 +0000328#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000329#endif
330
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000331#ifdef MS_WIN32
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000332#define EAFNOSUPPORT WSAEAFNOSUPPORT
333#define snprintf _snprintf
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000334#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000335
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000336#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000337#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000338#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000339#endif
340
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000341#ifndef SOCKETCLOSE
342#define SOCKETCLOSE close
343#endif
344
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000345#ifdef __VMS
346/* TCP/IP Services for VMS uses a maximum send/revc buffer length of 65535 */
347#define SEGMENT_SIZE 65535
348#endif
349
Hye-Shik Chang81268602004-02-02 06:05:24 +0000350#if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)
351#define USE_BLUETOOTH 1
352#if defined(__FreeBSD__)
353#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
354#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
355#define sockaddr_l2 sockaddr_l2cap
356#define sockaddr_rc sockaddr_rfcomm
357#define _BT_SOCKADDR_MEMB(s, proto) &((s)->sock_addr)
358#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
359#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
360#else
Anthony Baxter5d7c0672004-02-16 05:35:28 +0000361#define _BT_SOCKADDR_MEMB(s, proto) (&((s)->sock_addr).bt_##proto)
Hye-Shik Chang81268602004-02-02 06:05:24 +0000362#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
363#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
364#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
365#endif
366#endif
367
Martin v. Löwise9416172003-05-03 10:12:45 +0000368/*
369 * Constants for getnameinfo()
370 */
371#if !defined(NI_MAXHOST)
372#define NI_MAXHOST 1025
373#endif
374#if !defined(NI_MAXSERV)
375#define NI_MAXSERV 32
376#endif
377
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000378/* XXX There's a problem here: *static* functions are not supposed to have
379 a Py prefix (or use CapitalizedWords). Later... */
380
Guido van Rossum30a685f1991-06-27 15:51:29 +0000381/* Global variable holding the exception type for errors detected
382 by this module (but not argument type or memory errors, etc.). */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000383static PyObject *socket_error;
384static PyObject *socket_herror;
385static PyObject *socket_gaierror;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000386static PyObject *socket_timeout;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000387
Guido van Rossum48a680c2001-03-02 06:34:14 +0000388#ifdef RISCOS
389/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
390static int taskwindow;
391#endif
392
Tim Peters643a7fc2002-02-17 04:13:21 +0000393/* A forward reference to the socket type object.
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000394 The sock_type variable contains pointers to various functions,
395 some of which call new_sockobject(), which uses sock_type, so
Tim Peters643a7fc2002-02-17 04:13:21 +0000396 there has to be a circular reference. */
Jeremy Hylton938ace62002-07-17 16:30:39 +0000397static PyTypeObject sock_type;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000398
Neal Norwitz082b2df2006-02-07 07:04:46 +0000399/* Can we call select() with this socket without a buffer overrun? */
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000400#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
401/* Platform can select file descriptors beyond FD_SETSIZE */
402#define IS_SELECTABLE(s) 1
403#else
404/* POSIX says selecting file descriptors beyond FD_SETSIZE
405 has undefined behaviour. */
Neal Norwitz082b2df2006-02-07 07:04:46 +0000406#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE)
Martin v. Löwisf84d1b92006-02-11 09:27:05 +0000407#endif
Neal Norwitz082b2df2006-02-07 07:04:46 +0000408
409static PyObject*
410select_error(void)
411{
412 PyErr_SetString(socket_error, "unable to select on socket");
413 return NULL;
414}
415
Guido van Rossum30a685f1991-06-27 15:51:29 +0000416/* Convenience function to raise an error according to errno
417 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000418
Guido van Rossum73624e91994-10-10 17:59:00 +0000419static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000420set_error(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000421{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000422#ifdef MS_WINDOWS
Mark Hammond46a733d2000-07-24 01:45:11 +0000423 int err_no = WSAGetLastError();
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000424 static struct {
425 int no;
426 const char *msg;
427 } *msgp, msgs[] = {
428 {WSAEINTR, "Interrupted system call"},
429 {WSAEBADF, "Bad file descriptor"},
430 {WSAEACCES, "Permission denied"},
431 {WSAEFAULT, "Bad address"},
432 {WSAEINVAL, "Invalid argument"},
433 {WSAEMFILE, "Too many open files"},
434 {WSAEWOULDBLOCK,
435 "The socket operation could not complete "
436 "without blocking"},
437 {WSAEINPROGRESS, "Operation now in progress"},
438 {WSAEALREADY, "Operation already in progress"},
439 {WSAENOTSOCK, "Socket operation on non-socket"},
440 {WSAEDESTADDRREQ, "Destination address required"},
441 {WSAEMSGSIZE, "Message too long"},
442 {WSAEPROTOTYPE, "Protocol wrong type for socket"},
443 {WSAENOPROTOOPT, "Protocol not available"},
444 {WSAEPROTONOSUPPORT, "Protocol not supported"},
445 {WSAESOCKTNOSUPPORT, "Socket type not supported"},
446 {WSAEOPNOTSUPP, "Operation not supported"},
447 {WSAEPFNOSUPPORT, "Protocol family not supported"},
448 {WSAEAFNOSUPPORT, "Address family not supported"},
449 {WSAEADDRINUSE, "Address already in use"},
450 {WSAEADDRNOTAVAIL, "Can't assign requested address"},
451 {WSAENETDOWN, "Network is down"},
452 {WSAENETUNREACH, "Network is unreachable"},
453 {WSAENETRESET, "Network dropped connection on reset"},
454 {WSAECONNABORTED, "Software caused connection abort"},
455 {WSAECONNRESET, "Connection reset by peer"},
456 {WSAENOBUFS, "No buffer space available"},
457 {WSAEISCONN, "Socket is already connected"},
458 {WSAENOTCONN, "Socket is not connected"},
459 {WSAESHUTDOWN, "Can't send after socket shutdown"},
460 {WSAETOOMANYREFS, "Too many references: can't splice"},
461 {WSAETIMEDOUT, "Operation timed out"},
462 {WSAECONNREFUSED, "Connection refused"},
463 {WSAELOOP, "Too many levels of symbolic links"},
464 {WSAENAMETOOLONG, "File name too long"},
465 {WSAEHOSTDOWN, "Host is down"},
466 {WSAEHOSTUNREACH, "No route to host"},
467 {WSAENOTEMPTY, "Directory not empty"},
468 {WSAEPROCLIM, "Too many processes"},
469 {WSAEUSERS, "Too many users"},
470 {WSAEDQUOT, "Disc quota exceeded"},
471 {WSAESTALE, "Stale NFS file handle"},
472 {WSAEREMOTE, "Too many levels of remote in path"},
473 {WSASYSNOTREADY, "Network subsystem is unvailable"},
474 {WSAVERNOTSUPPORTED, "WinSock version is not supported"},
475 {WSANOTINITIALISED,
476 "Successful WSAStartup() not yet performed"},
477 {WSAEDISCON, "Graceful shutdown in progress"},
478 /* Resolver errors */
479 {WSAHOST_NOT_FOUND, "No such host is known"},
480 {WSATRY_AGAIN, "Host not found, or server failed"},
481 {WSANO_RECOVERY, "Unexpected server error encountered"},
482 {WSANO_DATA, "Valid name without requested data"},
483 {WSANO_ADDRESS, "No address, look for MX record"},
484 {0, NULL}
485 };
Mark Hammond46a733d2000-07-24 01:45:11 +0000486 if (err_no) {
Guido van Rossum73624e91994-10-10 17:59:00 +0000487 PyObject *v;
Mark Hammond46a733d2000-07-24 01:45:11 +0000488 const char *msg = "winsock error";
Guido van Rossum48a680c2001-03-02 06:34:14 +0000489
Mark Hammond46a733d2000-07-24 01:45:11 +0000490 for (msgp = msgs; msgp->msg; msgp++) {
491 if (err_no == msgp->no) {
492 msg = msgp->msg;
493 break;
494 }
495 }
496
497 v = Py_BuildValue("(is)", err_no, msg);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000498 if (v != NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000499 PyErr_SetObject(socket_error, v);
Guido van Rossum73624e91994-10-10 17:59:00 +0000500 Py_DECREF(v);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000501 }
502 return NULL;
503 }
504 else
505#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000506
Andrew MacIntyreba43e872002-03-03 03:03:52 +0000507#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000508 if (sock_errno() != NO_ERROR) {
509 APIRET rc;
510 ULONG msglen;
511 char outbuf[100];
512 int myerrorcode = sock_errno();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000513
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000514 /* Retrieve socket-related error message from MPTN.MSG file */
515 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
516 myerrorcode - SOCBASEERR + 26,
517 "mptn.msg",
518 &msglen);
519 if (rc == NO_ERROR) {
520 PyObject *v;
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000521
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000522 /* OS/2 doesn't guarantee a terminator */
523 outbuf[msglen] = '\0';
524 if (strlen(outbuf) > 0) {
525 /* If non-empty msg, trim CRLF */
526 char *lastc = &outbuf[ strlen(outbuf)-1 ];
Neal Norwitz30b5c5d2005-12-19 06:05:18 +0000527 while (lastc > outbuf &&
528 isspace(Py_CHARMASK(*lastc))) {
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000529 /* Trim trailing whitespace (CRLF) */
530 *lastc-- = '\0';
531 }
532 }
533 v = Py_BuildValue("(is)", myerrorcode, outbuf);
534 if (v != NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000535 PyErr_SetObject(socket_error, v);
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000536 Py_DECREF(v);
537 }
538 return NULL;
539 }
540 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000541#endif
542
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000543#if defined(RISCOS)
544 if (_inet_error.errnum != NULL) {
545 PyObject *v;
546 v = Py_BuildValue("(is)", errno, _inet_err());
547 if (v != NULL) {
548 PyErr_SetObject(socket_error, v);
549 Py_DECREF(v);
550 }
551 return NULL;
552 }
553#endif
554
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000555 return PyErr_SetFromErrno(socket_error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000556}
557
Guido van Rossum30a685f1991-06-27 15:51:29 +0000558
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000559static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000560set_herror(int h_error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000561{
562 PyObject *v;
563
564#ifdef HAVE_HSTRERROR
565 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
566#else
567 v = Py_BuildValue("(is)", h_error, "host not found");
568#endif
569 if (v != NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000570 PyErr_SetObject(socket_herror, v);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000571 Py_DECREF(v);
572 }
573
574 return NULL;
575}
576
577
578static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000579set_gaierror(int error)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000580{
581 PyObject *v;
582
Martin v. Löwis272cb402002-03-01 08:31:07 +0000583#ifdef EAI_SYSTEM
584 /* EAI_SYSTEM is not available on Windows XP. */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000585 if (error == EAI_SYSTEM)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000586 return set_error();
Martin v. Löwis272cb402002-03-01 08:31:07 +0000587#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000588
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000589#ifdef HAVE_GAI_STRERROR
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000590 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000591#else
592 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
593#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000594 if (v != NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000595 PyErr_SetObject(socket_gaierror, v);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000596 Py_DECREF(v);
597 }
598
599 return NULL;
600}
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{
607#ifndef RISCOS
608#ifndef MS_WINDOWS
609 int delay_flag;
610#endif
611#endif
612
613 Py_BEGIN_ALLOW_THREADS
614#ifdef __BEOS__
615 block = !block;
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000616 setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
617 (void *)(&block), sizeof(int));
Guido van Rossum67f7a382002-06-06 21:08:16 +0000618#else
619#ifndef RISCOS
620#ifndef MS_WINDOWS
621#if defined(PYOS_OS2) && !defined(PYCC_GCC)
622 block = !block;
623 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000624#elif defined(__VMS)
625 block = !block;
626 ioctl(s->sock_fd, FIONBIO, (char *)&block);
627#else /* !PYOS_OS2 && !_VMS */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000628 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
629 if (block)
Neal Norwitz39d22e52002-11-02 19:55:21 +0000630 delay_flag &= (~O_NONBLOCK);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000631 else
Neal Norwitz39d22e52002-11-02 19:55:21 +0000632 delay_flag |= O_NONBLOCK;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000633 fcntl(s->sock_fd, F_SETFL, delay_flag);
634#endif /* !PYOS_OS2 */
635#else /* MS_WINDOWS */
636 block = !block;
637 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
638#endif /* MS_WINDOWS */
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000639#else /* RISCOS */
640 block = !block;
641 socketioctl(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000642#endif /* RISCOS */
Martin v. Löwisa94568a2003-05-10 07:36:56 +0000643#endif /* __BEOS__ */
Guido van Rossum67f7a382002-06-06 21:08:16 +0000644 Py_END_ALLOW_THREADS
645
646 /* Since these don't return anything */
647 return 1;
648}
649
Guido van Rossum11ba0942002-06-13 15:07:44 +0000650/* Do a select() on the socket, if necessary (sock_timeout > 0).
651 The argument writing indicates the direction.
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000652 This does not raise an exception; we'll let our caller do that
653 after they've reacquired the interpreter lock.
654 Returns 1 on timeout, 0 otherwise. */
655static int
Guido van Rossumb9e916a2002-06-07 01:42:47 +0000656internal_select(PySocketSockObject *s, int writing)
Guido van Rossum67f7a382002-06-06 21:08:16 +0000657{
658 fd_set fds;
659 struct timeval tv;
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000660 int n;
Guido van Rossum11ba0942002-06-13 15:07:44 +0000661
Guido van Rossumad654902002-07-19 12:44:59 +0000662 /* Nothing to do unless we're in timeout mode (not non-blocking) */
Guido van Rossum11ba0942002-06-13 15:07:44 +0000663 if (s->sock_timeout <= 0.0)
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000664 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000665
Guido van Rossumad654902002-07-19 12:44:59 +0000666 /* Guard against closed socket */
667 if (s->sock_fd < 0)
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000668 return 0;
Guido van Rossumad654902002-07-19 12:44:59 +0000669
Guido van Rossum67f7a382002-06-06 21:08:16 +0000670 /* Construct the arguments to select */
671 tv.tv_sec = (int)s->sock_timeout;
Guido van Rossumb9e916a2002-06-07 01:42:47 +0000672 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000673 FD_ZERO(&fds);
674 FD_SET(s->sock_fd, &fds);
675
676 /* See if the socket is ready */
Guido van Rossumb9e916a2002-06-07 01:42:47 +0000677 if (writing)
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000678 n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
Guido van Rossum67f7a382002-06-06 21:08:16 +0000679 else
Raymond Hettingeref7343c2003-06-29 03:08:05 +0000680 n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
681 if (n == 0)
682 return 1;
683 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000684}
685
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000686/* Initialize a new socket object. */
687
Tim Petersa12b4cf2002-07-18 22:38:44 +0000688static double defaulttimeout = -1.0; /* Default timeout for new sockets */
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000689
Mark Hammond62b1ab12002-07-23 06:31:15 +0000690PyMODINIT_FUNC
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000691init_sockobject(PySocketSockObject *s,
692 SOCKET_T fd, int family, int type, int proto)
693{
694#ifdef RISCOS
695 int block = 1;
696#endif
697 s->sock_fd = fd;
698 s->sock_family = family;
699 s->sock_type = type;
700 s->sock_proto = proto;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000701 s->sock_timeout = defaulttimeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +0000702
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000703 s->errorhandler = &set_error;
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000704
705 if (defaulttimeout >= 0.0)
706 internal_setblocking(s, 0);
707
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000708#ifdef RISCOS
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000709 if (taskwindow)
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000710 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000711#endif
712}
713
714
Guido van Rossum30a685f1991-06-27 15:51:29 +0000715/* Create a new socket object.
716 This just creates the object and initializes it.
717 If the creation fails, return NULL and set an exception (implicit
718 in NEWOBJ()). */
719
Guido van Rossum73624e91994-10-10 17:59:00 +0000720static PySocketSockObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000721new_sockobject(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000722{
Guido van Rossum73624e91994-10-10 17:59:00 +0000723 PySocketSockObject *s;
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000724 s = (PySocketSockObject *)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000725 PyType_GenericNew(&sock_type, NULL, NULL);
Guido van Rossum384ca9c2001-10-27 22:20:47 +0000726 if (s != NULL)
727 init_sockobject(s, fd, family, type, proto);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000728 return s;
729}
730
Guido van Rossum30a685f1991-06-27 15:51:29 +0000731
Guido van Rossum48a680c2001-03-02 06:34:14 +0000732/* Lock to allow python interpreter to continue, but only allow one
Just van Rossum1040d2c2003-05-09 07:53:18 +0000733 thread to be in gethostbyname or getaddrinfo */
734#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
735PyThread_type_lock netdb_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000736#endif
737
738
Guido van Rossum30a685f1991-06-27 15:51:29 +0000739/* Convert a string specifying a host name or one of a few symbolic
740 names to a numeric IP address. This usually calls gethostbyname()
741 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000742 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000743 an error occurred; then an exception is raised. */
744
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000745static int
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000746setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000747{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000748 struct addrinfo hints, *res;
749 int error;
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000750 int d1, d2, d3, d4;
751 char ch;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000752
Guido van Rossuma376cc51996-12-05 23:43:35 +0000753 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
Guido van Rossum30a685f1991-06-27 15:51:29 +0000754 if (name[0] == '\0') {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000755 int siz;
756 memset(&hints, 0, sizeof(hints));
757 hints.ai_family = af;
758 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
759 hints.ai_flags = AI_PASSIVE;
Just van Rossum1040d2c2003-05-09 07:53:18 +0000760 Py_BEGIN_ALLOW_THREADS
761 ACQUIRE_GETADDRINFO_LOCK
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000762 error = getaddrinfo(NULL, "0", &hints, &res);
Just van Rossum1040d2c2003-05-09 07:53:18 +0000763 Py_END_ALLOW_THREADS
764 /* We assume that those thread-unsafe getaddrinfo() versions
765 *are* safe regarding their return value, ie. that a
766 subsequent call to getaddrinfo() does not destroy the
767 outcome of the first call. */
768 RELEASE_GETADDRINFO_LOCK
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000769 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000770 set_gaierror(error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000771 return -1;
772 }
773 switch (res->ai_family) {
774 case AF_INET:
775 siz = 4;
776 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000777#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000778 case AF_INET6:
779 siz = 16;
780 break;
781#endif
782 default:
783 freeaddrinfo(res);
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000784 PyErr_SetString(socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000785 "unsupported address family");
786 return -1;
787 }
788 if (res->ai_next) {
Martin v. Löwisf0b11d22001-11-07 08:31:03 +0000789 freeaddrinfo(res);
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000790 PyErr_SetString(socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000791 "wildcard resolved to multiple address");
792 return -1;
793 }
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000794 if (res->ai_addrlen < addr_ret_size)
795 addr_ret_size = res->ai_addrlen;
796 memcpy(addr_ret, res->ai_addr, addr_ret_size);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000797 freeaddrinfo(res);
798 return siz;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000799 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000800 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000801 struct sockaddr_in *sin;
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +0000802 if (af != AF_INET && af != AF_UNSPEC) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000803 PyErr_SetString(socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000804 "address family mismatched");
805 return -1;
806 }
807 sin = (struct sockaddr_in *)addr_ret;
808 memset((void *) sin, '\0', sizeof(*sin));
809 sin->sin_family = AF_INET;
810#ifdef HAVE_SOCKADDR_SA_LEN
811 sin->sin_len = sizeof(*sin);
812#endif
813 sin->sin_addr.s_addr = INADDR_BROADCAST;
814 return sizeof(sin->sin_addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000815 }
Anthony Baxter0e85f9d2003-05-02 15:40:46 +0000816 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
817 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
818 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
819 struct sockaddr_in *sin;
820 sin = (struct sockaddr_in *)addr_ret;
821 sin->sin_addr.s_addr = htonl(
822 ((long) d1 << 24) | ((long) d2 << 16) |
823 ((long) d3 << 8) | ((long) d4 << 0));
824 sin->sin_family = AF_INET;
825#ifdef HAVE_SOCKADDR_SA_LEN
826 sin->sin_len = sizeof(*sin);
827#endif
828 return 4;
829 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000830 memset(&hints, 0, sizeof(hints));
831 hints.ai_family = af;
Just van Rossum1040d2c2003-05-09 07:53:18 +0000832 Py_BEGIN_ALLOW_THREADS
833 ACQUIRE_GETADDRINFO_LOCK
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000834 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000835#if defined(__digital__) && defined(__unix__)
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000836 if (error == EAI_NONAME && af == AF_UNSPEC) {
837 /* On Tru64 V5.1, numeric-to-addr conversion fails
838 if no address family is given. Assume IPv4 for now.*/
839 hints.ai_family = AF_INET;
840 error = getaddrinfo(name, NULL, &hints, &res);
841 }
Martin v. Löwis7c4b5fa2001-10-25 09:04:03 +0000842#endif
Just van Rossum1040d2c2003-05-09 07:53:18 +0000843 Py_END_ALLOW_THREADS
844 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000845 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000846 set_gaierror(error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000847 return -1;
848 }
Martin v. Löwisddc6f472002-07-28 16:10:31 +0000849 if (res->ai_addrlen < addr_ret_size)
850 addr_ret_size = res->ai_addrlen;
851 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000852 freeaddrinfo(res);
853 switch (addr_ret->sa_family) {
854 case AF_INET:
855 return 4;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000856#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000857 case AF_INET6:
858 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000859#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000860 default:
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000861 PyErr_SetString(socket_error, "unknown address family");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000862 return -1;
863 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000864}
865
Guido van Rossum30a685f1991-06-27 15:51:29 +0000866
Guido van Rossum30a685f1991-06-27 15:51:29 +0000867/* Create a string object representing an IP address.
868 This is always a string of the form 'dd.dd.dd.dd' (with variable
869 size numbers). */
870
Guido van Rossum73624e91994-10-10 17:59:00 +0000871static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000872makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000873{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000874 char buf[NI_MAXHOST];
875 int error;
876
877 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
878 NI_NUMERICHOST);
879 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +0000880 set_gaierror(error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000881 return NULL;
882 }
Guido van Rossum73624e91994-10-10 17:59:00 +0000883 return PyString_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000884}
885
886
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000887#ifdef USE_BLUETOOTH
888/* Convert a string representation of a Bluetooth address into a numeric
889 address. Returns the length (6), or raises an exception and returns -1 if
890 an error occurred. */
891
892static int
893setbdaddr(char *name, bdaddr_t *bdaddr)
894{
895 unsigned int b0, b1, b2, b3, b4, b5;
896 char ch;
897 int n;
898
899 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
900 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
901 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
902 bdaddr->b[0] = b0;
903 bdaddr->b[1] = b1;
904 bdaddr->b[2] = b2;
905 bdaddr->b[3] = b3;
906 bdaddr->b[4] = b4;
907 bdaddr->b[5] = b5;
908 return 6;
909 } else {
910 PyErr_SetString(socket_error, "bad bluetooth address");
911 return -1;
912 }
913}
914
915/* Create a string representation of the Bluetooth address. This is always a
916 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
917 value (zero padded if necessary). */
918
919static PyObject *
920makebdaddr(bdaddr_t *bdaddr)
921{
922 char buf[(6 * 2) + 5 + 1];
923
924 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
925 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
926 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
927 return PyString_FromString(buf);
928}
929#endif
930
931
Guido van Rossum30a685f1991-06-27 15:51:29 +0000932/* Create an object representing the given socket address,
933 suitable for passing it back to bind(), connect() etc.
934 The family field of the sockaddr structure is inspected
935 to determine what kind of address it really is. */
936
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000937/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +0000938static PyObject *
Martin v. Löwis558d9bf2004-06-03 09:24:42 +0000939makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000940{
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000941 if (addrlen == 0) {
942 /* No address -- may be recvfrom() from known socket */
Guido van Rossum73624e91994-10-10 17:59:00 +0000943 Py_INCREF(Py_None);
944 return Py_None;
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000945 }
946
Guido van Rossumbcc20741998-08-04 22:53:56 +0000947#ifdef __BEOS__
Guido van Rossum2c8bcb82000-04-25 21:34:53 +0000948 /* XXX: BeOS version of accept() doesn't set family correctly */
Guido van Rossumbcc20741998-08-04 22:53:56 +0000949 addr->sa_family = AF_INET;
950#endif
951
Guido van Rossum30a685f1991-06-27 15:51:29 +0000952 switch (addr->sa_family) {
953
954 case AF_INET:
955 {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000956 struct sockaddr_in *a;
957 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
Barry Warsaw752300b1997-01-03 17:18:10 +0000958 PyObject *ret = NULL;
959 if (addrobj) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000960 a = (struct sockaddr_in *)addr;
Barry Warsaw752300b1997-01-03 17:18:10 +0000961 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
962 Py_DECREF(addrobj);
963 }
Guido van Rossum6f5afc91993-02-05 09:46:15 +0000964 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000965 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000966
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +0000967#if defined(AF_UNIX)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000968 case AF_UNIX:
969 {
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000970 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Guido van Rossum73624e91994-10-10 17:59:00 +0000971 return PyString_FromString(a->sun_path);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000972 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000973#endif /* AF_UNIX */
974
Martin v. Löwis11017b12006-01-14 18:12:57 +0000975#if defined(AF_NETLINK)
976 case AF_NETLINK:
977 {
978 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
Martin v. Löwisd0560052006-01-15 07:49:20 +0000979 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
Martin v. Löwis11017b12006-01-14 18:12:57 +0000980 }
981#endif /* AF_NETLINK */
982
Martin v. Löwis44ddbde2001-12-02 10:15:37 +0000983#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000984 case AF_INET6:
985 {
986 struct sockaddr_in6 *a;
987 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
988 PyObject *ret = NULL;
989 if (addrobj) {
990 a = (struct sockaddr_in6 *)addr;
Guido van Rossum3eede5a2002-06-07 02:08:35 +0000991 ret = Py_BuildValue("Oiii",
992 addrobj,
993 ntohs(a->sin6_port),
994 a->sin6_flowinfo,
995 a->sin6_scope_id);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000996 Py_DECREF(addrobj);
997 }
998 return ret;
999 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001000#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001001
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001002#ifdef USE_BLUETOOTH
1003 case AF_BLUETOOTH:
1004 switch (proto) {
1005
1006 case BTPROTO_L2CAP:
1007 {
1008 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1009 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1010 PyObject *ret = NULL;
1011 if (addrobj) {
1012 ret = Py_BuildValue("Oi",
1013 addrobj,
1014 _BT_L2_MEMB(a, psm));
1015 Py_DECREF(addrobj);
1016 }
1017 return ret;
1018 }
1019
1020 case BTPROTO_RFCOMM:
1021 {
1022 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1023 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1024 PyObject *ret = NULL;
1025 if (addrobj) {
1026 ret = Py_BuildValue("Oi",
1027 addrobj,
1028 _BT_RC_MEMB(a, channel));
1029 Py_DECREF(addrobj);
1030 }
1031 return ret;
1032 }
1033
1034#if !defined(__FreeBSD__)
1035 case BTPROTO_SCO:
1036 {
1037 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1038 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1039 }
1040#endif
1041
1042 }
1043#endif
1044
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001045#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +00001046 case AF_PACKET:
1047 {
1048 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1049 char *ifname = "";
1050 struct ifreq ifr;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001051 /* need to look up interface name give index */
1052 if (a->sll_ifindex) {
Jeremy Hylton22308652001-02-02 03:23:09 +00001053 ifr.ifr_ifindex = a->sll_ifindex;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001054 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
Jeremy Hylton22308652001-02-02 03:23:09 +00001055 ifname = ifr.ifr_name;
Jeremy Hylton22308652001-02-02 03:23:09 +00001056 }
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001057 return Py_BuildValue("shbhs#",
1058 ifname,
1059 ntohs(a->sll_protocol),
1060 a->sll_pkttype,
1061 a->sll_hatype,
1062 a->sll_addr,
1063 a->sll_halen);
Jeremy Hylton22308652001-02-02 03:23:09 +00001064 }
1065#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001066
Guido van Rossum30a685f1991-06-27 15:51:29 +00001067 /* More cases here... */
1068
1069 default:
Guido van Rossumaa948df1997-05-07 17:41:48 +00001070 /* If we don't know the address family, don't raise an
1071 exception -- return it as a tuple. */
1072 return Py_BuildValue("is#",
1073 addr->sa_family,
1074 addr->sa_data,
1075 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +00001076
Guido van Rossum30a685f1991-06-27 15:51:29 +00001077 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001078}
1079
Guido van Rossum30a685f1991-06-27 15:51:29 +00001080
1081/* Parse a socket address argument according to the socket object's
1082 address family. Return 1 if the address was in the proper format,
1083 0 of not. The address is returned through addr_ret, its length
1084 through len_ret. */
1085
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001086static int
Guido van Rossum48a680c2001-03-02 06:34:14 +00001087getsockaddrarg(PySocketSockObject *s, PyObject *args,
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001088 struct sockaddr **addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001089{
Guido van Rossum30a685f1991-06-27 15:51:29 +00001090 switch (s->sock_family) {
1091
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001092#if defined(AF_UNIX)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001093 case AF_UNIX:
1094 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001095 struct sockaddr_un* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001096 char *path;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001097 int len;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001098 addr = (struct sockaddr_un*)&(s->sock_addr).un;
Guido van Rossum7e488981998-10-08 02:25:24 +00001099 if (!PyArg_Parse(args, "t#", &path, &len))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001100 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001101 if (len > sizeof addr->sun_path) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001102 PyErr_SetString(socket_error,
Barry Warsaw752300b1997-01-03 17:18:10 +00001103 "AF_UNIX path too long");
Guido van Rossum30a685f1991-06-27 15:51:29 +00001104 return 0;
1105 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001106 addr->sun_family = s->sock_family;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001107 memcpy(addr->sun_path, path, len);
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001108 addr->sun_path[len] = 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001109 *addr_ret = (struct sockaddr *) addr;
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001110#if defined(PYOS_OS2)
1111 *len_ret = sizeof(*addr);
1112#else
Guido van Rossum65af28a1996-06-11 18:36:33 +00001113 *len_ret = len + sizeof(*addr) - sizeof(addr->sun_path);
Andrew MacIntyredaedf212004-04-11 12:03:57 +00001114#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001115 return 1;
1116 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001117#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001118
Martin v. Löwis11017b12006-01-14 18:12:57 +00001119#if defined(AF_NETLINK)
1120 case AF_NETLINK:
1121 {
1122 struct sockaddr_nl* addr;
1123 int pid, groups;
1124 addr = (struct sockaddr_nl *)&(s->sock_addr).nl;
1125 if (!PyTuple_Check(args)) {
1126 PyErr_Format(
1127 PyExc_TypeError,
1128 "getsockaddrarg: "
1129 "AF_NETLINK address must be tuple, not %.500s",
1130 args->ob_type->tp_name);
1131 return 0;
1132 }
1133 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1134 return 0;
1135 addr->nl_family = AF_NETLINK;
1136 addr->nl_pid = pid;
1137 addr->nl_groups = groups;
1138 *addr_ret = (struct sockaddr *) addr;
1139 *len_ret = sizeof(*addr);
1140 return 1;
1141 }
1142#endif
1143
Guido van Rossum30a685f1991-06-27 15:51:29 +00001144 case AF_INET:
1145 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001146 struct sockaddr_in* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001147 char *host;
Martin v. Löwis5db099a2003-08-07 11:55:15 +00001148 int port, result;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001149 addr=(struct sockaddr_in*)&(s->sock_addr).in;
Guido van Rossume4dad902000-12-01 13:13:11 +00001150 if (!PyTuple_Check(args)) {
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001151 PyErr_Format(
1152 PyExc_TypeError,
1153 "getsockaddrarg: "
1154 "AF_INET address must be tuple, not %.500s",
1155 args->ob_type->tp_name);
Guido van Rossume4dad902000-12-01 13:13:11 +00001156 return 0;
1157 }
Martin v. Löwis2548c732003-04-18 10:39:54 +00001158 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1159 "idna", &host, &port))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001160 return 0;
Martin v. Löwis5db099a2003-08-07 11:55:15 +00001161 result = setipaddr(host, (struct sockaddr *)addr,
1162 sizeof(*addr), AF_INET);
1163 PyMem_Free(host);
1164 if (result < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001165 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001166 addr->sin_family = AF_INET;
Guido van Rossum644a12b1997-04-09 19:24:53 +00001167 addr->sin_port = htons((short)port);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001168 *addr_ret = (struct sockaddr *) addr;
1169 *len_ret = sizeof *addr;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001170 return 1;
1171 }
1172
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001173#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001174 case AF_INET6:
1175 {
1176 struct sockaddr_in6* addr;
1177 char *host;
Martin v. Löwis5db099a2003-08-07 11:55:15 +00001178 int port, flowinfo, scope_id, result;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001179 addr = (struct sockaddr_in6*)&(s->sock_addr).in6;
1180 flowinfo = scope_id = 0;
Martin v. Löwis2548c732003-04-18 10:39:54 +00001181 if (!PyArg_ParseTuple(args, "eti|ii",
1182 "idna", &host, &port, &flowinfo,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001183 &scope_id)) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001184 return 0;
1185 }
Martin v. Löwis5db099a2003-08-07 11:55:15 +00001186 result = setipaddr(host, (struct sockaddr *)addr,
1187 sizeof(*addr), AF_INET6);
1188 PyMem_Free(host);
1189 if (result < 0)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001190 return 0;
1191 addr->sin6_family = s->sock_family;
1192 addr->sin6_port = htons((short)port);
1193 addr->sin6_flowinfo = flowinfo;
1194 addr->sin6_scope_id = scope_id;
1195 *addr_ret = (struct sockaddr *) addr;
1196 *len_ret = sizeof *addr;
1197 return 1;
1198 }
1199#endif
1200
Hye-Shik Chang81268602004-02-02 06:05:24 +00001201#ifdef USE_BLUETOOTH
Martin v. Löwis12af0482004-01-31 12:34:17 +00001202 case AF_BLUETOOTH:
1203 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001204 switch (s->sock_proto) {
1205 case BTPROTO_L2CAP:
Martin v. Löwis12af0482004-01-31 12:34:17 +00001206 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001207 struct sockaddr_l2 *addr = (struct sockaddr_l2 *) _BT_SOCKADDR_MEMB(s, l2);
1208 char *straddr;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001209
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001210 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1211 if (!PyArg_ParseTuple(args, "si", &straddr,
1212 &_BT_L2_MEMB(addr, psm))) {
1213 PyErr_SetString(socket_error, "getsockaddrarg: "
1214 "wrong format");
Martin v. Löwis12af0482004-01-31 12:34:17 +00001215 return 0;
1216 }
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001217 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1218 return 0;
1219
1220 *addr_ret = (struct sockaddr *) addr;
1221 *len_ret = sizeof *addr;
1222 return 1;
1223 }
1224 case BTPROTO_RFCOMM:
1225 {
1226 struct sockaddr_rc *addr = (struct sockaddr_rc *) _BT_SOCKADDR_MEMB(s, rc);
1227 char *straddr;
1228
1229 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1230 if (!PyArg_ParseTuple(args, "si", &straddr,
1231 &_BT_RC_MEMB(addr, channel))) {
1232 PyErr_SetString(socket_error, "getsockaddrarg: "
1233 "wrong format");
1234 return 0;
1235 }
1236 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1237 return 0;
1238
1239 *addr_ret = (struct sockaddr *) addr;
1240 *len_ret = sizeof *addr;
1241 return 1;
1242 }
1243#if !defined(__FreeBSD__)
1244 case BTPROTO_SCO:
1245 {
1246 struct sockaddr_sco *addr = (struct sockaddr_sco *) _BT_SOCKADDR_MEMB(s, sco);
1247 char *straddr;
1248
1249 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1250 straddr = PyString_AsString(args);
1251 if (straddr == NULL) {
1252 PyErr_SetString(socket_error, "getsockaddrarg: "
1253 "wrong format");
1254 return 0;
1255 }
1256 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1257 return 0;
1258
1259 *addr_ret = (struct sockaddr *) addr;
1260 *len_ret = sizeof *addr;
1261 return 1;
1262 }
1263#endif
1264 default:
1265 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1266 return 0;
Martin v. Löwis12af0482004-01-31 12:34:17 +00001267 }
1268 }
1269#endif
1270
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001271#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +00001272 case AF_PACKET:
1273 {
1274 struct sockaddr_ll* addr;
1275 struct ifreq ifr;
1276 char *interfaceName;
1277 int protoNumber;
1278 int hatype = 0;
1279 int pkttype = 0;
Andrew M. Kuchlingb8e17172004-07-10 23:39:35 +00001280 char *haddr = NULL;
1281 unsigned int halen = 0;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001282
Andrew M. Kuchlingb8e17172004-07-10 23:39:35 +00001283 if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName,
1284 &protoNumber, &pkttype, &hatype,
1285 &haddr, &halen))
Jeremy Hylton22308652001-02-02 03:23:09 +00001286 return 0;
1287 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1288 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001289 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001290 s->errorhandler();
Jeremy Hylton22308652001-02-02 03:23:09 +00001291 return 0;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001292 }
Jeremy Hylton22308652001-02-02 03:23:09 +00001293 addr = &(s->sock_addr.ll);
1294 addr->sll_family = AF_PACKET;
1295 addr->sll_protocol = htons((short)protoNumber);
1296 addr->sll_ifindex = ifr.ifr_ifindex;
1297 addr->sll_pkttype = pkttype;
1298 addr->sll_hatype = hatype;
Andrew M. Kuchlingb8e17172004-07-10 23:39:35 +00001299 if (halen > 8) {
1300 PyErr_SetString(PyExc_ValueError,
1301 "Hardware address must be 8 bytes or less");
1302 return 0;
1303 }
1304 if (halen != 0) {
1305 memcpy(&addr->sll_addr, haddr, halen);
1306 }
1307 addr->sll_halen = halen;
Jeremy Hylton22308652001-02-02 03:23:09 +00001308 *addr_ret = (struct sockaddr *) addr;
1309 *len_ret = sizeof *addr;
1310 return 1;
1311 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001312#endif
1313
Guido van Rossum30a685f1991-06-27 15:51:29 +00001314 /* More cases here... */
1315
1316 default:
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001317 PyErr_SetString(socket_error, "getsockaddrarg: bad family");
Guido van Rossum30a685f1991-06-27 15:51:29 +00001318 return 0;
1319
1320 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001321}
1322
Guido van Rossum30a685f1991-06-27 15:51:29 +00001323
Guido van Rossum48a680c2001-03-02 06:34:14 +00001324/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +00001325 Return 1 if the family is known, 0 otherwise. The length is returned
1326 through len_ret. */
1327
1328static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +00001329getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001330{
1331 switch (s->sock_family) {
1332
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00001333#if defined(AF_UNIX)
Guido van Rossum710e1df1992-06-12 10:39:36 +00001334 case AF_UNIX:
1335 {
1336 *len_ret = sizeof (struct sockaddr_un);
1337 return 1;
1338 }
Guido van Rossumb6775db1994-08-01 11:34:53 +00001339#endif /* AF_UNIX */
Martin v. Löwis11017b12006-01-14 18:12:57 +00001340#if defined(AF_NETLINK)
1341 case AF_NETLINK:
1342 {
1343 *len_ret = sizeof (struct sockaddr_nl);
1344 return 1;
1345 }
1346#endif
Guido van Rossum710e1df1992-06-12 10:39:36 +00001347
1348 case AF_INET:
1349 {
1350 *len_ret = sizeof (struct sockaddr_in);
1351 return 1;
1352 }
1353
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00001354#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001355 case AF_INET6:
1356 {
1357 *len_ret = sizeof (struct sockaddr_in6);
1358 return 1;
1359 }
1360#endif
1361
Hye-Shik Chang81268602004-02-02 06:05:24 +00001362#ifdef USE_BLUETOOTH
Martin v. Löwis12af0482004-01-31 12:34:17 +00001363 case AF_BLUETOOTH:
1364 {
1365 switch(s->sock_proto)
1366 {
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001367
1368 case BTPROTO_L2CAP:
1369 *len_ret = sizeof (struct sockaddr_l2);
1370 return 1;
1371 case BTPROTO_RFCOMM:
1372 *len_ret = sizeof (struct sockaddr_rc);
1373 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001374#if !defined(__FreeBSD__)
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001375 case BTPROTO_SCO:
1376 *len_ret = sizeof (struct sockaddr_sco);
1377 return 1;
Hye-Shik Chang81268602004-02-02 06:05:24 +00001378#endif
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001379 default:
1380 PyErr_SetString(socket_error, "getsockaddrlen: "
1381 "unknown BT protocol");
1382 return 0;
1383
Martin v. Löwis12af0482004-01-31 12:34:17 +00001384 }
1385 }
1386#endif
1387
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00001388#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +00001389 case AF_PACKET:
1390 {
1391 *len_ret = sizeof (struct sockaddr_ll);
1392 return 1;
1393 }
1394#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001395
Guido van Rossum710e1df1992-06-12 10:39:36 +00001396 /* More cases here... */
1397
1398 default:
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001399 PyErr_SetString(socket_error, "getsockaddrlen: bad family");
Guido van Rossum710e1df1992-06-12 10:39:36 +00001400 return 0;
1401
1402 }
1403}
1404
1405
Guido van Rossum30a685f1991-06-27 15:51:29 +00001406/* s.accept() method */
1407
Guido van Rossum73624e91994-10-10 17:59:00 +00001408static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001409sock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001410{
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001411 sock_addr_t addrbuf;
Fred Drakea04eaad2000-06-30 02:46:07 +00001412 SOCKET_T newfd;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001413 socklen_t addrlen;
Barry Warsaw752300b1997-01-03 17:18:10 +00001414 PyObject *sock = NULL;
1415 PyObject *addr = NULL;
1416 PyObject *res = NULL;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001417 int timeout;
Barry Warsaw752300b1997-01-03 17:18:10 +00001418
Guido van Rossum710e1df1992-06-12 10:39:36 +00001419 if (!getsockaddrlen(s, &addrlen))
1420 return NULL;
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001421 memset(&addrbuf, 0, addrlen);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001422
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001423#ifdef MS_WINDOWS
1424 newfd = INVALID_SOCKET;
1425#else
1426 newfd = -1;
1427#endif
1428
Neal Norwitz082b2df2006-02-07 07:04:46 +00001429 if (!IS_SELECTABLE(s))
1430 return select_error();
1431
Guido van Rossum73624e91994-10-10 17:59:00 +00001432 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001433 timeout = internal_select(s, 0);
1434 if (!timeout)
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001435 newfd = accept(s->sock_fd, (struct sockaddr *) &addrbuf,
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001436 &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001437 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001438
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001439 if (timeout) {
1440 PyErr_SetString(socket_timeout, "timed out");
1441 return NULL;
1442 }
1443
Fred Drakea04eaad2000-06-30 02:46:07 +00001444#ifdef MS_WINDOWS
1445 if (newfd == INVALID_SOCKET)
1446#else
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001447 if (newfd < 0)
Fred Drakea04eaad2000-06-30 02:46:07 +00001448#endif
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001449 return s->errorhandler();
Barry Warsaw752300b1997-01-03 17:18:10 +00001450
Guido van Rossum30a685f1991-06-27 15:51:29 +00001451 /* Create the new object with unspecified family,
1452 to avoid calls to bind() etc. on it. */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001453 sock = (PyObject *) new_sockobject(newfd,
1454 s->sock_family,
1455 s->sock_type,
1456 s->sock_proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001457
Barry Warsaw752300b1997-01-03 17:18:10 +00001458 if (sock == NULL) {
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001459 SOCKETCLOSE(newfd);
Barry Warsaw752300b1997-01-03 17:18:10 +00001460 goto finally;
1461 }
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001462 addr = makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf,
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001463 addrlen, s->sock_proto);
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001464 if (addr == NULL)
Barry Warsaw752300b1997-01-03 17:18:10 +00001465 goto finally;
1466
Raymond Hettinger8ae46892003-10-12 19:09:37 +00001467 res = PyTuple_Pack(2, sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001468
Guido van Rossum67f7a382002-06-06 21:08:16 +00001469finally:
Guido van Rossum73624e91994-10-10 17:59:00 +00001470 Py_XDECREF(sock);
1471 Py_XDECREF(addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001472 return res;
1473}
1474
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001475PyDoc_STRVAR(accept_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001476"accept() -> (socket object, address info)\n\
1477\n\
1478Wait for an incoming connection. Return a new socket representing the\n\
1479connection, and the address of the client. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001480info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001481
Guido van Rossum11ba0942002-06-13 15:07:44 +00001482/* s.setblocking(flag) method. Argument:
1483 False -- non-blocking mode; same as settimeout(0)
1484 True -- blocking mode; same as settimeout(None)
1485*/
Guido van Rossume4485b01994-09-07 14:32:49 +00001486
Guido van Rossum73624e91994-10-10 17:59:00 +00001487static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001488sock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +00001489{
1490 int block;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001491
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001492 block = PyInt_AsLong(arg);
1493 if (block == -1 && PyErr_Occurred())
Guido van Rossume4485b01994-09-07 14:32:49 +00001494 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001495
Guido van Rossum11ba0942002-06-13 15:07:44 +00001496 s->sock_timeout = block ? -1.0 : 0.0;
Guido van Rossume8008f02002-06-07 03:36:20 +00001497 internal_setblocking(s, block);
Guido van Rossume4485b01994-09-07 14:32:49 +00001498
Guido van Rossum73624e91994-10-10 17:59:00 +00001499 Py_INCREF(Py_None);
1500 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001501}
Guido van Rossume4485b01994-09-07 14:32:49 +00001502
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001503PyDoc_STRVAR(setblocking_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001504"setblocking(flag)\n\
1505\n\
1506Set the socket to blocking (flag is true) or non-blocking (false).\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001507setblocking(True) is equivalent to settimeout(None);\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001508setblocking(False) is equivalent to settimeout(0.0).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001509
Guido van Rossum11ba0942002-06-13 15:07:44 +00001510/* s.settimeout(timeout) method. Argument:
1511 None -- no timeout, blocking mode; same as setblocking(True)
1512 0.0 -- non-blocking mode; same as setblocking(False)
1513 > 0 -- timeout mode; operations time out after timeout seconds
1514 < 0 -- illegal; raises an exception
1515*/
Guido van Rossum67f7a382002-06-06 21:08:16 +00001516static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001517sock_settimeout(PySocketSockObject *s, PyObject *arg)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001518{
Guido van Rossum11ba0942002-06-13 15:07:44 +00001519 double timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001520
1521 if (arg == Py_None)
Guido van Rossum11ba0942002-06-13 15:07:44 +00001522 timeout = -1.0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001523 else {
Guido van Rossum11ba0942002-06-13 15:07:44 +00001524 timeout = PyFloat_AsDouble(arg);
1525 if (timeout < 0.0) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00001526 if (!PyErr_Occurred())
1527 PyErr_SetString(PyExc_ValueError,
Guido van Rossum11ba0942002-06-13 15:07:44 +00001528 "Timeout value out of range");
Guido van Rossum67f7a382002-06-06 21:08:16 +00001529 return NULL;
1530 }
1531 }
1532
Guido van Rossum11ba0942002-06-13 15:07:44 +00001533 s->sock_timeout = timeout;
1534 internal_setblocking(s, timeout < 0.0);
Guido van Rossum67f7a382002-06-06 21:08:16 +00001535
1536 Py_INCREF(Py_None);
1537 return Py_None;
1538}
1539
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001540PyDoc_STRVAR(settimeout_doc,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001541"settimeout(timeout)\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001542\n\
Guido van Rossum11ba0942002-06-13 15:07:44 +00001543Set a timeout on socket operations. 'timeout' can be a float,\n\
1544giving in seconds, or None. Setting a timeout of None disables\n\
1545the timeout feature and is equivalent to setblocking(1).\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001546Setting a timeout of zero is the same as setblocking(0).");
Guido van Rossum67f7a382002-06-06 21:08:16 +00001547
Guido van Rossum3eede5a2002-06-07 02:08:35 +00001548/* s.gettimeout() method.
1549 Returns the timeout associated with a socket. */
Guido van Rossum67f7a382002-06-06 21:08:16 +00001550static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001551sock_gettimeout(PySocketSockObject *s)
Guido van Rossum67f7a382002-06-06 21:08:16 +00001552{
1553 if (s->sock_timeout < 0.0) {
1554 Py_INCREF(Py_None);
1555 return Py_None;
1556 }
1557 else
1558 return PyFloat_FromDouble(s->sock_timeout);
1559}
1560
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001561PyDoc_STRVAR(gettimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00001562"gettimeout() -> timeout\n\
Guido van Rossum67f7a382002-06-06 21:08:16 +00001563\n\
1564Returns the timeout in floating seconds associated with socket \n\
1565operations. A timeout of None indicates that timeouts on socket \n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001566operations are disabled.");
Guido van Rossume4485b01994-09-07 14:32:49 +00001567
Guido van Rossum48a680c2001-03-02 06:34:14 +00001568#ifdef RISCOS
1569/* s.sleeptaskw(1 | 0) method */
1570
1571static PyObject *
Martin v. Löwisa94568a2003-05-10 07:36:56 +00001572sock_sleeptaskw(PySocketSockObject *s,PyObject *arg)
Guido van Rossum48a680c2001-03-02 06:34:14 +00001573{
Guido van Rossum67f7a382002-06-06 21:08:16 +00001574 int block;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00001575 block = PyInt_AsLong(arg);
1576 if (block == -1 && PyErr_Occurred())
Guido van Rossum67f7a382002-06-06 21:08:16 +00001577 return NULL;
1578 Py_BEGIN_ALLOW_THREADS
1579 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
1580 Py_END_ALLOW_THREADS
Guido van Rossum48a680c2001-03-02 06:34:14 +00001581
Guido van Rossum67f7a382002-06-06 21:08:16 +00001582 Py_INCREF(Py_None);
1583 return Py_None;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001584}
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001585PyDoc_STRVAR(sleeptaskw_doc,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001586"sleeptaskw(flag)\n\
1587\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001588Allow sleeps in taskwindows.");
Guido van Rossum48a680c2001-03-02 06:34:14 +00001589#endif
1590
1591
Guido van Rossumaee08791992-09-08 09:05:33 +00001592/* s.setsockopt() method.
1593 With an integer third argument, sets an integer option.
1594 With a string third argument, sets an option from a buffer;
1595 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001596
Guido van Rossum73624e91994-10-10 17:59:00 +00001597static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001598sock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001599{
1600 int level;
1601 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001602 int res;
Guido van Rossumaee08791992-09-08 09:05:33 +00001603 char *buf;
1604 int buflen;
1605 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001606
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001607 if (PyArg_ParseTuple(args, "iii:setsockopt",
1608 &level, &optname, &flag)) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001609 buf = (char *) &flag;
1610 buflen = sizeof flag;
1611 }
1612 else {
Guido van Rossum73624e91994-10-10 17:59:00 +00001613 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001614 if (!PyArg_ParseTuple(args, "iis#:setsockopt",
1615 &level, &optname, &buf, &buflen))
Guido van Rossumaee08791992-09-08 09:05:33 +00001616 return NULL;
1617 }
Thomas Wouters334fb892000-07-25 12:56:38 +00001618 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001619 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001620 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00001621 Py_INCREF(Py_None);
1622 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001623}
1624
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001625PyDoc_STRVAR(setsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001626"setsockopt(level, option, value)\n\
1627\n\
1628Set a socket option. See the Unix manual for level and option.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001629The value argument can either be an integer or a string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001630
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001631
Guido van Rossumaee08791992-09-08 09:05:33 +00001632/* s.getsockopt() method.
1633 With two arguments, retrieves an integer option.
1634 With a third integer argument, retrieves a string buffer of that size;
1635 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001636
Guido van Rossum73624e91994-10-10 17:59:00 +00001637static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001638sock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001639{
1640 int level;
1641 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001642 int res;
Guido van Rossum73624e91994-10-10 17:59:00 +00001643 PyObject *buf;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001644 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001645
Guido van Rossumbcc20741998-08-04 22:53:56 +00001646#ifdef __BEOS__
Fred Drake564a6cc2001-05-11 20:12:26 +00001647 /* We have incomplete socket support. */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001648 PyErr_SetString(socket_error, "getsockopt not supported");
Guido van Rossumbcc20741998-08-04 22:53:56 +00001649 return NULL;
1650#else
1651
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001652 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1653 &level, &optname, &buflen))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001654 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001655
Guido van Rossumbe32c891996-06-20 16:25:29 +00001656 if (buflen == 0) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001657 int flag = 0;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001658 socklen_t flagsize = sizeof flag;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001659 res = getsockopt(s->sock_fd, level, optname,
Thomas Wouters334fb892000-07-25 12:56:38 +00001660 (void *)&flag, &flagsize);
Guido van Rossumaee08791992-09-08 09:05:33 +00001661 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001662 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00001663 return PyInt_FromLong(flag);
Guido van Rossumaee08791992-09-08 09:05:33 +00001664 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001665#ifdef __VMS
1666 if (buflen > 1024) {
1667#else
Guido van Rossumaee08791992-09-08 09:05:33 +00001668 if (buflen <= 0 || buflen > 1024) {
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00001669#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001670 PyErr_SetString(socket_error,
Barry Warsaw752300b1997-01-03 17:18:10 +00001671 "getsockopt buflen out of range");
Guido van Rossumaee08791992-09-08 09:05:33 +00001672 return NULL;
1673 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001674 buf = PyString_FromStringAndSize((char *)NULL, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001675 if (buf == NULL)
1676 return NULL;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001677 res = getsockopt(s->sock_fd, level, optname,
Fred Drake564a6cc2001-05-11 20:12:26 +00001678 (void *)PyString_AS_STRING(buf), &buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001679 if (res < 0) {
Guido van Rossum73624e91994-10-10 17:59:00 +00001680 Py_DECREF(buf);
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001681 return s->errorhandler();
Guido van Rossumaee08791992-09-08 09:05:33 +00001682 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001683 _PyString_Resize(&buf, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001684 return buf;
Guido van Rossumbcc20741998-08-04 22:53:56 +00001685#endif /* __BEOS__ */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001686}
1687
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001688PyDoc_STRVAR(getsockopt_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001689"getsockopt(level, option[, buffersize]) -> value\n\
1690\n\
1691Get a socket option. See the Unix manual for level and option.\n\
1692If a nonzero buffersize argument is given, the return value is a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001693string of that length; otherwise it is an integer.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001694
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001695
Fred Drake728819a2000-07-01 03:40:12 +00001696/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001697
Guido van Rossum73624e91994-10-10 17:59:00 +00001698static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001699sock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001700{
1701 struct sockaddr *addr;
1702 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001703 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001704
Fred Drake728819a2000-07-01 03:40:12 +00001705 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001706 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001707 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001708 res = bind(s->sock_fd, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001709 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001710 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001711 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00001712 Py_INCREF(Py_None);
1713 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001714}
1715
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001716PyDoc_STRVAR(bind_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001717"bind(address)\n\
1718\n\
1719Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00001720pair (host, port); the host must refer to the local host. For raw packet\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001721sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001722
Guido van Rossum30a685f1991-06-27 15:51:29 +00001723
1724/* s.close() method.
1725 Set the file descriptor to -1 so operations tried subsequently
1726 will surely fail. */
1727
Guido van Rossum73624e91994-10-10 17:59:00 +00001728static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001729sock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001730{
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001731 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001732
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001733 if ((fd = s->sock_fd) != -1) {
1734 s->sock_fd = -1;
Guido van Rossum08481461996-10-12 14:07:22 +00001735 Py_BEGIN_ALLOW_THREADS
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001736 (void) SOCKETCLOSE(fd);
Guido van Rossum08481461996-10-12 14:07:22 +00001737 Py_END_ALLOW_THREADS
1738 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001739 Py_INCREF(Py_None);
1740 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001741}
1742
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001743PyDoc_STRVAR(close_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001744"close()\n\
1745\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001746Close the socket. It cannot be used after this call.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001747
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001748static int
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001749internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
1750 int *timeoutp)
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001751{
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001752 int res, timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001753
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001754 timeout = 0;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001755 res = connect(s->sock_fd, addr, addrlen);
1756
1757#ifdef MS_WINDOWS
1758
1759 if (s->sock_timeout > 0.0) {
Neal Norwitz082b2df2006-02-07 07:04:46 +00001760 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
1761 IS_SELECTABLE(s)) {
Guido van Rossumb76bdf82003-02-19 17:50:16 +00001762 /* This is a mess. Best solution: trust select */
1763 fd_set fds;
Mark Hammonda57ec932004-08-03 05:06:26 +00001764 fd_set fds_exc;
Guido van Rossumb76bdf82003-02-19 17:50:16 +00001765 struct timeval tv;
1766 tv.tv_sec = (int)s->sock_timeout;
1767 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
1768 FD_ZERO(&fds);
1769 FD_SET(s->sock_fd, &fds);
Mark Hammonda57ec932004-08-03 05:06:26 +00001770 FD_ZERO(&fds_exc);
1771 FD_SET(s->sock_fd, &fds_exc);
1772 res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001773 if (res == 0) {
Guido van Rossumb76bdf82003-02-19 17:50:16 +00001774 res = WSAEWOULDBLOCK;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001775 timeout = 1;
Mark Hammonda57ec932004-08-03 05:06:26 +00001776 } else if (res > 0) {
1777 if (FD_ISSET(s->sock_fd, &fds))
1778 /* The socket is in the writeable set - this
1779 means connected */
1780 res = 0;
1781 else {
1782 /* As per MS docs, we need to call getsockopt()
1783 to get the underlying error */
1784 int res_size = sizeof res;
1785 /* It must be in the exception set */
1786 assert(FD_ISSET(s->sock_fd, &fds_exc));
1787 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
1788 (char *)&res, &res_size))
1789 /* getsockopt also clears WSAGetLastError,
1790 so reset it back. */
1791 WSASetLastError(res);
1792 else
1793 res = WSAGetLastError();
1794 }
1795 }
Guido van Rossumb76bdf82003-02-19 17:50:16 +00001796 /* else if (res < 0) an error occurred */
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001797 }
1798 }
1799
1800 if (res < 0)
1801 res = WSAGetLastError();
1802
1803#else
1804
1805 if (s->sock_timeout > 0.0) {
Neal Norwitz082b2df2006-02-07 07:04:46 +00001806 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001807 timeout = internal_select(s, 1);
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001808 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum12e3c712002-08-08 20:39:30 +00001809 if (res < 0 && errno == EISCONN)
1810 res = 0;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001811 }
1812 }
1813
1814 if (res < 0)
1815 res = errno;
1816
1817#endif
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001818 *timeoutp = timeout;
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001819
1820 return res;
1821}
Guido van Rossum30a685f1991-06-27 15:51:29 +00001822
Fred Drake728819a2000-07-01 03:40:12 +00001823/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001824
Guido van Rossum73624e91994-10-10 17:59:00 +00001825static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001826sock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001827{
1828 struct sockaddr *addr;
1829 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001830 int res;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001831 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001832
Fred Drake728819a2000-07-01 03:40:12 +00001833 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001834 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001835
Guido van Rossum73624e91994-10-10 17:59:00 +00001836 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001837 res = internal_connect(s, addr, addrlen, &timeout);
Guido van Rossum11ba0942002-06-13 15:07:44 +00001838 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001839
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001840 if (timeout) {
1841 PyErr_SetString(socket_timeout, "timed out");
1842 return NULL;
1843 }
Guido van Rossum7b8bac12002-06-13 16:07:04 +00001844 if (res != 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001845 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00001846 Py_INCREF(Py_None);
1847 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001848}
1849
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001850PyDoc_STRVAR(connect_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001851"connect(address)\n\
1852\n\
1853Connect the socket to a remote address. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001854is a pair (host, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001855
Guido van Rossum30a685f1991-06-27 15:51:29 +00001856
Fred Drake728819a2000-07-01 03:40:12 +00001857/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001858
1859static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001860sock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001861{
1862 struct sockaddr *addr;
1863 int addrlen;
1864 int res;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001865 int timeout;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001866
Fred Drake728819a2000-07-01 03:40:12 +00001867 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001868 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00001869
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001870 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00001871 res = internal_connect(s, addr, addrlen, &timeout);
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001872 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00001873
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001874 return PyInt_FromLong((long) res);
1875}
1876
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001877PyDoc_STRVAR(connect_ex_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00001878"connect_ex(address) -> errno\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00001879\n\
1880This is like connect(address), but returns an error code (the errno value)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001881instead of raising an exception when an error occurs.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001882
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001883
Guido van Rossumed233a51992-06-23 09:07:03 +00001884/* s.fileno() method */
1885
Guido van Rossum73624e91994-10-10 17:59:00 +00001886static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001887sock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00001888{
Fred Drakea04eaad2000-06-30 02:46:07 +00001889#if SIZEOF_SOCKET_T <= SIZEOF_LONG
Guido van Rossum73624e91994-10-10 17:59:00 +00001890 return PyInt_FromLong((long) s->sock_fd);
Fred Drakea04eaad2000-06-30 02:46:07 +00001891#else
Martin v. Löwisb9a0f912003-03-29 10:06:18 +00001892 return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd);
Fred Drakea04eaad2000-06-30 02:46:07 +00001893#endif
Guido van Rossumed233a51992-06-23 09:07:03 +00001894}
1895
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001896PyDoc_STRVAR(fileno_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001897"fileno() -> integer\n\
1898\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001899Return the integer file descriptor of the socket.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001900
Guido van Rossumed233a51992-06-23 09:07:03 +00001901
Guido van Rossumbe32c891996-06-20 16:25:29 +00001902#ifndef NO_DUP
1903/* s.dup() method */
1904
1905static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001906sock_dup(PySocketSockObject *s)
Guido van Rossumbe32c891996-06-20 16:25:29 +00001907{
Fred Drakea04eaad2000-06-30 02:46:07 +00001908 SOCKET_T newfd;
Guido van Rossumbe32c891996-06-20 16:25:29 +00001909 PyObject *sock;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001910
Guido van Rossumbe32c891996-06-20 16:25:29 +00001911 newfd = dup(s->sock_fd);
1912 if (newfd < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001913 return s->errorhandler();
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001914 sock = (PyObject *) new_sockobject(newfd,
1915 s->sock_family,
1916 s->sock_type,
1917 s->sock_proto);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001918 if (sock == NULL)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001919 SOCKETCLOSE(newfd);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001920 return sock;
1921}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001922
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001923PyDoc_STRVAR(dup_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001924"dup() -> socket object\n\
1925\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001926Return a new socket object connected to the same system resource.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001927
Guido van Rossumbe32c891996-06-20 16:25:29 +00001928#endif
1929
1930
Guido van Rossumc89705d1992-11-26 08:54:07 +00001931/* s.getsockname() method */
1932
Guido van Rossum73624e91994-10-10 17:59:00 +00001933static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001934sock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001935{
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001936 sock_addr_t addrbuf;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001937 int res;
1938 socklen_t addrlen;
1939
Guido van Rossumc89705d1992-11-26 08:54:07 +00001940 if (!getsockaddrlen(s, &addrlen))
1941 return NULL;
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001942 memset(&addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001943 Py_BEGIN_ALLOW_THREADS
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001944 res = getsockname(s->sock_fd, (struct sockaddr *) &addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001945 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001946 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001947 return s->errorhandler();
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001948 return makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, addrlen,
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001949 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001950}
1951
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001952PyDoc_STRVAR(getsockname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001953"getsockname() -> address info\n\
1954\n\
1955Return the address of the local endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001956info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001957
Guido van Rossumc89705d1992-11-26 08:54:07 +00001958
Guido van Rossumb6775db1994-08-01 11:34:53 +00001959#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001960/* s.getpeername() method */
1961
Guido van Rossum73624e91994-10-10 17:59:00 +00001962static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001963sock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001964{
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001965 sock_addr_t addrbuf;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001966 int res;
1967 socklen_t addrlen;
1968
Guido van Rossumc89705d1992-11-26 08:54:07 +00001969 if (!getsockaddrlen(s, &addrlen))
1970 return NULL;
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001971 memset(&addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001972 Py_BEGIN_ALLOW_THREADS
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001973 res = getpeername(s->sock_fd, (struct sockaddr *) &addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001974 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001975 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00001976 return s->errorhandler();
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00001977 return makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf, addrlen,
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00001978 s->sock_proto);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001979}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001980
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001981PyDoc_STRVAR(getpeername_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00001982"getpeername() -> address info\n\
1983\n\
1984Return the address of the remote endpoint. For IP sockets, the address\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001985info is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00001986
Guido van Rossumb6775db1994-08-01 11:34:53 +00001987#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001988
1989
Guido van Rossum30a685f1991-06-27 15:51:29 +00001990/* s.listen(n) method */
1991
Guido van Rossum73624e91994-10-10 17:59:00 +00001992static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00001993sock_listen(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001994{
1995 int backlog;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001996 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001997
1998 backlog = PyInt_AsLong(arg);
1999 if (backlog == -1 && PyErr_Occurred())
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002000 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002001 Py_BEGIN_ALLOW_THREADS
Guido van Rossumb6775db1994-08-01 11:34:53 +00002002 if (backlog < 1)
2003 backlog = 1;
Guido van Rossumff4949e1992-08-05 19:58:53 +00002004 res = listen(s->sock_fd, backlog);
Guido van Rossum73624e91994-10-10 17:59:00 +00002005 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002006 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002007 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00002008 Py_INCREF(Py_None);
2009 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002010}
2011
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002012PyDoc_STRVAR(listen_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002013"listen(backlog)\n\
2014\n\
2015Enable a server to accept connections. The backlog argument must be at\n\
2016least 1; it specifies the number of unaccepted connection that the system\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002017will allow before refusing new connections.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002018
2019
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002020#ifndef NO_DUP
Guido van Rossum30a685f1991-06-27 15:51:29 +00002021/* s.makefile(mode) method.
2022 Create a new open file object referring to a dupped version of
2023 the socket's file descriptor. (The dup() call is necessary so
2024 that the open file and socket objects may be closed independent
2025 of each other.)
2026 The mode argument specifies 'r' or 'w' passed to fdopen(). */
2027
Guido van Rossum73624e91994-10-10 17:59:00 +00002028static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002029sock_makefile(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002030{
Tim Petersdbd9ba62000-07-09 03:09:57 +00002031 extern int fclose(FILE *);
Guido van Rossum6b144911995-03-14 15:05:13 +00002032 char *mode = "r";
2033 int bufsize = -1;
Fred Drakea04eaad2000-06-30 02:46:07 +00002034#ifdef MS_WIN32
Tim Peters79248aa2001-08-29 21:37:10 +00002035 Py_intptr_t fd;
Fred Drakea04eaad2000-06-30 02:46:07 +00002036#else
Guido van Rossum30a685f1991-06-27 15:51:29 +00002037 int fd;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002038#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00002039 FILE *fp;
Guido van Rossum6b144911995-03-14 15:05:13 +00002040 PyObject *f;
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002041#ifdef __VMS
2042 char *mode_r = "r";
2043 char *mode_w = "w";
2044#endif
Guido van Rossum6b144911995-03-14 15:05:13 +00002045
Guido van Rossum43713e52000-02-29 13:59:29 +00002046 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002047 return NULL;
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002048#ifdef __VMS
2049 if (strcmp(mode,"rb") == 0) {
2050 mode = mode_r;
2051 }
2052 else {
2053 if (strcmp(mode,"wb") == 0) {
2054 mode = mode_w;
2055 }
2056 }
2057#endif
Guido van Rossum8d665e61996-06-26 18:22:49 +00002058#ifdef MS_WIN32
Guido van Rossum82a5c661998-07-07 20:45:43 +00002059 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) ||
2060 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL))
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00002061#else
Guido van Rossum82a5c661998-07-07 20:45:43 +00002062 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL)
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00002063#endif
Guido van Rossum82a5c661998-07-07 20:45:43 +00002064 {
Guido van Rossum6b144911995-03-14 15:05:13 +00002065 if (fd >= 0)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00002066 SOCKETCLOSE(fd);
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002067 return s->errorhandler();
Guido van Rossum6b144911995-03-14 15:05:13 +00002068 }
2069 f = PyFile_FromFile(fp, "<socket>", mode, fclose);
2070 if (f != NULL)
2071 PyFile_SetBufSize(f, bufsize);
2072 return f;
Guido van Rossum30a685f1991-06-27 15:51:29 +00002073}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002074
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002075PyDoc_STRVAR(makefile_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002076"makefile([mode[, buffersize]]) -> file object\n\
2077\n\
2078Return a regular file object corresponding to the socket.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002079The mode and buffersize arguments are as for the built-in open() function.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002080
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002081#endif /* NO_DUP */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002082
Guido van Rossum48a680c2001-03-02 06:34:14 +00002083
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002084/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002085
Guido van Rossum73624e91994-10-10 17:59:00 +00002086static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002087sock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002088{
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002089 int len, n = 0, flags = 0, timeout;
Guido van Rossum73624e91994-10-10 17:59:00 +00002090 PyObject *buf;
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002091#ifdef __VMS
2092 int read_length;
2093 char *read_buf;
2094#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00002095
Guido van Rossum43713e52000-02-29 13:59:29 +00002096 if (!PyArg_ParseTuple(args, "i|i:recv", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002097 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002098
2099 if (len < 0) {
Martin v. Löwisfba64e12001-11-19 10:41:26 +00002100 PyErr_SetString(PyExc_ValueError,
Guido van Rossum11ba0942002-06-13 15:07:44 +00002101 "negative buffersize in recv");
Martin v. Löwisfba64e12001-11-19 10:41:26 +00002102 return NULL;
2103 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002104
Guido van Rossum73624e91994-10-10 17:59:00 +00002105 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002106 if (buf == NULL)
2107 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002108
Neal Norwitz082b2df2006-02-07 07:04:46 +00002109 if (!IS_SELECTABLE(s))
2110 return select_error();
2111
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002112#ifndef __VMS
Guido van Rossum73624e91994-10-10 17:59:00 +00002113 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002114 timeout = internal_select(s, 0);
2115 if (!timeout)
2116 n = recv(s->sock_fd, PyString_AS_STRING(buf), len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00002117 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002118
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002119 if (timeout) {
2120 Py_DECREF(buf);
2121 PyErr_SetString(socket_timeout, "timed out");
2122 return NULL;
2123 }
Guido van Rossum7c53b771995-09-13 18:39:47 +00002124 if (n < 0) {
2125 Py_DECREF(buf);
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002126 return s->errorhandler();
Guido van Rossum7c53b771995-09-13 18:39:47 +00002127 }
Tim Peters5de98422002-04-27 18:44:32 +00002128 if (n != len)
2129 _PyString_Resize(&buf, n);
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002130#else
2131 read_buf = PyString_AsString(buf);
2132 read_length = len;
2133 while (read_length != 0) {
2134 unsigned int segment;
2135
2136 segment = read_length /SEGMENT_SIZE;
2137 if (segment != 0) {
2138 segment = SEGMENT_SIZE;
2139 }
2140 else {
2141 segment = read_length;
2142 }
2143
2144 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002145 timeout = internal_select(s, 0);
2146 if (!timeout)
2147 n = recv(s->sock_fd, read_buf, segment, flags);
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002148 Py_END_ALLOW_THREADS
2149
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002150 if (timeout) {
2151 Py_DECREF(buf);
2152 PyErr_SetString(socket_timeout, "timed out");
2153 return NULL;
2154 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002155 if (n < 0) {
2156 Py_DECREF(buf);
2157 return s->errorhandler();
2158 }
2159 if (n != read_length) {
2160 read_buf += n;
2161 break;
2162 }
2163
2164 read_length -= segment;
2165 read_buf += segment;
2166 }
2167 if (_PyString_Resize(&buf, (read_buf - PyString_AsString(buf))) < 0)
2168 {
2169 return NULL;
2170 }
2171#endif /* !__VMS */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002172 return buf;
2173}
2174
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002175PyDoc_STRVAR(recv_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002176"recv(buffersize[, flags]) -> data\n\
2177\n\
2178Receive up to buffersize bytes from the socket. For the optional flags\n\
2179argument, see the Unix manual. When no data is available, block until\n\
2180at least one byte is available or until the remote end is closed. When\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002181the remote end is closed and all data is read, return the empty string.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002182
Guido van Rossum30a685f1991-06-27 15:51:29 +00002183
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002184/* s.recvfrom(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002185
Guido van Rossum73624e91994-10-10 17:59:00 +00002186static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002187sock_recvfrom(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002188{
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002189 sock_addr_t addrbuf;
Barry Warsaw752300b1997-01-03 17:18:10 +00002190 PyObject *buf = NULL;
2191 PyObject *addr = NULL;
2192 PyObject *ret = NULL;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002193 int len, n = 0, flags = 0, timeout;
Guido van Rossumff3ab422000-04-24 15:16:03 +00002194 socklen_t addrlen;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002195
Guido van Rossum43713e52000-02-29 13:59:29 +00002196 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002197 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002198
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00002199 if (!getsockaddrlen(s, &addrlen))
2200 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002201 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00002202 if (buf == NULL)
2203 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002204
Neal Norwitz082b2df2006-02-07 07:04:46 +00002205 if (!IS_SELECTABLE(s))
2206 return select_error();
2207
Guido van Rossum73624e91994-10-10 17:59:00 +00002208 Py_BEGIN_ALLOW_THREADS
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002209 memset(&addrbuf, 0, addrlen);
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002210 timeout = internal_select(s, 0);
2211 if (!timeout)
2212 n = recvfrom(s->sock_fd, PyString_AS_STRING(buf), len, flags,
Guido van Rossum8d665e61996-06-26 18:22:49 +00002213#ifndef MS_WINDOWS
Andrew MacIntyreba43e872002-03-03 03:03:52 +00002214#if defined(PYOS_OS2) && !defined(PYCC_GCC)
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002215 (struct sockaddr *) &addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00002216#else
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002217 (void *) &addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00002218#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002219#else
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002220 (struct sockaddr *) &addrbuf, &addrlen
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002221#endif
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002222 );
Guido van Rossum73624e91994-10-10 17:59:00 +00002223 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002224
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002225 if (timeout) {
2226 Py_DECREF(buf);
2227 PyErr_SetString(socket_timeout, "timed out");
2228 return NULL;
2229 }
Guido van Rossum7c53b771995-09-13 18:39:47 +00002230 if (n < 0) {
2231 Py_DECREF(buf);
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002232 return s->errorhandler();
Guido van Rossum7c53b771995-09-13 18:39:47 +00002233 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002234
Guido van Rossum53a9bf81996-06-11 18:35:24 +00002235 if (n != len && _PyString_Resize(&buf, n) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002236 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002237
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002238 if (!(addr = makesockaddr(s->sock_fd, (struct sockaddr *) &addrbuf,
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00002239 addrlen, s->sock_proto)))
Barry Warsaw752300b1997-01-03 17:18:10 +00002240 goto finally;
2241
Raymond Hettinger8ae46892003-10-12 19:09:37 +00002242 ret = PyTuple_Pack(2, buf, addr);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002243
2244finally:
Guido van Rossum73624e91994-10-10 17:59:00 +00002245 Py_XDECREF(addr);
2246 Py_XDECREF(buf);
Guido van Rossum6f5afc91993-02-05 09:46:15 +00002247 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002248}
2249
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002250PyDoc_STRVAR(recvfrom_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002251"recvfrom(buffersize[, flags]) -> (data, address info)\n\
2252\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002253Like recv(buffersize, flags) but also return the sender's address info.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002254
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002255/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002256
Guido van Rossum73624e91994-10-10 17:59:00 +00002257static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002258sock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002259{
Guido van Rossumff4949e1992-08-05 19:58:53 +00002260 char *buf;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002261 int len, n = 0, flags = 0, timeout;
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002262#ifdef __VMS
2263 int send_length;
2264#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00002265
Guido van Rossum43713e52000-02-29 13:59:29 +00002266 if (!PyArg_ParseTuple(args, "s#|i:send", &buf, &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002267 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002268
Neal Norwitz082b2df2006-02-07 07:04:46 +00002269 if (!IS_SELECTABLE(s))
2270 return select_error();
2271
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002272#ifndef __VMS
Guido van Rossum73624e91994-10-10 17:59:00 +00002273 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002274 timeout = internal_select(s, 1);
2275 if (!timeout)
2276 n = send(s->sock_fd, buf, len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00002277 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002278
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002279 if (timeout) {
2280 PyErr_SetString(socket_timeout, "timed out");
2281 return NULL;
2282 }
Guido van Rossum30a685f1991-06-27 15:51:29 +00002283 if (n < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002284 return s->errorhandler();
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002285#else
2286 /* Divide packet into smaller segments for */
2287 /* TCP/IP Services for OpenVMS */
2288 send_length = len;
2289 while (send_length != 0) {
2290 unsigned int segment;
2291
2292 segment = send_length / SEGMENT_SIZE;
2293 if (segment != 0) {
2294 segment = SEGMENT_SIZE;
2295 }
2296 else {
2297 segment = send_length;
2298 }
2299 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002300 timeout = internal_select(s, 1);
2301 if (!timeout)
2302 n = send(s->sock_fd, buf, segment, flags);
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002303 Py_END_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002304 if (timeout) {
2305 PyErr_SetString(socket_timeout, "timed out");
2306 return NULL;
2307 }
Martin v. Löwis79acb9e2002-12-06 12:48:53 +00002308 if (n < 0) {
2309 return s->errorhandler();
2310 }
2311 send_length -= segment;
2312 buf += segment;
2313 } /* end while */
2314#endif /* !__VMS */
Guido van Rossum73624e91994-10-10 17:59:00 +00002315 return PyInt_FromLong((long)n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00002316}
2317
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002318PyDoc_STRVAR(send_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002319"send(data[, flags]) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002320\n\
2321Send a data string to the socket. For the optional flags\n\
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002322argument, see the Unix manual. Return the number of bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002323sent; this may be less than len(data) if the network is busy.");
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002324
2325
2326/* s.sendall(data [,flags]) method */
2327
2328static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002329sock_sendall(PySocketSockObject *s, PyObject *args)
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002330{
2331 char *buf;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002332 int len, n = 0, flags = 0, timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002333
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002334 if (!PyArg_ParseTuple(args, "s#|i:sendall", &buf, &len, &flags))
2335 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002336
Neal Norwitz082b2df2006-02-07 07:04:46 +00002337 if (!IS_SELECTABLE(s))
2338 return select_error();
2339
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002340 Py_BEGIN_ALLOW_THREADS
2341 do {
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002342 timeout = internal_select(s, 1);
2343 if (timeout)
2344 break;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002345 n = send(s->sock_fd, buf, len, flags);
2346 if (n < 0)
2347 break;
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002348 buf += n;
2349 len -= n;
2350 } while (len > 0);
2351 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002352
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002353 if (timeout) {
2354 PyErr_SetString(socket_timeout, "timed out");
2355 return NULL;
2356 }
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002357 if (n < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002358 return s->errorhandler();
Guido van Rossum67f7a382002-06-06 21:08:16 +00002359
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002360 Py_INCREF(Py_None);
2361 return Py_None;
2362}
2363
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002364PyDoc_STRVAR(sendall_doc,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002365"sendall(data[, flags])\n\
2366\n\
2367Send a data string to the socket. For the optional flags\n\
2368argument, see the Unix manual. This calls send() repeatedly\n\
2369until all data is sent. If an error occurs, it's impossible\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002370to tell how much data has been sent.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002371
Guido van Rossum30a685f1991-06-27 15:51:29 +00002372
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002373/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002374
Guido van Rossum73624e91994-10-10 17:59:00 +00002375static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002376sock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002377{
Guido van Rossum73624e91994-10-10 17:59:00 +00002378 PyObject *addro;
Guido van Rossumff4949e1992-08-05 19:58:53 +00002379 char *buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002380 struct sockaddr *addr;
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002381 int addrlen, len, n = 0, flags, timeout;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002382
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002383 flags = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002384 if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) {
Guido van Rossum73624e91994-10-10 17:59:00 +00002385 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002386 if (!PyArg_ParseTuple(args, "s#iO:sendto",
2387 &buf, &len, &flags, &addro))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002388 return NULL;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002389 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002390
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00002391 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002392 return NULL;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002393
Neal Norwitz082b2df2006-02-07 07:04:46 +00002394 if (!IS_SELECTABLE(s))
2395 return select_error();
2396
Guido van Rossum73624e91994-10-10 17:59:00 +00002397 Py_BEGIN_ALLOW_THREADS
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002398 timeout = internal_select(s, 1);
2399 if (!timeout)
2400 n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00002401 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002402
Raymond Hettingeref7343c2003-06-29 03:08:05 +00002403 if (timeout) {
2404 PyErr_SetString(socket_timeout, "timed out");
2405 return NULL;
2406 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002407 if (n < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002408 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00002409 return PyInt_FromLong((long)n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002410}
2411
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002412PyDoc_STRVAR(sendto_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00002413"sendto(data[, flags], address) -> count\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00002414\n\
2415Like send(data, flags) but allows specifying the destination address.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002416For IP sockets, the address is a pair (hostaddr, port).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002417
Guido van Rossum30a685f1991-06-27 15:51:29 +00002418
2419/* s.shutdown(how) method */
2420
Guido van Rossum73624e91994-10-10 17:59:00 +00002421static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002422sock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002423{
2424 int how;
Guido van Rossumff4949e1992-08-05 19:58:53 +00002425 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00002426
2427 how = PyInt_AsLong(arg);
2428 if (how == -1 && PyErr_Occurred())
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002429 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002430 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002431 res = shutdown(s->sock_fd, how);
Guido van Rossum73624e91994-10-10 17:59:00 +00002432 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002433 if (res < 0)
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00002434 return s->errorhandler();
Guido van Rossum73624e91994-10-10 17:59:00 +00002435 Py_INCREF(Py_None);
2436 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002437}
2438
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002439PyDoc_STRVAR(shutdown_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002440"shutdown(flag)\n\
2441\n\
Martin v. Löwis94681fc2003-11-27 19:40:22 +00002442Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
2443of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002444
Guido van Rossum30a685f1991-06-27 15:51:29 +00002445
2446/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002447
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002448static PyMethodDef sock_methods[] = {
2449 {"accept", (PyCFunction)sock_accept, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002450 accept_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002451 {"bind", (PyCFunction)sock_bind, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002452 bind_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002453 {"close", (PyCFunction)sock_close, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002454 close_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002455 {"connect", (PyCFunction)sock_connect, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002456 connect_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002457 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002458 connect_ex_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00002459#ifndef NO_DUP
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002460 {"dup", (PyCFunction)sock_dup, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002461 dup_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00002462#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002463 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002464 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00002465#ifdef HAVE_GETPEERNAME
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002466 {"getpeername", (PyCFunction)sock_getpeername,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002467 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00002468#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002469 {"getsockname", (PyCFunction)sock_getsockname,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002470 METH_NOARGS, getsockname_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002471 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002472 getsockopt_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002473 {"listen", (PyCFunction)sock_listen, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002474 listen_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002475#ifndef NO_DUP
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002476 {"makefile", (PyCFunction)sock_makefile, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002477 makefile_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002478#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002479 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002480 recv_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002481 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002482 recvfrom_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002483 {"send", (PyCFunction)sock_send, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002484 send_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002485 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
Guido van Rossum9f7a5392001-10-26 03:25:00 +00002486 sendall_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002487 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002488 sendto_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002489 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002490 setblocking_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002491 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
Guido van Rossum67f7a382002-06-06 21:08:16 +00002492 settimeout_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002493 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
Guido van Rossum67f7a382002-06-06 21:08:16 +00002494 gettimeout_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002495 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002496 setsockopt_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002497 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002498 shutdown_doc},
2499#ifdef RISCOS
Martin v. Löwisa94568a2003-05-10 07:36:56 +00002500 {"sleeptaskw", (PyCFunction)sock_sleeptaskw, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00002501 sleeptaskw_doc},
2502#endif
Guido van Rossumb6775db1994-08-01 11:34:53 +00002503 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002504};
2505
Georg Brandlbc45a3f2006-03-17 19:17:34 +00002506/* SockObject members */
2507static PyMemberDef sock_memberlist[] = {
2508 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
2509 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
2510 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
2511 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
2512 {0},
2513};
Guido van Rossum30a685f1991-06-27 15:51:29 +00002514
Guido van Rossum73624e91994-10-10 17:59:00 +00002515/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00002516 First close the file description. */
2517
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002518static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002519sock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002520{
Guido van Rossumfa972c92000-04-10 12:45:45 +00002521 if (s->sock_fd != -1)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00002522 (void) SOCKETCLOSE(s->sock_fd);
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002523 s->ob_type->tp_free((PyObject *)s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002524}
2525
Guido van Rossum30a685f1991-06-27 15:51:29 +00002526
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002527static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002528sock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002529{
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002530 char buf[512];
Fred Drakea04eaad2000-06-30 02:46:07 +00002531#if SIZEOF_SOCKET_T > SIZEOF_LONG
2532 if (s->sock_fd > LONG_MAX) {
2533 /* this can occur on Win64, and actually there is a special
2534 ugly printf formatter for decimal pointer length integer
2535 printing, only bother if necessary*/
2536 PyErr_SetString(PyExc_OverflowError,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002537 "no printf formatter to display "
2538 "the socket descriptor in decimal");
Fred Drakea04eaad2000-06-30 02:46:07 +00002539 return NULL;
2540 }
2541#endif
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002542 PyOS_snprintf(
2543 buf, sizeof(buf),
2544 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
2545 (long)s->sock_fd, s->sock_family,
2546 s->sock_type,
2547 s->sock_proto);
Guido van Rossumdc1c64a1996-02-27 15:21:19 +00002548 return PyString_FromString(buf);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002549}
2550
2551
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002552/* Create a new, uninitialized socket object. */
2553
2554static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002555sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002556{
2557 PyObject *new;
2558
2559 new = type->tp_alloc(type, 0);
Guido van Rossume1c478f2002-06-06 20:08:25 +00002560 if (new != NULL) {
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002561 ((PySocketSockObject *)new)->sock_fd = -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002562 ((PySocketSockObject *)new)->sock_timeout = -1.0;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002563 ((PySocketSockObject *)new)->errorhandler = &set_error;
Guido van Rossume1c478f2002-06-06 20:08:25 +00002564 }
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002565 return new;
2566}
2567
2568
2569/* Initialize a new socket object. */
2570
2571/*ARGSUSED*/
2572static int
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00002573sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002574{
2575 PySocketSockObject *s = (PySocketSockObject *)self;
2576 SOCKET_T fd;
2577 int family = AF_INET, type = SOCK_STREAM, proto = 0;
Martin v. Löwis02cbf4a2006-02-27 17:20:04 +00002578 static char *keywords[] = {"family", "type", "proto", 0};
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002579
2580 if (!PyArg_ParseTupleAndKeywords(args, kwds,
2581 "|iii:socket", keywords,
2582 &family, &type, &proto))
2583 return -1;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002584
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002585 Py_BEGIN_ALLOW_THREADS
2586 fd = socket(family, type, proto);
2587 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002588
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002589#ifdef MS_WINDOWS
2590 if (fd == INVALID_SOCKET)
2591#else
2592 if (fd < 0)
2593#endif
2594 {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002595 set_error();
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002596 return -1;
2597 }
2598 init_sockobject(s, fd, family, type, proto);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002599
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002600 return 0;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002601
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002602}
2603
2604
Guido van Rossumb6775db1994-08-01 11:34:53 +00002605/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002606
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002607static PyTypeObject sock_type = {
Guido van Rossum55558541996-05-23 22:54:50 +00002608 PyObject_HEAD_INIT(0) /* Must fill in type value later */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002609 0, /* ob_size */
Guido van Rossumca6dfa52001-10-28 12:31:33 +00002610 "_socket.socket", /* tp_name */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002611 sizeof(PySocketSockObject), /* tp_basicsize */
2612 0, /* tp_itemsize */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002613 (destructor)sock_dealloc, /* tp_dealloc */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002614 0, /* tp_print */
2615 0, /* tp_getattr */
2616 0, /* tp_setattr */
2617 0, /* tp_compare */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002618 (reprfunc)sock_repr, /* tp_repr */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002619 0, /* tp_as_number */
2620 0, /* tp_as_sequence */
2621 0, /* tp_as_mapping */
2622 0, /* tp_hash */
2623 0, /* tp_call */
2624 0, /* tp_str */
Jason Tishlerfb8595d2003-01-06 12:41:26 +00002625 PyObject_GenericGetAttr, /* tp_getattro */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002626 0, /* tp_setattro */
2627 0, /* tp_as_buffer */
2628 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002629 sock_doc, /* tp_doc */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002630 0, /* tp_traverse */
2631 0, /* tp_clear */
2632 0, /* tp_richcompare */
2633 0, /* tp_weaklistoffset */
2634 0, /* tp_iter */
2635 0, /* tp_iternext */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002636 sock_methods, /* tp_methods */
Georg Brandlbc45a3f2006-03-17 19:17:34 +00002637 sock_memberlist, /* tp_members */
Guido van Rossum384ca9c2001-10-27 22:20:47 +00002638 0, /* tp_getset */
2639 0, /* tp_base */
2640 0, /* tp_dict */
2641 0, /* tp_descr_get */
2642 0, /* tp_descr_set */
2643 0, /* tp_dictoffset */
Andrew MacIntyre7aec4a22002-06-13 11:53:52 +00002644 sock_initobj, /* tp_init */
Jason Tishlerfb8595d2003-01-06 12:41:26 +00002645 PyType_GenericAlloc, /* tp_alloc */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002646 sock_new, /* tp_new */
Jason Tishlerfb8595d2003-01-06 12:41:26 +00002647 PyObject_Del, /* tp_free */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002648};
2649
Guido van Rossum30a685f1991-06-27 15:51:29 +00002650
Guido van Rossum81194471991-07-27 21:42:02 +00002651/* Python interface to gethostname(). */
2652
2653/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002654static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002655socket_gethostname(PyObject *self, PyObject *args)
Guido van Rossum81194471991-07-27 21:42:02 +00002656{
2657 char buf[1024];
Guido van Rossumff4949e1992-08-05 19:58:53 +00002658 int res;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002659 if (!PyArg_ParseTuple(args, ":gethostname"))
Guido van Rossum81194471991-07-27 21:42:02 +00002660 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002661 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002662 res = gethostname(buf, (int) sizeof buf - 1);
Guido van Rossum73624e91994-10-10 17:59:00 +00002663 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002664 if (res < 0)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002665 return set_error();
Guido van Rossum81194471991-07-27 21:42:02 +00002666 buf[sizeof buf - 1] = '\0';
Guido van Rossum73624e91994-10-10 17:59:00 +00002667 return PyString_FromString(buf);
Guido van Rossum81194471991-07-27 21:42:02 +00002668}
Guido van Rossumff4949e1992-08-05 19:58:53 +00002669
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002670PyDoc_STRVAR(gethostname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002671"gethostname() -> string\n\
2672\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002673Return the current host name.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002674
Guido van Rossumff4949e1992-08-05 19:58:53 +00002675
Guido van Rossum30a685f1991-06-27 15:51:29 +00002676/* Python interface to gethostbyname(name). */
2677
2678/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002679static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002680socket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002681{
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002682 char *name;
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +00002683 sock_addr_t addrbuf;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002684
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002685 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
Guido van Rossum30a685f1991-06-27 15:51:29 +00002686 return NULL;
Martin v. Löwisddc6f472002-07-28 16:10:31 +00002687 if (setipaddr(name, (struct sockaddr *)&addrbuf, sizeof(addrbuf), AF_INET) < 0)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002688 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002689 return makeipaddr((struct sockaddr *)&addrbuf,
2690 sizeof(struct sockaddr_in));
Guido van Rossum30a685f1991-06-27 15:51:29 +00002691}
2692
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002693PyDoc_STRVAR(gethostbyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002694"gethostbyname(host) -> address\n\
2695\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002696Return the IP address (a string of the form '255.255.255.255') for a host.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002697
2698
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002699/* Convenience function common to gethostbyname_ex and gethostbyaddr */
2700
2701static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002702gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002703{
2704 char **pch;
2705 PyObject *rtn_tuple = (PyObject *)NULL;
2706 PyObject *name_list = (PyObject *)NULL;
2707 PyObject *addr_list = (PyObject *)NULL;
2708 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002709
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002710 if (h == NULL) {
Guido van Rossum48a680c2001-03-02 06:34:14 +00002711 /* Let's get real error message to return */
Guido van Rossume2ae77b2001-10-24 20:42:55 +00002712#ifndef RISCOS
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002713 set_herror(h_errno);
Guido van Rossume2ae77b2001-10-24 20:42:55 +00002714#else
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002715 PyErr_SetString(socket_error, "host not found");
Guido van Rossume2ae77b2001-10-24 20:42:55 +00002716#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002717 return NULL;
2718 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002719
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002720 if (h->h_addrtype != af) {
2721#ifdef HAVE_STRERROR
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002722 /* Let's get real error message to return */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002723 PyErr_SetString(socket_error,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002724 (char *)strerror(EAFNOSUPPORT));
2725#else
2726 PyErr_SetString(
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002727 socket_error,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002728 "Address family not supported by protocol family");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002729#endif
2730 return NULL;
2731 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002732
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002733 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00002734
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002735 case AF_INET:
2736 if (alen < sizeof(struct sockaddr_in))
2737 return NULL;
2738 break;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002739
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00002740#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002741 case AF_INET6:
2742 if (alen < sizeof(struct sockaddr_in6))
2743 return NULL;
2744 break;
2745#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00002746
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002747 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002748
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002749 if ((name_list = PyList_New(0)) == NULL)
2750 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002751
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002752 if ((addr_list = PyList_New(0)) == NULL)
2753 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002754
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002755 for (pch = h->h_aliases; *pch != NULL; pch++) {
2756 int status;
2757 tmp = PyString_FromString(*pch);
2758 if (tmp == NULL)
2759 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002760
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002761 status = PyList_Append(name_list, tmp);
2762 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002763
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002764 if (status)
2765 goto err;
2766 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002767
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002768 for (pch = h->h_addr_list; *pch != NULL; pch++) {
2769 int status;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002770
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002771 switch (af) {
Guido van Rossum67f7a382002-06-06 21:08:16 +00002772
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002773 case AF_INET:
2774 {
2775 struct sockaddr_in sin;
2776 memset(&sin, 0, sizeof(sin));
2777 sin.sin_family = af;
2778#ifdef HAVE_SOCKADDR_SA_LEN
2779 sin.sin_len = sizeof(sin);
2780#endif
2781 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
2782 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
Guido van Rossum67f7a382002-06-06 21:08:16 +00002783
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002784 if (pch == h->h_addr_list && alen >= sizeof(sin))
2785 memcpy((char *) addr, &sin, sizeof(sin));
2786 break;
2787 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002788
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00002789#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002790 case AF_INET6:
2791 {
2792 struct sockaddr_in6 sin6;
2793 memset(&sin6, 0, sizeof(sin6));
2794 sin6.sin6_family = af;
2795#ifdef HAVE_SOCKADDR_SA_LEN
2796 sin6.sin6_len = sizeof(sin6);
2797#endif
2798 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
2799 tmp = makeipaddr((struct sockaddr *)&sin6,
2800 sizeof(sin6));
Guido van Rossum67f7a382002-06-06 21:08:16 +00002801
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002802 if (pch == h->h_addr_list && alen >= sizeof(sin6))
2803 memcpy((char *) addr, &sin6, sizeof(sin6));
2804 break;
2805 }
2806#endif
Guido van Rossum67f7a382002-06-06 21:08:16 +00002807
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002808 default: /* can't happen */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002809 PyErr_SetString(socket_error,
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002810 "unsupported address family");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002811 return NULL;
2812 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002813
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002814 if (tmp == NULL)
2815 goto err;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002816
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002817 status = PyList_Append(addr_list, tmp);
2818 Py_DECREF(tmp);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002819
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002820 if (status)
2821 goto err;
2822 }
Guido van Rossum67f7a382002-06-06 21:08:16 +00002823
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002824 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
Guido van Rossum67f7a382002-06-06 21:08:16 +00002825
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002826 err:
2827 Py_XDECREF(name_list);
2828 Py_XDECREF(addr_list);
2829 return rtn_tuple;
2830}
2831
2832
2833/* Python interface to gethostbyname_ex(name). */
2834
2835/*ARGSUSED*/
2836static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002837socket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002838{
2839 char *name;
2840 struct hostent *h;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +00002841#ifdef ENABLE_IPV6
2842 struct sockaddr_storage addr;
2843#else
2844 struct sockaddr_in addr;
2845#endif
Martin v. Löwis9db2f572001-07-23 01:30:10 +00002846 struct sockaddr *sa;
Guido van Rossum955becc1999-03-22 20:14:53 +00002847 PyObject *ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002848#ifdef HAVE_GETHOSTBYNAME_R
2849 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002850#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
2851 struct hostent_data data;
2852#else
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002853 char buf[16384];
2854 int buf_len = (sizeof buf) - 1;
2855 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002856#endif
2857#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002858 int result;
2859#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002860#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002861
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002862 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002863 return NULL;
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00002864 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002865 return NULL;
2866 Py_BEGIN_ALLOW_THREADS
2867#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002868#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002869 result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
2870 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002871#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002872 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002873#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00002874 memset((void *) &data, '\0', sizeof(data));
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002875 result = gethostbyname_r(name, &hp_allocated, &data);
2876 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002877#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002878#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00002879#ifdef USE_GETHOSTBYNAME_LOCK
Just van Rossum1040d2c2003-05-09 07:53:18 +00002880 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002881#endif
2882 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002883#endif /* HAVE_GETHOSTBYNAME_R */
2884 Py_END_ALLOW_THREADS
Guido van Rossum67f7a382002-06-06 21:08:16 +00002885 /* Some C libraries would require addr.__ss_family instead of
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002886 addr.ss_family.
2887 Therefore, we cast the sockaddr_storage into sockaddr to
2888 access sa_family. */
Martin v. Löwis9db2f572001-07-23 01:30:10 +00002889 sa = (struct sockaddr*)&addr;
Guido van Rossum67f7a382002-06-06 21:08:16 +00002890 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002891 sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00002892#ifdef USE_GETHOSTBYNAME_LOCK
Just van Rossum1040d2c2003-05-09 07:53:18 +00002893 PyThread_release_lock(netdb_lock);
Guido van Rossum955becc1999-03-22 20:14:53 +00002894#endif
2895 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002896}
2897
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002898PyDoc_STRVAR(ghbn_ex_doc,
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002899"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
2900\n\
2901Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002902for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00002903
2904
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002905/* Python interface to gethostbyaddr(IP). */
2906
2907/*ARGSUSED*/
2908static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002909socket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002910{
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00002911#ifdef ENABLE_IPV6
Guido van Rossum3eede5a2002-06-07 02:08:35 +00002912 struct sockaddr_storage addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002913#else
Guido van Rossum48a680c2001-03-02 06:34:14 +00002914 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002915#endif
2916 struct sockaddr *sa = (struct sockaddr *)&addr;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002917 char *ip_num;
2918 struct hostent *h;
Guido van Rossum3baaa131999-03-22 21:44:51 +00002919 PyObject *ret;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002920#ifdef HAVE_GETHOSTBYNAME_R
2921 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002922#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
2923 struct hostent_data data;
2924#else
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002925 char buf[16384];
2926 int buf_len = (sizeof buf) - 1;
2927 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002928#endif
2929#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002930 int result;
2931#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002932#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002933 char *ap;
2934 int al;
2935 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002936
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002937 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002938 return NULL;
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00002939 af = AF_UNSPEC;
Martin v. Löwisddc6f472002-07-28 16:10:31 +00002940 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002941 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002942 af = sa->sa_family;
2943 ap = NULL;
2944 al = 0;
2945 switch (af) {
2946 case AF_INET:
2947 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
2948 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
2949 break;
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00002950#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002951 case AF_INET6:
2952 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
2953 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
2954 break;
2955#endif
2956 default:
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00002957 PyErr_SetString(socket_error, "unsupported address family");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002958 return NULL;
2959 }
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002960 Py_BEGIN_ALLOW_THREADS
2961#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002962#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002963 result = gethostbyaddr_r(ap, al, af,
2964 &hp_allocated, buf, buf_len,
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002965 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002966#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002967 h = gethostbyaddr_r(ap, al, af,
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002968 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002969#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00002970 memset((void *) &data, '\0', sizeof(data));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002971 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002972 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002973#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002974#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00002975#ifdef USE_GETHOSTBYNAME_LOCK
Just van Rossum1040d2c2003-05-09 07:53:18 +00002976 PyThread_acquire_lock(netdb_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002977#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002978 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002979#endif /* HAVE_GETHOSTBYNAME_R */
2980 Py_END_ALLOW_THREADS
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002981 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00002982#ifdef USE_GETHOSTBYNAME_LOCK
Just van Rossum1040d2c2003-05-09 07:53:18 +00002983 PyThread_release_lock(netdb_lock);
Guido van Rossum3baaa131999-03-22 21:44:51 +00002984#endif
2985 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002986}
2987
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002988PyDoc_STRVAR(gethostbyaddr_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00002989"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
2990\n\
2991Return the true host name, a list of aliases, and a list of IP addresses,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002992for a host. The host argument is a string giving a host name or IP number.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00002993
Guido van Rossum30a685f1991-06-27 15:51:29 +00002994
2995/* Python interface to getservbyname(name).
2996 This only returns the port number, since the other info is already
2997 known or not useful (like the list of aliases). */
2998
2999/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003000static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003001socket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00003002{
Barry Warsaw11b91a02004-06-28 00:50:43 +00003003 char *name, *proto=NULL;
Guido van Rossum30a685f1991-06-27 15:51:29 +00003004 struct servent *sp;
Barry Warsaw11b91a02004-06-28 00:50:43 +00003005 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
Guido van Rossum30a685f1991-06-27 15:51:29 +00003006 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00003007 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00003008 sp = getservbyname(name, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00003009 Py_END_ALLOW_THREADS
Guido van Rossum30a685f1991-06-27 15:51:29 +00003010 if (sp == NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003011 PyErr_SetString(socket_error, "service/proto not found");
Guido van Rossum30a685f1991-06-27 15:51:29 +00003012 return NULL;
3013 }
Guido van Rossum73624e91994-10-10 17:59:00 +00003014 return PyInt_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00003015}
3016
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003017PyDoc_STRVAR(getservbyname_doc,
Barry Warsaw11b91a02004-06-28 00:50:43 +00003018"getservbyname(servicename[, protocolname]) -> integer\n\
Guido van Rossum82a5c661998-07-07 20:45:43 +00003019\n\
3020Return a port number from a service name and protocol name.\n\
Barry Warsaw11b91a02004-06-28 00:50:43 +00003021The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3022otherwise any protocol will match.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003023
Guido van Rossum30a685f1991-06-27 15:51:29 +00003024
Barry Warsaw11b91a02004-06-28 00:50:43 +00003025/* Python interface to getservbyport(port).
3026 This only returns the service name, since the other info is already
3027 known or not useful (like the list of aliases). */
3028
3029/*ARGSUSED*/
3030static PyObject *
3031socket_getservbyport(PyObject *self, PyObject *args)
3032{
Raymond Hettinger87de0ca2004-09-28 02:19:40 +00003033 unsigned short port;
Barry Warsaw11b91a02004-06-28 00:50:43 +00003034 char *proto=NULL;
3035 struct servent *sp;
Raymond Hettinger87de0ca2004-09-28 02:19:40 +00003036 if (!PyArg_ParseTuple(args, "H|s:getservbyport", &port, &proto))
Barry Warsaw11b91a02004-06-28 00:50:43 +00003037 return NULL;
3038 Py_BEGIN_ALLOW_THREADS
3039 sp = getservbyport(htons(port), proto);
3040 Py_END_ALLOW_THREADS
3041 if (sp == NULL) {
3042 PyErr_SetString(socket_error, "port/proto not found");
3043 return NULL;
3044 }
3045 return PyString_FromString(sp->s_name);
3046}
3047
3048PyDoc_STRVAR(getservbyport_doc,
3049"getservbyport(port[, protocolname]) -> string\n\
3050\n\
3051Return the service name from a port number and protocol name.\n\
3052The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3053otherwise any protocol will match.");
3054
Guido van Rossum3901d851996-12-19 16:35:04 +00003055/* Python interface to getprotobyname(name).
3056 This only returns the protocol number, since the other info is
3057 already known or not useful (like the list of aliases). */
3058
3059/*ARGSUSED*/
3060static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003061socket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00003062{
3063 char *name;
3064 struct protoent *sp;
Guido van Rossumbcc20741998-08-04 22:53:56 +00003065#ifdef __BEOS__
3066/* Not available in BeOS yet. - [cjh] */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003067 PyErr_SetString(socket_error, "getprotobyname not supported");
Guido van Rossumbcc20741998-08-04 22:53:56 +00003068 return NULL;
3069#else
Guido van Rossum27fc3c02000-03-24 20:56:56 +00003070 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
Guido van Rossum3901d851996-12-19 16:35:04 +00003071 return NULL;
3072 Py_BEGIN_ALLOW_THREADS
3073 sp = getprotobyname(name);
3074 Py_END_ALLOW_THREADS
3075 if (sp == NULL) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003076 PyErr_SetString(socket_error, "protocol not found");
Guido van Rossum3901d851996-12-19 16:35:04 +00003077 return NULL;
3078 }
3079 return PyInt_FromLong((long) sp->p_proto);
Guido van Rossumbcc20741998-08-04 22:53:56 +00003080#endif
Guido van Rossum3901d851996-12-19 16:35:04 +00003081}
3082
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003083PyDoc_STRVAR(getprotobyname_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003084"getprotobyname(name) -> integer\n\
3085\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003086Return the protocol number for the named protocol. (Rarely used.)");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003087
Guido van Rossum3901d851996-12-19 16:35:04 +00003088
Dave Cole331708b2004-08-09 04:51:41 +00003089#ifdef HAVE_SOCKETPAIR
3090/* Create a pair of sockets using the socketpair() function.
Dave Cole07fda7e2004-08-23 05:16:23 +00003091 Arguments as for socket() except the default family is AF_UNIX if
Dave Colee8bbfe42004-08-26 00:51:16 +00003092 defined on the platform; otherwise, the default is AF_INET. */
Dave Cole331708b2004-08-09 04:51:41 +00003093
3094/*ARGSUSED*/
3095static PyObject *
3096socket_socketpair(PyObject *self, PyObject *args)
3097{
3098 PySocketSockObject *s0 = NULL, *s1 = NULL;
3099 SOCKET_T sv[2];
3100 int family, type = SOCK_STREAM, proto = 0;
3101 PyObject *res = NULL;
3102
3103#if defined(AF_UNIX)
3104 family = AF_UNIX;
3105#else
3106 family = AF_INET;
3107#endif
3108 if (!PyArg_ParseTuple(args, "|iii:socketpair",
3109 &family, &type, &proto))
3110 return NULL;
3111 /* Create a pair of socket fds */
3112 if (socketpair(family, type, proto, sv) < 0)
3113 return set_error();
Dave Cole331708b2004-08-09 04:51:41 +00003114 s0 = new_sockobject(sv[0], family, type, proto);
3115 if (s0 == NULL)
3116 goto finally;
3117 s1 = new_sockobject(sv[1], family, type, proto);
3118 if (s1 == NULL)
3119 goto finally;
3120 res = PyTuple_Pack(2, s0, s1);
3121
3122finally:
3123 if (res == NULL) {
3124 if (s0 == NULL)
3125 SOCKETCLOSE(sv[0]);
3126 if (s1 == NULL)
3127 SOCKETCLOSE(sv[1]);
3128 }
3129 Py_XDECREF(s0);
3130 Py_XDECREF(s1);
3131 return res;
3132}
3133
3134PyDoc_STRVAR(socketpair_doc,
3135"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
3136\n\
3137Create a pair of socket objects from the sockets returned by the platform\n\
3138socketpair() function.\n\
Dave Cole07fda7e2004-08-23 05:16:23 +00003139The arguments are the same as for socket() except the default family is\n\
Dave Colee8bbfe42004-08-26 00:51:16 +00003140AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
Dave Cole331708b2004-08-09 04:51:41 +00003141
3142#endif /* HAVE_SOCKETPAIR */
3143
3144
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00003145#ifndef NO_DUP
Guido van Rossum2a7178e1992-12-08 13:38:24 +00003146/* Create a socket object from a numeric file description.
3147 Useful e.g. if stdin is a socket.
3148 Additional arguments as for socket(). */
3149
3150/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00003151static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003152socket_fromfd(PyObject *self, PyObject *args)
Guido van Rossum2a7178e1992-12-08 13:38:24 +00003153{
Guido van Rossum73624e91994-10-10 17:59:00 +00003154 PySocketSockObject *s;
Fred Drakea04eaad2000-06-30 02:46:07 +00003155 SOCKET_T fd;
3156 int family, type, proto = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00003157 if (!PyArg_ParseTuple(args, "iii|i:fromfd",
3158 &fd, &family, &type, &proto))
Guido van Rossumbe32c891996-06-20 16:25:29 +00003159 return NULL;
Guido van Rossum5f59d601992-12-14 16:59:51 +00003160 /* Dup the fd so it and the socket can be closed independently */
3161 fd = dup(fd);
3162 if (fd < 0)
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003163 return set_error();
3164 s = new_sockobject(fd, family, type, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00003165 return (PyObject *) s;
Guido van Rossum2a7178e1992-12-08 13:38:24 +00003166}
Guido van Rossum82a5c661998-07-07 20:45:43 +00003167
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003168PyDoc_STRVAR(fromfd_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003169"fromfd(fd, family, type[, proto]) -> socket object\n\
3170\n\
Georg Brandldcfdae72006-04-01 07:33:08 +00003171Create a socket object from a duplicate of the given\n\
3172file descriptor.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003173The remaining arguments are the same as for socket().");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003174
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00003175#endif /* NO_DUP */
Guido van Rossum2a7178e1992-12-08 13:38:24 +00003176
Guido van Rossum82a5c661998-07-07 20:45:43 +00003177
Guido van Rossum006bf911996-06-12 04:04:55 +00003178static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003179socket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003180{
3181 int x1, x2;
3182
Guido van Rossum27fc3c02000-03-24 20:56:56 +00003183 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00003184 return NULL;
3185 }
3186 x2 = (int)ntohs((short)x1);
3187 return PyInt_FromLong(x2);
3188}
3189
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003190PyDoc_STRVAR(ntohs_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003191"ntohs(integer) -> integer\n\
3192\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003193Convert a 16-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003194
3195
Guido van Rossum006bf911996-06-12 04:04:55 +00003196static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003197socket_ntohl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003198{
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003199 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003200
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003201 if (PyInt_Check(arg)) {
3202 x = PyInt_AS_LONG(arg);
Jeremy Hylton825e47b2002-07-25 16:37:51 +00003203 if (x == (unsigned long) -1 && PyErr_Occurred())
3204 return NULL;
Guido van Rossum006bf911996-06-12 04:04:55 +00003205 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003206 else if (PyLong_Check(arg)) {
3207 x = PyLong_AsUnsignedLong(arg);
Jeremy Hylton825e47b2002-07-25 16:37:51 +00003208 if (x == (unsigned long) -1 && PyErr_Occurred())
3209 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003210#if SIZEOF_LONG > 4
3211 {
3212 unsigned long y;
3213 /* only want the trailing 32 bits */
3214 y = x & 0xFFFFFFFFUL;
3215 if (y ^ x)
3216 return PyErr_Format(PyExc_OverflowError,
3217 "long int larger than 32 bits");
3218 x = y;
Tim Peters58141872002-08-06 22:25:02 +00003219 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003220#endif
3221 }
3222 else
Tim Peters58141872002-08-06 22:25:02 +00003223 return PyErr_Format(PyExc_TypeError,
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003224 "expected int/long, %s found",
3225 arg->ob_type->tp_name);
3226 if (x == (unsigned long) -1 && PyErr_Occurred())
3227 return NULL;
3228 return PyInt_FromLong(ntohl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003229}
3230
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003231PyDoc_STRVAR(ntohl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003232"ntohl(integer) -> integer\n\
3233\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003234Convert a 32-bit integer from network to host byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003235
3236
Guido van Rossum006bf911996-06-12 04:04:55 +00003237static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003238socket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00003239{
Hye-Shik Changa7b673f2003-12-17 09:40:23 +00003240 int x1, x2;
Guido van Rossum006bf911996-06-12 04:04:55 +00003241
Guido van Rossum27fc3c02000-03-24 20:56:56 +00003242 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00003243 return NULL;
3244 }
3245 x2 = (int)htons((short)x1);
3246 return PyInt_FromLong(x2);
3247}
3248
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003249PyDoc_STRVAR(htons_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003250"htons(integer) -> integer\n\
3251\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003252Convert a 16-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003253
3254
Guido van Rossum006bf911996-06-12 04:04:55 +00003255static PyObject *
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003256socket_htonl(PyObject *self, PyObject *arg)
Guido van Rossum006bf911996-06-12 04:04:55 +00003257{
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003258 unsigned long x;
Guido van Rossum006bf911996-06-12 04:04:55 +00003259
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003260 if (PyInt_Check(arg)) {
3261 x = PyInt_AS_LONG(arg);
Jeremy Hylton825e47b2002-07-25 16:37:51 +00003262 if (x == (unsigned long) -1 && PyErr_Occurred())
3263 return NULL;
Guido van Rossum006bf911996-06-12 04:04:55 +00003264 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003265 else if (PyLong_Check(arg)) {
3266 x = PyLong_AsUnsignedLong(arg);
Jeremy Hylton825e47b2002-07-25 16:37:51 +00003267 if (x == (unsigned long) -1 && PyErr_Occurred())
3268 return NULL;
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003269#if SIZEOF_LONG > 4
3270 {
3271 unsigned long y;
3272 /* only want the trailing 32 bits */
3273 y = x & 0xFFFFFFFFUL;
3274 if (y ^ x)
3275 return PyErr_Format(PyExc_OverflowError,
3276 "long int larger than 32 bits");
3277 x = y;
Tim Peters58141872002-08-06 22:25:02 +00003278 }
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003279#endif
3280 }
3281 else
Tim Peters58141872002-08-06 22:25:02 +00003282 return PyErr_Format(PyExc_TypeError,
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003283 "expected int/long, %s found",
3284 arg->ob_type->tp_name);
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003285 return PyInt_FromLong(htonl(x));
Guido van Rossum006bf911996-06-12 04:04:55 +00003286}
3287
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003288PyDoc_STRVAR(htonl_doc,
Guido van Rossum82a5c661998-07-07 20:45:43 +00003289"htonl(integer) -> integer\n\
3290\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003291Convert a 32-bit integer from host to network byte order.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003292
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003293/* socket.inet_aton() and socket.inet_ntoa() functions. */
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003294
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003295PyDoc_STRVAR(inet_aton_doc,
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003296"inet_aton(string) -> packed 32-bit IP representation\n\
3297\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003298Convert 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 +00003299binary format used in low-level network functions.");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003300
3301static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003302socket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003303{
Guido van Rossuma2e48551999-09-09 15:42:59 +00003304#ifndef INADDR_NONE
3305#define INADDR_NONE (-1)
3306#endif
Neal Norwitz88f115b2003-02-13 02:15:42 +00003307#ifdef HAVE_INET_ATON
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003308 struct in_addr buf;
Tim Peters1df9fdd2003-02-13 03:13:40 +00003309#else
3310 /* Have to use inet_addr() instead */
3311 unsigned long packed_addr;
3312#endif
3313 char *ip_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003314
Tim Peters1df9fdd2003-02-13 03:13:40 +00003315 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003316 return NULL;
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003317
Tim Peters1df9fdd2003-02-13 03:13:40 +00003318
3319#ifdef HAVE_INET_ATON
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003320 if (inet_aton(ip_addr, &buf))
3321 return PyString_FromStringAndSize((char *)(&buf),
3322 sizeof(buf));
3323
3324 PyErr_SetString(socket_error,
3325 "illegal IP address string passed to inet_aton");
3326 return NULL;
3327
Tim Peters1df9fdd2003-02-13 03:13:40 +00003328#else /* ! HAVE_INET_ATON */
Georg Brandld2e3ba72005-08-26 08:34:00 +00003329 /* special-case this address as inet_addr might return INADDR_NONE
3330 * for this */
3331 if (strcmp(ip_addr, "255.255.255.255") == 0) {
3332 packed_addr = 0xFFFFFFFF;
3333 } else {
3334
3335 packed_addr = inet_addr(ip_addr);
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003336
Georg Brandld2e3ba72005-08-26 08:34:00 +00003337 if (packed_addr == INADDR_NONE) { /* invalid address */
3338 PyErr_SetString(socket_error,
3339 "illegal IP address string passed to inet_aton");
3340 return NULL;
3341 }
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003342 }
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003343 return PyString_FromStringAndSize((char *) &packed_addr,
3344 sizeof(packed_addr));
Guido van Rossumad05cdf2003-02-12 23:08:22 +00003345#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003346}
3347
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003348PyDoc_STRVAR(inet_ntoa_doc,
Fred Drakee0661342000-03-07 14:05:16 +00003349"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003350\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003351Convert an IP address from 32-bit packed binary format to string format");
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003352
3353static PyObject*
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003354socket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003355{
3356 char *packed_str;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00003357 int addr_len;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003358 struct in_addr packed_addr;
3359
Guido van Rossum27fc3c02000-03-24 20:56:56 +00003360 if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003361 return NULL;
3362 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00003363
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003364 if (addr_len != sizeof(packed_addr)) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003365 PyErr_SetString(socket_error,
Guido van Rossum5c9eb211999-08-20 18:21:51 +00003366 "packed IP wrong length for inet_ntoa");
3367 return NULL;
3368 }
3369
3370 memcpy(&packed_addr, packed_str, addr_len);
3371
3372 return PyString_FromString(inet_ntoa(packed_addr));
3373}
Guido van Rossum82a5c661998-07-07 20:45:43 +00003374
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003375#ifdef HAVE_INET_PTON
3376
3377PyDoc_STRVAR(inet_pton_doc,
3378"inet_pton(af, ip) -> packed IP address string\n\
3379\n\
3380Convert an IP address from string format to a packed string suitable\n\
3381for use with low-level network functions.");
3382
3383static PyObject *
3384socket_inet_pton(PyObject *self, PyObject *args)
3385{
3386 int af;
3387 char* ip;
3388 int retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003389#ifdef ENABLE_IPV6
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003390 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003391#else
3392 char packed[sizeof(struct in_addr)];
3393#endif
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003394 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
3395 return NULL;
3396 }
3397
Martin v. Löwis04697e82004-06-02 12:35:29 +00003398#if !defined(ENABLE_IPV6) && defined(AF_INET6)
Martin v. Löwis10649092003-08-05 06:25:06 +00003399 if(af == AF_INET6) {
3400 PyErr_SetString(socket_error,
3401 "can't use AF_INET6, IPv6 is disabled");
3402 return NULL;
3403 }
3404#endif
3405
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003406 retval = inet_pton(af, ip, packed);
3407 if (retval < 0) {
3408 PyErr_SetFromErrno(socket_error);
3409 return NULL;
3410 } else if (retval == 0) {
3411 PyErr_SetString(socket_error,
3412 "illegal IP address string passed to inet_pton");
3413 return NULL;
3414 } else if (af == AF_INET) {
3415 return PyString_FromStringAndSize(packed,
3416 sizeof(struct in_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003417#ifdef ENABLE_IPV6
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003418 } else if (af == AF_INET6) {
3419 return PyString_FromStringAndSize(packed,
3420 sizeof(struct in6_addr));
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003421#endif
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003422 } else {
3423 PyErr_SetString(socket_error, "unknown address family");
3424 return NULL;
3425 }
3426}
3427
3428PyDoc_STRVAR(inet_ntop_doc,
3429"inet_ntop(af, packed_ip) -> string formatted IP address\n\
3430\n\
3431Convert a packed IP address of the given family to string format.");
3432
3433static PyObject *
3434socket_inet_ntop(PyObject *self, PyObject *args)
3435{
3436 int af;
3437 char* packed;
3438 int len;
3439 const char* retval;
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003440#ifdef ENABLE_IPV6
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003441 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003442#else
3443 char ip[INET_ADDRSTRLEN + 1];
3444#endif
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003445
3446 /* Guarantee NUL-termination for PyString_FromString() below */
Jeremy Hylton80961f32004-11-07 14:24:25 +00003447 memset((void *) &ip[0], '\0', sizeof(ip));
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003448
3449 if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {
3450 return NULL;
3451 }
3452
3453 if (af == AF_INET) {
3454 if (len != sizeof(struct in_addr)) {
3455 PyErr_SetString(PyExc_ValueError,
3456 "invalid length of packed IP address string");
3457 return NULL;
3458 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003459#ifdef ENABLE_IPV6
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003460 } else if (af == AF_INET6) {
3461 if (len != sizeof(struct in6_addr)) {
3462 PyErr_SetString(PyExc_ValueError,
3463 "invalid length of packed IP address string");
3464 return NULL;
3465 }
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003466#endif
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003467 } else {
3468 PyErr_Format(PyExc_ValueError,
3469 "unknown address family %d", af);
3470 return NULL;
3471 }
3472
3473 retval = inet_ntop(af, packed, ip, sizeof(ip));
3474 if (!retval) {
3475 PyErr_SetFromErrno(socket_error);
3476 return NULL;
3477 } else {
3478 return PyString_FromString(retval);
3479 }
3480
3481 /* NOTREACHED */
3482 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
3483 return NULL;
3484}
3485
3486#endif /* HAVE_INET_PTON */
3487
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003488/* Python interface to getaddrinfo(host, port). */
3489
3490/*ARGSUSED*/
3491static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003492socket_getaddrinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003493{
Martin v. Löwisf0b11d22001-11-07 08:31:03 +00003494 struct addrinfo hints, *res;
3495 struct addrinfo *res0 = NULL;
Martin v. Löwis2548c732003-04-18 10:39:54 +00003496 PyObject *hobj = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003497 PyObject *pobj = (PyObject *)NULL;
Martin v. Löwisf65b1a12001-08-12 09:28:40 +00003498 char pbuf[30];
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003499 char *hptr, *pptr;
3500 int family, socktype, protocol, flags;
3501 int error;
3502 PyObject *all = (PyObject *)NULL;
3503 PyObject *single = (PyObject *)NULL;
Martin v. Löwis2548c732003-04-18 10:39:54 +00003504 PyObject *idna = NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003505
3506 family = socktype = protocol = flags = 0;
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00003507 family = AF_UNSPEC;
Martin v. Löwis2548c732003-04-18 10:39:54 +00003508 if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
3509 &hobj, &pobj, &family, &socktype,
3510 &protocol, &flags)) {
3511 return NULL;
3512 }
3513 if (hobj == Py_None) {
3514 hptr = NULL;
3515 } else if (PyUnicode_Check(hobj)) {
3516 idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
3517 if (!idna)
3518 return NULL;
3519 hptr = PyString_AsString(idna);
3520 } else if (PyString_Check(hobj)) {
3521 hptr = PyString_AsString(hobj);
3522 } else {
3523 PyErr_SetString(PyExc_TypeError,
3524 "getaddrinfo() argument 1 must be string or None");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003525 return NULL;
3526 }
3527 if (PyInt_Check(pobj)) {
Marc-André Lemburg03d1b182001-07-31 18:05:33 +00003528 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003529 pptr = pbuf;
3530 } else if (PyString_Check(pobj)) {
3531 pptr = PyString_AsString(pobj);
3532 } else if (pobj == Py_None) {
3533 pptr = (char *)NULL;
3534 } else {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003535 PyErr_SetString(socket_error, "Int or String expected");
Martin v. Löwis5db099a2003-08-07 11:55:15 +00003536 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003537 }
3538 memset(&hints, 0, sizeof(hints));
3539 hints.ai_family = family;
3540 hints.ai_socktype = socktype;
3541 hints.ai_protocol = protocol;
3542 hints.ai_flags = flags;
Just van Rossum1040d2c2003-05-09 07:53:18 +00003543 Py_BEGIN_ALLOW_THREADS
3544 ACQUIRE_GETADDRINFO_LOCK
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003545 error = getaddrinfo(hptr, pptr, &hints, &res0);
Just van Rossum1040d2c2003-05-09 07:53:18 +00003546 Py_END_ALLOW_THREADS
3547 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003548 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003549 set_gaierror(error);
Martin v. Löwis5db099a2003-08-07 11:55:15 +00003550 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003551 }
3552
3553 if ((all = PyList_New(0)) == NULL)
3554 goto err;
3555 for (res = res0; res; res = res->ai_next) {
Guido van Rossum716aac02001-10-12 18:59:27 +00003556 PyObject *addr =
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00003557 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
Guido van Rossum716aac02001-10-12 18:59:27 +00003558 if (addr == NULL)
3559 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003560 single = Py_BuildValue("iiisO", res->ai_family,
3561 res->ai_socktype, res->ai_protocol,
3562 res->ai_canonname ? res->ai_canonname : "",
Guido van Rossum716aac02001-10-12 18:59:27 +00003563 addr);
3564 Py_DECREF(addr);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003565 if (single == NULL)
3566 goto err;
3567
3568 if (PyList_Append(all, single))
3569 goto err;
3570 Py_XDECREF(single);
3571 }
Martin v. Löwis2548c732003-04-18 10:39:54 +00003572 Py_XDECREF(idna);
Neal Norwitz90128ba2002-08-09 03:37:42 +00003573 if (res0)
3574 freeaddrinfo(res0);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003575 return all;
3576 err:
3577 Py_XDECREF(single);
3578 Py_XDECREF(all);
Martin v. Löwis2548c732003-04-18 10:39:54 +00003579 Py_XDECREF(idna);
Martin v. Löwisf0b11d22001-11-07 08:31:03 +00003580 if (res0)
3581 freeaddrinfo(res0);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003582 return (PyObject *)NULL;
3583}
3584
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003585PyDoc_STRVAR(getaddrinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003586"getaddrinfo(host, port [, family, socktype, proto, flags])\n\
3587 -> list of (family, socktype, proto, canonname, sockaddr)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003588\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003589Resolve host and port into addrinfo struct.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003590
3591/* Python interface to getnameinfo(sa, flags). */
3592
3593/*ARGSUSED*/
3594static PyObject *
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003595socket_getnameinfo(PyObject *self, PyObject *args)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003596{
3597 PyObject *sa = (PyObject *)NULL;
3598 int flags;
3599 char *hostp;
Martin v. Löwis06b1d212001-11-02 23:34:52 +00003600 int port, flowinfo, scope_id;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003601 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
3602 struct addrinfo hints, *res = NULL;
3603 int error;
3604 PyObject *ret = (PyObject *)NULL;
3605
3606 flags = flowinfo = scope_id = 0;
Martin v. Löwis06b1d212001-11-02 23:34:52 +00003607 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003608 return NULL;
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003609 if (!PyArg_ParseTuple(sa, "si|ii",
3610 &hostp, &port, &flowinfo, &scope_id))
Martin v. Löwis06b1d212001-11-02 23:34:52 +00003611 return NULL;
Marc-André Lemburg03d1b182001-07-31 18:05:33 +00003612 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003613 memset(&hints, 0, sizeof(hints));
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00003614 hints.ai_family = AF_UNSPEC;
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003615 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Just van Rossum1040d2c2003-05-09 07:53:18 +00003616 Py_BEGIN_ALLOW_THREADS
3617 ACQUIRE_GETADDRINFO_LOCK
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003618 error = getaddrinfo(hostp, pbuf, &hints, &res);
Just van Rossum1040d2c2003-05-09 07:53:18 +00003619 Py_END_ALLOW_THREADS
3620 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003621 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003622 set_gaierror(error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003623 goto fail;
3624 }
3625 if (res->ai_next) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003626 PyErr_SetString(socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003627 "sockaddr resolved to multiple addresses");
3628 goto fail;
3629 }
3630 switch (res->ai_family) {
3631 case AF_INET:
3632 {
3633 char *t1;
3634 int t2;
3635 if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003636 PyErr_SetString(socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003637 "IPv4 sockaddr must be 2 tuple");
3638 goto fail;
3639 }
3640 break;
3641 }
Martin v. Löwis44ddbde2001-12-02 10:15:37 +00003642#ifdef ENABLE_IPV6
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003643 case AF_INET6:
3644 {
3645 struct sockaddr_in6 *sin6;
3646 sin6 = (struct sockaddr_in6 *)res->ai_addr;
3647 sin6->sin6_flowinfo = flowinfo;
3648 sin6->sin6_scope_id = scope_id;
3649 break;
3650 }
3651#endif
3652 }
3653 error = getnameinfo(res->ai_addr, res->ai_addrlen,
3654 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
3655 if (error) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003656 set_gaierror(error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003657 goto fail;
3658 }
3659 ret = Py_BuildValue("ss", hbuf, pbuf);
3660
3661fail:
3662 if (res)
3663 freeaddrinfo(res);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003664 return ret;
3665}
3666
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003667PyDoc_STRVAR(getnameinfo_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003668"getnameinfo(sockaddr, flags) --> (host, port)\n\
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003669\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003670Get host and port for a sockaddr.");
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003671
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00003672
3673/* Python API to getting and setting the default timeout value. */
3674
3675static PyObject *
3676socket_getdefaulttimeout(PyObject *self)
3677{
3678 if (defaulttimeout < 0.0) {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 else
3683 return PyFloat_FromDouble(defaulttimeout);
3684}
3685
3686PyDoc_STRVAR(getdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003687"getdefaulttimeout() -> timeout\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00003688\n\
3689Returns the default timeout in floating seconds for new socket objects.\n\
3690A value of None indicates that new socket objects have no timeout.\n\
3691When the socket module is first imported, the default is None.");
3692
3693static PyObject *
3694socket_setdefaulttimeout(PyObject *self, PyObject *arg)
3695{
3696 double timeout;
3697
3698 if (arg == Py_None)
3699 timeout = -1.0;
3700 else {
3701 timeout = PyFloat_AsDouble(arg);
3702 if (timeout < 0.0) {
3703 if (!PyErr_Occurred())
3704 PyErr_SetString(PyExc_ValueError,
3705 "Timeout value out of range");
3706 return NULL;
3707 }
3708 }
3709
3710 defaulttimeout = timeout;
3711
3712 Py_INCREF(Py_None);
3713 return Py_None;
3714}
3715
3716PyDoc_STRVAR(setdefaulttimeout_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003717"setdefaulttimeout(timeout)\n\
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00003718\n\
3719Set the default timeout in floating seconds for new socket objects.\n\
3720A value of None indicates that new socket objects have no timeout.\n\
3721When the socket module is first imported, the default is None.");
3722
3723
Guido van Rossum30a685f1991-06-27 15:51:29 +00003724/* List of functions exported by this module. */
3725
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003726static PyMethodDef socket_methods[] = {
3727 {"gethostbyname", socket_gethostbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003728 METH_VARARGS, gethostbyname_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003729 {"gethostbyname_ex", socket_gethostbyname_ex,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003730 METH_VARARGS, ghbn_ex_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003731 {"gethostbyaddr", socket_gethostbyaddr,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003732 METH_VARARGS, gethostbyaddr_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003733 {"gethostname", socket_gethostname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003734 METH_VARARGS, gethostname_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003735 {"getservbyname", socket_getservbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003736 METH_VARARGS, getservbyname_doc},
Barry Warsaw11b91a02004-06-28 00:50:43 +00003737 {"getservbyport", socket_getservbyport,
3738 METH_VARARGS, getservbyport_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003739 {"getprotobyname", socket_getprotobyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003740 METH_VARARGS,getprotobyname_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00003741#ifndef NO_DUP
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003742 {"fromfd", socket_fromfd,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003743 METH_VARARGS, fromfd_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00003744#endif
Dave Cole331708b2004-08-09 04:51:41 +00003745#ifdef HAVE_SOCKETPAIR
3746 {"socketpair", socket_socketpair,
3747 METH_VARARGS, socketpair_doc},
3748#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003749 {"ntohs", socket_ntohs,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003750 METH_VARARGS, ntohs_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003751 {"ntohl", socket_ntohl,
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003752 METH_O, ntohl_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003753 {"htons", socket_htons,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003754 METH_VARARGS, htons_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003755 {"htonl", socket_htonl,
Jeremy Hyltonc075e192002-07-25 16:01:12 +00003756 METH_O, htonl_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003757 {"inet_aton", socket_inet_aton,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003758 METH_VARARGS, inet_aton_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003759 {"inet_ntoa", socket_inet_ntoa,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00003760 METH_VARARGS, inet_ntoa_doc},
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003761#ifdef HAVE_INET_PTON
3762 {"inet_pton", socket_inet_pton,
3763 METH_VARARGS, inet_pton_doc},
3764 {"inet_ntop", socket_inet_ntop,
3765 METH_VARARGS, inet_ntop_doc},
3766#endif
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003767 {"getaddrinfo", socket_getaddrinfo,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003768 METH_VARARGS, getaddrinfo_doc},
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003769 {"getnameinfo", socket_getnameinfo,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003770 METH_VARARGS, getnameinfo_doc},
Guido van Rossum1693ba82002-07-18 21:11:26 +00003771 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00003772 METH_NOARGS, getdefaulttimeout_doc},
3773 {"setdefaulttimeout", socket_setdefaulttimeout,
3774 METH_O, setdefaulttimeout_doc},
Guido van Rossum30a685f1991-06-27 15:51:29 +00003775 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003776};
3777
Guido van Rossum30a685f1991-06-27 15:51:29 +00003778
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003779#ifdef RISCOS
3780#define OS_INIT_DEFINED
Guido van Rossumbe32c891996-06-20 16:25:29 +00003781
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003782static int
3783os_init(void)
3784{
3785 _kernel_swi_regs r;
3786
3787 r.r[0] = 0;
3788 _kernel_swi(0x43380, &r, &r);
3789 taskwindow = r.r[0];
3790
Martin v. Löwisa94568a2003-05-10 07:36:56 +00003791 return 1;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003792}
3793
3794#endif /* RISCOS */
3795
3796
3797#ifdef MS_WINDOWS
3798#define OS_INIT_DEFINED
3799
3800/* Additional initialization and cleanup for Windows */
Guido van Rossumbe32c891996-06-20 16:25:29 +00003801
3802static void
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003803os_cleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00003804{
3805 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00003806}
3807
3808static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003809os_init(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00003810{
3811 WSADATA WSAData;
3812 int ret;
3813 char buf[100];
3814 ret = WSAStartup(0x0101, &WSAData);
3815 switch (ret) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003816 case 0: /* No error */
Mark Hammond14350ab2003-07-09 04:57:46 +00003817 Py_AtExit(os_cleanup);
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003818 return 1; /* Success */
Guido van Rossumbe32c891996-06-20 16:25:29 +00003819 case WSASYSNOTREADY:
3820 PyErr_SetString(PyExc_ImportError,
3821 "WSAStartup failed: network not ready");
3822 break;
3823 case WSAVERNOTSUPPORTED:
3824 case WSAEINVAL:
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003825 PyErr_SetString(
3826 PyExc_ImportError,
3827 "WSAStartup failed: requested version not supported");
Guido van Rossumbe32c891996-06-20 16:25:29 +00003828 break;
3829 default:
Tim Peters885d4572001-11-28 20:27:42 +00003830 PyOS_snprintf(buf, sizeof(buf),
3831 "WSAStartup failed: error code %d", ret);
Guido van Rossumbe32c891996-06-20 16:25:29 +00003832 PyErr_SetString(PyExc_ImportError, buf);
3833 break;
3834 }
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003835 return 0; /* Failure */
Guido van Rossumbe32c891996-06-20 16:25:29 +00003836}
3837
Guido van Rossum8d665e61996-06-26 18:22:49 +00003838#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00003839
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003840
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003841#ifdef PYOS_OS2
3842#define OS_INIT_DEFINED
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003843
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003844/* Additional initialization for OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003845
3846static int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003847os_init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003848{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003849#ifndef PYCC_GCC
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003850 char reason[64];
3851 int rc = sock_init();
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003852
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003853 if (rc == 0) {
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003854 return 1; /* Success */
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003855 }
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003856
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003857 PyOS_snprintf(reason, sizeof(reason),
3858 "OS/2 TCP/IP Error# %d", sock_errno());
3859 PyErr_SetString(PyExc_ImportError, reason);
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003860
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003861 return 0; /* Failure */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00003862#else
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003863 /* No need to initialise sockets with GCC/EMX */
3864 return 1; /* Success */
Andrew MacIntyreba43e872002-03-03 03:03:52 +00003865#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003866}
3867
3868#endif /* PYOS_OS2 */
3869
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003870
3871#ifndef OS_INIT_DEFINED
3872static int
3873os_init(void)
3874{
3875 return 1; /* Success */
3876}
3877#endif
3878
3879
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00003880/* C API table - always add new things to the end for binary
3881 compatibility. */
3882static
3883PySocketModule_APIObject PySocketModuleAPI =
3884{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003885 &sock_type,
Brett Cannon06c34792004-03-23 23:16:54 +00003886 NULL
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00003887};
3888
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003889
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003890/* Initialize the _socket module.
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003891
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003892 This module is actually called "_socket", and there's a wrapper
3893 "socket.py" which implements some additional functionality. On some
3894 platforms (e.g. Windows and OS/2), socket.py also implements a
3895 wrapper for the socket type that provides missing functionality such
3896 as makefile(), dup() and fromfd(). The import of "_socket" may fail
3897 with an ImportError exception if os-specific initialization fails.
3898 On Windows, this does WINSOCK initialization. When WINSOCK is
3899 initialized succesfully, a call to WSACleanup() is scheduled to be
3900 made at exit time.
3901*/
Guido van Rossum3eede5a2002-06-07 02:08:35 +00003902
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00003903PyDoc_STRVAR(socket_doc,
Guido van Rossum22a97152002-08-08 20:37:08 +00003904"Implementation module for socket operations.\n\
3905\n\
3906See the socket module for documentation.");
Guido van Rossum82a5c661998-07-07 20:45:43 +00003907
Mark Hammondfe51c6d2002-08-02 02:27:13 +00003908PyMODINIT_FUNC
Thomas Wouters1e0c2f42000-07-24 16:06:23 +00003909init_socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003910{
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003911 PyObject *m, *has_ipv6;
Fred Drake4baedc12002-04-01 14:53:37 +00003912
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003913 if (!os_init())
Guido van Rossum0cb96de1997-10-01 04:29:29 +00003914 return;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003915
3916 sock_type.ob_type = &PyType_Type;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003917 m = Py_InitModule3(PySocket_MODULE_NAME,
3918 socket_methods,
3919 socket_doc);
Neal Norwitz1ac754f2006-01-19 06:09:39 +00003920 if (m == NULL)
3921 return;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003922
3923 socket_error = PyErr_NewException("socket.error", NULL, NULL);
3924 if (socket_error == NULL)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003925 return;
Brett Cannon06c34792004-03-23 23:16:54 +00003926 PySocketModuleAPI.error = socket_error;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003927 Py_INCREF(socket_error);
3928 PyModule_AddObject(m, "error", socket_error);
3929 socket_herror = PyErr_NewException("socket.herror",
3930 socket_error, NULL);
3931 if (socket_herror == NULL)
3932 return;
3933 Py_INCREF(socket_herror);
3934 PyModule_AddObject(m, "herror", socket_herror);
3935 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003936 NULL);
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003937 if (socket_gaierror == NULL)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003938 return;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003939 Py_INCREF(socket_gaierror);
3940 PyModule_AddObject(m, "gaierror", socket_gaierror);
Raymond Hettingeref7343c2003-06-29 03:08:05 +00003941 socket_timeout = PyErr_NewException("socket.timeout",
3942 socket_error, NULL);
3943 if (socket_timeout == NULL)
3944 return;
3945 Py_INCREF(socket_timeout);
3946 PyModule_AddObject(m, "timeout", socket_timeout);
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003947 Py_INCREF((PyObject *)&sock_type);
Fred Drake4baedc12002-04-01 14:53:37 +00003948 if (PyModule_AddObject(m, "SocketType",
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003949 (PyObject *)&sock_type) != 0)
Guido van Rossum0cb96de1997-10-01 04:29:29 +00003950 return;
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003951 Py_INCREF((PyObject *)&sock_type);
Fred Drake4baedc12002-04-01 14:53:37 +00003952 if (PyModule_AddObject(m, "socket",
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00003953 (PyObject *)&sock_type) != 0)
Guido van Rossum384ca9c2001-10-27 22:20:47 +00003954 return;
Guido van Rossum09be4091999-08-09 14:40:40 +00003955
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00003956#ifdef ENABLE_IPV6
3957 has_ipv6 = Py_True;
3958#else
3959 has_ipv6 = Py_False;
3960#endif
3961 Py_INCREF(has_ipv6);
3962 PyModule_AddObject(m, "has_ipv6", has_ipv6);
3963
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00003964 /* Export C API */
Fred Drake4baedc12002-04-01 14:53:37 +00003965 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
Marc-André Lemburga5d2b4c2002-02-16 18:23:30 +00003966 PyCObject_FromVoidPtr((void *)&PySocketModuleAPI, NULL)
3967 ) != 0)
3968 return;
3969
Guido van Rossum09be4091999-08-09 14:40:40 +00003970 /* Address families (we only support AF_INET and AF_UNIX) */
3971#ifdef AF_UNSPEC
Fred Drake4baedc12002-04-01 14:53:37 +00003972 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
Guido van Rossum09be4091999-08-09 14:40:40 +00003973#endif
Fred Drake4baedc12002-04-01 14:53:37 +00003974 PyModule_AddIntConstant(m, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003975#ifdef AF_INET6
Fred Drake4baedc12002-04-01 14:53:37 +00003976 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003977#endif /* AF_INET6 */
Andrew MacIntyred12dfbb2004-04-04 07:13:49 +00003978#if defined(AF_UNIX)
Fred Drake4baedc12002-04-01 14:53:37 +00003979 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00003980#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00003981#ifdef AF_AX25
Fred Drake4baedc12002-04-01 14:53:37 +00003982 /* Amateur Radio AX.25 */
3983 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00003984#endif
3985#ifdef AF_IPX
Fred Drake4baedc12002-04-01 14:53:37 +00003986 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
Guido van Rossum09be4091999-08-09 14:40:40 +00003987#endif
3988#ifdef AF_APPLETALK
Fred Drake4baedc12002-04-01 14:53:37 +00003989 /* Appletalk DDP */
3990 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00003991#endif
3992#ifdef AF_NETROM
Fred Drake4baedc12002-04-01 14:53:37 +00003993 /* Amateur radio NetROM */
3994 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00003995#endif
3996#ifdef AF_BRIDGE
Fred Drake4baedc12002-04-01 14:53:37 +00003997 /* Multiprotocol bridge */
3998 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
Guido van Rossum09be4091999-08-09 14:40:40 +00003999#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004000#ifdef AF_ATMPVC
4001 /* ATM PVCs */
4002 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
4003#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004004#ifdef AF_AAL5
Fred Drake4baedc12002-04-01 14:53:37 +00004005 /* Reserved for Werner's ATM */
4006 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
Guido van Rossum09be4091999-08-09 14:40:40 +00004007#endif
4008#ifdef AF_X25
Fred Drake4baedc12002-04-01 14:53:37 +00004009 /* Reserved for X.25 project */
4010 PyModule_AddIntConstant(m, "AF_X25", AF_X25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004011#endif
4012#ifdef AF_INET6
Fred Drake4baedc12002-04-01 14:53:37 +00004013 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
Guido van Rossum09be4091999-08-09 14:40:40 +00004014#endif
4015#ifdef AF_ROSE
Fred Drake4baedc12002-04-01 14:53:37 +00004016 /* Amateur Radio X.25 PLP */
4017 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004018#endif
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004019#ifdef AF_DECnet
4020 /* Reserved for DECnet project */
4021 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
4022#endif
4023#ifdef AF_NETBEUI
4024 /* Reserved for 802.2LLC project */
4025 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
4026#endif
4027#ifdef AF_SECURITY
4028 /* Security callback pseudo AF */
4029 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
4030#endif
4031#ifdef AF_KEY
4032 /* PF_KEY key management API */
4033 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
4034#endif
4035#ifdef AF_NETLINK
4036 /* */
4037 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
Martin v. Löwis11017b12006-01-14 18:12:57 +00004038 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004039#ifdef NETLINK_SKIP
Martin v. Löwis11017b12006-01-14 18:12:57 +00004040 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004041#endif
4042#ifdef NETLINK_W1
4043 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
4044#endif
Martin v. Löwis11017b12006-01-14 18:12:57 +00004045 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
4046 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004047#ifdef NETLINK_TCPDIAG
Martin v. Löwis11017b12006-01-14 18:12:57 +00004048 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004049#endif
4050#ifdef NETLINK_NFLOG
Martin v. Löwis11017b12006-01-14 18:12:57 +00004051 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
Guido van Rossum668a94a2006-02-21 01:07:27 +00004052#endif
Neal Norwitz65851662006-01-16 04:31:40 +00004053#ifdef NETLINK_XFRM
Martin v. Löwis11017b12006-01-14 18:12:57 +00004054 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
Neal Norwitz65851662006-01-16 04:31:40 +00004055#endif
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004056#ifdef NETLINK_ARPD
Martin v. Löwis11017b12006-01-14 18:12:57 +00004057 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004058#endif
4059#ifdef NETLINK_ROUTE6
Martin v. Löwis11017b12006-01-14 18:12:57 +00004060 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004061#endif
Martin v. Löwis11017b12006-01-14 18:12:57 +00004062 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
4063 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004064#ifdef NETLINK_TAPBASE
Martin v. Löwis11017b12006-01-14 18:12:57 +00004065 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
Martin v. Löwis5fe60e72006-04-06 22:29:33 +00004066#endif
Georg Brandldcfdae72006-04-01 07:33:08 +00004067#endif /* AF_NETLINK */
Martin v. Löwis81aec4b2004-07-19 17:01:20 +00004068#ifdef AF_ROUTE
4069 /* Alias to emulate 4.4BSD */
4070 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
4071#endif
4072#ifdef AF_ASH
4073 /* Ash */
4074 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
4075#endif
4076#ifdef AF_ECONET
4077 /* Acorn Econet */
4078 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
4079#endif
4080#ifdef AF_ATMSVC
4081 /* ATM SVCs */
4082 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
4083#endif
4084#ifdef AF_SNA
4085 /* Linux SNA Project (nutters!) */
4086 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
4087#endif
4088#ifdef AF_IRDA
4089 /* IRDA sockets */
4090 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
4091#endif
4092#ifdef AF_PPPOX
4093 /* PPPoX sockets */
4094 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
4095#endif
4096#ifdef AF_WANPIPE
4097 /* Wanpipe API Sockets */
4098 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
4099#endif
4100#ifdef AF_LLC
4101 /* Linux LLC */
4102 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
4103#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00004104
Hye-Shik Chang81268602004-02-02 06:05:24 +00004105#ifdef USE_BLUETOOTH
Martin v. Löwis12af0482004-01-31 12:34:17 +00004106 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
4107 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
Hye-Shik Chang81268602004-02-02 06:05:24 +00004108#if !defined(__FreeBSD__)
Martin v. Löwis12af0482004-01-31 12:34:17 +00004109 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
Hye-Shik Chang81268602004-02-02 06:05:24 +00004110#endif
Martin v. Löwis12af0482004-01-31 12:34:17 +00004111 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
Martin v. Löwis558d9bf2004-06-03 09:24:42 +00004112 PyModule_AddObject(m, "BDADDR_ANY", Py_BuildValue("s", "00:00:00:00:00:00"));
4113 PyModule_AddObject(m, "BDADDR_LOCAL", Py_BuildValue("s", "00:00:00:FF:FF:FF"));
Martin v. Löwis12af0482004-01-31 12:34:17 +00004114#endif
4115
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00004116#ifdef HAVE_NETPACKET_PACKET_H
Fred Drake4baedc12002-04-01 14:53:37 +00004117 PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
4118 PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
4119 PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
4120 PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
4121 PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
4122 PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
4123 PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
4124 PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
4125 PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00004126#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004127
4128 /* Socket types */
Fred Drake4baedc12002-04-01 14:53:37 +00004129 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
4130 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004131#ifndef __BEOS__
4132/* We have incomplete socket support. */
Fred Drake4baedc12002-04-01 14:53:37 +00004133 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
4134 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00004135#if defined(SOCK_RDM)
Fred Drake4baedc12002-04-01 14:53:37 +00004136 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00004137#endif
Martin v. Löwiscf8f47e2002-12-11 13:10:57 +00004138#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004139
4140#ifdef SO_DEBUG
Fred Drake4baedc12002-04-01 14:53:37 +00004141 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004142#endif
4143#ifdef SO_ACCEPTCONN
Fred Drake4baedc12002-04-01 14:53:37 +00004144 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004145#endif
4146#ifdef SO_REUSEADDR
Fred Drake4baedc12002-04-01 14:53:37 +00004147 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004148#endif
Andrew M. Kuchling42851ab2004-07-10 14:19:21 +00004149#ifdef SO_EXCLUSIVEADDRUSE
4150 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
4151#endif
4152
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004153#ifdef SO_KEEPALIVE
Fred Drake4baedc12002-04-01 14:53:37 +00004154 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004155#endif
4156#ifdef SO_DONTROUTE
Fred Drake4baedc12002-04-01 14:53:37 +00004157 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004158#endif
4159#ifdef SO_BROADCAST
Fred Drake4baedc12002-04-01 14:53:37 +00004160 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004161#endif
4162#ifdef SO_USELOOPBACK
Fred Drake4baedc12002-04-01 14:53:37 +00004163 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004164#endif
4165#ifdef SO_LINGER
Fred Drake4baedc12002-04-01 14:53:37 +00004166 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004167#endif
4168#ifdef SO_OOBINLINE
Fred Drake4baedc12002-04-01 14:53:37 +00004169 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004170#endif
4171#ifdef SO_REUSEPORT
Fred Drake4baedc12002-04-01 14:53:37 +00004172 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004173#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004174#ifdef SO_SNDBUF
Fred Drake4baedc12002-04-01 14:53:37 +00004175 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004176#endif
4177#ifdef SO_RCVBUF
Fred Drake4baedc12002-04-01 14:53:37 +00004178 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004179#endif
4180#ifdef SO_SNDLOWAT
Fred Drake4baedc12002-04-01 14:53:37 +00004181 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004182#endif
4183#ifdef SO_RCVLOWAT
Fred Drake4baedc12002-04-01 14:53:37 +00004184 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004185#endif
4186#ifdef SO_SNDTIMEO
Fred Drake4baedc12002-04-01 14:53:37 +00004187 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004188#endif
4189#ifdef SO_RCVTIMEO
Fred Drake4baedc12002-04-01 14:53:37 +00004190 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004191#endif
4192#ifdef SO_ERROR
Fred Drake4baedc12002-04-01 14:53:37 +00004193 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004194#endif
4195#ifdef SO_TYPE
Fred Drake4baedc12002-04-01 14:53:37 +00004196 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004197#endif
4198
4199 /* Maximum number of connections for "listen" */
4200#ifdef SOMAXCONN
Fred Drake4baedc12002-04-01 14:53:37 +00004201 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004202#else
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004203 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004204#endif
4205
4206 /* Flags for send, recv */
4207#ifdef MSG_OOB
Fred Drake4baedc12002-04-01 14:53:37 +00004208 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004209#endif
4210#ifdef MSG_PEEK
Fred Drake4baedc12002-04-01 14:53:37 +00004211 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004212#endif
4213#ifdef MSG_DONTROUTE
Fred Drake4baedc12002-04-01 14:53:37 +00004214 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004215#endif
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00004216#ifdef MSG_DONTWAIT
Fred Drake4baedc12002-04-01 14:53:37 +00004217 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00004218#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004219#ifdef MSG_EOR
Fred Drake4baedc12002-04-01 14:53:37 +00004220 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004221#endif
4222#ifdef MSG_TRUNC
Fred Drake4baedc12002-04-01 14:53:37 +00004223 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004224#endif
4225#ifdef MSG_CTRUNC
Fred Drake4baedc12002-04-01 14:53:37 +00004226 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004227#endif
4228#ifdef MSG_WAITALL
Fred Drake4baedc12002-04-01 14:53:37 +00004229 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004230#endif
4231#ifdef MSG_BTAG
Fred Drake4baedc12002-04-01 14:53:37 +00004232 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004233#endif
4234#ifdef MSG_ETAG
Fred Drake4baedc12002-04-01 14:53:37 +00004235 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004236#endif
4237
4238 /* Protocol level and numbers, usable for [gs]etsockopt */
4239#ifdef SOL_SOCKET
Fred Drake4baedc12002-04-01 14:53:37 +00004240 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004241#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004242#ifdef SOL_IP
Fred Drake4baedc12002-04-01 14:53:37 +00004243 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004244#else
Fred Drake4baedc12002-04-01 14:53:37 +00004245 PyModule_AddIntConstant(m, "SOL_IP", 0);
Guido van Rossum09be4091999-08-09 14:40:40 +00004246#endif
4247#ifdef SOL_IPX
Fred Drake4baedc12002-04-01 14:53:37 +00004248 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
Guido van Rossum09be4091999-08-09 14:40:40 +00004249#endif
4250#ifdef SOL_AX25
Fred Drake4baedc12002-04-01 14:53:37 +00004251 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
Guido van Rossum09be4091999-08-09 14:40:40 +00004252#endif
4253#ifdef SOL_ATALK
Fred Drake4baedc12002-04-01 14:53:37 +00004254 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
Guido van Rossum09be4091999-08-09 14:40:40 +00004255#endif
4256#ifdef SOL_NETROM
Fred Drake4baedc12002-04-01 14:53:37 +00004257 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
Guido van Rossum09be4091999-08-09 14:40:40 +00004258#endif
4259#ifdef SOL_ROSE
Fred Drake4baedc12002-04-01 14:53:37 +00004260 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004261#endif
4262#ifdef SOL_TCP
Fred Drake4baedc12002-04-01 14:53:37 +00004263 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004264#else
Fred Drake4baedc12002-04-01 14:53:37 +00004265 PyModule_AddIntConstant(m, "SOL_TCP", 6);
Guido van Rossum09be4091999-08-09 14:40:40 +00004266#endif
4267#ifdef SOL_UDP
Fred Drake4baedc12002-04-01 14:53:37 +00004268 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004269#else
Fred Drake4baedc12002-04-01 14:53:37 +00004270 PyModule_AddIntConstant(m, "SOL_UDP", 17);
Guido van Rossum09be4091999-08-09 14:40:40 +00004271#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004272#ifdef IPPROTO_IP
Fred Drake4baedc12002-04-01 14:53:37 +00004273 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00004274#else
Fred Drake4baedc12002-04-01 14:53:37 +00004275 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004276#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004277#ifdef IPPROTO_HOPOPTS
Fred Drake4baedc12002-04-01 14:53:37 +00004278 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004279#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004280#ifdef IPPROTO_ICMP
Fred Drake4baedc12002-04-01 14:53:37 +00004281 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00004282#else
Fred Drake4baedc12002-04-01 14:53:37 +00004283 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004284#endif
4285#ifdef IPPROTO_IGMP
Fred Drake4baedc12002-04-01 14:53:37 +00004286 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004287#endif
4288#ifdef IPPROTO_GGP
Fred Drake4baedc12002-04-01 14:53:37 +00004289 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004290#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004291#ifdef IPPROTO_IPV4
Fred Drake4baedc12002-04-01 14:53:37 +00004292 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004293#endif
Martin v. Löwisa0f17342003-10-03 13:56:20 +00004294#ifdef IPPROTO_IPV6
4295 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
4296#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004297#ifdef IPPROTO_IPIP
Fred Drake4baedc12002-04-01 14:53:37 +00004298 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004299#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004300#ifdef IPPROTO_TCP
Fred Drake4baedc12002-04-01 14:53:37 +00004301 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00004302#else
Fred Drake4baedc12002-04-01 14:53:37 +00004303 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004304#endif
4305#ifdef IPPROTO_EGP
Fred Drake4baedc12002-04-01 14:53:37 +00004306 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004307#endif
4308#ifdef IPPROTO_PUP
Fred Drake4baedc12002-04-01 14:53:37 +00004309 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004310#endif
4311#ifdef IPPROTO_UDP
Fred Drake4baedc12002-04-01 14:53:37 +00004312 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00004313#else
Fred Drake4baedc12002-04-01 14:53:37 +00004314 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004315#endif
4316#ifdef IPPROTO_IDP
Fred Drake4baedc12002-04-01 14:53:37 +00004317 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004318#endif
4319#ifdef IPPROTO_HELLO
Fred Drake4baedc12002-04-01 14:53:37 +00004320 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004321#endif
4322#ifdef IPPROTO_ND
Fred Drake4baedc12002-04-01 14:53:37 +00004323 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004324#endif
4325#ifdef IPPROTO_TP
Fred Drake4baedc12002-04-01 14:53:37 +00004326 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004327#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004328#ifdef IPPROTO_IPV6
Fred Drake4baedc12002-04-01 14:53:37 +00004329 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004330#endif
4331#ifdef IPPROTO_ROUTING
Fred Drake4baedc12002-04-01 14:53:37 +00004332 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004333#endif
4334#ifdef IPPROTO_FRAGMENT
Fred Drake4baedc12002-04-01 14:53:37 +00004335 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004336#endif
4337#ifdef IPPROTO_RSVP
Fred Drake4baedc12002-04-01 14:53:37 +00004338 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004339#endif
4340#ifdef IPPROTO_GRE
Fred Drake4baedc12002-04-01 14:53:37 +00004341 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004342#endif
4343#ifdef IPPROTO_ESP
Fred Drake4baedc12002-04-01 14:53:37 +00004344 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004345#endif
4346#ifdef IPPROTO_AH
Fred Drake4baedc12002-04-01 14:53:37 +00004347 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004348#endif
4349#ifdef IPPROTO_MOBILE
Fred Drake4baedc12002-04-01 14:53:37 +00004350 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004351#endif
4352#ifdef IPPROTO_ICMPV6
Fred Drake4baedc12002-04-01 14:53:37 +00004353 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004354#endif
4355#ifdef IPPROTO_NONE
Fred Drake4baedc12002-04-01 14:53:37 +00004356 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004357#endif
4358#ifdef IPPROTO_DSTOPTS
Fred Drake4baedc12002-04-01 14:53:37 +00004359 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004360#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004361#ifdef IPPROTO_XTP
Fred Drake4baedc12002-04-01 14:53:37 +00004362 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004363#endif
4364#ifdef IPPROTO_EON
Fred Drake4baedc12002-04-01 14:53:37 +00004365 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004366#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004367#ifdef IPPROTO_PIM
Fred Drake4baedc12002-04-01 14:53:37 +00004368 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004369#endif
4370#ifdef IPPROTO_IPCOMP
Fred Drake4baedc12002-04-01 14:53:37 +00004371 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004372#endif
4373#ifdef IPPROTO_VRRP
Fred Drake4baedc12002-04-01 14:53:37 +00004374 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004375#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004376#ifdef IPPROTO_BIP
Fred Drake4baedc12002-04-01 14:53:37 +00004377 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004378#endif
4379/**/
4380#ifdef IPPROTO_RAW
Fred Drake4baedc12002-04-01 14:53:37 +00004381 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00004382#else
Fred Drake4baedc12002-04-01 14:53:37 +00004383 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004384#endif
4385#ifdef IPPROTO_MAX
Fred Drake4baedc12002-04-01 14:53:37 +00004386 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004387#endif
4388
4389 /* Some port configuration */
4390#ifdef IPPORT_RESERVED
Fred Drake4baedc12002-04-01 14:53:37 +00004391 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004392#else
Fred Drake4baedc12002-04-01 14:53:37 +00004393 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004394#endif
4395#ifdef IPPORT_USERRESERVED
Fred Drake4baedc12002-04-01 14:53:37 +00004396 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004397#else
Fred Drake4baedc12002-04-01 14:53:37 +00004398 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004399#endif
4400
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004401 /* Some reserved IP v.4 addresses */
4402#ifdef INADDR_ANY
Fred Drake4baedc12002-04-01 14:53:37 +00004403 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004404#else
Fred Drake4baedc12002-04-01 14:53:37 +00004405 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004406#endif
4407#ifdef INADDR_BROADCAST
Fred Drake4baedc12002-04-01 14:53:37 +00004408 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004409#else
Fred Drake4baedc12002-04-01 14:53:37 +00004410 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004411#endif
4412#ifdef INADDR_LOOPBACK
Fred Drake4baedc12002-04-01 14:53:37 +00004413 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004414#else
Fred Drake4baedc12002-04-01 14:53:37 +00004415 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004416#endif
4417#ifdef INADDR_UNSPEC_GROUP
Fred Drake4baedc12002-04-01 14:53:37 +00004418 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004419#else
Fred Drake4baedc12002-04-01 14:53:37 +00004420 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004421#endif
4422#ifdef INADDR_ALLHOSTS_GROUP
Fred Drake4baedc12002-04-01 14:53:37 +00004423 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
4424 INADDR_ALLHOSTS_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004425#else
Fred Drake4baedc12002-04-01 14:53:37 +00004426 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004427#endif
4428#ifdef INADDR_MAX_LOCAL_GROUP
Fred Drake4baedc12002-04-01 14:53:37 +00004429 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
4430 INADDR_MAX_LOCAL_GROUP);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004431#else
Fred Drake4baedc12002-04-01 14:53:37 +00004432 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004433#endif
4434#ifdef INADDR_NONE
Fred Drake4baedc12002-04-01 14:53:37 +00004435 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004436#else
Fred Drake4baedc12002-04-01 14:53:37 +00004437 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
Guido van Rossum5f05eb41995-02-17 15:11:07 +00004438#endif
4439
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004440 /* IPv4 [gs]etsockopt options */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004441#ifdef IP_OPTIONS
Fred Drake4baedc12002-04-01 14:53:37 +00004442 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004443#endif
4444#ifdef IP_HDRINCL
Fred Drake4baedc12002-04-01 14:53:37 +00004445 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004446#endif
4447#ifdef IP_TOS
Fred Drake4baedc12002-04-01 14:53:37 +00004448 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004449#endif
4450#ifdef IP_TTL
Fred Drake4baedc12002-04-01 14:53:37 +00004451 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004452#endif
4453#ifdef IP_RECVOPTS
Fred Drake4baedc12002-04-01 14:53:37 +00004454 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004455#endif
4456#ifdef IP_RECVRETOPTS
Fred Drake4baedc12002-04-01 14:53:37 +00004457 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004458#endif
4459#ifdef IP_RECVDSTADDR
Fred Drake4baedc12002-04-01 14:53:37 +00004460 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004461#endif
4462#ifdef IP_RETOPTS
Fred Drake4baedc12002-04-01 14:53:37 +00004463 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004464#endif
4465#ifdef IP_MULTICAST_IF
Fred Drake4baedc12002-04-01 14:53:37 +00004466 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004467#endif
4468#ifdef IP_MULTICAST_TTL
Fred Drake4baedc12002-04-01 14:53:37 +00004469 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004470#endif
4471#ifdef IP_MULTICAST_LOOP
Fred Drake4baedc12002-04-01 14:53:37 +00004472 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004473#endif
4474#ifdef IP_ADD_MEMBERSHIP
Fred Drake4baedc12002-04-01 14:53:37 +00004475 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004476#endif
4477#ifdef IP_DROP_MEMBERSHIP
Fred Drake4baedc12002-04-01 14:53:37 +00004478 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00004479#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00004480#ifdef IP_DEFAULT_MULTICAST_TTL
Fred Drake4baedc12002-04-01 14:53:37 +00004481 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
4482 IP_DEFAULT_MULTICAST_TTL);
Guido van Rossum09be4091999-08-09 14:40:40 +00004483#endif
4484#ifdef IP_DEFAULT_MULTICAST_LOOP
Fred Drake4baedc12002-04-01 14:53:37 +00004485 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
4486 IP_DEFAULT_MULTICAST_LOOP);
Guido van Rossum09be4091999-08-09 14:40:40 +00004487#endif
4488#ifdef IP_MAX_MEMBERSHIPS
Fred Drake4baedc12002-04-01 14:53:37 +00004489 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
Guido van Rossum09be4091999-08-09 14:40:40 +00004490#endif
4491
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004492 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
4493#ifdef IPV6_JOIN_GROUP
Fred Drake4baedc12002-04-01 14:53:37 +00004494 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004495#endif
4496#ifdef IPV6_LEAVE_GROUP
Fred Drake4baedc12002-04-01 14:53:37 +00004497 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004498#endif
4499#ifdef IPV6_MULTICAST_HOPS
Fred Drake4baedc12002-04-01 14:53:37 +00004500 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004501#endif
4502#ifdef IPV6_MULTICAST_IF
Fred Drake4baedc12002-04-01 14:53:37 +00004503 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004504#endif
4505#ifdef IPV6_MULTICAST_LOOP
Fred Drake4baedc12002-04-01 14:53:37 +00004506 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004507#endif
4508#ifdef IPV6_UNICAST_HOPS
Fred Drake4baedc12002-04-01 14:53:37 +00004509 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004510#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00004511 /* Additional IPV6 socket options, defined in RFC 3493 */
4512#ifdef IPV6_V6ONLY
4513 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
4514#endif
4515 /* Advanced IPV6 socket options, from RFC 3542 */
4516#ifdef IPV6_CHECKSUM
4517 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
4518#endif
4519#ifdef IPV6_DONTFRAG
4520 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
4521#endif
4522#ifdef IPV6_DSTOPTS
4523 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
4524#endif
4525#ifdef IPV6_HOPLIMIT
4526 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
4527#endif
4528#ifdef IPV6_HOPOPTS
4529 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
4530#endif
4531#ifdef IPV6_NEXTHOP
4532 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
4533#endif
4534#ifdef IPV6_PATHMTU
4535 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
4536#endif
4537#ifdef IPV6_PKTINFO
4538 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
4539#endif
4540#ifdef IPV6_RECVDSTOPTS
4541 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
4542#endif
4543#ifdef IPV6_RECVHOPLIMIT
4544 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
4545#endif
4546#ifdef IPV6_RECVHOPOPTS
4547 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
4548#endif
4549#ifdef IPV6_RECVPKTINFO
4550 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
4551#endif
4552#ifdef IPV6_RECVRTHDR
4553 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
4554#endif
4555#ifdef IPV6_RECVTCLASS
4556 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
4557#endif
4558#ifdef IPV6_RTHDR
4559 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
4560#endif
4561#ifdef IPV6_RTHDRDSTOPTS
4562 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
4563#endif
4564#ifdef IPV6_RTHDR_TYPE_0
4565 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
4566#endif
4567#ifdef IPV6_RECVPATHMTU
4568 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
4569#endif
4570#ifdef IPV6_TCLASS
4571 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
4572#endif
4573#ifdef IPV6_USE_MIN_MTU
4574 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
4575#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00004576
Guido van Rossum09be4091999-08-09 14:40:40 +00004577 /* TCP options */
4578#ifdef TCP_NODELAY
Fred Drake4baedc12002-04-01 14:53:37 +00004579 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
Guido van Rossum09be4091999-08-09 14:40:40 +00004580#endif
4581#ifdef TCP_MAXSEG
Fred Drake4baedc12002-04-01 14:53:37 +00004582 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
Guido van Rossum09be4091999-08-09 14:40:40 +00004583#endif
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004584#ifdef TCP_CORK
Fred Drake4baedc12002-04-01 14:53:37 +00004585 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004586#endif
4587#ifdef TCP_KEEPIDLE
Fred Drake4baedc12002-04-01 14:53:37 +00004588 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004589#endif
4590#ifdef TCP_KEEPINTVL
Fred Drake4baedc12002-04-01 14:53:37 +00004591 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004592#endif
4593#ifdef TCP_KEEPCNT
Fred Drake4baedc12002-04-01 14:53:37 +00004594 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004595#endif
4596#ifdef TCP_SYNCNT
Fred Drake4baedc12002-04-01 14:53:37 +00004597 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004598#endif
4599#ifdef TCP_LINGER2
Fred Drake4baedc12002-04-01 14:53:37 +00004600 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004601#endif
4602#ifdef TCP_DEFER_ACCEPT
Fred Drake4baedc12002-04-01 14:53:37 +00004603 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004604#endif
4605#ifdef TCP_WINDOW_CLAMP
Fred Drake4baedc12002-04-01 14:53:37 +00004606 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004607#endif
4608#ifdef TCP_INFO
Fred Drake4baedc12002-04-01 14:53:37 +00004609 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004610#endif
4611#ifdef TCP_QUICKACK
Fred Drake4baedc12002-04-01 14:53:37 +00004612 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
Martin v. Löwis3cde2cb2001-12-22 15:05:32 +00004613#endif
4614
Guido van Rossum09be4091999-08-09 14:40:40 +00004615
4616 /* IPX options */
4617#ifdef IPX_TYPE
Fred Drake4baedc12002-04-01 14:53:37 +00004618 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
Guido van Rossum09be4091999-08-09 14:40:40 +00004619#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004620
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004621 /* get{addr,name}info parameters */
4622#ifdef EAI_ADDRFAMILY
Fred Drake4baedc12002-04-01 14:53:37 +00004623 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004624#endif
4625#ifdef EAI_AGAIN
Fred Drake4baedc12002-04-01 14:53:37 +00004626 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004627#endif
4628#ifdef EAI_BADFLAGS
Fred Drake4baedc12002-04-01 14:53:37 +00004629 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004630#endif
4631#ifdef EAI_FAIL
Fred Drake4baedc12002-04-01 14:53:37 +00004632 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004633#endif
4634#ifdef EAI_FAMILY
Fred Drake4baedc12002-04-01 14:53:37 +00004635 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004636#endif
4637#ifdef EAI_MEMORY
Fred Drake4baedc12002-04-01 14:53:37 +00004638 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004639#endif
4640#ifdef EAI_NODATA
Fred Drake4baedc12002-04-01 14:53:37 +00004641 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004642#endif
4643#ifdef EAI_NONAME
Fred Drake4baedc12002-04-01 14:53:37 +00004644 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004645#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00004646#ifdef EAI_OVERFLOW
4647 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
4648#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004649#ifdef EAI_SERVICE
Fred Drake4baedc12002-04-01 14:53:37 +00004650 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004651#endif
4652#ifdef EAI_SOCKTYPE
Fred Drake4baedc12002-04-01 14:53:37 +00004653 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004654#endif
4655#ifdef EAI_SYSTEM
Fred Drake4baedc12002-04-01 14:53:37 +00004656 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004657#endif
4658#ifdef EAI_BADHINTS
Fred Drake4baedc12002-04-01 14:53:37 +00004659 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004660#endif
4661#ifdef EAI_PROTOCOL
Fred Drake4baedc12002-04-01 14:53:37 +00004662 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004663#endif
4664#ifdef EAI_MAX
Fred Drake4baedc12002-04-01 14:53:37 +00004665 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004666#endif
4667#ifdef AI_PASSIVE
Fred Drake4baedc12002-04-01 14:53:37 +00004668 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004669#endif
4670#ifdef AI_CANONNAME
Fred Drake4baedc12002-04-01 14:53:37 +00004671 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004672#endif
4673#ifdef AI_NUMERICHOST
Fred Drake4baedc12002-04-01 14:53:37 +00004674 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004675#endif
Martin v. Löwisda91d022003-12-30 11:14:01 +00004676#ifdef AI_NUMERICSERV
4677 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
4678#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004679#ifdef AI_MASK
Fred Drake4baedc12002-04-01 14:53:37 +00004680 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004681#endif
4682#ifdef AI_ALL
Fred Drake4baedc12002-04-01 14:53:37 +00004683 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004684#endif
4685#ifdef AI_V4MAPPED_CFG
Fred Drake4baedc12002-04-01 14:53:37 +00004686 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004687#endif
4688#ifdef AI_ADDRCONFIG
Fred Drake4baedc12002-04-01 14:53:37 +00004689 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004690#endif
4691#ifdef AI_V4MAPPED
Fred Drake4baedc12002-04-01 14:53:37 +00004692 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004693#endif
4694#ifdef AI_DEFAULT
Fred Drake4baedc12002-04-01 14:53:37 +00004695 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004696#endif
4697#ifdef NI_MAXHOST
Fred Drake4baedc12002-04-01 14:53:37 +00004698 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004699#endif
4700#ifdef NI_MAXSERV
Fred Drake4baedc12002-04-01 14:53:37 +00004701 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004702#endif
4703#ifdef NI_NOFQDN
Fred Drake4baedc12002-04-01 14:53:37 +00004704 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004705#endif
4706#ifdef NI_NUMERICHOST
Fred Drake4baedc12002-04-01 14:53:37 +00004707 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004708#endif
4709#ifdef NI_NAMEREQD
Fred Drake4baedc12002-04-01 14:53:37 +00004710 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004711#endif
4712#ifdef NI_NUMERICSERV
Fred Drake4baedc12002-04-01 14:53:37 +00004713 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004714#endif
4715#ifdef NI_DGRAM
Fred Drake4baedc12002-04-01 14:53:37 +00004716 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00004717#endif
4718
Martin v. Löwis94681fc2003-11-27 19:40:22 +00004719 /* shutdown() parameters */
4720#ifdef SHUT_RD
4721 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
4722#elif defined(SD_RECEIVE)
4723 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
4724#else
4725 PyModule_AddIntConstant(m, "SHUT_RD", 0);
4726#endif
4727#ifdef SHUT_WR
4728 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
4729#elif defined(SD_SEND)
4730 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
4731#else
4732 PyModule_AddIntConstant(m, "SHUT_WR", 1);
4733#endif
4734#ifdef SHUT_RDWR
4735 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
4736#elif defined(SD_BOTH)
4737 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
4738#else
4739 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
4740#endif
4741
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004742 /* Initialize gethostbyname lock */
Just van Rossum1040d2c2003-05-09 07:53:18 +00004743#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
4744 netdb_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00004745#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00004746}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004747
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004748
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004749#ifndef HAVE_INET_PTON
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004750
4751/* Simplistic emulation code for inet_pton that only works for IPv4 */
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00004752/* These are not exposed because they do not set errno properly */
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004753
Guido van Rossum3eede5a2002-06-07 02:08:35 +00004754int
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004755inet_pton(int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004756{
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004757 if (af == AF_INET) {
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004758 long packed_addr;
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004759 packed_addr = inet_addr(src);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004760 if (packed_addr == INADDR_NONE)
4761 return 0;
4762 memcpy(dst, &packed_addr, 4);
4763 return 1;
4764 }
4765 /* Should set errno to EAFNOSUPPORT */
4766 return -1;
4767}
4768
Martin v. Löwisc925b1532001-07-21 09:42:15 +00004769const char *
4770inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004771{
4772 if (af == AF_INET) {
4773 struct in_addr packed_addr;
4774 if (size < 16)
4775 /* Should set errno to ENOSPC. */
4776 return NULL;
4777 memcpy(&packed_addr, src, sizeof(packed_addr));
4778 return strncpy(dst, inet_ntoa(packed_addr), size);
4779 }
4780 /* Should set errno to EAFNOSUPPORT */
4781 return NULL;
4782}
Guido van Rossumc4fcfa32002-06-07 03:19:37 +00004783
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00004784#endif