5 This module provides an interface to Berkeley socket IPC.
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
12 - No read/write operations (use sendall/recv or makefile instead).
13 - Additional restrictions apply on some non-Unix platforms (compensated
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:
64 v2 is the port identifier
66 if addr_type is TIPC_ADDR_NAMESEQ:
68 v2 is the lower port number
69 v3 is the upper port number
70 if addr_type is TIPC_ADDR_ID:
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
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
94 #include "structmember.h"
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! */
150 # undef HAVE_GETHOSTBYNAME_R_3_ARG
151 # undef HAVE_GETHOSTBYNAME_R_5_ARG
152 # undef HAVE_GETHOSTBYNAME_R_6_ARG
156 # undef HAVE_GETHOSTBYNAME_R
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 */
167 # undef HAVE_GETHOSTBYNAME_R
171 #if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
173 # define USE_GETHOSTBYNAME_LOCK
176 /* To use __FreeBSD_version */
177 #ifdef HAVE_SYS_PARAM_H
178 #include <sys/param.h>
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
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);
193 #define ACQUIRE_GETADDRINFO_LOCK
194 #define RELEASE_GETADDRINFO_LOCK
197 #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
198 # include "pythread.h"
201 #if defined(PYCC_VACPP)
204 # include <sys/ioctl.h>
213 #if defined(PYOS_OS2)
215 # define INCL_DOSERRORS
216 # define INCL_NOPMAPI
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 */
231 #include <sys/socket.h>
232 #include <sys/types.h>
233 #include <netinet/in.h>
235 #define HAVE_GETADDRINFO 1
236 #define HAVE_GETNAMEINFO 1
239 #define HAVE_INET_PTON
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
250 /* Generic includes */
251 #ifdef HAVE_SYS_TYPES_H
252 #include <sys/types.h>
255 /* Generic socket object definitions and includes */
256 #define PySocket_BUILDING_SOCKET
257 #include "socketmodule.h"
259 /* Addressing includes */
263 /* Non-MS WINDOWS includes */
266 /* Headers needed for inet_ntoa() and inet_addr() */
268 # include <net/netdb.h>
269 # elif defined(PYOS_OS2) && defined(PYCC_VACPP)
271 typedef size_t socklen_t
;
273 # include <arpa/inet.h>
279 # include <sys/ioctl.h>
280 # include <socklib.h>
282 int h_errno
; /* not used */
283 # define INET_ADDRSTRLEN 16
288 /* MS_WINDOWS includes */
298 # define offsetof(type, member) ((size_t)(&((type *)0)->member))
302 # define O_NONBLOCK O_NDELAY
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.
316 # include "addrinfo.h"
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
);
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
342 #ifdef HAVE_INET_ATON
343 #define USE_INET_ATON_WEAKLINK
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"
356 #if !defined(HAVE_GETNAMEINFO)
357 #define getnameinfo fake_getnameinfo
358 #include "getnameinfo.c"
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... */
369 #define EAFNOSUPPORT WSAEAFNOSUPPORT
370 #define snprintf _snprintf
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 */
379 #define SOCKETCLOSE close
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)
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)
414 /* TCP/IP Services for VMS uses a maximum send/recv buffer length */
415 #define SEGMENT_SIZE (32 * 1024 -1)
418 #define SAS2SA(x) ((struct sockaddr *)(x))
421 * Constants for getnameinfo()
423 #if !defined(NI_MAXHOST)
424 #define NI_MAXHOST 1025
426 #if !defined(NI_MAXSERV)
427 #define NI_MAXSERV 32
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
;
441 /* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
442 static int taskwindow
;
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)
453 #elif defined(HAVE_SYS_POLL_H)
454 #include <sys/poll.h>
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? */
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)
474 PyErr_SetString(socket_error
, "unable to select on socket");
478 /* Convenience function to raise an error according to errno
479 and return a NULL pointer from a function. */
485 int err_no
= WSAGetLastError();
486 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
487 recognizes the error codes used by both GetLastError() and
490 return PyErr_SetExcFromWindowsErr(socket_error
, err_no
);
493 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
494 if (sock_errno() != NO_ERROR
) {
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,
505 if (rc
== NO_ERROR
) {
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) */
519 v
= Py_BuildValue("(is)", myerrorcode
, outbuf
);
521 PyErr_SetObject(socket_error
, v
);
530 if (_inet_error
.errnum
!= NULL
) {
532 v
= Py_BuildValue("(is)", errno
, _inet_err());
534 PyErr_SetObject(socket_error
, v
);
541 return PyErr_SetFromErrno(socket_error
);
546 set_herror(int h_error
)
550 #ifdef HAVE_HSTRERROR
551 v
= Py_BuildValue("(is)", h_error
, (char *)hstrerror(h_error
));
553 v
= Py_BuildValue("(is)", h_error
, "host not found");
556 PyErr_SetObject(socket_herror
, v
);
565 set_gaierror(int error
)
570 /* EAI_SYSTEM is not available on Windows XP. */
571 if (error
== EAI_SYSTEM
)
575 #ifdef HAVE_GAI_STRERROR
576 v
= Py_BuildValue("(is)", error
, gai_strerror(error
));
578 v
= Py_BuildValue("(is)", error
, "getaddrinfo failed");
581 PyErr_SetObject(socket_gaierror
, v
);
589 /* Function to send in segments */
591 sendsegmented(int sock_fd
, char *buf
, int len
, int flags
)
596 while (remaining
> 0) {
597 unsigned int segment
;
599 segment
= (remaining
>= SEGMENT_SIZE
? SEGMENT_SIZE
: remaining
);
600 n
= send(sock_fd
, buf
, segment
, flags
);
604 remaining
-= segment
;
612 /* Function to perform the setting of socket blocking mode
613 internally. block = (1 | 0). */
615 internal_setblocking(PySocketSockObject
*s
, int block
)
623 Py_BEGIN_ALLOW_THREADS
626 setsockopt(s
->sock_fd
, SOL_SOCKET
, SO_NONBLOCK
,
627 (void *)(&block
), sizeof(int));
631 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
633 ioctl(s
->sock_fd
, FIONBIO
, (caddr_t
)&block
, sizeof(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);
640 delay_flag
&= (~O_NONBLOCK
);
642 delay_flag
|= O_NONBLOCK
;
643 fcntl(s
->sock_fd
, F_SETFL
, delay_flag
);
644 #endif /* !PYOS_OS2 */
645 #else /* MS_WINDOWS */
647 ioctlsocket(s
->sock_fd
, FIONBIO
, (u_long
*)&block
);
648 #endif /* MS_WINDOWS */
651 socketioctl(s
->sock_fd
, FIONBIO
, (u_long
*)&block
);
653 #endif /* __BEOS__ */
656 /* Since these don't return anything */
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. */
666 internal_select(PySocketSockObject
*s
, int writing
)
670 /* Nothing to do unless we're in timeout mode (not non-blocking) */
671 if (s
->sock_timeout
<= 0.0)
674 /* Guard against closed socket */
678 /* Prefer poll, if available, since you can poll() any fd
679 * which can't be done with select(). */
682 struct pollfd pollfd
;
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
);
694 /* Construct the arguments to select */
697 tv
.tv_sec
= (int)s
->sock_timeout
;
698 tv
.tv_usec
= (int)((s
->sock_timeout
- tv
.tv_sec
) * 1e6
);
700 FD_SET(s
->sock_fd
, &fds
);
702 /* See if the socket is ready */
704 n
= select(s
->sock_fd
+1, NULL
, &fds
, NULL
, &tv
);
706 n
= select(s
->sock_fd
+1, &fds
, NULL
, NULL
, &tv
);
717 /* Initialize a new socket object. */
719 static double defaulttimeout
= -1.0; /* Default timeout for new sockets */
722 init_sockobject(PySocketSockObject
*s
,
723 SOCKET_T fd
, int family
, int type
, int proto
)
729 s
->sock_family
= family
;
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);
741 socketioctl(s
->sock_fd
, 0x80046679, (u_long
*)&block
);
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
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
);
758 init_sockobject(s
, fd
, family
, type
, proto
);
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
;
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. */
777 setipaddr(char *name
, struct sockaddr
*addr_ret
, size_t addr_ret_size
, int af
)
779 struct addrinfo hints
, *res
;
784 memset((void *) addr_ret
, '\0', sizeof(*addr_ret
));
785 if (name
[0] == '\0') {
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
);
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
804 switch (res
->ai_family
) {
815 PyErr_SetString(socket_error
,
816 "unsupported address family");
821 PyErr_SetString(socket_error
,
822 "wildcard resolved to multiple address");
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
);
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");
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
);
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
);
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
);
875 RELEASE_GETADDRINFO_LOCK
/* see comment in setipaddr() */
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
);
884 switch (addr_ret
->sa_family
) {
892 PyErr_SetString(socket_error
, "unknown address family");
898 /* Create a string object representing an IP address.
899 This is always a string of the form 'dd.dd.dd.dd' (with variable
903 makeipaddr(struct sockaddr
*addr
, int addrlen
)
905 char buf
[NI_MAXHOST
];
908 error
= getnameinfo(addr
, addrlen
, buf
, sizeof(buf
), NULL
, 0,
914 return PyString_FromString(buf
);
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. */
924 setbdaddr(char *name
, bdaddr_t
*bdaddr
)
926 unsigned int b0
, b1
, b2
, b3
, b4
, b5
;
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) {
941 PyErr_SetString(socket_error
, "bad bluetooth address");
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). */
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
);
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. */
970 makesockaddr(int sockfd
, struct sockaddr
*addr
, int addrlen
, int proto
)
973 /* No address -- may be recvfrom() from known socket */
979 /* XXX: BeOS version of accept() doesn't set family correctly */
980 addr
->sa_family
= AF_INET
;
983 switch (addr
->sa_family
) {
987 struct sockaddr_in
*a
;
988 PyObject
*addrobj
= makeipaddr(addr
, sizeof(*a
));
989 PyObject
*ret
= NULL
;
991 a
= (struct sockaddr_in
*)addr
;
992 ret
= Py_BuildValue("Oi", addrobj
, ntohs(a
->sin_port
));
1001 struct sockaddr_un
*a
= (struct sockaddr_un
*) addr
;
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
,
1011 /* regular NULL-terminated string */
1012 return PyString_FromString(a
->sun_path
);
1015 #endif /* AF_UNIX */
1017 #if defined(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 */
1028 struct sockaddr_in6
*a
;
1029 PyObject
*addrobj
= makeipaddr(addr
, sizeof(*a
));
1030 PyObject
*ret
= NULL
;
1032 a
= (struct sockaddr_in6
*)addr
;
1033 ret
= Py_BuildValue("Oiii",
1035 ntohs(a
->sin6_port
),
1044 #ifdef USE_BLUETOOTH
1050 struct sockaddr_l2
*a
= (struct sockaddr_l2
*) addr
;
1051 PyObject
*addrobj
= makebdaddr(&_BT_L2_MEMB(a
, bdaddr
));
1052 PyObject
*ret
= NULL
;
1054 ret
= Py_BuildValue("Oi",
1056 _BT_L2_MEMB(a
, psm
));
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
;
1068 ret
= Py_BuildValue("Oi",
1070 _BT_RC_MEMB(a
, channel
));
1078 struct sockaddr_hci
*a
= (struct sockaddr_hci
*) addr
;
1079 PyObject
*ret
= NULL
;
1080 ret
= Py_BuildValue("i", _BT_HCI_MEMB(a
, dev
));
1084 #if !defined(__FreeBSD__)
1087 struct sockaddr_sco
*a
= (struct sockaddr_sco
*) addr
;
1088 return makebdaddr(&_BT_SCO_MEMB(a
, bdaddr
));
1095 #ifdef HAVE_NETPACKET_PACKET_H
1098 struct sockaddr_ll
*a
= (struct sockaddr_ll
*)addr
;
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#",
1109 ntohs(a
->sll_protocol
),
1117 #ifdef HAVE_LINUX_TIPC_H
1120 struct sockaddr_tipc
*a
= (struct sockaddr_tipc
*) addr
;
1121 if (a
->addrtype
== TIPC_ADDR_NAMESEQ
) {
1122 return Py_BuildValue("IIIII",
1124 a
->addr
.nameseq
.type
,
1125 a
->addr
.nameseq
.lower
,
1126 a
->addr
.nameseq
.upper
,
1128 } else if (a
->addrtype
== TIPC_ADDR_NAME
) {
1129 return Py_BuildValue("IIIII",
1131 a
->addr
.name
.name
.type
,
1132 a
->addr
.name
.name
.instance
,
1133 a
->addr
.name
.name
.instance
,
1135 } else if (a
->addrtype
== TIPC_ADDR_ID
) {
1136 return Py_BuildValue("IIIII",
1143 PyErr_SetString(PyExc_TypeError
,
1144 "Invalid address type");
1150 /* More cases here... */
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#",
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
1170 getsockaddrarg(PySocketSockObject
*s
, PyObject
*args
,
1171 struct sockaddr
*addr_ret
, int *len_ret
)
1173 switch (s
->sock_family
) {
1175 #if defined(AF_UNIX)
1178 struct sockaddr_un
* addr
;
1181 if (!PyArg_Parse(args
, "t#", &path
, &len
))
1184 addr
= (struct sockaddr_un
*)addr_ret
;
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");
1197 /* regular NULL-terminated string */
1198 if (len
>= sizeof addr
->sun_path
) {
1199 PyErr_SetString(socket_error
,
1200 "AF_UNIX path too long");
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
);
1210 *len_ret
= len
+ offsetof(struct sockaddr_un
, sun_path
);
1214 #endif /* AF_UNIX */
1216 #if defined(AF_NETLINK)
1219 struct sockaddr_nl
* addr
;
1221 addr
= (struct sockaddr_nl
*)addr_ret
;
1222 if (!PyTuple_Check(args
)) {
1226 "AF_NETLINK address must be tuple, not %.500s",
1227 Py_TYPE(args
)->tp_name
);
1230 if (!PyArg_ParseTuple(args
, "II:getsockaddrarg", &pid
, &groups
))
1232 addr
->nl_family
= AF_NETLINK
;
1234 addr
->nl_groups
= groups
;
1235 *len_ret
= sizeof(*addr
);
1242 struct sockaddr_in
* addr
;
1245 if (!PyTuple_Check(args
)) {
1249 "AF_INET address must be tuple, not %.500s",
1250 Py_TYPE(args
)->tp_name
);
1253 if (!PyArg_ParseTuple(args
, "eti:getsockaddrarg",
1254 "idna", &host
, &port
))
1256 addr
=(struct sockaddr_in
*)addr_ret
;
1257 result
= setipaddr(host
, (struct sockaddr
*)addr
,
1258 sizeof(*addr
), AF_INET
);
1262 addr
->sin_family
= AF_INET
;
1263 addr
->sin_port
= htons((short)port
);
1264 *len_ret
= sizeof *addr
;
1271 struct sockaddr_in6
* addr
;
1273 int port
, flowinfo
, scope_id
, result
;
1274 flowinfo
= scope_id
= 0;
1275 if (!PyTuple_Check(args
)) {
1279 "AF_INET6 address must be tuple, not %.500s",
1280 Py_TYPE(args
)->tp_name
);
1283 if (!PyArg_ParseTuple(args
, "eti|ii",
1284 "idna", &host
, &port
, &flowinfo
,
1288 addr
= (struct sockaddr_in6
*)addr_ret
;
1289 result
= setipaddr(host
, (struct sockaddr
*)addr
,
1290 sizeof(*addr
), AF_INET6
);
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
;
1303 #ifdef USE_BLUETOOTH
1306 switch (s
->sock_proto
) {
1309 struct sockaddr_l2
*addr
;
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: "
1320 if (setbdaddr(straddr
, &_BT_L2_MEMB(addr
, bdaddr
)) < 0)
1323 *len_ret
= sizeof *addr
;
1326 case BTPROTO_RFCOMM
:
1328 struct sockaddr_rc
*addr
;
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: "
1339 if (setbdaddr(straddr
, &_BT_RC_MEMB(addr
, bdaddr
)) < 0)
1342 *len_ret
= sizeof *addr
;
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: "
1354 *len_ret
= sizeof *addr
;
1357 #if !defined(__FreeBSD__)
1360 struct sockaddr_sco
*addr
;
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: "
1371 if (setbdaddr(straddr
, &_BT_SCO_MEMB(addr
, bdaddr
)) < 0)
1374 *len_ret
= sizeof *addr
;
1379 PyErr_SetString(socket_error
, "getsockaddrarg: unknown Bluetooth protocol");
1385 #ifdef HAVE_NETPACKET_PACKET_H
1388 struct sockaddr_ll
* addr
;
1390 char *interfaceName
;
1395 unsigned int halen
= 0;
1397 if (!PyTuple_Check(args
)) {
1401 "AF_PACKET address must be tuple, not %.500s",
1402 Py_TYPE(args
)->tp_name
);
1405 if (!PyArg_ParseTuple(args
, "si|iis#", &interfaceName
,
1406 &protoNumber
, &pkttype
, &hatype
,
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) {
1416 PyErr_SetString(PyExc_ValueError
,
1417 "Hardware address must be 8 bytes or less");
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
;
1427 memcpy(&addr
->sll_addr
, haddr
, halen
);
1429 addr
->sll_halen
= halen
;
1430 *len_ret
= sizeof *addr
;
1435 #ifdef HAVE_LINUX_TIPC_H
1438 unsigned int atype
, v1
, v2
, v3
;
1439 unsigned int scope
= TIPC_CLUSTER_SCOPE
;
1440 struct sockaddr_tipc
*addr
;
1442 if (!PyTuple_Check(args
)) {
1446 "AF_TIPC address must be tuple, not %.500s",
1447 Py_TYPE(args
)->tp_name
);
1451 if (!PyArg_ParseTuple(args
,
1452 "IIII|I;Invalid TIPC address format",
1453 &atype
, &v1
, &v2
, &v3
, &scope
))
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
;
1474 /* Shouldn't happen */
1475 PyErr_SetString(PyExc_TypeError
, "Invalid address type");
1479 *len_ret
= sizeof(*addr
);
1485 /* More cases here... */
1488 PyErr_SetString(socket_error
, "getsockaddrarg: bad family");
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
1500 getsockaddrlen(PySocketSockObject
*s
, socklen_t
*len_ret
)
1502 switch (s
->sock_family
) {
1504 #if defined(AF_UNIX)
1507 *len_ret
= sizeof (struct sockaddr_un
);
1510 #endif /* AF_UNIX */
1511 #if defined(AF_NETLINK)
1514 *len_ret
= sizeof (struct sockaddr_nl
);
1521 *len_ret
= sizeof (struct sockaddr_in
);
1528 *len_ret
= sizeof (struct sockaddr_in6
);
1533 #ifdef USE_BLUETOOTH
1536 switch(s
->sock_proto
)
1540 *len_ret
= sizeof (struct sockaddr_l2
);
1542 case BTPROTO_RFCOMM
:
1543 *len_ret
= sizeof (struct sockaddr_rc
);
1546 *len_ret
= sizeof (struct sockaddr_hci
);
1548 #if !defined(__FreeBSD__)
1550 *len_ret
= sizeof (struct sockaddr_sco
);
1554 PyErr_SetString(socket_error
, "getsockaddrlen: "
1555 "unknown BT protocol");
1562 #ifdef HAVE_NETPACKET_PACKET_H
1565 *len_ret
= sizeof (struct sockaddr_ll
);
1570 #ifdef HAVE_LINUX_TIPC_H
1573 *len_ret
= sizeof (struct sockaddr_tipc
);
1578 /* More cases here... */
1581 PyErr_SetString(socket_error
, "getsockaddrlen: bad family");
1588 /* s.accept() method */
1591 sock_accept(PySocketSockObject
*s
)
1593 sock_addr_t addrbuf
;
1596 PyObject
*sock
= NULL
;
1597 PyObject
*addr
= NULL
;
1598 PyObject
*res
= NULL
;
1601 if (!getsockaddrlen(s
, &addrlen
))
1603 memset(&addrbuf
, 0, addrlen
);
1606 newfd
= INVALID_SOCKET
;
1611 if (!IS_SELECTABLE(s
))
1612 return select_error();
1614 Py_BEGIN_ALLOW_THREADS
1615 timeout
= internal_select(s
, 0);
1617 newfd
= accept(s
->sock_fd
, SAS2SA(&addrbuf
), &addrlen
);
1618 Py_END_ALLOW_THREADS
1621 PyErr_SetString(socket_timeout
, "timed out");
1626 if (newfd
== INVALID_SOCKET
)
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
,
1643 addr
= makesockaddr(s
->sock_fd
, SAS2SA(&addrbuf
),
1644 addrlen
, s
->sock_proto
);
1648 res
= PyTuple_Pack(2, sock
, addr
);
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)
1669 sock_setblocking(PySocketSockObject
*s
, PyObject
*arg
)
1673 block
= PyInt_AsLong(arg
);
1674 if (block
== -1 && PyErr_Occurred())
1677 s
->sock_timeout
= block
? -1.0 : 0.0;
1678 internal_setblocking(s
, block
);
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
1698 sock_settimeout(PySocketSockObject
*s
, PyObject
*arg
)
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");
1714 s
->sock_timeout
= timeout
;
1715 internal_setblocking(s
, timeout
< 0.0);
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. */
1732 sock_gettimeout(PySocketSockObject
*s
)
1734 if (s
->sock_timeout
< 0.0) {
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.");
1750 /* s.sleeptaskw(1 | 0) method */
1753 sock_sleeptaskw(PySocketSockObject
*s
,PyObject
*arg
)
1756 block
= PyInt_AsLong(arg
);
1757 if (block
== -1 && PyErr_Occurred())
1759 Py_BEGIN_ALLOW_THREADS
1760 socketioctl(s
->sock_fd
, 0x80046679, (u_long
*)&block
);
1761 Py_END_ALLOW_THREADS
1766 PyDoc_STRVAR(sleeptaskw_doc
,
1767 "sleeptaskw(flag)\n\
1769 Allow sleeps in taskwindows.");
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. */
1779 sock_setsockopt(PySocketSockObject
*s
, PyObject
*args
)
1788 if (PyArg_ParseTuple(args
, "iii:setsockopt",
1789 &level
, &optname
, &flag
)) {
1790 buf
= (char *) &flag
;
1791 buflen
= sizeof flag
;
1795 if (!PyArg_ParseTuple(args
, "iis#:setsockopt",
1796 &level
, &optname
, &buf
, &buflen
))
1799 res
= setsockopt(s
->sock_fd
, level
, optname
, (void *)buf
, buflen
);
1801 return s
->errorhandler();
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. */
1819 sock_getsockopt(PySocketSockObject
*s
, PyObject
*args
)
1825 socklen_t buflen
= 0;
1828 /* We have incomplete socket support. */
1829 PyErr_SetString(socket_error
, "getsockopt not supported");
1833 if (!PyArg_ParseTuple(args
, "ii|i:getsockopt",
1834 &level
, &optname
, &buflen
))
1839 socklen_t flagsize
= sizeof flag
;
1840 res
= getsockopt(s
->sock_fd
, level
, optname
,
1841 (void *)&flag
, &flagsize
);
1843 return s
->errorhandler();
1844 return PyInt_FromLong(flag
);
1847 /* socklen_t is unsigned so no negative test is needed,
1848 test buflen == 0 is previously done */
1849 if (buflen
> 1024) {
1851 if (buflen
<= 0 || buflen
> 1024) {
1853 PyErr_SetString(socket_error
,
1854 "getsockopt buflen out of range");
1857 buf
= PyString_FromStringAndSize((char *)NULL
, buflen
);
1860 res
= getsockopt(s
->sock_fd
, level
, optname
,
1861 (void *)PyString_AS_STRING(buf
), &buflen
);
1864 return s
->errorhandler();
1866 _PyString_Resize(&buf
, buflen
);
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 */
1882 sock_bind(PySocketSockObject
*s
, PyObject
*addro
)
1884 sock_addr_t addrbuf
;
1888 if (!getsockaddrarg(s
, addro
, SAS2SA(&addrbuf
), &addrlen
))
1890 Py_BEGIN_ALLOW_THREADS
1891 res
= bind(s
->sock_fd
, SAS2SA(&addrbuf
), addrlen
);
1892 Py_END_ALLOW_THREADS
1894 return s
->errorhandler();
1899 PyDoc_STRVAR(bind_doc
,
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. */
1912 sock_close(PySocketSockObject
*s
)
1916 if ((fd
= s
->sock_fd
) != -1) {
1918 Py_BEGIN_ALLOW_THREADS
1919 (void) SOCKETCLOSE(fd
);
1920 Py_END_ALLOW_THREADS
1926 PyDoc_STRVAR(close_doc
,
1929 Close the socket. It cannot be used after this call.");
1932 internal_connect(PySocketSockObject
*s
, struct sockaddr
*addr
, int addrlen
,
1938 res
= connect(s
->sock_fd
, addr
, addrlen
);
1942 if (s
->sock_timeout
> 0.0) {
1943 if (res
< 0 && WSAGetLastError() == WSAEWOULDBLOCK
&&
1945 /* This is a mess. Best solution: trust select */
1949 tv
.tv_sec
= (int)s
->sock_timeout
;
1950 tv
.tv_usec
= (int)((s
->sock_timeout
- tv
.tv_sec
) * 1e6
);
1952 FD_SET(s
->sock_fd
, &fds
);
1954 FD_SET(s
->sock_fd
, &fds_exc
);
1955 res
= select(s
->sock_fd
+1, NULL
, &fds
, &fds_exc
, &tv
);
1957 res
= WSAEWOULDBLOCK
;
1959 } else if (res
> 0) {
1960 if (FD_ISSET(s
->sock_fd
, &fds
))
1961 /* The socket is in the writeable set - this
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
);
1976 res
= WSAGetLastError();
1979 /* else if (res < 0) an error occurred */
1984 res
= WSAGetLastError();
1988 if (s
->sock_timeout
> 0.0) {
1989 if (res
< 0 && errno
== EINPROGRESS
&& IS_SELECTABLE(s
)) {
1990 timeout
= internal_select(s
, 1);
1992 /* Bug #1019808: in case of an EINPROGRESS,
1993 use getsockopt(SO_ERROR) to get the real
1995 socklen_t res_size
= sizeof res
;
1996 (void)getsockopt(s
->sock_fd
, SOL_SOCKET
,
1997 SO_ERROR
, &res
, &res_size
);
2002 else if (timeout
== -1) {
2003 res
= errno
; /* had error */
2006 res
= EWOULDBLOCK
; /* timed out */
2014 *timeoutp
= timeout
;
2019 /* s.connect(sockaddr) method */
2022 sock_connect(PySocketSockObject
*s
, PyObject
*addro
)
2024 sock_addr_t addrbuf
;
2029 if (!getsockaddrarg(s
, addro
, SAS2SA(&addrbuf
), &addrlen
))
2032 Py_BEGIN_ALLOW_THREADS
2033 res
= internal_connect(s
, SAS2SA(&addrbuf
), addrlen
, &timeout
);
2034 Py_END_ALLOW_THREADS
2037 PyErr_SetString(socket_timeout
, "timed out");
2041 return s
->errorhandler();
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 */
2056 sock_connect_ex(PySocketSockObject
*s
, PyObject
*addro
)
2058 sock_addr_t addrbuf
;
2063 if (!getsockaddrarg(s
, addro
, SAS2SA(&addrbuf
), &addrlen
))
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(). */
2073 if (res
== EINTR
&& PyErr_CheckSignals())
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 */
2090 sock_fileno(PySocketSockObject
*s
)
2092 #if SIZEOF_SOCKET_T <= SIZEOF_LONG
2093 return PyInt_FromLong((long) s
->sock_fd
);
2095 return PyLong_FromLongLong((PY_LONG_LONG
)s
->sock_fd
);
2099 PyDoc_STRVAR(fileno_doc
,
2100 "fileno() -> integer\n\
2102 Return the integer file descriptor of the socket.");
2106 /* s.dup() method */
2109 sock_dup(PySocketSockObject
*s
)
2114 newfd
= dup(s
->sock_fd
);
2116 return s
->errorhandler();
2117 sock
= (PyObject
*) new_sockobject(newfd
,
2126 PyDoc_STRVAR(dup_doc
,
2127 "dup() -> socket object\n\
2129 Return a new socket object connected to the same system resource.");
2134 /* s.getsockname() method */
2137 sock_getsockname(PySocketSockObject
*s
)
2139 sock_addr_t addrbuf
;
2143 if (!getsockaddrlen(s
, &addrlen
))
2145 memset(&addrbuf
, 0, addrlen
);
2146 Py_BEGIN_ALLOW_THREADS
2147 res
= getsockname(s
->sock_fd
, SAS2SA(&addrbuf
), &addrlen
);
2148 Py_END_ALLOW_THREADS
2150 return s
->errorhandler();
2151 return makesockaddr(s
->sock_fd
, SAS2SA(&addrbuf
), addrlen
,
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 */
2166 sock_getpeername(PySocketSockObject
*s
)
2168 sock_addr_t addrbuf
;
2172 if (!getsockaddrlen(s
, &addrlen
))
2174 memset(&addrbuf
, 0, addrlen
);
2175 Py_BEGIN_ALLOW_THREADS
2176 res
= getpeername(s
->sock_fd
, SAS2SA(&addrbuf
), &addrlen
);
2177 Py_END_ALLOW_THREADS
2179 return s
->errorhandler();
2180 return makesockaddr(s
->sock_fd
, SAS2SA(&addrbuf
), addrlen
,
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 */
2196 sock_listen(PySocketSockObject
*s
, PyObject
*arg
)
2201 backlog
= PyInt_AsLong(arg
);
2202 if (backlog
== -1 && PyErr_Occurred())
2204 Py_BEGIN_ALLOW_THREADS
2207 res
= listen(s
->sock_fd
, backlog
);
2208 Py_END_ALLOW_THREADS
2210 return s
->errorhandler();
2215 PyDoc_STRVAR(listen_doc
,
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.");
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
2229 The mode argument specifies 'r' or 'w' passed to fdopen(). */
2232 sock_makefile(PySocketSockObject
*s
, PyObject
*args
)
2234 extern int fclose(FILE *);
2249 if (!PyArg_ParseTuple(args
, "|si:makefile", &mode
, &bufsize
))
2252 if (strcmp(mode
,"rb") == 0) {
2256 if (strcmp(mode
,"wb") == 0) {
2262 if (((fd
= _open_osfhandle(s
->sock_fd
, _O_BINARY
)) < 0) ||
2263 ((fd
= dup(fd
)) < 0) || ((fp
= fdopen(fd
, mode
)) == NULL
))
2265 if ((fd
= dup(s
->sock_fd
)) < 0 || (fp
= fdopen(fd
, mode
)) == NULL
)
2270 return s
->errorhandler();
2272 f
= PyFile_FromFile(fp
, "<socket>", mode
, fclose
);
2274 PyFile_SetBufSize(f
, bufsize
);
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.");
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
2295 sock_recv_guts(PySocketSockObject
*s
, char* cbuf
, int len
, int flags
)
2297 ssize_t outlen
= -1;
2304 if (!IS_SELECTABLE(s
)) {
2310 Py_BEGIN_ALLOW_THREADS
2311 timeout
= internal_select(s
, 0);
2313 outlen
= recv(s
->sock_fd
, cbuf
, len
, flags
);
2314 Py_END_ALLOW_THREADS
2317 PyErr_SetString(socket_timeout
, "timed out");
2321 /* Note: the call to errorhandler() ALWAYS indirectly returned
2322 NULL, so ignore its return value */
2329 while (remaining
!= 0) {
2330 unsigned int segment
;
2333 segment
= remaining
/SEGMENT_SIZE
;
2335 segment
= SEGMENT_SIZE
;
2338 segment
= remaining
;
2341 Py_BEGIN_ALLOW_THREADS
2342 timeout
= internal_select(s
, 0);
2344 nread
= recv(s
->sock_fd
, read_buf
, segment
, flags
);
2345 Py_END_ALLOW_THREADS
2348 PyErr_SetString(socket_timeout
, "timed out");
2355 if (nread
!= remaining
) {
2360 remaining
-= segment
;
2361 read_buf
+= segment
;
2363 outlen
= read_buf
- cbuf
;
2370 /* s.recv(nbytes [,flags]) method */
2373 sock_recv(PySocketSockObject
*s
, PyObject
*args
)
2375 int recvlen
, flags
= 0;
2379 if (!PyArg_ParseTuple(args
, "i|i:recv", &recvlen
, &flags
))
2383 PyErr_SetString(PyExc_ValueError
,
2384 "negative buffersize in recv");
2388 /* Allocate a new string. */
2389 buf
= PyString_FromStringAndSize((char *) 0, recvlen
);
2394 outlen
= sock_recv_guts(s
, PyString_AS_STRING(buf
), recvlen
, flags
);
2396 /* An error occurred, release the string and return an
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. */
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 */
2424 sock_recv_into(PySocketSockObject
*s
, PyObject
*args
, PyObject
*kwds
)
2426 static char *kwlist
[] = {"buffer", "nbytes", "flags", 0};
2428 int recvlen
= 0, flags
= 0;
2433 /* Get the buffer's memory */
2434 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "w#|ii:recv_into", kwlist
,
2435 &buf
, &buflen
, &recvlen
, &flags
))
2437 assert(buf
!= 0 && buflen
> 0);
2440 PyErr_SetString(PyExc_ValueError
,
2441 "negative buffersize in recv_into");
2445 /* If nbytes was not specified, use the buffer's length */
2449 /* Check if the buffer is large enough */
2450 if (buflen
< recvlen
) {
2451 PyErr_SetString(PyExc_ValueError
,
2452 "buffer too small for requested bytes");
2457 readlen
= sock_recv_guts(s
, buf
, recvlen
, flags
);
2459 /* Return an error. */
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
2486 * 'addr' is a return value for the address object. Note that you must decref
2490 sock_recvfrom_guts(PySocketSockObject
*s
, char* cbuf
, int len
, int flags
,
2493 sock_addr_t addrbuf
;
2500 if (!getsockaddrlen(s
, &addrlen
))
2503 if (!IS_SELECTABLE(s
)) {
2508 Py_BEGIN_ALLOW_THREADS
2509 memset(&addrbuf
, 0, addrlen
);
2510 timeout
= internal_select(s
, 0);
2513 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
2514 n
= recvfrom(s
->sock_fd
, cbuf
, len
, flags
,
2515 SAS2SA(&addrbuf
), &addrlen
);
2517 n
= recvfrom(s
->sock_fd
, cbuf
, len
, flags
,
2518 (void *) &addrbuf
, &addrlen
);
2521 n
= recvfrom(s
->sock_fd
, cbuf
, len
, flags
,
2522 SAS2SA(&addrbuf
), &addrlen
);
2525 Py_END_ALLOW_THREADS
2528 PyErr_SetString(socket_timeout
, "timed out");
2536 if (!(*addr
= makesockaddr(s
->sock_fd
, SAS2SA(&addrbuf
),
2537 addrlen
, s
->sock_proto
)))
2543 /* s.recvfrom(nbytes [,flags]) method */
2546 sock_recvfrom(PySocketSockObject
*s
, PyObject
*args
)
2548 PyObject
*buf
= NULL
;
2549 PyObject
*addr
= NULL
;
2550 PyObject
*ret
= NULL
;
2551 int recvlen
, flags
= 0;
2554 if (!PyArg_ParseTuple(args
, "i|i:recvfrom", &recvlen
, &flags
))
2558 PyErr_SetString(PyExc_ValueError
,
2559 "negative buffersize in recvfrom");
2563 buf
= PyString_FromStringAndSize((char *) 0, recvlen
);
2567 outlen
= sock_recvfrom_guts(s
, PyString_AS_STRING(buf
),
2568 recvlen
, flags
, &addr
);
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. */
2581 ret
= PyTuple_Pack(2, buf
, addr
);
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 */
2598 sock_recvfrom_into(PySocketSockObject
*s
, PyObject
*args
, PyObject
* kwds
)
2600 static char *kwlist
[] = {"buffer", "nbytes", "flags", 0};
2602 int recvlen
= 0, flags
= 0;
2607 PyObject
*addr
= NULL
;
2609 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "w#|ii:recvfrom_into",
2610 kwlist
, &buf
, &buflen
,
2613 assert(buf
!= 0 && buflen
> 0);
2616 PyErr_SetString(PyExc_ValueError
,
2617 "negative buffersize in recvfrom_into");
2621 /* If nbytes was not specified, use the buffer's length */
2625 readlen
= sock_recvfrom_guts(s
, buf
, recvlen
, flags
, &addr
);
2627 /* Return an error */
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 */
2646 sock_send(PySocketSockObject
*s
, PyObject
*args
)
2649 int len
, n
= -1, flags
= 0, timeout
;
2652 if (!PyArg_ParseTuple(args
, "s*|i:send", &pbuf
, &flags
))
2655 if (!IS_SELECTABLE(s
)) {
2656 PyBuffer_Release(&pbuf
);
2657 return select_error();
2662 Py_BEGIN_ALLOW_THREADS
2663 timeout
= internal_select(s
, 1);
2666 n
= sendsegmented(s
->sock_fd
, buf
, len
, flags
);
2668 n
= send(s
->sock_fd
, buf
, len
, flags
);
2670 Py_END_ALLOW_THREADS
2672 PyBuffer_Release(&pbuf
);
2675 PyErr_SetString(socket_timeout
, "timed out");
2679 return s
->errorhandler();
2680 return PyInt_FromLong((long)n
);
2683 PyDoc_STRVAR(send_doc
,
2684 "send(data[, flags]) -> count\n\
2686 Send a data string to the socket. For the optional flags\n\
2687 argument, see the Unix manual. Return the number of bytes\n\
2688 sent; this may be less than len(data) if the network is busy.");
2691 /* s.sendall(data [,flags]) method */
2694 sock_sendall(PySocketSockObject
*s
, PyObject
*args
)
2697 int len
, n
= -1, flags
= 0, timeout
;
2700 if (!PyArg_ParseTuple(args
, "s*|i:sendall", &pbuf
, &flags
))
2705 if (!IS_SELECTABLE(s
)) {
2706 PyBuffer_Release(&pbuf
);
2707 return select_error();
2710 Py_BEGIN_ALLOW_THREADS
2712 timeout
= internal_select(s
, 1);
2717 n
= sendsegmented(s
->sock_fd
, buf
, len
, flags
);
2719 n
= send(s
->sock_fd
, buf
, len
, flags
);
2726 Py_END_ALLOW_THREADS
2727 PyBuffer_Release(&pbuf
);
2730 PyErr_SetString(socket_timeout
, "timed out");
2734 return s
->errorhandler();
2740 PyDoc_STRVAR(sendall_doc
,
2741 "sendall(data[, flags])\n\
2743 Send a data string to the socket. For the optional flags\n\
2744 argument, see the Unix manual. This calls send() repeatedly\n\
2745 until all data is sent. If an error occurs, it's impossible\n\
2746 to tell how much data has been sent.");
2749 /* s.sendto(data, [flags,] sockaddr) method */
2752 sock_sendto(PySocketSockObject
*s
, PyObject
*args
)
2758 sock_addr_t addrbuf
;
2759 int addrlen
, n
= -1, flags
, timeout
;
2762 if (!PyArg_ParseTuple(args
, "s*O:sendto", &pbuf
, &addro
)) {
2764 if (!PyArg_ParseTuple(args
, "s*iO:sendto",
2765 &pbuf
, &flags
, &addro
))
2771 if (!IS_SELECTABLE(s
)) {
2772 PyBuffer_Release(&pbuf
);
2773 return select_error();
2776 if (!getsockaddrarg(s
, addro
, SAS2SA(&addrbuf
), &addrlen
)) {
2777 PyBuffer_Release(&pbuf
);
2781 Py_BEGIN_ALLOW_THREADS
2782 timeout
= internal_select(s
, 1);
2784 n
= sendto(s
->sock_fd
, buf
, len
, flags
, SAS2SA(&addrbuf
), addrlen
);
2785 Py_END_ALLOW_THREADS
2787 PyBuffer_Release(&pbuf
);
2789 PyErr_SetString(socket_timeout
, "timed out");
2793 return s
->errorhandler();
2794 return PyInt_FromLong((long)n
);
2797 PyDoc_STRVAR(sendto_doc
,
2798 "sendto(data[, flags], address) -> count\n\
2800 Like send(data, flags) but allows specifying the destination address.\n\
2801 For IP sockets, the address is a pair (hostaddr, port).");
2804 /* s.shutdown(how) method */
2807 sock_shutdown(PySocketSockObject
*s
, PyObject
*arg
)
2812 how
= PyInt_AsLong(arg
);
2813 if (how
== -1 && PyErr_Occurred())
2815 Py_BEGIN_ALLOW_THREADS
2816 res
= shutdown(s
->sock_fd
, how
);
2817 Py_END_ALLOW_THREADS
2819 return s
->errorhandler();
2824 PyDoc_STRVAR(shutdown_doc
,
2827 Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\
2828 of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");
2830 #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
2832 sock_ioctl(PySocketSockObject
*s
, PyObject
*arg
)
2834 unsigned long cmd
= SIO_RCVALL
;
2835 unsigned int option
= RCVALL_ON
;
2838 if (!PyArg_ParseTuple(arg
, "kI:ioctl", &cmd
, &option
))
2841 if (WSAIoctl(s
->sock_fd
, cmd
, &option
, sizeof(option
),
2842 NULL
, 0, &recv
, NULL
, NULL
) == SOCKET_ERROR
) {
2845 return PyLong_FromUnsignedLong(recv
);
2847 PyDoc_STRVAR(sock_ioctl_doc
,
2848 "ioctl(cmd, option) -> long\n\
2850 Control the socket with WSAIoctl syscall. Currently only socket.SIO_RCVALL\n\
2851 is supported as control. Options must be one of the socket.RCVALL_*\n\
2856 /* List of methods for socket objects */
2858 static PyMethodDef sock_methods
[] = {
2859 {"accept", (PyCFunction
)sock_accept
, METH_NOARGS
,
2861 {"bind", (PyCFunction
)sock_bind
, METH_O
,
2863 {"close", (PyCFunction
)sock_close
, METH_NOARGS
,
2865 {"connect", (PyCFunction
)sock_connect
, METH_O
,
2867 {"connect_ex", (PyCFunction
)sock_connect_ex
, METH_O
,
2870 {"dup", (PyCFunction
)sock_dup
, METH_NOARGS
,
2873 {"fileno", (PyCFunction
)sock_fileno
, METH_NOARGS
,
2875 #ifdef HAVE_GETPEERNAME
2876 {"getpeername", (PyCFunction
)sock_getpeername
,
2877 METH_NOARGS
, getpeername_doc
},
2879 {"getsockname", (PyCFunction
)sock_getsockname
,
2880 METH_NOARGS
, getsockname_doc
},
2881 {"getsockopt", (PyCFunction
)sock_getsockopt
, METH_VARARGS
,
2883 #if defined(MS_WINDOWS) && defined(SIO_RCVALL)
2884 {"ioctl", (PyCFunction
)sock_ioctl
, METH_VARARGS
,
2887 {"listen", (PyCFunction
)sock_listen
, METH_O
,
2890 {"makefile", (PyCFunction
)sock_makefile
, METH_VARARGS
,
2893 {"recv", (PyCFunction
)sock_recv
, METH_VARARGS
,
2895 {"recv_into", (PyCFunction
)sock_recv_into
, METH_VARARGS
| METH_KEYWORDS
,
2897 {"recvfrom", (PyCFunction
)sock_recvfrom
, METH_VARARGS
,
2899 {"recvfrom_into", (PyCFunction
)sock_recvfrom_into
, METH_VARARGS
| METH_KEYWORDS
,
2901 {"send", (PyCFunction
)sock_send
, METH_VARARGS
,
2903 {"sendall", (PyCFunction
)sock_sendall
, METH_VARARGS
,
2905 {"sendto", (PyCFunction
)sock_sendto
, METH_VARARGS
,
2907 {"setblocking", (PyCFunction
)sock_setblocking
, METH_O
,
2909 {"settimeout", (PyCFunction
)sock_settimeout
, METH_O
,
2911 {"gettimeout", (PyCFunction
)sock_gettimeout
, METH_NOARGS
,
2913 {"setsockopt", (PyCFunction
)sock_setsockopt
, METH_VARARGS
,
2915 {"shutdown", (PyCFunction
)sock_shutdown
, METH_O
,
2918 {"sleeptaskw", (PyCFunction
)sock_sleeptaskw
, METH_O
,
2921 {NULL
, NULL
} /* sentinel */
2924 /* SockObject members */
2925 static PyMemberDef sock_memberlist
[] = {
2926 {"family", T_INT
, offsetof(PySocketSockObject
, sock_family
), READONLY
, "the socket family"},
2927 {"type", T_INT
, offsetof(PySocketSockObject
, sock_type
), READONLY
, "the socket type"},
2928 {"proto", T_INT
, offsetof(PySocketSockObject
, sock_proto
), READONLY
, "the socket protocol"},
2929 {"timeout", T_DOUBLE
, offsetof(PySocketSockObject
, sock_timeout
), READONLY
, "the socket timeout"},
2933 /* Deallocate a socket object in response to the last Py_DECREF().
2934 First close the file description. */
2937 sock_dealloc(PySocketSockObject
*s
)
2939 if (s
->sock_fd
!= -1)
2940 (void) SOCKETCLOSE(s
->sock_fd
);
2941 Py_TYPE(s
)->tp_free((PyObject
*)s
);
2946 sock_repr(PySocketSockObject
*s
)
2949 #if SIZEOF_SOCKET_T > SIZEOF_LONG
2950 if (s
->sock_fd
> LONG_MAX
) {
2951 /* this can occur on Win64, and actually there is a special
2952 ugly printf formatter for decimal pointer length integer
2953 printing, only bother if necessary*/
2954 PyErr_SetString(PyExc_OverflowError
,
2955 "no printf formatter to display "
2956 "the socket descriptor in decimal");
2962 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
2963 (long)s
->sock_fd
, s
->sock_family
,
2966 return PyString_FromString(buf
);
2970 /* Create a new, uninitialized socket object. */
2973 sock_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
2977 new = type
->tp_alloc(type
, 0);
2979 ((PySocketSockObject
*)new)->sock_fd
= -1;
2980 ((PySocketSockObject
*)new)->sock_timeout
= -1.0;
2981 ((PySocketSockObject
*)new)->errorhandler
= &set_error
;
2987 /* Initialize a new socket object. */
2991 sock_initobj(PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
2993 PySocketSockObject
*s
= (PySocketSockObject
*)self
;
2995 int family
= AF_INET
, type
= SOCK_STREAM
, proto
= 0;
2996 static char *keywords
[] = {"family", "type", "proto", 0};
2998 if (!PyArg_ParseTupleAndKeywords(args
, kwds
,
2999 "|iii:socket", keywords
,
3000 &family
, &type
, &proto
))
3003 Py_BEGIN_ALLOW_THREADS
3004 fd
= socket(family
, type
, proto
);
3005 Py_END_ALLOW_THREADS
3008 if (fd
== INVALID_SOCKET
)
3016 init_sockobject(s
, fd
, family
, type
, proto
);
3023 /* Type object for socket objects. */
3025 static PyTypeObject sock_type
= {
3026 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */
3027 "_socket.socket", /* tp_name */
3028 sizeof(PySocketSockObject
), /* tp_basicsize */
3029 0, /* tp_itemsize */
3030 (destructor
)sock_dealloc
, /* tp_dealloc */
3035 (reprfunc
)sock_repr
, /* tp_repr */
3036 0, /* tp_as_number */
3037 0, /* tp_as_sequence */
3038 0, /* tp_as_mapping */
3042 PyObject_GenericGetAttr
, /* tp_getattro */
3043 0, /* tp_setattro */
3044 0, /* tp_as_buffer */
3045 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
3046 sock_doc
, /* tp_doc */
3047 0, /* tp_traverse */
3049 0, /* tp_richcompare */
3050 0, /* tp_weaklistoffset */
3052 0, /* tp_iternext */
3053 sock_methods
, /* tp_methods */
3054 sock_memberlist
, /* tp_members */
3058 0, /* tp_descr_get */
3059 0, /* tp_descr_set */
3060 0, /* tp_dictoffset */
3061 sock_initobj
, /* tp_init */
3062 PyType_GenericAlloc
, /* tp_alloc */
3063 sock_new
, /* tp_new */
3064 PyObject_Del
, /* tp_free */
3068 /* Python interface to gethostname(). */
3072 socket_gethostname(PyObject
*self
, PyObject
*unused
)
3076 Py_BEGIN_ALLOW_THREADS
3077 res
= gethostname(buf
, (int) sizeof buf
- 1);
3078 Py_END_ALLOW_THREADS
3081 buf
[sizeof buf
- 1] = '\0';
3082 return PyString_FromString(buf
);
3085 PyDoc_STRVAR(gethostname_doc
,
3086 "gethostname() -> string\n\
3088 Return the current host name.");
3091 /* Python interface to gethostbyname(name). */
3095 socket_gethostbyname(PyObject
*self
, PyObject
*args
)
3098 sock_addr_t addrbuf
;
3100 if (!PyArg_ParseTuple(args
, "s:gethostbyname", &name
))
3102 if (setipaddr(name
, SAS2SA(&addrbuf
), sizeof(addrbuf
), AF_INET
) < 0)
3104 return makeipaddr(SAS2SA(&addrbuf
), sizeof(struct sockaddr_in
));
3107 PyDoc_STRVAR(gethostbyname_doc
,
3108 "gethostbyname(host) -> address\n\
3110 Return the IP address (a string of the form '255.255.255.255') for a host.");
3113 /* Convenience function common to gethostbyname_ex and gethostbyaddr */
3116 gethost_common(struct hostent
*h
, struct sockaddr
*addr
, int alen
, int af
)
3119 PyObject
*rtn_tuple
= (PyObject
*)NULL
;
3120 PyObject
*name_list
= (PyObject
*)NULL
;
3121 PyObject
*addr_list
= (PyObject
*)NULL
;
3125 /* Let's get real error message to return */
3127 set_herror(h_errno
);
3129 PyErr_SetString(socket_error
, "host not found");
3134 if (h
->h_addrtype
!= af
) {
3135 /* Let's get real error message to return */
3136 PyErr_SetString(socket_error
,
3137 (char *)strerror(EAFNOSUPPORT
));
3145 if (alen
< sizeof(struct sockaddr_in
))
3151 if (alen
< sizeof(struct sockaddr_in6
))
3158 if ((name_list
= PyList_New(0)) == NULL
)
3161 if ((addr_list
= PyList_New(0)) == NULL
)
3164 /* SF #1511317: h_aliases can be NULL */
3166 for (pch
= h
->h_aliases
; *pch
!= NULL
; pch
++) {
3168 tmp
= PyString_FromString(*pch
);
3172 status
= PyList_Append(name_list
, tmp
);
3180 for (pch
= h
->h_addr_list
; *pch
!= NULL
; pch
++) {
3187 struct sockaddr_in sin
;
3188 memset(&sin
, 0, sizeof(sin
));
3189 sin
.sin_family
= af
;
3190 #ifdef HAVE_SOCKADDR_SA_LEN
3191 sin
.sin_len
= sizeof(sin
);
3193 memcpy(&sin
.sin_addr
, *pch
, sizeof(sin
.sin_addr
));
3194 tmp
= makeipaddr((struct sockaddr
*)&sin
, sizeof(sin
));
3196 if (pch
== h
->h_addr_list
&& alen
>= sizeof(sin
))
3197 memcpy((char *) addr
, &sin
, sizeof(sin
));
3204 struct sockaddr_in6 sin6
;
3205 memset(&sin6
, 0, sizeof(sin6
));
3206 sin6
.sin6_family
= af
;
3207 #ifdef HAVE_SOCKADDR_SA_LEN
3208 sin6
.sin6_len
= sizeof(sin6
);
3210 memcpy(&sin6
.sin6_addr
, *pch
, sizeof(sin6
.sin6_addr
));
3211 tmp
= makeipaddr((struct sockaddr
*)&sin6
,
3214 if (pch
== h
->h_addr_list
&& alen
>= sizeof(sin6
))
3215 memcpy((char *) addr
, &sin6
, sizeof(sin6
));
3220 default: /* can't happen */
3221 PyErr_SetString(socket_error
,
3222 "unsupported address family");
3229 status
= PyList_Append(addr_list
, tmp
);
3236 rtn_tuple
= Py_BuildValue("sOO", h
->h_name
, name_list
, addr_list
);
3239 Py_XDECREF(name_list
);
3240 Py_XDECREF(addr_list
);
3245 /* Python interface to gethostbyname_ex(name). */
3249 socket_gethostbyname_ex(PyObject
*self
, PyObject
*args
)
3254 struct sockaddr_storage addr
;
3256 struct sockaddr_in addr
;
3258 struct sockaddr
*sa
;
3260 #ifdef HAVE_GETHOSTBYNAME_R
3261 struct hostent hp_allocated
;
3262 #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
3263 struct hostent_data data
;
3266 int buf_len
= (sizeof buf
) - 1;
3269 #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3272 #endif /* HAVE_GETHOSTBYNAME_R */
3274 if (!PyArg_ParseTuple(args
, "s:gethostbyname_ex", &name
))
3276 if (setipaddr(name
, (struct sockaddr
*)&addr
, sizeof(addr
), AF_INET
) < 0)
3278 Py_BEGIN_ALLOW_THREADS
3279 #ifdef HAVE_GETHOSTBYNAME_R
3280 #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3281 result
= gethostbyname_r(name
, &hp_allocated
, buf
, buf_len
,
3283 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
3284 h
= gethostbyname_r(name
, &hp_allocated
, buf
, buf_len
, &errnop
);
3285 #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
3286 memset((void *) &data
, '\0', sizeof(data
));
3287 result
= gethostbyname_r(name
, &hp_allocated
, &data
);
3288 h
= (result
!= 0) ? NULL
: &hp_allocated
;
3290 #else /* not HAVE_GETHOSTBYNAME_R */
3291 #ifdef USE_GETHOSTBYNAME_LOCK
3292 PyThread_acquire_lock(netdb_lock
, 1);
3294 h
= gethostbyname(name
);
3295 #endif /* HAVE_GETHOSTBYNAME_R */
3296 Py_END_ALLOW_THREADS
3297 /* Some C libraries would require addr.__ss_family instead of
3299 Therefore, we cast the sockaddr_storage into sockaddr to
3300 access sa_family. */
3301 sa
= (struct sockaddr
*)&addr
;
3302 ret
= gethost_common(h
, (struct sockaddr
*)&addr
, sizeof(addr
),
3304 #ifdef USE_GETHOSTBYNAME_LOCK
3305 PyThread_release_lock(netdb_lock
);
3310 PyDoc_STRVAR(ghbn_ex_doc
,
3311 "gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
3313 Return the true host name, a list of aliases, and a list of IP addresses,\n\
3314 for a host. The host argument is a string giving a host name or IP number.");
3317 /* Python interface to gethostbyaddr(IP). */
3321 socket_gethostbyaddr(PyObject
*self
, PyObject
*args
)
3324 struct sockaddr_storage addr
;
3326 struct sockaddr_in addr
;
3328 struct sockaddr
*sa
= (struct sockaddr
*)&addr
;
3332 #ifdef HAVE_GETHOSTBYNAME_R
3333 struct hostent hp_allocated
;
3334 #ifdef HAVE_GETHOSTBYNAME_R_3_ARG
3335 struct hostent_data data
;
3338 int buf_len
= (sizeof buf
) - 1;
3341 #if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3344 #endif /* HAVE_GETHOSTBYNAME_R */
3349 if (!PyArg_ParseTuple(args
, "s:gethostbyaddr", &ip_num
))
3352 if (setipaddr(ip_num
, sa
, sizeof(addr
), af
) < 0)
3359 ap
= (char *)&((struct sockaddr_in
*)sa
)->sin_addr
;
3360 al
= sizeof(((struct sockaddr_in
*)sa
)->sin_addr
);
3364 ap
= (char *)&((struct sockaddr_in6
*)sa
)->sin6_addr
;
3365 al
= sizeof(((struct sockaddr_in6
*)sa
)->sin6_addr
);
3369 PyErr_SetString(socket_error
, "unsupported address family");
3372 Py_BEGIN_ALLOW_THREADS
3373 #ifdef HAVE_GETHOSTBYNAME_R
3374 #if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
3375 result
= gethostbyaddr_r(ap
, al
, af
,
3376 &hp_allocated
, buf
, buf_len
,
3378 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
3379 h
= gethostbyaddr_r(ap
, al
, af
,
3380 &hp_allocated
, buf
, buf_len
, &errnop
);
3381 #else /* HAVE_GETHOSTBYNAME_R_3_ARG */
3382 memset((void *) &data
, '\0', sizeof(data
));
3383 result
= gethostbyaddr_r(ap
, al
, af
, &hp_allocated
, &data
);
3384 h
= (result
!= 0) ? NULL
: &hp_allocated
;
3386 #else /* not HAVE_GETHOSTBYNAME_R */
3387 #ifdef USE_GETHOSTBYNAME_LOCK
3388 PyThread_acquire_lock(netdb_lock
, 1);
3390 h
= gethostbyaddr(ap
, al
, af
);
3391 #endif /* HAVE_GETHOSTBYNAME_R */
3392 Py_END_ALLOW_THREADS
3393 ret
= gethost_common(h
, (struct sockaddr
*)&addr
, sizeof(addr
), af
);
3394 #ifdef USE_GETHOSTBYNAME_LOCK
3395 PyThread_release_lock(netdb_lock
);
3400 PyDoc_STRVAR(gethostbyaddr_doc
,
3401 "gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
3403 Return the true host name, a list of aliases, and a list of IP addresses,\n\
3404 for a host. The host argument is a string giving a host name or IP number.");
3407 /* Python interface to getservbyname(name).
3408 This only returns the port number, since the other info is already
3409 known or not useful (like the list of aliases). */
3413 socket_getservbyname(PyObject
*self
, PyObject
*args
)
3415 char *name
, *proto
=NULL
;
3417 if (!PyArg_ParseTuple(args
, "s|s:getservbyname", &name
, &proto
))
3419 Py_BEGIN_ALLOW_THREADS
3420 sp
= getservbyname(name
, proto
);
3421 Py_END_ALLOW_THREADS
3423 PyErr_SetString(socket_error
, "service/proto not found");
3426 return PyInt_FromLong((long) ntohs(sp
->s_port
));
3429 PyDoc_STRVAR(getservbyname_doc
,
3430 "getservbyname(servicename[, protocolname]) -> integer\n\
3432 Return a port number from a service name and protocol name.\n\
3433 The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3434 otherwise any protocol will match.");
3437 /* Python interface to getservbyport(port).
3438 This only returns the service name, since the other info is already
3439 known or not useful (like the list of aliases). */
3443 socket_getservbyport(PyObject
*self
, PyObject
*args
)
3445 unsigned short port
;
3448 if (!PyArg_ParseTuple(args
, "H|s:getservbyport", &port
, &proto
))
3450 Py_BEGIN_ALLOW_THREADS
3451 sp
= getservbyport(htons(port
), proto
);
3452 Py_END_ALLOW_THREADS
3454 PyErr_SetString(socket_error
, "port/proto not found");
3457 return PyString_FromString(sp
->s_name
);
3460 PyDoc_STRVAR(getservbyport_doc
,
3461 "getservbyport(port[, protocolname]) -> string\n\
3463 Return the service name from a port number and protocol name.\n\
3464 The optional protocol name, if given, should be 'tcp' or 'udp',\n\
3465 otherwise any protocol will match.");
3467 /* Python interface to getprotobyname(name).
3468 This only returns the protocol number, since the other info is
3469 already known or not useful (like the list of aliases). */
3473 socket_getprotobyname(PyObject
*self
, PyObject
*args
)
3476 struct protoent
*sp
;
3478 /* Not available in BeOS yet. - [cjh] */
3479 PyErr_SetString(socket_error
, "getprotobyname not supported");
3482 if (!PyArg_ParseTuple(args
, "s:getprotobyname", &name
))
3484 Py_BEGIN_ALLOW_THREADS
3485 sp
= getprotobyname(name
);
3486 Py_END_ALLOW_THREADS
3488 PyErr_SetString(socket_error
, "protocol not found");
3491 return PyInt_FromLong((long) sp
->p_proto
);
3495 PyDoc_STRVAR(getprotobyname_doc
,
3496 "getprotobyname(name) -> integer\n\
3498 Return the protocol number for the named protocol. (Rarely used.)");
3501 #ifdef HAVE_SOCKETPAIR
3502 /* Create a pair of sockets using the socketpair() function.
3503 Arguments as for socket() except the default family is AF_UNIX if
3504 defined on the platform; otherwise, the default is AF_INET. */
3508 socket_socketpair(PyObject
*self
, PyObject
*args
)
3510 PySocketSockObject
*s0
= NULL
, *s1
= NULL
;
3512 int family
, type
= SOCK_STREAM
, proto
= 0;
3513 PyObject
*res
= NULL
;
3515 #if defined(AF_UNIX)
3520 if (!PyArg_ParseTuple(args
, "|iii:socketpair",
3521 &family
, &type
, &proto
))
3523 /* Create a pair of socket fds */
3524 if (socketpair(family
, type
, proto
, sv
) < 0)
3526 s0
= new_sockobject(sv
[0], family
, type
, proto
);
3529 s1
= new_sockobject(sv
[1], family
, type
, proto
);
3532 res
= PyTuple_Pack(2, s0
, s1
);
3546 PyDoc_STRVAR(socketpair_doc
,
3547 "socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\
3549 Create a pair of socket objects from the sockets returned by the platform\n\
3550 socketpair() function.\n\
3551 The arguments are the same as for socket() except the default family is\n\
3552 AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");
3554 #endif /* HAVE_SOCKETPAIR */
3558 /* Create a socket object from a numeric file description.
3559 Useful e.g. if stdin is a socket.
3560 Additional arguments as for socket(). */
3564 socket_fromfd(PyObject
*self
, PyObject
*args
)
3566 PySocketSockObject
*s
;
3568 int family
, type
, proto
= 0;
3569 if (!PyArg_ParseTuple(args
, "iii|i:fromfd",
3570 &fd
, &family
, &type
, &proto
))
3572 /* Dup the fd so it and the socket can be closed independently */
3576 s
= new_sockobject(fd
, family
, type
, proto
);
3577 return (PyObject
*) s
;
3580 PyDoc_STRVAR(fromfd_doc
,
3581 "fromfd(fd, family, type[, proto]) -> socket object\n\
3583 Create a socket object from a duplicate of the given\n\
3585 The remaining arguments are the same as for socket().");
3591 socket_ntohs(PyObject
*self
, PyObject
*args
)
3595 if (!PyArg_ParseTuple(args
, "i:ntohs", &x1
)) {
3599 PyErr_SetString(PyExc_OverflowError
,
3600 "can't convert negative number to unsigned long");
3603 x2
= (unsigned int)ntohs((unsigned short)x1
);
3604 return PyInt_FromLong(x2
);
3607 PyDoc_STRVAR(ntohs_doc
,
3608 "ntohs(integer) -> integer\n\
3610 Convert a 16-bit integer from network to host byte order.");
3614 socket_ntohl(PyObject
*self
, PyObject
*arg
)
3618 if (PyInt_Check(arg
)) {
3619 x
= PyInt_AS_LONG(arg
);
3620 if (x
== (unsigned long) -1 && PyErr_Occurred())
3623 PyErr_SetString(PyExc_OverflowError
,
3624 "can't convert negative number to unsigned long");
3628 else if (PyLong_Check(arg
)) {
3629 x
= PyLong_AsUnsignedLong(arg
);
3630 if (x
== (unsigned long) -1 && PyErr_Occurred())
3635 /* only want the trailing 32 bits */
3636 y
= x
& 0xFFFFFFFFUL
;
3638 return PyErr_Format(PyExc_OverflowError
,
3639 "long int larger than 32 bits");
3645 return PyErr_Format(PyExc_TypeError
,
3646 "expected int/long, %s found",
3647 Py_TYPE(arg
)->tp_name
);
3648 if (x
== (unsigned long) -1 && PyErr_Occurred())
3650 return PyLong_FromUnsignedLong(ntohl(x
));
3653 PyDoc_STRVAR(ntohl_doc
,
3654 "ntohl(integer) -> integer\n\
3656 Convert a 32-bit integer from network to host byte order.");
3660 socket_htons(PyObject
*self
, PyObject
*args
)
3664 if (!PyArg_ParseTuple(args
, "i:htons", &x1
)) {
3668 PyErr_SetString(PyExc_OverflowError
,
3669 "can't convert negative number to unsigned long");
3672 x2
= (unsigned int)htons((unsigned short)x1
);
3673 return PyInt_FromLong(x2
);
3676 PyDoc_STRVAR(htons_doc
,
3677 "htons(integer) -> integer\n\
3679 Convert a 16-bit integer from host to network byte order.");
3683 socket_htonl(PyObject
*self
, PyObject
*arg
)
3687 if (PyInt_Check(arg
)) {
3688 x
= PyInt_AS_LONG(arg
);
3689 if (x
== (unsigned long) -1 && PyErr_Occurred())
3692 PyErr_SetString(PyExc_OverflowError
,
3693 "can't convert negative number to unsigned long");
3697 else if (PyLong_Check(arg
)) {
3698 x
= PyLong_AsUnsignedLong(arg
);
3699 if (x
== (unsigned long) -1 && PyErr_Occurred())
3704 /* only want the trailing 32 bits */
3705 y
= x
& 0xFFFFFFFFUL
;
3707 return PyErr_Format(PyExc_OverflowError
,
3708 "long int larger than 32 bits");
3714 return PyErr_Format(PyExc_TypeError
,
3715 "expected int/long, %s found",
3716 Py_TYPE(arg
)->tp_name
);
3717 return PyLong_FromUnsignedLong(htonl((unsigned long)x
));
3720 PyDoc_STRVAR(htonl_doc
,
3721 "htonl(integer) -> integer\n\
3723 Convert a 32-bit integer from host to network byte order.");
3725 /* socket.inet_aton() and socket.inet_ntoa() functions. */
3727 PyDoc_STRVAR(inet_aton_doc
,
3728 "inet_aton(string) -> packed 32-bit IP representation\n\
3730 Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
3731 binary format used in low-level network functions.");
3734 socket_inet_aton(PyObject
*self
, PyObject
*args
)
3737 #define INADDR_NONE (-1)
3739 #ifdef HAVE_INET_ATON
3743 #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3744 /* Have to use inet_addr() instead */
3745 unsigned long packed_addr
;
3749 if (!PyArg_ParseTuple(args
, "s:inet_aton", &ip_addr
))
3753 #ifdef HAVE_INET_ATON
3755 #ifdef USE_INET_ATON_WEAKLINK
3756 if (inet_aton
!= NULL
) {
3758 if (inet_aton(ip_addr
, &buf
))
3759 return PyString_FromStringAndSize((char *)(&buf
),
3762 PyErr_SetString(socket_error
,
3763 "illegal IP address string passed to inet_aton");
3766 #ifdef USE_INET_ATON_WEAKLINK
3772 #if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
3774 /* special-case this address as inet_addr might return INADDR_NONE
3776 if (strcmp(ip_addr
, "255.255.255.255") == 0) {
3777 packed_addr
= 0xFFFFFFFF;
3780 packed_addr
= inet_addr(ip_addr
);
3782 if (packed_addr
== INADDR_NONE
) { /* invalid address */
3783 PyErr_SetString(socket_error
,
3784 "illegal IP address string passed to inet_aton");
3788 return PyString_FromStringAndSize((char *) &packed_addr
,
3789 sizeof(packed_addr
));
3791 #ifdef USE_INET_ATON_WEAKLINK
3798 PyDoc_STRVAR(inet_ntoa_doc
,
3799 "inet_ntoa(packed_ip) -> ip_address_string\n\
3801 Convert an IP address from 32-bit packed binary format to string format");
3804 socket_inet_ntoa(PyObject
*self
, PyObject
*args
)
3808 struct in_addr packed_addr
;
3810 if (!PyArg_ParseTuple(args
, "s#:inet_ntoa", &packed_str
, &addr_len
)) {
3814 if (addr_len
!= sizeof(packed_addr
)) {
3815 PyErr_SetString(socket_error
,
3816 "packed IP wrong length for inet_ntoa");
3820 memcpy(&packed_addr
, packed_str
, addr_len
);
3822 return PyString_FromString(inet_ntoa(packed_addr
));
3825 #ifdef HAVE_INET_PTON
3827 PyDoc_STRVAR(inet_pton_doc
,
3828 "inet_pton(af, ip) -> packed IP address string\n\
3830 Convert an IP address from string format to a packed string suitable\n\
3831 for use with low-level network functions.");
3834 socket_inet_pton(PyObject
*self
, PyObject
*args
)
3840 char packed
[MAX(sizeof(struct in_addr
), sizeof(struct in6_addr
))];
3842 char packed
[sizeof(struct in_addr
)];
3844 if (!PyArg_ParseTuple(args
, "is:inet_pton", &af
, &ip
)) {
3848 #if !defined(ENABLE_IPV6) && defined(AF_INET6)
3849 if(af
== AF_INET6
) {
3850 PyErr_SetString(socket_error
,
3851 "can't use AF_INET6, IPv6 is disabled");
3856 retval
= inet_pton(af
, ip
, packed
);
3858 PyErr_SetFromErrno(socket_error
);
3860 } else if (retval
== 0) {
3861 PyErr_SetString(socket_error
,
3862 "illegal IP address string passed to inet_pton");
3864 } else if (af
== AF_INET
) {
3865 return PyString_FromStringAndSize(packed
,
3866 sizeof(struct in_addr
));
3868 } else if (af
== AF_INET6
) {
3869 return PyString_FromStringAndSize(packed
,
3870 sizeof(struct in6_addr
));
3873 PyErr_SetString(socket_error
, "unknown address family");
3878 PyDoc_STRVAR(inet_ntop_doc
,
3879 "inet_ntop(af, packed_ip) -> string formatted IP address\n\
3881 Convert a packed IP address of the given family to string format.");
3884 socket_inet_ntop(PyObject
*self
, PyObject
*args
)
3891 char ip
[MAX(INET_ADDRSTRLEN
, INET6_ADDRSTRLEN
) + 1];
3893 char ip
[INET_ADDRSTRLEN
+ 1];
3896 /* Guarantee NUL-termination for PyString_FromString() below */
3897 memset((void *) &ip
[0], '\0', sizeof(ip
));
3899 if (!PyArg_ParseTuple(args
, "is#:inet_ntop", &af
, &packed
, &len
)) {
3903 if (af
== AF_INET
) {
3904 if (len
!= sizeof(struct in_addr
)) {
3905 PyErr_SetString(PyExc_ValueError
,
3906 "invalid length of packed IP address string");
3910 } else if (af
== AF_INET6
) {
3911 if (len
!= sizeof(struct in6_addr
)) {
3912 PyErr_SetString(PyExc_ValueError
,
3913 "invalid length of packed IP address string");
3918 PyErr_Format(PyExc_ValueError
,
3919 "unknown address family %d", af
);
3923 retval
= inet_ntop(af
, packed
, ip
, sizeof(ip
));
3925 PyErr_SetFromErrno(socket_error
);
3928 return PyString_FromString(retval
);
3932 PyErr_SetString(PyExc_RuntimeError
, "invalid handling of inet_ntop");
3936 #endif /* HAVE_INET_PTON */
3938 /* Python interface to getaddrinfo(host, port). */
3942 socket_getaddrinfo(PyObject
*self
, PyObject
*args
)
3944 struct addrinfo hints
, *res
;
3945 struct addrinfo
*res0
= NULL
;
3946 PyObject
*hobj
= NULL
;
3947 PyObject
*pobj
= (PyObject
*)NULL
;
3950 int family
, socktype
, protocol
, flags
;
3952 PyObject
*all
= (PyObject
*)NULL
;
3953 PyObject
*single
= (PyObject
*)NULL
;
3954 PyObject
*idna
= NULL
;
3956 family
= socktype
= protocol
= flags
= 0;
3958 if (!PyArg_ParseTuple(args
, "OO|iiii:getaddrinfo",
3959 &hobj
, &pobj
, &family
, &socktype
,
3960 &protocol
, &flags
)) {
3963 if (hobj
== Py_None
) {
3965 } else if (PyUnicode_Check(hobj
)) {
3966 idna
= PyObject_CallMethod(hobj
, "encode", "s", "idna");
3969 hptr
= PyString_AsString(idna
);
3970 } else if (PyString_Check(hobj
)) {
3971 hptr
= PyString_AsString(hobj
);
3973 PyErr_SetString(PyExc_TypeError
,
3974 "getaddrinfo() argument 1 must be string or None");
3977 if (PyInt_Check(pobj
)) {
3978 PyOS_snprintf(pbuf
, sizeof(pbuf
), "%ld", PyInt_AsLong(pobj
));
3980 } else if (PyString_Check(pobj
)) {
3981 pptr
= PyString_AsString(pobj
);
3982 } else if (pobj
== Py_None
) {
3983 pptr
= (char *)NULL
;
3985 PyErr_SetString(socket_error
, "Int or String expected");
3988 memset(&hints
, 0, sizeof(hints
));
3989 hints
.ai_family
= family
;
3990 hints
.ai_socktype
= socktype
;
3991 hints
.ai_protocol
= protocol
;
3992 hints
.ai_flags
= flags
;
3993 Py_BEGIN_ALLOW_THREADS
3994 ACQUIRE_GETADDRINFO_LOCK
3995 error
= getaddrinfo(hptr
, pptr
, &hints
, &res0
);
3996 Py_END_ALLOW_THREADS
3997 RELEASE_GETADDRINFO_LOCK
/* see comment in setipaddr() */
3999 set_gaierror(error
);
4003 if ((all
= PyList_New(0)) == NULL
)
4005 for (res
= res0
; res
; res
= res
->ai_next
) {
4007 makesockaddr(-1, res
->ai_addr
, res
->ai_addrlen
, protocol
);
4010 single
= Py_BuildValue("iiisO", res
->ai_family
,
4011 res
->ai_socktype
, res
->ai_protocol
,
4012 res
->ai_canonname
? res
->ai_canonname
: "",
4018 if (PyList_Append(all
, single
))
4032 return (PyObject
*)NULL
;
4035 PyDoc_STRVAR(getaddrinfo_doc
,
4036 "getaddrinfo(host, port [, family, socktype, proto, flags])\n\
4037 -> list of (family, socktype, proto, canonname, sockaddr)\n\
4039 Resolve host and port into addrinfo struct.");
4041 /* Python interface to getnameinfo(sa, flags). */
4045 socket_getnameinfo(PyObject
*self
, PyObject
*args
)
4047 PyObject
*sa
= (PyObject
*)NULL
;
4050 int port
, flowinfo
, scope_id
;
4051 char hbuf
[NI_MAXHOST
], pbuf
[NI_MAXSERV
];
4052 struct addrinfo hints
, *res
= NULL
;
4054 PyObject
*ret
= (PyObject
*)NULL
;
4056 flags
= flowinfo
= scope_id
= 0;
4057 if (!PyArg_ParseTuple(args
, "Oi:getnameinfo", &sa
, &flags
))
4059 if (!PyArg_ParseTuple(sa
, "si|ii",
4060 &hostp
, &port
, &flowinfo
, &scope_id
))
4062 PyOS_snprintf(pbuf
, sizeof(pbuf
), "%d", port
);
4063 memset(&hints
, 0, sizeof(hints
));
4064 hints
.ai_family
= AF_UNSPEC
;
4065 hints
.ai_socktype
= SOCK_DGRAM
; /* make numeric port happy */
4066 Py_BEGIN_ALLOW_THREADS
4067 ACQUIRE_GETADDRINFO_LOCK
4068 error
= getaddrinfo(hostp
, pbuf
, &hints
, &res
);
4069 Py_END_ALLOW_THREADS
4070 RELEASE_GETADDRINFO_LOCK
/* see comment in setipaddr() */
4072 set_gaierror(error
);
4076 PyErr_SetString(socket_error
,
4077 "sockaddr resolved to multiple addresses");
4080 switch (res
->ai_family
) {
4085 if (PyArg_ParseTuple(sa
, "si", &t1
, &t2
) == 0) {
4086 PyErr_SetString(socket_error
,
4087 "IPv4 sockaddr must be 2 tuple");
4095 struct sockaddr_in6
*sin6
;
4096 sin6
= (struct sockaddr_in6
*)res
->ai_addr
;
4097 sin6
->sin6_flowinfo
= flowinfo
;
4098 sin6
->sin6_scope_id
= scope_id
;
4103 error
= getnameinfo(res
->ai_addr
, res
->ai_addrlen
,
4104 hbuf
, sizeof(hbuf
), pbuf
, sizeof(pbuf
), flags
);
4106 set_gaierror(error
);
4109 ret
= Py_BuildValue("ss", hbuf
, pbuf
);
4117 PyDoc_STRVAR(getnameinfo_doc
,
4118 "getnameinfo(sockaddr, flags) --> (host, port)\n\
4120 Get host and port for a sockaddr.");
4123 /* Python API to getting and setting the default timeout value. */
4126 socket_getdefaulttimeout(PyObject
*self
)
4128 if (defaulttimeout
< 0.0) {
4133 return PyFloat_FromDouble(defaulttimeout
);
4136 PyDoc_STRVAR(getdefaulttimeout_doc
,
4137 "getdefaulttimeout() -> timeout\n\
4139 Returns the default timeout in floating seconds for new socket objects.\n\
4140 A value of None indicates that new socket objects have no timeout.\n\
4141 When the socket module is first imported, the default is None.");
4144 socket_setdefaulttimeout(PyObject
*self
, PyObject
*arg
)
4151 timeout
= PyFloat_AsDouble(arg
);
4152 if (timeout
< 0.0) {
4153 if (!PyErr_Occurred())
4154 PyErr_SetString(PyExc_ValueError
,
4155 "Timeout value out of range");
4160 defaulttimeout
= timeout
;
4166 PyDoc_STRVAR(setdefaulttimeout_doc
,
4167 "setdefaulttimeout(timeout)\n\
4169 Set the default timeout in floating seconds for new socket objects.\n\
4170 A value of None indicates that new socket objects have no timeout.\n\
4171 When the socket module is first imported, the default is None.");
4174 /* List of functions exported by this module. */
4176 static PyMethodDef socket_methods
[] = {
4177 {"gethostbyname", socket_gethostbyname
,
4178 METH_VARARGS
, gethostbyname_doc
},
4179 {"gethostbyname_ex", socket_gethostbyname_ex
,
4180 METH_VARARGS
, ghbn_ex_doc
},
4181 {"gethostbyaddr", socket_gethostbyaddr
,
4182 METH_VARARGS
, gethostbyaddr_doc
},
4183 {"gethostname", socket_gethostname
,
4184 METH_NOARGS
, gethostname_doc
},
4185 {"getservbyname", socket_getservbyname
,
4186 METH_VARARGS
, getservbyname_doc
},
4187 {"getservbyport", socket_getservbyport
,
4188 METH_VARARGS
, getservbyport_doc
},
4189 {"getprotobyname", socket_getprotobyname
,
4190 METH_VARARGS
, getprotobyname_doc
},
4192 {"fromfd", socket_fromfd
,
4193 METH_VARARGS
, fromfd_doc
},
4195 #ifdef HAVE_SOCKETPAIR
4196 {"socketpair", socket_socketpair
,
4197 METH_VARARGS
, socketpair_doc
},
4199 {"ntohs", socket_ntohs
,
4200 METH_VARARGS
, ntohs_doc
},
4201 {"ntohl", socket_ntohl
,
4203 {"htons", socket_htons
,
4204 METH_VARARGS
, htons_doc
},
4205 {"htonl", socket_htonl
,
4207 {"inet_aton", socket_inet_aton
,
4208 METH_VARARGS
, inet_aton_doc
},
4209 {"inet_ntoa", socket_inet_ntoa
,
4210 METH_VARARGS
, inet_ntoa_doc
},
4211 #ifdef HAVE_INET_PTON
4212 {"inet_pton", socket_inet_pton
,
4213 METH_VARARGS
, inet_pton_doc
},
4214 {"inet_ntop", socket_inet_ntop
,
4215 METH_VARARGS
, inet_ntop_doc
},
4217 {"getaddrinfo", socket_getaddrinfo
,
4218 METH_VARARGS
, getaddrinfo_doc
},
4219 {"getnameinfo", socket_getnameinfo
,
4220 METH_VARARGS
, getnameinfo_doc
},
4221 {"getdefaulttimeout", (PyCFunction
)socket_getdefaulttimeout
,
4222 METH_NOARGS
, getdefaulttimeout_doc
},
4223 {"setdefaulttimeout", socket_setdefaulttimeout
,
4224 METH_O
, setdefaulttimeout_doc
},
4225 {NULL
, NULL
} /* Sentinel */
4230 #define OS_INIT_DEFINED
4238 _kernel_swi(0x43380, &r
, &r
);
4239 taskwindow
= r
.r
[0];
4248 #define OS_INIT_DEFINED
4250 /* Additional initialization and cleanup for Windows */
4264 ret
= WSAStartup(0x0101, &WSAData
);
4266 case 0: /* No error */
4267 Py_AtExit(os_cleanup
);
4268 return 1; /* Success */
4269 case WSASYSNOTREADY
:
4270 PyErr_SetString(PyExc_ImportError
,
4271 "WSAStartup failed: network not ready");
4273 case WSAVERNOTSUPPORTED
:
4277 "WSAStartup failed: requested version not supported");
4280 PyOS_snprintf(buf
, sizeof(buf
),
4281 "WSAStartup failed: error code %d", ret
);
4282 PyErr_SetString(PyExc_ImportError
, buf
);
4285 return 0; /* Failure */
4288 #endif /* MS_WINDOWS */
4292 #define OS_INIT_DEFINED
4294 /* Additional initialization for OS/2 */
4301 int rc
= sock_init();
4304 return 1; /* Success */
4307 PyOS_snprintf(reason
, sizeof(reason
),
4308 "OS/2 TCP/IP Error# %d", sock_errno());
4309 PyErr_SetString(PyExc_ImportError
, reason
);
4311 return 0; /* Failure */
4313 /* No need to initialise sockets with GCC/EMX */
4314 return 1; /* Success */
4318 #endif /* PYOS_OS2 */
4321 #ifndef OS_INIT_DEFINED
4325 return 1; /* Success */
4330 /* C API table - always add new things to the end for binary
4333 PySocketModule_APIObject PySocketModuleAPI
=
4340 /* Initialize the _socket module.
4342 This module is actually called "_socket", and there's a wrapper
4343 "socket.py" which implements some additional functionality. On some
4344 platforms (e.g. Windows and OS/2), socket.py also implements a
4345 wrapper for the socket type that provides missing functionality such
4346 as makefile(), dup() and fromfd(). The import of "_socket" may fail
4347 with an ImportError exception if os-specific initialization fails.
4348 On Windows, this does WINSOCK initialization. When WINSOCK is
4349 initialized succesfully, a call to WSACleanup() is scheduled to be
4353 PyDoc_STRVAR(socket_doc
,
4354 "Implementation module for socket operations.\n\
4356 See the socket module for documentation.");
4361 PyObject
*m
, *has_ipv6
;
4366 Py_TYPE(&sock_type
) = &PyType_Type
;
4367 m
= Py_InitModule3(PySocket_MODULE_NAME
,
4373 socket_error
= PyErr_NewException("socket.error",
4374 PyExc_IOError
, NULL
);
4375 if (socket_error
== NULL
)
4377 PySocketModuleAPI
.error
= socket_error
;
4378 Py_INCREF(socket_error
);
4379 PyModule_AddObject(m
, "error", socket_error
);
4380 socket_herror
= PyErr_NewException("socket.herror",
4381 socket_error
, NULL
);
4382 if (socket_herror
== NULL
)
4384 Py_INCREF(socket_herror
);
4385 PyModule_AddObject(m
, "herror", socket_herror
);
4386 socket_gaierror
= PyErr_NewException("socket.gaierror", socket_error
,
4388 if (socket_gaierror
== NULL
)
4390 Py_INCREF(socket_gaierror
);
4391 PyModule_AddObject(m
, "gaierror", socket_gaierror
);
4392 socket_timeout
= PyErr_NewException("socket.timeout",
4393 socket_error
, NULL
);
4394 if (socket_timeout
== NULL
)
4396 Py_INCREF(socket_timeout
);
4397 PyModule_AddObject(m
, "timeout", socket_timeout
);
4398 Py_INCREF((PyObject
*)&sock_type
);
4399 if (PyModule_AddObject(m
, "SocketType",
4400 (PyObject
*)&sock_type
) != 0)
4402 Py_INCREF((PyObject
*)&sock_type
);
4403 if (PyModule_AddObject(m
, "socket",
4404 (PyObject
*)&sock_type
) != 0)
4410 has_ipv6
= Py_False
;
4412 Py_INCREF(has_ipv6
);
4413 PyModule_AddObject(m
, "has_ipv6", has_ipv6
);
4416 if (PyModule_AddObject(m
, PySocket_CAPI_NAME
,
4417 PyCObject_FromVoidPtr((void *)&PySocketModuleAPI
, NULL
)
4421 /* Address families (we only support AF_INET and AF_UNIX) */
4423 PyModule_AddIntConstant(m
, "AF_UNSPEC", AF_UNSPEC
);
4425 PyModule_AddIntConstant(m
, "AF_INET", AF_INET
);
4427 PyModule_AddIntConstant(m
, "AF_INET6", AF_INET6
);
4428 #endif /* AF_INET6 */
4429 #if defined(AF_UNIX)
4430 PyModule_AddIntConstant(m
, "AF_UNIX", AF_UNIX
);
4431 #endif /* AF_UNIX */
4433 /* Amateur Radio AX.25 */
4434 PyModule_AddIntConstant(m
, "AF_AX25", AF_AX25
);
4437 PyModule_AddIntConstant(m
, "AF_IPX", AF_IPX
); /* Novell IPX */
4441 PyModule_AddIntConstant(m
, "AF_APPLETALK", AF_APPLETALK
);
4444 /* Amateur radio NetROM */
4445 PyModule_AddIntConstant(m
, "AF_NETROM", AF_NETROM
);
4448 /* Multiprotocol bridge */
4449 PyModule_AddIntConstant(m
, "AF_BRIDGE", AF_BRIDGE
);
4453 PyModule_AddIntConstant(m
, "AF_ATMPVC", AF_ATMPVC
);
4456 /* Reserved for Werner's ATM */
4457 PyModule_AddIntConstant(m
, "AF_AAL5", AF_AAL5
);
4460 /* Reserved for X.25 project */
4461 PyModule_AddIntConstant(m
, "AF_X25", AF_X25
);
4464 PyModule_AddIntConstant(m
, "AF_INET6", AF_INET6
); /* IP version 6 */
4467 /* Amateur Radio X.25 PLP */
4468 PyModule_AddIntConstant(m
, "AF_ROSE", AF_ROSE
);
4471 /* Reserved for DECnet project */
4472 PyModule_AddIntConstant(m
, "AF_DECnet", AF_DECnet
);
4475 /* Reserved for 802.2LLC project */
4476 PyModule_AddIntConstant(m
, "AF_NETBEUI", AF_NETBEUI
);
4479 /* Security callback pseudo AF */
4480 PyModule_AddIntConstant(m
, "AF_SECURITY", AF_SECURITY
);
4483 /* PF_KEY key management API */
4484 PyModule_AddIntConstant(m
, "AF_KEY", AF_KEY
);
4488 PyModule_AddIntConstant(m
, "AF_NETLINK", AF_NETLINK
);
4489 PyModule_AddIntConstant(m
, "NETLINK_ROUTE", NETLINK_ROUTE
);
4491 PyModule_AddIntConstant(m
, "NETLINK_SKIP", NETLINK_SKIP
);
4494 PyModule_AddIntConstant(m
, "NETLINK_W1", NETLINK_W1
);
4496 PyModule_AddIntConstant(m
, "NETLINK_USERSOCK", NETLINK_USERSOCK
);
4497 PyModule_AddIntConstant(m
, "NETLINK_FIREWALL", NETLINK_FIREWALL
);
4498 #ifdef NETLINK_TCPDIAG
4499 PyModule_AddIntConstant(m
, "NETLINK_TCPDIAG", NETLINK_TCPDIAG
);
4501 #ifdef NETLINK_NFLOG
4502 PyModule_AddIntConstant(m
, "NETLINK_NFLOG", NETLINK_NFLOG
);
4505 PyModule_AddIntConstant(m
, "NETLINK_XFRM", NETLINK_XFRM
);
4508 PyModule_AddIntConstant(m
, "NETLINK_ARPD", NETLINK_ARPD
);
4510 #ifdef NETLINK_ROUTE6
4511 PyModule_AddIntConstant(m
, "NETLINK_ROUTE6", NETLINK_ROUTE6
);
4513 PyModule_AddIntConstant(m
, "NETLINK_IP6_FW", NETLINK_IP6_FW
);
4514 #ifdef NETLINK_DNRTMSG
4515 PyModule_AddIntConstant(m
, "NETLINK_DNRTMSG", NETLINK_DNRTMSG
);
4517 #ifdef NETLINK_TAPBASE
4518 PyModule_AddIntConstant(m
, "NETLINK_TAPBASE", NETLINK_TAPBASE
);
4520 #endif /* AF_NETLINK */
4522 /* Alias to emulate 4.4BSD */
4523 PyModule_AddIntConstant(m
, "AF_ROUTE", AF_ROUTE
);
4527 PyModule_AddIntConstant(m
, "AF_ASH", AF_ASH
);
4531 PyModule_AddIntConstant(m
, "AF_ECONET", AF_ECONET
);
4535 PyModule_AddIntConstant(m
, "AF_ATMSVC", AF_ATMSVC
);
4538 /* Linux SNA Project (nutters!) */
4539 PyModule_AddIntConstant(m
, "AF_SNA", AF_SNA
);
4543 PyModule_AddIntConstant(m
, "AF_IRDA", AF_IRDA
);
4547 PyModule_AddIntConstant(m
, "AF_PPPOX", AF_PPPOX
);
4550 /* Wanpipe API Sockets */
4551 PyModule_AddIntConstant(m
, "AF_WANPIPE", AF_WANPIPE
);
4555 PyModule_AddIntConstant(m
, "AF_LLC", AF_LLC
);
4558 #ifdef USE_BLUETOOTH
4559 PyModule_AddIntConstant(m
, "AF_BLUETOOTH", AF_BLUETOOTH
);
4560 PyModule_AddIntConstant(m
, "BTPROTO_L2CAP", BTPROTO_L2CAP
);
4561 PyModule_AddIntConstant(m
, "BTPROTO_HCI", BTPROTO_HCI
);
4562 PyModule_AddIntConstant(m
, "SOL_HCI", SOL_HCI
);
4563 PyModule_AddIntConstant(m
, "HCI_FILTER", HCI_FILTER
);
4564 #if !defined(__FreeBSD__)
4565 PyModule_AddIntConstant(m
, "HCI_TIME_STAMP", HCI_TIME_STAMP
);
4566 PyModule_AddIntConstant(m
, "HCI_DATA_DIR", HCI_DATA_DIR
);
4567 PyModule_AddIntConstant(m
, "BTPROTO_SCO", BTPROTO_SCO
);
4569 PyModule_AddIntConstant(m
, "BTPROTO_RFCOMM", BTPROTO_RFCOMM
);
4570 PyModule_AddStringConstant(m
, "BDADDR_ANY", "00:00:00:00:00:00");
4571 PyModule_AddStringConstant(m
, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");
4574 #ifdef HAVE_NETPACKET_PACKET_H
4575 PyModule_AddIntConstant(m
, "AF_PACKET", AF_PACKET
);
4576 PyModule_AddIntConstant(m
, "PF_PACKET", PF_PACKET
);
4577 PyModule_AddIntConstant(m
, "PACKET_HOST", PACKET_HOST
);
4578 PyModule_AddIntConstant(m
, "PACKET_BROADCAST", PACKET_BROADCAST
);
4579 PyModule_AddIntConstant(m
, "PACKET_MULTICAST", PACKET_MULTICAST
);
4580 PyModule_AddIntConstant(m
, "PACKET_OTHERHOST", PACKET_OTHERHOST
);
4581 PyModule_AddIntConstant(m
, "PACKET_OUTGOING", PACKET_OUTGOING
);
4582 PyModule_AddIntConstant(m
, "PACKET_LOOPBACK", PACKET_LOOPBACK
);
4583 PyModule_AddIntConstant(m
, "PACKET_FASTROUTE", PACKET_FASTROUTE
);
4586 #ifdef HAVE_LINUX_TIPC_H
4587 PyModule_AddIntConstant(m
, "AF_TIPC", AF_TIPC
);
4590 PyModule_AddIntConstant(m
, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ
);
4591 PyModule_AddIntConstant(m
, "TIPC_ADDR_NAME", TIPC_ADDR_NAME
);
4592 PyModule_AddIntConstant(m
, "TIPC_ADDR_ID", TIPC_ADDR_ID
);
4594 PyModule_AddIntConstant(m
, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE
);
4595 PyModule_AddIntConstant(m
, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE
);
4596 PyModule_AddIntConstant(m
, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE
);
4598 /* for setsockopt() */
4599 PyModule_AddIntConstant(m
, "SOL_TIPC", SOL_TIPC
);
4600 PyModule_AddIntConstant(m
, "TIPC_IMPORTANCE", TIPC_IMPORTANCE
);
4601 PyModule_AddIntConstant(m
, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE
);
4602 PyModule_AddIntConstant(m
, "TIPC_DEST_DROPPABLE",
4603 TIPC_DEST_DROPPABLE
);
4604 PyModule_AddIntConstant(m
, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT
);
4606 PyModule_AddIntConstant(m
, "TIPC_LOW_IMPORTANCE",
4607 TIPC_LOW_IMPORTANCE
);
4608 PyModule_AddIntConstant(m
, "TIPC_MEDIUM_IMPORTANCE",
4609 TIPC_MEDIUM_IMPORTANCE
);
4610 PyModule_AddIntConstant(m
, "TIPC_HIGH_IMPORTANCE",
4611 TIPC_HIGH_IMPORTANCE
);
4612 PyModule_AddIntConstant(m
, "TIPC_CRITICAL_IMPORTANCE",
4613 TIPC_CRITICAL_IMPORTANCE
);
4615 /* for subscriptions */
4616 PyModule_AddIntConstant(m
, "TIPC_SUB_PORTS", TIPC_SUB_PORTS
);
4617 PyModule_AddIntConstant(m
, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE
);
4618 #ifdef TIPC_SUB_CANCEL
4619 /* doesn't seem to be available everywhere */
4620 PyModule_AddIntConstant(m
, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL
);
4622 PyModule_AddIntConstant(m
, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER
);
4623 PyModule_AddIntConstant(m
, "TIPC_PUBLISHED", TIPC_PUBLISHED
);
4624 PyModule_AddIntConstant(m
, "TIPC_WITHDRAWN", TIPC_WITHDRAWN
);
4625 PyModule_AddIntConstant(m
, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT
);
4626 PyModule_AddIntConstant(m
, "TIPC_CFG_SRV", TIPC_CFG_SRV
);
4627 PyModule_AddIntConstant(m
, "TIPC_TOP_SRV", TIPC_TOP_SRV
);
4631 PyModule_AddIntConstant(m
, "SOCK_STREAM", SOCK_STREAM
);
4632 PyModule_AddIntConstant(m
, "SOCK_DGRAM", SOCK_DGRAM
);
4634 /* We have incomplete socket support. */
4635 PyModule_AddIntConstant(m
, "SOCK_RAW", SOCK_RAW
);
4636 PyModule_AddIntConstant(m
, "SOCK_SEQPACKET", SOCK_SEQPACKET
);
4637 #if defined(SOCK_RDM)
4638 PyModule_AddIntConstant(m
, "SOCK_RDM", SOCK_RDM
);
4643 PyModule_AddIntConstant(m
, "SO_DEBUG", SO_DEBUG
);
4645 #ifdef SO_ACCEPTCONN
4646 PyModule_AddIntConstant(m
, "SO_ACCEPTCONN", SO_ACCEPTCONN
);
4649 PyModule_AddIntConstant(m
, "SO_REUSEADDR", SO_REUSEADDR
);
4651 #ifdef SO_EXCLUSIVEADDRUSE
4652 PyModule_AddIntConstant(m
, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE
);
4656 PyModule_AddIntConstant(m
, "SO_KEEPALIVE", SO_KEEPALIVE
);
4659 PyModule_AddIntConstant(m
, "SO_DONTROUTE", SO_DONTROUTE
);
4662 PyModule_AddIntConstant(m
, "SO_BROADCAST", SO_BROADCAST
);
4664 #ifdef SO_USELOOPBACK
4665 PyModule_AddIntConstant(m
, "SO_USELOOPBACK", SO_USELOOPBACK
);
4668 PyModule_AddIntConstant(m
, "SO_LINGER", SO_LINGER
);
4671 PyModule_AddIntConstant(m
, "SO_OOBINLINE", SO_OOBINLINE
);
4674 PyModule_AddIntConstant(m
, "SO_REUSEPORT", SO_REUSEPORT
);
4677 PyModule_AddIntConstant(m
, "SO_SNDBUF", SO_SNDBUF
);
4680 PyModule_AddIntConstant(m
, "SO_RCVBUF", SO_RCVBUF
);
4683 PyModule_AddIntConstant(m
, "SO_SNDLOWAT", SO_SNDLOWAT
);
4686 PyModule_AddIntConstant(m
, "SO_RCVLOWAT", SO_RCVLOWAT
);
4689 PyModule_AddIntConstant(m
, "SO_SNDTIMEO", SO_SNDTIMEO
);
4692 PyModule_AddIntConstant(m
, "SO_RCVTIMEO", SO_RCVTIMEO
);
4695 PyModule_AddIntConstant(m
, "SO_ERROR", SO_ERROR
);
4698 PyModule_AddIntConstant(m
, "SO_TYPE", SO_TYPE
);
4701 /* Maximum number of connections for "listen" */
4703 PyModule_AddIntConstant(m
, "SOMAXCONN", SOMAXCONN
);
4705 PyModule_AddIntConstant(m
, "SOMAXCONN", 5); /* Common value */
4708 /* Flags for send, recv */
4710 PyModule_AddIntConstant(m
, "MSG_OOB", MSG_OOB
);
4713 PyModule_AddIntConstant(m
, "MSG_PEEK", MSG_PEEK
);
4715 #ifdef MSG_DONTROUTE
4716 PyModule_AddIntConstant(m
, "MSG_DONTROUTE", MSG_DONTROUTE
);
4719 PyModule_AddIntConstant(m
, "MSG_DONTWAIT", MSG_DONTWAIT
);
4722 PyModule_AddIntConstant(m
, "MSG_EOR", MSG_EOR
);
4725 PyModule_AddIntConstant(m
, "MSG_TRUNC", MSG_TRUNC
);
4728 PyModule_AddIntConstant(m
, "MSG_CTRUNC", MSG_CTRUNC
);
4731 PyModule_AddIntConstant(m
, "MSG_WAITALL", MSG_WAITALL
);
4734 PyModule_AddIntConstant(m
, "MSG_BTAG", MSG_BTAG
);
4737 PyModule_AddIntConstant(m
, "MSG_ETAG", MSG_ETAG
);
4740 /* Protocol level and numbers, usable for [gs]etsockopt */
4742 PyModule_AddIntConstant(m
, "SOL_SOCKET", SOL_SOCKET
);
4745 PyModule_AddIntConstant(m
, "SOL_IP", SOL_IP
);
4747 PyModule_AddIntConstant(m
, "SOL_IP", 0);
4750 PyModule_AddIntConstant(m
, "SOL_IPX", SOL_IPX
);
4753 PyModule_AddIntConstant(m
, "SOL_AX25", SOL_AX25
);
4756 PyModule_AddIntConstant(m
, "SOL_ATALK", SOL_ATALK
);
4759 PyModule_AddIntConstant(m
, "SOL_NETROM", SOL_NETROM
);
4762 PyModule_AddIntConstant(m
, "SOL_ROSE", SOL_ROSE
);
4765 PyModule_AddIntConstant(m
, "SOL_TCP", SOL_TCP
);
4767 PyModule_AddIntConstant(m
, "SOL_TCP", 6);
4770 PyModule_AddIntConstant(m
, "SOL_UDP", SOL_UDP
);
4772 PyModule_AddIntConstant(m
, "SOL_UDP", 17);
4775 PyModule_AddIntConstant(m
, "IPPROTO_IP", IPPROTO_IP
);
4777 PyModule_AddIntConstant(m
, "IPPROTO_IP", 0);
4779 #ifdef IPPROTO_HOPOPTS
4780 PyModule_AddIntConstant(m
, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS
);
4783 PyModule_AddIntConstant(m
, "IPPROTO_ICMP", IPPROTO_ICMP
);
4785 PyModule_AddIntConstant(m
, "IPPROTO_ICMP", 1);
4788 PyModule_AddIntConstant(m
, "IPPROTO_IGMP", IPPROTO_IGMP
);
4791 PyModule_AddIntConstant(m
, "IPPROTO_GGP", IPPROTO_GGP
);
4794 PyModule_AddIntConstant(m
, "IPPROTO_IPV4", IPPROTO_IPV4
);
4797 PyModule_AddIntConstant(m
, "IPPROTO_IPV6", IPPROTO_IPV6
);
4800 PyModule_AddIntConstant(m
, "IPPROTO_IPIP", IPPROTO_IPIP
);
4803 PyModule_AddIntConstant(m
, "IPPROTO_TCP", IPPROTO_TCP
);
4805 PyModule_AddIntConstant(m
, "IPPROTO_TCP", 6);
4808 PyModule_AddIntConstant(m
, "IPPROTO_EGP", IPPROTO_EGP
);
4811 PyModule_AddIntConstant(m
, "IPPROTO_PUP", IPPROTO_PUP
);
4814 PyModule_AddIntConstant(m
, "IPPROTO_UDP", IPPROTO_UDP
);
4816 PyModule_AddIntConstant(m
, "IPPROTO_UDP", 17);
4819 PyModule_AddIntConstant(m
, "IPPROTO_IDP", IPPROTO_IDP
);
4821 #ifdef IPPROTO_HELLO
4822 PyModule_AddIntConstant(m
, "IPPROTO_HELLO", IPPROTO_HELLO
);
4825 PyModule_AddIntConstant(m
, "IPPROTO_ND", IPPROTO_ND
);
4828 PyModule_AddIntConstant(m
, "IPPROTO_TP", IPPROTO_TP
);
4831 PyModule_AddIntConstant(m
, "IPPROTO_IPV6", IPPROTO_IPV6
);
4833 #ifdef IPPROTO_ROUTING
4834 PyModule_AddIntConstant(m
, "IPPROTO_ROUTING", IPPROTO_ROUTING
);
4836 #ifdef IPPROTO_FRAGMENT
4837 PyModule_AddIntConstant(m
, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT
);
4840 PyModule_AddIntConstant(m
, "IPPROTO_RSVP", IPPROTO_RSVP
);
4843 PyModule_AddIntConstant(m
, "IPPROTO_GRE", IPPROTO_GRE
);
4846 PyModule_AddIntConstant(m
, "IPPROTO_ESP", IPPROTO_ESP
);
4849 PyModule_AddIntConstant(m
, "IPPROTO_AH", IPPROTO_AH
);
4851 #ifdef IPPROTO_MOBILE
4852 PyModule_AddIntConstant(m
, "IPPROTO_MOBILE", IPPROTO_MOBILE
);
4854 #ifdef IPPROTO_ICMPV6
4855 PyModule_AddIntConstant(m
, "IPPROTO_ICMPV6", IPPROTO_ICMPV6
);
4858 PyModule_AddIntConstant(m
, "IPPROTO_NONE", IPPROTO_NONE
);
4860 #ifdef IPPROTO_DSTOPTS
4861 PyModule_AddIntConstant(m
, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS
);
4864 PyModule_AddIntConstant(m
, "IPPROTO_XTP", IPPROTO_XTP
);
4867 PyModule_AddIntConstant(m
, "IPPROTO_EON", IPPROTO_EON
);
4870 PyModule_AddIntConstant(m
, "IPPROTO_PIM", IPPROTO_PIM
);
4872 #ifdef IPPROTO_IPCOMP
4873 PyModule_AddIntConstant(m
, "IPPROTO_IPCOMP", IPPROTO_IPCOMP
);
4876 PyModule_AddIntConstant(m
, "IPPROTO_VRRP", IPPROTO_VRRP
);
4879 PyModule_AddIntConstant(m
, "IPPROTO_BIP", IPPROTO_BIP
);
4883 PyModule_AddIntConstant(m
, "IPPROTO_RAW", IPPROTO_RAW
);
4885 PyModule_AddIntConstant(m
, "IPPROTO_RAW", 255);
4888 PyModule_AddIntConstant(m
, "IPPROTO_MAX", IPPROTO_MAX
);
4891 /* Some port configuration */
4892 #ifdef IPPORT_RESERVED
4893 PyModule_AddIntConstant(m
, "IPPORT_RESERVED", IPPORT_RESERVED
);
4895 PyModule_AddIntConstant(m
, "IPPORT_RESERVED", 1024);
4897 #ifdef IPPORT_USERRESERVED
4898 PyModule_AddIntConstant(m
, "IPPORT_USERRESERVED", IPPORT_USERRESERVED
);
4900 PyModule_AddIntConstant(m
, "IPPORT_USERRESERVED", 5000);
4903 /* Some reserved IP v.4 addresses */
4905 PyModule_AddIntConstant(m
, "INADDR_ANY", INADDR_ANY
);
4907 PyModule_AddIntConstant(m
, "INADDR_ANY", 0x00000000);
4909 #ifdef INADDR_BROADCAST
4910 PyModule_AddIntConstant(m
, "INADDR_BROADCAST", INADDR_BROADCAST
);
4912 PyModule_AddIntConstant(m
, "INADDR_BROADCAST", 0xffffffff);
4914 #ifdef INADDR_LOOPBACK
4915 PyModule_AddIntConstant(m
, "INADDR_LOOPBACK", INADDR_LOOPBACK
);
4917 PyModule_AddIntConstant(m
, "INADDR_LOOPBACK", 0x7F000001);
4919 #ifdef INADDR_UNSPEC_GROUP
4920 PyModule_AddIntConstant(m
, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP
);
4922 PyModule_AddIntConstant(m
, "INADDR_UNSPEC_GROUP", 0xe0000000);
4924 #ifdef INADDR_ALLHOSTS_GROUP
4925 PyModule_AddIntConstant(m
, "INADDR_ALLHOSTS_GROUP",
4926 INADDR_ALLHOSTS_GROUP
);
4928 PyModule_AddIntConstant(m
, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
4930 #ifdef INADDR_MAX_LOCAL_GROUP
4931 PyModule_AddIntConstant(m
, "INADDR_MAX_LOCAL_GROUP",
4932 INADDR_MAX_LOCAL_GROUP
);
4934 PyModule_AddIntConstant(m
, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
4937 PyModule_AddIntConstant(m
, "INADDR_NONE", INADDR_NONE
);
4939 PyModule_AddIntConstant(m
, "INADDR_NONE", 0xffffffff);
4942 /* IPv4 [gs]etsockopt options */
4944 PyModule_AddIntConstant(m
, "IP_OPTIONS", IP_OPTIONS
);
4947 PyModule_AddIntConstant(m
, "IP_HDRINCL", IP_HDRINCL
);
4950 PyModule_AddIntConstant(m
, "IP_TOS", IP_TOS
);
4953 PyModule_AddIntConstant(m
, "IP_TTL", IP_TTL
);
4956 PyModule_AddIntConstant(m
, "IP_RECVOPTS", IP_RECVOPTS
);
4958 #ifdef IP_RECVRETOPTS
4959 PyModule_AddIntConstant(m
, "IP_RECVRETOPTS", IP_RECVRETOPTS
);
4961 #ifdef IP_RECVDSTADDR
4962 PyModule_AddIntConstant(m
, "IP_RECVDSTADDR", IP_RECVDSTADDR
);
4965 PyModule_AddIntConstant(m
, "IP_RETOPTS", IP_RETOPTS
);
4967 #ifdef IP_MULTICAST_IF
4968 PyModule_AddIntConstant(m
, "IP_MULTICAST_IF", IP_MULTICAST_IF
);
4970 #ifdef IP_MULTICAST_TTL
4971 PyModule_AddIntConstant(m
, "IP_MULTICAST_TTL", IP_MULTICAST_TTL
);
4973 #ifdef IP_MULTICAST_LOOP
4974 PyModule_AddIntConstant(m
, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP
);
4976 #ifdef IP_ADD_MEMBERSHIP
4977 PyModule_AddIntConstant(m
, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP
);
4979 #ifdef IP_DROP_MEMBERSHIP
4980 PyModule_AddIntConstant(m
, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP
);
4982 #ifdef IP_DEFAULT_MULTICAST_TTL
4983 PyModule_AddIntConstant(m
, "IP_DEFAULT_MULTICAST_TTL",
4984 IP_DEFAULT_MULTICAST_TTL
);
4986 #ifdef IP_DEFAULT_MULTICAST_LOOP
4987 PyModule_AddIntConstant(m
, "IP_DEFAULT_MULTICAST_LOOP",
4988 IP_DEFAULT_MULTICAST_LOOP
);
4990 #ifdef IP_MAX_MEMBERSHIPS
4991 PyModule_AddIntConstant(m
, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS
);
4994 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
4995 #ifdef IPV6_JOIN_GROUP
4996 PyModule_AddIntConstant(m
, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP
);
4998 #ifdef IPV6_LEAVE_GROUP
4999 PyModule_AddIntConstant(m
, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP
);
5001 #ifdef IPV6_MULTICAST_HOPS
5002 PyModule_AddIntConstant(m
, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS
);
5004 #ifdef IPV6_MULTICAST_IF
5005 PyModule_AddIntConstant(m
, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF
);
5007 #ifdef IPV6_MULTICAST_LOOP
5008 PyModule_AddIntConstant(m
, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP
);
5010 #ifdef IPV6_UNICAST_HOPS
5011 PyModule_AddIntConstant(m
, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS
);
5013 /* Additional IPV6 socket options, defined in RFC 3493 */
5015 PyModule_AddIntConstant(m
, "IPV6_V6ONLY", IPV6_V6ONLY
);
5017 /* Advanced IPV6 socket options, from RFC 3542 */
5018 #ifdef IPV6_CHECKSUM
5019 PyModule_AddIntConstant(m
, "IPV6_CHECKSUM", IPV6_CHECKSUM
);
5021 #ifdef IPV6_DONTFRAG
5022 PyModule_AddIntConstant(m
, "IPV6_DONTFRAG", IPV6_DONTFRAG
);
5025 PyModule_AddIntConstant(m
, "IPV6_DSTOPTS", IPV6_DSTOPTS
);
5027 #ifdef IPV6_HOPLIMIT
5028 PyModule_AddIntConstant(m
, "IPV6_HOPLIMIT", IPV6_HOPLIMIT
);
5031 PyModule_AddIntConstant(m
, "IPV6_HOPOPTS", IPV6_HOPOPTS
);
5034 PyModule_AddIntConstant(m
, "IPV6_NEXTHOP", IPV6_NEXTHOP
);
5037 PyModule_AddIntConstant(m
, "IPV6_PATHMTU", IPV6_PATHMTU
);
5040 PyModule_AddIntConstant(m
, "IPV6_PKTINFO", IPV6_PKTINFO
);
5042 #ifdef IPV6_RECVDSTOPTS
5043 PyModule_AddIntConstant(m
, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS
);
5045 #ifdef IPV6_RECVHOPLIMIT
5046 PyModule_AddIntConstant(m
, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT
);
5048 #ifdef IPV6_RECVHOPOPTS
5049 PyModule_AddIntConstant(m
, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS
);
5051 #ifdef IPV6_RECVPKTINFO
5052 PyModule_AddIntConstant(m
, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO
);
5054 #ifdef IPV6_RECVRTHDR
5055 PyModule_AddIntConstant(m
, "IPV6_RECVRTHDR", IPV6_RECVRTHDR
);
5057 #ifdef IPV6_RECVTCLASS
5058 PyModule_AddIntConstant(m
, "IPV6_RECVTCLASS", IPV6_RECVTCLASS
);
5061 PyModule_AddIntConstant(m
, "IPV6_RTHDR", IPV6_RTHDR
);
5063 #ifdef IPV6_RTHDRDSTOPTS
5064 PyModule_AddIntConstant(m
, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS
);
5066 #ifdef IPV6_RTHDR_TYPE_0
5067 PyModule_AddIntConstant(m
, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0
);
5069 #ifdef IPV6_RECVPATHMTU
5070 PyModule_AddIntConstant(m
, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU
);
5073 PyModule_AddIntConstant(m
, "IPV6_TCLASS", IPV6_TCLASS
);
5075 #ifdef IPV6_USE_MIN_MTU
5076 PyModule_AddIntConstant(m
, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU
);
5081 PyModule_AddIntConstant(m
, "TCP_NODELAY", TCP_NODELAY
);
5084 PyModule_AddIntConstant(m
, "TCP_MAXSEG", TCP_MAXSEG
);
5087 PyModule_AddIntConstant(m
, "TCP_CORK", TCP_CORK
);
5090 PyModule_AddIntConstant(m
, "TCP_KEEPIDLE", TCP_KEEPIDLE
);
5092 #ifdef TCP_KEEPINTVL
5093 PyModule_AddIntConstant(m
, "TCP_KEEPINTVL", TCP_KEEPINTVL
);
5096 PyModule_AddIntConstant(m
, "TCP_KEEPCNT", TCP_KEEPCNT
);
5099 PyModule_AddIntConstant(m
, "TCP_SYNCNT", TCP_SYNCNT
);
5102 PyModule_AddIntConstant(m
, "TCP_LINGER2", TCP_LINGER2
);
5104 #ifdef TCP_DEFER_ACCEPT
5105 PyModule_AddIntConstant(m
, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT
);
5107 #ifdef TCP_WINDOW_CLAMP
5108 PyModule_AddIntConstant(m
, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP
);
5111 PyModule_AddIntConstant(m
, "TCP_INFO", TCP_INFO
);
5114 PyModule_AddIntConstant(m
, "TCP_QUICKACK", TCP_QUICKACK
);
5120 PyModule_AddIntConstant(m
, "IPX_TYPE", IPX_TYPE
);
5123 /* get{addr,name}info parameters */
5124 #ifdef EAI_ADDRFAMILY
5125 PyModule_AddIntConstant(m
, "EAI_ADDRFAMILY", EAI_ADDRFAMILY
);
5128 PyModule_AddIntConstant(m
, "EAI_AGAIN", EAI_AGAIN
);
5131 PyModule_AddIntConstant(m
, "EAI_BADFLAGS", EAI_BADFLAGS
);
5134 PyModule_AddIntConstant(m
, "EAI_FAIL", EAI_FAIL
);
5137 PyModule_AddIntConstant(m
, "EAI_FAMILY", EAI_FAMILY
);
5140 PyModule_AddIntConstant(m
, "EAI_MEMORY", EAI_MEMORY
);
5143 PyModule_AddIntConstant(m
, "EAI_NODATA", EAI_NODATA
);
5146 PyModule_AddIntConstant(m
, "EAI_NONAME", EAI_NONAME
);
5149 PyModule_AddIntConstant(m
, "EAI_OVERFLOW", EAI_OVERFLOW
);
5152 PyModule_AddIntConstant(m
, "EAI_SERVICE", EAI_SERVICE
);
5155 PyModule_AddIntConstant(m
, "EAI_SOCKTYPE", EAI_SOCKTYPE
);
5158 PyModule_AddIntConstant(m
, "EAI_SYSTEM", EAI_SYSTEM
);
5161 PyModule_AddIntConstant(m
, "EAI_BADHINTS", EAI_BADHINTS
);
5164 PyModule_AddIntConstant(m
, "EAI_PROTOCOL", EAI_PROTOCOL
);
5167 PyModule_AddIntConstant(m
, "EAI_MAX", EAI_MAX
);
5170 PyModule_AddIntConstant(m
, "AI_PASSIVE", AI_PASSIVE
);
5173 PyModule_AddIntConstant(m
, "AI_CANONNAME", AI_CANONNAME
);
5175 #ifdef AI_NUMERICHOST
5176 PyModule_AddIntConstant(m
, "AI_NUMERICHOST", AI_NUMERICHOST
);
5178 #ifdef AI_NUMERICSERV
5179 PyModule_AddIntConstant(m
, "AI_NUMERICSERV", AI_NUMERICSERV
);
5182 PyModule_AddIntConstant(m
, "AI_MASK", AI_MASK
);
5185 PyModule_AddIntConstant(m
, "AI_ALL", AI_ALL
);
5187 #ifdef AI_V4MAPPED_CFG
5188 PyModule_AddIntConstant(m
, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG
);
5190 #ifdef AI_ADDRCONFIG
5191 PyModule_AddIntConstant(m
, "AI_ADDRCONFIG", AI_ADDRCONFIG
);
5194 PyModule_AddIntConstant(m
, "AI_V4MAPPED", AI_V4MAPPED
);
5197 PyModule_AddIntConstant(m
, "AI_DEFAULT", AI_DEFAULT
);
5200 PyModule_AddIntConstant(m
, "NI_MAXHOST", NI_MAXHOST
);
5203 PyModule_AddIntConstant(m
, "NI_MAXSERV", NI_MAXSERV
);
5206 PyModule_AddIntConstant(m
, "NI_NOFQDN", NI_NOFQDN
);
5208 #ifdef NI_NUMERICHOST
5209 PyModule_AddIntConstant(m
, "NI_NUMERICHOST", NI_NUMERICHOST
);
5212 PyModule_AddIntConstant(m
, "NI_NAMEREQD", NI_NAMEREQD
);
5214 #ifdef NI_NUMERICSERV
5215 PyModule_AddIntConstant(m
, "NI_NUMERICSERV", NI_NUMERICSERV
);
5218 PyModule_AddIntConstant(m
, "NI_DGRAM", NI_DGRAM
);
5221 /* shutdown() parameters */
5223 PyModule_AddIntConstant(m
, "SHUT_RD", SHUT_RD
);
5224 #elif defined(SD_RECEIVE)
5225 PyModule_AddIntConstant(m
, "SHUT_RD", SD_RECEIVE
);
5227 PyModule_AddIntConstant(m
, "SHUT_RD", 0);
5230 PyModule_AddIntConstant(m
, "SHUT_WR", SHUT_WR
);
5231 #elif defined(SD_SEND)
5232 PyModule_AddIntConstant(m
, "SHUT_WR", SD_SEND
);
5234 PyModule_AddIntConstant(m
, "SHUT_WR", 1);
5237 PyModule_AddIntConstant(m
, "SHUT_RDWR", SHUT_RDWR
);
5238 #elif defined(SD_BOTH)
5239 PyModule_AddIntConstant(m
, "SHUT_RDWR", SD_BOTH
);
5241 PyModule_AddIntConstant(m
, "SHUT_RDWR", 2);
5247 tmp
= PyLong_FromUnsignedLong(SIO_RCVALL
);
5250 PyModule_AddObject(m
, "SIO_RCVALL", tmp
);
5252 PyModule_AddIntConstant(m
, "RCVALL_OFF", RCVALL_OFF
);
5253 PyModule_AddIntConstant(m
, "RCVALL_ON", RCVALL_ON
);
5254 PyModule_AddIntConstant(m
, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY
);
5255 #ifdef RCVALL_IPLEVEL
5256 PyModule_AddIntConstant(m
, "RCVALL_IPLEVEL", RCVALL_IPLEVEL
);
5259 PyModule_AddIntConstant(m
, "RCVALL_MAX", RCVALL_MAX
);
5261 #endif /* _MSTCPIP_ */
5263 /* Initialize gethostbyname lock */
5264 #if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
5265 netdb_lock
= PyThread_allocate_lock();
5270 #ifndef HAVE_INET_PTON
5271 #if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
5273 /* Simplistic emulation code for inet_pton that only works for IPv4 */
5274 /* These are not exposed because they do not set errno properly */
5277 inet_pton(int af
, const char *src
, void *dst
)
5279 if (af
== AF_INET
) {
5281 packed_addr
= inet_addr(src
);
5282 if (packed_addr
== INADDR_NONE
)
5284 memcpy(dst
, &packed_addr
, 4);
5287 /* Should set errno to EAFNOSUPPORT */
5292 inet_ntop(int af
, const void *src
, char *dst
, socklen_t size
)
5294 if (af
== AF_INET
) {
5295 struct in_addr packed_addr
;
5297 /* Should set errno to ENOSPC. */
5299 memcpy(&packed_addr
, src
, sizeof(packed_addr
));
5300 return strncpy(dst
, inet_ntoa(packed_addr
), size
);
5302 /* Should set errno to EAFNOSUPPORT */