/Modules/socketmodule.c

Large files files are truncated, but you can click here to view the full file

   1/* Socket module */
   2
   3/*
   4
   5This module provides an interface to Berkeley socket IPC.
   6
   7Limitations:
   8
   9- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
  10  portable manner, though AF_PACKET and AF_NETLINK are supported under Linux.
  11- No read/write operations (use sendall/recv or makefile instead).
  12- Additional restrictions apply on some non-Unix platforms (compensated
  13  for by socket.py).
  14
  15Module interface:
  16
  17- socket.error: exception raised for socket specific errors
  18- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
  19	a subclass of socket.error
  20- socket.herror: exception raised for gethostby* errors,
  21	a subclass of socket.error
  22- socket.fromfd(fd, family, type[, proto]) --> new socket object (created
  23        from an existing file descriptor)
  24- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
  25- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
  26- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
  27- socket.getprotobyname(protocolname) --> protocol number
  28- socket.getservbyname(servicename[, protocolname]) --> port number
  29- socket.getservbyport(portnumber[, protocolname]) --> service name
  30- socket.socket([family[, type [, proto]]]) --> new socket object
  31- socket.socketpair([family[, type [, proto]]]) --> (socket, socket)
  32- socket.ntohs(16 bit value) --> new int object
  33- socket.ntohl(32 bit value) --> new int object
  34- socket.htons(16 bit value) --> new int object
  35- socket.htonl(32 bit value) --> new int object
  36- socket.getaddrinfo(host, port [, family, socktype, proto, flags])
  37	--> List of (family, socktype, proto, canonname, sockaddr)
  38- socket.getnameinfo(sockaddr, flags) --> (host, port)
  39- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
  40- socket.has_ipv6: boolean value indicating if IPv6 is supported
  41- socket.inet_aton(IP address) -> 32-bit packed IP representation
  42- socket.inet_ntoa(packed IP) -> IP address string
  43- socket.getdefaulttimeout() -> None | float
  44- socket.setdefaulttimeout(None | float)
  45- an Internet socket address is a pair (hostname, port)
  46  where hostname can be anything recognized by gethostbyname()
  47  (including the dd.dd.dd.dd notation) and port is in host byte order
  48- where a hostname is returned, the dd.dd.dd.dd notation is used
  49- a UNIX domain socket address is a string specifying the pathname
  50- an AF_PACKET socket address is a tuple containing a string
  51  specifying the ethernet interface and an integer specifying
  52  the Ethernet protocol number to be received. For example:
  53  ("eth0",0x1234).  Optional 3rd,4th,5th elements in the tuple
  54  specify packet-type and ha-type/addr.
  55
  56Local naming conventions:
  57
  58- names starting with sock_ are socket object methods
  59- names starting with socket_ are module-level functions
  60- names starting with PySocket are exported through socketmodule.h
  61
  62*/
  63
  64#ifdef __APPLE__
  65  /*
  66   * inet_aton is not available on OSX 10.3, yet we want to use a binary
  67   * that was build on 10.4 or later to work on that release, weak linking
  68   * comes to the rescue.
  69   */
  70# pragma weak inet_aton
  71#endif
  72
  73#include "Python.h"
  74#include "structmember.h"
  75
  76#undef MAX
  77#define MAX(x, y) ((x) < (y) ? (y) : (x))
  78
  79/* Socket object documentation */
  80PyDoc_STRVAR(sock_doc,
  81"socket([family[, type[, proto]]]) -> socket object\n\
  82\n\
  83Open a socket of the given type.  The family argument specifies the\n\
  84address family; it defaults to AF_INET.  The type argument specifies\n\
  85whether this is a stream (SOCK_STREAM, this is the default)\n\
  86or datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\n\
  87specifying the default protocol.  Keyword arguments are accepted.\n\
  88\n\
  89A socket object represents one endpoint of a network connection.\n\
  90\n\
  91Methods of socket objects (keyword arguments not allowed):\n\
  92\n\
  93accept() -- accept a connection, returning new socket and client address\n\
  94bind(addr) -- bind the socket to a local address\n\
  95close() -- close the socket\n\
  96connect(addr) -- connect the socket to a remote address\n\
  97connect_ex(addr) -- connect, return an error code instead of an exception\n\
  98dup() -- return a new socket object identical to the current one [*]\n\
  99fileno() -- return underlying file descriptor\n\
 100getpeername() -- return remote address [*]\n\
 101getsockname() -- return local address\n\
 102getsockopt(level, optname[, buflen]) -- get socket options\n\
 103gettimeout() -- return timeout or None\n\
 104listen(n) -- start listening for incoming connections\n\
 105makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\
 106recv(buflen[, flags]) -- receive data\n\
 107recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\
 108recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\
 109recvfrom_into(buffer[, nbytes, [, flags])\n\
 110  -- receive data and sender\'s address (into a buffer)\n\
 111sendall(data[, flags]) -- send all data\n\
 112send(data[, flags]) -- send data, may not send all of it\n\
 113sendto(data[, flags], addr) -- send data to a given address\n\
 114setblocking(0 | 1) -- set or clear the blocking I/O flag\n\
 115setsockopt(level, optname, value) -- set socket options\n\
 116settimeout(None | float) -- set or clear the timeout\n\
 117shutdown(how) -- shut down traffic in one or both directions\n\
 118\n\
 119 [*] not available on all platforms!");
 120
 121/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
 122   I hope some day someone can clean this up please... */
 123
 124/* Hacks for gethostbyname_r().  On some non-Linux platforms, the configure
 125   script doesn't get this right, so we hardcode some platform checks below.
 126   On the other hand, not all Linux versions agree, so there the settings
 127   computed by the configure script are needed! */
 128
 129#ifndef linux
 130# undef HAVE_GETHOSTBYNAME_R_3_ARG
 131# undef HAVE_GETHOSTBYNAME_R_5_ARG
 132# undef HAVE_GETHOSTBYNAME_R_6_ARG
 133#endif
 134
 135#ifndef WITH_THREAD
 136# undef HAVE_GETHOSTBYNAME_R
 137#endif
 138
 139#ifdef HAVE_GETHOSTBYNAME_R
 140# if defined(_AIX) || defined(__osf__)
 141#  define HAVE_GETHOSTBYNAME_R_3_ARG
 142# elif defined(__sun) || defined(__sgi)
 143#  define HAVE_GETHOSTBYNAME_R_5_ARG
 144# elif defined(linux)
 145/* Rely on the configure script */
 146# else
 147#  undef HAVE_GETHOSTBYNAME_R
 148# endif
 149#endif
 150
 151#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
 152    !defined(MS_WINDOWS)
 153# define USE_GETHOSTBYNAME_LOCK
 154#endif
 155
 156/* To use __FreeBSD_version */
 157#ifdef HAVE_SYS_PARAM_H
 158#include <sys/param.h>
 159#endif
 160/* On systems on which getaddrinfo() is believed to not be thread-safe,
 161   (this includes the getaddrinfo emulation) protect access with a lock. */
 162#if defined(WITH_THREAD) && (defined(__APPLE__) || \
 163    (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \
 164    defined(__OpenBSD__) || defined(__NetBSD__) || \
 165    defined(__VMS) || !defined(HAVE_GETADDRINFO))
 166#define USE_GETADDRINFO_LOCK
 167#endif
 168
 169#ifdef USE_GETADDRINFO_LOCK
 170#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
 171#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
 172#else
 173#define ACQUIRE_GETADDRINFO_LOCK
 174#define RELEASE_GETADDRINFO_LOCK
 175#endif
 176
 177#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
 178# include "pythread.h"
 179#endif
 180
 181#if defined(PYCC_VACPP)
 182# include <types.h>
 183# include <io.h>
 184# include <sys/ioctl.h>
 185# include <utils.h>
 186# include <ctype.h>
 187#endif
 188
 189#if defined(__VMS)
 190#  include <ioctl.h>
 191#endif
 192
 193#if defined(PYOS_OS2)
 194# define  INCL_DOS
 195# define  INCL_DOSERRORS
 196# define  INCL_NOPMAPI
 197# include <os2.h>
 198#endif
 199
 200#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
 201/* make sure that the reentrant (gethostbyaddr_r etc)
 202   functions are declared correctly if compiling with
 203   MIPSPro 7.x in ANSI C mode (default) */
 204
 205/* XXX Using _SGIAPI is the wrong thing,
 206   but I don't know what the right thing is. */
 207#undef _SGIAPI /* to avoid warning */
 208#define _SGIAPI 1
 209
 210#undef _XOPEN_SOURCE
 211#include <sys/socket.h>
 212#include <sys/types.h>
 213#include <netinet/in.h>
 214#ifdef _SS_ALIGNSIZE
 215#define HAVE_GETADDRINFO 1
 216#define HAVE_GETNAMEINFO 1
 217#endif
 218
 219#define HAVE_INET_PTON
 220#include <netdb.h>
 221#endif
 222
 223/* Irix 6.5 fails to define this variable at all. This is needed
 224   for both GCC and SGI's compiler. I'd say that the SGI headers
 225   are just busted. Same thing for Solaris. */
 226#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
 227#define INET_ADDRSTRLEN 16
 228#endif
 229
 230/* Generic includes */
 231#ifdef HAVE_SYS_TYPES_H
 232#include <sys/types.h>
 233#endif
 234
 235/* Generic socket object definitions and includes */
 236#define PySocket_BUILDING_SOCKET
 237#include "socketmodule.h"
 238
 239/* Addressing includes */
 240
 241#ifndef MS_WINDOWS
 242
 243/* Non-MS WINDOWS includes */
 244# include <netdb.h>
 245
 246/* Headers needed for inet_ntoa() and inet_addr() */
 247# ifdef __BEOS__
 248#  include <net/netdb.h>
 249# elif defined(PYOS_OS2) && defined(PYCC_VACPP)
 250#  include <netdb.h>
 251typedef size_t socklen_t;
 252# else
 253#   include <arpa/inet.h>
 254# endif
 255
 256# ifndef RISCOS
 257#  include <fcntl.h>
 258# else
 259#  include <sys/ioctl.h>
 260#  include <socklib.h>
 261#  define NO_DUP
 262int h_errno; /* not used */
 263#  define INET_ADDRSTRLEN 16
 264# endif
 265
 266#else
 267
 268/* MS_WINDOWS includes */
 269# ifdef HAVE_FCNTL_H
 270#  include <fcntl.h>
 271# endif
 272
 273#endif
 274
 275#include <stddef.h>
 276
 277#ifndef offsetof
 278# define offsetof(type, member)	((size_t)(&((type *)0)->member))
 279#endif
 280
 281#ifndef O_NONBLOCK
 282# define O_NONBLOCK O_NDELAY
 283#endif
 284
 285/* include Python's addrinfo.h unless it causes trouble */
 286#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
 287  /* Do not include addinfo.h on some newer IRIX versions.
 288   * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,
 289   * for example, but not by 6.5.10.
 290   */
 291#elif defined(_MSC_VER) && _MSC_VER>1201
 292  /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
 293   * EAI_* constants are defined in (the already included) ws2tcpip.h.
 294   */
 295#else
 296#  include "addrinfo.h"
 297#endif
 298
 299#ifndef HAVE_INET_PTON
 300int inet_pton(int af, const char *src, void *dst);
 301const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
 302#endif
 303
 304#ifdef __APPLE__
 305/* On OS X, getaddrinfo returns no error indication of lookup
 306   failure, so we must use the emulation instead of the libinfo
 307   implementation. Unfortunately, performing an autoconf test
 308   for this bug would require DNS access for the machine performing
 309   the configuration, which is not acceptable. Therefore, we
 310   determine the bug just by checking for __APPLE__. If this bug
 311   gets ever fixed, perhaps checking for sys/version.h would be
 312   appropriate, which is 10/0 on the system with the bug. */
 313#ifndef HAVE_GETNAMEINFO
 314/* This bug seems to be fixed in Jaguar. Ths easiest way I could
 315   Find to check for Jaguar is that it has getnameinfo(), which
 316   older releases don't have */
 317#undef HAVE_GETADDRINFO
 318#endif
 319
 320#ifdef HAVE_INET_ATON
 321#define USE_INET_ATON_WEAKLINK
 322#endif
 323
 324#endif
 325
 326/* I know this is a bad practice, but it is the easiest... */
 327#if !defined(HAVE_GETADDRINFO)
 328/* avoid clashes with the C library definition of the symbol. */
 329#define getaddrinfo fake_getaddrinfo
 330#define gai_strerror fake_gai_strerror
 331#define freeaddrinfo fake_freeaddrinfo
 332#include "getaddrinfo.c"
 333#endif
 334#if !defined(HAVE_GETNAMEINFO)
 335#define getnameinfo fake_getnameinfo
 336#include "getnameinfo.c"
 337#endif
 338
 339#if defined(MS_WINDOWS) || defined(__BEOS__)
 340/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
 341/* seem to be a few differences in the API */
 342#define SOCKETCLOSE closesocket
 343#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
 344#endif
 345
 346#ifdef MS_WIN32
 347#define EAFNOSUPPORT WSAEAFNOSUPPORT
 348#define snprintf _snprintf
 349#endif
 350
 351#if defined(PYOS_OS2) && !defined(PYCC_GCC)
 352#define SOCKETCLOSE soclose
 353#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
 354#endif
 355
 356#ifndef SOCKETCLOSE
 357#define SOCKETCLOSE close
 358#endif
 359
 360#if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)
 361#define USE_BLUETOOTH 1
 362#if defined(__FreeBSD__)
 363#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
 364#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
 365#define sockaddr_l2 sockaddr_l2cap
 366#define sockaddr_rc sockaddr_rfcomm
 367#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
 368#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
 369#elif defined(__NetBSD__)
 370#define sockaddr_l2 sockaddr_bt
 371#define sockaddr_rc sockaddr_bt
 372#define sockaddr_sco sockaddr_bt
 373#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
 374#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
 375#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
 376#else
 377#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
 378#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
 379#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
 380#endif
 381#endif
 382
 383#ifdef __VMS
 384/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
 385#define SEGMENT_SIZE (32 * 1024 -1)
 386#endif
 387
 388#define	SAS2SA(x)	((struct sockaddr *)(x))
 389
 390/*
 391 * Constants for getnameinfo()
 392 */
 393#if !defined(NI_MAXHOST)
 394#define NI_MAXHOST 1025
 395#endif
 396#if !defined(NI_MAXSERV)
 397#define NI_MAXSERV 32
 398#endif
 399
 400/* XXX There's a problem here: *static* functions are not supposed to have
 401   a Py prefix (or use CapitalizedWords).  Later... */
 402
 403/* Global variable holding the exception type for errors detected
 404   by this module (but not argument type or memory errors, etc.). */
 405static PyObject *socket_error;
 406static PyObject *socket_herror;
 407static PyObject *socket_gaierror;
 408static PyObject *socket_timeout;
 409
 410#ifdef RISCOS
 411/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
 412static int taskwindow;
 413#endif
 414
 415/* A forward reference to the socket type object.
 416   The sock_type variable contains pointers to various functions,
 417   some of which call new_sockobject(), which uses sock_type, so
 418   there has to be a circular reference. */
 419static PyTypeObject sock_type;
 420
 421#if defined(HAVE_POLL_H)
 422#include <poll.h>
 423#elif defined(HAVE_SYS_POLL_H)
 424#include <sys/poll.h>
 425#endif
 426
 427#ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
 428/* Platform can select file descriptors beyond FD_SETSIZE */
 429#define IS_SELECTABLE(s) 1
 430#elif defined(HAVE_POLL)
 431/* Instead of select(), we'll use poll() since poll() works on any fd. */
 432#define IS_SELECTABLE(s) 1
 433/* Can we call select() with this socket without a buffer overrun? */
 434#else
 435/* POSIX says selecting file descriptors beyond FD_SETSIZE
 436   has undefined behaviour.  If there's no timeout left, we don't have to
 437   call select, so it's a safe, little white lie. */
 438#define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
 439#endif
 440
 441static PyObject*
 442select_error(void)
 443{
 444	PyErr_SetString(socket_error, "unable to select on socket");
 445	return NULL;
 446}
 447
 448/* Convenience function to raise an error according to errno
 449   and return a NULL pointer from a function. */
 450
 451static PyObject *
 452set_error(void)
 453{
 454#ifdef MS_WINDOWS
 455	int err_no = WSAGetLastError();
 456	static struct {
 457		int no;
 458		const char *msg;
 459	} *msgp, msgs[] = {
 460		{WSAEINTR, "Interrupted system call"},
 461		{WSAEBADF, "Bad file descriptor"},
 462		{WSAEACCES, "Permission denied"},
 463		{WSAEFAULT, "Bad address"},
 464		{WSAEINVAL, "Invalid argument"},
 465		{WSAEMFILE, "Too many open files"},
 466		{WSAEWOULDBLOCK,
 467		  "The socket operation could not complete "
 468		  "without blocking"},
 469		{WSAEINPROGRESS, "Operation now in progress"},
 470		{WSAEALREADY, "Operation already in progress"},
 471		{WSAENOTSOCK, "Socket operation on non-socket"},
 472		{WSAEDESTADDRREQ, "Destination address required"},
 473		{WSAEMSGSIZE, "Message too long"},
 474		{WSAEPROTOTYPE, "Protocol wrong type for socket"},
 475		{WSAENOPROTOOPT, "Protocol not available"},
 476		{WSAEPROTONOSUPPORT, "Protocol not supported"},
 477		{WSAESOCKTNOSUPPORT, "Socket type not supported"},
 478		{WSAEOPNOTSUPP, "Operation not supported"},
 479		{WSAEPFNOSUPPORT, "Protocol family not supported"},
 480		{WSAEAFNOSUPPORT, "Address family not supported"},
 481		{WSAEADDRINUSE, "Address already in use"},
 482		{WSAEADDRNOTAVAIL, "Can't assign requested address"},
 483		{WSAENETDOWN, "Network is down"},
 484		{WSAENETUNREACH, "Network is unreachable"},
 485		{WSAENETRESET, "Network dropped connection on reset"},
 486		{WSAECONNABORTED, "Software caused connection abort"},
 487		{WSAECONNRESET, "Connection reset by peer"},
 488		{WSAENOBUFS, "No buffer space available"},
 489		{WSAEISCONN, "Socket is already connected"},
 490		{WSAENOTCONN, "Socket is not connected"},
 491		{WSAESHUTDOWN, "Can't send after socket shutdown"},
 492		{WSAETOOMANYREFS, "Too many references: can't splice"},
 493		{WSAETIMEDOUT, "Operation timed out"},
 494		{WSAECONNREFUSED, "Connection refused"},
 495		{WSAELOOP, "Too many levels of symbolic links"},
 496		{WSAENAMETOOLONG, "File name too long"},
 497		{WSAEHOSTDOWN, "Host is down"},
 498		{WSAEHOSTUNREACH, "No route to host"},
 499		{WSAENOTEMPTY, "Directory not empty"},
 500		{WSAEPROCLIM, "Too many processes"},
 501		{WSAEUSERS, "Too many users"},
 502		{WSAEDQUOT, "Disc quota exceeded"},
 503		{WSAESTALE, "Stale NFS file handle"},
 504		{WSAEREMOTE, "Too many levels of remote in path"},
 505		{WSASYSNOTREADY, "Network subsystem is unvailable"},
 506		{WSAVERNOTSUPPORTED, "WinSock version is not supported"},
 507		{WSANOTINITIALISED,
 508		  "Successful WSAStartup() not yet performed"},
 509		{WSAEDISCON, "Graceful shutdown in progress"},
 510		/* Resolver errors */
 511		{WSAHOST_NOT_FOUND, "No such host is known"},
 512		{WSATRY_AGAIN, "Host not found, or server failed"},
 513		{WSANO_RECOVERY, "Unexpected server error encountered"},
 514		{WSANO_DATA, "Valid name without requested data"},
 515		{WSANO_ADDRESS, "No address, look for MX record"},
 516		{0, NULL}
 517	};
 518	if (err_no) {
 519		PyObject *v;
 520		const char *msg = "winsock error";
 521
 522		for (msgp = msgs; msgp->msg; msgp++) {
 523			if (err_no == msgp->no) {
 524				msg = msgp->msg;
 525				break;
 526			}
 527		}
 528
 529		v = Py_BuildValue("(is)", err_no, msg);
 530		if (v != NULL) {
 531			PyErr_SetObject(socket_error, v);
 532			Py_DECREF(v);
 533		}
 534		return NULL;
 535	}
 536	else
 537#endif
 538
 539#if defined(PYOS_OS2) && !defined(PYCC_GCC)
 540	if (sock_errno() != NO_ERROR) {
 541		APIRET rc;
 542		ULONG  msglen;
 543		char outbuf[100];
 544		int myerrorcode = sock_errno();
 545
 546		/* Retrieve socket-related error message from MPTN.MSG file */
 547		rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
 548				   myerrorcode - SOCBASEERR + 26,
 549				   "mptn.msg",
 550				   &msglen);
 551		if (rc == NO_ERROR) {
 552			PyObject *v;
 553
 554			/* OS/2 doesn't guarantee a terminator */
 555			outbuf[msglen] = '\0';
 556			if (strlen(outbuf) > 0) {
 557				/* If non-empty msg, trim CRLF */
 558				char *lastc = &outbuf[ strlen(outbuf)-1 ];
 559				while (lastc > outbuf &&
 560				       isspace(Py_CHARMASK(*lastc))) {
 561					/* Trim trailing whitespace (CRLF) */
 562					*lastc-- = '\0';
 563				}
 564			}
 565			v = Py_BuildValue("(is)", myerrorcode, outbuf);
 566			if (v != NULL) {
 567				PyErr_SetObject(socket_error, v);
 568				Py_DECREF(v);
 569			}
 570			return NULL;
 571		}
 572	}
 573#endif
 574
 575#if defined(RISCOS)
 576	if (_inet_error.errnum != NULL) {
 577		PyObject *v;
 578		v = Py_BuildValue("(is)", errno, _inet_err());
 579		if (v != NULL) {
 580			PyErr_SetObject(socket_error, v);
 581			Py_DECREF(v);
 582		}
 583		return NULL;
 584	}
 585#endif
 586
 587	return PyErr_SetFromErrno(socket_error);
 588}
 589
 590
 591static PyObject *
 592set_herror(int h_error)
 593{
 594	PyObject *v;
 595
 596#ifdef HAVE_HSTRERROR
 597	v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
 598#else
 599	v = Py_BuildValue("(is)", h_error, "host not found");
 600#endif
 601	if (v != NULL) {
 602		PyErr_SetObject(socket_herror, v);
 603		Py_DECREF(v);
 604	}
 605
 606	return NULL;
 607}
 608
 609
 610static PyObject *
 611set_gaierror(int error)
 612{
 613	PyObject *v;
 614
 615#ifdef EAI_SYSTEM
 616	/* EAI_SYSTEM is not available on Windows XP. */
 617	if (error == EAI_SYSTEM)
 618		return set_error();
 619#endif
 620
 621#ifdef HAVE_GAI_STRERROR
 622	v = Py_BuildValue("(is)", error, gai_strerror(error));
 623#else
 624	v = Py_BuildValue("(is)", error, "getaddrinfo failed");
 625#endif
 626	if (v != NULL) {
 627		PyErr_SetObject(socket_gaierror, v);
 628		Py_DECREF(v);
 629	}
 630
 631	return NULL;
 632}
 633
 634#ifdef __VMS
 635/* Function to send in segments */
 636static int
 637sendsegmented(int sock_fd, char *buf, int len, int flags)
 638{
 639	int n = 0;
 640	int remaining = len;
 641
 642	while (remaining > 0) {
 643		unsigned int segment;
 644
 645		segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);
 646		n = send(sock_fd, buf, segment, flags);
 647		if (n < 0) {
 648			return n;
 649		}
 650		remaining -= segment;
 651		buf += segment;
 652	} /* end while */
 653
 654	return len;
 655}
 656#endif
 657
 658/* Function to perform the setting of socket blocking mode
 659   internally. block = (1 | 0). */
 660static int
 661internal_setblocking(PySocketSockObject *s, int block)
 662{
 663#ifndef RISCOS
 664#ifndef MS_WINDOWS
 665	int delay_flag;
 666#endif
 667#endif
 668
 669	Py_BEGIN_ALLOW_THREADS
 670#ifdef __BEOS__
 671	block = !block;
 672	setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
 673		   (void *)(&block), sizeof(int));
 674#else
 675#ifndef RISCOS
 676#ifndef MS_WINDOWS
 677#if defined(PYOS_OS2) && !defined(PYCC_GCC)
 678	block = !block;
 679	ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
 680#elif defined(__VMS)
 681	block = !block;
 682	ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);
 683#else  /* !PYOS_OS2 && !__VMS */
 684	delay_flag = fcntl(s->sock_fd, F_GETFL, 0);
 685	if (block)
 686		delay_flag &= (~O_NONBLOCK);
 687	else
 688		delay_flag |= O_NONBLOCK;
 689	fcntl(s->sock_fd, F_SETFL, delay_flag);
 690#endif /* !PYOS_OS2 */
 691#else /* MS_WINDOWS */
 692	block = !block;
 693	ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
 694#endif /* MS_WINDOWS */
 695#else /* RISCOS */
 696	block = !block;
 697	socketioctl(s->sock_fd, FIONBIO, (u_long*)&block);
 698#endif /* RISCOS */
 699#endif /* __BEOS__ */
 700	Py_END_ALLOW_THREADS
 701
 702	/* Since these don't return anything */
 703	return 1;
 704}
 705
 706/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
 707   The argument writing indicates the direction.
 708   This does not raise an exception; we'll let our caller do that
 709   after they've reacquired the interpreter lock.
 710   Returns 1 on timeout, -1 on error, 0 otherwise. */
 711static int
 712internal_select(PySocketSockObject *s, int writing)
 713{
 714	int n;
 715
 716	/* Nothing to do unless we're in timeout mode (not non-blocking) */
 717	if (s->sock_timeout <= 0.0)
 718		return 0;
 719
 720	/* Guard against closed socket */
 721	if (s->sock_fd < 0)
 722		return 0;
 723
 724	/* Prefer poll, if available, since you can poll() any fd
 725	 * which can't be done with select(). */
 726#ifdef HAVE_POLL
 727	{
 728		struct pollfd pollfd;
 729		int timeout;
 730
 731		pollfd.fd = s->sock_fd;
 732		pollfd.events = writing ? POLLOUT : POLLIN;
 733
 734		/* s->sock_timeout is in seconds, timeout in ms */
 735		timeout = (int)(s->sock_timeout * 1000 + 0.5); 
 736		n = poll(&pollfd, 1, timeout);
 737	}
 738#else
 739	{
 740		/* Construct the arguments to select */
 741		fd_set fds;
 742		struct timeval tv;
 743		tv.tv_sec = (int)s->sock_timeout;
 744		tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
 745		FD_ZERO(&fds);
 746		FD_SET(s->sock_fd, &fds);
 747
 748		/* See if the socket is ready */
 749		if (writing)
 750			n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);
 751		else
 752			n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);
 753	}
 754#endif
 755	
 756	if (n < 0)
 757		return -1;
 758	if (n == 0)
 759		return 1;
 760	return 0;
 761}
 762
 763/* Initialize a new socket object. */
 764
 765static double defaulttimeout = -1.0; /* Default timeout for new sockets */
 766
 767PyMODINIT_FUNC
 768init_sockobject(PySocketSockObject *s,
 769		SOCKET_T fd, int family, int type, int proto)
 770{
 771#ifdef RISCOS
 772	int block = 1;
 773#endif
 774	s->sock_fd = fd;
 775	s->sock_family = family;
 776	s->sock_type = type;
 777	s->sock_proto = proto;
 778	s->sock_timeout = defaulttimeout;
 779
 780	s->errorhandler = &set_error;
 781
 782	if (defaulttimeout >= 0.0)
 783		internal_setblocking(s, 0);
 784
 785#ifdef RISCOS
 786	if (taskwindow)
 787		socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
 788#endif
 789}
 790
 791
 792/* Create a new socket object.
 793   This just creates the object and initializes it.
 794   If the creation fails, return NULL and set an exception (implicit
 795   in NEWOBJ()). */
 796
 797static PySocketSockObject *
 798new_sockobject(SOCKET_T fd, int family, int type, int proto)
 799{
 800	PySocketSockObject *s;
 801	s = (PySocketSockObject *)
 802		PyType_GenericNew(&sock_type, NULL, NULL);
 803	if (s != NULL)
 804		init_sockobject(s, fd, family, type, proto);
 805	return s;
 806}
 807
 808
 809/* Lock to allow python interpreter to continue, but only allow one
 810   thread to be in gethostbyname or getaddrinfo */
 811#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
 812PyThread_type_lock netdb_lock;
 813#endif
 814
 815
 816/* Convert a string specifying a host name or one of a few symbolic
 817   names to a numeric IP address.  This usually calls gethostbyname()
 818   to do the work; the names "" and "<broadcast>" are special.
 819   Return the length (IPv4 should be 4 bytes), or negative if
 820   an error occurred; then an exception is raised. */
 821
 822static int
 823setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)
 824{
 825	struct addrinfo hints, *res;
 826	int error;
 827	int d1, d2, d3, d4;
 828	char ch;
 829
 830	memset((void *) addr_ret, '\0', sizeof(*addr_ret));
 831	if (name[0] == '\0') {
 832		int siz;
 833		memset(&hints, 0, sizeof(hints));
 834		hints.ai_family = af;
 835		hints.ai_socktype = SOCK_DGRAM;	/*dummy*/
 836		hints.ai_flags = AI_PASSIVE;
 837		Py_BEGIN_ALLOW_THREADS
 838		ACQUIRE_GETADDRINFO_LOCK
 839		error = getaddrinfo(NULL, "0", &hints, &res);
 840		Py_END_ALLOW_THREADS
 841		/* We assume that those thread-unsafe getaddrinfo() versions
 842		   *are* safe regarding their return value, ie. that a
 843		   subsequent call to getaddrinfo() does not destroy the
 844		   outcome of the first call. */
 845		RELEASE_GETADDRINFO_LOCK
 846		if (error) {
 847			set_gaierror(error);
 848			return -1;
 849		}
 850		switch (res->ai_family) {
 851		case AF_INET:
 852			siz = 4;
 853			break;
 854#ifdef ENABLE_IPV6
 855		case AF_INET6:
 856			siz = 16;
 857			break;
 858#endif
 859		default:
 860			freeaddrinfo(res);
 861			PyErr_SetString(socket_error,
 862				"unsupported address family");
 863			return -1;
 864		}
 865		if (res->ai_next) {
 866			freeaddrinfo(res);
 867			PyErr_SetString(socket_error,
 868				"wildcard resolved to multiple address");
 869			return -1;
 870		}
 871		if (res->ai_addrlen < addr_ret_size)
 872			addr_ret_size = res->ai_addrlen;
 873		memcpy(addr_ret, res->ai_addr, addr_ret_size);
 874		freeaddrinfo(res);
 875		return siz;
 876	}
 877	if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
 878		struct sockaddr_in *sin;
 879		if (af != AF_INET && af != AF_UNSPEC) {
 880			PyErr_SetString(socket_error,
 881				"address family mismatched");
 882			return -1;
 883		}
 884		sin = (struct sockaddr_in *)addr_ret;
 885		memset((void *) sin, '\0', sizeof(*sin));
 886		sin->sin_family = AF_INET;
 887#ifdef HAVE_SOCKADDR_SA_LEN
 888		sin->sin_len = sizeof(*sin);
 889#endif
 890		sin->sin_addr.s_addr = INADDR_BROADCAST;
 891		return sizeof(sin->sin_addr);
 892	}
 893	if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
 894	    0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
 895	    0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
 896		struct sockaddr_in *sin;
 897		sin = (struct sockaddr_in *)addr_ret;
 898		sin->sin_addr.s_addr = htonl(
 899			((long) d1 << 24) | ((long) d2 << 16) |
 900			((long) d3 << 8) | ((long) d4 << 0));
 901		sin->sin_family = AF_INET;
 902#ifdef HAVE_SOCKADDR_SA_LEN
 903		sin->sin_len = sizeof(*sin);
 904#endif
 905		return 4;
 906	}
 907	memset(&hints, 0, sizeof(hints));
 908	hints.ai_family = af;
 909	Py_BEGIN_ALLOW_THREADS
 910	ACQUIRE_GETADDRINFO_LOCK
 911	error = getaddrinfo(name, NULL, &hints, &res);
 912#if defined(__digital__) && defined(__unix__)
 913	if (error == EAI_NONAME && af == AF_UNSPEC) {
 914		/* On Tru64 V5.1, numeric-to-addr conversion fails
 915		   if no address family is given. Assume IPv4 for now.*/
 916		hints.ai_family = AF_INET;
 917		error = getaddrinfo(name, NULL, &hints, &res);
 918	}
 919#endif
 920	Py_END_ALLOW_THREADS
 921	RELEASE_GETADDRINFO_LOCK  /* see comment in setipaddr() */
 922	if (error) {
 923		set_gaierror(error);
 924		return -1;
 925	}
 926	if (res->ai_addrlen < addr_ret_size)
 927		addr_ret_size = res->ai_addrlen;
 928	memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
 929	freeaddrinfo(res);
 930	switch (addr_ret->sa_family) {
 931	case AF_INET:
 932		return 4;
 933#ifdef ENABLE_IPV6
 934	case AF_INET6:
 935		return 16;
 936#endif
 937	default:
 938		PyErr_SetString(socket_error, "unknown address family");
 939		return -1;
 940	}
 941}
 942
 943
 944/* Create a string object representing an IP address.
 945   This is always a string of the form 'dd.dd.dd.dd' (with variable
 946   size numbers). */
 947
 948static PyObject *
 949makeipaddr(struct sockaddr *addr, int addrlen)
 950{
 951	char buf[NI_MAXHOST];
 952	int error;
 953
 954	error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
 955		NI_NUMERICHOST);
 956	if (error) {
 957		set_gaierror(error);
 958		return NULL;
 959	}
 960	return PyString_FromString(buf);
 961}
 962
 963
 964#ifdef USE_BLUETOOTH
 965/* Convert a string representation of a Bluetooth address into a numeric
 966   address.  Returns the length (6), or raises an exception and returns -1 if
 967   an error occurred. */
 968
 969static int
 970setbdaddr(char *name, bdaddr_t *bdaddr)
 971{
 972	unsigned int b0, b1, b2, b3, b4, b5;
 973	char ch;
 974	int n;
 975
 976	n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",
 977		   &b5, &b4, &b3, &b2, &b1, &b0, &ch);
 978	if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {
 979		bdaddr->b[0] = b0;
 980		bdaddr->b[1] = b1;
 981		bdaddr->b[2] = b2;
 982		bdaddr->b[3] = b3;
 983		bdaddr->b[4] = b4;
 984		bdaddr->b[5] = b5;
 985		return 6;
 986	} else {
 987		PyErr_SetString(socket_error, "bad bluetooth address");
 988		return -1;
 989	}
 990}
 991
 992/* Create a string representation of the Bluetooth address.  This is always a
 993   string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal
 994   value (zero padded if necessary). */
 995
 996static PyObject *
 997makebdaddr(bdaddr_t *bdaddr)
 998{
 999	char buf[(6 * 2) + 5 + 1];
1000
1001	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1002		bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],
1003		bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);
1004	return PyString_FromString(buf);
1005}
1006#endif
1007
1008
1009/* Create an object representing the given socket address,
1010   suitable for passing it back to bind(), connect() etc.
1011   The family field of the sockaddr structure is inspected
1012   to determine what kind of address it really is. */
1013
1014/*ARGSUSED*/
1015static PyObject *
1016makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)
1017{
1018	if (addrlen == 0) {
1019		/* No address -- may be recvfrom() from known socket */
1020		Py_INCREF(Py_None);
1021		return Py_None;
1022	}
1023
1024#ifdef __BEOS__
1025	/* XXX: BeOS version of accept() doesn't set family correctly */
1026	addr->sa_family = AF_INET;
1027#endif
1028
1029	switch (addr->sa_family) {
1030
1031	case AF_INET:
1032	{
1033		struct sockaddr_in *a;
1034		PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1035		PyObject *ret = NULL;
1036		if (addrobj) {
1037			a = (struct sockaddr_in *)addr;
1038			ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
1039			Py_DECREF(addrobj);
1040		}
1041		return ret;
1042	}
1043
1044#if defined(AF_UNIX)
1045	case AF_UNIX:
1046	{
1047		struct sockaddr_un *a = (struct sockaddr_un *) addr;
1048#ifdef linux
1049		if (a->sun_path[0] == 0) {  /* Linux abstract namespace */
1050			addrlen -= (sizeof(*a) - sizeof(a->sun_path));
1051			return PyString_FromStringAndSize(a->sun_path,
1052							  addrlen);
1053		}
1054		else
1055#endif /* linux */
1056		{
1057			/* regular NULL-terminated string */
1058			return PyString_FromString(a->sun_path);
1059		}
1060	}
1061#endif /* AF_UNIX */
1062
1063#if defined(AF_NETLINK)
1064       case AF_NETLINK:
1065       {
1066               struct sockaddr_nl *a = (struct sockaddr_nl *) addr;
1067               return Py_BuildValue("II", a->nl_pid, a->nl_groups);
1068       }
1069#endif /* AF_NETLINK */
1070
1071#ifdef ENABLE_IPV6
1072	case AF_INET6:
1073	{
1074		struct sockaddr_in6 *a;
1075		PyObject *addrobj = makeipaddr(addr, sizeof(*a));
1076		PyObject *ret = NULL;
1077		if (addrobj) {
1078			a = (struct sockaddr_in6 *)addr;
1079			ret = Py_BuildValue("Oiii",
1080					    addrobj,
1081					    ntohs(a->sin6_port),
1082					    a->sin6_flowinfo,
1083					    a->sin6_scope_id);
1084			Py_DECREF(addrobj);
1085		}
1086		return ret;
1087	}
1088#endif
1089
1090#ifdef USE_BLUETOOTH
1091	case AF_BLUETOOTH:
1092		switch (proto) {
1093
1094		case BTPROTO_L2CAP:
1095		{
1096			struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;
1097			PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));
1098			PyObject *ret = NULL;
1099			if (addrobj) {
1100				ret = Py_BuildValue("Oi",
1101						    addrobj,
1102						    _BT_L2_MEMB(a, psm));
1103				Py_DECREF(addrobj);
1104			}
1105			return ret;
1106		}
1107
1108		case BTPROTO_RFCOMM:
1109		{
1110			struct sockaddr_rc *a = (struct sockaddr_rc *) addr;
1111			PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));
1112			PyObject *ret = NULL;
1113			if (addrobj) {
1114				ret = Py_BuildValue("Oi",
1115						    addrobj,
1116						    _BT_RC_MEMB(a, channel));
1117				Py_DECREF(addrobj);
1118			}
1119			return ret;
1120		}
1121
1122#if !defined(__FreeBSD__)
1123		case BTPROTO_SCO:
1124		{
1125			struct sockaddr_sco *a = (struct sockaddr_sco *) addr;
1126			return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));
1127		}
1128#endif
1129
1130		}
1131#endif
1132
1133#ifdef HAVE_NETPACKET_PACKET_H
1134	case AF_PACKET:
1135	{
1136		struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
1137		char *ifname = "";
1138		struct ifreq ifr;
1139		/* need to look up interface name give index */
1140		if (a->sll_ifindex) {
1141			ifr.ifr_ifindex = a->sll_ifindex;
1142			if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
1143				ifname = ifr.ifr_name;
1144		}
1145		return Py_BuildValue("shbhs#",
1146				     ifname,
1147				     ntohs(a->sll_protocol),
1148				     a->sll_pkttype,
1149				     a->sll_hatype,
1150				     a->sll_addr,
1151				     a->sll_halen);
1152	}
1153#endif
1154
1155	/* More cases here... */
1156
1157	default:
1158		/* If we don't know the address family, don't raise an
1159		   exception -- return it as a tuple. */
1160		return Py_BuildValue("is#",
1161				     addr->sa_family,
1162				     addr->sa_data,
1163				     sizeof(addr->sa_data));
1164
1165	}
1166}
1167
1168
1169/* Parse a socket address argument according to the socket object's
1170   address family.  Return 1 if the address was in the proper format,
1171   0 of not.  The address is returned through addr_ret, its length
1172   through len_ret. */
1173
1174static int
1175getsockaddrarg(PySocketSockObject *s, PyObject *args,
1176	       struct sockaddr *addr_ret, int *len_ret)
1177{
1178	switch (s->sock_family) {
1179
1180#if defined(AF_UNIX)
1181	case AF_UNIX:
1182	{
1183		struct sockaddr_un* addr;
1184		char *path;
1185		int len;
1186		if (!PyArg_Parse(args, "t#", &path, &len))
1187			return 0;
1188
1189		addr = (struct sockaddr_un*)addr_ret;
1190#ifdef linux
1191		if (len > 0 && path[0] == 0) {
1192			/* Linux abstract namespace extension */
1193			if (len > sizeof addr->sun_path) {
1194				PyErr_SetString(socket_error,
1195						"AF_UNIX path too long");
1196				return 0;
1197			}
1198		}
1199		else
1200#endif /* linux */
1201                {
1202			/* regular NULL-terminated string */
1203			if (len >= sizeof addr->sun_path) {
1204				PyErr_SetString(socket_error,
1205						"AF_UNIX path too long");
1206				return 0;
1207			}
1208			addr->sun_path[len] = 0;
1209		}
1210		addr->sun_family = s->sock_family;
1211		memcpy(addr->sun_path, path, len);
1212#if defined(PYOS_OS2)
1213		*len_ret = sizeof(*addr);
1214#else
1215		*len_ret = len + sizeof(*addr) - sizeof(addr->sun_path);
1216#endif
1217		return 1;
1218	}
1219#endif /* AF_UNIX */
1220
1221#if defined(AF_NETLINK)
1222	case AF_NETLINK:
1223	{
1224		struct sockaddr_nl* addr;
1225		int pid, groups;
1226		addr = (struct sockaddr_nl *)addr_ret;
1227		if (!PyTuple_Check(args)) {
1228			PyErr_Format(
1229				PyExc_TypeError,
1230				"getsockaddrarg: "
1231				"AF_NETLINK address must be tuple, not %.500s",
1232				args->ob_type->tp_name);
1233			return 0;
1234		}
1235		if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))
1236			return 0;
1237		addr->nl_family = AF_NETLINK;
1238		addr->nl_pid = pid;
1239		addr->nl_groups = groups;
1240		*len_ret = sizeof(*addr);
1241		return 1;
1242	}
1243#endif
1244
1245	case AF_INET:
1246	{
1247		struct sockaddr_in* addr;
1248		char *host;
1249		int port, result;
1250		if (!PyTuple_Check(args)) {
1251			PyErr_Format(
1252				PyExc_TypeError,
1253				"getsockaddrarg: "
1254				"AF_INET address must be tuple, not %.500s",
1255				args->ob_type->tp_name);
1256			return 0;
1257		}
1258		if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",
1259				      "idna", &host, &port))
1260			return 0;
1261		addr=(struct sockaddr_in*)addr_ret;
1262                result = setipaddr(host, (struct sockaddr *)addr,
1263                                   sizeof(*addr),  AF_INET);
1264                PyMem_Free(host);
1265                if (result < 0)
1266			return 0;
1267		addr->sin_family = AF_INET;
1268		addr->sin_port = htons((short)port);
1269		*len_ret = sizeof *addr;
1270		return 1;
1271	}
1272
1273#ifdef ENABLE_IPV6
1274	case AF_INET6:
1275	{
1276		struct sockaddr_in6* addr;
1277		char *host;
1278		int port, flowinfo, scope_id, result;
1279		flowinfo = scope_id = 0;
1280		if (!PyTuple_Check(args)) {
1281			PyErr_Format(
1282				PyExc_TypeError,
1283				"getsockaddrarg: "
1284				"AF_INET6 address must be tuple, not %.500s",
1285				args->ob_type->tp_name);
1286			return 0;
1287		}
1288		if (!PyArg_ParseTuple(args, "eti|ii",
1289				      "idna", &host, &port, &flowinfo,
1290				      &scope_id)) {
1291			return 0;
1292		}
1293		addr = (struct sockaddr_in6*)addr_ret;
1294                result = setipaddr(host, (struct sockaddr *)addr,
1295                                   sizeof(*addr), AF_INET6);
1296                PyMem_Free(host);
1297                if (result < 0)
1298			return 0;
1299		addr->sin6_family = s->sock_family;
1300		addr->sin6_port = htons((short)port);
1301		addr->sin6_flowinfo = flowinfo;
1302		addr->sin6_scope_id = scope_id;
1303		*len_ret = sizeof *addr;
1304		return 1;
1305	}
1306#endif
1307
1308#ifdef USE_BLUETOOTH
1309	case AF_BLUETOOTH:
1310	{
1311		switch (s->sock_proto) {
1312		case BTPROTO_L2CAP:
1313		{
1314			struct sockaddr_l2 *addr;
1315			char *straddr;
1316
1317			addr = (struct sockaddr_l2 *)addr_ret;
1318			_BT_L2_MEMB(addr, family) = AF_BLUETOOTH;
1319			if (!PyArg_ParseTuple(args, "si", &straddr,
1320					      &_BT_L2_MEMB(addr, psm))) {
1321				PyErr_SetString(socket_error, "getsockaddrarg: "
1322						"wrong format");
1323				return 0;
1324			}
1325			if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)
1326				return 0;
1327
1328			*len_ret = sizeof *addr;
1329			return 1;
1330		}
1331		case BTPROTO_RFCOMM:
1332		{
1333			struct sockaddr_rc *addr;
1334			char *straddr;
1335
1336			addr = (struct sockaddr_rc *)addr_ret;
1337			_BT_RC_MEMB(addr, family) = AF_BLUETOOTH;
1338			if (!PyArg_ParseTuple(args, "si", &straddr,
1339					      &_BT_RC_MEMB(addr, channel))) {
1340				PyErr_SetString(socket_error, "getsockaddrarg: "
1341						"wrong format");
1342				return 0;
1343			}
1344			if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)
1345				return 0;
1346
1347			*len_ret = sizeof *addr;
1348			return 1;
1349		}
1350#if !defined(__FreeBSD__)
1351		case BTPROTO_SCO:
1352		{
1353			struct sockaddr_sco *addr;
1354			char *straddr;
1355
1356			addr = (struct sockaddr_sco *)addr_ret;
1357			_BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;
1358			straddr = PyString_AsString(args);
1359			if (straddr == NULL) {
1360				PyErr_SetString(socket_error, "getsockaddrarg: "
1361						"wrong format");
1362				return 0;
1363			}
1364			if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)
1365				return 0;
1366
1367			*len_ret = sizeof *addr;
1368			return 1;
1369		}
1370#endif
1371		default:
1372			PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");
1373			return 0;
1374		}
1375	}
1376#endif
1377
1378#ifdef HAVE_NETPACKET_PACKET_H
1379	case AF_PACKET:
1380	{
1381		struct sockaddr_ll* addr;
1382		struct ifreq ifr;
1383		char *interfaceName;
1384		int protoNumber;
1385		int hatype = 0;
1386		int pkttype = 0;
1387		char *haddr = NULL;
1388		unsigned int halen = 0;
1389
1390		if (!PyTuple_Check(args)) {
1391			PyErr_Format(
1392				PyExc_TypeError,
1393				"getsockaddrarg: "
1394				"AF_PACKET address must be tuple, not %.500s",
1395				args->ob_type->tp_name);
1396			return 0;
1397		}
1398		if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName,
1399				      &protoNumber, &pkttype, &hatype,
1400				      &haddr, &halen))
1401			return 0;
1402		strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
1403		ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
1404		if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
1405		        s->errorhandler();
1406			return 0;
1407		}
1408		if (halen > 8) {
1409		  PyErr_SetString(PyExc_ValueError,
1410				  "Hardware address must be 8 bytes or less");
1411		  return 0;
1412		}
1413		addr = (struct sockaddr_ll*)addr_ret;
1414		addr->sll_family = AF_PACKET;
1415		addr->sll_protocol = htons((short)protoNumber);
1416		addr->sll_ifindex = ifr.ifr_ifindex;
1417		addr->sll_pkttype = pkttype;
1418		addr->sll_hatype = hatype;
1419		if (halen != 0) {
1420		  memcpy(&addr->sll_addr, haddr, halen);
1421		}
1422		addr->sll_halen = halen;
1423		*len_ret = sizeof *addr;
1424		return 1;
1425	}
1426#endif
1427
1428	/* More cases here... */
1429
1430	default:
1431		PyErr_SetString(socket_error, "getsockaddrarg: bad family");
1432		return 0;
1433
1434	}
1435}
1436
1437
1438/* Get the address length according to the socket object's address family.
1439   Return 1 if the family is known, 0 otherwise.  The length is returned
1440   through len_ret. */
1441
1442static int
1443getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
1444{
1445	switch (s->sock_family) {
1446
1447#if defined(AF_UNIX)
1448	case AF_UNIX:
1449	{
1450		*len_ret = sizeof (struct sockaddr_un);
1451		return 1;
1452	}
1453#endif /* AF_UNIX */
1454#if defined(AF_NETLINK)
1455       case AF_NETLINK:
1456       {
1457               *len_ret = sizeof (struct sockaddr_nl);
1458               return 1;
1459       }
1460#endif
1461
1462	case AF_INET:
1463	{
1464		*len_ret = sizeof (struct sockaddr_in);
1465		return 1;
1466	}
1467
1468#ifdef ENABLE_IPV6
1469	case AF_INET6:
1470	{
1471		*len_ret = sizeof (struct sockaddr_in6);
1472		return 1;
1473	}
1474#endif
1475
1476#ifdef USE_BLUETOOTH
1477	case AF_BLUETOOTH:
1478	{
1479		switch(s->sock_proto)
1480		{
1481
1482		case BTPROTO_L2CAP:
1483			*len_ret = sizeof (struct sockaddr_l2);
1484			return 1;
1485		case BTPROTO_RFCOMM:
1486			*len_ret = sizeof (struct sockaddr_rc);
1487			return 1;
1488#if !defined(__FreeBSD__)
1489		case BTPROTO_SCO:
1490			*len_ret = sizeof (struct sockaddr_sco);
1491			return 1;
1492#endif
1493		default:
1494			PyErr_SetString(socket_error, "getsockaddrlen: "
1495					"unknown BT protocol");
1496			return 0;
1497
1498		}
1499	}
1500#endif
1501
1502#ifdef HAVE_NETPACKET_PACKET_H
1503	case AF_PACKET:
1504	{
1505		*len_ret = sizeof (struct sockaddr_ll);
1506		return 1;
1507	}
1508#endif
1509
1510	/* More cases here... */
1511
1512	default:
1513		PyErr_SetString(socket_error, "getsockaddrlen: bad family");
1514		return 0;
1515
1516	}
1517}
1518
1519
1520/* s.accept() method */
1521
1522static PyObject *
1523sock_accept(PySocketSockObject *s)
1524{
1525	sock_addr_t addrbuf;
1526	SOCKET_T newfd;
1527	socklen_t addrlen;
1528	PyObject *sock = NULL;
1529	PyObject *addr = NULL;
1530	PyObject *res = NULL;
1531	int timeout;
1532
1533	if (!getsockaddrlen(s, &addrlen))
1534		return NULL;
1535	memset(&addrbuf, 0, addrlen);
1536
1537#ifdef MS_WINDOWS
1538	newfd = INVALID_SOCKET;
1539#else
1540	newfd = -1;
1541#endif
1542
1543	if (!IS_SELECTABLE(s))
1544		return select_error();
1545
1546	Py_BEGIN_ALLOW_THREADS
1547	timeout = internal_select(s, 0);
1548	if (!timeout)
1549		newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);
1550	Py_END_ALLOW_THREADS
1551
1552	if (timeout == 1) {
1553		PyErr_SetString(socket_timeout, "timed out");
1554		return NULL;
1555	}
1556
1557#ifdef MS_WINDOWS
1558	if (newfd == INVALID_SOCKET)
1559#else
1560	if (newfd < 0)
1561#endif
1562		return s->errorhandler();
1563
1564	/* Create the new object with unspecified family,
1565	   to avoid calls to bind() etc. on it. */
1566	sock = (PyObject *) new_sockobject(newfd,
1567					   s->sock_family,
1568					   s->sock_type,
1569					   s->sock_proto);
1570
1571	if (sock == NULL) {
1572		SOCKETCLOSE(newfd);
1573		goto finally;
1574	}
1575	addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),
1576			    addrlen, s->sock_proto);
1577	if (addr == NULL)
1578		goto finally;
1579
1580	res = PyTuple_Pack(2, sock, addr);
1581
1582finally:
1583	Py_XDECREF(sock);
1584	Py_XDECREF(addr);
1585	return res;
1586}
1587
1588PyDoc_STRVAR(accept_doc,
1589"accept() -> (socket object, address info)\n\
1590\n\
1591Wait for an incoming connection.  Return a new socket representing the\n\
1592connection, and the address of the client.  For IP sockets, the address\n\
1593info is a pair (hostaddr, port).");
1594
1595/* s.setblocking(flag) method.  Argument:
1596   False -- non-blocking mode; same as settimeout(0)
1597   True -- blocking mode; same as settimeout(None)
1598*/
1599
1600static PyObject *
1601sock_setblocking(PySocketSockObject *s, PyObject *arg)
1602{
1603	int block;
1604
1605	block = PyInt_AsLong(arg);
1606	if (block == -1 && PyErr_Occurred())
1607		return NULL;
1608
1609	s->sock_timeout = block ? -1.0 : 0.0;
1610	internal_setblocking(s, block);
1611
1612	Py_INCREF(Py_None);
1613	return Py_None;
1614}
1615
1616PyDoc_STRVAR(setblocking_doc,
1617"setblocking(flag)\n\
1618\n\
1619Set the socket to blocking (flag is true) or non-blocking (false).\n\
1620setblocking(True) is equivalent to settimeout(None);\n\
1621setblocking(False) is equivalent to settimeout(0.0).");
1622
1623/* s.settimeout(timeout) method.  Argument:
1624   None -- no timeout, blocking mode; same as setblocking(True)
1625   0.0  -- non-blocking mode; same as setblocking(False)
1626   > 0  -- timeout mode; operations time out after timeout seconds
1627   < 0  -- illegal; raises an exception
1628*/
1629static PyObject *
1630sock_settimeout(PySocketSockObject *s, PyObject *arg)
1631{
1632	double timeout;
1633
1634	if (arg == Py_None)
1635		timeout = -1.0;
1636	else {
1637		timeout = PyFloat_AsDouble(arg);
1638		if (timeout < 0.0) {
1639			if (!PyErr_Occurred())
1640				PyErr_SetString(PyExc_ValueError,
1641						"Timeout value out of range");
1642			return NULL;
1643		}
1644	}
1645
1646	s->sock_timeout = timeout;
1647	internal_setblocking(s, timeout < 0.0);
1648
1649	Py_INCREF(Py_None);
1650	return Py_None;
1651}
1652
1653PyDoc_STRVAR(settimeout_doc,
1654"settimeout(timeout)\n\
1655\n\
1656Set a timeout on socket operations.  'timeout' can be a float,\n\
1657giving in seconds, or None.  Setting a timeout of None disables\n\
1658the timeout feature and is equivalent to setblocking(1).\n\
1659Setting a timeout of zero is the same as setblocking(0).");
1660
1661/* s.gettimeout() method.
1662   Returns the timeout associated with a socket. */
1663static PyObject *
1664sock_gettimeout(PySocketSockObject *s)
1665{
1666	if (s->sock_timeout < 0.0) {
1667		Py_INCREF(Py_None);
1668		return Py_None;
1669	}
1670	else
1671		return PyFloat_FromDouble(s->sock_timeout);
1672}
1673
1674PyDoc_STRVAR(gettimeout_doc,
1675"gettimeout() -> timeout\n\
1676\n\
1677Returns the timeout in floating seconds associated with socket \n\
1678operations. A timeout of None indicates that timeouts on socket \n\
1679operations are disabled.");
1680
1681#ifdef RISCOS
1682/* s.sleeptaskw(1 | 0) method */
1683
1684static PyObject *
1685sock_sleeptaskw(PySocketSockObject *s,PyObject *arg)
1686{
1687	int block;
1688	block = PyInt_AsLong(arg);
1689	if (block == -1 && PyErr_Occurred())
1690		return NULL;
1691	Py_BEGIN_ALLOW_THREADS
1692	socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
1693	Py_END_ALLOW_THREADS
1694
1695	Py_INCREF(Py_None);
1696	return Py_None;
1697}
1698PyDoc_STRVAR(sleeptaskw_doc,
1699"sleeptaskw(flag)\n\
1700\n\
1701Allow sleeps in taskwindows.");
1702#endif
1703
1704
1705/* s.setsockopt() method.
1706   With an integer third argument, sets an integer option.
1707   With a string third argument, sets an option from a buffer;
1708   use optional built-in module 'struct' to encode the string. */
1709
1710static PyObject *
1711sock_setsockopt(PySocketSockObject *s, PyObject *args)
1712{
1713	int level;
1714	int optname;
1715	int res;
1716	char *buf;
1717	int buflen;
1718	int flag;
1719
1720	if (PyArg_ParseTuple(args, "iii:setsockopt",
1721			     &level, &optname, &flag)) {
1722		buf = (char *) &flag;
1723		buflen = sizeof flag;
1724	}
1725	else {
1726		PyErr_Clear();
1727		if (!PyArg_ParseTuple(args, "iis#:setsockopt",
1728				      &level, &optname, &buf, &buflen))
1729			return NULL;
1730	}
1731	res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
1732	if (res < 0)
1733		return s->errorhandler();
1734	Py_INCREF(Py_None);
1735	return Py_None;
1736}
1737
1738PyDoc_STRVAR(setsockopt_doc,
1739"setsockopt(level, option, value)\n\
1740\n\
1741Set a socket option.  See the Unix manual for level and option.\n\
1742The value argument can either be an integer or a string.");
1743
1744
1745/* s.getsockopt() method.
1746   With two arguments, retrieves an integer option.
1747   With a third integer argument, retrieves a string buffer of that size;
1748   use optional built-in module 'struct' to decode the string. */
1749
1750static PyObject *
1751sock_getsockopt(PySocketSockObject *s, PyObject *args)
1752{
1753	int level;
1754	int optname;
1755	int res;
1756	PyObject *buf;
1757	socklen_t buflen = 0;
1758
1759#ifdef __BEOS__
1760	/* We have incomplete socket support. */
1761	PyErr_SetString(socket_error, "getsockopt not supported");
1762	return NULL;
1763#else
1764
1765	if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1766			      &level, &optname, &buflen))
1767		return NULL;
1768
1769	if (buflen == 0) {
1770		int flag = 0;
1771		socklen_t flagsize = sizeof flag;
1772		res = getsockopt(s->sock_fd, level, optname,
1773				 (void *)&flag, &flagsize);
1774		if (res < 0)
1775			return s->errorhandler();
1776		return PyInt_FromLong(flag);
1777	}
1778#ifdef __VMS
1779	/* socklen_t is unsigned so no negative test is needed,
1780	   test buflen == 0 is previously done */
1781	if (buflen > 1024) {
1782#else
1783	if (buflen <= 0 || buflen > 1024) {
1784#endif
1785		PyErr_SetString(socket_error,
1786				"getsockopt buflen out of range");
1787		return NULL;
1788	}
1789	buf = PyString_FromStringAndSize((char *)NULL, buflen);
1790	if (buf == NULL)
1791		return NULL;
1792	res = getsockopt(s->sock_fd, level, optname,
1793			 (void *)PyString_AS_STRING(buf), &buflen);
1794	if (res < 0) {
1795		Py_DECREF(buf);
1796		return s->errorhandler();
1797	}
1798	_PyString_Resize(&buf, buflen);
1799	return buf;
1800#endif /* __BEOS__ */
1801}
1802
1803PyDoc_STRVAR(getsockopt_doc,
1804"getsockopt(level, option[, buffersize]) -> value\n\
1805\n\
1806Get a socket option.  See the Unix manual for level and option.\n\
1807If a nonzero buffersize argument is given, the return value is a\n\
1808string of that length; otherwise it is an integer.");
1809
1810
1811/* s.bind(sockaddr) method */
1812
1813static PyObject *
1814sock_bind(PySocketSockObject *s, PyObject *addro)
1815{
1816	sock_addr_t addrbuf;
1817	int addrlen;
1818	int res;
1819
1820	if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))
1821		return NULL;
1822	Py_BEGIN_ALLOW_THREADS
1823	res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);
1824	Py_END_ALLOW_THREADS
1825	if (res < 0)
1826		return s->errorhandler();
1827	Py_INCREF(Py_None);
1828	return Py_None;
1829}
1830
1831PyDoc_STRVAR(bind_doc,
1832"bind(address)\n\
1833\n\
1834Bind the socket to a local address.  For IP sockets, the address is a\n\
1835pair (host, port); the host must refer to the local host. For raw packet\n\
1836sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");
1837
1838
1839/* s.close() method.
1840   Set the file descriptor to -1 so operations tried subsequently
1841   will surely fail. */
1842
1843static PyObject *
1844sock_close(PySocketSockObject *s)
1845{
1846	SOCKET_T fd;
1847
1848	if ((fd = s->sock_fd) != -1) {
1849		s->sock_fd = -1;
1850		Py_BEGIN_ALLOW_THREADS
1851		(void) SOCKETCLOSE(fd);
1852		Py_END_ALLOW_THREADS
1853	}
1854	Py_INCREF(Py_None);
1855	return Py_None;
1856}
1857
1858PyDoc_STRVAR(close_doc,
1859"close()\n\
1860\n\
1861Close the socket.  It cannot be used after this call.");
1862
1863static int
1864internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,
1865		 int *timeoutp)
1866{
1867	int res, timeout;
1868
1869	timeout = 0;
1870	res = connect(s->sock_fd, addr, addrlen);
1871
1872#ifdef MS_WINDOWS
1873
1874	if (s->sock_timeout > 0.0) {
1875		if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&
1876		    IS_SELECTABLE(s)) {
1877			/* This is a mess.  Best solution: trust select */
1878			fd_set fds;
1879			fd_set fds_exc;
1880			struct timeval tv;
1881			tv.tv_sec = (int)s->sock_timeout;
1882			tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);
1883			FD_ZERO(&fds);
1884			FD_SET(s->sock_fd, &fds);
1885			FD_ZERO(&fds_exc);
1886			FD_SET(s->sock_fd, &fds_exc);
1887			res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);
1888			if (res == 0) {
1889				res = WSAEWOULDBLOCK;
1890				timeout = 1;
1891			} else if (res > 0) {
1892				if (FD_ISSET(s->sock_fd, &fds))
1893					/* The socket is in the writeable set - this
1894					   means connected */
1895					res = 0;
1896				else {
1897					/* As per MS docs, we need to call getsockopt()
1898					   to get the underlying error */
1899					int res_size = sizeof res;
1900					/* It must be in the exception set */
1901					assert(FD_ISSET(s->sock_fd, &fds_exc));
1902					if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,
1903					                    (char *)&res, &res_size))
1904						/* getsockopt also clears WSAGetLastError,
1905						   so reset it back. */
1906						WSASetLastError(res);
1907					else
1908						res = WSAGetLastError();
1909				}
1910			}
1911			/* else if (res < 0) an error occurred */
1912		}
1913	}
1914
1915	if (res < 0)
1916		res = WSAGetLastError();
1917
1918#else
1919
1920	if (s->sock_timeout > 0.0) {
1921		if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {
1922			timeout = internal_select(s, 1);
1923			if (timeout == 0) {
1924				res = connect(s->sock_fd, addr, addrlen);
1925				if (res < 0 && errno == EISCONN)
1926					res = 0;
1927			}
1928			else if (timeout == -1)
1929				res = errno;		/* had error */
1930			else
1931				res = EWOULDBLOCK;	/* timed out */
1932		}
1933	}
1934
1935	if (r…