1/* Socket module */ 2 3/* 4 5This module provides an interface to Berkeley socket IPC. 6 7Limitations: 8 9- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a 10 portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported 11 under Linux. 12- No read/write operations (use sendall/recv or makefile instead). 13- Additional restrictions apply on some non-Unix platforms (compensated 14 for by socket.py). 15 16Module interface: 17 18- socket.error: exception raised for socket specific errors 19- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors, 20 a subclass of socket.error 21- socket.herror: exception raised for gethostby* errors, 22 a subclass of socket.error 23- socket.fromfd(fd, family, type[, proto]) --> new socket object (created 24 from an existing file descriptor) 25- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd') 26- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...]) 27- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com') 28- socket.getprotobyname(protocolname) --> protocol number 29- socket.getservbyname(servicename[, protocolname]) --> port number 30- socket.getservbyport(portnumber[, protocolname]) --> service name 31- socket.socket([family[, type [, proto]]]) --> new socket object 32- socket.socketpair([family[, type [, proto]]]) --> (socket, socket) 33- socket.ntohs(16 bit value) --> new int object 34- socket.ntohl(32 bit value) --> new int object 35- socket.htons(16 bit value) --> new int object 36- socket.htonl(32 bit value) --> new int object 37- socket.getaddrinfo(host, port [, family, socktype, proto, flags]) 38 --> List of (family, socktype, proto, canonname, sockaddr) 39- socket.getnameinfo(sockaddr, flags) --> (host, port) 40- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h> 41- socket.has_ipv6: boolean value indicating if IPv6 is supported 42- socket.inet_aton(IP address) -> 32-bit packed IP representation 43- socket.inet_ntoa(packed IP) -> IP address string 44- socket.getdefaulttimeout() -> None | float 45- socket.setdefaulttimeout(None | float) 46- an Internet socket address is a pair (hostname, port) 47 where hostname can be anything recognized by gethostbyname() 48 (including the dd.dd.dd.dd notation) and port is in host byte order 49- where a hostname is returned, the dd.dd.dd.dd notation is used 50- a UNIX domain socket address is a string specifying the pathname 51- an AF_PACKET socket address is a tuple containing a string 52 specifying the ethernet interface and an integer specifying 53 the Ethernet protocol number to be received. For example: 54 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple 55 specify packet-type and ha-type/addr. 56- an AF_TIPC socket address is expressed as 57 (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of: 58 TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID; 59 and scope can be one of: 60 TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE. 61 The meaning of v1, v2 and v3 depends on the value of addr_type: 62 if addr_type is TIPC_ADDR_NAME: 63 v1 is the server type 64 v2 is the port identifier 65 v3 is ignored 66 if addr_type is TIPC_ADDR_NAMESEQ: 67 v1 is the server type 68 v2 is the lower port number 69 v3 is the upper port number 70 if addr_type is TIPC_ADDR_ID: 71 v1 is the node 72 v2 is the ref 73 v3 is ignored 74 75 76Local naming conventions: 77 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 81 82*/ 83 84#ifdef __APPLE__ 85#include <AvailabilityMacros.h> 86/* for getaddrinfo thread safety test on old versions of OS X */ 87#ifndef MAC_OS_X_VERSION_10_5 88#define MAC_OS_X_VERSION_10_5 1050 89#endif 90 /* 91 * inet_aton is not available on OSX 10.3, yet we want to use a binary 92 * that was build on 10.4 or later to work on that release, weak linking 93 * comes to the rescue. 94 */ 95# pragma weak inet_aton 96#endif 97 98#include "Python.h" 99#include "structmember.h" 100#include "timefuncs.h" 101 102#ifndef INVALID_SOCKET /* MS defines this */ 103#define INVALID_SOCKET (-1) 104#endif 105 106#undef MAX 107#define MAX(x, y) ((x) < (y) ? (y) : (x)) 108 109/* Socket object documentation */ 110PyDoc_STRVAR(sock_doc, 111"socket([family[, type[, proto]]]) -> socket object\n\ 112\n\ 113Open a socket of the given type. The family argument specifies the\n\ 114address family; it defaults to AF_INET. The type argument specifies\n\ 115whether this is a stream (SOCK_STREAM, this is the default)\n\ 116or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\ 117specifying the default protocol. Keyword arguments are accepted.\n\ 118\n\ 119A socket object represents one endpoint of a network connection.\n\ 120\n\ 121Methods of socket objects (keyword arguments not allowed):\n\ 122\n\ 123accept() -- accept a connection, returning new socket and client address\n\ 124bind(addr) -- bind the socket to a local address\n\ 125close() -- close the socket\n\ 126connect(addr) -- connect the socket to a remote address\n\ 127connect_ex(addr) -- connect, return an error code instead of an exception\n\ 128dup() -- return a new socket object identical to the current one [*]\n\ 129fileno() -- return underlying file descriptor\n\ 130getpeername() -- return remote address [*]\n\ 131getsockname() -- return local address\n\ 132getsockopt(level, optname[, buflen]) -- get socket options\n\ 133gettimeout() -- return timeout or None\n\ 134listen(n) -- start listening for incoming connections\n\ 135makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\ 136recv(buflen[, flags]) -- receive data\n\ 137recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\ 138recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\ 139recvfrom_into(buffer[, nbytes, [, flags])\n\ 140 -- receive data and sender\'s address (into a buffer)\n\ 141sendall(data[, flags]) -- send all data\n\ 142send(data[, flags]) -- send data, may not send all of it\n\ 143sendto(data[, flags], addr) -- send data to a given address\n\ 144setblocking(0 | 1) -- set or clear the blocking I/O flag\n\ 145setsockopt(level, optname, value) -- set socket options\n\ 146settimeout(None | float) -- set or clear the timeout\n\ 147shutdown(how) -- shut down traffic in one or both directions\n\ 148\n\ 149 [*] not available on all platforms!"); 150 151/* XXX This is a terrible mess of platform-dependent preprocessor hacks. 152 I hope some day someone can clean this up please... */ 153 154/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure 155 script doesn't get this right, so we hardcode some platform checks below. 156 On the other hand, not all Linux versions agree, so there the settings 157 computed by the configure script are needed! */ 158 159#ifndef linux 160# undef HAVE_GETHOSTBYNAME_R_3_ARG 161# undef HAVE_GETHOSTBYNAME_R_5_ARG 162# undef HAVE_GETHOSTBYNAME_R_6_ARG 163#endif 164 165#ifndef WITH_THREAD 166# undef HAVE_GETHOSTBYNAME_R 167#endif 168 169#ifdef HAVE_GETHOSTBYNAME_R 170# if defined(_AIX) && !defined(_LINUX_SOURCE_COMPAT) || defined(__osf__) 171# define HAVE_GETHOSTBYNAME_R_3_ARG 172# elif defined(__sun) || defined(__sgi) 173# define HAVE_GETHOSTBYNAME_R_5_ARG 174# elif defined(linux) 175/* Rely on the configure script */ 176# elif defined(_LINUX_SOURCE_COMPAT) /* Linux compatibility on AIX */ 177# define HAVE_GETHOSTBYNAME_R_6_ARG 178# else 179# undef HAVE_GETHOSTBYNAME_R 180# endif 181#endif 182 183#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \ 184 !defined(MS_WINDOWS) 185# define USE_GETHOSTBYNAME_LOCK 186#endif 187 188/* To use __FreeBSD_version, __OpenBSD__, and __NetBSD_Version__ */ 189#ifdef HAVE_SYS_PARAM_H 190#include <sys/param.h> 191#endif 192/* On systems on which getaddrinfo() is believed to not be thread-safe, 193 (this includes the getaddrinfo emulation) protect access with a lock. 194 195 getaddrinfo is thread-safe on Mac OS X 10.5 and later. Originally it was 196 a mix of code including an unsafe implementation from an old BSD's 197 libresolv. In 10.5 Apple reimplemented it as a safe IPC call to the 198 mDNSResponder process. 10.5 is the first be UNIX '03 certified, which 199 includes the requirement that getaddrinfo be thread-safe. See issue #25924. 200 201 It's thread-safe in OpenBSD starting with 5.4, released Nov 2013: 202 http://www.openbsd.org/plus54.html 203 204 It's thread-safe in NetBSD starting with 4.0, released Dec 2007: 205 206http://cvsweb.netbsd.org/bsdweb.cgi/src/lib/libc/net/getaddrinfo.c.diff?r1=1.82&r2=1.83 207*/ 208#if defined(WITH_THREAD) && ( \ 209 (defined(__APPLE__) && \ 210 MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5) || \ 211 (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \ 212 (defined(__OpenBSD__) && OpenBSD+0 < 201311) || \ 213 (defined(__NetBSD__) && __NetBSD_Version__+0 < 400000000) || \ 214 defined(__VMS) || !defined(HAVE_GETADDRINFO)) 215#define USE_GETADDRINFO_LOCK 216#endif 217 218#ifdef USE_GETADDRINFO_LOCK 219#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1); 220#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock); 221#else 222#define ACQUIRE_GETADDRINFO_LOCK 223#define RELEASE_GETADDRINFO_LOCK 224#endif 225 226#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK) 227# include "pythread.h" 228#endif 229 230#if defined(PYCC_VACPP) 231# include <types.h> 232# include <io.h> 233# include <sys/ioctl.h> 234# include <utils.h> 235# include <ctype.h> 236#endif 237 238#if defined(__VMS) 239# include <ioctl.h> 240#endif 241 242#if defined(PYOS_OS2) 243# define INCL_DOS 244# define INCL_DOSERRORS 245# define INCL_NOPMAPI 246# include <os2.h> 247#endif 248 249#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI 250/* make sure that the reentrant (gethostbyaddr_r etc) 251 functions are declared correctly if compiling with 252 MIPSPro 7.x in ANSI C mode (default) */ 253 254/* XXX Using _SGIAPI is the wrong thing, 255 but I don't know what the right thing is. */ 256#undef _SGIAPI /* to avoid warning */ 257#define _SGIAPI 1 258 259#undef _XOPEN_SOURCE 260#include <sys/socket.h> 261#include <sys/types.h> 262#include <netinet/in.h> 263#ifdef _SS_ALIGNSIZE 264#define HAVE_GETADDRINFO 1 265#define HAVE_GETNAMEINFO 1 266#endif 267 268#define HAVE_INET_PTON 269#include <netdb.h> 270#endif 271 272/* Irix 6.5 fails to define this variable at all. This is needed 273 for both GCC and SGI's compiler. I'd say that the SGI headers 274 are just busted. Same thing for Solaris. */ 275#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN) 276#define INET_ADDRSTRLEN 16 277#endif 278 279/* Generic includes */ 280#ifdef HAVE_SYS_TYPES_H 281#include <sys/types.h> 282#endif 283 284/* Generic socket object definitions and includes */ 285#define PySocket_BUILDING_SOCKET 286#include "socketmodule.h" 287 288/* Addressing includes */ 289 290#ifndef MS_WINDOWS 291 292/* Non-MS WINDOWS includes */ 293# include <netdb.h> 294 295/* Headers needed for inet_ntoa() and inet_addr() */ 296# ifdef __BEOS__ 297# include <net/netdb.h> 298# elif defined(PYOS_OS2) && defined(PYCC_VACPP) 299# include <netdb.h> 300typedef size_t socklen_t; 301# else 302# include <arpa/inet.h> 303# endif 304 305# ifndef RISCOS 306# include <fcntl.h> 307# else 308# include <sys/ioctl.h> 309# include <socklib.h> 310# define NO_DUP 311int h_errno; /* not used */ 312# define INET_ADDRSTRLEN 16 313# endif 314 315#else 316 317/* MS_WINDOWS includes */ 318# ifdef HAVE_FCNTL_H 319# include <fcntl.h> 320# endif 321 322#endif 323 324#include <stddef.h> 325 326#ifndef offsetof 327# define offsetof(type, member) ((size_t)(&((type *)0)->member)) 328#endif 329 330#ifndef O_NONBLOCK 331# define O_NONBLOCK O_NDELAY 332#endif 333 334/* include Python's addrinfo.h unless it causes trouble */ 335#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE) 336 /* Do not include addinfo.h on some newer IRIX versions. 337 * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21, 338 * for example, but not by 6.5.10. 339 */ 340#elif defined(_MSC_VER) && _MSC_VER>1201 341 /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and 342 * EAI_* constants are defined in (the already included) ws2tcpip.h. 343 */ 344#else 345# include "addrinfo.h" 346#endif 347 348#ifndef HAVE_INET_PTON 349#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN) 350int inet_pton(int af, const char *src, void *dst); 351const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); 352#endif 353#endif 354 355#ifdef __APPLE__ 356/* On OS X, getaddrinfo returns no error indication of lookup 357 failure, so we must use the emulation instead of the libinfo 358 implementation. Unfortunately, performing an autoconf test 359 for this bug would require DNS access for the machine performing 360 the configuration, which is not acceptable. Therefore, we 361 determine the bug just by checking for __APPLE__. If this bug 362 gets ever fixed, perhaps checking for sys/version.h would be 363 appropriate, which is 10/0 on the system with the bug. */ 364#ifndef HAVE_GETNAMEINFO 365/* This bug seems to be fixed in Jaguar. Ths easiest way I could 366 Find to check for Jaguar is that it has getnameinfo(), which 367 older releases don't have */ 368#undef HAVE_GETADDRINFO 369#endif 370 371#ifdef HAVE_INET_ATON 372#define USE_INET_ATON_WEAKLINK 373#endif 374 375#endif 376 377/* I know this is a bad practice, but it is the easiest... */ 378#if !defined(HAVE_GETADDRINFO) 379/* avoid clashes with the C library definition of the symbol. */ 380#define getaddrinfo fake_getaddrinfo 381#define gai_strerror fake_gai_strerror 382#define freeaddrinfo fake_freeaddrinfo 383#include "getaddrinfo.c" 384#endif 385#if !defined(HAVE_GETNAMEINFO) 386#define getnameinfo fake_getnameinfo 387#include "getnameinfo.c" 388#endif 389 390#if defined(MS_WINDOWS) || defined(__BEOS__) 391/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */ 392/* seem to be a few differences in the API */ 393#define SOCKETCLOSE closesocket 394#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */ 395#endif 396 397#ifdef MS_WIN32 398#define EAFNOSUPPORT WSAEAFNOSUPPORT 399#define snprintf _snprintf 400#endif 401 402#if defined(PYOS_OS2) && !defined(PYCC_GCC) 403#define SOCKETCLOSE soclose 404#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */ 405#endif 406 407#ifndef SOCKETCLOSE 408#define SOCKETCLOSE close 409#endif 410 411#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__) 412#define USE_BLUETOOTH 1 413#if defined(__FreeBSD__) 414#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP 415#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM 416#define BTPROTO_HCI BLUETOOTH_PROTO_HCI 417#define SOL_HCI SOL_HCI_RAW 418#define HCI_FILTER SO_HCI_RAW_FILTER 419#define sockaddr_l2 sockaddr_l2cap 420#define sockaddr_rc sockaddr_rfcomm 421#define hci_dev hci_node 422#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb) 423#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb) 424#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb) 425#elif defined(__NetBSD__) || defined(__DragonFly__) 426#define sockaddr_l2 sockaddr_bt 427#define sockaddr_rc sockaddr_bt 428#define sockaddr_hci sockaddr_bt 429#define sockaddr_sco sockaddr_bt 430#define SOL_HCI BTPROTO_HCI 431#define HCI_DATA_DIR SO_HCI_DIRECTION 432#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb) 433#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb) 434#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb) 435#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb) 436#else 437#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb) 438#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb) 439#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb) 440#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb) 441#endif 442#endif 443 444#ifdef __VMS 445/* TCP/IP Services for VMS uses a maximum send/recv buffer length */ 446#define SEGMENT_SIZE (32 * 1024 -1) 447#endif 448 449#define SAS2SA(x) ((struct sockaddr *)(x)) 450 451/* 452 * Constants for getnameinfo() 453 */ 454#if !defined(NI_MAXHOST) 455#define NI_MAXHOST 1025 456#endif 457#if !defined(NI_MAXSERV) 458#define NI_MAXSERV 32 459#endif 460 461/* XXX There's a problem here: *static* functions are not supposed to have 462 a Py prefix (or use CapitalizedWords). Later... */ 463 464/* Global variable holding the exception type for errors detected 465 by this module (but not argument type or memory errors, etc.). */ 466static PyObject *socket_error; 467static PyObject *socket_herror; 468static PyObject *socket_gaierror; 469static PyObject *socket_timeout; 470 471#ifdef RISCOS 472/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */ 473static int taskwindow; 474#endif 475 476/* A forward reference to the socket type object. 477 The sock_type variable contains pointers to various functions, 478 some of which call new_sockobject(), which uses sock_type, so 479 there has to be a circular reference. */ 480static PyTypeObject sock_type; 481 482#if defined(HAVE_POLL_H) 483#include <poll.h> 484#elif defined(HAVE_SYS_POLL_H) 485#include <sys/poll.h> 486#endif 487 488#ifdef HAVE_POLL 489/* Instead of select(), we'll use poll() since poll() works on any fd. */ 490#define IS_SELECTABLE(s) 1 491/* Can we call select() with this socket without a buffer overrun? */ 492#else 493/* If there's no timeout left, we don't have to call select, so it's a safe, 494 * little white lie. */ 495#define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0.0) 496#endif 497 498static PyObject* 499select_error(void) 500{ 501 PyErr_SetString(socket_error, "unable to select on socket"); 502 return NULL; 503} 504 505#ifdef MS_WINDOWS 506#ifndef WSAEAGAIN 507#define WSAEAGAIN WSAEWOULDBLOCK 508#endif 509#define CHECK_ERRNO(expected) \ 510 (WSAGetLastError() == WSA ## expected) 511#else 512#define CHECK_ERRNO(expected) \ 513 (errno == expected) 514#endif 515 516/* Convenience function to raise an error according to errno 517 and return a NULL pointer from a function. */ 518 519static PyObject * 520set_error(void) 521{ 522#ifdef MS_WINDOWS 523 int err_no = WSAGetLastError(); 524 /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which 525 recognizes the error codes used by both GetLastError() and 526 WSAGetLastError */ 527 if (err_no) 528 return PyErr_SetExcFromWindowsErr(socket_error, err_no); 529#endif 530 531#if defined(PYOS_OS2) && !defined(PYCC_GCC) 532 if (sock_errno() != NO_ERROR) { 533 APIRET rc; 534 ULONG msglen; 535 char outbuf[100]; 536 int myerrorcode = sock_errno(); 537 538 /* Retrieve socket-related error message from MPTN.MSG file */ 539 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf), 540 myerrorcode - SOCBASEERR + 26, 541 "mptn.msg", 542 &msglen); 543 if (rc == NO_ERROR) { 544 PyObject *v; 545 546 /* OS/2 doesn't guarantee a terminator */ 547 outbuf[msglen] = '\0'; 548 if (strlen(outbuf) > 0) { 549 /* If non-empty msg, trim CRLF */ 550 char *lastc = &outbuf[ strlen(outbuf)-1 ]; 551 while (lastc > outbuf && 552 isspace(Py_CHARMASK(*lastc))) { 553 /* Trim trailing whitespace (CRLF) */ 554 *lastc-- = '\0'; 555 } 556 } 557 v = Py_BuildValue("(is)", myerrorcode, outbuf); 558 if (v != NULL) { 559 PyErr_SetObject(socket_error, v); 560 Py_DECREF(v); 561 } 562 return NULL; 563 } 564 } 565#endif 566 567#if defined(RISCOS) 568 if (_inet_error.errnum != NULL) { 569 PyObject *v; 570 v = Py_BuildValue("(is)", errno, _inet_err()); 571 if (v != NULL) { 572 PyErr_SetObject(socket_error, v); 573 Py_DECREF(v); 574 } 575 return NULL; 576 } 577#endif 578 579 return PyErr_SetFromErrno(socket_error); 580} 581 582 583static PyObject * 584set_herror(int h_error) 585{ 586 PyObject *v; 587 588#ifdef HAVE_HSTRERROR 589 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error)); 590#else 591 v = Py_BuildValue("(is)", h_error, "host not found"); 592#endif 593 if (v != NULL) { 594 PyErr_SetObject(socket_herror, v); 595 Py_DECREF(v); 596 } 597 598 return NULL; 599} 600 601 602static PyObject * 603set_gaierror(int error) 604{ 605 PyObject *v; 606 607#ifdef EAI_SYSTEM 608 /* EAI_SYSTEM is not available on Windows XP. */ 609 if (error == EAI_SYSTEM) 610 return set_error(); 611#endif 612 613#ifdef HAVE_GAI_STRERROR 614 v = Py_BuildValue("(is)", error, gai_strerror(error)); 615#else 616 v = Py_BuildValue("(is)", error, "getaddrinfo failed"); 617#endif 618 if (v != NULL) { 619 PyErr_SetObject(socket_gaierror, v); 620 Py_DECREF(v); 621 } 622 623 return NULL; 624} 625 626#ifdef __VMS 627/* Function to send in segments */ 628static int 629sendsegmented(int sock_fd, char *buf, int len, int flags) 630{ 631 int n = 0; 632 int remaining = len; 633 634 while (remaining > 0) { 635 unsigned int segment; 636 637 segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining); 638 n = send(sock_fd, buf, segment, flags); 639 if (n < 0) { 640 return n; 641 } 642 remaining -= segment; 643 buf += segment; 644 } /* end while */ 645 646 return len; 647} 648#endif 649 650/* Function to perform the setting of socket blocking mode 651 internally. block = (1 | 0). */ 652static int 653internal_setblocking(PySocketSockObject *s, int block) 654{ 655#ifndef RISCOS 656#ifndef MS_WINDOWS 657 int delay_flag; 658#endif 659#endif 660 661 Py_BEGIN_ALLOW_THREADS 662#ifdef __BEOS__ 663 block = !block; 664 setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK, 665 (void *)(&block), sizeof(int)); 666#else 667#ifndef RISCOS 668#ifndef MS_WINDOWS 669#if defined(PYOS_OS2) && !defined(PYCC_GCC) 670 block = !block; 671 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block)); 672#elif defined(__VMS) 673 block = !block; 674 ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block); 675#else /* !PYOS_OS2 && !__VMS */ 676 delay_flag = fcntl(s->sock_fd, F_GETFL, 0); 677 if (block) 678 delay_flag &= (~O_NONBLOCK); 679 else 680 delay_flag |= O_NONBLOCK; 681 fcntl(s->sock_fd, F_SETFL, delay_flag); 682#endif /* !PYOS_OS2 */ 683#else /* MS_WINDOWS */ 684 block = !block; 685 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block); 686#endif /* MS_WINDOWS */ 687#else /* RISCOS */ 688 block = !block; 689 socketioctl(s->sock_fd, FIONBIO, (u_long*)&block); 690#endif /* RISCOS */ 691#endif /* __BEOS__ */ 692 Py_END_ALLOW_THREADS 693 694 /* Since these don't return anything */ 695 return 1; 696} 697 698/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0). 699 The argument writing indicates the direction. 700 This does not raise an exception; we'll let our caller do that 701 after they've reacquired the interpreter lock. 702 Returns 1 on timeout, -1 on error, 0 otherwise. */ 703static int 704internal_select_ex(PySocketSockObject *s, int writing, double interval) 705{ 706 int n; 707 708 /* Nothing to do unless we're in timeout mode (not non-blocking) */ 709 if (s->sock_timeout <= 0.0) 710 return 0; 711 712 /* Guard against closed socket */ 713 if (s->sock_fd < 0) 714 return 0; 715 716 /* Handling this condition here simplifies the select loops */ 717 if (interval < 0.0) 718 return 1; 719 720 /* Prefer poll, if available, since you can poll() any fd 721 * which can't be done with select(). */ 722#ifdef HAVE_POLL 723 { 724 struct pollfd pollfd; 725 int timeout; 726 727 pollfd.fd = s->sock_fd; 728 pollfd.events = writing ? POLLOUT : POLLIN; 729 730 /* s->sock_timeout is in seconds, timeout in ms */ 731 timeout = (int)(interval * 1000 + 0.5); 732 n = poll(&pollfd, 1, timeout); 733 } 734#else 735 { 736 /* Construct the arguments to select */ 737 fd_set fds; 738 struct timeval tv; 739 tv.tv_sec = (int)interval; 740 tv.tv_usec = (int)((interval - tv.tv_sec) * 1e6); 741 FD_ZERO(&fds); 742 FD_SET(s->sock_fd, &fds); 743 744 /* See if the socket is ready */ 745 if (writing) 746 n = select(s->sock_fd+1, NULL, &fds, NULL, &tv); 747 else 748 n = select(s->sock_fd+1, &fds, NULL, NULL, &tv); 749 } 750#endif 751 752 if (n < 0) 753 return -1; 754 if (n == 0) 755 return 1; 756 return 0; 757} 758 759static int 760internal_select(PySocketSockObject *s, int writing) 761{ 762 return internal_select_ex(s, writing, s->sock_timeout); 763} 764 765/* 766 Two macros for automatic retry of select() in case of false positives 767 (for example, select() could indicate a socket is ready for reading 768 but the data then discarded by the OS because of a wrong checksum). 769 Here is an example of use: 770 771 BEGIN_SELECT_LOOP(s) 772 Py_BEGIN_ALLOW_THREADS 773 timeout = internal_select_ex(s, 0, interval); 774 if (!timeout) 775 outlen = recv(s->sock_fd, cbuf, len, flags); 776 Py_END_ALLOW_THREADS 777 if (timeout == 1) { 778 PyErr_SetString(socket_timeout, "timed out"); 779 return -1; 780 } 781 END_SELECT_LOOP(s) 782*/ 783#define BEGIN_SELECT_LOOP(s) \ 784 { \ 785 double deadline = 0, interval = s->sock_timeout; \ 786 int has_timeout = s->sock_timeout > 0.0; \ 787 if (has_timeout) { \ 788 deadline = _PyTime_FloatTime() + s->sock_timeout; \ 789 } \ 790 while (1) { \ 791 errno = 0; 792 793#define END_SELECT_LOOP(s) \ 794 if (!has_timeout || \ 795 (!CHECK_ERRNO(EWOULDBLOCK) && !CHECK_ERRNO(EAGAIN))) \ 796 break; \ 797 interval = deadline - _PyTime_FloatTime(); \ 798 } \ 799 } 800 801/* Initialize a new socket object. */ 802 803static double defaulttimeout = -1.0; /* Default timeout for new sockets */ 804 805PyMODINIT_FUNC 806init_sockobject(PySocketSockObject *s, 807 SOCKET_T fd, int family, int type, int proto) 808{ 809#ifdef RISCOS 810 int block = 1; 811#endif 812 s->sock_fd = fd; 813 s->sock_family = family; 814 s->sock_type = type; 815 s->sock_proto = proto; 816 s->sock_timeout = defaulttimeout; 817 818 s->errorhandler = &set_error; 819 820 if (defaulttimeout >= 0.0) 821 internal_setblocking(s, 0); 822 823#ifdef RISCOS 824 if (taskwindow) 825 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); 826#endif 827} 828 829 830/* Create a new socket object. 831 This just creates the object and initializes it. 832 If the creation fails, return NULL and set an exception (implicit 833 in NEWOBJ()). */ 834 835static PySocketSockObject * 836new_sockobject(SOCKET_T fd, int family, int type, int proto) 837{ 838 PySocketSockObject *s; 839 s = (PySocketSockObject *) 840 PyType_GenericNew(&sock_type, NULL, NULL); 841 if (s != NULL) 842 init_sockobject(s, fd, family, type, proto); 843 return s; 844} 845 846 847/* Lock to allow python interpreter to continue, but only allow one 848 thread to be in gethostbyname or getaddrinfo */ 849#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK) 850static PyThread_type_lock netdb_lock; 851#endif 852 853 854/* Convert a string specifying a host name or one of a few symbolic 855 names to a numeric IP address. This usually calls gethostbyname() 856 to do the work; the names "" and "<broadcast>" are special. 857 Return the length (IPv4 should be 4 bytes), or negative if 858 an error occurred; then an exception is raised. */ 859 860static int 861setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af) 862{ 863 struct addrinfo hints, *res; 864 int error; 865 int d1, d2, d3, d4; 866 char ch; 867 868 memset((void *) addr_ret, '\0', sizeof(*addr_ret)); 869 if (name[0] == '\0') { 870 int siz; 871 memset(&hints, 0, sizeof(hints)); 872 hints.ai_family = af; 873 hints.ai_socktype = SOCK_DGRAM; /*dummy*/ 874 hints.ai_flags = AI_PASSIVE; 875 Py_BEGIN_ALLOW_THREADS 876 ACQUIRE_GETADDRINFO_LOCK 877 error = getaddrinfo(NULL, "0", &hints, &res); 878 Py_END_ALLOW_THREADS 879 /* We assume that those thread-unsafe getaddrinfo() versions 880 *are* safe regarding their return value, ie. that a 881 subsequent call to getaddrinfo() does not destroy the 882 outcome of the first call. */ 883 RELEASE_GETADDRINFO_LOCK 884 if (error) { 885 set_gaierror(error); 886 return -1; 887 } 888 switch (res->ai_family) { 889 case AF_INET: 890 siz = 4; 891 break; 892#ifdef ENABLE_IPV6 893 case AF_INET6: 894 siz = 16; 895 break; 896#endif 897 default: 898 freeaddrinfo(res); 899 PyErr_SetString(socket_error, 900 "unsupported address family"); 901 return -1; 902 } 903 if (res->ai_next) { 904 freeaddrinfo(res); 905 PyErr_SetString(socket_error, 906 "wildcard resolved to multiple address"); 907 return -1; 908 } 909 if (res->ai_addrlen < addr_ret_size) 910 addr_ret_size = res->ai_addrlen; 911 memcpy(addr_ret, res->ai_addr, addr_ret_size); 912 freeaddrinfo(res); 913 return siz; 914 } 915 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) { 916 struct sockaddr_in *sin; 917 if (af != AF_INET && af != AF_UNSPEC) { 918 PyErr_SetString(socket_error, 919 "address family mismatched"); 920 return -1; 921 } 922 sin = (struct sockaddr_in *)addr_ret; 923 memset((void *) sin, '\0', sizeof(*sin)); 924 sin->sin_family = AF_INET; 925#ifdef HAVE_SOCKADDR_SA_LEN 926 sin->sin_len = sizeof(*sin); 927#endif 928 sin->sin_addr.s_addr = INADDR_BROADCAST; 929 return sizeof(sin->sin_addr); 930 } 931 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 && 932 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 && 933 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) { 934 struct sockaddr_in *sin; 935 sin = (struct sockaddr_in *)addr_ret; 936 sin->sin_addr.s_addr = htonl( 937 ((long) d1 << 24) | ((long) d2 << 16) | 938 ((long) d3 << 8) | ((long) d4 << 0)); 939 sin->sin_family = AF_INET; 940#ifdef HAVE_SOCKADDR_SA_LEN 941 sin->sin_len = sizeof(*sin); 942#endif 943 return 4; 944 } 945 memset(&hints, 0, sizeof(hints)); 946 hints.ai_family = af; 947 Py_BEGIN_ALLOW_THREADS 948 ACQUIRE_GETADDRINFO_LOCK 949 error = getaddrinfo(name, NULL, &hints, &res); 950#if defined(__digital__) && defined(__unix__) 951 if (error == EAI_NONAME && af == AF_UNSPEC) { 952 /* On Tru64 V5.1, numeric-to-addr conversion fails 953 if no address family is given. Assume IPv4 for now.*/ 954 hints.ai_family = AF_INET; 955 error = getaddrinfo(name, NULL, &hints, &res); 956 } 957#endif 958 Py_END_ALLOW_THREADS 959 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */ 960 if (error) { 961 set_gaierror(error); 962 return -1; 963 } 964 if (res->ai_addrlen < addr_ret_size) 965 addr_ret_size = res->ai_addrlen; 966 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size); 967 freeaddrinfo(res); 968 switch (addr_ret->sa_family) { 969 case AF_INET: 970 return 4; 971#ifdef ENABLE_IPV6 972 case AF_INET6: 973 return 16; 974#endif 975 default: 976 PyErr_SetString(socket_error, "unknown address family"); 977 return -1; 978 } 979} 980 981 982/* Create a string object representing an IP address. 983 This is always a string of the form 'dd.dd.dd.dd' (with variable 984 size numbers). */ 985 986static PyObject * 987makeipaddr(struct sockaddr *addr, int addrlen) 988{ 989 char buf[NI_MAXHOST]; 990 int error; 991 992 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0, 993 NI_NUMERICHOST); 994 if (error) { 995 set_gaierror(error); 996 return NULL; 997 } 998 return PyString_FromString(buf); 999} 1000 1001 1002#ifdef USE_BLUETOOTH 1003/* Convert a string representation of a Bluetooth address into a numeric 1004 address. Returns the length (6), or raises an exception and returns -1 if 1005 an error occurred. */ 1006 1007static int 1008setbdaddr(char *name, bdaddr_t *bdaddr) 1009{ 1010 unsigned int b0, b1, b2, b3, b4, b5; 1011 char ch; 1012 int n; 1013 1014 n = sscanf(name, "%X:%X:%X:%X:%X:%X%c", 1015 &b5, &b4, &b3, &b2, &b1, &b0, &ch); 1016 if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) { 1017 bdaddr->b[0] = b0; 1018 bdaddr->b[1] = b1; 1019 bdaddr->b[2] = b2; 1020 bdaddr->b[3] = b3; 1021 bdaddr->b[4] = b4; 1022 bdaddr->b[5] = b5; 1023 return 6; 1024 } else { 1025 PyErr_SetString(socket_error, "bad bluetooth address"); 1026 return -1; 1027 } 1028} 1029 1030/* Create a string representation of the Bluetooth address. This is always a 1031 string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal 1032 value (zero padded if necessary). */ 1033 1034static PyObject * 1035makebdaddr(bdaddr_t *bdaddr) 1036{ 1037 char buf[(6 * 2) + 5 + 1]; 1038 1039 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", 1040 bdaddr->b[5], bdaddr->b[4], bdaddr->b[3], 1041 bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]); 1042 return PyString_FromString(buf); 1043} 1044#endif 1045 1046 1047/* Create an object representing the given socket address, 1048 suitable for passing it back to bind(), connect() etc. 1049 The family field of the sockaddr structure is inspected 1050 to determine what kind of address it really is. */ 1051 1052/*ARGSUSED*/ 1053static PyObject * 1054makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto) 1055{ 1056 if (addrlen == 0) { 1057 /* No address -- may be recvfrom() from known socket */ 1058 Py_INCREF(Py_None); 1059 return Py_None; 1060 } 1061 1062#ifdef __BEOS__ 1063 /* XXX: BeOS version of accept() doesn't set family correctly */ 1064 addr->sa_family = AF_INET; 1065#endif 1066 1067 switch (addr->sa_family) { 1068 1069 case AF_INET: 1070 { 1071 struct sockaddr_in *a; 1072 PyObject *addrobj = makeipaddr(addr, sizeof(*a)); 1073 PyObject *ret = NULL; 1074 if (addrobj) { 1075 a = (struct sockaddr_in *)addr; 1076 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port)); 1077 Py_DECREF(addrobj); 1078 } 1079 return ret; 1080 } 1081 1082#if defined(AF_UNIX) 1083 case AF_UNIX: 1084 { 1085 struct sockaddr_un *a = (struct sockaddr_un *) addr; 1086#ifdef linux 1087 if (a->sun_path[0] == 0) { /* Linux abstract namespace */ 1088 addrlen -= offsetof(struct sockaddr_un, sun_path); 1089 return PyString_FromStringAndSize(a->sun_path, 1090 addrlen); 1091 } 1092 else 1093#endif /* linux */ 1094 { 1095 /* regular NULL-terminated string */ 1096 return PyString_FromString(a->sun_path); 1097 } 1098 } 1099#endif /* AF_UNIX */ 1100 1101#if defined(AF_NETLINK) 1102 case AF_NETLINK: 1103 { 1104 struct sockaddr_nl *a = (struct sockaddr_nl *) addr; 1105 return Py_BuildValue("II", a->nl_pid, a->nl_groups); 1106 } 1107#endif /* AF_NETLINK */ 1108 1109#ifdef ENABLE_IPV6 1110 case AF_INET6: 1111 { 1112 struct sockaddr_in6 *a; 1113 PyObject *addrobj = makeipaddr(addr, sizeof(*a)); 1114 PyObject *ret = NULL; 1115 if (addrobj) { 1116 a = (struct sockaddr_in6 *)addr; 1117 ret = Py_BuildValue("OiII", 1118 addrobj, 1119 ntohs(a->sin6_port), 1120 ntohl(a->sin6_flowinfo), 1121 a->sin6_scope_id); 1122 Py_DECREF(addrobj); 1123 } 1124 return ret; 1125 } 1126#endif 1127 1128#ifdef USE_BLUETOOTH 1129 case AF_BLUETOOTH: 1130 switch (proto) { 1131 1132 case BTPROTO_L2CAP: 1133 { 1134 struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr; 1135 PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr)); 1136 PyObject *ret = NULL; 1137 if (addrobj) { 1138 ret = Py_BuildValue("Oi", 1139 addrobj, 1140 _BT_L2_MEMB(a, psm)); 1141 Py_DECREF(addrobj); 1142 } 1143 return ret; 1144 } 1145 1146 case BTPROTO_RFCOMM: 1147 { 1148 struct sockaddr_rc *a = (struct sockaddr_rc *) addr; 1149 PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr)); 1150 PyObject *ret = NULL; 1151 if (addrobj) { 1152 ret = Py_BuildValue("Oi", 1153 addrobj, 1154 _BT_RC_MEMB(a, channel)); 1155 Py_DECREF(addrobj); 1156 } 1157 return ret; 1158 } 1159 1160 case BTPROTO_HCI: 1161 { 1162 struct sockaddr_hci *a = (struct sockaddr_hci *) addr; 1163#if defined(__NetBSD__) || defined(__DragonFly__) 1164 return makebdaddr(&_BT_HCI_MEMB(a, bdaddr)); 1165#else 1166 PyObject *ret = NULL; 1167 ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev)); 1168 return ret; 1169#endif 1170 } 1171 1172#if !defined(__FreeBSD__) 1173 case BTPROTO_SCO: 1174 { 1175 struct sockaddr_sco *a = (struct sockaddr_sco *) addr; 1176 return makebdaddr(&_BT_SCO_MEMB(a, bdaddr)); 1177 } 1178#endif 1179 1180 default: 1181 PyErr_SetString(PyExc_ValueError, 1182 "Unknown Bluetooth protocol"); 1183 return NULL; 1184 } 1185#endif 1186 1187#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME) 1188 case AF_PACKET: 1189 { 1190 struct sockaddr_ll *a = (struct sockaddr_ll *)addr; 1191 char *ifname = ""; 1192 struct ifreq ifr; 1193 /* need to look up interface name give index */ 1194 if (a->sll_ifindex) { 1195 ifr.ifr_ifindex = a->sll_ifindex; 1196 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0) 1197 ifname = ifr.ifr_name; 1198 } 1199 return Py_BuildValue("shbhs#", 1200 ifname, 1201 ntohs(a->sll_protocol), 1202 a->sll_pkttype, 1203 a->sll_hatype, 1204 a->sll_addr, 1205 a->sll_halen); 1206 } 1207#endif 1208 1209#ifdef HAVE_LINUX_TIPC_H 1210 case AF_TIPC: 1211 { 1212 struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr; 1213 if (a->addrtype == TIPC_ADDR_NAMESEQ) { 1214 return Py_BuildValue("IIIII", 1215 a->addrtype, 1216 a->addr.nameseq.type, 1217 a->addr.nameseq.lower, 1218 a->addr.nameseq.upper, 1219 a->scope); 1220 } else if (a->addrtype == TIPC_ADDR_NAME) { 1221 return Py_BuildValue("IIIII", 1222 a->addrtype, 1223 a->addr.name.name.type, 1224 a->addr.name.name.instance, 1225 a->addr.name.name.instance, 1226 a->scope); 1227 } else if (a->addrtype == TIPC_ADDR_ID) { 1228 return Py_BuildValue("IIIII", 1229 a->addrtype, 1230 a->addr.id.node, 1231 a->addr.id.ref, 1232 0, 1233 a->scope); 1234 } else { 1235 PyErr_SetString(PyExc_ValueError, 1236 "Invalid address type"); 1237 return NULL; 1238 } 1239 } 1240#endif 1241 1242 /* More cases here... */ 1243 1244 default: 1245 /* If we don't know the address family, don't raise an 1246 exception -- return it as a tuple. */ 1247 return Py_BuildValue("is#", 1248 addr->sa_family, 1249 addr->sa_data, 1250 sizeof(addr->sa_data)); 1251 1252 } 1253} 1254 1255 1256/* Parse a socket address argument according to the socket object's 1257 address family. Return 1 if the address was in the proper format, 1258 0 of not. The address is returned through addr_ret, its length 1259 through len_ret. */ 1260 1261static int 1262getsockaddrarg(PySocketSockObject *s, PyObject *args, 1263 struct sockaddr *addr_ret, int *len_ret) 1264{ 1265 switch (s->sock_family) { 1266 1267#if defined(AF_UNIX) 1268 case AF_UNIX: 1269 { 1270 struct sockaddr_un* addr; 1271 char *path; 1272 int len; 1273 if (!PyArg_Parse(args, "t#", &path, &len)) 1274 return 0; 1275 1276 addr = (struct sockaddr_un*)addr_ret; 1277#ifdef linux 1278 if (len > 0 && path[0] == 0) { 1279 /* Linux abstract namespace extension */ 1280 if (len > sizeof addr->sun_path) { 1281 PyErr_SetString(socket_error, 1282 "AF_UNIX path too long"); 1283 return 0; 1284 } 1285 } 1286 else 1287#endif /* linux */ 1288 { 1289 /* regular NULL-terminated string */ 1290 if (len >= sizeof addr->sun_path) { 1291 PyErr_SetString(socket_error, 1292 "AF_UNIX path too long"); 1293 return 0; 1294 } 1295 addr->sun_path[len] = 0; 1296 } 1297 addr->sun_family = s->sock_family; 1298 memcpy(addr->sun_path, path, len); 1299#if defined(PYOS_OS2) 1300 *len_ret = sizeof(*addr); 1301#else 1302 *len_ret = len + offsetof(struct sockaddr_un, sun_path); 1303#endif 1304 return 1; 1305 } 1306#endif /* AF_UNIX */ 1307 1308#if defined(AF_NETLINK) 1309 case AF_NETLINK: 1310 { 1311 struct sockaddr_nl* addr; 1312 int pid, groups; 1313 addr = (struct sockaddr_nl *)addr_ret; 1314 if (!PyTuple_Check(args)) { 1315 PyErr_Format( 1316 PyExc_TypeError, 1317 "getsockaddrarg: " 1318 "AF_NETLINK address must be tuple, not %.500s", 1319 Py_TYPE(args)->tp_name); 1320 return 0; 1321 } 1322 if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups)) 1323 return 0; 1324 addr->nl_family = AF_NETLINK; 1325 addr->nl_pid = pid; 1326 addr->nl_groups = groups; 1327 *len_ret = sizeof(*addr); 1328 return 1; 1329 } 1330#endif 1331 1332 case AF_INET: 1333 { 1334 struct sockaddr_in* addr; 1335 char *host; 1336 int port, result; 1337 if (!PyTuple_Check(args)) { 1338 PyErr_Format( 1339 PyExc_TypeError, 1340 "getsockaddrarg: " 1341 "AF_INET address must be tuple, not %.500s", 1342 Py_TYPE(args)->tp_name); 1343 return 0; 1344 } 1345 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg", 1346 "idna", &host, &port)) 1347 return 0; 1348 addr=(struct sockaddr_in*)addr_ret; 1349 result = setipaddr(host, (struct sockaddr *)addr, 1350 sizeof(*addr), AF_INET); 1351 PyMem_Free(host); 1352 if (result < 0) 1353 return 0; 1354 if (port < 0 || port > 0xffff) { 1355 PyErr_SetString( 1356 PyExc_OverflowError, 1357 "getsockaddrarg: port must be 0-65535."); 1358 return 0; 1359 } 1360 addr->sin_family = AF_INET; 1361 addr->sin_port = htons((short)port); 1362 *len_ret = sizeof *addr; 1363 return 1; 1364 } 1365 1366#ifdef ENABLE_IPV6 1367 case AF_INET6: 1368 { 1369 struct sockaddr_in6* addr; 1370 char *host; 1371 int port, result; 1372 unsigned int flowinfo, scope_id; 1373 flowinfo = scope_id = 0; 1374 if (!PyTuple_Check(args)) { 1375 PyErr_Format( 1376 PyExc_TypeError, 1377 "getsockaddrarg: " 1378 "AF_INET6 address must be tuple, not %.500s", 1379 Py_TYPE(args)->tp_name); 1380 return 0; 1381 } 1382 if (!PyArg_ParseTuple(args, "eti|II", 1383 "idna", &host, &port, &flowinfo, 1384 &scope_id)) { 1385 return 0; 1386 } 1387 addr = (struct sockaddr_in6*)addr_ret; 1388 result = setipaddr(host, (struct sockaddr *)addr, 1389 sizeof(*addr), AF_INET6); 1390 PyMem_Free(host); 1391 if (result < 0) 1392 return 0; 1393 if (port < 0 || port > 0xffff) { 1394 PyErr_SetString( 1395 PyExc_OverflowError, 1396 "getsockaddrarg: port must be 0-65535."); 1397 return 0; 1398 } 1399 if (flowinfo > 0xfffff) { 1400 PyErr_SetString( 1401 PyExc_OverflowError, 1402 "getsockaddrarg: flowinfo must be 0-1048575."); 1403 return 0; 1404 } 1405 addr->sin6_family = s->sock_family; 1406 addr->sin6_port = htons((short)port); 1407 addr->sin6_flowinfo = htonl(flowinfo); 1408 addr->sin6_scope_id = scope_id; 1409 *len_ret = sizeof *addr; 1410 return 1; 1411 } 1412#endif 1413 1414#ifdef USE_BLUETOOTH 1415 case AF_BLUETOOTH: 1416 { 1417 switch (s->sock_proto) { 1418 case BTPROTO_L2CAP: 1419 { 1420 struct sockaddr_l2 *addr; 1421 char *straddr; 1422 1423 addr = (struct sockaddr_l2 *)addr_ret; 1424 memset(addr, 0, sizeof(struct sockaddr_l2)); 1425 _BT_L2_MEMB(addr, family) = AF_BLUETOOTH; 1426 if (!PyArg_ParseTuple(args, "si", &straddr, 1427 &_BT_L2_MEMB(addr, psm))) { 1428 PyErr_SetString(socket_error, "getsockaddrarg: " 1429 "wrong format"); 1430 return 0; 1431 } 1432 if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0) 1433 return 0; 1434 1435 *len_ret = sizeof *addr; 1436 return 1; 1437 } 1438 case BTPROTO_RFCOMM: 1439 { 1440 struct sockaddr_rc *addr; 1441 char *straddr; 1442 1443 addr = (struct sockaddr_rc *)addr_ret; 1444 _BT_RC_MEMB(addr, family) = AF_BLUETOOTH; 1445 if (!PyArg_ParseTuple(args, "si", &straddr, 1446 &_BT_RC_MEMB(addr, channel))) { 1447 PyErr_SetString(socket_error, "getsockaddrarg: " 1448 "wrong format"); 1449 return 0; 1450 } 1451 if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0) 1452 return 0; 1453 1454 *len_ret = sizeof *addr; 1455 return 1; 1456 } 1457 case BTPROTO_HCI: 1458 { 1459 struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret; 1460#if defined(__NetBSD__) || defined(__DragonFly__) 1461 char *straddr = PyBytes_AS_STRING(args); 1462 1463 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH; 1464 if (straddr == NULL) { 1465 PyErr_SetString(socket_error, "getsockaddrarg: " 1466 "wrong format"); 1467 return 0; 1468 } 1469 if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0) 1470 return 0; 1471#else 1472 _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH; 1473 if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) { 1474 PyErr_SetString(socket_error, "getsockaddrarg: " 1475 "wrong format"); 1476 return 0; 1477 } 1478#endif 1479 *len_ret = sizeof *addr; 1480 return 1; 1481 } 1482#if !defined(__FreeBSD__) 1483 case BTPROTO_SCO: 1484 { 1485 struct sockaddr_sco *addr; 1486 char *straddr; 1487 1488 addr = (struct sockaddr_sco *)addr_ret; 1489 _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH; 1490 straddr = PyString_AsString(args); 1491 if (straddr == NULL) { 1492 PyErr_SetString(socket_error, "getsockaddrarg: " 1493 "wrong format"); 1494 return 0; 1495 } 1496 if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0) 1497 return 0; 1498 1499 *len_ret = sizeof *addr; 1500 return 1; 1501 } 1502#endif 1503 default: 1504 PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol"); 1505 return 0; 1506 } 1507 } 1508#endif 1509 1510#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX) 1511 case AF_PACKET: 1512 { 1513 struct sockaddr_ll* addr; 1514 struct ifreq ifr; 1515 char *interfaceName; 1516 int protoNumber; 1517 int hatype = 0; 1518 int pkttype = 0; 1519 char *haddr = NULL; 1520 unsigned int halen = 0; 1521 1522 if (!PyTuple_Check(args)) { 1523 PyErr_Format( 1524 PyExc_TypeError, 1525 "getsockaddrarg: " 1526 "AF_PACKET address must be tuple, not %.500s", 1527 Py_TYPE(args)->tp_name); 1528 return 0; 1529 } 1530 if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName, 1531 &protoNumber, &pkttype, &hatype, 1532 &haddr, &halen)) 1533 return 0; 1534 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name)); 1535 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0'; 1536 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) { 1537 s->errorhandler(); 1538 return 0; 1539 } 1540 if (halen > 8) { 1541 PyErr_SetString(PyExc_ValueError, 1542 "Hardware address must be 8 bytes or less"); 1543 return 0; 1544 } 1545 if (protoNumber < 0 || protoNumber > 0xffff) { 1546 PyErr_SetString( 1547 PyExc_OverflowError, 1548 "getsockaddrarg: protoNumber must be 0-65535."); 1549 return 0; 1550 } 1551 addr = (struct sockaddr_ll*)addr_ret; 1552 addr->sll_family = AF_PACKET; 1553 addr->sll_protocol = htons((short)protoNumber); 1554 addr->sll_ifindex = ifr.ifr_ifindex; 1555 addr->sll_pkttype = pkttype; 1556 addr->sll_hatype = hatype; 1557 if (halen != 0) { 1558 memcpy(&addr->sll_addr, haddr, halen); 1559 } 1560 addr->sll_halen = halen; 1561 *len_ret = sizeof *addr; 1562 return 1; 1563 } 1564#endif 1565 1566#ifdef HAVE_LINUX_TIPC_H 1567 case AF_TIPC: 1568 { 1569 unsigned int atype, v1, v2, v3; 1570 unsigned int scope = TIPC_CLUSTER_SCOPE; 1571 struct sockaddr_tipc *addr; 1572 1573 if (!PyTuple_Check(args)) { 1574 PyErr_Format( 1575 PyExc_TypeError, 1576 "getsockaddrarg: " 1577 "AF_TIPC address must be tuple, not %.500s", 1578 Py_TYPE(args)->tp_name); 1579 return 0; 1580 } 1581 1582 if (!PyArg_ParseTuple(args, 1583 "IIII|I;Invalid TIPC address format", 1584 &atype, &v1, &v2, &v3, &scope)) 1585 return 0; 1586 1587 addr = (struct sockaddr_tipc *) addr_ret; 1588 memset(addr, 0, sizeof(struct sockaddr_tipc)); 1589 1590 addr->family = AF_TIPC; 1591 addr->scope = scope; 1592 addr->addrtype = atype; 1593 1594 if (atype == TIPC_ADDR_NAMESEQ) { 1595 addr->addr.nameseq.type = v1; 1596 addr->addr.nameseq.lower = v2; 1597 addr->addr.nameseq.upper = v3; 1598 } else if (atype == TIPC_ADDR_NAME) { 1599 addr->addr.name.name.type = v1; 1600 addr->addr.name.name.instance = v2; 1601 } else if (atype == TIPC_ADDR_ID) { 1602 addr->addr.id.node = v1; 1603 addr->addr.id.ref = v2; 1604 } else { 1605 /* Shouldn't happen */ 1606 PyErr_SetString(PyExc_TypeError, "Invalid address type"); 1607 return 0; 1608 } 1609 1610 *len_ret = sizeof(*addr); 1611 1612 return 1; 1613 } 1614#endif 1615 1616 /* More cases here... */ 1617 1618 default: 1619 PyErr_SetString(socket_error, "getsockaddrarg: bad family"); 1620 return 0; 1621 1622 } 1623} 1624 1625 1626/* Get the address length according to the socket object's address family. 1627 Return 1 if the family is known, 0 otherwise. The length is returned 1628 through len_ret. */ 1629 1630static int 1631getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret) 1632{ 1633 switch (s->sock_family) { 1634 1635#if defined(AF_UNIX) 1636 case AF_UNIX: 1637 { 1638 *len_ret = sizeof (struct sockaddr_un); 1639 return 1; 1640 } 1641#endif /* AF_UNIX */ 1642 1643#if defined(AF_NETLINK) 1644 case AF_NETLINK: 1645 { 1646 *len_ret = sizeof (struct sockaddr_nl); 1647 return 1; 1648 } 1649#endif 1650 1651 case AF_INET: 1652 { 1653 *len_ret = sizeof (struct sockaddr_in); 1654 return 1; 1655 } 1656 1657#ifdef ENABLE_IPV6 1658 case AF_INET6: 1659 { 1660 *len_ret = sizeof (struct sockaddr_in6); 1661 return 1; 1662 } 1663#endif 1664 1665#ifdef USE_BLUETOOTH 1666 case AF_BLUETOOTH: 1667 { 1668 switch(s->sock_proto) 1669 { 1670 1671 case BTPROTO_L2CAP: 1672 *len_ret = sizeof (struct sockaddr_l2); 1673 return 1; 1674 case BTPROTO_RFCOMM: 1675 *len_ret = sizeof (struct sockaddr_rc); 1676 return 1; 1677 case BTPROTO_HCI: 1678 *len_ret = sizeof (struct sockaddr_hci); 1679 return 1; 1680#if !defined(__FreeBSD__) 1681 case BTPROTO_SCO: 1682 *len_ret = sizeof (struct sockaddr_sco); 1683 return 1; 1684#endif 1685 default: 1686 PyErr_SetString(socket_error, "getsockaddrlen: " 1687 "unknown BT protocol"); 1688 return 0; 1689 1690 } 1691 } 1692#endif 1693 1694#ifdef HAVE_NETPACKET_PACKET_H 1695 case AF_PACKET: 1696 { 1697 *len_ret = sizeof (struct sockaddr_ll); 1698 return 1; 1699 } 1700#endif 1701 1702#ifdef HAVE_LINUX_TIPC_H 1703 case AF_TIPC: 1704 { 1705 *len_ret = sizeof (struct sockaddr_tipc); 1706 return 1; 1707 } 1708#endif 1709 1710 /* More cases here... */ 1711 1712 default: 1713 PyErr_SetString(socket_error, "getsockaddrlen: bad family"); 1714 return 0; 1715 1716 } 1717} 1718 1719 1720/* s.accept() method */ 1721 1722static PyObject * 1723sock_accept(PySocketSockObject *s) 1724{ 1725 sock_addr_t addrbuf; 1726 SOCKET_T newfd; 1727 socklen_t addrlen; 1728 PyObject *sock = NULL; 1729 PyObject *addr = NULL; 1730 PyObject *res = NULL; 1731 int timeout; 1732 1733 if (!getsockaddrlen(s, &addrlen)) 1734 return NULL; 1735 memset(&addrbuf, 0, addrlen); 1736 1737 newfd = INVALID_SOCKET; 1738 1739 if (!IS_SELECTABLE(s)) 1740 return select_error(); 1741 1742 BEGIN_SELECT_LOOP(s) 1743 Py_BEGIN_ALLOW_THREADS 1744 timeout = internal_select_ex(s, 0, interval); 1745 if (!timeout) 1746 newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen); 1747 Py_END_ALLOW_THREADS 1748 1749 if (timeout == 1) { 1750 PyErr_SetString(socket_timeout, "timed out"); 1751 return NULL; 1752 } 1753 END_SELECT_LOOP(s) 1754 1755 if (newfd == INVALID_SOCKET) 1756 return s->errorhandler(); 1757 1758 /* Create the new object with unspecified family, 1759 to avoid calls to bind() etc. on it. */ 1760 sock = (PyObject *) new_sockobject(newfd, 1761 s->sock_family, 1762 s->sock_type, 1763 s->sock_proto); 1764 1765 if (sock == NULL) { 1766 SOCKETCLOSE(newfd); 1767 goto finally; 1768 } 1769 addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf), 1770 addrlen, s->sock_proto); 1771 if (addr == NULL) 1772 goto finally; 1773 1774 res = PyTuple_Pack(2, sock, addr); 1775 1776finally: 1777 Py_XDECREF(sock); 1778 Py_XDECREF(addr); 1779 return res; 1780} 1781 1782PyDoc_STRVAR(accept_doc, 1783"accept() -> (socket object, address info)\n\ 1784\n\ 1785Wait for an incoming connection. Return a new socket representing the\n\ 1786connection, and the address of the client. For IP sockets, the address\n\ 1787info is a pair (hostaddr, port)."); 1788 1789/* s.setblocking(flag) method. Argument: 1790 False -- non-blocking mode; same as settimeout(0) 1791 True -- blocking mode; same as settimeout(None) 1792*/ 1793 1794static PyObject * 1795sock_setblocking(PySocketSockObject *s, PyObject *arg) 1796{ 1797 long block; 1798 1799 block = PyInt_AsLong(arg); 1800 if (block == -1 && PyErr_Occurred()) 1801 return NULL; 1802 1803 s->sock_timeout = block ? -1.0 : 0.0; 1804 internal_setblocking(s, block); 1805 1806 Py_INCREF(Py_None); 1807 return Py_None; 1808} 1809 1810PyDoc_STRVAR(setblocking_doc, 1811"setblocking(flag)\n\ 1812\n\ 1813Set the socket to blocking (flag is true) or non-blocking (false).\n\ 1814setblocking(True) is equivalent to settimeout(None);\n\ 1815setblocking(False) is equivalent to settimeout(0.0)."); 1816 1817/* s.settimeout(timeout) method. Argument: 1818 None -- no timeout, blocking mode; same as setblocking(True) 1819 0.0 -- non-blocking mode; same as setblocking(False) 1820 > 0 -- timeout mode; operations time out after timeout seconds 1821 < 0 -- illegal; raises an exception 1822*/ 1823static PyObject * 1824sock_settimeout(PySocketSockObject *s, PyObject *arg) 1825{ 1826 double timeout; 1827 1828 if (arg == Py_None) 1829 timeout = -1.0; 1830 else { 1831 timeout = PyFloat_AsDouble(arg); 1832 if (timeout < 0.0) { 1833 if (!PyErr_Occurred()) 1834 PyErr_SetString(PyExc_ValueError, 1835 "Timeout value out of range"); 1836 return NULL; 1837 } 1838 } 1839 1840 s->sock_timeout = timeout; 1841 internal_setblocking(s, timeout < 0.0); 1842 1843 Py_INCREF(Py_None); 1844 return Py_None; 1845} 1846 1847PyDoc_STRVAR(settimeout_doc, 1848"settimeout(timeout)\n\ 1849\n\ 1850Set a timeout on socket operations. 'timeout' can be a float,\n\ 1851giving in seconds, or None. Setting a timeout of None disables\n\ 1852the timeout feature and is equivalent to setblocking(1).\n\ 1853Setting a timeout of zero is the same as setblocking(0)."); 1854 1855/* s.gettimeout() method. 1856 Returns the timeout associated with a socket. */ 1857static PyObject * 1858sock_gettimeout(PySocketSockObject *s) 1859{ 1860 if (s->sock_timeout < 0.0) { 1861 Py_INCREF(Py_None); 1862 return Py_None; 1863 } 1864 else 1865 return PyFloat_FromDouble(s->sock_timeout); 1866} 1867 1868PyDoc_STRVAR(gettimeout_doc, 1869"gettimeout() -> timeout\n\ 1870\n\ 1871Returns the timeout in seconds (float) associated with socket \n\ 1872operations. A timeout of None indicates that timeouts on socket \n\ 1873operations are disabled."); 1874 1875#ifdef RISCOS 1876/* s.sleeptaskw(1 | 0) method */ 1877 1878static PyObject * 1879sock_sleeptaskw(PySocketSockObject *s,PyObject *arg) 1880{ 1881 int block; 1882 block = PyInt_AsLong(arg); 1883 if (block == -1 && PyErr_Occurred()) 1884 return NULL; 1885 Py_BEGIN_ALLOW_THREADS 1886 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); 1887 Py_END_ALLOW_THREADS 1888 1889 Py_INCREF(Py_None); 1890 return Py_None; 1891} 1892PyDoc_STRVAR(sleeptaskw_doc, 1893"sleeptaskw(flag)\n\ 1894\n\ 1895Allow sleeps in taskwindows."); 1896#endif 1897 1898 1899/* s.setsockopt() method. 1900 With an integer third argument, sets an integer option. 1901 With a string third argument, sets an option from a buffer; 1902 use optional built-in module 'struct' to encode the string. */ 1903 1904static PyObject * 1905sock_setsockopt(PySocketSockObject *s, PyObject *args) 1906{ 1907 int level; 1908 int optname; 1909 int res; 1910 char *buf; 1911 int buflen; 1912 int flag; 1913 1914 if (PyArg_ParseTuple(args, "iii:setsockopt", 1915 &level, &optname, &flag)) { 1916 buf = (char *) &flag; 1917 buflen = sizeof flag; 1918 } 1919 else { 1920 PyErr_Clear(); 1921 if (!PyArg_ParseTuple(args, "iis#:setsockopt", 1922 &level, &optname, &buf, &buflen)) 1923 return NULL; 1924 } 1925 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen); 1926 if (res < 0) 1927 return s->errorhandler(); 1928 Py_INCREF(Py_None); 1929 return Py_None; 1930} 1931 1932PyDoc_STRVAR(setsockopt_doc, 1933"setsockopt(level, option, value)\n\ 1934\n\ 1935Set a socket option. See the Unix manual for level and option.\n\ 1936The value argument can either be an integer or a string."); 1937 1938 1939/* s.getsockopt() method. 1940 With two arguments, retrieves an integer option. 1941 With a third integer argument, retrieves a string buffer of that size; 1942 use optional built-in module 'struct' to decode the string. */ 1943 1944static PyObject * 1945sock_getsockopt(PySocketSockObject *s, PyObject *args) 1946{ 1947 int level; 1948 int optname; 1949 int res; 1950 PyObject *buf; 1951 socklen_t buflen = 0; 1952 1953#ifdef __BEOS__ 1954 /* We have incomplete socket support. */ 1955 PyErr_SetString(socket_error, "getsockopt not supported"); 1956 return NULL; 1957#else 1958 1959 if (!PyArg_ParseTuple(args, "ii|i:getsockopt", 1960 &level, &optname, &buflen)) 1961 return NULL; 1962 1963 if (buflen == 0) { 1964 int flag = 0; 1965 socklen_t flagsize = sizeof flag; 1966 res = getsockopt(s->sock_fd, level, optname, 1967 (void *)&flag, &flagsize); 1968 if (res < 0) 1969 return s->errorhandler(); 1970 return PyInt_FromLong(flag); 1971 } 1972#ifdef __VMS 1973 /* socklen_t is unsigned so no negative test is needed, 1974 test buflen == 0 is previously done */ 1975 if (buflen > 1024) { 1976#else 1977 if (buflen <= 0 || buflen > 1024) { 1978#endif 1979 PyErr_SetString(socket_error, 1980 "getsockopt buflen out of range"); 1981 return NULL; 1982 } 1983 buf = PyString_FromStringAndSize((char *)NULL, buflen); 1984 if (buf == NULL) 1985 return NULL; 1986 res = getsockopt(s->sock_fd, level, optname, 1987 (void *)PyString_AS_STRING(buf), &buflen); 1988 if (res < 0) { 1989 Py_DECREF(buf); 1990 return s->errorhandler(); 1991 } 1992 _PyString_Resize(&buf, buflen); 1993 return buf; 1994#endif /* __BEOS__ */ 1995} 1996 1997PyDoc_STRVAR(getsockopt_doc, 1998"getsockopt(level, option[, buffersize]) -> value\n\ 1999\n\ 2000Get a socket option. See the Unix manual for level and option.\n\ 2001If a nonzero buffersize argument is given, the return value is a\n\ 2002string of that length; otherwise it is an integer."); 2003 2004 2005/* s.bind(sockaddr) method */ 2006 2007static PyObject * 2008sock_bind(PySocketSockObject *s, PyObject *addro) 2009{ 2010 sock_addr_t addrbuf; 2011 int addrlen; 2012 int res; 2013 2014 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) 2015 return NULL; 2016 Py_BEGIN_ALLOW_THREADS 2017 res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen); 2018 Py_END_ALLOW_THREADS 2019 if (res < 0) 2020 return s->errorhandler(); 2021 Py_INCREF(Py_None); 2022 return Py_None; 2023} 2024 2025PyDoc_STRVAR(bind_doc, 2026"bind(address)\n\ 2027\n\ 2028Bind the socket to a local address. For IP sockets, the address is a\n\ 2029pair (host, port); the host must refer to the local host. For raw packet\n\ 2030sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])"); 2031 2032 2033/* s.close() method. 2034 Set the file descriptor to -1 so operations tried subsequently 2035 will surely fail. */ 2036 2037static PyObject * 2038sock_close(PySocketSockObject *s) 2039{ 2040 SOCKET_T fd; 2041 2042 if ((fd = s->sock_fd) != -1) { 2043 s->sock_fd = -1; 2044 Py_BEGIN_ALLOW_THREADS 2045 (void) SOCKETCLOSE(fd); 2046 Py_END_ALLOW_THREADS 2047 } 2048 Py_INCREF(Py_None); 2049 return Py_None; 2050} 2051 2052PyDoc_STRVAR(close_doc, 2053"close()\n\ 2054\n\ 2055Close the socket. It cannot be used after this call."); 2056 2057static int 2058internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen, 2059 int *timeoutp) 2060{ 2061 int res, timeout; 2062 2063 timeout = 0; 2064 res = connect(s->sock_fd, addr, addrlen); 2065 2066#ifdef MS_WINDOWS 2067 2068 if (s->sock_timeout > 0.0) { 2069 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK && 2070 IS_SELECTABLE(s)) { 2071 /* This is a mess. Best solution: trust select */ 2072 fd_set fds; 2073 fd_set fds_exc; 2074 struct timeval tv; 2075 tv.tv_sec = (int)s->sock_timeout; 2076 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6); 2077 FD_ZERO(&fds); 2078 FD_SET(s->sock_fd, &fds); 2079 FD_ZERO(&fds_exc); 2080 FD_SET(s->sock_fd, &fds_exc); 2081 res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv); 2082 if (res == 0) { 2083 res = WSAEWOULDBLOCK; 2084 timeout = 1; 2085 } else if (res > 0) { 2086 if (FD_ISSET(s->sock_fd, &fds)) 2087 /* The socket is in the writeable set - this 2088 means connected */ 2089 res = 0; 2090 else { 2091 /* As per MS docs, we need to call getsockopt() 2092 to get the underlying error */ 2093 int res_size = sizeof res; 2094 /* It must be in the exception set */ 2095 assert(FD_ISSET(s->sock_fd, &fds_exc)); 2096 if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR, 2097 (char *)&res, &res_size)) 2098 /* getsockopt also clears WSAGetLastError, 2099 so reset it back. */ 2100 WSASetLastError(res); 2101 else 2102 res = WSAGetLastError(); 2103 } 2104 } 2105 /* else if (res < 0) an error occurred */ 2106 } 2107 } 2108 2109 if (res < 0) 2110 res = WSAGetLastError(); 2111 2112#else 2113 2114 if (s->sock_timeout > 0.0) { 2115 if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) { 2116 timeout = internal_select(s, 1); 2117 if (timeout == 0) { 2118 /* Bug #1019808: in case of an EINPROGRESS, 2119 use getsockopt(SO_ERROR) to get the real 2120 error. */ 2121 socklen_t res_size = sizeof res; 2122 (void)getsockopt(s->sock_fd, SOL_SOCKET, 2123 SO_ERROR, &res, &res_size); 2124 if (res == EISCONN) 2125 res = 0; 2126 errno = res; 2127 } 2128 else if (timeout == -1) { 2129 res = errno; /* had error */ 2130 } 2131 else 2132 res = EWOULDBLOCK; /* timed out */ 2133 } 2134 } 2135 2136 if (res < 0) 2137 res = errno; 2138 2139#endif 2140 *timeoutp = timeout; 2141 2142 return res; 2143} 2144 2145/* s.connect(sockaddr) method */ 2146 2147static PyObject * 2148sock_connect(PySocketSockObject *s, PyObject *addro) 2149{ 2150 sock_addr_t addrbuf; 2151 int addrlen; 2152 int res; 2153 int timeout; 2154 2155 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) 2156 return NULL; 2157 2158 Py_BEGIN_ALLOW_THREADS 2159 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout); 2160 Py_END_ALLOW_THREADS 2161 2162 if (timeout == 1) { 2163 PyErr_SetString(socket_timeout, "timed out"); 2164 return NULL; 2165 } 2166 if (res != 0) 2167 return s->errorhandler(); 2168 Py_INCREF(Py_None); 2169 return Py_None; 2170} 2171 2172PyDoc_STRVAR(connect_doc, 2173"connect(address)\n\ 2174\n\ 2175Connect the socket to a remote address. For IP sockets, the address\n\ 2176is a pair (host, port)."); 2177 2178 2179/* s.connect_ex(sockaddr) method */ 2180 2181static PyObject * 2182sock_connect_ex(PySocketSockObject *s, PyObject *addro) 2183{ 2184 sock_addr_t addrbuf; 2185 int addrlen; 2186 int res; 2187 int timeout; 2188 2189 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) 2190 return NULL; 2191 2192 Py_BEGIN_ALLOW_THREADS 2193 res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout); 2194 Py_END_ALLOW_THREADS 2195 2196 /* Signals are not errors (though they may raise exceptions). Adapted 2197 from PyErr_SetFromErrnoWithFilenameObject(). */ 2198#ifdef EINTR 2199 if (res == EINTR && PyErr_CheckSignals()) 2200 return NULL; 2201#endif 2202 2203 return PyInt_FromLong((long) res); 2204} 2205 2206PyDoc_STRVAR(connect_ex_doc, 2207"connect_ex(address) -> errno\n\ 2208\n\ 2209This is like connect(address), but returns an error code (the errno value)\n\ 2210instead of raising an exception when an error occurs."); 2211 2212 2213/* s.fileno() method */ 2214 2215static PyObject * 2216sock_fileno(PySocketSockObject *s) 2217{ 2218#if SIZEOF_SOCKET_T <= SIZEOF_LONG 2219 return PyInt_FromLong((long) s->sock_fd); 2220#else 2221 return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd); 2222#endif 2223} 2224 2225PyDoc_STRVAR(fileno_doc, 2226"fileno() -> integer\n\ 2227\n\ 2228Return the integer file descriptor of the socket."); 2229 2230 2231#ifndef NO_DUP 2232/* s.dup() method */ 2233 2234static PyObject * 2235sock_dup(PySocketSockObject *s) 2236{ 2237 SOCKET_T newfd; 2238 PyObject *sock; 2239 2240 newfd = dup(s->sock_fd); 2241 if (newfd < 0) 2242 return s->errorhandler(); 2243 sock = (PyObject *) new_sockobject(newfd, 2244 s->sock_family, 2245 s->sock_type, 2246 s->sock_proto); 2247 if (sock == NULL) 2248 SOCKETCLOSE(newfd); 2249 return sock; 2250} 2251 2252PyDoc_STRVAR(dup_doc, 2253"dup() -> socket object\n\ 2254\n\ 2255Return a new socket object connected to the same system resource."); 2256 2257#endif 2258 2259 2260/* s.getsockname() method */ 2261 2262static PyObject * 2263sock_getsockname(PySocketSockObject *s) 2264{ 2265 sock_addr_t addrbuf; 2266 int res; 2267 socklen_t addrlen; 2268 2269 if (!getsockaddrlen(s, &addrlen)) 2270 return NULL; 2271 memset(&addrbuf, 0, addrlen); 2272 Py_BEGIN_ALLOW_THREADS 2273 res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen); 2274 Py_END_ALLOW_THREADS 2275 if (res < 0) 2276 return s->errorhandler(); 2277 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen, 2278 s->sock_proto); 2279} 2280 2281PyDoc_STRVAR(getsockname_doc, 2282"getsockname() -> address info\n\ 2283\n\ 2284Return the address of the local endpoint. For IP sockets, the address\n\ 2285info is a pair (hostaddr, port)."); 2286 2287 2288#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */ 2289/* s.getpeername() method */ 2290 2291static PyObject * 2292sock_getpeername(PySocketSockObject *s) 2293{ 2294 sock_addr_t addrbuf; 2295 int res; 2296 socklen_t addrlen; 2297 2298 if (!getsockaddrlen(s, &addrlen)) 2299 return NULL; 2300 memset(&addrbuf, 0, addrlen); 2301 Py_BEGIN_ALLOW_THREADS 2302 res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen); 2303 Py_END_ALLOW_THREADS 2304 if (res < 0) 2305 return s->errorhandler(); 2306 return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen, 2307 s->sock_proto); 2308} 2309 2310PyDoc_STRVAR(getpeername_doc, 2311"getpeername() -> address info\n\ 2312\n\ 2313Return the address of the remote endpoint. For IP sockets, the address\n\ 2314info is a pair (hostaddr, port)."); 2315 2316#endif /* HAVE_GETPEERNAME */ 2317 2318 2319/* s.listen(n) method */ 2320 2321static PyObject * 2322sock_listen(PySocketSockObject *s, PyObject *arg) 2323{ 2324 int backlog; 2325 int res; 2326 2327 backlog = _PyInt_AsInt(arg); 2328 if (backlog == -1 && PyErr_Occurred()) 2329 return NULL; 2330 Py_BEGIN_ALLOW_THREADS 2331 /* To avoid problems on systems that don't allow a negative backlog 2332 * (which doesn't make sense anyway) we force a minimum value of 0. */ 2333 if (backlog < 0) 2334 backlog = 0; 2335 res = listen(s->sock_fd, backlog); 2336 Py_END_ALLOW_THREADS 2337 if (res < 0) 2338 return s->errorhandler(); 2339 Py_INCREF(Py_None); 2340 return Py_None; 2341} 2342 2343PyDoc_STRVAR(listen_doc, 2344"listen(backlog)\n\ 2345\n\ 2346Enable a server to accept connections. The backlog argument must be at\n\ 2347least 0 (if it is lower, it is set to 0); it specifies the number of\n\ 2348unaccepted connections that the system will allow before refusing new\n\ 2349connections."); 2350 2351 2352#ifndef NO_DUP 2353/* s.makefile(mode) method. 2354 Create a new open file object referring to a dupped version of 2355 the socket's file descriptor. (The dup() call is necessary so 2356 that the open file and socket objects may be closed independent 2357 of each other.) 2358 The mode argument specifies 'r' or 'w' passed to fdopen(). */ 2359 2360static PyObject * 2361sock_makefile(PySocketSockObject *s, PyObject *args) 2362{ 2363 extern int fclose(FILE *); 2364 char *mode = "r"; 2365 int bufsize = -1; 2366#ifdef MS_WIN32 2367 Py_intptr_t fd; 2368#else 2369 int fd; 2370#endif 2371 FILE *fp; 2372 PyObject *f; 2373#ifdef __VMS 2374 char *mode_r = "r"; 2375 char *mode_w = "w"; 2376#endif 2377 2378 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize)) 2379 return NULL; 2380#ifdef __VMS 2381 if (strcmp(mode,"rb") == 0) { 2382 mode = mode_r; 2383 } 2384 else { 2385 if (strcmp(mode,"wb") == 0) { 2386 mode = mode_w; 2387 } 2388 } 2389#endif 2390#ifdef MS_WIN32 2391 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) || 2392 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL)) 2393#else 2394 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL) 2395#endif 2396 { 2397 if (fd >= 0) 2398 SOCKETCLOSE(fd); 2399 return s->errorhandler(); 2400 } 2401 f = PyFile_FromFile(fp, "<socket>", mode, fclose); 2402 if (f != NULL) 2403 PyFile_SetBufSize(f, bufsize); 2404 return f; 2405} 2406 2407PyDoc_STRVAR(makefile_doc, 2408"makefile([mode[, buffersize]]) -> file object\n\ 2409\n\ 2410Return a regular file object corresponding to the socket.\n\ 2411The mode and buffersize arguments are as for the built-in open() function."); 2412 2413#endif /* NO_DUP */ 2414 2415/* 2416 * This is the guts of the recv() and recv_into() methods, which reads into a 2417 * char buffer. If you have any inc/dec ref to do to the objects that contain 2418 * the buffer, do it in the caller. This function returns the number of bytes 2419 * successfully read. If there was an error, it returns -1. Note that it is 2420 * also possible that we return a number of bytes smaller than the request 2421 * bytes. 2422 */ 2423static ssize_t 2424sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags) 2425{ 2426 ssize_t outlen = -1; 2427 int timeout; 2428#ifdef __VMS 2429 int remaining; 2430 char *read_buf; 2431#endif 2432 2433 if (!IS_SELECTABLE(s)) { 2434 select_error(); 2435 return -1; 2436 } 2437 2438#ifndef __VMS 2439 BEGIN_SELECT_LOOP(s) 2440 Py_BEGIN_ALLOW_THREADS 2441 timeout = internal_select_ex(s, 0, interval); 2442 if (!timeout) 2443 outlen = recv(s->sock_fd, cbuf, len, flags); 2444 Py_END_ALLOW_THREADS 2445 2446 if (timeout == 1) { 2447 PyErr_SetString(socket_timeout, "timed out"); 2448 return -1; 2449 } 2450 END_SELECT_LOOP(s) 2451 if (outlen < 0) { 2452 /* Note: the call to errorhandler() ALWAYS indirectly returned 2453 NULL, so ignore its return value */ 2454 s->errorhandler(); 2455 return -1; 2456 } 2457#else 2458 read_buf = cbuf; 2459 remaining = len; 2460 while (remaining != 0) { 2461 unsigned int segment; 2462 int nread = -1; 2463 2464 segment = remaining /SEGMENT_SIZE; 2465 if (segment != 0) { 2466 segment = SEGMENT_SIZE; 2467 } 2468 else { 2469 segment = remaining; 2470 } 2471 2472 BEGIN_SELECT_LOOP(s) 2473 Py_BEGIN_ALLOW_THREADS 2474 timeout = internal_select_ex(s, 0, interval); 2475 if (!timeout) 2476 nread = recv(s->sock_fd, read_buf, segment, flags); 2477 Py_END_ALLOW_THREADS 2478 2479 if (timeout == 1) { 2480 PyErr_SetString(socket_timeout, "timed out"); 2481 return -1; 2482 } 2483 END_SELECT_LOOP(s) 2484 2485 if (nread < 0) { 2486 s->errorhandler(); 2487 return -1; 2488 } 2489 if (nread != remaining) { 2490 read_buf += nread; 2491 break; 2492 } 2493 2494 remaining -= segment; 2495 read_buf += segment; 2496 } 2497 outlen = read_buf - cbuf; 2498#endif /* !__VMS */ 2499 2500 return outlen; 2501} 2502 2503 2504/* s.recv(nbytes [,flags]) method */ 2505 2506static PyObject * 2507sock_recv(PySocketSockObject *s, PyObject *args) 2508{ 2509 int recvlen, flags = 0; 2510 ssize_t outlen; 2511 PyObject *buf; 2512 2513 if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags)) 2514 return NULL; 2515 2516 if (recvlen < 0) { 2517 PyErr_SetString(PyExc_ValueError, 2518 "negative buffersize in recv"); 2519 return NULL; 2520 } 2521 2522 /* Allocate a new string. */ 2523 buf = PyString_FromStringAndSize((char *) 0, recvlen); 2524 if (buf == NULL) 2525 return NULL; 2526 2527 /* Call the guts */ 2528 outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags); 2529 if (outlen < 0) { 2530 /* An error occurred, release the string and return an 2531 error. */ 2532 Py_DECREF(buf); 2533 return NULL; 2534 } 2535 if (outlen != recvlen) { 2536 /* We did not read as many bytes as we anticipated, resize the 2537 string if possible and be successful. */ 2538 if (_PyString_Resize(&buf, outlen) < 0) 2539 /* Oopsy, not so successful after all. */ 2540 return NULL; 2541 } 2542 2543 return buf; 2544} 2545 2546PyDoc_STRVAR(recv_doc, 2547"recv(buffersize[, flags]) -> data\n\ 2548\n\ 2549Receive up to buffersize bytes from the socket. For the optional flags\n\ 2550argument, see the Unix manual. When no data is available, block until\n\ 2551at least one byte is available or until the remote end is closed. When\n\ 2552the remote end is closed and all data is read, return the empty string."); 2553 2554 2555/* s.recv_into(buffer, [nbytes [,flags]]) method */ 2556 2557static PyObject* 2558sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds) 2559{ 2560 static char *kwlist[] = {"buffer", "nbytes", "flags", 0}; 2561 2562 int recvlen = 0, flags = 0; 2563 ssize_t readlen; 2564 Py_buffer buf; 2565 Py_ssize_t buflen; 2566 2567 /* Get the buffer's memory */ 2568 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist, 2569 &buf, &recvlen, &flags)) 2570 return NULL; 2571 buflen = buf.len; 2572 assert(buf.buf != 0 && buflen > 0); 2573 2574 if (recvlen < 0) { 2575 PyErr_SetString(PyExc_ValueError, 2576 "negative buffersize in recv_into"); 2577 goto error; 2578 } 2579 if (recvlen == 0) { 2580 /* If nbytes was not specified, use the buffer's length */ 2581 recvlen = buflen; 2582 } 2583 2584 /* Check if the buffer is large enough */ 2585 if (buflen < recvlen) { 2586 PyErr_SetString(PyExc_ValueError, 2587 "buffer too small for requested bytes"); 2588 goto error; 2589 } 2590 2591 /* Call the guts */ 2592 readlen = sock_recv_guts(s, buf.buf, recvlen, flags); 2593 if (readlen < 0) { 2594 /* Return an error. */ 2595 goto error; 2596 } 2597 2598 PyBuffer_Release(&buf); 2599 /* Return the number of bytes read. Note that we do not do anything 2600 special here in the case that readlen < recvlen. */ 2601 return PyInt_FromSsize_t(readlen); 2602 2603error: 2604 PyBuffer_Release(&buf); 2605 return NULL; 2606} 2607 2608PyDoc_STRVAR(recv_into_doc, 2609"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\ 2610\n\ 2611A version of recv() that stores its data into a buffer rather than creating \n\ 2612a new string. Receive up to buffersize bytes from the socket. If buffersize \n\ 2613is not specified (or 0), receive up to the size available in the given buffer.\n\ 2614\n\ 2615See recv() for documentation about the flags."); 2616 2617 2618/* 2619 * This is the guts of the recvfrom() and recvfrom_into() methods, which reads 2620 * into a char buffer. If you have any inc/def ref to do to the objects that 2621 * contain the buffer, do it in the caller. This function returns the number 2622 * of bytes successfully read. If there was an error, it returns -1. Note 2623 * that it is also possible that we return a number of bytes smaller than the 2624 * request bytes. 2625 * 2626 * 'addr' is a return value for the address object. Note that you must decref 2627 * it yourself. 2628 */ 2629static ssize_t 2630sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags, 2631 PyObject** addr) 2632{ 2633 sock_addr_t addrbuf; 2634 int timeout; 2635 ssize_t n = -1; 2636 socklen_t addrlen; 2637 2638 *addr = NULL; 2639 2640 if (!getsockaddrlen(s, &addrlen)) 2641 return -1; 2642 2643 if (!IS_SELECTABLE(s)) { 2644 select_error(); 2645 return -1; 2646 } 2647 2648 BEGIN_SELECT_LOOP(s) 2649 Py_BEGIN_ALLOW_THREADS 2650 memset(&addrbuf, 0, addrlen); 2651 timeout = internal_select_ex(s, 0, interval); 2652 if (!timeout) { 2653#ifndef MS_WINDOWS 2654#if defined(PYOS_OS2) && !defined(PYCC_GCC) 2655 n = recvfrom(s->sock_fd, cbuf, len, flags, 2656 SAS2SA(&addrbuf), &addrlen); 2657#else 2658 n = recvfrom(s->sock_fd, cbuf, len, flags, 2659 (void *) &addrbuf, &addrlen); 2660#endif 2661#else 2662 n = recvfrom(s->sock_fd, cbuf, len, flags, 2663 SAS2SA(&addrbuf), &addrlen); 2664#endif 2665 } 2666 Py_END_ALLOW_THREADS 2667 2668 if (timeout == 1) { 2669 PyErr_SetString(socket_timeout, "timed out"); 2670 return -1; 2671 } 2672 END_SELECT_LOOP(s) 2673 if (n < 0) { 2674 s->errorhandler(); 2675 return -1; 2676 } 2677 2678 if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf), 2679 addrlen, s->sock_proto))) 2680 return -1; 2681 2682 return n; 2683} 2684 2685/* s.recvfrom(nbytes [,flags]) method */ 2686 2687static PyObject * 2688sock_recvfrom(PySocketSockObject *s, PyObject *args) 2689{ 2690 PyObject *buf = NULL; 2691 PyObject *addr = NULL; 2692 PyObject *ret = NULL; 2693 int recvlen, flags = 0; 2694 ssize_t outlen; 2695 2696 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags)) 2697 return NULL; 2698 2699 if (recvlen < 0) { 2700 PyErr_SetString(PyExc_ValueError, 2701 "negative buffersize in recvfrom"); 2702 return NULL; 2703 } 2704 2705 buf = PyString_FromStringAndSize((char *) 0, recvlen); 2706 if (buf == NULL) 2707 return NULL; 2708 2709 outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf), 2710 recvlen, flags, &addr); 2711 if (outlen < 0) { 2712 goto finally; 2713 } 2714 2715 if (outlen != recvlen) { 2716 /* We did not read as many bytes as we anticipated, resize the 2717 string if possible and be successful. */ 2718 if (_PyString_Resize(&buf, outlen) < 0) 2719 /* Oopsy, not so successful after all. */ 2720 goto finally; 2721 } 2722 2723 ret = PyTuple_Pack(2, buf, addr); 2724 2725finally: 2726 Py_XDECREF(buf); 2727 Py_XDECREF(addr); 2728 return ret; 2729} 2730 2731PyDoc_STRVAR(recvfrom_doc, 2732"recvfrom(buffersize[, flags]) -> (data, address info)\n\ 2733\n\ 2734Like recv(buffersize, flags) but also return the sender's address info."); 2735 2736 2737/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */ 2738 2739static PyObject * 2740sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds) 2741{ 2742 static char *kwlist[] = {"buffer", "nbytes", "flags", 0}; 2743 2744 int recvlen = 0, flags = 0; 2745 ssize_t readlen; 2746 Py_buffer buf; 2747 int buflen; 2748 2749 PyObject *addr = NULL; 2750 2751 if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into", 2752 kwlist, &buf, 2753 &recvlen, &flags)) 2754 return NULL; 2755 buflen = buf.len; 2756 2757 if (recvlen < 0) { 2758 PyErr_SetString(PyExc_ValueError, 2759 "negative buffersize in recvfrom_into"); 2760 goto error; 2761 } 2762 if (recvlen == 0) { 2763 /* If nbytes was not specified, use the buffer's length */ 2764 recvlen = buflen; 2765 } else if (recvlen > buflen) { 2766 PyErr_SetString(PyExc_ValueError, 2767 "nbytes is greater than the length of the buffer"); 2768 goto error; 2769 } 2770 2771 readlen = sock_recvfrom_guts(s, buf.buf, recvlen, flags, &addr); 2772 if (readlen < 0) { 2773 /* Return an error */ 2774 goto error; 2775 } 2776 2777 PyBuffer_Release(&buf); 2778 /* Return the number of bytes read and the address. Note that we do 2779 not do anything special here in the case that readlen < recvlen. */ 2780 return Py_BuildValue("lN", readlen, addr); 2781 2782error: 2783 Py_XDECREF(addr); 2784 PyBuffer_Release(&buf); 2785 return NULL; 2786} 2787 2788PyDoc_STRVAR(recvfrom_into_doc, 2789"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\ 2790\n\ 2791Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info."); 2792 2793 2794/* s.send(data [,flags]) method */ 2795 2796static PyObject * 2797sock_send(PySocketSockObject *s, PyObject *args) 2798{ 2799 char *buf; 2800 int len, n = -1, flags = 0, timeout; 2801 Py_buffer pbuf; 2802 2803 if (!PyArg_ParseTuple(args, "s*|i:send", &pbuf, &flags)) 2804 return NULL; 2805 2806 if (!IS_SELECTABLE(s)) { 2807 PyBuffer_Release(&pbuf); 2808 return select_error(); 2809 } 2810 buf = pbuf.buf; 2811 len = pbuf.len; 2812 2813 BEGIN_SELECT_LOOP(s) 2814 Py_BEGIN_ALLOW_THREADS 2815 timeout = internal_select_ex(s, 1, interval); 2816 if (!timeout) 2817#ifdef __VMS 2818 n = sendsegmented(s->sock_fd, buf, len, flags); 2819#else 2820 n = send(s->sock_fd, buf, len, flags); 2821#endif 2822 Py_END_ALLOW_THREADS 2823 if (timeout == 1) { 2824 PyBuffer_Release(&pbuf); 2825 PyErr_SetString(socket_timeout, "timed out"); 2826 return NULL; 2827 } 2828 END_SELECT_LOOP(s) 2829 2830 PyBuffer_Release(&pbuf); 2831 if (n < 0) 2832 return s->errorhandler(); 2833 return PyInt_FromLong((long)n); 2834} 2835 2836PyDoc_STRVAR(send_doc, 2837"send(data[, flags]) -> count\n\ 2838\n\ 2839Send a data string to the socket. For the optional flags\n\ 2840argument, see the Unix manual. Return the number of bytes\n\ 2841sent; this may be less than len(data) if the network is busy."); 2842 2843 2844/* s.sendall(data [,flags]) method */ 2845 2846static PyObject * 2847sock_sendall(PySocketSockObject *s, PyObject *args) 2848{ 2849 char *buf; 2850 int len, n = -1, flags = 0, timeout, saved_errno; 2851 Py_buffer pbuf; 2852 2853 if (!PyArg_ParseTuple(args, "s*|i:sendall", &pbuf, &flags)) 2854 return NULL; 2855 buf = pbuf.buf; 2856 len = pbuf.len; 2857 2858 if (!IS_SELECTABLE(s)) { 2859 PyBuffer_Release(&pbuf); 2860 return select_error(); 2861 } 2862 2863 do { 2864 BEGIN_SELECT_LOOP(s) 2865 Py_BEGIN_ALLOW_THREADS 2866 timeout = internal_select_ex(s, 1, interval); 2867 n = -1; 2868 if (!timeout) { 2869#ifdef __VMS 2870 n = sendsegmented(s->sock_fd, buf, len, flags); 2871#else 2872 n = send(s->sock_fd, buf, len, flags); 2873#endif 2874 } 2875 Py_END_ALLOW_THREADS 2876 if (timeout == 1) { 2877 PyBuffer_Release(&pbuf); 2878 PyErr_SetString(socket_timeout, "timed out"); 2879 return NULL; 2880 } 2881 END_SELECT_LOOP(s) 2882 /* PyErr_CheckSignals() might change errno */ 2883 saved_errno = errno; 2884 /* We must run our signal handlers before looping again. 2885 send() can return a successful partial write when it is 2886 interrupted, so we can't restrict ourselves to EINTR. */ 2887 if (PyErr_CheckSignals()) { 2888 PyBuffer_Release(&pbuf); 2889 return NULL; 2890 } 2891 if (n < 0) { 2892 /* If interrupted, try again */ 2893 if (saved_errno == EINTR) 2894 continue; 2895 else 2896 break; 2897 } 2898 buf += n; 2899 len -= n; 2900 } while (len > 0); 2901 PyBuffer_Release(&pbuf); 2902 2903 if (n < 0) 2904 return s->errorhandler(); 2905 2906 Py_INCREF(Py_None); 2907 return Py_None; 2908} 2909 2910PyDoc_STRVAR(sendall_doc, 2911"sendall(data[, flags])\n\ 2912\n\ 2913Send a data string to the socket. For the optional flags\n\ 2914argument, see the Unix manual. This calls send() repeatedly\n\ 2915until all data is sent. If an error occurs, it's impossible\n\ 2916to tell how much data has been sent."); 2917 2918 2919/* s.sendto(data, [flags,] sockaddr) method */ 2920 2921static PyObject * 2922sock_sendto(PySocketSockObject *s, PyObject *args) 2923{ 2924 Py_buffer pbuf; 2925 PyObject *addro; 2926 char *buf; 2927 Py_ssize_t len; 2928 sock_addr_t addrbuf; 2929 int addrlen, flags, timeout; 2930 long n = -1; 2931 int arglen; 2932 2933 flags = 0; 2934 arglen = PyTuple_Size(args); 2935 switch(arglen) { 2936 case 2: 2937 PyArg_ParseTuple(args, "s*O:sendto", &pbuf, &addro); 2938 break; 2939 case 3: 2940 PyArg_ParseTuple(args, "s*iO:sendto", &pbuf, &flags, &addro); 2941 break; 2942 default: 2943 PyErr_Format(PyExc_TypeError, "sendto() takes 2 or 3" 2944 " arguments (%d given)", arglen); 2945 } 2946 if (PyErr_Occurred()) 2947 return NULL; 2948 2949 buf = pbuf.buf; 2950 len = pbuf.len; 2951 2952 if (!IS_SELECTABLE(s)) { 2953 PyBuffer_Release(&pbuf); 2954 return select_error(); 2955 } 2956 2957 if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) { 2958 PyBuffer_Release(&pbuf); 2959 return NULL; 2960 } 2961 2962 BEGIN_SELECT_LOOP(s) 2963 Py_BEGIN_ALLOW_THREADS 2964 timeout = internal_select_ex(s, 1, interval); 2965 if (!timeout) 2966 n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen); 2967 Py_END_ALLOW_THREADS 2968 2969 if (timeout == 1) { 2970 PyBuffer_Release(&pbuf); 2971 PyErr_SetString(socket_timeout, "timed out"); 2972 return NULL; 2973 } 2974 END_SELECT_LOOP(s) 2975 PyBuffer_Release(&pbuf); 2976 if (n < 0) 2977 return s->errorhandler(); 2978 return PyInt_FromLong((long)n); 2979} 2980 2981PyDoc_STRVAR(sendto_doc, 2982"sendto(data[, flags], address) -> count\n\ 2983\n\ 2984Like send(data, flags) but allows specifying the destination address.\n\ 2985For IP sockets, the address is a pair (hostaddr, port)."); 2986 2987 2988/* s.shutdown(how) method */ 2989 2990static PyObject * 2991sock_shutdown(PySocketSockObject *s, PyObject *arg) 2992{ 2993 int how; 2994 int res; 2995 2996 how = _PyInt_AsInt(arg); 2997 if (how == -1 && PyErr_Occurred()) 2998 return NULL; 2999 Py_BEGIN_ALLOW_THREADS 3000 res = shutdown(s->sock_fd, how); 3001 Py_END_ALLOW_THREADS 3002 if (res < 0) 3003 return s->errorhandler(); 3004 Py_INCREF(Py_None); 3005 return Py_None; 3006} 3007 3008PyDoc_STRVAR(shutdown_doc, 3009"shutdown(flag)\n\ 3010\n\ 3011Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\ 3012of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR)."); 3013 3014#if defined(MS_WINDOWS) && defined(SIO_RCVALL) 3015static PyObject* 3016sock_ioctl(PySocketSockObject *s, PyObject *arg) 3017{ 3018 unsigned long cmd = SIO_RCVALL; 3019 PyObject *argO; 3020 DWORD recv; 3021 3022 if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO)) 3023 return NULL; 3024 3025 switch (cmd) { 3026 case SIO_RCVALL: { 3027 unsigned int option = RCVALL_ON; 3028 if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option)) 3029 return NULL; 3030 if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option), 3031 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) { 3032 return set_error(); 3033 } 3034 return PyLong_FromUnsignedLong(recv); } 3035 case SIO_KEEPALIVE_VALS: { 3036 struct tcp_keepalive ka; 3037 if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd, 3038 &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval)) 3039 return NULL; 3040 if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka), 3041 NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) { 3042 return set_error(); 3043 } 3044 return PyLong_FromUnsignedLong(recv); } 3045 default: 3046 PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd); 3047 return NULL; 3048 } 3049} 3050PyDoc_STRVAR(sock_ioctl_doc, 3051"ioctl(cmd, option) -> long\n\ 3052\n\ 3053Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\ 3054SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\ 3055SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval)."); 3056 3057#endif 3058 3059/* List of methods for socket objects */ 3060 3061static PyMethodDef sock_methods[] = { 3062 {"accept", (PyCFunction)sock_accept, METH_NOARGS, 3063 accept_doc}, 3064 {"bind", (PyCFunction)sock_bind, METH_O, 3065 bind_doc}, 3066 {"close", (PyCFunction)sock_close, METH_NOARGS, 3067 close_doc}, 3068 {"connect", (PyCFunction)sock_connect, METH_O, 3069 connect_doc}, 3070 {"connect_ex", (PyCFunction)sock_connect_ex, METH_O, 3071 connect_ex_doc}, 3072#ifndef NO_DUP 3073 {"dup", (PyCFunction)sock_dup, METH_NOARGS, 3074 dup_doc}, 3075#endif 3076 {"fileno", (PyCFunction)sock_fileno, METH_NOARGS, 3077 fileno_doc}, 3078#ifdef HAVE_GETPEERNAME 3079 {"getpeername", (PyCFunction)sock_getpeername, 3080 METH_NOARGS, getpeername_doc}, 3081#endif 3082 {"getsockname", (PyCFunction)sock_getsockname, 3083 METH_NOARGS, getsockname_doc}, 3084 {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS, 3085 getsockopt_doc}, 3086#if defined(MS_WINDOWS) && defined(SIO_RCVALL) 3087 {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS, 3088 sock_ioctl_doc}, 3089#endif 3090 {"listen", (PyCFunction)sock_listen, METH_O, 3091 listen_doc}, 3092#ifndef NO_DUP 3093 {"makefile", (PyCFunction)sock_makefile, METH_VARARGS, 3094 makefile_doc}, 3095#endif 3096 {"recv", (PyCFunction)sock_recv, METH_VARARGS, 3097 recv_doc}, 3098 {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS, 3099 recv_into_doc}, 3100 {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS, 3101 recvfrom_doc}, 3102 {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS, 3103 recvfrom_into_doc}, 3104 {"send", (PyCFunction)sock_send, METH_VARARGS, 3105 send_doc}, 3106 {"sendall", (PyCFunction)sock_sendall, METH_VARARGS, 3107 sendall_doc}, 3108 {"sendto", (PyCFunction)sock_sendto, METH_VARARGS, 3109 sendto_doc}, 3110 {"setblocking", (PyCFunction)sock_setblocking, METH_O, 3111 setblocking_doc}, 3112 {"settimeout", (PyCFunction)sock_settimeout, METH_O, 3113 settimeout_doc}, 3114 {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS, 3115 gettimeout_doc}, 3116 {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS, 3117 setsockopt_doc}, 3118 {"shutdown", (PyCFunction)sock_shutdown, METH_O, 3119 shutdown_doc}, 3120#ifdef RISCOS 3121 {"sleeptaskw", (PyCFunction)sock_sleeptaskw, METH_O, 3122 sleeptaskw_doc}, 3123#endif 3124 {NULL, NULL} /* sentinel */ 3125}; 3126 3127/* SockObject members */ 3128static PyMemberDef sock_memberlist[] = { 3129 {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"}, 3130 {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"}, 3131 {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"}, 3132 {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"}, 3133 {0}, 3134}; 3135 3136/* Deallocate a socket object in response to the last Py_DECREF(). 3137 First close the file description. */ 3138 3139static void 3140sock_dealloc(PySocketSockObject *s) 3141{ 3142 if (s->sock_fd != -1) 3143 (void) SOCKETCLOSE(s->sock_fd); 3144 if (s->weakreflist != NULL) 3145 PyObject_ClearWeakRefs((PyObject *)s); 3146 Py_TYPE(s)->tp_free((PyObject *)s); 3147} 3148 3149 3150static PyObject * 3151sock_repr(PySocketSockObject *s) 3152{ 3153 char buf[512]; 3154 long sock_fd; 3155 /* On Windows, this test is needed because SOCKET_T is unsigned */ 3156 if (s->sock_fd == INVALID_SOCKET) { 3157 sock_fd = -1; 3158 } 3159#if SIZEOF_SOCKET_T > SIZEOF_LONG 3160 else if (s->sock_fd > LONG_MAX) { 3161 /* this can occur on Win64, and actually there is a special 3162 ugly printf formatter for decimal pointer length integer 3163 printing, only bother if necessary*/ 3164 PyErr_SetString(PyExc_OverflowError, 3165 "no printf formatter to display " 3166 "the socket descriptor in decimal"); 3167 return NULL; 3168 } 3169#endif 3170 else 3171 sock_fd = (long)s->sock_fd; 3172 PyOS_snprintf( 3173 buf, sizeof(buf), 3174 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>", 3175 sock_fd, s->sock_family, 3176 s->sock_type, 3177 s->sock_proto); 3178 return PyString_FromString(buf); 3179} 3180 3181 3182/* Create a new, uninitialized socket object. */ 3183 3184static PyObject * 3185sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 3186{ 3187 PyObject *new; 3188 3189 new = type->tp_alloc(type, 0); 3190 if (new != NULL) { 3191 ((PySocketSockObject *)new)->sock_fd = -1; 3192 ((PySocketSockObject *)new)->sock_timeout = -1.0; 3193 ((PySocketSockObject *)new)->errorhandler = &set_error; 3194 ((PySocketSockObject *)new)->weakreflist = NULL; 3195 } 3196 return new; 3197} 3198 3199 3200/* Initialize a new socket object. */ 3201 3202/*ARGSUSED*/ 3203static int 3204sock_initobj(PyObject *self, PyObject *args, PyObject *kwds) 3205{ 3206 PySocketSockObject *s = (PySocketSockObject *)self; 3207 SOCKET_T fd; 3208 int family = AF_INET, type = SOCK_STREAM, proto = 0; 3209 static char *keywords[] = {"family", "type", "proto", 0}; 3210 3211 if (!PyArg_ParseTupleAndKeywords(args, kwds, 3212 "|iii:socket", keywords, 3213 &family, &type, &proto)) 3214 return -1; 3215 3216 Py_BEGIN_ALLOW_THREADS 3217 fd = socket(family, type, proto); 3218 Py_END_ALLOW_THREADS 3219 3220 if (fd == INVALID_SOCKET) { 3221 set_error(); 3222 return -1; 3223 } 3224 init_sockobject(s, fd, family, type, proto); 3225 3226 return 0; 3227 3228} 3229 3230 3231/* Type object for socket objects. */ 3232 3233static PyTypeObject sock_type = { 3234 PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */ 3235 "_socket.socket", /* tp_name */ 3236 sizeof(PySocketSockObject), /* tp_basicsize */ 3237 0, /* tp_itemsize */ 3238 (destructor)sock_dealloc, /* tp_dealloc */ 3239 0, /* tp_print */ 3240 0, /* tp_getattr */ 3241 0, /* tp_setattr */ 3242 0, /* tp_compare */ 3243 (reprfunc)sock_repr, /* tp_repr */ 3244 0, /* tp_as_number */ 3245 0, /* tp_as_sequence */ 3246 0, /* tp_as_mapping */ 3247 0, /* tp_hash */ 3248 0, /* tp_call */ 3249 0, /* tp_str */ 3250 PyObject_GenericGetAttr, /* tp_getattro */ 3251 0, /* tp_setattro */ 3252 0, /* tp_as_buffer */ 3253 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 3254 sock_doc, /* tp_doc */ 3255 0, /* tp_traverse */ 3256 0, /* tp_clear */ 3257 0, /* tp_richcompare */ 3258 offsetof(PySocketSockObject, weakreflist), /* tp_weaklistoffset */ 3259 0, /* tp_iter */ 3260 0, /* tp_iternext */ 3261 sock_methods, /* tp_methods */ 3262 sock_memberlist, /* tp_members */ 3263 0, /* tp_getset */ 3264 0, /* tp_base */ 3265 0, /* tp_dict */ 3266 0, /* tp_descr_get */ 3267 0, /* tp_descr_set */ 3268 0, /* tp_dictoffset */ 3269 sock_initobj, /* tp_init */ 3270 PyType_GenericAlloc, /* tp_alloc */ 3271 sock_new, /* tp_new */ 3272 PyObject_Del, /* tp_free */ 3273}; 3274 3275 3276/* Python interface to gethostname(). */ 3277 3278/*ARGSUSED*/ 3279static PyObject * 3280socket_gethostname(PyObject *self, PyObject *unused) 3281{ 3282 char buf[1024]; 3283 int res; 3284 Py_BEGIN_ALLOW_THREADS 3285 res = gethostname(buf, (int) sizeof buf - 1); 3286 Py_END_ALLOW_THREADS 3287 if (res < 0) 3288 return set_error(); 3289 buf[sizeof buf - 1] = '\0'; 3290 return PyString_FromString(buf); 3291} 3292 3293PyDoc_STRVAR(gethostname_doc, 3294"gethostname() -> string\n\ 3295\n\ 3296Return the current host name."); 3297 3298 3299/* Python interface to gethostbyname(name). */ 3300 3301/*ARGSUSED*/ 3302static PyObject * 3303socket_gethostbyname(PyObject *self, PyObject *args) 3304{ 3305 char *name; 3306 sock_addr_t addrbuf; 3307 3308 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name)) 3309 return NULL; 3310 if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0) 3311 return NULL; 3312 return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in)); 3313} 3314 3315PyDoc_STRVAR(gethostbyname_doc, 3316"gethostbyname(host) -> address\n\ 3317\n\ 3318Return the IP address (a string of the form '255.255.255.255') for a host."); 3319 3320 3321/* Convenience function common to gethostbyname_ex and gethostbyaddr */ 3322 3323static PyObject * 3324gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af) 3325{ 3326 char **pch; 3327 PyObject *rtn_tuple = (PyObject *)NULL; 3328 PyObject *name_list = (PyObject *)NULL; 3329 PyObject *addr_list = (PyObject *)NULL; 3330 PyObject *tmp; 3331 3332 if (h == NULL) { 3333 /* Let's get real error message to return */ 3334#ifndef RISCOS 3335 set_herror(h_errno); 3336#else 3337 PyErr_SetString(socket_error, "host not found"); 3338#endif 3339 return NULL; 3340 } 3341 3342 if (h->h_addrtype != af) { 3343 /* Let's get real error message to return */ 3344 PyErr_SetString(socket_error, 3345 (char *)strerror(EAFNOSUPPORT)); 3346 3347 return NULL; 3348 } 3349 3350 switch (af) { 3351 3352 case AF_INET: 3353 if (alen < sizeof(struct sockaddr_in)) 3354 return NULL; 3355 break; 3356 3357#ifdef ENABLE_IPV6 3358 case AF_INET6: 3359 if (alen < sizeof(struct sockaddr_in6)) 3360 return NULL; 3361 break; 3362#endif 3363 3364 } 3365 3366 if ((name_list = PyList_New(0)) == NULL) 3367 goto err; 3368 3369 if ((addr_list = PyList_New(0)) == NULL) 3370 goto err; 3371 3372 /* SF #1511317: h_aliases can be NULL */ 3373 if (h->h_aliases) { 3374 for (pch = h->h_aliases; *pch != NULL; pch++) { 3375 int status; 3376 tmp = PyString_FromString(*pch); 3377 if (tmp == NULL) 3378 goto err; 3379 3380 status = PyList_Append(name_list, tmp); 3381 Py_DECREF(tmp); 3382 3383 if (status) 3384 goto err; 3385 } 3386 } 3387 3388 for (pch = h->h_addr_list; *pch != NULL; pch++) { 3389 int status; 3390 3391 switch (af) { 3392 3393 case AF_INET: 3394 { 3395 struct sockaddr_in sin; 3396 memset(&sin, 0, sizeof(sin)); 3397 sin.sin_family = af; 3398#ifdef HAVE_SOCKADDR_SA_LEN 3399 sin.sin_len = sizeof(sin); 3400#endif 3401 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr)); 3402 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin)); 3403 3404 if (pch == h->h_addr_list && alen >= sizeof(sin)) 3405 memcpy((char *) addr, &sin, sizeof(sin)); 3406 break; 3407 } 3408 3409#ifdef ENABLE_IPV6 3410 case AF_INET6: 3411 { 3412 struct sockaddr_in6 sin6; 3413 memset(&sin6, 0, sizeof(sin6)); 3414 sin6.sin6_family = af; 3415#ifdef HAVE_SOCKADDR_SA_LEN 3416 sin6.sin6_len = sizeof(sin6); 3417#endif 3418 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr)); 3419 tmp = makeipaddr((struct sockaddr *)&sin6, 3420 sizeof(sin6)); 3421 3422 if (pch == h->h_addr_list && alen >= sizeof(sin6)) 3423 memcpy((char *) addr, &sin6, sizeof(sin6)); 3424 break; 3425 } 3426#endif 3427 3428 default: /* can't happen */ 3429 PyErr_SetString(socket_error, 3430 "unsupported address family"); 3431 return NULL; 3432 } 3433 3434 if (tmp == NULL) 3435 goto err; 3436 3437 status = PyList_Append(addr_list, tmp); 3438 Py_DECREF(tmp); 3439 3440 if (status) 3441 goto err; 3442 } 3443 3444 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list); 3445 3446 err: 3447 Py_XDECREF(name_list); 3448 Py_XDECREF(addr_list); 3449 return rtn_tuple; 3450} 3451 3452 3453/* Python interface to gethostbyname_ex(name). */ 3454 3455/*ARGSUSED*/ 3456static PyObject * 3457socket_gethostbyname_ex(PyObject *self, PyObject *args) 3458{ 3459 char *name; 3460 struct hostent *h; 3461#ifdef ENABLE_IPV6 3462 struct sockaddr_storage addr; 3463#else 3464 struct sockaddr_in addr; 3465#endif 3466 struct sockaddr *sa; 3467 PyObject *ret; 3468#ifdef HAVE_GETHOSTBYNAME_R 3469 struct hostent hp_allocated; 3470#ifdef HAVE_GETHOSTBYNAME_R_3_ARG 3471 struct hostent_data data; 3472#else 3473 char buf[16384]; 3474 int buf_len = (sizeof buf) - 1; 3475 int errnop; 3476#endif 3477#ifdef HAVE_GETHOSTBYNAME_R_3_ARG 3478 int result; 3479#endif 3480#endif /* HAVE_GETHOSTBYNAME_R */ 3481 3482 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name)) 3483 return NULL; 3484 if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0) 3485 return NULL; 3486 Py_BEGIN_ALLOW_THREADS 3487#ifdef HAVE_GETHOSTBYNAME_R 3488#if defined(HAVE_GETHOSTBYNAME_R_6_ARG) 3489 gethostbyname_r(name, &hp_allocated, buf, buf_len, 3490 &h, &errnop); 3491#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG) 3492 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop); 3493#else /* HAVE_GETHOSTBYNAME_R_3_ARG */ 3494 memset((void *) &data, '\0', sizeof(data)); 3495 result = gethostbyname_r(name, &hp_allocated, &data); 3496 h = (result != 0) ? NULL : &hp_allocated; 3497#endif 3498#else /* not HAVE_GETHOSTBYNAME_R */ 3499#ifdef USE_GETHOSTBYNAME_LOCK 3500 PyThread_acquire_lock(netdb_lock, 1); 3501#endif 3502 h = gethostbyname(name); 3503#endif /* HAVE_GETHOSTBYNAME_R */ 3504 Py_END_ALLOW_THREADS 3505 /* Some C libraries would require addr.__ss_family instead of 3506 addr.ss_family. 3507 Therefore, we cast the sockaddr_storage into sockaddr to 3508 access sa_family. */ 3509 sa = (struct sockaddr*)&addr; 3510 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), 3511 sa->sa_family); 3512#ifdef USE_GETHOSTBYNAME_LOCK 3513 PyThread_release_lock(netdb_lock); 3514#endif 3515 return ret; 3516} 3517 3518PyDoc_STRVAR(ghbn_ex_doc, 3519"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\ 3520\n\ 3521Return the true host name, a list of aliases, and a list of IP addresses,\n\ 3522for a host. The host argument is a string giving a host name or IP number."); 3523 3524 3525/* Python interface to gethostbyaddr(IP). */ 3526 3527/*ARGSUSED*/ 3528static PyObject * 3529socket_gethostbyaddr(PyObject *self, PyObject *args) 3530{ 3531#ifdef ENABLE_IPV6 3532 struct sockaddr_storage addr; 3533#else 3534 struct sockaddr_in addr; 3535#endif 3536 struct sockaddr *sa = (struct sockaddr *)&addr; 3537 char *ip_num; 3538 struct hostent *h; 3539 PyObject *ret; 3540#ifdef HAVE_GETHOSTBYNAME_R 3541 struct hostent hp_allocated; 3542#ifdef HAVE_GETHOSTBYNAME_R_3_ARG 3543 struct hostent_data data; 3544#else 3545 /* glibcs up to 2.10 assume that the buf argument to 3546 gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc 3547 does not ensure. The attribute below instructs the compiler 3548 to maintain this alignment. */ 3549 char buf[16384] Py_ALIGNED(8); 3550 int buf_len = (sizeof buf) - 1; 3551 int errnop; 3552#endif 3553#ifdef HAVE_GETHOSTBYNAME_R_3_ARG 3554 int result; 3555#endif 3556#endif /* HAVE_GETHOSTBYNAME_R */ 3557 char *ap; 3558 int al; 3559 int af; 3560 3561 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num)) 3562 return NULL; 3563 af = AF_UNSPEC; 3564 if (setipaddr(ip_num, sa, sizeof(addr), af) < 0) 3565 return NULL; 3566 af = sa->sa_family; 3567 ap = NULL; 3568 switch (af) { 3569 case AF_INET: 3570 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr; 3571 al = sizeof(((struct sockaddr_in *)sa)->sin_addr); 3572 break; 3573#ifdef ENABLE_IPV6 3574 case AF_INET6: 3575 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr; 3576 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr); 3577 break; 3578#endif 3579 default: 3580 PyErr_SetString(socket_error, "unsupported address family"); 3581 return NULL; 3582 } 3583 Py_BEGIN_ALLOW_THREADS 3584#ifdef HAVE_GETHOSTBYNAME_R 3585#if defined(HAVE_GETHOSTBYNAME_R_6_ARG) 3586 gethostbyaddr_r(ap, al, af, 3587 &hp_allocated, buf, buf_len, 3588 &h, &errnop); 3589#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG) 3590 h = gethostbyaddr_r(ap, al, af, 3591 &hp_allocated, buf, buf_len, &errnop); 3592#else /* HAVE_GETHOSTBYNAME_R_3_ARG */ 3593 memset((void *) &data, '\0', sizeof(data)); 3594 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data); 3595 h = (result != 0) ? NULL : &hp_allocated; 3596#endif 3597#else /* not HAVE_GETHOSTBYNAME_R */ 3598#ifdef USE_GETHOSTBYNAME_LOCK 3599 PyThread_acquire_lock(netdb_lock, 1); 3600#endif 3601 h = gethostbyaddr(ap, al, af); 3602#endif /* HAVE_GETHOSTBYNAME_R */ 3603 Py_END_ALLOW_THREADS 3604 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af); 3605#ifdef USE_GETHOSTBYNAME_LOCK 3606 PyThread_release_lock(netdb_lock); 3607#endif 3608 return ret; 3609} 3610 3611PyDoc_STRVAR(gethostbyaddr_doc, 3612"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\ 3613\n\ 3614Return the true host name, a list of aliases, and a list of IP addresses,\n\ 3615for a host. The host argument is a string giving a host name or IP number."); 3616 3617 3618/* Python interface to getservbyname(name). 3619 This only returns the port number, since the other info is already 3620 known or not useful (like the list of aliases). */ 3621 3622/*ARGSUSED*/ 3623static PyObject * 3624socket_getservbyname(PyObject *self, PyObject *args) 3625{ 3626 char *name, *proto=NULL; 3627 struct servent *sp; 3628 if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto)) 3629 return NULL; 3630 Py_BEGIN_ALLOW_THREADS 3631 sp = getservbyname(name, proto); 3632 Py_END_ALLOW_THREADS 3633 if (sp == NULL) { 3634 PyErr_SetString(socket_error, "service/proto not found"); 3635 return NULL; 3636 } 3637 return PyInt_FromLong((long) ntohs(sp->s_port)); 3638} 3639 3640PyDoc_STRVAR(getservbyname_doc, 3641"getservbyname(servicename[, protocolname]) -> integer\n\ 3642\n\ 3643Return a port number from a service name and protocol name.\n\ 3644The optional protocol name, if given, should be 'tcp' or 'udp',\n\ 3645otherwise any protocol will match."); 3646 3647 3648/* Python interface to getservbyport(port). 3649 This only returns the service name, since the other info is already 3650 known or not useful (like the list of aliases). */ 3651 3652/*ARGSUSED*/ 3653static PyObject * 3654socket_getservbyport(PyObject *self, PyObject *args) 3655{ 3656 int port; 3657 char *proto=NULL; 3658 struct servent *sp; 3659 if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto)) 3660 return NULL; 3661 if (port < 0 || port > 0xffff) { 3662 PyErr_SetString( 3663 PyExc_OverflowError, 3664 "getservbyport: port must be 0-65535."); 3665 return NULL; 3666 } 3667 Py_BEGIN_ALLOW_THREADS 3668 sp = getservbyport(htons((short)port), proto); 3669 Py_END_ALLOW_THREADS 3670 if (sp == NULL) { 3671 PyErr_SetString(socket_error, "port/proto not found"); 3672 return NULL; 3673 } 3674 return PyString_FromString(sp->s_name); 3675} 3676 3677PyDoc_STRVAR(getservbyport_doc, 3678"getservbyport(port[, protocolname]) -> string\n\ 3679\n\ 3680Return the service name from a port number and protocol name.\n\ 3681The optional protocol name, if given, should be 'tcp' or 'udp',\n\ 3682otherwise any protocol will match."); 3683 3684/* Python interface to getprotobyname(name). 3685 This only returns the protocol number, since the other info is 3686 already known or not useful (like the list of aliases). */ 3687 3688/*ARGSUSED*/ 3689static PyObject * 3690socket_getprotobyname(PyObject *self, PyObject *args) 3691{ 3692 char *name; 3693 struct protoent *sp; 3694#ifdef __BEOS__ 3695/* Not available in BeOS yet. - [cjh] */ 3696 PyErr_SetString(socket_error, "getprotobyname not supported"); 3697 return NULL; 3698#else 3699 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name)) 3700 return NULL; 3701 Py_BEGIN_ALLOW_THREADS 3702 sp = getprotobyname(name); 3703 Py_END_ALLOW_THREADS 3704 if (sp == NULL) { 3705 PyErr_SetString(socket_error, "protocol not found"); 3706 return NULL; 3707 } 3708 return PyInt_FromLong((long) sp->p_proto); 3709#endif 3710} 3711 3712PyDoc_STRVAR(getprotobyname_doc, 3713"getprotobyname(name) -> integer\n\ 3714\n\ 3715Return the protocol number for the named protocol. (Rarely used.)"); 3716 3717 3718#ifdef HAVE_SOCKETPAIR 3719/* Create a pair of sockets using the socketpair() function. 3720 Arguments as for socket() except the default family is AF_UNIX if 3721 defined on the platform; otherwise, the default is AF_INET. */ 3722 3723/*ARGSUSED*/ 3724static PyObject * 3725socket_socketpair(PyObject *self, PyObject *args) 3726{ 3727 PySocketSockObject *s0 = NULL, *s1 = NULL; 3728 SOCKET_T sv[2]; 3729 int family, type = SOCK_STREAM, proto = 0; 3730 PyObject *res = NULL; 3731 3732#if defined(AF_UNIX) 3733 family = AF_UNIX; 3734#else 3735 family = AF_INET; 3736#endif 3737 if (!PyArg_ParseTuple(args, "|iii:socketpair", 3738 &family, &type, &proto)) 3739 return NULL; 3740 /* Create a pair of socket fds */ 3741 if (socketpair(family, type, proto, sv) < 0) 3742 return set_error(); 3743 s0 = new_sockobject(sv[0], family, type, proto); 3744 if (s0 == NULL) 3745 goto finally; 3746 s1 = new_sockobject(sv[1], family, type, proto); 3747 if (s1 == NULL) 3748 goto finally; 3749 res = PyTuple_Pack(2, s0, s1); 3750 3751finally: 3752 if (res == NULL) { 3753 if (s0 == NULL) 3754 SOCKETCLOSE(sv[0]); 3755 if (s1 == NULL) 3756 SOCKETCLOSE(sv[1]); 3757 } 3758 Py_XDECREF(s0); 3759 Py_XDECREF(s1); 3760 return res; 3761} 3762 3763PyDoc_STRVAR(socketpair_doc, 3764"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\ 3765\n\ 3766Create a pair of socket objects from the sockets returned by the platform\n\ 3767socketpair() function.\n\ 3768The arguments are the same as for socket() except the default family is\n\ 3769AF_UNIX if defined on the platform; otherwise, the default is AF_INET."); 3770 3771#endif /* HAVE_SOCKETPAIR */ 3772 3773 3774#ifndef NO_DUP 3775/* Create a socket object from a numeric file description. 3776 Useful e.g. if stdin is a socket. 3777 Additional arguments as for socket(). */ 3778 3779/*ARGSUSED*/ 3780static PyObject * 3781socket_fromfd(PyObject *self, PyObject *args) 3782{ 3783 PySocketSockObject *s; 3784 SOCKET_T fd; 3785 int family, type, proto = 0; 3786 if (!PyArg_ParseTuple(args, "iii|i:fromfd", 3787 &fd, &family, &type, &proto)) 3788 return NULL; 3789 /* Dup the fd so it and the socket can be closed independently */ 3790 fd = dup(fd); 3791 if (fd < 0) 3792 return set_error(); 3793 s = new_sockobject(fd, family, type, proto); 3794 return (PyObject *) s; 3795} 3796 3797PyDoc_STRVAR(fromfd_doc, 3798"fromfd(fd, family, type[, proto]) -> socket object\n\ 3799\n\ 3800Create a socket object from a duplicate of the given\n\ 3801file descriptor.\n\ 3802The remaining arguments are the same as for socket()."); 3803 3804#endif /* NO_DUP */ 3805 3806 3807static PyObject * 3808socket_ntohs(PyObject *self, PyObject *args) 3809{ 3810 int x1, x2; 3811 3812 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) { 3813 return NULL; 3814 } 3815 if (x1 < 0) { 3816 PyErr_SetString(PyExc_OverflowError, 3817 "can't convert negative number to unsigned long"); 3818 return NULL; 3819 } 3820 x2 = (unsigned int)ntohs((unsigned short)x1); 3821 return PyInt_FromLong(x2); 3822} 3823 3824PyDoc_STRVAR(ntohs_doc, 3825"ntohs(integer) -> integer\n\ 3826\n\ 3827Convert a 16-bit integer from network to host byte order."); 3828 3829 3830static PyObject * 3831socket_ntohl(PyObject *self, PyObject *arg) 3832{ 3833 unsigned long x; 3834 3835 if (PyInt_Check(arg)) { 3836 x = PyInt_AS_LONG(arg); 3837 if (x == (unsigned long) -1 && PyErr_Occurred()) 3838 return NULL; 3839 if ((long)x < 0) { 3840 PyErr_SetString(PyExc_OverflowError, 3841 "can't convert negative number to unsigned long"); 3842 return NULL; 3843 } 3844 } 3845 else if (PyLong_Check(arg)) { 3846 x = PyLong_AsUnsignedLong(arg); 3847 if (x == (unsigned long) -1 && PyErr_Occurred()) 3848 return NULL; 3849#if SIZEOF_LONG > 4 3850 { 3851 unsigned long y; 3852 /* only want the trailing 32 bits */ 3853 y = x & 0xFFFFFFFFUL; 3854 if (y ^ x) 3855 return PyErr_Format(PyExc_OverflowError, 3856 "long int larger than 32 bits"); 3857 x = y; 3858 } 3859#endif 3860 } 3861 else 3862 return PyErr_Format(PyExc_TypeError, 3863 "expected int/long, %s found", 3864 Py_TYPE(arg)->tp_name); 3865 if (x == (unsigned long) -1 && PyErr_Occurred()) 3866 return NULL; 3867 return PyLong_FromUnsignedLong(ntohl(x)); 3868} 3869 3870PyDoc_STRVAR(ntohl_doc, 3871"ntohl(integer) -> integer\n\ 3872\n\ 3873Convert a 32-bit integer from network to host byte order."); 3874 3875 3876static PyObject * 3877socket_htons(PyObject *self, PyObject *args) 3878{ 3879 int x1, x2; 3880 3881 if (!PyArg_ParseTuple(args, "i:htons", &x1)) { 3882 return NULL; 3883 } 3884 if (x1 < 0) { 3885 PyErr_SetString(PyExc_OverflowError, 3886 "can't convert negative number to unsigned long"); 3887 return NULL; 3888 } 3889 x2 = (unsigned int)htons((unsigned short)x1); 3890 return PyInt_FromLong(x2); 3891} 3892 3893PyDoc_STRVAR(htons_doc, 3894"htons(integer) -> integer\n\ 3895\n\ 3896Convert a 16-bit integer from host to network byte order."); 3897 3898 3899static PyObject * 3900socket_htonl(PyObject *self, PyObject *arg) 3901{ 3902 unsigned long x; 3903 3904 if (PyInt_Check(arg)) { 3905 x = PyInt_AS_LONG(arg); 3906 if (x == (unsigned long) -1 && PyErr_Occurred()) 3907 return NULL; 3908 if ((long)x < 0) { 3909 PyErr_SetString(PyExc_OverflowError, 3910 "can't convert negative number to unsigned long"); 3911 return NULL; 3912 } 3913 } 3914 else if (PyLong_Check(arg)) { 3915 x = PyLong_AsUnsignedLong(arg); 3916 if (x == (unsigned long) -1 && PyErr_Occurred()) 3917 return NULL; 3918#if SIZEOF_LONG > 4 3919 { 3920 unsigned long y; 3921 /* only want the trailing 32 bits */ 3922 y = x & 0xFFFFFFFFUL; 3923 if (y ^ x) 3924 return PyErr_Format(PyExc_OverflowError, 3925 "long int larger than 32 bits"); 3926 x = y; 3927 } 3928#endif 3929 } 3930 else 3931 return PyErr_Format(PyExc_TypeError, 3932 "expected int/long, %s found", 3933 Py_TYPE(arg)->tp_name); 3934 return PyLong_FromUnsignedLong(htonl((unsigned long)x)); 3935} 3936 3937PyDoc_STRVAR(htonl_doc, 3938"htonl(integer) -> integer\n\ 3939\n\ 3940Convert a 32-bit integer from host to network byte order."); 3941 3942/* socket.inet_aton() and socket.inet_ntoa() functions. */ 3943 3944PyDoc_STRVAR(inet_aton_doc, 3945"inet_aton(string) -> packed 32-bit IP representation\n\ 3946\n\ 3947Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\ 3948binary format used in low-level network functions."); 3949 3950static PyObject* 3951socket_inet_aton(PyObject *self, PyObject *args) 3952{ 3953#ifndef INADDR_NONE 3954#define INADDR_NONE (-1) 3955#endif 3956#ifdef HAVE_INET_ATON 3957 struct in_addr buf; 3958#endif 3959 3960#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK) 3961#if (SIZEOF_INT != 4) 3962#error "Not sure if in_addr_t exists and int is not 32-bits." 3963#endif 3964 /* Have to use inet_addr() instead */ 3965 unsigned int packed_addr; 3966#endif 3967 char *ip_addr; 3968 3969 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr)) 3970 return NULL; 3971 3972 3973#ifdef HAVE_INET_ATON 3974 3975#ifdef USE_INET_ATON_WEAKLINK 3976 if (inet_aton != NULL) { 3977#endif 3978 if (inet_aton(ip_addr, &buf)) 3979 return PyString_FromStringAndSize((char *)(&buf), 3980 sizeof(buf)); 3981 3982 PyErr_SetString(socket_error, 3983 "illegal IP address string passed to inet_aton"); 3984 return NULL; 3985 3986#ifdef USE_INET_ATON_WEAKLINK 3987 } else { 3988#endif 3989 3990#endif 3991 3992#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK) 3993 3994 /* special-case this address as inet_addr might return INADDR_NONE 3995 * for this */ 3996 if (strcmp(ip_addr, "255.255.255.255") == 0) { 3997 packed_addr = 0xFFFFFFFF; 3998 } else { 3999 4000 packed_addr = inet_addr(ip_addr); 4001 4002 if (packed_addr == INADDR_NONE) { /* invalid address */ 4003 PyErr_SetString(socket_error, 4004 "illegal IP address string passed to inet_aton"); 4005 return NULL; 4006 } 4007 } 4008 return PyString_FromStringAndSize((char *) &packed_addr, 4009 sizeof(packed_addr)); 4010 4011#ifdef USE_INET_ATON_WEAKLINK 4012 } 4013#endif 4014 4015#endif 4016} 4017 4018PyDoc_STRVAR(inet_ntoa_doc, 4019"inet_ntoa(packed_ip) -> ip_address_string\n\ 4020\n\ 4021Convert an IP address from 32-bit packed binary format to string format"); 4022 4023static PyObject* 4024socket_inet_ntoa(PyObject *self, PyObject *args) 4025{ 4026 char *packed_str; 4027 int addr_len; 4028 struct in_addr packed_addr; 4029 4030 if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) { 4031 return NULL; 4032 } 4033 4034 if (addr_len != sizeof(packed_addr)) { 4035 PyErr_SetString(socket_error, 4036 "packed IP wrong length for inet_ntoa"); 4037 return NULL; 4038 } 4039 4040 memcpy(&packed_addr, packed_str, addr_len); 4041 4042 return PyString_FromString(inet_ntoa(packed_addr)); 4043} 4044 4045#ifdef HAVE_INET_PTON 4046 4047PyDoc_STRVAR(inet_pton_doc, 4048"inet_pton(af, ip) -> packed IP address string\n\ 4049\n\ 4050Convert an IP address from string format to a packed string suitable\n\ 4051for use with low-level network functions."); 4052 4053static PyObject * 4054socket_inet_pton(PyObject *self, PyObject *args) 4055{ 4056 int af; 4057 char* ip; 4058 int retval; 4059#ifdef ENABLE_IPV6 4060 char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))]; 4061#else 4062 char packed[sizeof(struct in_addr)]; 4063#endif 4064 if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) { 4065 return NULL; 4066 } 4067 4068#if !defined(ENABLE_IPV6) && defined(AF_INET6) 4069 if(af == AF_INET6) { 4070 PyErr_SetString(socket_error, 4071 "can't use AF_INET6, IPv6 is disabled"); 4072 return NULL; 4073 } 4074#endif 4075 4076 retval = inet_pton(af, ip, packed); 4077 if (retval < 0) { 4078 PyErr_SetFromErrno(socket_error); 4079 return NULL; 4080 } else if (retval == 0) { 4081 PyErr_SetString(socket_error, 4082 "illegal IP address string passed to inet_pton"); 4083 return NULL; 4084 } else if (af == AF_INET) { 4085 return PyString_FromStringAndSize(packed, 4086 sizeof(struct in_addr)); 4087#ifdef ENABLE_IPV6 4088 } else if (af == AF_INET6) { 4089 return PyString_FromStringAndSize(packed, 4090 sizeof(struct in6_addr)); 4091#endif 4092 } else { 4093 PyErr_SetString(socket_error, "unknown address family"); 4094 return NULL; 4095 } 4096} 4097 4098PyDoc_STRVAR(inet_ntop_doc, 4099"inet_ntop(af, packed_ip) -> string formatted IP address\n\ 4100\n\ 4101Convert a packed IP address of the given family to string format."); 4102 4103static PyObject * 4104socket_inet_ntop(PyObject *self, PyObject *args) 4105{ 4106 int af; 4107 char* packed; 4108 int len; 4109 const char* retval; 4110#ifdef ENABLE_IPV6 4111 char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1]; 4112#else 4113 char ip[INET_ADDRSTRLEN + 1]; 4114#endif 4115 4116 /* Guarantee NUL-termination for PyString_FromString() below */ 4117 memset((void *) &ip[0], '\0', sizeof(ip)); 4118 4119 if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) { 4120 return NULL; 4121 } 4122 4123 if (af == AF_INET) { 4124 if (len != sizeof(struct in_addr)) { 4125 PyErr_SetString(PyExc_ValueError, 4126 "invalid length of packed IP address string"); 4127 return NULL; 4128 } 4129#ifdef ENABLE_IPV6 4130 } else if (af == AF_INET6) { 4131 if (len != sizeof(struct in6_addr)) { 4132 PyErr_SetString(PyExc_ValueError, 4133 "invalid length of packed IP address string"); 4134 return NULL; 4135 } 4136#endif 4137 } else { 4138 PyErr_Format(PyExc_ValueError, 4139 "unknown address family %d", af); 4140 return NULL; 4141 } 4142 4143 retval = inet_ntop(af, packed, ip, sizeof(ip)); 4144 if (!retval) { 4145 PyErr_SetFromErrno(socket_error); 4146 return NULL; 4147 } else { 4148 return PyString_FromString(retval); 4149 } 4150 4151 /* NOTREACHED */ 4152 PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop"); 4153 return NULL; 4154} 4155 4156#endif /* HAVE_INET_PTON */ 4157 4158/* Python interface to getaddrinfo(host, port). */ 4159 4160/*ARGSUSED*/ 4161static PyObject * 4162socket_getaddrinfo(PyObject *self, PyObject *args) 4163{ 4164 struct addrinfo hints, *res; 4165 struct addrinfo *res0 = NULL; 4166 PyObject *hobj = NULL; 4167 PyObject *pobj = (PyObject *)NULL; 4168 char pbuf[30]; 4169 char *hptr, *pptr; 4170 int family, socktype, protocol, flags; 4171 int error; 4172 PyObject *all = (PyObject *)NULL; 4173 PyObject *single = (PyObject *)NULL; 4174 PyObject *idna = NULL; 4175 4176 family = socktype = protocol = flags = 0; 4177 family = AF_UNSPEC; 4178 if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo", 4179 &hobj, &pobj, &family, &socktype, 4180 &protocol, &flags)) { 4181 return NULL; 4182 } 4183 if (hobj == Py_None) { 4184 hptr = NULL; 4185 } else if (PyUnicode_Check(hobj)) { 4186 idna = PyUnicode_AsEncodedString(hobj, "idna", NULL); 4187 if (!idna) 4188 return NULL; 4189 hptr = PyString_AsString(idna); 4190 } else if (PyString_Check(hobj)) { 4191 hptr = PyString_AsString(hobj); 4192 } else { 4193 PyErr_SetString(PyExc_TypeError, 4194 "getaddrinfo() argument 1 must be string or None"); 4195 return NULL; 4196 } 4197 if (PyInt_Check(pobj) || PyLong_Check(pobj)) { 4198 long value = PyLong_AsLong(pobj); 4199 if (value == -1 && PyErr_Occurred()) 4200 return NULL; 4201 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value); 4202 pptr = pbuf; 4203 } else if (PyString_Check(pobj)) { 4204 pptr = PyString_AsString(pobj); 4205 } else if (pobj == Py_None) { 4206 pptr = (char *)NULL; 4207 } else { 4208 PyErr_SetString(socket_error, 4209 "getaddrinfo() argument 2 must be integer or string"); 4210 goto err; 4211 } 4212#if defined(__APPLE__) && defined(AI_NUMERICSERV) 4213 if ((flags & AI_NUMERICSERV) && (pptr == NULL || (pptr[0] == '0' && pptr[1] == 0))) { 4214 /* On OSX upto at least OSX 10.8 getaddrinfo crashes 4215 * if AI_NUMERICSERV is set and the servname is NULL or "0". 4216 * This workaround avoids a segfault in libsystem. 4217 */ 4218 pptr = "00"; 4219 } 4220#endif 4221 memset(&hints, 0, sizeof(hints)); 4222 hints.ai_family = family; 4223 hints.ai_socktype = socktype; 4224 hints.ai_protocol = protocol; 4225 hints.ai_flags = flags; 4226 Py_BEGIN_ALLOW_THREADS 4227 ACQUIRE_GETADDRINFO_LOCK 4228 error = getaddrinfo(hptr, pptr, &hints, &res0); 4229 Py_END_ALLOW_THREADS 4230 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */ 4231 if (error) { 4232 set_gaierror(error); 4233 goto err; 4234 } 4235 4236 all = PyList_New(0); 4237 if (all == NULL) 4238 goto err; 4239 for (res = res0; res; res = res->ai_next) { 4240 PyObject *addr = 4241 makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol); 4242 if (addr == NULL) 4243 goto err; 4244 single = Py_BuildValue("iiisO", res->ai_family, 4245 res->ai_socktype, res->ai_protocol, 4246 res->ai_canonname ? res->ai_canonname : "", 4247 addr); 4248 Py_DECREF(addr); 4249 if (single == NULL) 4250 goto err; 4251 4252 if (PyList_Append(all, single)) 4253 goto err; 4254 Py_XDECREF(single); 4255 } 4256 Py_XDECREF(idna); 4257 if (res0) 4258 freeaddrinfo(res0); 4259 return all; 4260 err: 4261 Py_XDECREF(single); 4262 Py_XDECREF(all); 4263 Py_XDECREF(idna); 4264 if (res0) 4265 freeaddrinfo(res0); 4266 return (PyObject *)NULL; 4267} 4268 4269PyDoc_STRVAR(getaddrinfo_doc, 4270"getaddrinfo(host, port [, family, socktype, proto, flags])\n\ 4271 -> list of (family, socktype, proto, canonname, sockaddr)\n\ 4272\n\ 4273Resolve host and port into addrinfo struct."); 4274 4275/* Python interface to getnameinfo(sa, flags). */ 4276 4277/*ARGSUSED*/ 4278static PyObject * 4279socket_getnameinfo(PyObject *self, PyObject *args) 4280{ 4281 PyObject *sa = (PyObject *)NULL; 4282 int flags; 4283 char *hostp; 4284 int port; 4285 unsigned int flowinfo, scope_id; 4286 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV]; 4287 struct addrinfo hints, *res = NULL; 4288 int error; 4289 PyObject *ret = (PyObject *)NULL; 4290 4291 flags = flowinfo = scope_id = 0; 4292 if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags)) 4293 return NULL; 4294 if (!PyTuple_Check(sa)) { 4295 PyErr_SetString(PyExc_TypeError, 4296 "getnameinfo() argument 1 must be a tuple"); 4297 return NULL; 4298 } 4299 if (!PyArg_ParseTuple(sa, "si|II", 4300 &hostp, &port, &flowinfo, &scope_id)) 4301 return NULL; 4302 if (flowinfo > 0xfffff) { 4303 PyErr_SetString(PyExc_OverflowError, 4304 "getsockaddrarg: flowinfo must be 0-1048575."); 4305 return NULL; 4306 } 4307 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port); 4308 memset(&hints, 0, sizeof(hints)); 4309 hints.ai_family = AF_UNSPEC; 4310 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */ 4311 Py_BEGIN_ALLOW_THREADS 4312 ACQUIRE_GETADDRINFO_LOCK 4313 error = getaddrinfo(hostp, pbuf, &hints, &res); 4314 Py_END_ALLOW_THREADS 4315 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */ 4316 if (error) { 4317 set_gaierror(error); 4318 goto fail; 4319 } 4320 if (res->ai_next) { 4321 PyErr_SetString(socket_error, 4322 "sockaddr resolved to multiple addresses"); 4323 goto fail; 4324 } 4325 switch (res->ai_family) { 4326 case AF_INET: 4327 { 4328 if (PyTuple_GET_SIZE(sa) != 2) { 4329 PyErr_SetString(socket_error, 4330 "IPv4 sockaddr must be 2 tuple"); 4331 goto fail; 4332 } 4333 break; 4334 } 4335#ifdef ENABLE_IPV6 4336 case AF_INET6: 4337 { 4338 struct sockaddr_in6 *sin6; 4339 sin6 = (struct sockaddr_in6 *)res->ai_addr; 4340 sin6->sin6_flowinfo = htonl(flowinfo); 4341 sin6->sin6_scope_id = scope_id; 4342 break; 4343 } 4344#endif 4345 } 4346 error = getnameinfo(res->ai_addr, res->ai_addrlen, 4347 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags); 4348 if (error) { 4349 set_gaierror(error); 4350 goto fail; 4351 } 4352 ret = Py_BuildValue("ss", hbuf, pbuf); 4353 4354fail: 4355 if (res) 4356 freeaddrinfo(res); 4357 return ret; 4358} 4359 4360PyDoc_STRVAR(getnameinfo_doc, 4361"getnameinfo(sockaddr, flags) --> (host, port)\n\ 4362\n\ 4363Get host and port for a sockaddr."); 4364 4365 4366/* Python API to getting and setting the default timeout value. */ 4367 4368static PyObject * 4369socket_getdefaulttimeout(PyObject *self) 4370{ 4371 if (defaulttimeout < 0.0) { 4372 Py_INCREF(Py_None); 4373 return Py_None; 4374 } 4375 else 4376 return PyFloat_FromDouble(defaulttimeout); 4377} 4378 4379PyDoc_STRVAR(getdefaulttimeout_doc, 4380"getdefaulttimeout() -> timeout\n\ 4381\n\ 4382Returns the default timeout in seconds (float) for new socket objects.\n\ 4383A value of None indicates that new socket objects have no timeout.\n\ 4384When the socket module is first imported, the default is None."); 4385 4386static PyObject * 4387socket_setdefaulttimeout(PyObject *self, PyObject *arg) 4388{ 4389 double timeout; 4390 4391 if (arg == Py_None) 4392 timeout = -1.0; 4393 else { 4394 timeout = PyFloat_AsDouble(arg); 4395 if (timeout < 0.0) { 4396 if (!PyErr_Occurred()) 4397 PyErr_SetString(PyExc_ValueError, 4398 "Timeout value out of range"); 4399 return NULL; 4400 } 4401 } 4402 4403 defaulttimeout = timeout; 4404 4405 Py_INCREF(Py_None); 4406 return Py_None; 4407} 4408 4409PyDoc_STRVAR(setdefaulttimeout_doc, 4410"setdefaulttimeout(timeout)\n\ 4411\n\ 4412Set the default timeout in seconds (float) for new socket objects.\n\ 4413A value of None indicates that new socket objects have no timeout.\n\ 4414When the socket module is first imported, the default is None."); 4415 4416 4417/* List of functions exported by this module. */ 4418 4419static PyMethodDef socket_methods[] = { 4420 {"gethostbyname", socket_gethostbyname, 4421 METH_VARARGS, gethostbyname_doc}, 4422 {"gethostbyname_ex", socket_gethostbyname_ex, 4423 METH_VARARGS, ghbn_ex_doc}, 4424 {"gethostbyaddr", socket_gethostbyaddr, 4425 METH_VARARGS, gethostbyaddr_doc}, 4426 {"gethostname", socket_gethostname, 4427 METH_NOARGS, gethostname_doc}, 4428 {"getservbyname", socket_getservbyname, 4429 METH_VARARGS, getservbyname_doc}, 4430 {"getservbyport", socket_getservbyport, 4431 METH_VARARGS, getservbyport_doc}, 4432 {"getprotobyname", socket_getprotobyname, 4433 METH_VARARGS, getprotobyname_doc}, 4434#ifndef NO_DUP 4435 {"fromfd", socket_fromfd, 4436 METH_VARARGS, fromfd_doc}, 4437#endif 4438#ifdef HAVE_SOCKETPAIR 4439 {"socketpair", socket_socketpair, 4440 METH_VARARGS, socketpair_doc}, 4441#endif 4442 {"ntohs", socket_ntohs, 4443 METH_VARARGS, ntohs_doc}, 4444 {"ntohl", socket_ntohl, 4445 METH_O, ntohl_doc}, 4446 {"htons", socket_htons, 4447 METH_VARARGS, htons_doc}, 4448 {"htonl", socket_htonl, 4449 METH_O, htonl_doc}, 4450 {"inet_aton", socket_inet_aton, 4451 METH_VARARGS, inet_aton_doc}, 4452 {"inet_ntoa", socket_inet_ntoa, 4453 METH_VARARGS, inet_ntoa_doc}, 4454#ifdef HAVE_INET_PTON 4455 {"inet_pton", socket_inet_pton, 4456 METH_VARARGS, inet_pton_doc}, 4457 {"inet_ntop", socket_inet_ntop, 4458 METH_VARARGS, inet_ntop_doc}, 4459#endif 4460 {"getaddrinfo", socket_getaddrinfo, 4461 METH_VARARGS, getaddrinfo_doc}, 4462 {"getnameinfo", socket_getnameinfo, 4463 METH_VARARGS, getnameinfo_doc}, 4464 {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout, 4465 METH_NOARGS, getdefaulttimeout_doc}, 4466 {"setdefaulttimeout", socket_setdefaulttimeout, 4467 METH_O, setdefaulttimeout_doc}, 4468 {NULL, NULL} /* Sentinel */ 4469}; 4470 4471 4472#ifdef RISCOS 4473#define OS_INIT_DEFINED 4474 4475static int 4476os_init(void) 4477{ 4478 _kernel_swi_regs r; 4479 4480 r.r[0] = 0; 4481 _kernel_swi(0x43380, &r, &r); 4482 taskwindow = r.r[0]; 4483 4484 return 1; 4485} 4486 4487#endif /* RISCOS */ 4488 4489 4490#ifdef MS_WINDOWS 4491#define OS_INIT_DEFINED 4492 4493/* Additional initialization and cleanup for Windows */ 4494 4495static void 4496os_cleanup(void) 4497{ 4498 WSACleanup(); 4499} 4500 4501static int 4502os_init(void) 4503{ 4504 WSADATA WSAData; 4505 int ret; 4506 char buf[100]; 4507 ret = WSAStartup(0x0101, &WSAData); 4508 switch (ret) { 4509 case 0: /* No error */ 4510 Py_AtExit(os_cleanup); 4511 return 1; /* Success */ 4512 case WSASYSNOTREADY: 4513 PyErr_SetString(PyExc_ImportError, 4514 "WSAStartup failed: network not ready"); 4515 break; 4516 case WSAVERNOTSUPPORTED: 4517 case WSAEINVAL: 4518 PyErr_SetString( 4519 PyExc_ImportError, 4520 "WSAStartup failed: requested version not supported"); 4521 break; 4522 default: 4523 PyOS_snprintf(buf, sizeof(buf), 4524 "WSAStartup failed: error code %d", ret); 4525 PyErr_SetString(PyExc_ImportError, buf); 4526 break; 4527 } 4528 return 0; /* Failure */ 4529} 4530 4531#endif /* MS_WINDOWS */ 4532 4533 4534#ifdef PYOS_OS2 4535#define OS_INIT_DEFINED 4536 4537/* Additional initialization for OS/2 */ 4538 4539static int 4540os_init(void) 4541{ 4542#ifndef PYCC_GCC 4543 char reason[64]; 4544 int rc = sock_init(); 4545 4546 if (rc == 0) { 4547 return 1; /* Success */ 4548 } 4549 4550 PyOS_snprintf(reason, sizeof(reason), 4551 "OS/2 TCP/IP Error# %d", sock_errno()); 4552 PyErr_SetString(PyExc_ImportError, reason); 4553 4554 return 0; /* Failure */ 4555#else 4556 /* No need to initialize sockets with GCC/EMX */ 4557 return 1; /* Success */ 4558#endif 4559} 4560 4561#endif /* PYOS_OS2 */ 4562 4563 4564#ifndef OS_INIT_DEFINED 4565static int 4566os_init(void) 4567{ 4568 return 1; /* Success */ 4569} 4570#endif 4571 4572 4573/* C API table - always add new things to the end for binary 4574 compatibility. */ 4575static 4576PySocketModule_APIObject PySocketModuleAPI = 4577{ 4578 &sock_type, 4579 NULL 4580}; 4581 4582 4583/* Initialize the _socket module. 4584 4585 This module is actually called "_socket", and there's a wrapper 4586 "socket.py" which implements some additional functionality. On some 4587 platforms (e.g. Windows and OS/2), socket.py also implements a 4588 wrapper for the socket type that provides missing functionality such 4589 as makefile(), dup() and fromfd(). The import of "_socket" may fail 4590 with an ImportError exception if os-specific initialization fails. 4591 On Windows, this does WINSOCK initialization. When WINSOCK is 4592 initialized successfully, a call to WSACleanup() is scheduled to be 4593 made at exit time. 4594*/ 4595 4596PyDoc_STRVAR(socket_doc, 4597"Implementation module for socket operations.\n\ 4598\n\ 4599See the socket module for documentation."); 4600 4601PyMODINIT_FUNC 4602init_socket(void) 4603{ 4604 PyObject *m, *has_ipv6; 4605 4606 if (!os_init()) 4607 return; 4608 4609 Py_TYPE(&sock_type) = &PyType_Type; 4610 m = Py_InitModule3(PySocket_MODULE_NAME, 4611 socket_methods, 4612 socket_doc); 4613 if (m == NULL) 4614 return; 4615 4616 socket_error = PyErr_NewException("socket.error", 4617 PyExc_IOError, NULL); 4618 if (socket_error == NULL) 4619 return; 4620 PySocketModuleAPI.error = socket_error; 4621 Py_INCREF(socket_error); 4622 PyModule_AddObject(m, "error", socket_error); 4623 socket_herror = PyErr_NewException("socket.herror", 4624 socket_error, NULL); 4625 if (socket_herror == NULL) 4626 return; 4627 Py_INCREF(socket_herror); 4628 PyModule_AddObject(m, "herror", socket_herror); 4629 socket_gaierror = PyErr_NewException("socket.gaierror", socket_error, 4630 NULL); 4631 if (socket_gaierror == NULL) 4632 return; 4633 Py_INCREF(socket_gaierror); 4634 PyModule_AddObject(m, "gaierror", socket_gaierror); 4635 socket_timeout = PyErr_NewException("socket.timeout", 4636 socket_error, NULL); 4637 if (socket_timeout == NULL) 4638 return; 4639 Py_INCREF(socket_timeout); 4640 PyModule_AddObject(m, "timeout", socket_timeout); 4641 Py_INCREF((PyObject *)&sock_type); 4642 if (PyModule_AddObject(m, "SocketType", 4643 (PyObject *)&sock_type) != 0) 4644 return; 4645 Py_INCREF((PyObject *)&sock_type); 4646 if (PyModule_AddObject(m, "socket", 4647 (PyObject *)&sock_type) != 0) 4648 return; 4649 4650#ifdef ENABLE_IPV6 4651 has_ipv6 = Py_True; 4652#else 4653 has_ipv6 = Py_False; 4654#endif 4655 Py_INCREF(has_ipv6); 4656 PyModule_AddObject(m, "has_ipv6", has_ipv6); 4657 4658 /* Export C API */ 4659 if (PyModule_AddObject(m, PySocket_CAPI_NAME, 4660 PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL) 4661 ) != 0) 4662 return; 4663 4664 /* Address families (we only support AF_INET and AF_UNIX) */ 4665#ifdef AF_UNSPEC 4666 PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC); 4667#endif 4668 PyModule_AddIntConstant(m, "AF_INET", AF_INET); 4669#ifdef AF_INET6 4670 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); 4671#endif /* AF_INET6 */ 4672#if defined(AF_UNIX) 4673 PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX); 4674#endif /* AF_UNIX */ 4675#ifdef AF_AX25 4676 /* Amateur Radio AX.25 */ 4677 PyModule_AddIntConstant(m, "AF_AX25", AF_AX25); 4678#endif 4679#ifdef AF_IPX 4680 PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */ 4681#endif 4682#ifdef AF_APPLETALK 4683 /* Appletalk DDP */ 4684 PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK); 4685#endif 4686#ifdef AF_NETROM 4687 /* Amateur radio NetROM */ 4688 PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM); 4689#endif 4690#ifdef AF_BRIDGE 4691 /* Multiprotocol bridge */ 4692 PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE); 4693#endif 4694#ifdef AF_ATMPVC 4695 /* ATM PVCs */ 4696 PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC); 4697#endif 4698#ifdef AF_AAL5 4699 /* Reserved for Werner's ATM */ 4700 PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5); 4701#endif 4702#ifdef AF_X25 4703 /* Reserved for X.25 project */ 4704 PyModule_AddIntConstant(m, "AF_X25", AF_X25); 4705#endif 4706#ifdef AF_INET6 4707 PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */ 4708#endif 4709#ifdef AF_ROSE 4710 /* Amateur Radio X.25 PLP */ 4711 PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE); 4712#endif 4713#ifdef AF_DECnet 4714 /* Reserved for DECnet project */ 4715 PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet); 4716#endif 4717#ifdef AF_NETBEUI 4718 /* Reserved for 802.2LLC project */ 4719 PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI); 4720#endif 4721#ifdef AF_SECURITY 4722 /* Security callback pseudo AF */ 4723 PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY); 4724#endif 4725#ifdef AF_KEY 4726 /* PF_KEY key management API */ 4727 PyModule_AddIntConstant(m, "AF_KEY", AF_KEY); 4728#endif 4729#ifdef AF_NETLINK 4730 /* */ 4731 PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK); 4732 PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE); 4733#ifdef NETLINK_SKIP 4734 PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP); 4735#endif 4736#ifdef NETLINK_W1 4737 PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1); 4738#endif 4739 PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK); 4740 PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL); 4741#ifdef NETLINK_TCPDIAG 4742 PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG); 4743#endif 4744#ifdef NETLINK_NFLOG 4745 PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG); 4746#endif 4747#ifdef NETLINK_XFRM 4748 PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM); 4749#endif 4750#ifdef NETLINK_ARPD 4751 PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD); 4752#endif 4753#ifdef NETLINK_ROUTE6 4754 PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6); 4755#endif 4756 PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW); 4757#ifdef NETLINK_DNRTMSG 4758 PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG); 4759#endif 4760#ifdef NETLINK_TAPBASE 4761 PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE); 4762#endif 4763#endif /* AF_NETLINK */ 4764#ifdef AF_ROUTE 4765 /* Alias to emulate 4.4BSD */ 4766 PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE); 4767#endif 4768#ifdef AF_ASH 4769 /* Ash */ 4770 PyModule_AddIntConstant(m, "AF_ASH", AF_ASH); 4771#endif 4772#ifdef AF_ECONET 4773 /* Acorn Econet */ 4774 PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET); 4775#endif 4776#ifdef AF_ATMSVC 4777 /* ATM SVCs */ 4778 PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC); 4779#endif 4780#ifdef AF_SNA 4781 /* Linux SNA Project (nutters!) */ 4782 PyModule_AddIntConstant(m, "AF_SNA", AF_SNA); 4783#endif 4784#ifdef AF_IRDA 4785 /* IRDA sockets */ 4786 PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA); 4787#endif 4788#ifdef AF_PPPOX 4789 /* PPPoX sockets */ 4790 PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX); 4791#endif 4792#ifdef AF_WANPIPE 4793 /* Wanpipe API Sockets */ 4794 PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE); 4795#endif 4796#ifdef AF_LLC 4797 /* Linux LLC */ 4798 PyModule_AddIntConstant(m, "AF_LLC", AF_LLC); 4799#endif 4800 4801#ifdef USE_BLUETOOTH 4802 PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH); 4803 PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP); 4804 PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI); 4805 PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI); 4806#if !defined(__NetBSD__) && !defined(__DragonFly__) 4807 PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER); 4808#endif 4809#if !defined(__FreeBSD__) 4810#if !defined(__NetBSD__) && !defined(__DragonFly__) 4811 PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP); 4812#endif 4813 PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR); 4814 PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO); 4815#endif 4816 PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM); 4817 PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00"); 4818 PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF"); 4819#endif 4820 4821#ifdef AF_PACKET 4822 PyModule_AddIntMacro(m, AF_PACKET); 4823#endif 4824#ifdef PF_PACKET 4825 PyModule_AddIntMacro(m, PF_PACKET); 4826#endif 4827#ifdef PACKET_HOST 4828 PyModule_AddIntMacro(m, PACKET_HOST); 4829#endif 4830#ifdef PACKET_BROADCAST 4831 PyModule_AddIntMacro(m, PACKET_BROADCAST); 4832#endif 4833#ifdef PACKET_MULTICAST 4834 PyModule_AddIntMacro(m, PACKET_MULTICAST); 4835#endif 4836#ifdef PACKET_OTHERHOST 4837 PyModule_AddIntMacro(m, PACKET_OTHERHOST); 4838#endif 4839#ifdef PACKET_OUTGOING 4840 PyModule_AddIntMacro(m, PACKET_OUTGOING); 4841#endif 4842#ifdef PACKET_LOOPBACK 4843 PyModule_AddIntMacro(m, PACKET_LOOPBACK); 4844#endif 4845#ifdef PACKET_FASTROUTE 4846 PyModule_AddIntMacro(m, PACKET_FASTROUTE); 4847#endif 4848 4849#ifdef HAVE_LINUX_TIPC_H 4850 PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC); 4851 4852 /* for addresses */ 4853 PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ); 4854 PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME); 4855 PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID); 4856 4857 PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE); 4858 PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE); 4859 PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE); 4860 4861 /* for setsockopt() */ 4862 PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC); 4863 PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE); 4864 PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE); 4865 PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE", 4866 TIPC_DEST_DROPPABLE); 4867 PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT); 4868 4869 PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE", 4870 TIPC_LOW_IMPORTANCE); 4871 PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE", 4872 TIPC_MEDIUM_IMPORTANCE); 4873 PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE", 4874 TIPC_HIGH_IMPORTANCE); 4875 PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE", 4876 TIPC_CRITICAL_IMPORTANCE); 4877 4878 /* for subscriptions */ 4879 PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS); 4880 PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE); 4881#ifdef TIPC_SUB_CANCEL 4882 /* doesn't seem to be available everywhere */ 4883 PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL); 4884#endif 4885 PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER); 4886 PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED); 4887 PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN); 4888 PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT); 4889 PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV); 4890 PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV); 4891#endif 4892 4893 /* Socket types */ 4894 PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM); 4895 PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM); 4896#ifndef __BEOS__ 4897/* We have incomplete socket support. */ 4898 PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW); 4899 PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET); 4900#if defined(SOCK_RDM) 4901 PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM); 4902#endif 4903#endif 4904 4905#ifdef SO_DEBUG 4906 PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG); 4907#endif 4908#ifdef SO_ACCEPTCONN 4909 PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN); 4910#endif 4911#ifdef SO_REUSEADDR 4912 PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR); 4913#endif 4914#ifdef SO_EXCLUSIVEADDRUSE 4915 PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE); 4916#endif 4917 4918#ifdef SO_KEEPALIVE 4919 PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE); 4920#endif 4921#ifdef SO_DONTROUTE 4922 PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE); 4923#endif 4924#ifdef SO_BROADCAST 4925 PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST); 4926#endif 4927#ifdef SO_USELOOPBACK 4928 PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK); 4929#endif 4930#ifdef SO_LINGER 4931 PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER); 4932#endif 4933#ifdef SO_OOBINLINE 4934 PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE); 4935#endif 4936#ifdef SO_REUSEPORT 4937 PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT); 4938#endif 4939#ifdef SO_SNDBUF 4940 PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF); 4941#endif 4942#ifdef SO_RCVBUF 4943 PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF); 4944#endif 4945#ifdef SO_SNDLOWAT 4946 PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT); 4947#endif 4948#ifdef SO_RCVLOWAT 4949 PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT); 4950#endif 4951#ifdef SO_SNDTIMEO 4952 PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO); 4953#endif 4954#ifdef SO_RCVTIMEO 4955 PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO); 4956#endif 4957#ifdef SO_ERROR 4958 PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR); 4959#endif 4960#ifdef SO_TYPE 4961 PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE); 4962#endif 4963#ifdef SO_SETFIB 4964 PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB); 4965#endif 4966 4967 /* Maximum number of connections for "listen" */ 4968#ifdef SOMAXCONN 4969 PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN); 4970#else 4971 PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */ 4972#endif 4973 4974 /* Flags for send, recv */ 4975#ifdef MSG_OOB 4976 PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB); 4977#endif 4978#ifdef MSG_PEEK 4979 PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK); 4980#endif 4981#ifdef MSG_DONTROUTE 4982 PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE); 4983#endif 4984#ifdef MSG_DONTWAIT 4985 PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT); 4986#endif 4987#ifdef MSG_EOR 4988 PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR); 4989#endif 4990#ifdef MSG_TRUNC 4991 PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC); 4992#endif 4993#ifdef MSG_CTRUNC 4994 PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC); 4995#endif 4996#ifdef MSG_WAITALL 4997 PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL); 4998#endif 4999#ifdef MSG_BTAG 5000 PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG); 5001#endif 5002#ifdef MSG_ETAG 5003 PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG); 5004#endif 5005 5006 /* Protocol level and numbers, usable for [gs]etsockopt */ 5007#ifdef SOL_SOCKET 5008 PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET); 5009#endif 5010#ifdef SOL_IP 5011 PyModule_AddIntConstant(m, "SOL_IP", SOL_IP); 5012#else 5013 PyModule_AddIntConstant(m, "SOL_IP", 0); 5014#endif 5015#ifdef SOL_IPX 5016 PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX); 5017#endif 5018#ifdef SOL_AX25 5019 PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25); 5020#endif 5021#ifdef SOL_ATALK 5022 PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK); 5023#endif 5024#ifdef SOL_NETROM 5025 PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM); 5026#endif 5027#ifdef SOL_ROSE 5028 PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE); 5029#endif 5030#ifdef SOL_TCP 5031 PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP); 5032#else 5033 PyModule_AddIntConstant(m, "SOL_TCP", 6); 5034#endif 5035#ifdef SOL_UDP 5036 PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP); 5037#else 5038 PyModule_AddIntConstant(m, "SOL_UDP", 17); 5039#endif 5040#ifdef IPPROTO_IP 5041 PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP); 5042#else 5043 PyModule_AddIntConstant(m, "IPPROTO_IP", 0); 5044#endif 5045#ifdef IPPROTO_HOPOPTS 5046 PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS); 5047#endif 5048#ifdef IPPROTO_ICMP 5049 PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP); 5050#else 5051 PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1); 5052#endif 5053#ifdef IPPROTO_IGMP 5054 PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP); 5055#endif 5056#ifdef IPPROTO_GGP 5057 PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP); 5058#endif 5059#ifdef IPPROTO_IPV4 5060 PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4); 5061#endif 5062#ifdef IPPROTO_IPV6 5063 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6); 5064#endif 5065#ifdef IPPROTO_IPIP 5066 PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP); 5067#endif 5068#ifdef IPPROTO_TCP 5069 PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP); 5070#else 5071 PyModule_AddIntConstant(m, "IPPROTO_TCP", 6); 5072#endif 5073#ifdef IPPROTO_EGP 5074 PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP); 5075#endif 5076#ifdef IPPROTO_PUP 5077 PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP); 5078#endif 5079#ifdef IPPROTO_UDP 5080 PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP); 5081#else 5082 PyModule_AddIntConstant(m, "IPPROTO_UDP", 17); 5083#endif 5084#ifdef IPPROTO_IDP 5085 PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP); 5086#endif 5087#ifdef IPPROTO_HELLO 5088 PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO); 5089#endif 5090#ifdef IPPROTO_ND 5091 PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND); 5092#endif 5093#ifdef IPPROTO_TP 5094 PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP); 5095#endif 5096#ifdef IPPROTO_IPV6 5097 PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6); 5098#endif 5099#ifdef IPPROTO_ROUTING 5100 PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING); 5101#endif 5102#ifdef IPPROTO_FRAGMENT 5103 PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT); 5104#endif 5105#ifdef IPPROTO_RSVP 5106 PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP); 5107#endif 5108#ifdef IPPROTO_GRE 5109 PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE); 5110#endif 5111#ifdef IPPROTO_ESP 5112 PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP); 5113#endif 5114#ifdef IPPROTO_AH 5115 PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH); 5116#endif 5117#ifdef IPPROTO_MOBILE 5118 PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE); 5119#endif 5120#ifdef IPPROTO_ICMPV6 5121 PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6); 5122#endif 5123#ifdef IPPROTO_NONE 5124 PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE); 5125#endif 5126#ifdef IPPROTO_DSTOPTS 5127 PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS); 5128#endif 5129#ifdef IPPROTO_XTP 5130 PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP); 5131#endif 5132#ifdef IPPROTO_EON 5133 PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON); 5134#endif 5135#ifdef IPPROTO_PIM 5136 PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM); 5137#endif 5138#ifdef IPPROTO_IPCOMP 5139 PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP); 5140#endif 5141#ifdef IPPROTO_VRRP 5142 PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP); 5143#endif 5144#ifdef IPPROTO_BIP 5145 PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP); 5146#endif 5147/**/ 5148#ifdef IPPROTO_RAW 5149 PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW); 5150#else 5151 PyModule_AddIntConstant(m, "IPPROTO_RAW", 255); 5152#endif 5153#ifdef IPPROTO_MAX 5154 PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX); 5155#endif 5156 5157 /* Some port configuration */ 5158#ifdef IPPORT_RESERVED 5159 PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED); 5160#else 5161 PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024); 5162#endif 5163#ifdef IPPORT_USERRESERVED 5164 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED); 5165#else 5166 PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000); 5167#endif 5168 5169 /* Some reserved IP v.4 addresses */ 5170#ifdef INADDR_ANY 5171 PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY); 5172#else 5173 PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000); 5174#endif 5175#ifdef INADDR_BROADCAST 5176 PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST); 5177#else 5178 PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff); 5179#endif 5180#ifdef INADDR_LOOPBACK 5181 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK); 5182#else 5183 PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001); 5184#endif 5185#ifdef INADDR_UNSPEC_GROUP 5186 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP); 5187#else 5188 PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000); 5189#endif 5190#ifdef INADDR_ALLHOSTS_GROUP 5191 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 5192 INADDR_ALLHOSTS_GROUP); 5193#else 5194 PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001); 5195#endif 5196#ifdef INADDR_MAX_LOCAL_GROUP 5197 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 5198 INADDR_MAX_LOCAL_GROUP); 5199#else 5200 PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff); 5201#endif 5202#ifdef INADDR_NONE 5203 PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE); 5204#else 5205 PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff); 5206#endif 5207 5208 /* IPv4 [gs]etsockopt options */ 5209#ifdef IP_OPTIONS 5210 PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS); 5211#endif 5212#ifdef IP_HDRINCL 5213 PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL); 5214#endif 5215#ifdef IP_TOS 5216 PyModule_AddIntConstant(m, "IP_TOS", IP_TOS); 5217#endif 5218#ifdef IP_TTL 5219 PyModule_AddIntConstant(m, "IP_TTL", IP_TTL); 5220#endif 5221#ifdef IP_RECVOPTS 5222 PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS); 5223#endif 5224#ifdef IP_RECVRETOPTS 5225 PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS); 5226#endif 5227#ifdef IP_RECVDSTADDR 5228 PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR); 5229#endif 5230#ifdef IP_RETOPTS 5231 PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS); 5232#endif 5233#ifdef IP_MULTICAST_IF 5234 PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF); 5235#endif 5236#ifdef IP_MULTICAST_TTL 5237 PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL); 5238#endif 5239#ifdef IP_MULTICAST_LOOP 5240 PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP); 5241#endif 5242#ifdef IP_ADD_MEMBERSHIP 5243 PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP); 5244#endif 5245#ifdef IP_DROP_MEMBERSHIP 5246 PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP); 5247#endif 5248#ifdef IP_DEFAULT_MULTICAST_TTL 5249 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL", 5250 IP_DEFAULT_MULTICAST_TTL); 5251#endif 5252#ifdef IP_DEFAULT_MULTICAST_LOOP 5253 PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP", 5254 IP_DEFAULT_MULTICAST_LOOP); 5255#endif 5256#ifdef IP_MAX_MEMBERSHIPS 5257 PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS); 5258#endif 5259 5260 /* IPv6 [gs]etsockopt options, defined in RFC2553 */ 5261#ifdef IPV6_JOIN_GROUP 5262 PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP); 5263#endif 5264#ifdef IPV6_LEAVE_GROUP 5265 PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP); 5266#endif 5267#ifdef IPV6_MULTICAST_HOPS 5268 PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS); 5269#endif 5270#ifdef IPV6_MULTICAST_IF 5271 PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF); 5272#endif 5273#ifdef IPV6_MULTICAST_LOOP 5274 PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP); 5275#endif 5276#ifdef IPV6_UNICAST_HOPS 5277 PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS); 5278#endif 5279 /* Additional IPV6 socket options, defined in RFC 3493 */ 5280#ifdef IPV6_V6ONLY 5281 PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY); 5282#endif 5283 /* Advanced IPV6 socket options, from RFC 3542 */ 5284#ifdef IPV6_CHECKSUM 5285 PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM); 5286#endif 5287#ifdef IPV6_DONTFRAG 5288 PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG); 5289#endif 5290#ifdef IPV6_DSTOPTS 5291 PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS); 5292#endif 5293#ifdef IPV6_HOPLIMIT 5294 PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT); 5295#endif 5296#ifdef IPV6_HOPOPTS 5297 PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS); 5298#endif 5299#ifdef IPV6_NEXTHOP 5300 PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP); 5301#endif 5302#ifdef IPV6_PATHMTU 5303 PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU); 5304#endif 5305#ifdef IPV6_PKTINFO 5306 PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO); 5307#endif 5308#ifdef IPV6_RECVDSTOPTS 5309 PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS); 5310#endif 5311#ifdef IPV6_RECVHOPLIMIT 5312 PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT); 5313#endif 5314#ifdef IPV6_RECVHOPOPTS 5315 PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS); 5316#endif 5317#ifdef IPV6_RECVPKTINFO 5318 PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO); 5319#endif 5320#ifdef IPV6_RECVRTHDR 5321 PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR); 5322#endif 5323#ifdef IPV6_RECVTCLASS 5324 PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS); 5325#endif 5326#ifdef IPV6_RTHDR 5327 PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR); 5328#endif 5329#ifdef IPV6_RTHDRDSTOPTS 5330 PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS); 5331#endif 5332#ifdef IPV6_RTHDR_TYPE_0 5333 PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0); 5334#endif 5335#ifdef IPV6_RECVPATHMTU 5336 PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU); 5337#endif 5338#ifdef IPV6_TCLASS 5339 PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS); 5340#endif 5341#ifdef IPV6_USE_MIN_MTU 5342 PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU); 5343#endif 5344 5345 /* TCP options */ 5346#ifdef TCP_NODELAY 5347 PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY); 5348#endif 5349#ifdef TCP_MAXSEG 5350 PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG); 5351#endif 5352#ifdef TCP_CORK 5353 PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK); 5354#endif 5355#ifdef TCP_KEEPIDLE 5356 PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE); 5357#endif 5358#ifdef TCP_KEEPINTVL 5359 PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL); 5360#endif 5361#ifdef TCP_KEEPCNT 5362 PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT); 5363#endif 5364#ifdef TCP_SYNCNT 5365 PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT); 5366#endif 5367#ifdef TCP_LINGER2 5368 PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2); 5369#endif 5370#ifdef TCP_DEFER_ACCEPT 5371 PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT); 5372#endif 5373#ifdef TCP_WINDOW_CLAMP 5374 PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP); 5375#endif 5376#ifdef TCP_INFO 5377 PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO); 5378#endif 5379#ifdef TCP_QUICKACK 5380 PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK); 5381#endif 5382 5383 5384 /* IPX options */ 5385#ifdef IPX_TYPE 5386 PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE); 5387#endif 5388 5389 /* get{addr,name}info parameters */ 5390#ifdef EAI_ADDRFAMILY 5391 PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY); 5392#endif 5393#ifdef EAI_AGAIN 5394 PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN); 5395#endif 5396#ifdef EAI_BADFLAGS 5397 PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS); 5398#endif 5399#ifdef EAI_FAIL 5400 PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL); 5401#endif 5402#ifdef EAI_FAMILY 5403 PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY); 5404#endif 5405#ifdef EAI_MEMORY 5406 PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY); 5407#endif 5408#ifdef EAI_NODATA 5409 PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA); 5410#endif 5411#ifdef EAI_NONAME 5412 PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME); 5413#endif 5414#ifdef EAI_OVERFLOW 5415 PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW); 5416#endif 5417#ifdef EAI_SERVICE 5418 PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE); 5419#endif 5420#ifdef EAI_SOCKTYPE 5421 PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE); 5422#endif 5423#ifdef EAI_SYSTEM 5424 PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM); 5425#endif 5426#ifdef EAI_BADHINTS 5427 PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS); 5428#endif 5429#ifdef EAI_PROTOCOL 5430 PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL); 5431#endif 5432#ifdef EAI_MAX 5433 PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX); 5434#endif 5435#ifdef AI_PASSIVE 5436 PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE); 5437#endif 5438#ifdef AI_CANONNAME 5439 PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME); 5440#endif 5441#ifdef AI_NUMERICHOST 5442 PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST); 5443#endif 5444#ifdef AI_NUMERICSERV 5445 PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV); 5446#endif 5447#ifdef AI_MASK 5448 PyModule_AddIntConstant(m, "AI_MASK", AI_MASK); 5449#endif 5450#ifdef AI_ALL 5451 PyModule_AddIntConstant(m, "AI_ALL", AI_ALL); 5452#endif 5453#ifdef AI_V4MAPPED_CFG 5454 PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG); 5455#endif 5456#ifdef AI_ADDRCONFIG 5457 PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG); 5458#endif 5459#ifdef AI_V4MAPPED 5460 PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED); 5461#endif 5462#ifdef AI_DEFAULT 5463 PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT); 5464#endif 5465#ifdef NI_MAXHOST 5466 PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST); 5467#endif 5468#ifdef NI_MAXSERV 5469 PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV); 5470#endif 5471#ifdef NI_NOFQDN 5472 PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN); 5473#endif 5474#ifdef NI_NUMERICHOST 5475 PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST); 5476#endif 5477#ifdef NI_NAMEREQD 5478 PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD); 5479#endif 5480#ifdef NI_NUMERICSERV 5481 PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV); 5482#endif 5483#ifdef NI_DGRAM 5484 PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM); 5485#endif 5486 5487 /* shutdown() parameters */ 5488#ifdef SHUT_RD 5489 PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD); 5490#elif defined(SD_RECEIVE) 5491 PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE); 5492#else 5493 PyModule_AddIntConstant(m, "SHUT_RD", 0); 5494#endif 5495#ifdef SHUT_WR 5496 PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR); 5497#elif defined(SD_SEND) 5498 PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND); 5499#else 5500 PyModule_AddIntConstant(m, "SHUT_WR", 1); 5501#endif 5502#ifdef SHUT_RDWR 5503 PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR); 5504#elif defined(SD_BOTH) 5505 PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH); 5506#else 5507 PyModule_AddIntConstant(m, "SHUT_RDWR", 2); 5508#endif 5509 5510#ifdef SIO_RCVALL 5511 { 5512 DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS}; 5513 const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"}; 5514 int i; 5515 for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) { 5516 PyObject *tmp; 5517 tmp = PyLong_FromUnsignedLong(codes[i]); 5518 if (tmp == NULL) 5519 return; 5520 PyModule_AddObject(m, names[i], tmp); 5521 } 5522 } 5523 PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF); 5524 PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON); 5525 PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY); 5526#ifdef RCVALL_IPLEVEL 5527 PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL); 5528#endif 5529#ifdef RCVALL_MAX 5530 PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX); 5531#endif 5532#endif /* _MSTCPIP_ */ 5533 5534 /* Initialize gethostbyname lock */ 5535#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK) 5536 netdb_lock = PyThread_allocate_lock(); 5537#endif 5538} 5539 5540 5541#ifndef HAVE_INET_PTON 5542#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN) 5543 5544/* Simplistic emulation code for inet_pton that only works for IPv4 */ 5545/* These are not exposed because they do not set errno properly */ 5546 5547int 5548inet_pton(int af, const char *src, void *dst) 5549{ 5550 if (af == AF_INET) { 5551#if (SIZEOF_INT != 4) 5552#error "Not sure if in_addr_t exists and int is not 32-bits." 5553#endif 5554 unsigned int packed_addr; 5555 packed_addr = inet_addr(src); 5556 if (packed_addr == INADDR_NONE) 5557 return 0; 5558 memcpy(dst, &packed_addr, 4); 5559 return 1; 5560 } 5561 /* Should set errno to EAFNOSUPPORT */ 5562 return -1; 5563} 5564 5565const char * 5566inet_ntop(int af, const void *src, char *dst, socklen_t size) 5567{ 5568 if (af == AF_INET) { 5569 struct in_addr packed_addr; 5570 if (size < 16) 5571 /* Should set errno to ENOSPC. */ 5572 return NULL; 5573 memcpy(&packed_addr, src, sizeof(packed_addr)); 5574 return strncpy(dst, inet_ntoa(packed_addr), size); 5575 } 5576 /* Should set errno to EAFNOSUPPORT */ 5577 return NULL; 5578} 5579 5580#endif 5581#endif 5582