Added updates with respect to recent changes to TimedRotatingFileHandler.
[python.git] / Modules / socketmodule.c
blobe9568315d4f4b49b181e09f977103ea51762030d
1 /* Socket module */
3 /*
5 This module provides an interface to Berkeley socket IPC.
7 Limitations:
9 - Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
10 portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported
11 under Linux.
12 - No read/write operations (use sendall/recv or makefile instead).
13 - Additional restrictions apply on some non-Unix platforms (compensated
14 for by socket.py).
16 Module interface:
18 - socket.error: exception raised for socket specific errors
19 - socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
20 a subclass of socket.error
21 - socket.herror: exception raised for gethostby* errors,
22 a subclass of socket.error
23 - socket.fromfd(fd, family, type[, proto]) --> new socket object (created
24 from an existing file descriptor)
25 - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
26 - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
27 - socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
28 - socket.getprotobyname(protocolname) --> protocol number
29 - socket.getservbyname(servicename[, protocolname]) --> port number
30 - socket.getservbyport(portnumber[, protocolname]) --> service name
31 - socket.socket([family[, type [, proto]]]) --> new socket object
32 - socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
33 - socket.ntohs(16 bit value) --> new int object
34 - socket.ntohl(32 bit value) --> new int object
35 - socket.htons(16 bit value) --> new int object
36 - socket.htonl(32 bit value) --> new int object
37 - socket.getaddrinfo(host, port [, family, socktype, proto, flags])
38 --> List of (family, socktype, proto, canonname, sockaddr)
39 - socket.getnameinfo(sockaddr, flags) --> (host, port)
40 - socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
41 - socket.has_ipv6: boolean value indicating if IPv6 is supported
42 - socket.inet_aton(IP address) -> 32-bit packed IP representation
43 - socket.inet_ntoa(packed IP) -> IP address string
44 - socket.getdefaulttimeout() -> None | float
45 - socket.setdefaulttimeout(None | float)
46 - an Internet socket address is a pair (hostname, port)
47 where hostname can be anything recognized by gethostbyname()
48 (including the dd.dd.dd.dd notation) and port is in host byte order
49 - where a hostname is returned, the dd.dd.dd.dd notation is used
50 - a UNIX domain socket address is a string specifying the pathname
51 - an AF_PACKET socket address is a tuple containing a string
52 specifying the ethernet interface and an integer specifying
53 the Ethernet protocol number to be received. For example:
54 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
55 specify packet-type and ha-type/addr.
56 - an AF_TIPC socket address is expressed as
57 (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:
58 TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;
59 and scope can be one of:
60 TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.
61 The meaning of v1, v2 and v3 depends on the value of addr_type:
62 if addr_type is TIPC_ADDR_NAME:
63 v1 is the server type
64 v2 is the port identifier
65 v3 is ignored
66 if addr_type is TIPC_ADDR_NAMESEQ:
67 v1 is the server type
68 v2 is the lower port number
69 v3 is the upper port number
70 if addr_type is TIPC_ADDR_ID:
71 v1 is the node
72 v2 is the ref
73 v3 is ignored
76 Local naming conventions:
78 - names starting with sock_ are socket object methods
79 - names starting with socket_ are module-level functions
80 - names starting with PySocket are exported through socketmodule.h
84 #ifdef __APPLE__
86 * inet_aton is not available on OSX 10.3, yet we want to use a binary
87 * that was build on 10.4 or later to work on that release, weak linking
88 * comes to the rescue.
90 # pragma weak inet_aton
91 #endif
93 #include "Python.h"
94 #include "structmember.h"
96 #undef MAX
97 #define MAX(x, y) ((x) < (y) ? (y) : (x))
99 /* Socket object documentation */
100 PyDoc_STRVAR(sock_doc,
101 "socket([family[, type[, proto]]]) -> socket object\n\
103 Open a socket of the given type. The family argument specifies the\n\
104 address family; it defaults to AF_INET. The type argument specifies\n\
105 whether this is a stream (SOCK_STREAM, this is the default)\n\
106 or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
107 specifying the default protocol. Keyword arguments are accepted.\n\
109 A socket object represents one endpoint of a network connection.\n\
111 Methods of socket objects (keyword arguments not allowed):\n\
113 accept() -- accept a connection, returning new socket and client address\n\
114 bind(addr) -- bind the socket to a local address\n\
115 close() -- close the socket\n\
116 connect(addr) -- connect the socket to a remote address\n\
117 connect_ex(addr) -- connect, return an error code instead of an exception\n\
118 dup() -- return a new socket object identical to the current one [*]\n\
119 fileno() -- return underlying file descriptor\n\
120 getpeername() -- return remote address [*]\n\
121 getsockname() -- return local address\n\
122 getsockopt(level, optname[, buflen]) -- get socket options\n\
123 gettimeout() -- return timeout or None\n\
124 listen(n) -- start listening for incoming connections\n\
125 makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\
126 recv(buflen[, flags]) -- receive data\n\
127 recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
128 recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
129 recvfrom_into(buffer[, nbytes, [, flags])\n\
130 -- receive data and sender\'s address (into a buffer)\n\
131 sendall(data[, flags]) -- send all data\n\
132 send(data[, flags]) -- send data, may not send all of it\n\
133 sendto(data[, flags], addr) -- send data to a given address\n\
134 setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
135 setsockopt(level, optname, value) -- set socket options\n\
136 settimeout(None | float) -- set or clear the timeout\n\
137 shutdown(how) -- shut down traffic in one or both directions\n\
139 [*] not available on all platforms!");
141 /* XXX This is a terrible mess of platform-dependent preprocessor hacks.
142 I hope some day someone can clean this up please... */
144 /* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
145 script doesn't get this right, so we hardcode some platform checks below.
146 On the other hand, not all Linux versions agree, so there the settings
147 computed by the configure script are needed! */
149 #ifndef linux
150 # undef HAVE_GETHOSTBYNAME_R_3_ARG
151 # undef HAVE_GETHOSTBYNAME_R_5_ARG
152 # undef HAVE_GETHOSTBYNAME_R_6_ARG
153 #endif
155 #ifndef WITH_THREAD
156 # undef HAVE_GETHOSTBYNAME_R
157 #endif
159 #ifdef HAVE_GETHOSTBYNAME_R
160 # if defined(_AIX) || defined(__osf__)
161 # define HAVE_GETHOSTBYNAME_R_3_ARG
162 # elif defined(__sun) || defined(__sgi)
163 # define HAVE_GETHOSTBYNAME_R_5_ARG
164 # elif defined(linux)
165 /* Rely on the configure script */
166 # else
167 # undef HAVE_GETHOSTBYNAME_R
168 # endif
169 #endif
171 #if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
172 !defined(MS_WINDOWS)
173 # define USE_GETHOSTBYNAME_LOCK
174 #endif
176 /* To use __FreeBSD_version */
177 #ifdef HAVE_SYS_PARAM_H
178 #include <sys/param.h>
179 #endif
180 /* On systems on which getaddrinfo() is believed to not be thread-safe,
181 (this includes the getaddrinfo emulation) protect access with a lock. */
182 #if defined(WITH_THREAD) && (defined(__APPLE__) || \
183 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
184 defined(__OpenBSD__) || defined(__NetBSD__) || \
185 defined(__VMS) || !defined(HAVE_GETADDRINFO))
186 #define USE_GETADDRINFO_LOCK
187 #endif
189 #ifdef USE_GETADDRINFO_LOCK
190 #define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
191 #define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
192 #else
193 #define ACQUIRE_GETADDRINFO_LOCK
194 #define RELEASE_GETADDRINFO_LOCK
195 #endif
197 #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
198 # include "pythread.h"
199 #endif
201 #if defined(PYCC_VACPP)
202 # include <types.h>
203 # include <io.h>
204 # include <sys/ioctl.h>
205 # include <utils.h>
206 # include <ctype.h>
207 #endif
209 #if defined(__VMS)
210 # include <ioctl.h>
211 #endif
213 #if defined(PYOS_OS2)
214 # define INCL_DOS
215 # define INCL_DOSERRORS
216 # define INCL_NOPMAPI
217 # include <os2.h>
218 #endif
220 #if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
221 /* make sure that the reentrant (gethostbyaddr_r etc)
222 functions are declared correctly if compiling with
223 MIPSPro 7.x in ANSI C mode (default) */
225 /* XXX Using _SGIAPI is the wrong thing,
226 but I don't know what the right thing is. */
227 #undef _SGIAPI /* to avoid warning */
228 #define _SGIAPI 1
230 #undef _XOPEN_SOURCE
231 #include <sys/socket.h>
232 #include <sys/types.h>
233 #include <netinet/in.h>
234 #ifdef _SS_ALIGNSIZE
235 #define HAVE_GETADDRINFO 1
236 #define HAVE_GETNAMEINFO 1
237 #endif
239 #define HAVE_INET_PTON
240 #include <netdb.h>
241 #endif
243 /* Irix 6.5 fails to define this variable at all. This is needed
244 for both GCC and SGI's compiler. I'd say that the SGI headers
245 are just busted. Same thing for Solaris. */
246 #if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
247 #define INET_ADDRSTRLEN 16
248 #endif
250 /* Generic includes */
251 #ifdef HAVE_SYS_TYPES_H
252 #include <sys/types.h>
253 #endif
255 /* Generic socket object definitions and includes */
256 #define PySocket_BUILDING_SOCKET
257 #include "socketmodule.h"
259 /* Addressing includes */
261 #ifndef MS_WINDOWS
263 /* Non-MS WINDOWS includes */
264 # include <netdb.h>
266 /* Headers needed for inet_ntoa() and inet_addr() */
267 # ifdef __BEOS__
268 # include <net/netdb.h>
269 # elif defined(PYOS_OS2) && defined(PYCC_VACPP)
270 # include <netdb.h>
271 typedef size_t socklen_t;
272 # else
273 # include <arpa/inet.h>
274 # endif
276 # ifndef RISCOS
277 # include <fcntl.h>
278 # else
279 # include <sys/ioctl.h>
280 # include <socklib.h>
281 # define NO_DUP
282 int h_errno; /* not used */
283 # define INET_ADDRSTRLEN 16
284 # endif
286 #else
288 /* MS_WINDOWS includes */
289 # ifdef HAVE_FCNTL_H
290 # include <fcntl.h>
291 # endif
293 #endif
295 #include <stddef.h>
297 #ifndef offsetof
298 # define offsetof(type, member) ((size_t)(&((type *)0)->member))
299 #endif
301 #ifndef O_NONBLOCK
302 # define O_NONBLOCK O_NDELAY
303 #endif
305 /* include Python's addrinfo.h unless it causes trouble */
306 #if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
307 /* Do not include addinfo.h on some newer IRIX versions.
308 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
309 * for example, but not by 6.5.10.
311 #elif defined(_MSC_VER) && _MSC_VER>1201
312 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
313 * EAI_* constants are defined in (the already included) ws2tcpip.h.
315 #else
316 # include "addrinfo.h"
317 #endif
319 #ifndef HAVE_INET_PTON
320 #if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
321 int inet_pton(int af, const char *src, void *dst);
322 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
323 #endif
324 #endif
326 #ifdef __APPLE__
327 /* On OS X, getaddrinfo returns no error indication of lookup
328 failure, so we must use the emulation instead of the libinfo
329 implementation. Unfortunately, performing an autoconf test
330 for this bug would require DNS access for the machine performing
331 the configuration, which is not acceptable. Therefore, we
332 determine the bug just by checking for __APPLE__. If this bug
333 gets ever fixed, perhaps checking for sys/version.h would be
334 appropriate, which is 10/0 on the system with the bug. */
335 #ifndef HAVE_GETNAMEINFO
336 /* This bug seems to be fixed in Jaguar. Ths easiest way I could
337 Find to check for Jaguar is that it has getnameinfo(), which
338 older releases don't have */
339 #undef HAVE_GETADDRINFO
340 #endif
342 #ifdef HAVE_INET_ATON
343 #define USE_INET_ATON_WEAKLINK
344 #endif
346 #endif
348 /* I know this is a bad practice, but it is the easiest... */
349 #if !defined(HAVE_GETADDRINFO)
350 /* avoid clashes with the C library definition of the symbol. */
351 #define getaddrinfo fake_getaddrinfo
352 #define gai_strerror fake_gai_strerror
353 #define freeaddrinfo fake_freeaddrinfo
354 #include "getaddrinfo.c"
355 #endif
356 #if !defined(HAVE_GETNAMEINFO)
357 #define getnameinfo fake_getnameinfo
358 #include "getnameinfo.c"
359 #endif
361 #if defined(MS_WINDOWS) || defined(__BEOS__)
362 /* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
363 /* seem to be a few differences in the API */
364 #define SOCKETCLOSE closesocket
365 #define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
366 #endif
368 #ifdef MS_WIN32
369 #define EAFNOSUPPORT WSAEAFNOSUPPORT
370 #define snprintf _snprintf
371 #endif
373 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
374 #define SOCKETCLOSE soclose
375 #define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
376 #endif
378 #ifndef SOCKETCLOSE
379 #define SOCKETCLOSE close
380 #endif
382 #if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)
383 #define USE_BLUETOOTH 1
384 #if defined(__FreeBSD__)
385 #define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
386 #define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
387 #define BTPROTO_HCI BLUETOOTH_PROTO_HCI
388 #define SOL_HCI SOL_HCI_RAW
389 #define HCI_FILTER SO_HCI_RAW_FILTER
390 #define sockaddr_l2 sockaddr_l2cap
391 #define sockaddr_rc sockaddr_rfcomm
392 #define hci_dev hci_node
393 #define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
394 #define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
395 #define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
396 #elif defined(__NetBSD__)
397 #define sockaddr_l2 sockaddr_bt
398 #define sockaddr_rc sockaddr_bt
399 #define sockaddr_hci sockaddr_bt
400 #define sockaddr_sco sockaddr_bt
401 #define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
402 #define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
403 #define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
404 #define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
405 #else
406 #define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
407 #define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
408 #define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
409 #define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
410 #endif
411 #endif
413 #ifdef __VMS
414 /* TCP/IP Services for VMS uses a maximum send/recv buffer length */
415 #define SEGMENT_SIZE (32 * 1024 -1)
416 #endif
418 #define SAS2SA(x) ((struct sockaddr *)(x))
421 * Constants for getnameinfo()
423 #if !defined(NI_MAXHOST)
424 #define NI_MAXHOST 1025
425 #endif
426 #if !defined(NI_MAXSERV)
427 #define NI_MAXSERV 32
428 #endif
430 /* XXX There's a problem here: *static* functions are not supposed to have
431 a Py prefix (or use CapitalizedWords). Later... */
433 /* Global variable holding the exception type for errors detected
434 by this module (but not argument type or memory errors, etc.). */
435 static PyObject *socket_error;
436 static PyObject *socket_herror;
437 static PyObject *socket_gaierror;
438 static PyObject *socket_timeout;
440 #ifdef RISCOS
441 /* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
442 static int taskwindow;
443 #endif
445 /* A forward reference to the socket type object.
446 The sock_type variable contains pointers to various functions,
447 some of which call new_sockobject(), which uses sock_type, so
448 there has to be a circular reference. */
449 static PyTypeObject sock_type;
451 #if defined(HAVE_POLL_H)
452 #include <poll.h>
453 #elif defined(HAVE_SYS_POLL_H)
454 #include <sys/poll.h>
455 #endif
457 #ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
458 /* Platform can select file descriptors beyond FD_SETSIZE */
459 #define IS_SELECTABLE(s) 1
460 #elif defined(HAVE_POLL)
461 /* Instead of select(), we'll use poll() since poll() works on any fd. */
462 #define IS_SELECTABLE(s) 1
463 /* Can we call select() with this socket without a buffer overrun? */
464 #else
465 /* POSIX says selecting file descriptors beyond FD_SETSIZE
466 has undefined behaviour. If there's no timeout left, we don't have to
467 call select, so it's a safe, little white lie. */
468 #define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
469 #endif
471 static PyObject*
472 select_error(void)
474 PyErr_SetString(socket_error, "unable to select on socket");
475 return NULL;
478 /* Convenience function to raise an error according to errno
479 and return a NULL pointer from a function. */
481 static PyObject *
482 set_error(void)
484 #ifdef MS_WINDOWS
485 int err_no = WSAGetLastError();
486 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
487 recognizes the error codes used by both GetLastError() and
488 WSAGetLastError */
489 if (err_no)
490 return PyErr_SetExcFromWindowsErr(socket_error, err_no);
491 #endif
493 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
494 if (sock_errno() != NO_ERROR) {
495 APIRET rc;
496 ULONG msglen;
497 char outbuf[100];
498 int myerrorcode = sock_errno();
500 /* Retrieve socket-related error message from MPTN.MSG file */
501 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
502 myerrorcode - SOCBASEERR + 26,
503 "mptn.msg",
504 &msglen);
505 if (rc == NO_ERROR) {
506 PyObject *v;
508 /* OS/2 doesn't guarantee a terminator */
509 outbuf[msglen] = '\0';
510 if (strlen(outbuf) > 0) {
511 /* If non-empty msg, trim CRLF */
512 char *lastc = &outbuf[ strlen(outbuf)-1 ];
513 while (lastc > outbuf &&
514 isspace(Py_CHARMASK(*lastc))) {
515 /* Trim trailing whitespace (CRLF) */
516 *lastc-- = '\0';
519 v = Py_BuildValue("(is)", myerrorcode, outbuf);
520 if (v != NULL) {
521 PyErr_SetObject(socket_error, v);
522 Py_DECREF(v);
524 return NULL;
527 #endif
529 #if defined(RISCOS)
530 if (_inet_error.errnum != NULL) {
531 PyObject *v;
532 v = Py_BuildValue("(is)", errno, _inet_err());
533 if (v != NULL) {
534 PyErr_SetObject(socket_error, v);
535 Py_DECREF(v);
537 return NULL;
539 #endif
541 return PyErr_SetFromErrno(socket_error);
545 static PyObject *
546 set_herror(int h_error)
548 PyObject *v;
550 #ifdef HAVE_HSTRERROR
551 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
552 #else
553 v = Py_BuildValue("(is)", h_error, "host not found");
554 #endif
555 if (v != NULL) {
556 PyErr_SetObject(socket_herror, v);
557 Py_DECREF(v);
560 return NULL;
564 static PyObject *
565 set_gaierror(int error)
567 PyObject *v;
569 #ifdef EAI_SYSTEM
570 /* EAI_SYSTEM is not available on Windows XP. */
571 if (error == EAI_SYSTEM)
572 return set_error();
573 #endif
575 #ifdef HAVE_GAI_STRERROR
576 v = Py_BuildValue("(is)", error, gai_strerror(error));
577 #else
578 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
579 #endif
580 if (v != NULL) {
581 PyErr_SetObject(socket_gaierror, v);
582 Py_DECREF(v);
585 return NULL;
588 #ifdef __VMS
589 /* Function to send in segments */
590 static int
591 sendsegmented(int sock_fd, char *buf, int len, int flags)
593 int n = 0;
594 int remaining = len;
596 while (remaining > 0) {
597 unsigned int segment;
599 segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
600 n = send(sock_fd, buf, segment, flags);
601 if (n < 0) {
602 return n;
604 remaining -= segment;
605 buf += segment;
606 } /* end while */
608 return len;
610 #endif
612 /* Function to perform the setting of socket blocking mode
613 internally. block = (1 | 0). */
614 static int
615 internal_setblocking(PySocketSockObject *s, int block)
617 #ifndef RISCOS
618 #ifndef MS_WINDOWS
619 int delay_flag;
620 #endif
621 #endif
623 Py_BEGIN_ALLOW_THREADS
624 #ifdef __BEOS__
625 block = !block;
626 setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
627 (void *)(&block), sizeof(int));
628 #else
629 #ifndef RISCOS
630 #ifndef MS_WINDOWS
631 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
632 block = !block;
633 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
634 #elif defined(__VMS)
635 block = !block;
636 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
637 #else /* !PYOS_OS2 && !__VMS */
638 delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
639 if (block)
640 delay_flag &= (~O_NONBLOCK);
641 else
642 delay_flag |= O_NONBLOCK;
643 fcntl(s->sock_fd, F_SETFL, delay_flag);
644 #endif /* !PYOS_OS2 */
645 #else /* MS_WINDOWS */
646 block = !block;
647 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
648 #endif /* MS_WINDOWS */
649 #else /* RISCOS */
650 block = !block;
651 socketioctl(s->sock_fd, FIONBIO, (u_long*)&block);
652 #endif /* RISCOS */
653 #endif /* __BEOS__ */
654 Py_END_ALLOW_THREADS
656 /* Since these don't return anything */
657 return 1;
660 /* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
661 The argument writing indicates the direction.
662 This does not raise an exception; we'll let our caller do that
663 after they've reacquired the interpreter lock.
664 Returns 1 on timeout, -1 on error, 0 otherwise. */
665 static int
666 internal_select(PySocketSockObject *s, int writing)
668 int n;
670 /* Nothing to do unless we're in timeout mode (not non-blocking) */
671 if (s->sock_timeout <= 0.0)
672 return 0;
674 /* Guard against closed socket */
675 if (s->sock_fd < 0)
676 return 0;
678 /* Prefer poll, if available, since you can poll() any fd
679 * which can't be done with select(). */
680 #ifdef HAVE_POLL
682 struct pollfd pollfd;
683 int timeout;
685 pollfd.fd = s->sock_fd;
686 pollfd.events = writing ? POLLOUT : POLLIN;
688 /* s->sock_timeout is in seconds, timeout in ms */
689 timeout = (int)(s->sock_timeout * 1000 + 0.5);
690 n = poll(&pollfd, 1, timeout);
692 #else
694 /* Construct the arguments to select */
695 fd_set fds;
696 struct timeval tv;
697 tv.tv_sec = (int)s->sock_timeout;
698 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
699 FD_ZERO(&fds);
700 FD_SET(s->sock_fd, &fds);
702 /* See if the socket is ready */
703 if (writing)
704 n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
705 else
706 n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
708 #endif
710 if (n < 0)
711 return -1;
712 if (n == 0)
713 return 1;
714 return 0;
717 /* Initialize a new socket object. */
719 static double defaulttimeout = -1.0; /* Default timeout for new sockets */
721 PyMODINIT_FUNC
722 init_sockobject(PySocketSockObject *s,
723 SOCKET_T fd, int family, int type, int proto)
725 #ifdef RISCOS
726 int block = 1;
727 #endif
728 s->sock_fd = fd;
729 s->sock_family = family;
730 s->sock_type = type;
731 s->sock_proto = proto;
732 s->sock_timeout = defaulttimeout;
734 s->errorhandler = &set_error;
736 if (defaulttimeout >= 0.0)
737 internal_setblocking(s, 0);
739 #ifdef RISCOS
740 if (taskwindow)
741 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
742 #endif
746 /* Create a new socket object.
747 This just creates the object and initializes it.
748 If the creation fails, return NULL and set an exception (implicit
749 in NEWOBJ()). */
751 static PySocketSockObject *
752 new_sockobject(SOCKET_T fd, int family, int type, int proto)
754 PySocketSockObject *s;
755 s = (PySocketSockObject *)
756 PyType_GenericNew(&sock_type, NULL, NULL);
757 if (s != NULL)
758 init_sockobject(s, fd, family, type, proto);
759 return s;
763 /* Lock to allow python interpreter to continue, but only allow one
764 thread to be in gethostbyname or getaddrinfo */
765 #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
766 PyThread_type_lock netdb_lock;
767 #endif
770 /* Convert a string specifying a host name or one of a few symbolic
771 names to a numeric IP address. This usually calls gethostbyname()
772 to do the work; the names "" and "<broadcast>" are special.
773 Return the length (IPv4 should be 4 bytes), or negative if
774 an error occurred; then an exception is raised. */
776 static int
777 setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
779 struct addrinfo hints, *res;
780 int error;
781 int d1, d2, d3, d4;
782 char ch;
784 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
785 if (name[0] == '\0') {
786 int siz;
787 memset(&hints, 0, sizeof(hints));
788 hints.ai_family = af;
789 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
790 hints.ai_flags = AI_PASSIVE;
791 Py_BEGIN_ALLOW_THREADS
792 ACQUIRE_GETADDRINFO_LOCK
793 error = getaddrinfo(NULL, "0", &hints, &res);
794 Py_END_ALLOW_THREADS
795 /* We assume that those thread-unsafe getaddrinfo() versions
796 *are* safe regarding their return value, ie. that a
797 subsequent call to getaddrinfo() does not destroy the
798 outcome of the first call. */
799 RELEASE_GETADDRINFO_LOCK
800 if (error) {
801 set_gaierror(error);
802 return -1;
804 switch (res->ai_family) {
805 case AF_INET:
806 siz = 4;
807 break;
808 #ifdef ENABLE_IPV6
809 case AF_INET6:
810 siz = 16;
811 break;
812 #endif
813 default:
814 freeaddrinfo(res);
815 PyErr_SetString(socket_error,
816 "unsupported address family");
817 return -1;
819 if (res->ai_next) {
820 freeaddrinfo(res);
821 PyErr_SetString(socket_error,
822 "wildcard resolved to multiple address");
823 return -1;
825 if (res->ai_addrlen < addr_ret_size)
826 addr_ret_size = res->ai_addrlen;
827 memcpy(addr_ret, res->ai_addr, addr_ret_size);
828 freeaddrinfo(res);
829 return siz;
831 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
832 struct sockaddr_in *sin;
833 if (af != AF_INET && af != AF_UNSPEC) {
834 PyErr_SetString(socket_error,
835 "address family mismatched");
836 return -1;
838 sin = (struct sockaddr_in *)addr_ret;
839 memset((void *) sin, '\0', sizeof(*sin));
840 sin->sin_family = AF_INET;
841 #ifdef HAVE_SOCKADDR_SA_LEN
842 sin->sin_len = sizeof(*sin);
843 #endif
844 sin->sin_addr.s_addr = INADDR_BROADCAST;
845 return sizeof(sin->sin_addr);
847 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
848 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
849 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
850 struct sockaddr_in *sin;
851 sin = (struct sockaddr_in *)addr_ret;
852 sin->sin_addr.s_addr = htonl(
853 ((long) d1 << 24) | ((long) d2 << 16) |
854 ((long) d3 << 8) | ((long) d4 << 0));
855 sin->sin_family = AF_INET;
856 #ifdef HAVE_SOCKADDR_SA_LEN
857 sin->sin_len = sizeof(*sin);
858 #endif
859 return 4;
861 memset(&hints, 0, sizeof(hints));
862 hints.ai_family = af;
863 Py_BEGIN_ALLOW_THREADS
864 ACQUIRE_GETADDRINFO_LOCK
865 error = getaddrinfo(name, NULL, &hints, &res);
866 #if defined(__digital__) && defined(__unix__)
867 if (error == EAI_NONAME && af == AF_UNSPEC) {
868 /* On Tru64 V5.1, numeric-to-addr conversion fails
869 if no address family is given. Assume IPv4 for now.*/
870 hints.ai_family = AF_INET;
871 error = getaddrinfo(name, NULL, &hints, &res);
873 #endif
874 Py_END_ALLOW_THREADS
875 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
876 if (error) {
877 set_gaierror(error);
878 return -1;
880 if (res->ai_addrlen < addr_ret_size)
881 addr_ret_size = res->ai_addrlen;
882 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
883 freeaddrinfo(res);
884 switch (addr_ret->sa_family) {
885 case AF_INET:
886 return 4;
887 #ifdef ENABLE_IPV6
888 case AF_INET6:
889 return 16;
890 #endif
891 default:
892 PyErr_SetString(socket_error, "unknown address family");
893 return -1;
898 /* Create a string object representing an IP address.
899 This is always a string of the form 'dd.dd.dd.dd' (with variable
900 size numbers). */
902 static PyObject *
903 makeipaddr(struct sockaddr *addr, int addrlen)
905 char buf[NI_MAXHOST];
906 int error;
908 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
909 NI_NUMERICHOST);
910 if (error) {
911 set_gaierror(error);
912 return NULL;
914 return PyString_FromString(buf);
918 #ifdef USE_BLUETOOTH
919 /* Convert a string representation of a Bluetooth address into a numeric
920 address. Returns the length (6), or raises an exception and returns -1 if
921 an error occurred. */
923 static int
924 setbdaddr(char *name, bdaddr_t *bdaddr)
926 unsigned int b0, b1, b2, b3, b4, b5;
927 char ch;
928 int n;
930 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
931 &b5, &b4, &b3, &b2, &b1, &b0, &ch);
932 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
933 bdaddr->b[0] = b0;
934 bdaddr->b[1] = b1;
935 bdaddr->b[2] = b2;
936 bdaddr->b[3] = b3;
937 bdaddr->b[4] = b4;
938 bdaddr->b[5] = b5;
939 return 6;
940 } else {
941 PyErr_SetString(socket_error, "bad bluetooth address");
942 return -1;
946 /* Create a string representation of the Bluetooth address. This is always a
947 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
948 value (zero padded if necessary). */
950 static PyObject *
951 makebdaddr(bdaddr_t *bdaddr)
953 char buf[(6 * 2) + 5 + 1];
955 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
956 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
957 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
958 return PyString_FromString(buf);
960 #endif
963 /* Create an object representing the given socket address,
964 suitable for passing it back to bind(), connect() etc.
965 The family field of the sockaddr structure is inspected
966 to determine what kind of address it really is. */
968 /*ARGSUSED*/
969 static PyObject *
970 makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
972 if (addrlen == 0) {
973 /* No address -- may be recvfrom() from known socket */
974 Py_INCREF(Py_None);
975 return Py_None;
978 #ifdef __BEOS__
979 /* XXX: BeOS version of accept() doesn't set family correctly */
980 addr->sa_family = AF_INET;
981 #endif
983 switch (addr->sa_family) {
985 case AF_INET:
987 struct sockaddr_in *a;
988 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
989 PyObject *ret = NULL;
990 if (addrobj) {
991 a = (struct sockaddr_in *)addr;
992 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
993 Py_DECREF(addrobj);
995 return ret;
998 #if defined(AF_UNIX)
999 case AF_UNIX:
1001 struct sockaddr_un *a = (struct sockaddr_un *) addr;
1002 #ifdef linux
1003 if (a->sun_path[0] == 0) { /* Linux abstract namespace */
1004 addrlen -= offsetof(struct sockaddr_un, sun_path);
1005 return PyString_FromStringAndSize(a->sun_path,
1006 addrlen);
1008 else
1009 #endif /* linux */
1011 /* regular NULL-terminated string */
1012 return PyString_FromString(a->sun_path);
1015 #endif /* AF_UNIX */
1017 #if defined(AF_NETLINK)
1018 case AF_NETLINK:
1020 struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1021 return Py_BuildValue("II", a->nl_pid, a->nl_groups);
1023 #endif /* AF_NETLINK */
1025 #ifdef ENABLE_IPV6
1026 case AF_INET6:
1028 struct sockaddr_in6 *a;
1029 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1030 PyObject *ret = NULL;
1031 if (addrobj) {
1032 a = (struct sockaddr_in6 *)addr;
1033 ret = Py_BuildValue("Oiii",
1034 addrobj,
1035 ntohs(a->sin6_port),
1036 a->sin6_flowinfo,
1037 a->sin6_scope_id);
1038 Py_DECREF(addrobj);
1040 return ret;
1042 #endif
1044 #ifdef USE_BLUETOOTH
1045 case AF_BLUETOOTH:
1046 switch (proto) {
1048 case BTPROTO_L2CAP:
1050 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1051 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1052 PyObject *ret = NULL;
1053 if (addrobj) {
1054 ret = Py_BuildValue("Oi",
1055 addrobj,
1056 _BT_L2_MEMB(a, psm));
1057 Py_DECREF(addrobj);
1059 return ret;
1062 case BTPROTO_RFCOMM:
1064 struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1065 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1066 PyObject *ret = NULL;
1067 if (addrobj) {
1068 ret = Py_BuildValue("Oi",
1069 addrobj,
1070 _BT_RC_MEMB(a, channel));
1071 Py_DECREF(addrobj);
1073 return ret;
1076 case BTPROTO_HCI:
1078 struct sockaddr_hci *a = (struct sockaddr_hci *) addr;
1079 PyObject *ret = NULL;
1080 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));
1081 return ret;
1084 #if !defined(__FreeBSD__)
1085 case BTPROTO_SCO:
1087 struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1088 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1090 #endif
1093 #endif
1095 #ifdef HAVE_NETPACKET_PACKET_H
1096 case AF_PACKET:
1098 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1099 char *ifname = "";
1100 struct ifreq ifr;
1101 /* need to look up interface name give index */
1102 if (a->sll_ifindex) {
1103 ifr.ifr_ifindex = a->sll_ifindex;
1104 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1105 ifname = ifr.ifr_name;
1107 return Py_BuildValue("shbhs#",
1108 ifname,
1109 ntohs(a->sll_protocol),
1110 a->sll_pkttype,
1111 a->sll_hatype,
1112 a->sll_addr,
1113 a->sll_halen);
1115 #endif
1117 #ifdef HAVE_LINUX_TIPC_H
1118 case AF_TIPC:
1120 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;
1121 if (a->addrtype == TIPC_ADDR_NAMESEQ) {
1122 return Py_BuildValue("IIIII",
1123 a->addrtype,
1124 a->addr.nameseq.type,
1125 a->addr.nameseq.lower,
1126 a->addr.nameseq.upper,
1127 a->scope);
1128 } else if (a->addrtype == TIPC_ADDR_NAME) {
1129 return Py_BuildValue("IIIII",
1130 a->addrtype,
1131 a->addr.name.name.type,
1132 a->addr.name.name.instance,
1133 a->addr.name.name.instance,
1134 a->scope);
1135 } else if (a->addrtype == TIPC_ADDR_ID) {
1136 return Py_BuildValue("IIIII",
1137 a->addrtype,
1138 a->addr.id.node,
1139 a->addr.id.ref,
1141 a->scope);
1142 } else {
1143 PyErr_SetString(PyExc_TypeError,
1144 "Invalid address type");
1145 return NULL;
1148 #endif
1150 /* More cases here... */
1152 default:
1153 /* If we don't know the address family, don't raise an
1154 exception -- return it as a tuple. */
1155 return Py_BuildValue("is#",
1156 addr->sa_family,
1157 addr->sa_data,
1158 sizeof(addr->sa_data));
1164 /* Parse a socket address argument according to the socket object's
1165 address family. Return 1 if the address was in the proper format,
1166 0 of not. The address is returned through addr_ret, its length
1167 through len_ret. */
1169 static int
1170 getsockaddrarg(PySocketSockObject *s, PyObject *args,
1171 struct sockaddr *addr_ret, int *len_ret)
1173 switch (s->sock_family) {
1175 #if defined(AF_UNIX)
1176 case AF_UNIX:
1178 struct sockaddr_un* addr;
1179 char *path;
1180 int len;
1181 if (!PyArg_Parse(args, "t#", &path, &len))
1182 return 0;
1184 addr = (struct sockaddr_un*)addr_ret;
1185 #ifdef linux
1186 if (len > 0 && path[0] == 0) {
1187 /* Linux abstract namespace extension */
1188 if (len > sizeof addr->sun_path) {
1189 PyErr_SetString(socket_error,
1190 "AF_UNIX path too long");
1191 return 0;
1194 else
1195 #endif /* linux */
1197 /* regular NULL-terminated string */
1198 if (len >= sizeof addr->sun_path) {
1199 PyErr_SetString(socket_error,
1200 "AF_UNIX path too long");
1201 return 0;
1203 addr->sun_path[len] = 0;
1205 addr->sun_family = s->sock_family;
1206 memcpy(addr->sun_path, path, len);
1207 #if defined(PYOS_OS2)
1208 *len_ret = sizeof(*addr);
1209 #else
1210 *len_ret = len + offsetof(struct sockaddr_un, sun_path);
1211 #endif
1212 return 1;
1214 #endif /* AF_UNIX */
1216 #if defined(AF_NETLINK)
1217 case AF_NETLINK:
1219 struct sockaddr_nl* addr;
1220 int pid, groups;
1221 addr = (struct sockaddr_nl *)addr_ret;
1222 if (!PyTuple_Check(args)) {
1223 PyErr_Format(
1224 PyExc_TypeError,
1225 "getsockaddrarg: "
1226 "AF_NETLINK address must be tuple, not %.500s",
1227 Py_TYPE(args)->tp_name);
1228 return 0;
1230 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1231 return 0;
1232 addr->nl_family = AF_NETLINK;
1233 addr->nl_pid = pid;
1234 addr->nl_groups = groups;
1235 *len_ret = sizeof(*addr);
1236 return 1;
1238 #endif
1240 case AF_INET:
1242 struct sockaddr_in* addr;
1243 char *host;
1244 int port, result;
1245 if (!PyTuple_Check(args)) {
1246 PyErr_Format(
1247 PyExc_TypeError,
1248 "getsockaddrarg: "
1249 "AF_INET address must be tuple, not %.500s",
1250 Py_TYPE(args)->tp_name);
1251 return 0;
1253 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1254 "idna", &host, &port))
1255 return 0;
1256 addr=(struct sockaddr_in*)addr_ret;
1257 result = setipaddr(host, (struct sockaddr *)addr,
1258 sizeof(*addr), AF_INET);
1259 PyMem_Free(host);
1260 if (result < 0)
1261 return 0;
1262 addr->sin_family = AF_INET;
1263 addr->sin_port = htons((short)port);
1264 *len_ret = sizeof *addr;
1265 return 1;
1268 #ifdef ENABLE_IPV6
1269 case AF_INET6:
1271 struct sockaddr_in6* addr;
1272 char *host;
1273 int port, flowinfo, scope_id, result;
1274 flowinfo = scope_id = 0;
1275 if (!PyTuple_Check(args)) {
1276 PyErr_Format(
1277 PyExc_TypeError,
1278 "getsockaddrarg: "
1279 "AF_INET6 address must be tuple, not %.500s",
1280 Py_TYPE(args)->tp_name);
1281 return 0;
1283 if (!PyArg_ParseTuple(args, "eti|ii",
1284 "idna", &host, &port, &flowinfo,
1285 &scope_id)) {
1286 return 0;
1288 addr = (struct sockaddr_in6*)addr_ret;
1289 result = setipaddr(host, (struct sockaddr *)addr,
1290 sizeof(*addr), AF_INET6);
1291 PyMem_Free(host);
1292 if (result < 0)
1293 return 0;
1294 addr->sin6_family = s->sock_family;
1295 addr->sin6_port = htons((short)port);
1296 addr->sin6_flowinfo = flowinfo;
1297 addr->sin6_scope_id = scope_id;
1298 *len_ret = sizeof *addr;
1299 return 1;
1301 #endif
1303 #ifdef USE_BLUETOOTH
1304 case AF_BLUETOOTH:
1306 switch (s->sock_proto) {
1307 case BTPROTO_L2CAP:
1309 struct sockaddr_l2 *addr;
1310 char *straddr;
1312 addr = (struct sockaddr_l2 *)addr_ret;
1313 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1314 if (!PyArg_ParseTuple(args, "si", &straddr,
1315 &_BT_L2_MEMB(addr, psm))) {
1316 PyErr_SetString(socket_error, "getsockaddrarg: "
1317 "wrong format");
1318 return 0;
1320 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1321 return 0;
1323 *len_ret = sizeof *addr;
1324 return 1;
1326 case BTPROTO_RFCOMM:
1328 struct sockaddr_rc *addr;
1329 char *straddr;
1331 addr = (struct sockaddr_rc *)addr_ret;
1332 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1333 if (!PyArg_ParseTuple(args, "si", &straddr,
1334 &_BT_RC_MEMB(addr, channel))) {
1335 PyErr_SetString(socket_error, "getsockaddrarg: "
1336 "wrong format");
1337 return 0;
1339 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1340 return 0;
1342 *len_ret = sizeof *addr;
1343 return 1;
1345 case BTPROTO_HCI:
1347 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;
1348 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;
1349 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {
1350 PyErr_SetString(socket_error, "getsockaddrarg: "
1351 "wrong format");
1352 return 0;
1354 *len_ret = sizeof *addr;
1355 return 1;
1357 #if !defined(__FreeBSD__)
1358 case BTPROTO_SCO:
1360 struct sockaddr_sco *addr;
1361 char *straddr;
1363 addr = (struct sockaddr_sco *)addr_ret;
1364 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1365 straddr = PyString_AsString(args);
1366 if (straddr == NULL) {
1367 PyErr_SetString(socket_error, "getsockaddrarg: "
1368 "wrong format");
1369 return 0;
1371 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1372 return 0;
1374 *len_ret = sizeof *addr;
1375 return 1;
1377 #endif
1378 default:
1379 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1380 return 0;
1383 #endif
1385 #ifdef HAVE_NETPACKET_PACKET_H
1386 case AF_PACKET:
1388 struct sockaddr_ll* addr;
1389 struct ifreq ifr;
1390 char *interfaceName;
1391 int protoNumber;
1392 int hatype = 0;
1393 int pkttype = 0;
1394 char *haddr = NULL;
1395 unsigned int halen = 0;
1397 if (!PyTuple_Check(args)) {
1398 PyErr_Format(
1399 PyExc_TypeError,
1400 "getsockaddrarg: "
1401 "AF_PACKET address must be tuple, not %.500s",
1402 Py_TYPE(args)->tp_name);
1403 return 0;
1405 if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName,
1406 &protoNumber, &pkttype, &hatype,
1407 &haddr, &halen))
1408 return 0;
1409 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1410 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1411 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1412 s->errorhandler();
1413 return 0;
1415 if (halen > 8) {
1416 PyErr_SetString(PyExc_ValueError,
1417 "Hardware address must be 8 bytes or less");
1418 return 0;
1420 addr = (struct sockaddr_ll*)addr_ret;
1421 addr->sll_family = AF_PACKET;
1422 addr->sll_protocol = htons((short)protoNumber);
1423 addr->sll_ifindex = ifr.ifr_ifindex;
1424 addr->sll_pkttype = pkttype;
1425 addr->sll_hatype = hatype;
1426 if (halen != 0) {
1427 memcpy(&addr->sll_addr, haddr, halen);
1429 addr->sll_halen = halen;
1430 *len_ret = sizeof *addr;
1431 return 1;
1433 #endif
1435 #ifdef HAVE_LINUX_TIPC_H
1436 case AF_TIPC:
1438 unsigned int atype, v1, v2, v3;
1439 unsigned int scope = TIPC_CLUSTER_SCOPE;
1440 struct sockaddr_tipc *addr;
1442 if (!PyTuple_Check(args)) {
1443 PyErr_Format(
1444 PyExc_TypeError,
1445 "getsockaddrarg: "
1446 "AF_TIPC address must be tuple, not %.500s",
1447 Py_TYPE(args)->tp_name);
1448 return 0;
1451 if (!PyArg_ParseTuple(args,
1452 "IIII|I;Invalid TIPC address format",
1453 &atype, &v1, &v2, &v3, &scope))
1454 return 0;
1456 addr = (struct sockaddr_tipc *) addr_ret;
1457 memset(addr, 0, sizeof(struct sockaddr_tipc));
1459 addr->family = AF_TIPC;
1460 addr->scope = scope;
1461 addr->addrtype = atype;
1463 if (atype == TIPC_ADDR_NAMESEQ) {
1464 addr->addr.nameseq.type = v1;
1465 addr->addr.nameseq.lower = v2;
1466 addr->addr.nameseq.upper = v3;
1467 } else if (atype == TIPC_ADDR_NAME) {
1468 addr->addr.name.name.type = v1;
1469 addr->addr.name.name.instance = v2;
1470 } else if (atype == TIPC_ADDR_ID) {
1471 addr->addr.id.node = v1;
1472 addr->addr.id.ref = v2;
1473 } else {
1474 /* Shouldn't happen */
1475 PyErr_SetString(PyExc_TypeError, "Invalid address type");
1476 return 0;
1479 *len_ret = sizeof(*addr);
1481 return 1;
1483 #endif
1485 /* More cases here... */
1487 default:
1488 PyErr_SetString(socket_error, "getsockaddrarg: bad family");
1489 return 0;
1495 /* Get the address length according to the socket object's address family.
1496 Return 1 if the family is known, 0 otherwise. The length is returned
1497 through len_ret. */
1499 static int
1500 getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
1502 switch (s->sock_family) {
1504 #if defined(AF_UNIX)
1505 case AF_UNIX:
1507 *len_ret = sizeof (struct sockaddr_un);
1508 return 1;
1510 #endif /* AF_UNIX */
1511 #if defined(AF_NETLINK)
1512 case AF_NETLINK:
1514 *len_ret = sizeof (struct sockaddr_nl);
1515 return 1;
1517 #endif
1519 case AF_INET:
1521 *len_ret = sizeof (struct sockaddr_in);
1522 return 1;
1525 #ifdef ENABLE_IPV6
1526 case AF_INET6:
1528 *len_ret = sizeof (struct sockaddr_in6);
1529 return 1;
1531 #endif
1533 #ifdef USE_BLUETOOTH
1534 case AF_BLUETOOTH:
1536 switch(s->sock_proto)
1539 case BTPROTO_L2CAP:
1540 *len_ret = sizeof (struct sockaddr_l2);
1541 return 1;
1542 case BTPROTO_RFCOMM:
1543 *len_ret = sizeof (struct sockaddr_rc);
1544 return 1;
1545 case BTPROTO_HCI:
1546 *len_ret = sizeof (struct sockaddr_hci);
1547 return 1;
1548 #if !defined(__FreeBSD__)
1549 case BTPROTO_SCO:
1550 *len_ret = sizeof (struct sockaddr_sco);
1551 return 1;
1552 #endif
1553 default:
1554 PyErr_SetString(socket_error, "getsockaddrlen: "
1555 "unknown BT protocol");
1556 return 0;
1560 #endif
1562 #ifdef HAVE_NETPACKET_PACKET_H
1563 case AF_PACKET:
1565 *len_ret = sizeof (struct sockaddr_ll);
1566 return 1;
1568 #endif
1570 #ifdef HAVE_LINUX_TIPC_H
1571 case AF_TIPC:
1573 *len_ret = sizeof (struct sockaddr_tipc);
1574 return 1;
1576 #endif
1578 /* More cases here... */
1580 default:
1581 PyErr_SetString(socket_error, "getsockaddrlen: bad family");
1582 return 0;
1588 /* s.accept() method */
1590 static PyObject *
1591 sock_accept(PySocketSockObject *s)
1593 sock_addr_t addrbuf;
1594 SOCKET_T newfd;
1595 socklen_t addrlen;
1596 PyObject *sock = NULL;
1597 PyObject *addr = NULL;
1598 PyObject *res = NULL;
1599 int timeout;
1601 if (!getsockaddrlen(s, &addrlen))
1602 return NULL;
1603 memset(&addrbuf, 0, addrlen);
1605 #ifdef MS_WINDOWS
1606 newfd = INVALID_SOCKET;
1607 #else
1608 newfd = -1;
1609 #endif
1611 if (!IS_SELECTABLE(s))
1612 return select_error();
1614 Py_BEGIN_ALLOW_THREADS
1615 timeout = internal_select(s, 0);
1616 if (!timeout)
1617 newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
1618 Py_END_ALLOW_THREADS
1620 if (timeout == 1) {
1621 PyErr_SetString(socket_timeout, "timed out");
1622 return NULL;
1625 #ifdef MS_WINDOWS
1626 if (newfd == INVALID_SOCKET)
1627 #else
1628 if (newfd < 0)
1629 #endif
1630 return s->errorhandler();
1632 /* Create the new object with unspecified family,
1633 to avoid calls to bind() etc. on it. */
1634 sock = (PyObject *) new_sockobject(newfd,
1635 s->sock_family,
1636 s->sock_type,
1637 s->sock_proto);
1639 if (sock == NULL) {
1640 SOCKETCLOSE(newfd);
1641 goto finally;
1643 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
1644 addrlen, s->sock_proto);
1645 if (addr == NULL)
1646 goto finally;
1648 res = PyTuple_Pack(2, sock, addr);
1650 finally:
1651 Py_XDECREF(sock);
1652 Py_XDECREF(addr);
1653 return res;
1656 PyDoc_STRVAR(accept_doc,
1657 "accept() -> (socket object, address info)\n\
1659 Wait for an incoming connection. Return a new socket representing the\n\
1660 connection, and the address of the client. For IP sockets, the address\n\
1661 info is a pair (hostaddr, port).");
1663 /* s.setblocking(flag) method. Argument:
1664 False -- non-blocking mode; same as settimeout(0)
1665 True -- blocking mode; same as settimeout(None)
1668 static PyObject *
1669 sock_setblocking(PySocketSockObject *s, PyObject *arg)
1671 int block;
1673 block = PyInt_AsLong(arg);
1674 if (block == -1 && PyErr_Occurred())
1675 return NULL;
1677 s->sock_timeout = block ? -1.0 : 0.0;
1678 internal_setblocking(s, block);
1680 Py_INCREF(Py_None);
1681 return Py_None;
1684 PyDoc_STRVAR(setblocking_doc,
1685 "setblocking(flag)\n\
1687 Set the socket to blocking (flag is true) or non-blocking (false).\n\
1688 setblocking(True) is equivalent to settimeout(None);\n\
1689 setblocking(False) is equivalent to settimeout(0.0).");
1691 /* s.settimeout(timeout) method. Argument:
1692 None -- no timeout, blocking mode; same as setblocking(True)
1693 0.0 -- non-blocking mode; same as setblocking(False)
1694 > 0 -- timeout mode; operations time out after timeout seconds
1695 < 0 -- illegal; raises an exception
1697 static PyObject *
1698 sock_settimeout(PySocketSockObject *s, PyObject *arg)
1700 double timeout;
1702 if (arg == Py_None)
1703 timeout = -1.0;
1704 else {
1705 timeout = PyFloat_AsDouble(arg);
1706 if (timeout < 0.0) {
1707 if (!PyErr_Occurred())
1708 PyErr_SetString(PyExc_ValueError,
1709 "Timeout value out of range");
1710 return NULL;
1714 s->sock_timeout = timeout;
1715 internal_setblocking(s, timeout < 0.0);
1717 Py_INCREF(Py_None);
1718 return Py_None;
1721 PyDoc_STRVAR(settimeout_doc,
1722 "settimeout(timeout)\n\
1724 Set a timeout on socket operations. 'timeout' can be a float,\n\
1725 giving in seconds, or None. Setting a timeout of None disables\n\
1726 the timeout feature and is equivalent to setblocking(1).\n\
1727 Setting a timeout of zero is the same as setblocking(0).");
1729 /* s.gettimeout() method.
1730 Returns the timeout associated with a socket. */
1731 static PyObject *
1732 sock_gettimeout(PySocketSockObject *s)
1734 if (s->sock_timeout < 0.0) {
1735 Py_INCREF(Py_None);
1736 return Py_None;
1738 else
1739 return PyFloat_FromDouble(s->sock_timeout);
1742 PyDoc_STRVAR(gettimeout_doc,
1743 "gettimeout() -> timeout\n\
1745 Returns the timeout in floating seconds associated with socket \n\
1746 operations. A timeout of None indicates that timeouts on socket \n\
1747 operations are disabled.");
1749 #ifdef RISCOS
1750 /* s.sleeptaskw(1 | 0) method */
1752 static PyObject *
1753 sock_sleeptaskw(PySocketSockObject *s,PyObject *arg)
1755 int block;
1756 block = PyInt_AsLong(arg);
1757 if (block == -1 && PyErr_Occurred())
1758 return NULL;
1759 Py_BEGIN_ALLOW_THREADS
1760 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
1761 Py_END_ALLOW_THREADS
1763 Py_INCREF(Py_None);
1764 return Py_None;
1766 PyDoc_STRVAR(sleeptaskw_doc,
1767 "sleeptaskw(flag)\n\
1769 Allow sleeps in taskwindows.");
1770 #endif
1773 /* s.setsockopt() method.
1774 With an integer third argument, sets an integer option.
1775 With a string third argument, sets an option from a buffer;
1776 use optional built-in module 'struct' to encode the string. */
1778 static PyObject *
1779 sock_setsockopt(PySocketSockObject *s, PyObject *args)
1781 int level;
1782 int optname;
1783 int res;
1784 char *buf;
1785 int buflen;
1786 int flag;
1788 if (PyArg_ParseTuple(args, "iii:setsockopt",
1789 &level, &optname, &flag)) {
1790 buf = (char *) &flag;
1791 buflen = sizeof flag;
1793 else {
1794 PyErr_Clear();
1795 if (!PyArg_ParseTuple(args, "iis#:setsockopt",
1796 &level, &optname, &buf, &buflen))
1797 return NULL;
1799 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
1800 if (res < 0)
1801 return s->errorhandler();
1802 Py_INCREF(Py_None);
1803 return Py_None;
1806 PyDoc_STRVAR(setsockopt_doc,
1807 "setsockopt(level, option, value)\n\
1809 Set a socket option. See the Unix manual for level and option.\n\
1810 The value argument can either be an integer or a string.");
1813 /* s.getsockopt() method.
1814 With two arguments, retrieves an integer option.
1815 With a third integer argument, retrieves a string buffer of that size;
1816 use optional built-in module 'struct' to decode the string. */
1818 static PyObject *
1819 sock_getsockopt(PySocketSockObject *s, PyObject *args)
1821 int level;
1822 int optname;
1823 int res;
1824 PyObject *buf;
1825 socklen_t buflen = 0;
1827 #ifdef __BEOS__
1828 /* We have incomplete socket support. */
1829 PyErr_SetString(socket_error, "getsockopt not supported");
1830 return NULL;
1831 #else
1833 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1834 &level, &optname, &buflen))
1835 return NULL;
1837 if (buflen == 0) {
1838 int flag = 0;
1839 socklen_t flagsize = sizeof flag;
1840 res = getsockopt(s->sock_fd, level, optname,
1841 (void *)&flag, &flagsize);
1842 if (res < 0)
1843 return s->errorhandler();
1844 return PyInt_FromLong(flag);
1846 #ifdef __VMS
1847 /* socklen_t is unsigned so no negative test is needed,
1848 test buflen == 0 is previously done */
1849 if (buflen > 1024) {
1850 #else
1851 if (buflen <= 0 || buflen > 1024) {
1852 #endif
1853 PyErr_SetString(socket_error,
1854 "getsockopt buflen out of range");
1855 return NULL;
1857 buf = PyString_FromStringAndSize((char *)NULL, buflen);
1858 if (buf == NULL)
1859 return NULL;
1860 res = getsockopt(s->sock_fd, level, optname,
1861 (void *)PyString_AS_STRING(buf), &buflen);
1862 if (res < 0) {
1863 Py_DECREF(buf);
1864 return s->errorhandler();
1866 _PyString_Resize(&buf, buflen);
1867 return buf;
1868 #endif /* __BEOS__ */
1871 PyDoc_STRVAR(getsockopt_doc,
1872 "getsockopt(level, option[, buffersize]) -> value\n\
1874 Get a socket option. See the Unix manual for level and option.\n\
1875 If a nonzero buffersize argument is given, the return value is a\n\
1876 string of that length; otherwise it is an integer.");
1879 /* s.bind(sockaddr) method */
1881 static PyObject *
1882 sock_bind(PySocketSockObject *s, PyObject *addro)
1884 sock_addr_t addrbuf;
1885 int addrlen;
1886 int res;
1888 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
1889 return NULL;
1890 Py_BEGIN_ALLOW_THREADS
1891 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
1892 Py_END_ALLOW_THREADS
1893 if (res < 0)
1894 return s->errorhandler();
1895 Py_INCREF(Py_None);
1896 return Py_None;
1899 PyDoc_STRVAR(bind_doc,
1900 "bind(address)\n\
1902 Bind the socket to a local address. For IP sockets, the address is a\n\
1903 pair (host, port); the host must refer to the local host. For raw packet\n\
1904 sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
1907 /* s.close() method.
1908 Set the file descriptor to -1 so operations tried subsequently
1909 will surely fail. */
1911 static PyObject *
1912 sock_close(PySocketSockObject *s)
1914 SOCKET_T fd;
1916 if ((fd = s->sock_fd) != -1) {
1917 s->sock_fd = -1;
1918 Py_BEGIN_ALLOW_THREADS
1919 (void) SOCKETCLOSE(fd);
1920 Py_END_ALLOW_THREADS
1922 Py_INCREF(Py_None);
1923 return Py_None;
1926 PyDoc_STRVAR(close_doc,
1927 "close()\n\
1929 Close the socket. It cannot be used after this call.");
1931 static int
1932 internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
1933 int *timeoutp)
1935 int res, timeout;
1937 timeout = 0;
1938 res = connect(s->sock_fd, addr, addrlen);
1940 #ifdef MS_WINDOWS
1942 if (s->sock_timeout > 0.0) {
1943 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
1944 IS_SELECTABLE(s)) {
1945 /* This is a mess. Best solution: trust select */
1946 fd_set fds;
1947 fd_set fds_exc;
1948 struct timeval tv;
1949 tv.tv_sec = (int)s->sock_timeout;
1950 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
1951 FD_ZERO(&fds);
1952 FD_SET(s->sock_fd, &fds);
1953 FD_ZERO(&fds_exc);
1954 FD_SET(s->sock_fd, &fds_exc);
1955 res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
1956 if (res == 0) {
1957 res = WSAEWOULDBLOCK;
1958 timeout = 1;
1959 } else if (res > 0) {
1960 if (FD_ISSET(s->sock_fd, &fds))
1961 /* The socket is in the writeable set - this
1962 means connected */
1963 res = 0;
1964 else {
1965 /* As per MS docs, we need to call getsockopt()
1966 to get the underlying error */
1967 int res_size = sizeof res;
1968 /* It must be in the exception set */
1969 assert(FD_ISSET(s->sock_fd, &fds_exc));
1970 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
1971 (char *)&res, &res_size))
1972 /* getsockopt also clears WSAGetLastError,
1973 so reset it back. */
1974 WSASetLastError(res);
1975 else
1976 res = WSAGetLastError();
1979 /* else if (res < 0) an error occurred */
1983 if (res < 0)
1984 res = WSAGetLastError();
1986 #else
1988 if (s->sock_timeout > 0.0) {
1989 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
1990 timeout = internal_select(s, 1);
1991 if (timeout == 0) {
1992 /* Bug #1019808: in case of an EINPROGRESS,
1993 use getsockopt(SO_ERROR) to get the real
1994 error. */
1995 socklen_t res_size = sizeof res;
1996 (void)getsockopt(s->sock_fd, SOL_SOCKET,
1997 SO_ERROR, &res, &res_size);
1998 if (res == EISCONN)
1999 res = 0;
2000 errno = res;
2002 else if (timeout == -1) {
2003 res = errno; /* had error */
2005 else
2006 res = EWOULDBLOCK; /* timed out */
2010 if (res < 0)
2011 res = errno;
2013 #endif
2014 *timeoutp = timeout;
2016 return res;
2019 /* s.connect(sockaddr) method */
2021 static PyObject *
2022 sock_connect(PySocketSockObject *s, PyObject *addro)
2024 sock_addr_t addrbuf;
2025 int addrlen;
2026 int res;
2027 int timeout;
2029 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2030 return NULL;
2032 Py_BEGIN_ALLOW_THREADS
2033 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2034 Py_END_ALLOW_THREADS
2036 if (timeout == 1) {
2037 PyErr_SetString(socket_timeout, "timed out");
2038 return NULL;
2040 if (res != 0)
2041 return s->errorhandler();
2042 Py_INCREF(Py_None);
2043 return Py_None;
2046 PyDoc_STRVAR(connect_doc,
2047 "connect(address)\n\
2049 Connect the socket to a remote address. For IP sockets, the address\n\
2050 is a pair (host, port).");
2053 /* s.connect_ex(sockaddr) method */
2055 static PyObject *
2056 sock_connect_ex(PySocketSockObject *s, PyObject *addro)
2058 sock_addr_t addrbuf;
2059 int addrlen;
2060 int res;
2061 int timeout;
2063 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2064 return NULL;
2066 Py_BEGIN_ALLOW_THREADS
2067 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);
2068 Py_END_ALLOW_THREADS
2070 /* Signals are not errors (though they may raise exceptions). Adapted
2071 from PyErr_SetFromErrnoWithFilenameObject(). */
2072 #ifdef EINTR
2073 if (res == EINTR && PyErr_CheckSignals())
2074 return NULL;
2075 #endif
2077 return PyInt_FromLong((long) res);
2080 PyDoc_STRVAR(connect_ex_doc,
2081 "connect_ex(address) -> errno\n\
2083 This is like connect(address), but returns an error code (the errno value)\n\
2084 instead of raising an exception when an error occurs.");
2087 /* s.fileno() method */
2089 static PyObject *
2090 sock_fileno(PySocketSockObject *s)
2092 #if SIZEOF_SOCKET_T <= SIZEOF_LONG
2093 return PyInt_FromLong((long) s->sock_fd);
2094 #else
2095 return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd);
2096 #endif
2099 PyDoc_STRVAR(fileno_doc,
2100 "fileno() -> integer\n\
2102 Return the integer file descriptor of the socket.");
2105 #ifndef NO_DUP
2106 /* s.dup() method */
2108 static PyObject *
2109 sock_dup(PySocketSockObject *s)
2111 SOCKET_T newfd;
2112 PyObject *sock;
2114 newfd = dup(s->sock_fd);
2115 if (newfd < 0)
2116 return s->errorhandler();
2117 sock = (PyObject *) new_sockobject(newfd,
2118 s->sock_family,
2119 s->sock_type,
2120 s->sock_proto);
2121 if (sock == NULL)
2122 SOCKETCLOSE(newfd);
2123 return sock;
2126 PyDoc_STRVAR(dup_doc,
2127 "dup() -> socket object\n\
2129 Return a new socket object connected to the same system resource.");
2131 #endif
2134 /* s.getsockname() method */
2136 static PyObject *
2137 sock_getsockname(PySocketSockObject *s)
2139 sock_addr_t addrbuf;
2140 int res;
2141 socklen_t addrlen;
2143 if (!getsockaddrlen(s, &addrlen))
2144 return NULL;
2145 memset(&addrbuf, 0, addrlen);
2146 Py_BEGIN_ALLOW_THREADS
2147 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2148 Py_END_ALLOW_THREADS
2149 if (res < 0)
2150 return s->errorhandler();
2151 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2152 s->sock_proto);
2155 PyDoc_STRVAR(getsockname_doc,
2156 "getsockname() -> address info\n\
2158 Return the address of the local endpoint. For IP sockets, the address\n\
2159 info is a pair (hostaddr, port).");
2162 #ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
2163 /* s.getpeername() method */
2165 static PyObject *
2166 sock_getpeername(PySocketSockObject *s)
2168 sock_addr_t addrbuf;
2169 int res;
2170 socklen_t addrlen;
2172 if (!getsockaddrlen(s, &addrlen))
2173 return NULL;
2174 memset(&addrbuf, 0, addrlen);
2175 Py_BEGIN_ALLOW_THREADS
2176 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
2177 Py_END_ALLOW_THREADS
2178 if (res < 0)
2179 return s->errorhandler();
2180 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,
2181 s->sock_proto);
2184 PyDoc_STRVAR(getpeername_doc,
2185 "getpeername() -> address info\n\
2187 Return the address of the remote endpoint. For IP sockets, the address\n\
2188 info is a pair (hostaddr, port).");
2190 #endif /* HAVE_GETPEERNAME */
2193 /* s.listen(n) method */
2195 static PyObject *
2196 sock_listen(PySocketSockObject *s, PyObject *arg)
2198 int backlog;
2199 int res;
2201 backlog = PyInt_AsLong(arg);
2202 if (backlog == -1 && PyErr_Occurred())
2203 return NULL;
2204 Py_BEGIN_ALLOW_THREADS
2205 if (backlog < 1)
2206 backlog = 1;
2207 res = listen(s->sock_fd, backlog);
2208 Py_END_ALLOW_THREADS
2209 if (res < 0)
2210 return s->errorhandler();
2211 Py_INCREF(Py_None);
2212 return Py_None;
2215 PyDoc_STRVAR(listen_doc,
2216 "listen(backlog)\n\
2218 Enable a server to accept connections. The backlog argument must be at\n\
2219 least 1; it specifies the number of unaccepted connection that the system\n\
2220 will allow before refusing new connections.");
2223 #ifndef NO_DUP
2224 /* s.makefile(mode) method.
2225 Create a new open file object referring to a dupped version of
2226 the socket's file descriptor. (The dup() call is necessary so
2227 that the open file and socket objects may be closed independent
2228 of each other.)
2229 The mode argument specifies 'r' or 'w' passed to fdopen(). */
2231 static PyObject *
2232 sock_makefile(PySocketSockObject *s, PyObject *args)
2234 extern int fclose(FILE *);
2235 char *mode = "r";
2236 int bufsize = -1;
2237 #ifdef MS_WIN32
2238 Py_intptr_t fd;
2239 #else
2240 int fd;
2241 #endif
2242 FILE *fp;
2243 PyObject *f;
2244 #ifdef __VMS
2245 char *mode_r = "r";
2246 char *mode_w = "w";
2247 #endif
2249 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize))
2250 return NULL;
2251 #ifdef __VMS
2252 if (strcmp(mode,"rb") == 0) {
2253 mode = mode_r;
2255 else {
2256 if (strcmp(mode,"wb") == 0) {
2257 mode = mode_w;
2260 #endif
2261 #ifdef MS_WIN32
2262 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) ||
2263 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL))
2264 #else
2265 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL)
2266 #endif
2268 if (fd >= 0)
2269 SOCKETCLOSE(fd);
2270 return s->errorhandler();
2272 f = PyFile_FromFile(fp, "<socket>", mode, fclose);
2273 if (f != NULL)
2274 PyFile_SetBufSize(f, bufsize);
2275 return f;
2278 PyDoc_STRVAR(makefile_doc,
2279 "makefile([mode[, buffersize]]) -> file object\n\
2281 Return a regular file object corresponding to the socket.\n\
2282 The mode and buffersize arguments are as for the built-in open() function.");
2284 #endif /* NO_DUP */
2287 * This is the guts of the recv() and recv_into() methods, which reads into a
2288 * char buffer. If you have any inc/dec ref to do to the objects that contain
2289 * the buffer, do it in the caller. This function returns the number of bytes
2290 * succesfully read. If there was an error, it returns -1. Note that it is
2291 * also possible that we return a number of bytes smaller than the request
2292 * bytes.
2294 static ssize_t
2295 sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags)
2297 ssize_t outlen = -1;
2298 int timeout;
2299 #ifdef __VMS
2300 int remaining;
2301 char *read_buf;
2302 #endif
2304 if (!IS_SELECTABLE(s)) {
2305 select_error();
2306 return -1;
2309 #ifndef __VMS
2310 Py_BEGIN_ALLOW_THREADS
2311 timeout = internal_select(s, 0);
2312 if (!timeout)
2313 outlen = recv(s->sock_fd, cbuf, len, flags);
2314 Py_END_ALLOW_THREADS
2316 if (timeout == 1) {
2317 PyErr_SetString(socket_timeout, "timed out");
2318 return -1;
2320 if (outlen < 0) {
2321 /* Note: the call to errorhandler() ALWAYS indirectly returned
2322 NULL, so ignore its return value */
2323 s->errorhandler();
2324 return -1;
2326 #else
2327 read_buf = cbuf;
2328 remaining = len;
2329 while (remaining != 0) {
2330 unsigned int segment;
2331 int nread = -1;
2333 segment = remaining /SEGMENT_SIZE;
2334 if (segment != 0) {
2335 segment = SEGMENT_SIZE;
2337 else {
2338 segment = remaining;
2341 Py_BEGIN_ALLOW_THREADS
2342 timeout = internal_select(s, 0);
2343 if (!timeout)
2344 nread = recv(s->sock_fd, read_buf, segment, flags);
2345 Py_END_ALLOW_THREADS
2347 if (timeout == 1) {
2348 PyErr_SetString(socket_timeout, "timed out");
2349 return -1;
2351 if (nread < 0) {
2352 s->errorhandler();
2353 return -1;
2355 if (nread != remaining) {
2356 read_buf += nread;
2357 break;
2360 remaining -= segment;
2361 read_buf += segment;
2363 outlen = read_buf - cbuf;
2364 #endif /* !__VMS */
2366 return outlen;
2370 /* s.recv(nbytes [,flags]) method */
2372 static PyObject *
2373 sock_recv(PySocketSockObject *s, PyObject *args)
2375 int recvlen, flags = 0;
2376 ssize_t outlen;
2377 PyObject *buf;
2379 if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))
2380 return NULL;
2382 if (recvlen < 0) {
2383 PyErr_SetString(PyExc_ValueError,
2384 "negative buffersize in recv");
2385 return NULL;
2388 /* Allocate a new string. */
2389 buf = PyString_FromStringAndSize((char *) 0, recvlen);
2390 if (buf == NULL)
2391 return NULL;
2393 /* Call the guts */
2394 outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags);
2395 if (outlen < 0) {
2396 /* An error occurred, release the string and return an
2397 error. */
2398 Py_DECREF(buf);
2399 return NULL;
2401 if (outlen != recvlen) {
2402 /* We did not read as many bytes as we anticipated, resize the
2403 string if possible and be succesful. */
2404 if (_PyString_Resize(&buf, outlen) < 0)
2405 /* Oopsy, not so succesful after all. */
2406 return NULL;
2409 return buf;
2412 PyDoc_STRVAR(recv_doc,
2413 "recv(buffersize[, flags]) -> data\n\
2415 Receive up to buffersize bytes from the socket. For the optional flags\n\
2416 argument, see the Unix manual. When no data is available, block until\n\
2417 at least one byte is available or until the remote end is closed. When\n\
2418 the remote end is closed and all data is read, return the empty string.");
2421 /* s.recv_into(buffer, [nbytes [,flags]]) method */
2423 static PyObject*
2424 sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)
2426 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
2428 int recvlen = 0, flags = 0;
2429 ssize_t readlen;
2430 char *buf;
2431 int buflen;
2433 /* Get the buffer's memory */
2434 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#|ii:recv_into", kwlist,
2435 &buf, &buflen, &recvlen, &flags))
2436 return NULL;
2437 assert(buf != 0 && buflen > 0);
2439 if (recvlen < 0) {
2440 PyErr_SetString(PyExc_ValueError,
2441 "negative buffersize in recv_into");
2442 return NULL;
2444 if (recvlen == 0) {
2445 /* If nbytes was not specified, use the buffer's length */
2446 recvlen = buflen;
2449 /* Check if the buffer is large enough */
2450 if (buflen < recvlen) {
2451 PyErr_SetString(PyExc_ValueError,
2452 "buffer too small for requested bytes");
2453 return NULL;
2456 /* Call the guts */
2457 readlen = sock_recv_guts(s, buf, recvlen, flags);
2458 if (readlen < 0) {
2459 /* Return an error. */
2460 return NULL;
2463 /* Return the number of bytes read. Note that we do not do anything
2464 special here in the case that readlen < recvlen. */
2465 return PyInt_FromSsize_t(readlen);
2468 PyDoc_STRVAR(recv_into_doc,
2469 "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\
2471 A version of recv() that stores its data into a buffer rather than creating \n\
2472 a new string. Receive up to buffersize bytes from the socket. If buffersize \n\
2473 is not specified (or 0), receive up to the size available in the given buffer.\n\
2475 See recv() for documentation about the flags.");
2479 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads
2480 * into a char buffer. If you have any inc/def ref to do to the objects that
2481 * contain the buffer, do it in the caller. This function returns the number
2482 * of bytes succesfully read. If there was an error, it returns -1. Note
2483 * that it is also possible that we return a number of bytes smaller than the
2484 * request bytes.
2486 * 'addr' is a return value for the address object. Note that you must decref
2487 * it yourself.
2489 static ssize_t
2490 sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags,
2491 PyObject** addr)
2493 sock_addr_t addrbuf;
2494 int timeout;
2495 ssize_t n = -1;
2496 socklen_t addrlen;
2498 *addr = NULL;
2500 if (!getsockaddrlen(s, &addrlen))
2501 return -1;
2503 if (!IS_SELECTABLE(s)) {
2504 select_error();
2505 return -1;
2508 Py_BEGIN_ALLOW_THREADS
2509 memset(&addrbuf, 0, addrlen);
2510 timeout = internal_select(s, 0);
2511 if (!timeout) {
2512 #ifndef MS_WINDOWS
2513 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
2514 n = recvfrom(s->sock_fd, cbuf, len, flags,
2515 SAS2SA(&addrbuf), &addrlen);
2516 #else
2517 n = recvfrom(s->sock_fd, cbuf, len, flags,
2518 (void *) &addrbuf, &addrlen);
2519 #endif
2520 #else
2521 n = recvfrom(s->sock_fd, cbuf, len, flags,
2522 SAS2SA(&addrbuf), &addrlen);
2523 #endif
2525 Py_END_ALLOW_THREADS
2527 if (timeout == 1) {
2528 PyErr_SetString(socket_timeout, "timed out");
2529 return -1;
2531 if (n < 0) {
2532 s->errorhandler();
2533 return -1;
2536 if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
2537 addrlen, s->sock_proto)))
2538 return -1;
2540 return n;
2543 /* s.recvfrom(nbytes [,flags]) method */
2545 static PyObject *
2546 sock_recvfrom(PySocketSockObject *s, PyObject *args)
2548 PyObject *buf = NULL;
2549 PyObject *addr = NULL;
2550 PyObject *ret = NULL;
2551 int recvlen, flags = 0;
2552 ssize_t outlen;
2554 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))
2555 return NULL;
2557 if (recvlen < 0) {
2558 PyErr_SetString(PyExc_ValueError,
2559 "negative buffersize in recvfrom");
2560 return NULL;
2563 buf = PyString_FromStringAndSize((char *) 0, recvlen);
2564 if (buf == NULL)
2565 return NULL;
2567 outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf),
2568 recvlen, flags, &addr);
2569 if (outlen < 0) {
2570 goto finally;
2573 if (outlen != recvlen) {
2574 /* We did not read as many bytes as we anticipated, resize the
2575 string if possible and be succesful. */
2576 if (_PyString_Resize(&buf, outlen) < 0)
2577 /* Oopsy, not so succesful after all. */
2578 goto finally;
2581 ret = PyTuple_Pack(2, buf, addr);
2583 finally:
2584 Py_XDECREF(buf);
2585 Py_XDECREF(addr);
2586 return ret;
2589 PyDoc_STRVAR(recvfrom_doc,
2590 "recvfrom(buffersize[, flags]) -> (data, address info)\n\
2592 Like recv(buffersize, flags) but also return the sender's address info.");
2595 /* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
2597 static PyObject *
2598 sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)
2600 static char *kwlist[] = {"buffer", "nbytes", "flags", 0};
2602 int recvlen = 0, flags = 0;
2603 ssize_t readlen;
2604 char *buf;
2605 int buflen;
2607 PyObject *addr = NULL;
2609 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w#|ii:recvfrom_into",
2610 kwlist, &buf, &buflen,
2611 &recvlen, &flags))
2612 return NULL;
2613 assert(buf != 0 && buflen > 0);
2615 if (recvlen < 0) {
2616 PyErr_SetString(PyExc_ValueError,
2617 "negative buffersize in recvfrom_into");
2618 return NULL;
2620 if (recvlen == 0) {
2621 /* If nbytes was not specified, use the buffer's length */
2622 recvlen = buflen;
2625 readlen = sock_recvfrom_guts(s, buf, recvlen, flags, &addr);
2626 if (readlen < 0) {
2627 /* Return an error */
2628 Py_XDECREF(addr);
2629 return NULL;
2632 /* Return the number of bytes read and the address. Note that we do
2633 not do anything special here in the case that readlen < recvlen. */
2634 return Py_BuildValue("lN", readlen, addr);
2637 PyDoc_STRVAR(recvfrom_into_doc,
2638 "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\
2640 Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");
2643 /* s.send(data [,flags]) method */
2645 static PyObject *
2646 sock_send(PySocketSockObject *s, PyObject *args)
2648 char *buf;
2649 int len, n = -1, flags = 0, timeout;
2651 if (!PyArg_ParseTuple(args, "s#|i:send", &buf, &len, &flags))
2652 return NULL;
2654 if (!IS_SELECTABLE(s))
2655 return select_error();
2657 Py_BEGIN_ALLOW_THREADS
2658 timeout = internal_select(s, 1);
2659 if (!timeout)
2660 #ifdef __VMS
2661 n = sendsegmented(s->sock_fd, buf, len, flags);
2662 #else
2663 n = send(s->sock_fd, buf, len, flags);
2664 #endif
2665 Py_END_ALLOW_THREADS
2667 if (timeout == 1) {
2668 PyErr_SetString(socket_timeout, "timed out");
2669 return NULL;
2671 if (n < 0)
2672 return s->errorhandler();
2673 return PyInt_FromLong((long)n);
2676 PyDoc_STRVAR(send_doc,
2677 "send(data[, flags]) -> count\n\
2679 Send a data string to the socket. For the optional flags\n\
2680 argument, see the Unix manual. Return the number of bytes\n\
2681 sent; this may be less than len(data) if the network is busy.");
2684 /* s.sendall(data [,flags]) method */
2686 static PyObject *
2687 sock_sendall(PySocketSockObject *s, PyObject *args)
2689 char *buf;
2690 int len, n = -1, flags = 0, timeout;
2692 if (!PyArg_ParseTuple(args, "s#|i:sendall", &buf, &len, &flags))
2693 return NULL;
2695 if (!IS_SELECTABLE(s))
2696 return select_error();
2698 Py_BEGIN_ALLOW_THREADS
2699 do {
2700 timeout = internal_select(s, 1);
2701 n = -1;
2702 if (timeout)
2703 break;
2704 #ifdef __VMS
2705 n = sendsegmented(s->sock_fd, buf, len, flags);
2706 #else
2707 n = send(s->sock_fd, buf, len, flags);
2708 #endif
2709 if (n < 0)
2710 break;
2711 buf += n;
2712 len -= n;
2713 } while (len > 0);
2714 Py_END_ALLOW_THREADS
2716 if (timeout == 1) {
2717 PyErr_SetString(socket_timeout, "timed out");
2718 return NULL;
2720 if (n < 0)
2721 return s->errorhandler();
2723 Py_INCREF(Py_None);
2724 return Py_None;
2727 PyDoc_STRVAR(sendall_doc,
2728 "sendall(data[, flags])\n\
2730 Send a data string to the socket. For the optional flags\n\
2731 argument, see the Unix manual. This calls send() repeatedly\n\
2732 until all data is sent. If an error occurs, it's impossible\n\
2733 to tell how much data has been sent.");
2736 /* s.sendto(data, [flags,] sockaddr) method */
2738 static PyObject *
2739 sock_sendto(PySocketSockObject *s, PyObject *args)
2741 PyObject *addro;
2742 char *buf;
2743 sock_addr_t addrbuf;
2744 int addrlen, len, n = -1, flags, timeout;
2746 flags = 0;
2747 if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) {
2748 PyErr_Clear();
2749 if (!PyArg_ParseTuple(args, "s#iO:sendto",
2750 &buf, &len, &flags, &addro))
2751 return NULL;
2754 if (!IS_SELECTABLE(s))
2755 return select_error();
2757 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
2758 return NULL;
2760 Py_BEGIN_ALLOW_THREADS
2761 timeout = internal_select(s, 1);
2762 if (!timeout)
2763 n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);
2764 Py_END_ALLOW_THREADS
2766 if (timeout == 1) {
2767 PyErr_SetString(socket_timeout, "timed out");
2768 return NULL;
2770 if (n < 0)
2771 return s->errorhandler();
2772 return PyInt_FromLong((long)n);
2775 PyDoc_STRVAR(sendto_doc,
2776 "sendto(data[, flags], address) -> count\n\
2778 Like send(data, flags) but allows specifying the destination address.\n\
2779 For IP sockets, the address is a pair (hostaddr, port).");
2782 /* s.shutdown(how) method */
2784 static PyObject *
2785 sock_shutdown(PySocketSockObject *s, PyObject *arg)
2787 int how;
2788 int res;
2790 how = PyInt_AsLong(arg);
2791 if (how == -1 && PyErr_Occurred())
2792 return NULL;
2793 Py_BEGIN_ALLOW_THREADS
2794 res = shutdown(s->sock_fd, how);
2795 Py_END_ALLOW_THREADS
2796 if (res < 0)
2797 return s->errorhandler();
2798 Py_INCREF(Py_None);
2799 return Py_None;
2802 PyDoc_STRVAR(shutdown_doc,
2803 "shutdown(flag)\n\
2805 Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
2806 of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
2808 #ifdef MS_WINDOWS
2809 static PyObject*
2810 sock_ioctl(PySocketSockObject *s, PyObject *arg)
2812 unsigned long cmd = SIO_RCVALL;
2813 unsigned int option = RCVALL_ON;
2814 DWORD recv;
2816 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))
2817 return NULL;
2819 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),
2820 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {
2821 return set_error();
2823 return PyLong_FromUnsignedLong(recv);
2825 PyDoc_STRVAR(sock_ioctl_doc,
2826 "ioctl(cmd, option) -> long\n\
2828 Control the socket with WSAIoctl syscall. Currently only socket.SIO_RCVALL\n\
2829 is supported as control. Options must be one of the socket.RCVALL_*\n\
2830 constants.");
2832 #endif
2834 /* List of methods for socket objects */
2836 static PyMethodDef sock_methods[] = {
2837 {"accept", (PyCFunction)sock_accept, METH_NOARGS,
2838 accept_doc},
2839 {"bind", (PyCFunction)sock_bind, METH_O,
2840 bind_doc},
2841 {"close", (PyCFunction)sock_close, METH_NOARGS,
2842 close_doc},
2843 {"connect", (PyCFunction)sock_connect, METH_O,
2844 connect_doc},
2845 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,
2846 connect_ex_doc},
2847 #ifndef NO_DUP
2848 {"dup", (PyCFunction)sock_dup, METH_NOARGS,
2849 dup_doc},
2850 #endif
2851 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,
2852 fileno_doc},
2853 #ifdef HAVE_GETPEERNAME
2854 {"getpeername", (PyCFunction)sock_getpeername,
2855 METH_NOARGS, getpeername_doc},
2856 #endif
2857 {"getsockname", (PyCFunction)sock_getsockname,
2858 METH_NOARGS, getsockname_doc},
2859 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,
2860 getsockopt_doc},
2861 #ifdef MS_WINDOWS
2862 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,
2863 sock_ioctl_doc},
2864 #endif
2865 {"listen", (PyCFunction)sock_listen, METH_O,
2866 listen_doc},
2867 #ifndef NO_DUP
2868 {"makefile", (PyCFunction)sock_makefile, METH_VARARGS,
2869 makefile_doc},
2870 #endif
2871 {"recv", (PyCFunction)sock_recv, METH_VARARGS,
2872 recv_doc},
2873 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
2874 recv_into_doc},
2875 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
2876 recvfrom_doc},
2877 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
2878 recvfrom_into_doc},
2879 {"send", (PyCFunction)sock_send, METH_VARARGS,
2880 send_doc},
2881 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,
2882 sendall_doc},
2883 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,
2884 sendto_doc},
2885 {"setblocking", (PyCFunction)sock_setblocking, METH_O,
2886 setblocking_doc},
2887 {"settimeout", (PyCFunction)sock_settimeout, METH_O,
2888 settimeout_doc},
2889 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,
2890 gettimeout_doc},
2891 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,
2892 setsockopt_doc},
2893 {"shutdown", (PyCFunction)sock_shutdown, METH_O,
2894 shutdown_doc},
2895 #ifdef RISCOS
2896 {"sleeptaskw", (PyCFunction)sock_sleeptaskw, METH_O,
2897 sleeptaskw_doc},
2898 #endif
2899 {NULL, NULL} /* sentinel */
2902 /* SockObject members */
2903 static PyMemberDef sock_memberlist[] = {
2904 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},
2905 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},
2906 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},
2907 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},
2908 {0},
2911 /* Deallocate a socket object in response to the last Py_DECREF().
2912 First close the file description. */
2914 static void
2915 sock_dealloc(PySocketSockObject *s)
2917 if (s->sock_fd != -1)
2918 (void) SOCKETCLOSE(s->sock_fd);
2919 Py_TYPE(s)->tp_free((PyObject *)s);
2923 static PyObject *
2924 sock_repr(PySocketSockObject *s)
2926 char buf[512];
2927 #if SIZEOF_SOCKET_T > SIZEOF_LONG
2928 if (s->sock_fd > LONG_MAX) {
2929 /* this can occur on Win64, and actually there is a special
2930 ugly printf formatter for decimal pointer length integer
2931 printing, only bother if necessary*/
2932 PyErr_SetString(PyExc_OverflowError,
2933 "no printf formatter to display "
2934 "the socket descriptor in decimal");
2935 return NULL;
2937 #endif
2938 PyOS_snprintf(
2939 buf, sizeof(buf),
2940 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
2941 (long)s->sock_fd, s->sock_family,
2942 s->sock_type,
2943 s->sock_proto);
2944 return PyString_FromString(buf);
2948 /* Create a new, uninitialized socket object. */
2950 static PyObject *
2951 sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2953 PyObject *new;
2955 new = type->tp_alloc(type, 0);
2956 if (new != NULL) {
2957 ((PySocketSockObject *)new)->sock_fd = -1;
2958 ((PySocketSockObject *)new)->sock_timeout = -1.0;
2959 ((PySocketSockObject *)new)->errorhandler = &set_error;
2961 return new;
2965 /* Initialize a new socket object. */
2967 /*ARGSUSED*/
2968 static int
2969 sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)
2971 PySocketSockObject *s = (PySocketSockObject *)self;
2972 SOCKET_T fd;
2973 int family = AF_INET, type = SOCK_STREAM, proto = 0;
2974 static char *keywords[] = {"family", "type", "proto", 0};
2976 if (!PyArg_ParseTupleAndKeywords(args, kwds,
2977 "|iii:socket", keywords,
2978 &family, &type, &proto))
2979 return -1;
2981 Py_BEGIN_ALLOW_THREADS
2982 fd = socket(family, type, proto);
2983 Py_END_ALLOW_THREADS
2985 #ifdef MS_WINDOWS
2986 if (fd == INVALID_SOCKET)
2987 #else
2988 if (fd < 0)
2989 #endif
2991 set_error();
2992 return -1;
2994 init_sockobject(s, fd, family, type, proto);
2996 return 0;
3001 /* Type object for socket objects. */
3003 static PyTypeObject sock_type = {
3004 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
3005 "_socket.socket", /* tp_name */
3006 sizeof(PySocketSockObject), /* tp_basicsize */
3007 0, /* tp_itemsize */
3008 (destructor)sock_dealloc, /* tp_dealloc */
3009 0, /* tp_print */
3010 0, /* tp_getattr */
3011 0, /* tp_setattr */
3012 0, /* tp_compare */
3013 (reprfunc)sock_repr, /* tp_repr */
3014 0, /* tp_as_number */
3015 0, /* tp_as_sequence */
3016 0, /* tp_as_mapping */
3017 0, /* tp_hash */
3018 0, /* tp_call */
3019 0, /* tp_str */
3020 PyObject_GenericGetAttr, /* tp_getattro */
3021 0, /* tp_setattro */
3022 0, /* tp_as_buffer */
3023 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
3024 sock_doc, /* tp_doc */
3025 0, /* tp_traverse */
3026 0, /* tp_clear */
3027 0, /* tp_richcompare */
3028 0, /* tp_weaklistoffset */
3029 0, /* tp_iter */
3030 0, /* tp_iternext */
3031 sock_methods, /* tp_methods */
3032 sock_memberlist, /* tp_members */
3033 0, /* tp_getset */
3034 0, /* tp_base */
3035 0, /* tp_dict */
3036 0, /* tp_descr_get */
3037 0, /* tp_descr_set */
3038 0, /* tp_dictoffset */
3039 sock_initobj, /* tp_init */
3040 PyType_GenericAlloc, /* tp_alloc */
3041 sock_new, /* tp_new */
3042 PyObject_Del, /* tp_free */
3046 /* Python interface to gethostname(). */
3048 /*ARGSUSED*/
3049 static PyObject *
3050 socket_gethostname(PyObject *self, PyObject *unused)
3052 char buf[1024];
3053 int res;
3054 Py_BEGIN_ALLOW_THREADS
3055 res = gethostname(buf, (int) sizeof buf - 1);
3056 Py_END_ALLOW_THREADS
3057 if (res < 0)
3058 return set_error();
3059 buf[sizeof buf - 1] = '\0';
3060 return PyString_FromString(buf);
3063 PyDoc_STRVAR(gethostname_doc,
3064 "gethostname() -> string\n\
3066 Return the current host name.");
3069 /* Python interface to gethostbyname(name). */
3071 /*ARGSUSED*/
3072 static PyObject *
3073 socket_gethostbyname(PyObject *self, PyObject *args)
3075 char *name;
3076 sock_addr_t addrbuf;
3078 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
3079 return NULL;
3080 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)
3081 return NULL;
3082 return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));
3085 PyDoc_STRVAR(gethostbyname_doc,
3086 "gethostbyname(host) -> address\n\
3088 Return the IP address (a string of the form '255.255.255.255') for a host.");
3091 /* Convenience function common to gethostbyname_ex and gethostbyaddr */
3093 static PyObject *
3094 gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
3096 char **pch;
3097 PyObject *rtn_tuple = (PyObject *)NULL;
3098 PyObject *name_list = (PyObject *)NULL;
3099 PyObject *addr_list = (PyObject *)NULL;
3100 PyObject *tmp;
3102 if (h == NULL) {
3103 /* Let's get real error message to return */
3104 #ifndef RISCOS
3105 set_herror(h_errno);
3106 #else
3107 PyErr_SetString(socket_error, "host not found");
3108 #endif
3109 return NULL;
3112 if (h->h_addrtype != af) {
3113 /* Let's get real error message to return */
3114 PyErr_SetString(socket_error,
3115 (char *)strerror(EAFNOSUPPORT));
3117 return NULL;
3120 switch (af) {
3122 case AF_INET:
3123 if (alen < sizeof(struct sockaddr_in))
3124 return NULL;
3125 break;
3127 #ifdef ENABLE_IPV6
3128 case AF_INET6:
3129 if (alen < sizeof(struct sockaddr_in6))
3130 return NULL;
3131 break;
3132 #endif
3136 if ((name_list = PyList_New(0)) == NULL)
3137 goto err;
3139 if ((addr_list = PyList_New(0)) == NULL)
3140 goto err;
3142 /* SF #1511317: h_aliases can be NULL */
3143 if (h->h_aliases) {
3144 for (pch = h->h_aliases; *pch != NULL; pch++) {
3145 int status;
3146 tmp = PyString_FromString(*pch);
3147 if (tmp == NULL)
3148 goto err;
3150 status = PyList_Append(name_list, tmp);
3151 Py_DECREF(tmp);
3153 if (status)
3154 goto err;
3158 for (pch = h->h_addr_list; *pch != NULL; pch++) {
3159 int status;
3161 switch (af) {
3163 case AF_INET:
3165 struct sockaddr_in sin;
3166 memset(&sin, 0, sizeof(sin));
3167 sin.sin_family = af;
3168 #ifdef HAVE_SOCKADDR_SA_LEN
3169 sin.sin_len = sizeof(sin);
3170 #endif
3171 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
3172 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
3174 if (pch == h->h_addr_list && alen >= sizeof(sin))
3175 memcpy((char *) addr, &sin, sizeof(sin));
3176 break;
3179 #ifdef ENABLE_IPV6
3180 case AF_INET6:
3182 struct sockaddr_in6 sin6;
3183 memset(&sin6, 0, sizeof(sin6));
3184 sin6.sin6_family = af;
3185 #ifdef HAVE_SOCKADDR_SA_LEN
3186 sin6.sin6_len = sizeof(sin6);
3187 #endif
3188 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
3189 tmp = makeipaddr((struct sockaddr *)&sin6,
3190 sizeof(sin6));
3192 if (pch == h->h_addr_list && alen >= sizeof(sin6))
3193 memcpy((char *) addr, &sin6, sizeof(sin6));
3194 break;
3196 #endif
3198 default: /* can't happen */
3199 PyErr_SetString(socket_error,
3200 "unsupported address family");
3201 return NULL;
3204 if (tmp == NULL)
3205 goto err;
3207 status = PyList_Append(addr_list, tmp);
3208 Py_DECREF(tmp);
3210 if (status)
3211 goto err;
3214 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
3216 err:
3217 Py_XDECREF(name_list);
3218 Py_XDECREF(addr_list);
3219 return rtn_tuple;
3223 /* Python interface to gethostbyname_ex(name). */
3225 /*ARGSUSED*/
3226 static PyObject *
3227 socket_gethostbyname_ex(PyObject *self, PyObject *args)
3229 char *name;
3230 struct hostent *h;
3231 #ifdef ENABLE_IPV6
3232 struct sockaddr_storage addr;
3233 #else
3234 struct sockaddr_in addr;
3235 #endif
3236 struct sockaddr *sa;
3237 PyObject *ret;
3238 #ifdef HAVE_GETHOSTBYNAME_R
3239 struct hostent hp_allocated;
3240 #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
3241 struct hostent_data data;
3242 #else
3243 char buf[16384];
3244 int buf_len = (sizeof buf) - 1;
3245 int errnop;
3246 #endif
3247 #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3248 int result;
3249 #endif
3250 #endif /* HAVE_GETHOSTBYNAME_R */
3252 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
3253 return NULL;
3254 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)
3255 return NULL;
3256 Py_BEGIN_ALLOW_THREADS
3257 #ifdef HAVE_GETHOSTBYNAME_R
3258 #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3259 result = gethostbyname_r(name, &hp_allocated, buf, buf_len,
3260 &h, &errnop);
3261 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
3262 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
3263 #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
3264 memset((void *) &data, '\0', sizeof(data));
3265 result = gethostbyname_r(name, &hp_allocated, &data);
3266 h = (result != 0) ? NULL : &hp_allocated;
3267 #endif
3268 #else /* not HAVE_GETHOSTBYNAME_R */
3269 #ifdef USE_GETHOSTBYNAME_LOCK
3270 PyThread_acquire_lock(netdb_lock, 1);
3271 #endif
3272 h = gethostbyname(name);
3273 #endif /* HAVE_GETHOSTBYNAME_R */
3274 Py_END_ALLOW_THREADS
3275 /* Some C libraries would require addr.__ss_family instead of
3276 addr.ss_family.
3277 Therefore, we cast the sockaddr_storage into sockaddr to
3278 access sa_family. */
3279 sa = (struct sockaddr*)&addr;
3280 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),
3281 sa->sa_family);
3282 #ifdef USE_GETHOSTBYNAME_LOCK
3283 PyThread_release_lock(netdb_lock);
3284 #endif
3285 return ret;
3288 PyDoc_STRVAR(ghbn_ex_doc,
3289 "gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
3291 Return the true host name, a list of aliases, and a list of IP addresses,\n\
3292 for a host. The host argument is a string giving a host name or IP number.");
3295 /* Python interface to gethostbyaddr(IP). */
3297 /*ARGSUSED*/
3298 static PyObject *
3299 socket_gethostbyaddr(PyObject *self, PyObject *args)
3301 #ifdef ENABLE_IPV6
3302 struct sockaddr_storage addr;
3303 #else
3304 struct sockaddr_in addr;
3305 #endif
3306 struct sockaddr *sa = (struct sockaddr *)&addr;
3307 char *ip_num;
3308 struct hostent *h;
3309 PyObject *ret;
3310 #ifdef HAVE_GETHOSTBYNAME_R
3311 struct hostent hp_allocated;
3312 #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
3313 struct hostent_data data;
3314 #else
3315 char buf[16384];
3316 int buf_len = (sizeof buf) - 1;
3317 int errnop;
3318 #endif
3319 #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3320 int result;
3321 #endif
3322 #endif /* HAVE_GETHOSTBYNAME_R */
3323 char *ap;
3324 int al;
3325 int af;
3327 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
3328 return NULL;
3329 af = AF_UNSPEC;
3330 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)
3331 return NULL;
3332 af = sa->sa_family;
3333 ap = NULL;
3334 al = 0;
3335 switch (af) {
3336 case AF_INET:
3337 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
3338 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
3339 break;
3340 #ifdef ENABLE_IPV6
3341 case AF_INET6:
3342 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
3343 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
3344 break;
3345 #endif
3346 default:
3347 PyErr_SetString(socket_error, "unsupported address family");
3348 return NULL;
3350 Py_BEGIN_ALLOW_THREADS
3351 #ifdef HAVE_GETHOSTBYNAME_R
3352 #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3353 result = gethostbyaddr_r(ap, al, af,
3354 &hp_allocated, buf, buf_len,
3355 &h, &errnop);
3356 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
3357 h = gethostbyaddr_r(ap, al, af,
3358 &hp_allocated, buf, buf_len, &errnop);
3359 #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
3360 memset((void *) &data, '\0', sizeof(data));
3361 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
3362 h = (result != 0) ? NULL : &hp_allocated;
3363 #endif
3364 #else /* not HAVE_GETHOSTBYNAME_R */
3365 #ifdef USE_GETHOSTBYNAME_LOCK
3366 PyThread_acquire_lock(netdb_lock, 1);
3367 #endif
3368 h = gethostbyaddr(ap, al, af);
3369 #endif /* HAVE_GETHOSTBYNAME_R */
3370 Py_END_ALLOW_THREADS
3371 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
3372 #ifdef USE_GETHOSTBYNAME_LOCK
3373 PyThread_release_lock(netdb_lock);
3374 #endif
3375 return ret;
3378 PyDoc_STRVAR(gethostbyaddr_doc,
3379 "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
3381 Return the true host name, a list of aliases, and a list of IP addresses,\n\
3382 for a host. The host argument is a string giving a host name or IP number.");
3385 /* Python interface to getservbyname(name).
3386 This only returns the port number, since the other info is already
3387 known or not useful (like the list of aliases). */
3389 /*ARGSUSED*/
3390 static PyObject *
3391 socket_getservbyname(PyObject *self, PyObject *args)
3393 char *name, *proto=NULL;
3394 struct servent *sp;
3395 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))
3396 return NULL;
3397 Py_BEGIN_ALLOW_THREADS
3398 sp = getservbyname(name, proto);
3399 Py_END_ALLOW_THREADS
3400 if (sp == NULL) {
3401 PyErr_SetString(socket_error, "service/proto not found");
3402 return NULL;
3404 return PyInt_FromLong((long) ntohs(sp->s_port));
3407 PyDoc_STRVAR(getservbyname_doc,
3408 "getservbyname(servicename[, protocolname]) -> integer\n\
3410 Return a port number from a service name and protocol name.\n\
3411 The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3412 otherwise any protocol will match.");
3415 /* Python interface to getservbyport(port).
3416 This only returns the service name, since the other info is already
3417 known or not useful (like the list of aliases). */
3419 /*ARGSUSED*/
3420 static PyObject *
3421 socket_getservbyport(PyObject *self, PyObject *args)
3423 unsigned short port;
3424 char *proto=NULL;
3425 struct servent *sp;
3426 if (!PyArg_ParseTuple(args, "H|s:getservbyport", &port, &proto))
3427 return NULL;
3428 Py_BEGIN_ALLOW_THREADS
3429 sp = getservbyport(htons(port), proto);
3430 Py_END_ALLOW_THREADS
3431 if (sp == NULL) {
3432 PyErr_SetString(socket_error, "port/proto not found");
3433 return NULL;
3435 return PyString_FromString(sp->s_name);
3438 PyDoc_STRVAR(getservbyport_doc,
3439 "getservbyport(port[, protocolname]) -> string\n\
3441 Return the service name from a port number and protocol name.\n\
3442 The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3443 otherwise any protocol will match.");
3445 /* Python interface to getprotobyname(name).
3446 This only returns the protocol number, since the other info is
3447 already known or not useful (like the list of aliases). */
3449 /*ARGSUSED*/
3450 static PyObject *
3451 socket_getprotobyname(PyObject *self, PyObject *args)
3453 char *name;
3454 struct protoent *sp;
3455 #ifdef __BEOS__
3456 /* Not available in BeOS yet. - [cjh] */
3457 PyErr_SetString(socket_error, "getprotobyname not supported");
3458 return NULL;
3459 #else
3460 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
3461 return NULL;
3462 Py_BEGIN_ALLOW_THREADS
3463 sp = getprotobyname(name);
3464 Py_END_ALLOW_THREADS
3465 if (sp == NULL) {
3466 PyErr_SetString(socket_error, "protocol not found");
3467 return NULL;
3469 return PyInt_FromLong((long) sp->p_proto);
3470 #endif
3473 PyDoc_STRVAR(getprotobyname_doc,
3474 "getprotobyname(name) -> integer\n\
3476 Return the protocol number for the named protocol. (Rarely used.)");
3479 #ifdef HAVE_SOCKETPAIR
3480 /* Create a pair of sockets using the socketpair() function.
3481 Arguments as for socket() except the default family is AF_UNIX if
3482 defined on the platform; otherwise, the default is AF_INET. */
3484 /*ARGSUSED*/
3485 static PyObject *
3486 socket_socketpair(PyObject *self, PyObject *args)
3488 PySocketSockObject *s0 = NULL, *s1 = NULL;
3489 SOCKET_T sv[2];
3490 int family, type = SOCK_STREAM, proto = 0;
3491 PyObject *res = NULL;
3493 #if defined(AF_UNIX)
3494 family = AF_UNIX;
3495 #else
3496 family = AF_INET;
3497 #endif
3498 if (!PyArg_ParseTuple(args, "|iii:socketpair",
3499 &family, &type, &proto))
3500 return NULL;
3501 /* Create a pair of socket fds */
3502 if (socketpair(family, type, proto, sv) < 0)
3503 return set_error();
3504 s0 = new_sockobject(sv[0], family, type, proto);
3505 if (s0 == NULL)
3506 goto finally;
3507 s1 = new_sockobject(sv[1], family, type, proto);
3508 if (s1 == NULL)
3509 goto finally;
3510 res = PyTuple_Pack(2, s0, s1);
3512 finally:
3513 if (res == NULL) {
3514 if (s0 == NULL)
3515 SOCKETCLOSE(sv[0]);
3516 if (s1 == NULL)
3517 SOCKETCLOSE(sv[1]);
3519 Py_XDECREF(s0);
3520 Py_XDECREF(s1);
3521 return res;
3524 PyDoc_STRVAR(socketpair_doc,
3525 "socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
3527 Create a pair of socket objects from the sockets returned by the platform\n\
3528 socketpair() function.\n\
3529 The arguments are the same as for socket() except the default family is\n\
3530 AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
3532 #endif /* HAVE_SOCKETPAIR */
3535 #ifndef NO_DUP
3536 /* Create a socket object from a numeric file description.
3537 Useful e.g. if stdin is a socket.
3538 Additional arguments as for socket(). */
3540 /*ARGSUSED*/
3541 static PyObject *
3542 socket_fromfd(PyObject *self, PyObject *args)
3544 PySocketSockObject *s;
3545 SOCKET_T fd;
3546 int family, type, proto = 0;
3547 if (!PyArg_ParseTuple(args, "iii|i:fromfd",
3548 &fd, &family, &type, &proto))
3549 return NULL;
3550 /* Dup the fd so it and the socket can be closed independently */
3551 fd = dup(fd);
3552 if (fd < 0)
3553 return set_error();
3554 s = new_sockobject(fd, family, type, proto);
3555 return (PyObject *) s;
3558 PyDoc_STRVAR(fromfd_doc,
3559 "fromfd(fd, family, type[, proto]) -> socket object\n\
3561 Create a socket object from a duplicate of the given\n\
3562 file descriptor.\n\
3563 The remaining arguments are the same as for socket().");
3565 #endif /* NO_DUP */
3568 static PyObject *
3569 socket_ntohs(PyObject *self, PyObject *args)
3571 int x1, x2;
3573 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
3574 return NULL;
3576 if (x1 < 0) {
3577 PyErr_SetString(PyExc_OverflowError,
3578 "can't convert negative number to unsigned long");
3579 return NULL;
3581 x2 = (unsigned int)ntohs((unsigned short)x1);
3582 return PyInt_FromLong(x2);
3585 PyDoc_STRVAR(ntohs_doc,
3586 "ntohs(integer) -> integer\n\
3588 Convert a 16-bit integer from network to host byte order.");
3591 static PyObject *
3592 socket_ntohl(PyObject *self, PyObject *arg)
3594 unsigned long x;
3596 if (PyInt_Check(arg)) {
3597 x = PyInt_AS_LONG(arg);
3598 if (x == (unsigned long) -1 && PyErr_Occurred())
3599 return NULL;
3600 if ((long)x < 0) {
3601 PyErr_SetString(PyExc_OverflowError,
3602 "can't convert negative number to unsigned long");
3603 return NULL;
3606 else if (PyLong_Check(arg)) {
3607 x = PyLong_AsUnsignedLong(arg);
3608 if (x == (unsigned long) -1 && PyErr_Occurred())
3609 return NULL;
3610 #if SIZEOF_LONG > 4
3612 unsigned long y;
3613 /* only want the trailing 32 bits */
3614 y = x & 0xFFFFFFFFUL;
3615 if (y ^ x)
3616 return PyErr_Format(PyExc_OverflowError,
3617 "long int larger than 32 bits");
3618 x = y;
3620 #endif
3622 else
3623 return PyErr_Format(PyExc_TypeError,
3624 "expected int/long, %s found",
3625 Py_TYPE(arg)->tp_name);
3626 if (x == (unsigned long) -1 && PyErr_Occurred())
3627 return NULL;
3628 return PyLong_FromUnsignedLong(ntohl(x));
3631 PyDoc_STRVAR(ntohl_doc,
3632 "ntohl(integer) -> integer\n\
3634 Convert a 32-bit integer from network to host byte order.");
3637 static PyObject *
3638 socket_htons(PyObject *self, PyObject *args)
3640 int x1, x2;
3642 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
3643 return NULL;
3645 if (x1 < 0) {
3646 PyErr_SetString(PyExc_OverflowError,
3647 "can't convert negative number to unsigned long");
3648 return NULL;
3650 x2 = (unsigned int)htons((unsigned short)x1);
3651 return PyInt_FromLong(x2);
3654 PyDoc_STRVAR(htons_doc,
3655 "htons(integer) -> integer\n\
3657 Convert a 16-bit integer from host to network byte order.");
3660 static PyObject *
3661 socket_htonl(PyObject *self, PyObject *arg)
3663 unsigned long x;
3665 if (PyInt_Check(arg)) {
3666 x = PyInt_AS_LONG(arg);
3667 if (x == (unsigned long) -1 && PyErr_Occurred())
3668 return NULL;
3669 if ((long)x < 0) {
3670 PyErr_SetString(PyExc_OverflowError,
3671 "can't convert negative number to unsigned long");
3672 return NULL;
3675 else if (PyLong_Check(arg)) {
3676 x = PyLong_AsUnsignedLong(arg);
3677 if (x == (unsigned long) -1 && PyErr_Occurred())
3678 return NULL;
3679 #if SIZEOF_LONG > 4
3681 unsigned long y;
3682 /* only want the trailing 32 bits */
3683 y = x & 0xFFFFFFFFUL;
3684 if (y ^ x)
3685 return PyErr_Format(PyExc_OverflowError,
3686 "long int larger than 32 bits");
3687 x = y;
3689 #endif
3691 else
3692 return PyErr_Format(PyExc_TypeError,
3693 "expected int/long, %s found",
3694 Py_TYPE(arg)->tp_name);
3695 return PyLong_FromUnsignedLong(htonl((unsigned long)x));
3698 PyDoc_STRVAR(htonl_doc,
3699 "htonl(integer) -> integer\n\
3701 Convert a 32-bit integer from host to network byte order.");
3703 /* socket.inet_aton() and socket.inet_ntoa() functions. */
3705 PyDoc_STRVAR(inet_aton_doc,
3706 "inet_aton(string) -> packed 32-bit IP representation\n\
3708 Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
3709 binary format used in low-level network functions.");
3711 static PyObject*
3712 socket_inet_aton(PyObject *self, PyObject *args)
3714 #ifndef INADDR_NONE
3715 #define INADDR_NONE (-1)
3716 #endif
3717 #ifdef HAVE_INET_ATON
3718 struct in_addr buf;
3719 #endif
3721 #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3722 /* Have to use inet_addr() instead */
3723 unsigned long packed_addr;
3724 #endif
3725 char *ip_addr;
3727 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))
3728 return NULL;
3731 #ifdef HAVE_INET_ATON
3733 #ifdef USE_INET_ATON_WEAKLINK
3734 if (inet_aton != NULL) {
3735 #endif
3736 if (inet_aton(ip_addr, &buf))
3737 return PyString_FromStringAndSize((char *)(&buf),
3738 sizeof(buf));
3740 PyErr_SetString(socket_error,
3741 "illegal IP address string passed to inet_aton");
3742 return NULL;
3744 #ifdef USE_INET_ATON_WEAKLINK
3745 } else {
3746 #endif
3748 #endif
3750 #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3752 /* special-case this address as inet_addr might return INADDR_NONE
3753 * for this */
3754 if (strcmp(ip_addr, "255.255.255.255") == 0) {
3755 packed_addr = 0xFFFFFFFF;
3756 } else {
3758 packed_addr = inet_addr(ip_addr);
3760 if (packed_addr == INADDR_NONE) { /* invalid address */
3761 PyErr_SetString(socket_error,
3762 "illegal IP address string passed to inet_aton");
3763 return NULL;
3766 return PyString_FromStringAndSize((char *) &packed_addr,
3767 sizeof(packed_addr));
3769 #ifdef USE_INET_ATON_WEAKLINK
3771 #endif
3773 #endif
3776 PyDoc_STRVAR(inet_ntoa_doc,
3777 "inet_ntoa(packed_ip) -> ip_address_string\n\
3779 Convert an IP address from 32-bit packed binary format to string format");
3781 static PyObject*
3782 socket_inet_ntoa(PyObject *self, PyObject *args)
3784 char *packed_str;
3785 int addr_len;
3786 struct in_addr packed_addr;
3788 if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {
3789 return NULL;
3792 if (addr_len != sizeof(packed_addr)) {
3793 PyErr_SetString(socket_error,
3794 "packed IP wrong length for inet_ntoa");
3795 return NULL;
3798 memcpy(&packed_addr, packed_str, addr_len);
3800 return PyString_FromString(inet_ntoa(packed_addr));
3803 #ifdef HAVE_INET_PTON
3805 PyDoc_STRVAR(inet_pton_doc,
3806 "inet_pton(af, ip) -> packed IP address string\n\
3808 Convert an IP address from string format to a packed string suitable\n\
3809 for use with low-level network functions.");
3811 static PyObject *
3812 socket_inet_pton(PyObject *self, PyObject *args)
3814 int af;
3815 char* ip;
3816 int retval;
3817 #ifdef ENABLE_IPV6
3818 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];
3819 #else
3820 char packed[sizeof(struct in_addr)];
3821 #endif
3822 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {
3823 return NULL;
3826 #if !defined(ENABLE_IPV6) && defined(AF_INET6)
3827 if(af == AF_INET6) {
3828 PyErr_SetString(socket_error,
3829 "can't use AF_INET6, IPv6 is disabled");
3830 return NULL;
3832 #endif
3834 retval = inet_pton(af, ip, packed);
3835 if (retval < 0) {
3836 PyErr_SetFromErrno(socket_error);
3837 return NULL;
3838 } else if (retval == 0) {
3839 PyErr_SetString(socket_error,
3840 "illegal IP address string passed to inet_pton");
3841 return NULL;
3842 } else if (af == AF_INET) {
3843 return PyString_FromStringAndSize(packed,
3844 sizeof(struct in_addr));
3845 #ifdef ENABLE_IPV6
3846 } else if (af == AF_INET6) {
3847 return PyString_FromStringAndSize(packed,
3848 sizeof(struct in6_addr));
3849 #endif
3850 } else {
3851 PyErr_SetString(socket_error, "unknown address family");
3852 return NULL;
3856 PyDoc_STRVAR(inet_ntop_doc,
3857 "inet_ntop(af, packed_ip) -> string formatted IP address\n\
3859 Convert a packed IP address of the given family to string format.");
3861 static PyObject *
3862 socket_inet_ntop(PyObject *self, PyObject *args)
3864 int af;
3865 char* packed;
3866 int len;
3867 const char* retval;
3868 #ifdef ENABLE_IPV6
3869 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];
3870 #else
3871 char ip[INET_ADDRSTRLEN + 1];
3872 #endif
3874 /* Guarantee NUL-termination for PyString_FromString() below */
3875 memset((void *) &ip[0], '\0', sizeof(ip));
3877 if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {
3878 return NULL;
3881 if (af == AF_INET) {
3882 if (len != sizeof(struct in_addr)) {
3883 PyErr_SetString(PyExc_ValueError,
3884 "invalid length of packed IP address string");
3885 return NULL;
3887 #ifdef ENABLE_IPV6
3888 } else if (af == AF_INET6) {
3889 if (len != sizeof(struct in6_addr)) {
3890 PyErr_SetString(PyExc_ValueError,
3891 "invalid length of packed IP address string");
3892 return NULL;
3894 #endif
3895 } else {
3896 PyErr_Format(PyExc_ValueError,
3897 "unknown address family %d", af);
3898 return NULL;
3901 retval = inet_ntop(af, packed, ip, sizeof(ip));
3902 if (!retval) {
3903 PyErr_SetFromErrno(socket_error);
3904 return NULL;
3905 } else {
3906 return PyString_FromString(retval);
3909 /* NOTREACHED */
3910 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");
3911 return NULL;
3914 #endif /* HAVE_INET_PTON */
3916 /* Python interface to getaddrinfo(host, port). */
3918 /*ARGSUSED*/
3919 static PyObject *
3920 socket_getaddrinfo(PyObject *self, PyObject *args)
3922 struct addrinfo hints, *res;
3923 struct addrinfo *res0 = NULL;
3924 PyObject *hobj = NULL;
3925 PyObject *pobj = (PyObject *)NULL;
3926 char pbuf[30];
3927 char *hptr, *pptr;
3928 int family, socktype, protocol, flags;
3929 int error;
3930 PyObject *all = (PyObject *)NULL;
3931 PyObject *single = (PyObject *)NULL;
3932 PyObject *idna = NULL;
3934 family = socktype = protocol = flags = 0;
3935 family = AF_UNSPEC;
3936 if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",
3937 &hobj, &pobj, &family, &socktype,
3938 &protocol, &flags)) {
3939 return NULL;
3941 if (hobj == Py_None) {
3942 hptr = NULL;
3943 } else if (PyUnicode_Check(hobj)) {
3944 idna = PyObject_CallMethod(hobj, "encode", "s", "idna");
3945 if (!idna)
3946 return NULL;
3947 hptr = PyString_AsString(idna);
3948 } else if (PyString_Check(hobj)) {
3949 hptr = PyString_AsString(hobj);
3950 } else {
3951 PyErr_SetString(PyExc_TypeError,
3952 "getaddrinfo() argument 1 must be string or None");
3953 return NULL;
3955 if (PyInt_Check(pobj)) {
3956 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
3957 pptr = pbuf;
3958 } else if (PyString_Check(pobj)) {
3959 pptr = PyString_AsString(pobj);
3960 } else if (pobj == Py_None) {
3961 pptr = (char *)NULL;
3962 } else {
3963 PyErr_SetString(socket_error, "Int or String expected");
3964 goto err;
3966 memset(&hints, 0, sizeof(hints));
3967 hints.ai_family = family;
3968 hints.ai_socktype = socktype;
3969 hints.ai_protocol = protocol;
3970 hints.ai_flags = flags;
3971 Py_BEGIN_ALLOW_THREADS
3972 ACQUIRE_GETADDRINFO_LOCK
3973 error = getaddrinfo(hptr, pptr, &hints, &res0);
3974 Py_END_ALLOW_THREADS
3975 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
3976 if (error) {
3977 set_gaierror(error);
3978 goto err;
3981 if ((all = PyList_New(0)) == NULL)
3982 goto err;
3983 for (res = res0; res; res = res->ai_next) {
3984 PyObject *addr =
3985 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);
3986 if (addr == NULL)
3987 goto err;
3988 single = Py_BuildValue("iiisO", res->ai_family,
3989 res->ai_socktype, res->ai_protocol,
3990 res->ai_canonname ? res->ai_canonname : "",
3991 addr);
3992 Py_DECREF(addr);
3993 if (single == NULL)
3994 goto err;
3996 if (PyList_Append(all, single))
3997 goto err;
3998 Py_XDECREF(single);
4000 Py_XDECREF(idna);
4001 if (res0)
4002 freeaddrinfo(res0);
4003 return all;
4004 err:
4005 Py_XDECREF(single);
4006 Py_XDECREF(all);
4007 Py_XDECREF(idna);
4008 if (res0)
4009 freeaddrinfo(res0);
4010 return (PyObject *)NULL;
4013 PyDoc_STRVAR(getaddrinfo_doc,
4014 "getaddrinfo(host, port [, family, socktype, proto, flags])\n\
4015 -> list of (family, socktype, proto, canonname, sockaddr)\n\
4017 Resolve host and port into addrinfo struct.");
4019 /* Python interface to getnameinfo(sa, flags). */
4021 /*ARGSUSED*/
4022 static PyObject *
4023 socket_getnameinfo(PyObject *self, PyObject *args)
4025 PyObject *sa = (PyObject *)NULL;
4026 int flags;
4027 char *hostp;
4028 int port, flowinfo, scope_id;
4029 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
4030 struct addrinfo hints, *res = NULL;
4031 int error;
4032 PyObject *ret = (PyObject *)NULL;
4034 flags = flowinfo = scope_id = 0;
4035 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))
4036 return NULL;
4037 if (!PyArg_ParseTuple(sa, "si|ii",
4038 &hostp, &port, &flowinfo, &scope_id))
4039 return NULL;
4040 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
4041 memset(&hints, 0, sizeof(hints));
4042 hints.ai_family = AF_UNSPEC;
4043 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
4044 Py_BEGIN_ALLOW_THREADS
4045 ACQUIRE_GETADDRINFO_LOCK
4046 error = getaddrinfo(hostp, pbuf, &hints, &res);
4047 Py_END_ALLOW_THREADS
4048 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
4049 if (error) {
4050 set_gaierror(error);
4051 goto fail;
4053 if (res->ai_next) {
4054 PyErr_SetString(socket_error,
4055 "sockaddr resolved to multiple addresses");
4056 goto fail;
4058 switch (res->ai_family) {
4059 case AF_INET:
4061 char *t1;
4062 int t2;
4063 if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) {
4064 PyErr_SetString(socket_error,
4065 "IPv4 sockaddr must be 2 tuple");
4066 goto fail;
4068 break;
4070 #ifdef ENABLE_IPV6
4071 case AF_INET6:
4073 struct sockaddr_in6 *sin6;
4074 sin6 = (struct sockaddr_in6 *)res->ai_addr;
4075 sin6->sin6_flowinfo = flowinfo;
4076 sin6->sin6_scope_id = scope_id;
4077 break;
4079 #endif
4081 error = getnameinfo(res->ai_addr, res->ai_addrlen,
4082 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
4083 if (error) {
4084 set_gaierror(error);
4085 goto fail;
4087 ret = Py_BuildValue("ss", hbuf, pbuf);
4089 fail:
4090 if (res)
4091 freeaddrinfo(res);
4092 return ret;
4095 PyDoc_STRVAR(getnameinfo_doc,
4096 "getnameinfo(sockaddr, flags) --> (host, port)\n\
4098 Get host and port for a sockaddr.");
4101 /* Python API to getting and setting the default timeout value. */
4103 static PyObject *
4104 socket_getdefaulttimeout(PyObject *self)
4106 if (defaulttimeout < 0.0) {
4107 Py_INCREF(Py_None);
4108 return Py_None;
4110 else
4111 return PyFloat_FromDouble(defaulttimeout);
4114 PyDoc_STRVAR(getdefaulttimeout_doc,
4115 "getdefaulttimeout() -> timeout\n\
4117 Returns the default timeout in floating seconds for new socket objects.\n\
4118 A value of None indicates that new socket objects have no timeout.\n\
4119 When the socket module is first imported, the default is None.");
4121 static PyObject *
4122 socket_setdefaulttimeout(PyObject *self, PyObject *arg)
4124 double timeout;
4126 if (arg == Py_None)
4127 timeout = -1.0;
4128 else {
4129 timeout = PyFloat_AsDouble(arg);
4130 if (timeout < 0.0) {
4131 if (!PyErr_Occurred())
4132 PyErr_SetString(PyExc_ValueError,
4133 "Timeout value out of range");
4134 return NULL;
4138 defaulttimeout = timeout;
4140 Py_INCREF(Py_None);
4141 return Py_None;
4144 PyDoc_STRVAR(setdefaulttimeout_doc,
4145 "setdefaulttimeout(timeout)\n\
4147 Set the default timeout in floating seconds for new socket objects.\n\
4148 A value of None indicates that new socket objects have no timeout.\n\
4149 When the socket module is first imported, the default is None.");
4152 /* List of functions exported by this module. */
4154 static PyMethodDef socket_methods[] = {
4155 {"gethostbyname", socket_gethostbyname,
4156 METH_VARARGS, gethostbyname_doc},
4157 {"gethostbyname_ex", socket_gethostbyname_ex,
4158 METH_VARARGS, ghbn_ex_doc},
4159 {"gethostbyaddr", socket_gethostbyaddr,
4160 METH_VARARGS, gethostbyaddr_doc},
4161 {"gethostname", socket_gethostname,
4162 METH_NOARGS, gethostname_doc},
4163 {"getservbyname", socket_getservbyname,
4164 METH_VARARGS, getservbyname_doc},
4165 {"getservbyport", socket_getservbyport,
4166 METH_VARARGS, getservbyport_doc},
4167 {"getprotobyname", socket_getprotobyname,
4168 METH_VARARGS, getprotobyname_doc},
4169 #ifndef NO_DUP
4170 {"fromfd", socket_fromfd,
4171 METH_VARARGS, fromfd_doc},
4172 #endif
4173 #ifdef HAVE_SOCKETPAIR
4174 {"socketpair", socket_socketpair,
4175 METH_VARARGS, socketpair_doc},
4176 #endif
4177 {"ntohs", socket_ntohs,
4178 METH_VARARGS, ntohs_doc},
4179 {"ntohl", socket_ntohl,
4180 METH_O, ntohl_doc},
4181 {"htons", socket_htons,
4182 METH_VARARGS, htons_doc},
4183 {"htonl", socket_htonl,
4184 METH_O, htonl_doc},
4185 {"inet_aton", socket_inet_aton,
4186 METH_VARARGS, inet_aton_doc},
4187 {"inet_ntoa", socket_inet_ntoa,
4188 METH_VARARGS, inet_ntoa_doc},
4189 #ifdef HAVE_INET_PTON
4190 {"inet_pton", socket_inet_pton,
4191 METH_VARARGS, inet_pton_doc},
4192 {"inet_ntop", socket_inet_ntop,
4193 METH_VARARGS, inet_ntop_doc},
4194 #endif
4195 {"getaddrinfo", socket_getaddrinfo,
4196 METH_VARARGS, getaddrinfo_doc},
4197 {"getnameinfo", socket_getnameinfo,
4198 METH_VARARGS, getnameinfo_doc},
4199 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,
4200 METH_NOARGS, getdefaulttimeout_doc},
4201 {"setdefaulttimeout", socket_setdefaulttimeout,
4202 METH_O, setdefaulttimeout_doc},
4203 {NULL, NULL} /* Sentinel */
4207 #ifdef RISCOS
4208 #define OS_INIT_DEFINED
4210 static int
4211 os_init(void)
4213 _kernel_swi_regs r;
4215 r.r[0] = 0;
4216 _kernel_swi(0x43380, &r, &r);
4217 taskwindow = r.r[0];
4219 return 1;
4222 #endif /* RISCOS */
4225 #ifdef MS_WINDOWS
4226 #define OS_INIT_DEFINED
4228 /* Additional initialization and cleanup for Windows */
4230 static void
4231 os_cleanup(void)
4233 WSACleanup();
4236 static int
4237 os_init(void)
4239 WSADATA WSAData;
4240 int ret;
4241 char buf[100];
4242 ret = WSAStartup(0x0101, &WSAData);
4243 switch (ret) {
4244 case 0: /* No error */
4245 Py_AtExit(os_cleanup);
4246 return 1; /* Success */
4247 case WSASYSNOTREADY:
4248 PyErr_SetString(PyExc_ImportError,
4249 "WSAStartup failed: network not ready");
4250 break;
4251 case WSAVERNOTSUPPORTED:
4252 case WSAEINVAL:
4253 PyErr_SetString(
4254 PyExc_ImportError,
4255 "WSAStartup failed: requested version not supported");
4256 break;
4257 default:
4258 PyOS_snprintf(buf, sizeof(buf),
4259 "WSAStartup failed: error code %d", ret);
4260 PyErr_SetString(PyExc_ImportError, buf);
4261 break;
4263 return 0; /* Failure */
4266 #endif /* MS_WINDOWS */
4269 #ifdef PYOS_OS2
4270 #define OS_INIT_DEFINED
4272 /* Additional initialization for OS/2 */
4274 static int
4275 os_init(void)
4277 #ifndef PYCC_GCC
4278 char reason[64];
4279 int rc = sock_init();
4281 if (rc == 0) {
4282 return 1; /* Success */
4285 PyOS_snprintf(reason, sizeof(reason),
4286 "OS/2 TCP/IP Error# %d", sock_errno());
4287 PyErr_SetString(PyExc_ImportError, reason);
4289 return 0; /* Failure */
4290 #else
4291 /* No need to initialise sockets with GCC/EMX */
4292 return 1; /* Success */
4293 #endif
4296 #endif /* PYOS_OS2 */
4299 #ifndef OS_INIT_DEFINED
4300 static int
4301 os_init(void)
4303 return 1; /* Success */
4305 #endif
4308 /* C API table - always add new things to the end for binary
4309 compatibility. */
4310 static
4311 PySocketModule_APIObject PySocketModuleAPI =
4313 &sock_type,
4314 NULL
4318 /* Initialize the _socket module.
4320 This module is actually called "_socket", and there's a wrapper
4321 "socket.py" which implements some additional functionality. On some
4322 platforms (e.g. Windows and OS/2), socket.py also implements a
4323 wrapper for the socket type that provides missing functionality such
4324 as makefile(), dup() and fromfd(). The import of "_socket" may fail
4325 with an ImportError exception if os-specific initialization fails.
4326 On Windows, this does WINSOCK initialization. When WINSOCK is
4327 initialized succesfully, a call to WSACleanup() is scheduled to be
4328 made at exit time.
4331 PyDoc_STRVAR(socket_doc,
4332 "Implementation module for socket operations.\n\
4334 See the socket module for documentation.");
4336 PyMODINIT_FUNC
4337 init_socket(void)
4339 PyObject *m, *has_ipv6;
4341 if (!os_init())
4342 return;
4344 Py_TYPE(&sock_type) = &PyType_Type;
4345 m = Py_InitModule3(PySocket_MODULE_NAME,
4346 socket_methods,
4347 socket_doc);
4348 if (m == NULL)
4349 return;
4351 socket_error = PyErr_NewException("socket.error",
4352 PyExc_IOError, NULL);
4353 if (socket_error == NULL)
4354 return;
4355 PySocketModuleAPI.error = socket_error;
4356 Py_INCREF(socket_error);
4357 PyModule_AddObject(m, "error", socket_error);
4358 socket_herror = PyErr_NewException("socket.herror",
4359 socket_error, NULL);
4360 if (socket_herror == NULL)
4361 return;
4362 Py_INCREF(socket_herror);
4363 PyModule_AddObject(m, "herror", socket_herror);
4364 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,
4365 NULL);
4366 if (socket_gaierror == NULL)
4367 return;
4368 Py_INCREF(socket_gaierror);
4369 PyModule_AddObject(m, "gaierror", socket_gaierror);
4370 socket_timeout = PyErr_NewException("socket.timeout",
4371 socket_error, NULL);
4372 if (socket_timeout == NULL)
4373 return;
4374 Py_INCREF(socket_timeout);
4375 PyModule_AddObject(m, "timeout", socket_timeout);
4376 Py_INCREF((PyObject *)&sock_type);
4377 if (PyModule_AddObject(m, "SocketType",
4378 (PyObject *)&sock_type) != 0)
4379 return;
4380 Py_INCREF((PyObject *)&sock_type);
4381 if (PyModule_AddObject(m, "socket",
4382 (PyObject *)&sock_type) != 0)
4383 return;
4385 #ifdef ENABLE_IPV6
4386 has_ipv6 = Py_True;
4387 #else
4388 has_ipv6 = Py_False;
4389 #endif
4390 Py_INCREF(has_ipv6);
4391 PyModule_AddObject(m, "has_ipv6", has_ipv6);
4393 /* Export C API */
4394 if (PyModule_AddObject(m, PySocket_CAPI_NAME,
4395 PyCObject_FromVoidPtr((void *)&PySocketModuleAPI, NULL)
4396 ) != 0)
4397 return;
4399 /* Address families (we only support AF_INET and AF_UNIX) */
4400 #ifdef AF_UNSPEC
4401 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);
4402 #endif
4403 PyModule_AddIntConstant(m, "AF_INET", AF_INET);
4404 #ifdef AF_INET6
4405 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);
4406 #endif /* AF_INET6 */
4407 #if defined(AF_UNIX)
4408 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);
4409 #endif /* AF_UNIX */
4410 #ifdef AF_AX25
4411 /* Amateur Radio AX.25 */
4412 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);
4413 #endif
4414 #ifdef AF_IPX
4415 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */
4416 #endif
4417 #ifdef AF_APPLETALK
4418 /* Appletalk DDP */
4419 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);
4420 #endif
4421 #ifdef AF_NETROM
4422 /* Amateur radio NetROM */
4423 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);
4424 #endif
4425 #ifdef AF_BRIDGE
4426 /* Multiprotocol bridge */
4427 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);
4428 #endif
4429 #ifdef AF_ATMPVC
4430 /* ATM PVCs */
4431 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);
4432 #endif
4433 #ifdef AF_AAL5
4434 /* Reserved for Werner's ATM */
4435 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);
4436 #endif
4437 #ifdef AF_X25
4438 /* Reserved for X.25 project */
4439 PyModule_AddIntConstant(m, "AF_X25", AF_X25);
4440 #endif
4441 #ifdef AF_INET6
4442 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */
4443 #endif
4444 #ifdef AF_ROSE
4445 /* Amateur Radio X.25 PLP */
4446 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);
4447 #endif
4448 #ifdef AF_DECnet
4449 /* Reserved for DECnet project */
4450 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);
4451 #endif
4452 #ifdef AF_NETBEUI
4453 /* Reserved for 802.2LLC project */
4454 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);
4455 #endif
4456 #ifdef AF_SECURITY
4457 /* Security callback pseudo AF */
4458 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);
4459 #endif
4460 #ifdef AF_KEY
4461 /* PF_KEY key management API */
4462 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);
4463 #endif
4464 #ifdef AF_NETLINK
4465 /* */
4466 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);
4467 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);
4468 #ifdef NETLINK_SKIP
4469 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);
4470 #endif
4471 #ifdef NETLINK_W1
4472 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);
4473 #endif
4474 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);
4475 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);
4476 #ifdef NETLINK_TCPDIAG
4477 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);
4478 #endif
4479 #ifdef NETLINK_NFLOG
4480 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);
4481 #endif
4482 #ifdef NETLINK_XFRM
4483 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);
4484 #endif
4485 #ifdef NETLINK_ARPD
4486 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);
4487 #endif
4488 #ifdef NETLINK_ROUTE6
4489 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);
4490 #endif
4491 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);
4492 #ifdef NETLINK_DNRTMSG
4493 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);
4494 #endif
4495 #ifdef NETLINK_TAPBASE
4496 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);
4497 #endif
4498 #endif /* AF_NETLINK */
4499 #ifdef AF_ROUTE
4500 /* Alias to emulate 4.4BSD */
4501 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);
4502 #endif
4503 #ifdef AF_ASH
4504 /* Ash */
4505 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);
4506 #endif
4507 #ifdef AF_ECONET
4508 /* Acorn Econet */
4509 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);
4510 #endif
4511 #ifdef AF_ATMSVC
4512 /* ATM SVCs */
4513 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);
4514 #endif
4515 #ifdef AF_SNA
4516 /* Linux SNA Project (nutters!) */
4517 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);
4518 #endif
4519 #ifdef AF_IRDA
4520 /* IRDA sockets */
4521 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);
4522 #endif
4523 #ifdef AF_PPPOX
4524 /* PPPoX sockets */
4525 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);
4526 #endif
4527 #ifdef AF_WANPIPE
4528 /* Wanpipe API Sockets */
4529 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);
4530 #endif
4531 #ifdef AF_LLC
4532 /* Linux LLC */
4533 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);
4534 #endif
4536 #ifdef USE_BLUETOOTH
4537 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);
4538 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);
4539 PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);
4540 PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);
4541 PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);
4542 #if !defined(__FreeBSD__)
4543 PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);
4544 PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);
4545 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);
4546 #endif
4547 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);
4548 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");
4549 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
4550 #endif
4552 #ifdef HAVE_NETPACKET_PACKET_H
4553 PyModule_AddIntConstant(m, "AF_PACKET", AF_PACKET);
4554 PyModule_AddIntConstant(m, "PF_PACKET", PF_PACKET);
4555 PyModule_AddIntConstant(m, "PACKET_HOST", PACKET_HOST);
4556 PyModule_AddIntConstant(m, "PACKET_BROADCAST", PACKET_BROADCAST);
4557 PyModule_AddIntConstant(m, "PACKET_MULTICAST", PACKET_MULTICAST);
4558 PyModule_AddIntConstant(m, "PACKET_OTHERHOST", PACKET_OTHERHOST);
4559 PyModule_AddIntConstant(m, "PACKET_OUTGOING", PACKET_OUTGOING);
4560 PyModule_AddIntConstant(m, "PACKET_LOOPBACK", PACKET_LOOPBACK);
4561 PyModule_AddIntConstant(m, "PACKET_FASTROUTE", PACKET_FASTROUTE);
4562 #endif
4564 #ifdef HAVE_LINUX_TIPC_H
4565 PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);
4567 /* for addresses */
4568 PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);
4569 PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);
4570 PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);
4572 PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);
4573 PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);
4574 PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);
4576 /* for setsockopt() */
4577 PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);
4578 PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);
4579 PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);
4580 PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",
4581 TIPC_DEST_DROPPABLE);
4582 PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);
4584 PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",
4585 TIPC_LOW_IMPORTANCE);
4586 PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",
4587 TIPC_MEDIUM_IMPORTANCE);
4588 PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",
4589 TIPC_HIGH_IMPORTANCE);
4590 PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",
4591 TIPC_CRITICAL_IMPORTANCE);
4593 /* for subscriptions */
4594 PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);
4595 PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);
4596 #ifdef TIPC_SUB_CANCEL
4597 /* doesn't seem to be available everywhere */
4598 PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);
4599 #endif
4600 PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);
4601 PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);
4602 PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);
4603 PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);
4604 PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);
4605 PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);
4606 #endif
4608 /* Socket types */
4609 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);
4610 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);
4611 #ifndef __BEOS__
4612 /* We have incomplete socket support. */
4613 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);
4614 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);
4615 #if defined(SOCK_RDM)
4616 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);
4617 #endif
4618 #endif
4620 #ifdef SO_DEBUG
4621 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);
4622 #endif
4623 #ifdef SO_ACCEPTCONN
4624 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);
4625 #endif
4626 #ifdef SO_REUSEADDR
4627 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);
4628 #endif
4629 #ifdef SO_EXCLUSIVEADDRUSE
4630 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);
4631 #endif
4633 #ifdef SO_KEEPALIVE
4634 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);
4635 #endif
4636 #ifdef SO_DONTROUTE
4637 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);
4638 #endif
4639 #ifdef SO_BROADCAST
4640 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);
4641 #endif
4642 #ifdef SO_USELOOPBACK
4643 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);
4644 #endif
4645 #ifdef SO_LINGER
4646 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);
4647 #endif
4648 #ifdef SO_OOBINLINE
4649 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);
4650 #endif
4651 #ifdef SO_REUSEPORT
4652 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);
4653 #endif
4654 #ifdef SO_SNDBUF
4655 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);
4656 #endif
4657 #ifdef SO_RCVBUF
4658 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);
4659 #endif
4660 #ifdef SO_SNDLOWAT
4661 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);
4662 #endif
4663 #ifdef SO_RCVLOWAT
4664 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);
4665 #endif
4666 #ifdef SO_SNDTIMEO
4667 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);
4668 #endif
4669 #ifdef SO_RCVTIMEO
4670 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);
4671 #endif
4672 #ifdef SO_ERROR
4673 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);
4674 #endif
4675 #ifdef SO_TYPE
4676 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);
4677 #endif
4679 /* Maximum number of connections for "listen" */
4680 #ifdef SOMAXCONN
4681 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);
4682 #else
4683 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */
4684 #endif
4686 /* Flags for send, recv */
4687 #ifdef MSG_OOB
4688 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);
4689 #endif
4690 #ifdef MSG_PEEK
4691 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);
4692 #endif
4693 #ifdef MSG_DONTROUTE
4694 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);
4695 #endif
4696 #ifdef MSG_DONTWAIT
4697 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);
4698 #endif
4699 #ifdef MSG_EOR
4700 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);
4701 #endif
4702 #ifdef MSG_TRUNC
4703 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);
4704 #endif
4705 #ifdef MSG_CTRUNC
4706 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);
4707 #endif
4708 #ifdef MSG_WAITALL
4709 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);
4710 #endif
4711 #ifdef MSG_BTAG
4712 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);
4713 #endif
4714 #ifdef MSG_ETAG
4715 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);
4716 #endif
4718 /* Protocol level and numbers, usable for [gs]etsockopt */
4719 #ifdef SOL_SOCKET
4720 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);
4721 #endif
4722 #ifdef SOL_IP
4723 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);
4724 #else
4725 PyModule_AddIntConstant(m, "SOL_IP", 0);
4726 #endif
4727 #ifdef SOL_IPX
4728 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);
4729 #endif
4730 #ifdef SOL_AX25
4731 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);
4732 #endif
4733 #ifdef SOL_ATALK
4734 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);
4735 #endif
4736 #ifdef SOL_NETROM
4737 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);
4738 #endif
4739 #ifdef SOL_ROSE
4740 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);
4741 #endif
4742 #ifdef SOL_TCP
4743 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);
4744 #else
4745 PyModule_AddIntConstant(m, "SOL_TCP", 6);
4746 #endif
4747 #ifdef SOL_UDP
4748 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);
4749 #else
4750 PyModule_AddIntConstant(m, "SOL_UDP", 17);
4751 #endif
4752 #ifdef IPPROTO_IP
4753 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);
4754 #else
4755 PyModule_AddIntConstant(m, "IPPROTO_IP", 0);
4756 #endif
4757 #ifdef IPPROTO_HOPOPTS
4758 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
4759 #endif
4760 #ifdef IPPROTO_ICMP
4761 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);
4762 #else
4763 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);
4764 #endif
4765 #ifdef IPPROTO_IGMP
4766 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);
4767 #endif
4768 #ifdef IPPROTO_GGP
4769 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);
4770 #endif
4771 #ifdef IPPROTO_IPV4
4772 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);
4773 #endif
4774 #ifdef IPPROTO_IPV6
4775 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
4776 #endif
4777 #ifdef IPPROTO_IPIP
4778 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);
4779 #endif
4780 #ifdef IPPROTO_TCP
4781 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);
4782 #else
4783 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);
4784 #endif
4785 #ifdef IPPROTO_EGP
4786 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);
4787 #endif
4788 #ifdef IPPROTO_PUP
4789 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);
4790 #endif
4791 #ifdef IPPROTO_UDP
4792 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);
4793 #else
4794 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);
4795 #endif
4796 #ifdef IPPROTO_IDP
4797 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);
4798 #endif
4799 #ifdef IPPROTO_HELLO
4800 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);
4801 #endif
4802 #ifdef IPPROTO_ND
4803 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);
4804 #endif
4805 #ifdef IPPROTO_TP
4806 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);
4807 #endif
4808 #ifdef IPPROTO_IPV6
4809 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);
4810 #endif
4811 #ifdef IPPROTO_ROUTING
4812 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);
4813 #endif
4814 #ifdef IPPROTO_FRAGMENT
4815 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
4816 #endif
4817 #ifdef IPPROTO_RSVP
4818 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);
4819 #endif
4820 #ifdef IPPROTO_GRE
4821 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);
4822 #endif
4823 #ifdef IPPROTO_ESP
4824 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);
4825 #endif
4826 #ifdef IPPROTO_AH
4827 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);
4828 #endif
4829 #ifdef IPPROTO_MOBILE
4830 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);
4831 #endif
4832 #ifdef IPPROTO_ICMPV6
4833 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
4834 #endif
4835 #ifdef IPPROTO_NONE
4836 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);
4837 #endif
4838 #ifdef IPPROTO_DSTOPTS
4839 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
4840 #endif
4841 #ifdef IPPROTO_XTP
4842 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);
4843 #endif
4844 #ifdef IPPROTO_EON
4845 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);
4846 #endif
4847 #ifdef IPPROTO_PIM
4848 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);
4849 #endif
4850 #ifdef IPPROTO_IPCOMP
4851 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
4852 #endif
4853 #ifdef IPPROTO_VRRP
4854 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);
4855 #endif
4856 #ifdef IPPROTO_BIP
4857 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);
4858 #endif
4859 /**/
4860 #ifdef IPPROTO_RAW
4861 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);
4862 #else
4863 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);
4864 #endif
4865 #ifdef IPPROTO_MAX
4866 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);
4867 #endif
4869 /* Some port configuration */
4870 #ifdef IPPORT_RESERVED
4871 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);
4872 #else
4873 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);
4874 #endif
4875 #ifdef IPPORT_USERRESERVED
4876 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
4877 #else
4878 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);
4879 #endif
4881 /* Some reserved IP v.4 addresses */
4882 #ifdef INADDR_ANY
4883 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);
4884 #else
4885 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);
4886 #endif
4887 #ifdef INADDR_BROADCAST
4888 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);
4889 #else
4890 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);
4891 #endif
4892 #ifdef INADDR_LOOPBACK
4893 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);
4894 #else
4895 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);
4896 #endif
4897 #ifdef INADDR_UNSPEC_GROUP
4898 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
4899 #else
4900 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);
4901 #endif
4902 #ifdef INADDR_ALLHOSTS_GROUP
4903 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",
4904 INADDR_ALLHOSTS_GROUP);
4905 #else
4906 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
4907 #endif
4908 #ifdef INADDR_MAX_LOCAL_GROUP
4909 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",
4910 INADDR_MAX_LOCAL_GROUP);
4911 #else
4912 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
4913 #endif
4914 #ifdef INADDR_NONE
4915 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);
4916 #else
4917 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);
4918 #endif
4920 /* IPv4 [gs]etsockopt options */
4921 #ifdef IP_OPTIONS
4922 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);
4923 #endif
4924 #ifdef IP_HDRINCL
4925 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);
4926 #endif
4927 #ifdef IP_TOS
4928 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);
4929 #endif
4930 #ifdef IP_TTL
4931 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);
4932 #endif
4933 #ifdef IP_RECVOPTS
4934 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);
4935 #endif
4936 #ifdef IP_RECVRETOPTS
4937 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);
4938 #endif
4939 #ifdef IP_RECVDSTADDR
4940 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);
4941 #endif
4942 #ifdef IP_RETOPTS
4943 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);
4944 #endif
4945 #ifdef IP_MULTICAST_IF
4946 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);
4947 #endif
4948 #ifdef IP_MULTICAST_TTL
4949 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
4950 #endif
4951 #ifdef IP_MULTICAST_LOOP
4952 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
4953 #endif
4954 #ifdef IP_ADD_MEMBERSHIP
4955 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
4956 #endif
4957 #ifdef IP_DROP_MEMBERSHIP
4958 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
4959 #endif
4960 #ifdef IP_DEFAULT_MULTICAST_TTL
4961 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",
4962 IP_DEFAULT_MULTICAST_TTL);
4963 #endif
4964 #ifdef IP_DEFAULT_MULTICAST_LOOP
4965 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",
4966 IP_DEFAULT_MULTICAST_LOOP);
4967 #endif
4968 #ifdef IP_MAX_MEMBERSHIPS
4969 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
4970 #endif
4972 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
4973 #ifdef IPV6_JOIN_GROUP
4974 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
4975 #endif
4976 #ifdef IPV6_LEAVE_GROUP
4977 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
4978 #endif
4979 #ifdef IPV6_MULTICAST_HOPS
4980 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
4981 #endif
4982 #ifdef IPV6_MULTICAST_IF
4983 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
4984 #endif
4985 #ifdef IPV6_MULTICAST_LOOP
4986 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
4987 #endif
4988 #ifdef IPV6_UNICAST_HOPS
4989 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
4990 #endif
4991 /* Additional IPV6 socket options, defined in RFC 3493 */
4992 #ifdef IPV6_V6ONLY
4993 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);
4994 #endif
4995 /* Advanced IPV6 socket options, from RFC 3542 */
4996 #ifdef IPV6_CHECKSUM
4997 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);
4998 #endif
4999 #ifdef IPV6_DONTFRAG
5000 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);
5001 #endif
5002 #ifdef IPV6_DSTOPTS
5003 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);
5004 #endif
5005 #ifdef IPV6_HOPLIMIT
5006 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);
5007 #endif
5008 #ifdef IPV6_HOPOPTS
5009 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);
5010 #endif
5011 #ifdef IPV6_NEXTHOP
5012 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);
5013 #endif
5014 #ifdef IPV6_PATHMTU
5015 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);
5016 #endif
5017 #ifdef IPV6_PKTINFO
5018 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);
5019 #endif
5020 #ifdef IPV6_RECVDSTOPTS
5021 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
5022 #endif
5023 #ifdef IPV6_RECVHOPLIMIT
5024 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
5025 #endif
5026 #ifdef IPV6_RECVHOPOPTS
5027 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
5028 #endif
5029 #ifdef IPV6_RECVPKTINFO
5030 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
5031 #endif
5032 #ifdef IPV6_RECVRTHDR
5033 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);
5034 #endif
5035 #ifdef IPV6_RECVTCLASS
5036 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);
5037 #endif
5038 #ifdef IPV6_RTHDR
5039 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);
5040 #endif
5041 #ifdef IPV6_RTHDRDSTOPTS
5042 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
5043 #endif
5044 #ifdef IPV6_RTHDR_TYPE_0
5045 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
5046 #endif
5047 #ifdef IPV6_RECVPATHMTU
5048 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
5049 #endif
5050 #ifdef IPV6_TCLASS
5051 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);
5052 #endif
5053 #ifdef IPV6_USE_MIN_MTU
5054 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
5055 #endif
5057 /* TCP options */
5058 #ifdef TCP_NODELAY
5059 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);
5060 #endif
5061 #ifdef TCP_MAXSEG
5062 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);
5063 #endif
5064 #ifdef TCP_CORK
5065 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);
5066 #endif
5067 #ifdef TCP_KEEPIDLE
5068 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);
5069 #endif
5070 #ifdef TCP_KEEPINTVL
5071 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);
5072 #endif
5073 #ifdef TCP_KEEPCNT
5074 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);
5075 #endif
5076 #ifdef TCP_SYNCNT
5077 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);
5078 #endif
5079 #ifdef TCP_LINGER2
5080 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);
5081 #endif
5082 #ifdef TCP_DEFER_ACCEPT
5083 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);
5084 #endif
5085 #ifdef TCP_WINDOW_CLAMP
5086 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);
5087 #endif
5088 #ifdef TCP_INFO
5089 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);
5090 #endif
5091 #ifdef TCP_QUICKACK
5092 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);
5093 #endif
5096 /* IPX options */
5097 #ifdef IPX_TYPE
5098 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);
5099 #endif
5101 /* get{addr,name}info parameters */
5102 #ifdef EAI_ADDRFAMILY
5103 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
5104 #endif
5105 #ifdef EAI_AGAIN
5106 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);
5107 #endif
5108 #ifdef EAI_BADFLAGS
5109 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);
5110 #endif
5111 #ifdef EAI_FAIL
5112 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);
5113 #endif
5114 #ifdef EAI_FAMILY
5115 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);
5116 #endif
5117 #ifdef EAI_MEMORY
5118 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);
5119 #endif
5120 #ifdef EAI_NODATA
5121 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);
5122 #endif
5123 #ifdef EAI_NONAME
5124 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);
5125 #endif
5126 #ifdef EAI_OVERFLOW
5127 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);
5128 #endif
5129 #ifdef EAI_SERVICE
5130 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);
5131 #endif
5132 #ifdef EAI_SOCKTYPE
5133 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);
5134 #endif
5135 #ifdef EAI_SYSTEM
5136 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);
5137 #endif
5138 #ifdef EAI_BADHINTS
5139 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);
5140 #endif
5141 #ifdef EAI_PROTOCOL
5142 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);
5143 #endif
5144 #ifdef EAI_MAX
5145 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);
5146 #endif
5147 #ifdef AI_PASSIVE
5148 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);
5149 #endif
5150 #ifdef AI_CANONNAME
5151 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);
5152 #endif
5153 #ifdef AI_NUMERICHOST
5154 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);
5155 #endif
5156 #ifdef AI_NUMERICSERV
5157 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);
5158 #endif
5159 #ifdef AI_MASK
5160 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);
5161 #endif
5162 #ifdef AI_ALL
5163 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);
5164 #endif
5165 #ifdef AI_V4MAPPED_CFG
5166 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
5167 #endif
5168 #ifdef AI_ADDRCONFIG
5169 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);
5170 #endif
5171 #ifdef AI_V4MAPPED
5172 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);
5173 #endif
5174 #ifdef AI_DEFAULT
5175 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);
5176 #endif
5177 #ifdef NI_MAXHOST
5178 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);
5179 #endif
5180 #ifdef NI_MAXSERV
5181 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);
5182 #endif
5183 #ifdef NI_NOFQDN
5184 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);
5185 #endif
5186 #ifdef NI_NUMERICHOST
5187 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);
5188 #endif
5189 #ifdef NI_NAMEREQD
5190 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);
5191 #endif
5192 #ifdef NI_NUMERICSERV
5193 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);
5194 #endif
5195 #ifdef NI_DGRAM
5196 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);
5197 #endif
5199 /* shutdown() parameters */
5200 #ifdef SHUT_RD
5201 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);
5202 #elif defined(SD_RECEIVE)
5203 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);
5204 #else
5205 PyModule_AddIntConstant(m, "SHUT_RD", 0);
5206 #endif
5207 #ifdef SHUT_WR
5208 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);
5209 #elif defined(SD_SEND)
5210 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);
5211 #else
5212 PyModule_AddIntConstant(m, "SHUT_WR", 1);
5213 #endif
5214 #ifdef SHUT_RDWR
5215 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);
5216 #elif defined(SD_BOTH)
5217 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);
5218 #else
5219 PyModule_AddIntConstant(m, "SHUT_RDWR", 2);
5220 #endif
5222 #ifdef SIO_RCVALL
5224 PyObject *tmp;
5225 tmp = PyLong_FromUnsignedLong(SIO_RCVALL);
5226 if (tmp == NULL)
5227 return;
5228 PyModule_AddObject(m, "SIO_RCVALL", tmp);
5230 PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);
5231 PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);
5232 PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);
5233 #ifdef RCVALL_IPLEVEL
5234 PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);
5235 #endif
5236 #ifdef RCVALL_MAX
5237 PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);
5238 #endif
5239 #endif /* _MSTCPIP_ */
5241 /* Initialize gethostbyname lock */
5242 #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
5243 netdb_lock = PyThread_allocate_lock();
5244 #endif
5248 #ifndef HAVE_INET_PTON
5249 #if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
5251 /* Simplistic emulation code for inet_pton that only works for IPv4 */
5252 /* These are not exposed because they do not set errno properly */
5255 inet_pton(int af, const char *src, void *dst)
5257 if (af == AF_INET) {
5258 long packed_addr;
5259 packed_addr = inet_addr(src);
5260 if (packed_addr == INADDR_NONE)
5261 return 0;
5262 memcpy(dst, &packed_addr, 4);
5263 return 1;
5265 /* Should set errno to EAFNOSUPPORT */
5266 return -1;
5269 const char *
5270 inet_ntop(int af, const void *src, char *dst, socklen_t size)
5272 if (af == AF_INET) {
5273 struct in_addr packed_addr;
5274 if (size < 16)
5275 /* Should set errno to ENOSPC. */
5276 return NULL;
5277 memcpy(&packed_addr, src, sizeof(packed_addr));
5278 return strncpy(dst, inet_ntoa(packed_addr), size);
5280 /* Should set errno to EAFNOSUPPORT */
5281 return NULL;
5284 #endif
5285 #endif