Modules/socketmodule.c

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