+++ /dev/null
-/* Socket module */\r
-\r
-/*\r
-\r
-This module provides an interface to Berkeley socket IPC.\r
-\r
-Limitations:\r
-\r
-- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a\r
- portable manner, though AF_PACKET, AF_NETLINK and AF_TIPC are supported\r
- under Linux.\r
-- No read/write operations (use sendall/recv or makefile instead).\r
-- Additional restrictions apply on some non-Unix platforms (compensated\r
- for by socket.py).\r
-\r
-Module interface:\r
-\r
-- socket.error: exception raised for socket specific errors\r
-- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,\r
- a subclass of socket.error\r
-- socket.herror: exception raised for gethostby* errors,\r
- a subclass of socket.error\r
-- socket.fromfd(fd, family, type[, proto]) --> new socket object (created\r
- from an existing file descriptor)\r
-- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')\r
-- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])\r
-- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')\r
-- socket.getprotobyname(protocolname) --> protocol number\r
-- socket.getservbyname(servicename[, protocolname]) --> port number\r
-- socket.getservbyport(portnumber[, protocolname]) --> service name\r
-- socket.socket([family[, type [, proto]]]) --> new socket object\r
-- socket.socketpair([family[, type [, proto]]]) --> (socket, socket)\r
-- socket.ntohs(16 bit value) --> new int object\r
-- socket.ntohl(32 bit value) --> new int object\r
-- socket.htons(16 bit value) --> new int object\r
-- socket.htonl(32 bit value) --> new int object\r
-- socket.getaddrinfo(host, port [, family, socktype, proto, flags])\r
- --> List of (family, socktype, proto, canonname, sockaddr)\r
-- socket.getnameinfo(sockaddr, flags) --> (host, port)\r
-- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>\r
-- socket.has_ipv6: boolean value indicating if IPv6 is supported\r
-- socket.inet_aton(IP address) -> 32-bit packed IP representation\r
-- socket.inet_ntoa(packed IP) -> IP address string\r
-- socket.getdefaulttimeout() -> None | float\r
-- socket.setdefaulttimeout(None | float)\r
-- an Internet socket address is a pair (hostname, port)\r
- where hostname can be anything recognized by gethostbyname()\r
- (including the dd.dd.dd.dd notation) and port is in host byte order\r
-- where a hostname is returned, the dd.dd.dd.dd notation is used\r
-- a UNIX domain socket address is a string specifying the pathname\r
-- an AF_PACKET socket address is a tuple containing a string\r
- specifying the ethernet interface and an integer specifying\r
- the Ethernet protocol number to be received. For example:\r
- ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple\r
- specify packet-type and ha-type/addr.\r
-- an AF_TIPC socket address is expressed as\r
- (addr_type, v1, v2, v3 [, scope]); where addr_type can be one of:\r
- TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, and TIPC_ADDR_ID;\r
- and scope can be one of:\r
- TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and TIPC_NODE_SCOPE.\r
- The meaning of v1, v2 and v3 depends on the value of addr_type:\r
- if addr_type is TIPC_ADDR_NAME:\r
- v1 is the server type\r
- v2 is the port identifier\r
- v3 is ignored\r
- if addr_type is TIPC_ADDR_NAMESEQ:\r
- v1 is the server type\r
- v2 is the lower port number\r
- v3 is the upper port number\r
- if addr_type is TIPC_ADDR_ID:\r
- v1 is the node\r
- v2 is the ref\r
- v3 is ignored\r
-\r
-\r
-Local naming conventions:\r
-\r
-- names starting with sock_ are socket object methods\r
-- names starting with socket_ are module-level functions\r
-- names starting with PySocket are exported through socketmodule.h\r
-\r
-*/\r
-\r
-#ifdef __APPLE__\r
- /*\r
- * inet_aton is not available on OSX 10.3, yet we want to use a binary\r
- * that was build on 10.4 or later to work on that release, weak linking\r
- * comes to the rescue.\r
- */\r
-# pragma weak inet_aton\r
-#endif\r
-\r
-#include "Python.h"\r
-#include "structmember.h"\r
-#include "timefuncs.h"\r
-\r
-#ifndef INVALID_SOCKET /* MS defines this */\r
-#define INVALID_SOCKET (-1)\r
-#endif\r
-\r
-#undef MAX\r
-#define MAX(x, y) ((x) < (y) ? (y) : (x))\r
-\r
-/* Socket object documentation */\r
-PyDoc_STRVAR(sock_doc,\r
-"socket([family[, type[, proto]]]) -> socket object\n\\r
-\n\\r
-Open a socket of the given type. The family argument specifies the\n\\r
-address family; it defaults to AF_INET. The type argument specifies\n\\r
-whether this is a stream (SOCK_STREAM, this is the default)\n\\r
-or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\\r
-specifying the default protocol. Keyword arguments are accepted.\n\\r
-\n\\r
-A socket object represents one endpoint of a network connection.\n\\r
-\n\\r
-Methods of socket objects (keyword arguments not allowed):\n\\r
-\n\\r
-accept() -- accept a connection, returning new socket and client address\n\\r
-bind(addr) -- bind the socket to a local address\n\\r
-close() -- close the socket\n\\r
-connect(addr) -- connect the socket to a remote address\n\\r
-connect_ex(addr) -- connect, return an error code instead of an exception\n\\r
-dup() -- return a new socket object identical to the current one [*]\n\\r
-fileno() -- return underlying file descriptor\n\\r
-getpeername() -- return remote address [*]\n\\r
-getsockname() -- return local address\n\\r
-getsockopt(level, optname[, buflen]) -- get socket options\n\\r
-gettimeout() -- return timeout or None\n\\r
-listen(n) -- start listening for incoming connections\n\\r
-makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\\r
-recv(buflen[, flags]) -- receive data\n\\r
-recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\n\\r
-recvfrom(buflen[, flags]) -- receive data and sender\'s address\n\\r
-recvfrom_into(buffer[, nbytes, [, flags])\n\\r
- -- receive data and sender\'s address (into a buffer)\n\\r
-sendall(data[, flags]) -- send all data\n\\r
-send(data[, flags]) -- send data, may not send all of it\n\\r
-sendto(data[, flags], addr) -- send data to a given address\n\\r
-setblocking(0 | 1) -- set or clear the blocking I/O flag\n\\r
-setsockopt(level, optname, value) -- set socket options\n\\r
-settimeout(None | float) -- set or clear the timeout\n\\r
-shutdown(how) -- shut down traffic in one or both directions\n\\r
-\n\\r
- [*] not available on all platforms!");\r
-\r
-/* XXX This is a terrible mess of platform-dependent preprocessor hacks.\r
- I hope some day someone can clean this up please... */\r
-\r
-/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure\r
- script doesn't get this right, so we hardcode some platform checks below.\r
- On the other hand, not all Linux versions agree, so there the settings\r
- computed by the configure script are needed! */\r
-\r
-#ifndef linux\r
-# undef HAVE_GETHOSTBYNAME_R_3_ARG\r
-# undef HAVE_GETHOSTBYNAME_R_5_ARG\r
-# undef HAVE_GETHOSTBYNAME_R_6_ARG\r
-#endif\r
-\r
-#ifndef WITH_THREAD\r
-# undef HAVE_GETHOSTBYNAME_R\r
-#endif\r
-\r
-#ifdef HAVE_GETHOSTBYNAME_R\r
-# if defined(_AIX) || defined(__osf__)\r
-# define HAVE_GETHOSTBYNAME_R_3_ARG\r
-# elif defined(__sun) || defined(__sgi)\r
-# define HAVE_GETHOSTBYNAME_R_5_ARG\r
-# elif defined(linux)\r
-/* Rely on the configure script */\r
-# else\r
-# undef HAVE_GETHOSTBYNAME_R\r
-# endif\r
-#endif\r
-\r
-#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \\r
- !defined(MS_WINDOWS)\r
-# define USE_GETHOSTBYNAME_LOCK\r
-#endif\r
-\r
-/* To use __FreeBSD_version */\r
-#ifdef HAVE_SYS_PARAM_H\r
-#include <sys/param.h>\r
-#endif\r
-/* On systems on which getaddrinfo() is believed to not be thread-safe,\r
- (this includes the getaddrinfo emulation) protect access with a lock. */\r
-#if defined(WITH_THREAD) && (defined(__APPLE__) || \\r
- (defined(__FreeBSD__) && __FreeBSD_version+0 < 503000) || \\r
- defined(__OpenBSD__) || defined(__NetBSD__) || \\r
- defined(__VMS) || !defined(HAVE_GETADDRINFO))\r
-#define USE_GETADDRINFO_LOCK\r
-#endif\r
-\r
-#ifdef USE_GETADDRINFO_LOCK\r
-#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);\r
-#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);\r
-#else\r
-#define ACQUIRE_GETADDRINFO_LOCK\r
-#define RELEASE_GETADDRINFO_LOCK\r
-#endif\r
-\r
-#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)\r
-# include "pythread.h"\r
-#endif\r
-\r
-#if defined(PYCC_VACPP)\r
-# include <types.h>\r
-# include <io.h>\r
-# include <sys/ioctl.h>\r
-# include <utils.h>\r
-# include <ctype.h>\r
-#endif\r
-\r
-#if defined(__VMS)\r
-# include <ioctl.h>\r
-#endif\r
-\r
-#if defined(PYOS_OS2)\r
-# define INCL_DOS\r
-# define INCL_DOSERRORS\r
-# define INCL_NOPMAPI\r
-# include <os2.h>\r
-#endif\r
-\r
-#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI\r
-/* make sure that the reentrant (gethostbyaddr_r etc)\r
- functions are declared correctly if compiling with\r
- MIPSPro 7.x in ANSI C mode (default) */\r
-\r
-/* XXX Using _SGIAPI is the wrong thing,\r
- but I don't know what the right thing is. */\r
-#undef _SGIAPI /* to avoid warning */\r
-#define _SGIAPI 1\r
-\r
-#undef _XOPEN_SOURCE\r
-#include <sys/socket.h>\r
-#include <sys/types.h>\r
-#include <netinet/in.h>\r
-#ifdef _SS_ALIGNSIZE\r
-#define HAVE_GETADDRINFO 1\r
-#define HAVE_GETNAMEINFO 1\r
-#endif\r
-\r
-#define HAVE_INET_PTON\r
-#include <netdb.h>\r
-#endif\r
-\r
-/* Irix 6.5 fails to define this variable at all. This is needed\r
- for both GCC and SGI's compiler. I'd say that the SGI headers\r
- are just busted. Same thing for Solaris. */\r
-#if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)\r
-#define INET_ADDRSTRLEN 16\r
-#endif\r
-\r
-/* Generic includes */\r
-#ifdef HAVE_SYS_TYPES_H\r
-#include <sys/types.h>\r
-#endif\r
-\r
-/* Generic socket object definitions and includes */\r
-#define PySocket_BUILDING_SOCKET\r
-#include "socketmodule.h"\r
-\r
-/* Addressing includes */\r
-\r
-#ifndef MS_WINDOWS\r
-\r
-/* Non-MS WINDOWS includes */\r
-# include <netdb.h>\r
-\r
-/* Headers needed for inet_ntoa() and inet_addr() */\r
-# ifdef __BEOS__\r
-# include <net/netdb.h>\r
-# elif defined(PYOS_OS2) && defined(PYCC_VACPP)\r
-# include <netdb.h>\r
-typedef size_t socklen_t;\r
-# else\r
-# include <arpa/inet.h>\r
-# endif\r
-\r
-# ifndef RISCOS\r
-# include <fcntl.h>\r
-# else\r
-# include <sys/ioctl.h>\r
-# include <socklib.h>\r
-# define NO_DUP\r
-int h_errno; /* not used */\r
-# define INET_ADDRSTRLEN 16\r
-# endif\r
-\r
-#else\r
-\r
-/* MS_WINDOWS includes */\r
-# ifdef HAVE_FCNTL_H\r
-# include <fcntl.h>\r
-# endif\r
-\r
-#endif\r
-\r
-#include <stddef.h>\r
-\r
-#ifndef offsetof\r
-# define offsetof(type, member) ((size_t)(&((type *)0)->member))\r
-#endif\r
-\r
-#ifndef O_NONBLOCK\r
-# define O_NONBLOCK O_NDELAY\r
-#endif\r
-\r
-/* include Python's addrinfo.h unless it causes trouble */\r
-#if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)\r
- /* Do not include addinfo.h on some newer IRIX versions.\r
- * _SS_ALIGNSIZE is defined in sys/socket.h by 6.5.21,\r
- * for example, but not by 6.5.10.\r
- */\r
-#elif defined(_MSC_VER) && _MSC_VER>1201\r
- /* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and\r
- * EAI_* constants are defined in (the already included) ws2tcpip.h.\r
- */\r
-#else\r
-# include "addrinfo.h"\r
-#endif\r
-\r
-#ifndef HAVE_INET_PTON\r
-#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)\r
-int inet_pton(int af, const char *src, void *dst);\r
-const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);\r
-#endif\r
-#endif\r
-\r
-#ifdef __APPLE__\r
-/* On OS X, getaddrinfo returns no error indication of lookup\r
- failure, so we must use the emulation instead of the libinfo\r
- implementation. Unfortunately, performing an autoconf test\r
- for this bug would require DNS access for the machine performing\r
- the configuration, which is not acceptable. Therefore, we\r
- determine the bug just by checking for __APPLE__. If this bug\r
- gets ever fixed, perhaps checking for sys/version.h would be\r
- appropriate, which is 10/0 on the system with the bug. */\r
-#ifndef HAVE_GETNAMEINFO\r
-/* This bug seems to be fixed in Jaguar. Ths easiest way I could\r
- Find to check for Jaguar is that it has getnameinfo(), which\r
- older releases don't have */\r
-#undef HAVE_GETADDRINFO\r
-#endif\r
-\r
-#ifdef HAVE_INET_ATON\r
-#define USE_INET_ATON_WEAKLINK\r
-#endif\r
-\r
-#endif\r
-\r
-/* I know this is a bad practice, but it is the easiest... */\r
-#if !defined(HAVE_GETADDRINFO)\r
-/* avoid clashes with the C library definition of the symbol. */\r
-#define getaddrinfo fake_getaddrinfo\r
-#define gai_strerror fake_gai_strerror\r
-#define freeaddrinfo fake_freeaddrinfo\r
-#include "getaddrinfo.c"\r
-#endif\r
-#if !defined(HAVE_GETNAMEINFO)\r
-#define getnameinfo fake_getnameinfo\r
-#include "getnameinfo.c"\r
-#endif\r
-\r
-#if defined(MS_WINDOWS) || defined(__BEOS__)\r
-/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */\r
-/* seem to be a few differences in the API */\r
-#define SOCKETCLOSE closesocket\r
-#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */\r
-#endif\r
-\r
-#ifdef MS_WIN32\r
-#define EAFNOSUPPORT WSAEAFNOSUPPORT\r
-#define snprintf _snprintf\r
-#endif\r
-\r
-#if defined(PYOS_OS2) && !defined(PYCC_GCC)\r
-#define SOCKETCLOSE soclose\r
-#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */\r
-#endif\r
-\r
-#ifndef SOCKETCLOSE\r
-#define SOCKETCLOSE close\r
-#endif\r
-\r
-#if (defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)) && !defined(__NetBSD__) && !defined(__DragonFly__)\r
-#define USE_BLUETOOTH 1\r
-#if defined(__FreeBSD__)\r
-#define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP\r
-#define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM\r
-#define BTPROTO_HCI BLUETOOTH_PROTO_HCI\r
-#define SOL_HCI SOL_HCI_RAW\r
-#define HCI_FILTER SO_HCI_RAW_FILTER\r
-#define sockaddr_l2 sockaddr_l2cap\r
-#define sockaddr_rc sockaddr_rfcomm\r
-#define hci_dev hci_node\r
-#define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)\r
-#define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)\r
-#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)\r
-#elif defined(__NetBSD__) || defined(__DragonFly__)\r
-#define sockaddr_l2 sockaddr_bt\r
-#define sockaddr_rc sockaddr_bt\r
-#define sockaddr_hci sockaddr_bt\r
-#define sockaddr_sco sockaddr_bt\r
-#define SOL_HCI BTPROTO_HCI\r
-#define HCI_DATA_DIR SO_HCI_DIRECTION\r
-#define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)\r
-#define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)\r
-#define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)\r
-#define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)\r
-#else\r
-#define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)\r
-#define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)\r
-#define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)\r
-#define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)\r
-#endif\r
-#endif\r
-\r
-#ifdef __VMS\r
-/* TCP/IP Services for VMS uses a maximum send/recv buffer length */\r
-#define SEGMENT_SIZE (32 * 1024 -1)\r
-#endif\r
-\r
-#define SAS2SA(x) ((struct sockaddr *)(x))\r
-\r
-/*\r
- * Constants for getnameinfo()\r
- */\r
-#if !defined(NI_MAXHOST)\r
-#define NI_MAXHOST 1025\r
-#endif\r
-#if !defined(NI_MAXSERV)\r
-#define NI_MAXSERV 32\r
-#endif\r
-\r
-/* XXX There's a problem here: *static* functions are not supposed to have\r
- a Py prefix (or use CapitalizedWords). Later... */\r
-\r
-/* Global variable holding the exception type for errors detected\r
- by this module (but not argument type or memory errors, etc.). */\r
-static PyObject *socket_error;\r
-static PyObject *socket_herror;\r
-static PyObject *socket_gaierror;\r
-static PyObject *socket_timeout;\r
-\r
-#ifdef RISCOS\r
-/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */\r
-static int taskwindow;\r
-#endif\r
-\r
-/* A forward reference to the socket type object.\r
- The sock_type variable contains pointers to various functions,\r
- some of which call new_sockobject(), which uses sock_type, so\r
- there has to be a circular reference. */\r
-static PyTypeObject sock_type;\r
-\r
-#if defined(HAVE_POLL_H)\r
-#include <poll.h>\r
-#elif defined(HAVE_SYS_POLL_H)\r
-#include <sys/poll.h>\r
-#endif\r
-\r
-#ifdef HAVE_POLL\r
-/* Instead of select(), we'll use poll() since poll() works on any fd. */\r
-#define IS_SELECTABLE(s) 1\r
-/* Can we call select() with this socket without a buffer overrun? */\r
-#else\r
-/* If there's no timeout left, we don't have to call select, so it's a safe,\r
- * little white lie. */\r
-#define IS_SELECTABLE(s) (_PyIsSelectable_fd((s)->sock_fd) || (s)->sock_timeout <= 0.0)\r
-#endif\r
-\r
-static PyObject*\r
-select_error(void)\r
-{\r
- PyErr_SetString(socket_error, "unable to select on socket");\r
- return NULL;\r
-}\r
-\r
-#ifdef MS_WINDOWS\r
-#ifndef WSAEAGAIN\r
-#define WSAEAGAIN WSAEWOULDBLOCK\r
-#endif\r
-#define CHECK_ERRNO(expected) \\r
- (WSAGetLastError() == WSA ## expected)\r
-#else\r
-#define CHECK_ERRNO(expected) \\r
- (errno == expected)\r
-#endif\r
-\r
-/* Convenience function to raise an error according to errno\r
- and return a NULL pointer from a function. */\r
-\r
-static PyObject *\r
-set_error(void)\r
-{\r
-#ifdef MS_WINDOWS\r
- int err_no = WSAGetLastError();\r
- /* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which\r
- recognizes the error codes used by both GetLastError() and\r
- WSAGetLastError */\r
- if (err_no)\r
- return PyErr_SetExcFromWindowsErr(socket_error, err_no);\r
-#endif\r
-\r
-#if defined(PYOS_OS2) && !defined(PYCC_GCC)\r
- if (sock_errno() != NO_ERROR) {\r
- APIRET rc;\r
- ULONG msglen;\r
- char outbuf[100];\r
- int myerrorcode = sock_errno();\r
-\r
- /* Retrieve socket-related error message from MPTN.MSG file */\r
- rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),\r
- myerrorcode - SOCBASEERR + 26,\r
- "mptn.msg",\r
- &msglen);\r
- if (rc == NO_ERROR) {\r
- PyObject *v;\r
-\r
- /* OS/2 doesn't guarantee a terminator */\r
- outbuf[msglen] = '\0';\r
- if (strlen(outbuf) > 0) {\r
- /* If non-empty msg, trim CRLF */\r
- char *lastc = &outbuf[ strlen(outbuf)-1 ];\r
- while (lastc > outbuf &&\r
- isspace(Py_CHARMASK(*lastc))) {\r
- /* Trim trailing whitespace (CRLF) */\r
- *lastc-- = '\0';\r
- }\r
- }\r
- v = Py_BuildValue("(is)", myerrorcode, outbuf);\r
- if (v != NULL) {\r
- PyErr_SetObject(socket_error, v);\r
- Py_DECREF(v);\r
- }\r
- return NULL;\r
- }\r
- }\r
-#endif\r
-\r
-#if defined(RISCOS)\r
- if (_inet_error.errnum != NULL) {\r
- PyObject *v;\r
- v = Py_BuildValue("(is)", errno, _inet_err());\r
- if (v != NULL) {\r
- PyErr_SetObject(socket_error, v);\r
- Py_DECREF(v);\r
- }\r
- return NULL;\r
- }\r
-#endif\r
-\r
- return PyErr_SetFromErrno(socket_error);\r
-}\r
-\r
-\r
-static PyObject *\r
-set_herror(int h_error)\r
-{\r
- PyObject *v;\r
-\r
-#ifdef HAVE_HSTRERROR\r
- v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));\r
-#else\r
- v = Py_BuildValue("(is)", h_error, "host not found");\r
-#endif\r
- if (v != NULL) {\r
- PyErr_SetObject(socket_herror, v);\r
- Py_DECREF(v);\r
- }\r
-\r
- return NULL;\r
-}\r
-\r
-\r
-static PyObject *\r
-set_gaierror(int error)\r
-{\r
- PyObject *v;\r
-\r
-#ifdef EAI_SYSTEM\r
- /* EAI_SYSTEM is not available on Windows XP. */\r
- if (error == EAI_SYSTEM)\r
- return set_error();\r
-#endif\r
-\r
-#ifdef HAVE_GAI_STRERROR\r
- v = Py_BuildValue("(is)", error, gai_strerror(error));\r
-#else\r
- v = Py_BuildValue("(is)", error, "getaddrinfo failed");\r
-#endif\r
- if (v != NULL) {\r
- PyErr_SetObject(socket_gaierror, v);\r
- Py_DECREF(v);\r
- }\r
-\r
- return NULL;\r
-}\r
-\r
-#ifdef __VMS\r
-/* Function to send in segments */\r
-static int\r
-sendsegmented(int sock_fd, char *buf, int len, int flags)\r
-{\r
- int n = 0;\r
- int remaining = len;\r
-\r
- while (remaining > 0) {\r
- unsigned int segment;\r
-\r
- segment = (remaining >= SEGMENT_SIZE ? SEGMENT_SIZE : remaining);\r
- n = send(sock_fd, buf, segment, flags);\r
- if (n < 0) {\r
- return n;\r
- }\r
- remaining -= segment;\r
- buf += segment;\r
- } /* end while */\r
-\r
- return len;\r
-}\r
-#endif\r
-\r
-/* Function to perform the setting of socket blocking mode\r
- internally. block = (1 | 0). */\r
-static int\r
-internal_setblocking(PySocketSockObject *s, int block)\r
-{\r
-#ifndef RISCOS\r
-#ifndef MS_WINDOWS\r
- int delay_flag;\r
-#endif\r
-#endif\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
-#ifdef __BEOS__\r
- block = !block;\r
- setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK,\r
- (void *)(&block), sizeof(int));\r
-#else\r
-#ifndef RISCOS\r
-#ifndef MS_WINDOWS\r
-#if defined(PYOS_OS2) && !defined(PYCC_GCC)\r
- block = !block;\r
- ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));\r
-#elif defined(__VMS)\r
- block = !block;\r
- ioctl(s->sock_fd, FIONBIO, (unsigned int *)&block);\r
-#else /* !PYOS_OS2 && !__VMS */\r
- delay_flag = fcntl(s->sock_fd, F_GETFL, 0);\r
- if (block)\r
- delay_flag &= (~O_NONBLOCK);\r
- else\r
- delay_flag |= O_NONBLOCK;\r
- fcntl(s->sock_fd, F_SETFL, delay_flag);\r
-#endif /* !PYOS_OS2 */\r
-#else /* MS_WINDOWS */\r
- block = !block;\r
- ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);\r
-#endif /* MS_WINDOWS */\r
-#else /* RISCOS */\r
- block = !block;\r
- socketioctl(s->sock_fd, FIONBIO, (u_long*)&block);\r
-#endif /* RISCOS */\r
-#endif /* __BEOS__ */\r
- Py_END_ALLOW_THREADS\r
-\r
- /* Since these don't return anything */\r
- return 1;\r
-}\r
-\r
-/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).\r
- The argument writing indicates the direction.\r
- This does not raise an exception; we'll let our caller do that\r
- after they've reacquired the interpreter lock.\r
- Returns 1 on timeout, -1 on error, 0 otherwise. */\r
-static int\r
-internal_select_ex(PySocketSockObject *s, int writing, double interval)\r
-{\r
- int n;\r
-\r
- /* Nothing to do unless we're in timeout mode (not non-blocking) */\r
- if (s->sock_timeout <= 0.0)\r
- return 0;\r
-\r
- /* Guard against closed socket */\r
- if (s->sock_fd < 0)\r
- return 0;\r
-\r
- /* Handling this condition here simplifies the select loops */\r
- if (interval < 0.0)\r
- return 1;\r
-\r
- /* Prefer poll, if available, since you can poll() any fd\r
- * which can't be done with select(). */\r
-#ifdef HAVE_POLL\r
- {\r
- struct pollfd pollfd;\r
- int timeout;\r
-\r
- pollfd.fd = s->sock_fd;\r
- pollfd.events = writing ? POLLOUT : POLLIN;\r
-\r
- /* s->sock_timeout is in seconds, timeout in ms */\r
- timeout = (int)(interval * 1000 + 0.5);\r
- n = poll(&pollfd, 1, timeout);\r
- }\r
-#else\r
- {\r
- /* Construct the arguments to select */\r
- fd_set fds;\r
- struct timeval tv;\r
- tv.tv_sec = (int)interval;\r
- tv.tv_usec = (int)((interval - tv.tv_sec) * 1e6);\r
- FD_ZERO(&fds);\r
- FD_SET(s->sock_fd, &fds);\r
-\r
- /* See if the socket is ready */\r
- if (writing)\r
- n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);\r
- else\r
- n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);\r
- }\r
-#endif\r
-\r
- if (n < 0)\r
- return -1;\r
- if (n == 0)\r
- return 1;\r
- return 0;\r
-}\r
-\r
-static int\r
-internal_select(PySocketSockObject *s, int writing)\r
-{\r
- return internal_select_ex(s, writing, s->sock_timeout);\r
-}\r
-\r
-/*\r
- Two macros for automatic retry of select() in case of false positives\r
- (for example, select() could indicate a socket is ready for reading\r
- but the data then discarded by the OS because of a wrong checksum).\r
- Here is an example of use:\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 0, interval);\r
- if (!timeout)\r
- outlen = recv(s->sock_fd, cbuf, len, flags);\r
- Py_END_ALLOW_THREADS\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return -1;\r
- }\r
- END_SELECT_LOOP(s)\r
-*/\r
-#define BEGIN_SELECT_LOOP(s) \\r
- { \\r
- double deadline, interval = s->sock_timeout; \\r
- int has_timeout = s->sock_timeout > 0.0; \\r
- if (has_timeout) { \\r
- deadline = _PyTime_FloatTime() + s->sock_timeout; \\r
- } \\r
- while (1) { \\r
- errno = 0;\r
-\r
-#define END_SELECT_LOOP(s) \\r
- if (!has_timeout || \\r
- (!CHECK_ERRNO(EWOULDBLOCK) && !CHECK_ERRNO(EAGAIN))) \\r
- break; \\r
- interval = deadline - _PyTime_FloatTime(); \\r
- } \\r
- }\r
-\r
-/* Initialize a new socket object. */\r
-\r
-static double defaulttimeout = -1.0; /* Default timeout for new sockets */\r
-\r
-PyMODINIT_FUNC\r
-init_sockobject(PySocketSockObject *s,\r
- SOCKET_T fd, int family, int type, int proto)\r
-{\r
-#ifdef RISCOS\r
- int block = 1;\r
-#endif\r
- s->sock_fd = fd;\r
- s->sock_family = family;\r
- s->sock_type = type;\r
- s->sock_proto = proto;\r
- s->sock_timeout = defaulttimeout;\r
-\r
- s->errorhandler = &set_error;\r
-\r
- if (defaulttimeout >= 0.0)\r
- internal_setblocking(s, 0);\r
-\r
-#ifdef RISCOS\r
- if (taskwindow)\r
- socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);\r
-#endif\r
-}\r
-\r
-\r
-/* Create a new socket object.\r
- This just creates the object and initializes it.\r
- If the creation fails, return NULL and set an exception (implicit\r
- in NEWOBJ()). */\r
-\r
-static PySocketSockObject *\r
-new_sockobject(SOCKET_T fd, int family, int type, int proto)\r
-{\r
- PySocketSockObject *s;\r
- s = (PySocketSockObject *)\r
- PyType_GenericNew(&sock_type, NULL, NULL);\r
- if (s != NULL)\r
- init_sockobject(s, fd, family, type, proto);\r
- return s;\r
-}\r
-\r
-\r
-/* Lock to allow python interpreter to continue, but only allow one\r
- thread to be in gethostbyname or getaddrinfo */\r
-#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)\r
-static PyThread_type_lock netdb_lock;\r
-#endif\r
-\r
-\r
-/* Convert a string specifying a host name or one of a few symbolic\r
- names to a numeric IP address. This usually calls gethostbyname()\r
- to do the work; the names "" and "<broadcast>" are special.\r
- Return the length (IPv4 should be 4 bytes), or negative if\r
- an error occurred; then an exception is raised. */\r
-\r
-static int\r
-setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af)\r
-{\r
- struct addrinfo hints, *res;\r
- int error;\r
- int d1, d2, d3, d4;\r
- char ch;\r
-\r
- memset((void *) addr_ret, '\0', sizeof(*addr_ret));\r
- if (name[0] == '\0') {\r
- int siz;\r
- memset(&hints, 0, sizeof(hints));\r
- hints.ai_family = af;\r
- hints.ai_socktype = SOCK_DGRAM; /*dummy*/\r
- hints.ai_flags = AI_PASSIVE;\r
- Py_BEGIN_ALLOW_THREADS\r
- ACQUIRE_GETADDRINFO_LOCK\r
- error = getaddrinfo(NULL, "0", &hints, &res);\r
- Py_END_ALLOW_THREADS\r
- /* We assume that those thread-unsafe getaddrinfo() versions\r
- *are* safe regarding their return value, ie. that a\r
- subsequent call to getaddrinfo() does not destroy the\r
- outcome of the first call. */\r
- RELEASE_GETADDRINFO_LOCK\r
- if (error) {\r
- set_gaierror(error);\r
- return -1;\r
- }\r
- switch (res->ai_family) {\r
- case AF_INET:\r
- siz = 4;\r
- break;\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- siz = 16;\r
- break;\r
-#endif\r
- default:\r
- freeaddrinfo(res);\r
- PyErr_SetString(socket_error,\r
- "unsupported address family");\r
- return -1;\r
- }\r
- if (res->ai_next) {\r
- freeaddrinfo(res);\r
- PyErr_SetString(socket_error,\r
- "wildcard resolved to multiple address");\r
- return -1;\r
- }\r
- if (res->ai_addrlen < addr_ret_size)\r
- addr_ret_size = res->ai_addrlen;\r
- memcpy(addr_ret, res->ai_addr, addr_ret_size);\r
- freeaddrinfo(res);\r
- return siz;\r
- }\r
- if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {\r
- struct sockaddr_in *sin;\r
- if (af != AF_INET && af != AF_UNSPEC) {\r
- PyErr_SetString(socket_error,\r
- "address family mismatched");\r
- return -1;\r
- }\r
- sin = (struct sockaddr_in *)addr_ret;\r
- memset((void *) sin, '\0', sizeof(*sin));\r
- sin->sin_family = AF_INET;\r
-#ifdef HAVE_SOCKADDR_SA_LEN\r
- sin->sin_len = sizeof(*sin);\r
-#endif\r
- sin->sin_addr.s_addr = INADDR_BROADCAST;\r
- return sizeof(sin->sin_addr);\r
- }\r
- if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&\r
- 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&\r
- 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {\r
- struct sockaddr_in *sin;\r
- sin = (struct sockaddr_in *)addr_ret;\r
- sin->sin_addr.s_addr = htonl(\r
- ((long) d1 << 24) | ((long) d2 << 16) |\r
- ((long) d3 << 8) | ((long) d4 << 0));\r
- sin->sin_family = AF_INET;\r
-#ifdef HAVE_SOCKADDR_SA_LEN\r
- sin->sin_len = sizeof(*sin);\r
-#endif\r
- return 4;\r
- }\r
- memset(&hints, 0, sizeof(hints));\r
- hints.ai_family = af;\r
- Py_BEGIN_ALLOW_THREADS\r
- ACQUIRE_GETADDRINFO_LOCK\r
- error = getaddrinfo(name, NULL, &hints, &res);\r
-#if defined(__digital__) && defined(__unix__)\r
- if (error == EAI_NONAME && af == AF_UNSPEC) {\r
- /* On Tru64 V5.1, numeric-to-addr conversion fails\r
- if no address family is given. Assume IPv4 for now.*/\r
- hints.ai_family = AF_INET;\r
- error = getaddrinfo(name, NULL, &hints, &res);\r
- }\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */\r
- if (error) {\r
- set_gaierror(error);\r
- return -1;\r
- }\r
- if (res->ai_addrlen < addr_ret_size)\r
- addr_ret_size = res->ai_addrlen;\r
- memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);\r
- freeaddrinfo(res);\r
- switch (addr_ret->sa_family) {\r
- case AF_INET:\r
- return 4;\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- return 16;\r
-#endif\r
- default:\r
- PyErr_SetString(socket_error, "unknown address family");\r
- return -1;\r
- }\r
-}\r
-\r
-\r
-/* Create a string object representing an IP address.\r
- This is always a string of the form 'dd.dd.dd.dd' (with variable\r
- size numbers). */\r
-\r
-static PyObject *\r
-makeipaddr(struct sockaddr *addr, int addrlen)\r
-{\r
- char buf[NI_MAXHOST];\r
- int error;\r
-\r
- error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,\r
- NI_NUMERICHOST);\r
- if (error) {\r
- set_gaierror(error);\r
- return NULL;\r
- }\r
- return PyString_FromString(buf);\r
-}\r
-\r
-\r
-#ifdef USE_BLUETOOTH\r
-/* Convert a string representation of a Bluetooth address into a numeric\r
- address. Returns the length (6), or raises an exception and returns -1 if\r
- an error occurred. */\r
-\r
-static int\r
-setbdaddr(char *name, bdaddr_t *bdaddr)\r
-{\r
- unsigned int b0, b1, b2, b3, b4, b5;\r
- char ch;\r
- int n;\r
-\r
- n = sscanf(name, "%X:%X:%X:%X:%X:%X%c",\r
- &b5, &b4, &b3, &b2, &b1, &b0, &ch);\r
- if (n == 6 && (b0 | b1 | b2 | b3 | b4 | b5) < 256) {\r
- bdaddr->b[0] = b0;\r
- bdaddr->b[1] = b1;\r
- bdaddr->b[2] = b2;\r
- bdaddr->b[3] = b3;\r
- bdaddr->b[4] = b4;\r
- bdaddr->b[5] = b5;\r
- return 6;\r
- } else {\r
- PyErr_SetString(socket_error, "bad bluetooth address");\r
- return -1;\r
- }\r
-}\r
-\r
-/* Create a string representation of the Bluetooth address. This is always a\r
- string of the form 'XX:XX:XX:XX:XX:XX' where XX is a two digit hexadecimal\r
- value (zero padded if necessary). */\r
-\r
-static PyObject *\r
-makebdaddr(bdaddr_t *bdaddr)\r
-{\r
- char buf[(6 * 2) + 5 + 1];\r
-\r
- sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",\r
- bdaddr->b[5], bdaddr->b[4], bdaddr->b[3],\r
- bdaddr->b[2], bdaddr->b[1], bdaddr->b[0]);\r
- return PyString_FromString(buf);\r
-}\r
-#endif\r
-\r
-\r
-/* Create an object representing the given socket address,\r
- suitable for passing it back to bind(), connect() etc.\r
- The family field of the sockaddr structure is inspected\r
- to determine what kind of address it really is. */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-makesockaddr(int sockfd, struct sockaddr *addr, int addrlen, int proto)\r
-{\r
- if (addrlen == 0) {\r
- /* No address -- may be recvfrom() from known socket */\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-\r
-#ifdef __BEOS__\r
- /* XXX: BeOS version of accept() doesn't set family correctly */\r
- addr->sa_family = AF_INET;\r
-#endif\r
-\r
- switch (addr->sa_family) {\r
-\r
- case AF_INET:\r
- {\r
- struct sockaddr_in *a;\r
- PyObject *addrobj = makeipaddr(addr, sizeof(*a));\r
- PyObject *ret = NULL;\r
- if (addrobj) {\r
- a = (struct sockaddr_in *)addr;\r
- ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));\r
- Py_DECREF(addrobj);\r
- }\r
- return ret;\r
- }\r
-\r
-#if defined(AF_UNIX)\r
- case AF_UNIX:\r
- {\r
- struct sockaddr_un *a = (struct sockaddr_un *) addr;\r
-#ifdef linux\r
- if (a->sun_path[0] == 0) { /* Linux abstract namespace */\r
- addrlen -= offsetof(struct sockaddr_un, sun_path);\r
- return PyString_FromStringAndSize(a->sun_path,\r
- addrlen);\r
- }\r
- else\r
-#endif /* linux */\r
- {\r
- /* regular NULL-terminated string */\r
- return PyString_FromString(a->sun_path);\r
- }\r
- }\r
-#endif /* AF_UNIX */\r
-\r
-#if defined(AF_NETLINK)\r
- case AF_NETLINK:\r
- {\r
- struct sockaddr_nl *a = (struct sockaddr_nl *) addr;\r
- return Py_BuildValue("II", a->nl_pid, a->nl_groups);\r
- }\r
-#endif /* AF_NETLINK */\r
-\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- {\r
- struct sockaddr_in6 *a;\r
- PyObject *addrobj = makeipaddr(addr, sizeof(*a));\r
- PyObject *ret = NULL;\r
- if (addrobj) {\r
- a = (struct sockaddr_in6 *)addr;\r
- ret = Py_BuildValue("OiII",\r
- addrobj,\r
- ntohs(a->sin6_port),\r
- ntohl(a->sin6_flowinfo),\r
- a->sin6_scope_id);\r
- Py_DECREF(addrobj);\r
- }\r
- return ret;\r
- }\r
-#endif\r
-\r
-#ifdef USE_BLUETOOTH\r
- case AF_BLUETOOTH:\r
- switch (proto) {\r
-\r
- case BTPROTO_L2CAP:\r
- {\r
- struct sockaddr_l2 *a = (struct sockaddr_l2 *) addr;\r
- PyObject *addrobj = makebdaddr(&_BT_L2_MEMB(a, bdaddr));\r
- PyObject *ret = NULL;\r
- if (addrobj) {\r
- ret = Py_BuildValue("Oi",\r
- addrobj,\r
- _BT_L2_MEMB(a, psm));\r
- Py_DECREF(addrobj);\r
- }\r
- return ret;\r
- }\r
-\r
- case BTPROTO_RFCOMM:\r
- {\r
- struct sockaddr_rc *a = (struct sockaddr_rc *) addr;\r
- PyObject *addrobj = makebdaddr(&_BT_RC_MEMB(a, bdaddr));\r
- PyObject *ret = NULL;\r
- if (addrobj) {\r
- ret = Py_BuildValue("Oi",\r
- addrobj,\r
- _BT_RC_MEMB(a, channel));\r
- Py_DECREF(addrobj);\r
- }\r
- return ret;\r
- }\r
-\r
- case BTPROTO_HCI:\r
- {\r
- struct sockaddr_hci *a = (struct sockaddr_hci *) addr;\r
-#if defined(__NetBSD__) || defined(__DragonFly__)\r
- return makebdaddr(&_BT_HCI_MEMB(a, bdaddr));\r
-#else\r
- PyObject *ret = NULL;\r
- ret = Py_BuildValue("i", _BT_HCI_MEMB(a, dev));\r
- return ret;\r
-#endif\r
- }\r
-\r
-#if !defined(__FreeBSD__)\r
- case BTPROTO_SCO:\r
- {\r
- struct sockaddr_sco *a = (struct sockaddr_sco *) addr;\r
- return makebdaddr(&_BT_SCO_MEMB(a, bdaddr));\r
- }\r
-#endif\r
-\r
- default:\r
- PyErr_SetString(PyExc_ValueError,\r
- "Unknown Bluetooth protocol");\r
- return NULL;\r
- }\r
-#endif\r
-\r
-#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFNAME)\r
- case AF_PACKET:\r
- {\r
- struct sockaddr_ll *a = (struct sockaddr_ll *)addr;\r
- char *ifname = "";\r
- struct ifreq ifr;\r
- /* need to look up interface name give index */\r
- if (a->sll_ifindex) {\r
- ifr.ifr_ifindex = a->sll_ifindex;\r
- if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)\r
- ifname = ifr.ifr_name;\r
- }\r
- return Py_BuildValue("shbhs#",\r
- ifname,\r
- ntohs(a->sll_protocol),\r
- a->sll_pkttype,\r
- a->sll_hatype,\r
- a->sll_addr,\r
- a->sll_halen);\r
- }\r
-#endif\r
-\r
-#ifdef HAVE_LINUX_TIPC_H\r
- case AF_TIPC:\r
- {\r
- struct sockaddr_tipc *a = (struct sockaddr_tipc *) addr;\r
- if (a->addrtype == TIPC_ADDR_NAMESEQ) {\r
- return Py_BuildValue("IIIII",\r
- a->addrtype,\r
- a->addr.nameseq.type,\r
- a->addr.nameseq.lower,\r
- a->addr.nameseq.upper,\r
- a->scope);\r
- } else if (a->addrtype == TIPC_ADDR_NAME) {\r
- return Py_BuildValue("IIIII",\r
- a->addrtype,\r
- a->addr.name.name.type,\r
- a->addr.name.name.instance,\r
- a->addr.name.name.instance,\r
- a->scope);\r
- } else if (a->addrtype == TIPC_ADDR_ID) {\r
- return Py_BuildValue("IIIII",\r
- a->addrtype,\r
- a->addr.id.node,\r
- a->addr.id.ref,\r
- 0,\r
- a->scope);\r
- } else {\r
- PyErr_SetString(PyExc_ValueError,\r
- "Invalid address type");\r
- return NULL;\r
- }\r
- }\r
-#endif\r
-\r
- /* More cases here... */\r
-\r
- default:\r
- /* If we don't know the address family, don't raise an\r
- exception -- return it as a tuple. */\r
- return Py_BuildValue("is#",\r
- addr->sa_family,\r
- addr->sa_data,\r
- sizeof(addr->sa_data));\r
-\r
- }\r
-}\r
-\r
-\r
-/* Parse a socket address argument according to the socket object's\r
- address family. Return 1 if the address was in the proper format,\r
- 0 of not. The address is returned through addr_ret, its length\r
- through len_ret. */\r
-\r
-static int\r
-getsockaddrarg(PySocketSockObject *s, PyObject *args,\r
- struct sockaddr *addr_ret, int *len_ret)\r
-{\r
- switch (s->sock_family) {\r
-\r
-#if defined(AF_UNIX)\r
- case AF_UNIX:\r
- {\r
- struct sockaddr_un* addr;\r
- char *path;\r
- int len;\r
- if (!PyArg_Parse(args, "t#", &path, &len))\r
- return 0;\r
-\r
- addr = (struct sockaddr_un*)addr_ret;\r
-#ifdef linux\r
- if (len > 0 && path[0] == 0) {\r
- /* Linux abstract namespace extension */\r
- if (len > sizeof addr->sun_path) {\r
- PyErr_SetString(socket_error,\r
- "AF_UNIX path too long");\r
- return 0;\r
- }\r
- }\r
- else\r
-#endif /* linux */\r
- {\r
- /* regular NULL-terminated string */\r
- if (len >= sizeof addr->sun_path) {\r
- PyErr_SetString(socket_error,\r
- "AF_UNIX path too long");\r
- return 0;\r
- }\r
- addr->sun_path[len] = 0;\r
- }\r
- addr->sun_family = s->sock_family;\r
- memcpy(addr->sun_path, path, len);\r
-#if defined(PYOS_OS2)\r
- *len_ret = sizeof(*addr);\r
-#else\r
- *len_ret = len + offsetof(struct sockaddr_un, sun_path);\r
-#endif\r
- return 1;\r
- }\r
-#endif /* AF_UNIX */\r
-\r
-#if defined(AF_NETLINK)\r
- case AF_NETLINK:\r
- {\r
- struct sockaddr_nl* addr;\r
- int pid, groups;\r
- addr = (struct sockaddr_nl *)addr_ret;\r
- if (!PyTuple_Check(args)) {\r
- PyErr_Format(\r
- PyExc_TypeError,\r
- "getsockaddrarg: "\r
- "AF_NETLINK address must be tuple, not %.500s",\r
- Py_TYPE(args)->tp_name);\r
- return 0;\r
- }\r
- if (!PyArg_ParseTuple(args, "II:getsockaddrarg", &pid, &groups))\r
- return 0;\r
- addr->nl_family = AF_NETLINK;\r
- addr->nl_pid = pid;\r
- addr->nl_groups = groups;\r
- *len_ret = sizeof(*addr);\r
- return 1;\r
- }\r
-#endif\r
-\r
- case AF_INET:\r
- {\r
- struct sockaddr_in* addr;\r
- char *host;\r
- int port, result;\r
- if (!PyTuple_Check(args)) {\r
- PyErr_Format(\r
- PyExc_TypeError,\r
- "getsockaddrarg: "\r
- "AF_INET address must be tuple, not %.500s",\r
- Py_TYPE(args)->tp_name);\r
- return 0;\r
- }\r
- if (!PyArg_ParseTuple(args, "eti:getsockaddrarg",\r
- "idna", &host, &port))\r
- return 0;\r
- addr=(struct sockaddr_in*)addr_ret;\r
- result = setipaddr(host, (struct sockaddr *)addr,\r
- sizeof(*addr), AF_INET);\r
- PyMem_Free(host);\r
- if (result < 0)\r
- return 0;\r
- if (port < 0 || port > 0xffff) {\r
- PyErr_SetString(\r
- PyExc_OverflowError,\r
- "getsockaddrarg: port must be 0-65535.");\r
- return 0;\r
- }\r
- addr->sin_family = AF_INET;\r
- addr->sin_port = htons((short)port);\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
-\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- {\r
- struct sockaddr_in6* addr;\r
- char *host;\r
- int port, result;\r
- unsigned int flowinfo, scope_id;\r
- flowinfo = scope_id = 0;\r
- if (!PyTuple_Check(args)) {\r
- PyErr_Format(\r
- PyExc_TypeError,\r
- "getsockaddrarg: "\r
- "AF_INET6 address must be tuple, not %.500s",\r
- Py_TYPE(args)->tp_name);\r
- return 0;\r
- }\r
- if (!PyArg_ParseTuple(args, "eti|II",\r
- "idna", &host, &port, &flowinfo,\r
- &scope_id)) {\r
- return 0;\r
- }\r
- addr = (struct sockaddr_in6*)addr_ret;\r
- result = setipaddr(host, (struct sockaddr *)addr,\r
- sizeof(*addr), AF_INET6);\r
- PyMem_Free(host);\r
- if (result < 0)\r
- return 0;\r
- if (port < 0 || port > 0xffff) {\r
- PyErr_SetString(\r
- PyExc_OverflowError,\r
- "getsockaddrarg: port must be 0-65535.");\r
- return 0;\r
- }\r
- if (flowinfo > 0xfffff) {\r
- PyErr_SetString(\r
- PyExc_OverflowError,\r
- "getsockaddrarg: flowinfo must be 0-1048575.");\r
- return 0;\r
- }\r
- addr->sin6_family = s->sock_family;\r
- addr->sin6_port = htons((short)port);\r
- addr->sin6_flowinfo = htonl(flowinfo);\r
- addr->sin6_scope_id = scope_id;\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
-#endif\r
-\r
-#ifdef USE_BLUETOOTH\r
- case AF_BLUETOOTH:\r
- {\r
- switch (s->sock_proto) {\r
- case BTPROTO_L2CAP:\r
- {\r
- struct sockaddr_l2 *addr;\r
- char *straddr;\r
-\r
- addr = (struct sockaddr_l2 *)addr_ret;\r
- memset(addr, 0, sizeof(struct sockaddr_l2));\r
- _BT_L2_MEMB(addr, family) = AF_BLUETOOTH;\r
- if (!PyArg_ParseTuple(args, "si", &straddr,\r
- &_BT_L2_MEMB(addr, psm))) {\r
- PyErr_SetString(socket_error, "getsockaddrarg: "\r
- "wrong format");\r
- return 0;\r
- }\r
- if (setbdaddr(straddr, &_BT_L2_MEMB(addr, bdaddr)) < 0)\r
- return 0;\r
-\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
- case BTPROTO_RFCOMM:\r
- {\r
- struct sockaddr_rc *addr;\r
- char *straddr;\r
-\r
- addr = (struct sockaddr_rc *)addr_ret;\r
- _BT_RC_MEMB(addr, family) = AF_BLUETOOTH;\r
- if (!PyArg_ParseTuple(args, "si", &straddr,\r
- &_BT_RC_MEMB(addr, channel))) {\r
- PyErr_SetString(socket_error, "getsockaddrarg: "\r
- "wrong format");\r
- return 0;\r
- }\r
- if (setbdaddr(straddr, &_BT_RC_MEMB(addr, bdaddr)) < 0)\r
- return 0;\r
-\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
- case BTPROTO_HCI:\r
- {\r
- struct sockaddr_hci *addr = (struct sockaddr_hci *)addr_ret;\r
-#if defined(__NetBSD__) || defined(__DragonFly__)\r
- char *straddr = PyBytes_AS_STRING(args);\r
-\r
- _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;\r
- if (straddr == NULL) {\r
- PyErr_SetString(socket_error, "getsockaddrarg: "\r
- "wrong format");\r
- return 0;\r
- }\r
- if (setbdaddr(straddr, &_BT_HCI_MEMB(addr, bdaddr)) < 0)\r
- return 0;\r
-#else\r
- _BT_HCI_MEMB(addr, family) = AF_BLUETOOTH;\r
- if (!PyArg_ParseTuple(args, "i", &_BT_HCI_MEMB(addr, dev))) {\r
- PyErr_SetString(socket_error, "getsockaddrarg: "\r
- "wrong format");\r
- return 0;\r
- }\r
-#endif\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
-#if !defined(__FreeBSD__)\r
- case BTPROTO_SCO:\r
- {\r
- struct sockaddr_sco *addr;\r
- char *straddr;\r
-\r
- addr = (struct sockaddr_sco *)addr_ret;\r
- _BT_SCO_MEMB(addr, family) = AF_BLUETOOTH;\r
- straddr = PyString_AsString(args);\r
- if (straddr == NULL) {\r
- PyErr_SetString(socket_error, "getsockaddrarg: "\r
- "wrong format");\r
- return 0;\r
- }\r
- if (setbdaddr(straddr, &_BT_SCO_MEMB(addr, bdaddr)) < 0)\r
- return 0;\r
-\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
-#endif\r
- default:\r
- PyErr_SetString(socket_error, "getsockaddrarg: unknown Bluetooth protocol");\r
- return 0;\r
- }\r
- }\r
-#endif\r
-\r
-#if defined(HAVE_NETPACKET_PACKET_H) && defined(SIOCGIFINDEX)\r
- case AF_PACKET:\r
- {\r
- struct sockaddr_ll* addr;\r
- struct ifreq ifr;\r
- char *interfaceName;\r
- int protoNumber;\r
- int hatype = 0;\r
- int pkttype = 0;\r
- char *haddr = NULL;\r
- unsigned int halen = 0;\r
-\r
- if (!PyTuple_Check(args)) {\r
- PyErr_Format(\r
- PyExc_TypeError,\r
- "getsockaddrarg: "\r
- "AF_PACKET address must be tuple, not %.500s",\r
- Py_TYPE(args)->tp_name);\r
- return 0;\r
- }\r
- if (!PyArg_ParseTuple(args, "si|iis#", &interfaceName,\r
- &protoNumber, &pkttype, &hatype,\r
- &haddr, &halen))\r
- return 0;\r
- strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));\r
- ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';\r
- if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {\r
- s->errorhandler();\r
- return 0;\r
- }\r
- if (halen > 8) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "Hardware address must be 8 bytes or less");\r
- return 0;\r
- }\r
- if (protoNumber < 0 || protoNumber > 0xffff) {\r
- PyErr_SetString(\r
- PyExc_OverflowError,\r
- "getsockaddrarg: protoNumber must be 0-65535.");\r
- return 0;\r
- }\r
- addr = (struct sockaddr_ll*)addr_ret;\r
- addr->sll_family = AF_PACKET;\r
- addr->sll_protocol = htons((short)protoNumber);\r
- addr->sll_ifindex = ifr.ifr_ifindex;\r
- addr->sll_pkttype = pkttype;\r
- addr->sll_hatype = hatype;\r
- if (halen != 0) {\r
- memcpy(&addr->sll_addr, haddr, halen);\r
- }\r
- addr->sll_halen = halen;\r
- *len_ret = sizeof *addr;\r
- return 1;\r
- }\r
-#endif\r
-\r
-#ifdef HAVE_LINUX_TIPC_H\r
- case AF_TIPC:\r
- {\r
- unsigned int atype, v1, v2, v3;\r
- unsigned int scope = TIPC_CLUSTER_SCOPE;\r
- struct sockaddr_tipc *addr;\r
-\r
- if (!PyTuple_Check(args)) {\r
- PyErr_Format(\r
- PyExc_TypeError,\r
- "getsockaddrarg: "\r
- "AF_TIPC address must be tuple, not %.500s",\r
- Py_TYPE(args)->tp_name);\r
- return 0;\r
- }\r
-\r
- if (!PyArg_ParseTuple(args,\r
- "IIII|I;Invalid TIPC address format",\r
- &atype, &v1, &v2, &v3, &scope))\r
- return 0;\r
-\r
- addr = (struct sockaddr_tipc *) addr_ret;\r
- memset(addr, 0, sizeof(struct sockaddr_tipc));\r
-\r
- addr->family = AF_TIPC;\r
- addr->scope = scope;\r
- addr->addrtype = atype;\r
-\r
- if (atype == TIPC_ADDR_NAMESEQ) {\r
- addr->addr.nameseq.type = v1;\r
- addr->addr.nameseq.lower = v2;\r
- addr->addr.nameseq.upper = v3;\r
- } else if (atype == TIPC_ADDR_NAME) {\r
- addr->addr.name.name.type = v1;\r
- addr->addr.name.name.instance = v2;\r
- } else if (atype == TIPC_ADDR_ID) {\r
- addr->addr.id.node = v1;\r
- addr->addr.id.ref = v2;\r
- } else {\r
- /* Shouldn't happen */\r
- PyErr_SetString(PyExc_TypeError, "Invalid address type");\r
- return 0;\r
- }\r
-\r
- *len_ret = sizeof(*addr);\r
-\r
- return 1;\r
- }\r
-#endif\r
-\r
- /* More cases here... */\r
-\r
- default:\r
- PyErr_SetString(socket_error, "getsockaddrarg: bad family");\r
- return 0;\r
-\r
- }\r
-}\r
-\r
-\r
-/* Get the address length according to the socket object's address family.\r
- Return 1 if the family is known, 0 otherwise. The length is returned\r
- through len_ret. */\r
-\r
-static int\r
-getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)\r
-{\r
- switch (s->sock_family) {\r
-\r
-#if defined(AF_UNIX)\r
- case AF_UNIX:\r
- {\r
- *len_ret = sizeof (struct sockaddr_un);\r
- return 1;\r
- }\r
-#endif /* AF_UNIX */\r
-#if defined(AF_NETLINK)\r
- case AF_NETLINK:\r
- {\r
- *len_ret = sizeof (struct sockaddr_nl);\r
- return 1;\r
- }\r
-#endif\r
-\r
- case AF_INET:\r
- {\r
- *len_ret = sizeof (struct sockaddr_in);\r
- return 1;\r
- }\r
-\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- {\r
- *len_ret = sizeof (struct sockaddr_in6);\r
- return 1;\r
- }\r
-#endif\r
-\r
-#ifdef USE_BLUETOOTH\r
- case AF_BLUETOOTH:\r
- {\r
- switch(s->sock_proto)\r
- {\r
-\r
- case BTPROTO_L2CAP:\r
- *len_ret = sizeof (struct sockaddr_l2);\r
- return 1;\r
- case BTPROTO_RFCOMM:\r
- *len_ret = sizeof (struct sockaddr_rc);\r
- return 1;\r
- case BTPROTO_HCI:\r
- *len_ret = sizeof (struct sockaddr_hci);\r
- return 1;\r
-#if !defined(__FreeBSD__)\r
- case BTPROTO_SCO:\r
- *len_ret = sizeof (struct sockaddr_sco);\r
- return 1;\r
-#endif\r
- default:\r
- PyErr_SetString(socket_error, "getsockaddrlen: "\r
- "unknown BT protocol");\r
- return 0;\r
-\r
- }\r
- }\r
-#endif\r
-\r
-#ifdef HAVE_NETPACKET_PACKET_H\r
- case AF_PACKET:\r
- {\r
- *len_ret = sizeof (struct sockaddr_ll);\r
- return 1;\r
- }\r
-#endif\r
-\r
-#ifdef HAVE_LINUX_TIPC_H\r
- case AF_TIPC:\r
- {\r
- *len_ret = sizeof (struct sockaddr_tipc);\r
- return 1;\r
- }\r
-#endif\r
-\r
- /* More cases here... */\r
-\r
- default:\r
- PyErr_SetString(socket_error, "getsockaddrlen: bad family");\r
- return 0;\r
-\r
- }\r
-}\r
-\r
-\r
-/* s.accept() method */\r
-\r
-static PyObject *\r
-sock_accept(PySocketSockObject *s)\r
-{\r
- sock_addr_t addrbuf;\r
- SOCKET_T newfd;\r
- socklen_t addrlen;\r
- PyObject *sock = NULL;\r
- PyObject *addr = NULL;\r
- PyObject *res = NULL;\r
- int timeout;\r
-\r
- if (!getsockaddrlen(s, &addrlen))\r
- return NULL;\r
- memset(&addrbuf, 0, addrlen);\r
-\r
- newfd = INVALID_SOCKET;\r
-\r
- if (!IS_SELECTABLE(s))\r
- return select_error();\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 0, interval);\r
- if (!timeout)\r
- newfd = accept(s->sock_fd, SAS2SA(&addrbuf), &addrlen);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return NULL;\r
- }\r
- END_SELECT_LOOP(s)\r
-\r
- if (newfd == INVALID_SOCKET)\r
- return s->errorhandler();\r
-\r
- /* Create the new object with unspecified family,\r
- to avoid calls to bind() etc. on it. */\r
- sock = (PyObject *) new_sockobject(newfd,\r
- s->sock_family,\r
- s->sock_type,\r
- s->sock_proto);\r
-\r
- if (sock == NULL) {\r
- SOCKETCLOSE(newfd);\r
- goto finally;\r
- }\r
- addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),\r
- addrlen, s->sock_proto);\r
- if (addr == NULL)\r
- goto finally;\r
-\r
- res = PyTuple_Pack(2, sock, addr);\r
-\r
-finally:\r
- Py_XDECREF(sock);\r
- Py_XDECREF(addr);\r
- return res;\r
-}\r
-\r
-PyDoc_STRVAR(accept_doc,\r
-"accept() -> (socket object, address info)\n\\r
-\n\\r
-Wait for an incoming connection. Return a new socket representing the\n\\r
-connection, and the address of the client. For IP sockets, the address\n\\r
-info is a pair (hostaddr, port).");\r
-\r
-/* s.setblocking(flag) method. Argument:\r
- False -- non-blocking mode; same as settimeout(0)\r
- True -- blocking mode; same as settimeout(None)\r
-*/\r
-\r
-static PyObject *\r
-sock_setblocking(PySocketSockObject *s, PyObject *arg)\r
-{\r
- long block;\r
-\r
- block = PyInt_AsLong(arg);\r
- if (block == -1 && PyErr_Occurred())\r
- return NULL;\r
-\r
- s->sock_timeout = block ? -1.0 : 0.0;\r
- internal_setblocking(s, block);\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(setblocking_doc,\r
-"setblocking(flag)\n\\r
-\n\\r
-Set the socket to blocking (flag is true) or non-blocking (false).\n\\r
-setblocking(True) is equivalent to settimeout(None);\n\\r
-setblocking(False) is equivalent to settimeout(0.0).");\r
-\r
-/* s.settimeout(timeout) method. Argument:\r
- None -- no timeout, blocking mode; same as setblocking(True)\r
- 0.0 -- non-blocking mode; same as setblocking(False)\r
- > 0 -- timeout mode; operations time out after timeout seconds\r
- < 0 -- illegal; raises an exception\r
-*/\r
-static PyObject *\r
-sock_settimeout(PySocketSockObject *s, PyObject *arg)\r
-{\r
- double timeout;\r
-\r
- if (arg == Py_None)\r
- timeout = -1.0;\r
- else {\r
- timeout = PyFloat_AsDouble(arg);\r
- if (timeout < 0.0) {\r
- if (!PyErr_Occurred())\r
- PyErr_SetString(PyExc_ValueError,\r
- "Timeout value out of range");\r
- return NULL;\r
- }\r
- }\r
-\r
- s->sock_timeout = timeout;\r
- internal_setblocking(s, timeout < 0.0);\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(settimeout_doc,\r
-"settimeout(timeout)\n\\r
-\n\\r
-Set a timeout on socket operations. 'timeout' can be a float,\n\\r
-giving in seconds, or None. Setting a timeout of None disables\n\\r
-the timeout feature and is equivalent to setblocking(1).\n\\r
-Setting a timeout of zero is the same as setblocking(0).");\r
-\r
-/* s.gettimeout() method.\r
- Returns the timeout associated with a socket. */\r
-static PyObject *\r
-sock_gettimeout(PySocketSockObject *s)\r
-{\r
- if (s->sock_timeout < 0.0) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- else\r
- return PyFloat_FromDouble(s->sock_timeout);\r
-}\r
-\r
-PyDoc_STRVAR(gettimeout_doc,\r
-"gettimeout() -> timeout\n\\r
-\n\\r
-Returns the timeout in seconds (float) associated with socket \n\\r
-operations. A timeout of None indicates that timeouts on socket \n\\r
-operations are disabled.");\r
-\r
-#ifdef RISCOS\r
-/* s.sleeptaskw(1 | 0) method */\r
-\r
-static PyObject *\r
-sock_sleeptaskw(PySocketSockObject *s,PyObject *arg)\r
-{\r
- int block;\r
- block = PyInt_AsLong(arg);\r
- if (block == -1 && PyErr_Occurred())\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);\r
- Py_END_ALLOW_THREADS\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-PyDoc_STRVAR(sleeptaskw_doc,\r
-"sleeptaskw(flag)\n\\r
-\n\\r
-Allow sleeps in taskwindows.");\r
-#endif\r
-\r
-\r
-/* s.setsockopt() method.\r
- With an integer third argument, sets an integer option.\r
- With a string third argument, sets an option from a buffer;\r
- use optional built-in module 'struct' to encode the string. */\r
-\r
-static PyObject *\r
-sock_setsockopt(PySocketSockObject *s, PyObject *args)\r
-{\r
- int level;\r
- int optname;\r
- int res;\r
- char *buf;\r
- int buflen;\r
- int flag;\r
-\r
- if (PyArg_ParseTuple(args, "iii:setsockopt",\r
- &level, &optname, &flag)) {\r
- buf = (char *) &flag;\r
- buflen = sizeof flag;\r
- }\r
- else {\r
- PyErr_Clear();\r
- if (!PyArg_ParseTuple(args, "iis#:setsockopt",\r
- &level, &optname, &buf, &buflen))\r
- return NULL;\r
- }\r
- res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);\r
- if (res < 0)\r
- return s->errorhandler();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(setsockopt_doc,\r
-"setsockopt(level, option, value)\n\\r
-\n\\r
-Set a socket option. See the Unix manual for level and option.\n\\r
-The value argument can either be an integer or a string.");\r
-\r
-\r
-/* s.getsockopt() method.\r
- With two arguments, retrieves an integer option.\r
- With a third integer argument, retrieves a string buffer of that size;\r
- use optional built-in module 'struct' to decode the string. */\r
-\r
-static PyObject *\r
-sock_getsockopt(PySocketSockObject *s, PyObject *args)\r
-{\r
- int level;\r
- int optname;\r
- int res;\r
- PyObject *buf;\r
- socklen_t buflen = 0;\r
-\r
-#ifdef __BEOS__\r
- /* We have incomplete socket support. */\r
- PyErr_SetString(socket_error, "getsockopt not supported");\r
- return NULL;\r
-#else\r
-\r
- if (!PyArg_ParseTuple(args, "ii|i:getsockopt",\r
- &level, &optname, &buflen))\r
- return NULL;\r
-\r
- if (buflen == 0) {\r
- int flag = 0;\r
- socklen_t flagsize = sizeof flag;\r
- res = getsockopt(s->sock_fd, level, optname,\r
- (void *)&flag, &flagsize);\r
- if (res < 0)\r
- return s->errorhandler();\r
- return PyInt_FromLong(flag);\r
- }\r
-#ifdef __VMS\r
- /* socklen_t is unsigned so no negative test is needed,\r
- test buflen == 0 is previously done */\r
- if (buflen > 1024) {\r
-#else\r
- if (buflen <= 0 || buflen > 1024) {\r
-#endif\r
- PyErr_SetString(socket_error,\r
- "getsockopt buflen out of range");\r
- return NULL;\r
- }\r
- buf = PyString_FromStringAndSize((char *)NULL, buflen);\r
- if (buf == NULL)\r
- return NULL;\r
- res = getsockopt(s->sock_fd, level, optname,\r
- (void *)PyString_AS_STRING(buf), &buflen);\r
- if (res < 0) {\r
- Py_DECREF(buf);\r
- return s->errorhandler();\r
- }\r
- _PyString_Resize(&buf, buflen);\r
- return buf;\r
-#endif /* __BEOS__ */\r
-}\r
-\r
-PyDoc_STRVAR(getsockopt_doc,\r
-"getsockopt(level, option[, buffersize]) -> value\n\\r
-\n\\r
-Get a socket option. See the Unix manual for level and option.\n\\r
-If a nonzero buffersize argument is given, the return value is a\n\\r
-string of that length; otherwise it is an integer.");\r
-\r
-\r
-/* s.bind(sockaddr) method */\r
-\r
-static PyObject *\r
-sock_bind(PySocketSockObject *s, PyObject *addro)\r
-{\r
- sock_addr_t addrbuf;\r
- int addrlen;\r
- int res;\r
-\r
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = bind(s->sock_fd, SAS2SA(&addrbuf), addrlen);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return s->errorhandler();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(bind_doc,\r
-"bind(address)\n\\r
-\n\\r
-Bind the socket to a local address. For IP sockets, the address is a\n\\r
-pair (host, port); the host must refer to the local host. For raw packet\n\\r
-sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])");\r
-\r
-\r
-/* s.close() method.\r
- Set the file descriptor to -1 so operations tried subsequently\r
- will surely fail. */\r
-\r
-static PyObject *\r
-sock_close(PySocketSockObject *s)\r
-{\r
- SOCKET_T fd;\r
-\r
- if ((fd = s->sock_fd) != -1) {\r
- s->sock_fd = -1;\r
- Py_BEGIN_ALLOW_THREADS\r
- (void) SOCKETCLOSE(fd);\r
- Py_END_ALLOW_THREADS\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(close_doc,\r
-"close()\n\\r
-\n\\r
-Close the socket. It cannot be used after this call.");\r
-\r
-static int\r
-internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,\r
- int *timeoutp)\r
-{\r
- int res, timeout;\r
-\r
- timeout = 0;\r
- res = connect(s->sock_fd, addr, addrlen);\r
-\r
-#ifdef MS_WINDOWS\r
-\r
- if (s->sock_timeout > 0.0) {\r
- if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK &&\r
- IS_SELECTABLE(s)) {\r
- /* This is a mess. Best solution: trust select */\r
- fd_set fds;\r
- fd_set fds_exc;\r
- struct timeval tv;\r
- tv.tv_sec = (int)s->sock_timeout;\r
- tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);\r
- FD_ZERO(&fds);\r
- FD_SET(s->sock_fd, &fds);\r
- FD_ZERO(&fds_exc);\r
- FD_SET(s->sock_fd, &fds_exc);\r
- res = select(s->sock_fd+1, NULL, &fds, &fds_exc, &tv);\r
- if (res == 0) {\r
- res = WSAEWOULDBLOCK;\r
- timeout = 1;\r
- } else if (res > 0) {\r
- if (FD_ISSET(s->sock_fd, &fds))\r
- /* The socket is in the writeable set - this\r
- means connected */\r
- res = 0;\r
- else {\r
- /* As per MS docs, we need to call getsockopt()\r
- to get the underlying error */\r
- int res_size = sizeof res;\r
- /* It must be in the exception set */\r
- assert(FD_ISSET(s->sock_fd, &fds_exc));\r
- if (0 == getsockopt(s->sock_fd, SOL_SOCKET, SO_ERROR,\r
- (char *)&res, &res_size))\r
- /* getsockopt also clears WSAGetLastError,\r
- so reset it back. */\r
- WSASetLastError(res);\r
- else\r
- res = WSAGetLastError();\r
- }\r
- }\r
- /* else if (res < 0) an error occurred */\r
- }\r
- }\r
-\r
- if (res < 0)\r
- res = WSAGetLastError();\r
-\r
-#else\r
-\r
- if (s->sock_timeout > 0.0) {\r
- if (res < 0 && errno == EINPROGRESS && IS_SELECTABLE(s)) {\r
- timeout = internal_select(s, 1);\r
- if (timeout == 0) {\r
- /* Bug #1019808: in case of an EINPROGRESS,\r
- use getsockopt(SO_ERROR) to get the real\r
- error. */\r
- socklen_t res_size = sizeof res;\r
- (void)getsockopt(s->sock_fd, SOL_SOCKET,\r
- SO_ERROR, &res, &res_size);\r
- if (res == EISCONN)\r
- res = 0;\r
- errno = res;\r
- }\r
- else if (timeout == -1) {\r
- res = errno; /* had error */\r
- }\r
- else\r
- res = EWOULDBLOCK; /* timed out */\r
- }\r
- }\r
-\r
- if (res < 0)\r
- res = errno;\r
-\r
-#endif\r
- *timeoutp = timeout;\r
-\r
- return res;\r
-}\r
-\r
-/* s.connect(sockaddr) method */\r
-\r
-static PyObject *\r
-sock_connect(PySocketSockObject *s, PyObject *addro)\r
-{\r
- sock_addr_t addrbuf;\r
- int addrlen;\r
- int res;\r
- int timeout;\r
-\r
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return NULL;\r
- }\r
- if (res != 0)\r
- return s->errorhandler();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(connect_doc,\r
-"connect(address)\n\\r
-\n\\r
-Connect the socket to a remote address. For IP sockets, the address\n\\r
-is a pair (host, port).");\r
-\r
-\r
-/* s.connect_ex(sockaddr) method */\r
-\r
-static PyObject *\r
-sock_connect_ex(PySocketSockObject *s, PyObject *addro)\r
-{\r
- sock_addr_t addrbuf;\r
- int addrlen;\r
- int res;\r
- int timeout;\r
-\r
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen))\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = internal_connect(s, SAS2SA(&addrbuf), addrlen, &timeout);\r
- Py_END_ALLOW_THREADS\r
-\r
- /* Signals are not errors (though they may raise exceptions). Adapted\r
- from PyErr_SetFromErrnoWithFilenameObject(). */\r
-#ifdef EINTR\r
- if (res == EINTR && PyErr_CheckSignals())\r
- return NULL;\r
-#endif\r
-\r
- return PyInt_FromLong((long) res);\r
-}\r
-\r
-PyDoc_STRVAR(connect_ex_doc,\r
-"connect_ex(address) -> errno\n\\r
-\n\\r
-This is like connect(address), but returns an error code (the errno value)\n\\r
-instead of raising an exception when an error occurs.");\r
-\r
-\r
-/* s.fileno() method */\r
-\r
-static PyObject *\r
-sock_fileno(PySocketSockObject *s)\r
-{\r
-#if SIZEOF_SOCKET_T <= SIZEOF_LONG\r
- return PyInt_FromLong((long) s->sock_fd);\r
-#else\r
- return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd);\r
-#endif\r
-}\r
-\r
-PyDoc_STRVAR(fileno_doc,\r
-"fileno() -> integer\n\\r
-\n\\r
-Return the integer file descriptor of the socket.");\r
-\r
-\r
-#ifndef NO_DUP\r
-/* s.dup() method */\r
-\r
-static PyObject *\r
-sock_dup(PySocketSockObject *s)\r
-{\r
- SOCKET_T newfd;\r
- PyObject *sock;\r
-\r
- newfd = dup(s->sock_fd);\r
- if (newfd < 0)\r
- return s->errorhandler();\r
- sock = (PyObject *) new_sockobject(newfd,\r
- s->sock_family,\r
- s->sock_type,\r
- s->sock_proto);\r
- if (sock == NULL)\r
- SOCKETCLOSE(newfd);\r
- return sock;\r
-}\r
-\r
-PyDoc_STRVAR(dup_doc,\r
-"dup() -> socket object\n\\r
-\n\\r
-Return a new socket object connected to the same system resource.");\r
-\r
-#endif\r
-\r
-\r
-/* s.getsockname() method */\r
-\r
-static PyObject *\r
-sock_getsockname(PySocketSockObject *s)\r
-{\r
- sock_addr_t addrbuf;\r
- int res;\r
- socklen_t addrlen;\r
-\r
- if (!getsockaddrlen(s, &addrlen))\r
- return NULL;\r
- memset(&addrbuf, 0, addrlen);\r
- Py_BEGIN_ALLOW_THREADS\r
- res = getsockname(s->sock_fd, SAS2SA(&addrbuf), &addrlen);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return s->errorhandler();\r
- return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,\r
- s->sock_proto);\r
-}\r
-\r
-PyDoc_STRVAR(getsockname_doc,\r
-"getsockname() -> address info\n\\r
-\n\\r
-Return the address of the local endpoint. For IP sockets, the address\n\\r
-info is a pair (hostaddr, port).");\r
-\r
-\r
-#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */\r
-/* s.getpeername() method */\r
-\r
-static PyObject *\r
-sock_getpeername(PySocketSockObject *s)\r
-{\r
- sock_addr_t addrbuf;\r
- int res;\r
- socklen_t addrlen;\r
-\r
- if (!getsockaddrlen(s, &addrlen))\r
- return NULL;\r
- memset(&addrbuf, 0, addrlen);\r
- Py_BEGIN_ALLOW_THREADS\r
- res = getpeername(s->sock_fd, SAS2SA(&addrbuf), &addrlen);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return s->errorhandler();\r
- return makesockaddr(s->sock_fd, SAS2SA(&addrbuf), addrlen,\r
- s->sock_proto);\r
-}\r
-\r
-PyDoc_STRVAR(getpeername_doc,\r
-"getpeername() -> address info\n\\r
-\n\\r
-Return the address of the remote endpoint. For IP sockets, the address\n\\r
-info is a pair (hostaddr, port).");\r
-\r
-#endif /* HAVE_GETPEERNAME */\r
-\r
-\r
-/* s.listen(n) method */\r
-\r
-static PyObject *\r
-sock_listen(PySocketSockObject *s, PyObject *arg)\r
-{\r
- int backlog;\r
- int res;\r
-\r
- backlog = _PyInt_AsInt(arg);\r
- if (backlog == -1 && PyErr_Occurred())\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- /* To avoid problems on systems that don't allow a negative backlog\r
- * (which doesn't make sense anyway) we force a minimum value of 0. */\r
- if (backlog < 0)\r
- backlog = 0;\r
- res = listen(s->sock_fd, backlog);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return s->errorhandler();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(listen_doc,\r
-"listen(backlog)\n\\r
-\n\\r
-Enable a server to accept connections. The backlog argument must be at\n\\r
-least 0 (if it is lower, it is set to 0); it specifies the number of\n\\r
-unaccepted connections that the system will allow before refusing new\n\\r
-connections.");\r
-\r
-\r
-#ifndef NO_DUP\r
-/* s.makefile(mode) method.\r
- Create a new open file object referring to a dupped version of\r
- the socket's file descriptor. (The dup() call is necessary so\r
- that the open file and socket objects may be closed independent\r
- of each other.)\r
- The mode argument specifies 'r' or 'w' passed to fdopen(). */\r
-\r
-static PyObject *\r
-sock_makefile(PySocketSockObject *s, PyObject *args)\r
-{\r
- extern int fclose(FILE *);\r
- char *mode = "r";\r
- int bufsize = -1;\r
-#ifdef MS_WIN32\r
- Py_intptr_t fd;\r
-#else\r
- int fd;\r
-#endif\r
- FILE *fp;\r
- PyObject *f;\r
-#ifdef __VMS\r
- char *mode_r = "r";\r
- char *mode_w = "w";\r
-#endif\r
-\r
- if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize))\r
- return NULL;\r
-#ifdef __VMS\r
- if (strcmp(mode,"rb") == 0) {\r
- mode = mode_r;\r
- }\r
- else {\r
- if (strcmp(mode,"wb") == 0) {\r
- mode = mode_w;\r
- }\r
- }\r
-#endif\r
-#ifdef MS_WIN32\r
- if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) ||\r
- ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL))\r
-#else\r
- if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL)\r
-#endif\r
- {\r
- if (fd >= 0)\r
- SOCKETCLOSE(fd);\r
- return s->errorhandler();\r
- }\r
- f = PyFile_FromFile(fp, "<socket>", mode, fclose);\r
- if (f != NULL)\r
- PyFile_SetBufSize(f, bufsize);\r
- return f;\r
-}\r
-\r
-PyDoc_STRVAR(makefile_doc,\r
-"makefile([mode[, buffersize]]) -> file object\n\\r
-\n\\r
-Return a regular file object corresponding to the socket.\n\\r
-The mode and buffersize arguments are as for the built-in open() function.");\r
-\r
-#endif /* NO_DUP */\r
-\r
-/*\r
- * This is the guts of the recv() and recv_into() methods, which reads into a\r
- * char buffer. If you have any inc/dec ref to do to the objects that contain\r
- * the buffer, do it in the caller. This function returns the number of bytes\r
- * successfully read. If there was an error, it returns -1. Note that it is\r
- * also possible that we return a number of bytes smaller than the request\r
- * bytes.\r
- */\r
-static ssize_t\r
-sock_recv_guts(PySocketSockObject *s, char* cbuf, int len, int flags)\r
-{\r
- ssize_t outlen = -1;\r
- int timeout;\r
-#ifdef __VMS\r
- int remaining;\r
- char *read_buf;\r
-#endif\r
-\r
- if (!IS_SELECTABLE(s)) {\r
- select_error();\r
- return -1;\r
- }\r
-\r
-#ifndef __VMS\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 0, interval);\r
- if (!timeout)\r
- outlen = recv(s->sock_fd, cbuf, len, flags);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return -1;\r
- }\r
- END_SELECT_LOOP(s)\r
- if (outlen < 0) {\r
- /* Note: the call to errorhandler() ALWAYS indirectly returned\r
- NULL, so ignore its return value */\r
- s->errorhandler();\r
- return -1;\r
- }\r
-#else\r
- read_buf = cbuf;\r
- remaining = len;\r
- while (remaining != 0) {\r
- unsigned int segment;\r
- int nread = -1;\r
-\r
- segment = remaining /SEGMENT_SIZE;\r
- if (segment != 0) {\r
- segment = SEGMENT_SIZE;\r
- }\r
- else {\r
- segment = remaining;\r
- }\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 0, interval);\r
- if (!timeout)\r
- nread = recv(s->sock_fd, read_buf, segment, flags);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return -1;\r
- }\r
- END_SELECT_LOOP(s)\r
-\r
- if (nread < 0) {\r
- s->errorhandler();\r
- return -1;\r
- }\r
- if (nread != remaining) {\r
- read_buf += nread;\r
- break;\r
- }\r
-\r
- remaining -= segment;\r
- read_buf += segment;\r
- }\r
- outlen = read_buf - cbuf;\r
-#endif /* !__VMS */\r
-\r
- return outlen;\r
-}\r
-\r
-\r
-/* s.recv(nbytes [,flags]) method */\r
-\r
-static PyObject *\r
-sock_recv(PySocketSockObject *s, PyObject *args)\r
-{\r
- int recvlen, flags = 0;\r
- ssize_t outlen;\r
- PyObject *buf;\r
-\r
- if (!PyArg_ParseTuple(args, "i|i:recv", &recvlen, &flags))\r
- return NULL;\r
-\r
- if (recvlen < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "negative buffersize in recv");\r
- return NULL;\r
- }\r
-\r
- /* Allocate a new string. */\r
- buf = PyString_FromStringAndSize((char *) 0, recvlen);\r
- if (buf == NULL)\r
- return NULL;\r
-\r
- /* Call the guts */\r
- outlen = sock_recv_guts(s, PyString_AS_STRING(buf), recvlen, flags);\r
- if (outlen < 0) {\r
- /* An error occurred, release the string and return an\r
- error. */\r
- Py_DECREF(buf);\r
- return NULL;\r
- }\r
- if (outlen != recvlen) {\r
- /* We did not read as many bytes as we anticipated, resize the\r
- string if possible and be successful. */\r
- if (_PyString_Resize(&buf, outlen) < 0)\r
- /* Oopsy, not so successful after all. */\r
- return NULL;\r
- }\r
-\r
- return buf;\r
-}\r
-\r
-PyDoc_STRVAR(recv_doc,\r
-"recv(buffersize[, flags]) -> data\n\\r
-\n\\r
-Receive up to buffersize bytes from the socket. For the optional flags\n\\r
-argument, see the Unix manual. When no data is available, block until\n\\r
-at least one byte is available or until the remote end is closed. When\n\\r
-the remote end is closed and all data is read, return the empty string.");\r
-\r
-\r
-/* s.recv_into(buffer, [nbytes [,flags]]) method */\r
-\r
-static PyObject*\r
-sock_recv_into(PySocketSockObject *s, PyObject *args, PyObject *kwds)\r
-{\r
- static char *kwlist[] = {"buffer", "nbytes", "flags", 0};\r
-\r
- int recvlen = 0, flags = 0;\r
- ssize_t readlen;\r
- Py_buffer buf;\r
- Py_ssize_t buflen;\r
-\r
- /* Get the buffer's memory */\r
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recv_into", kwlist,\r
- &buf, &recvlen, &flags))\r
- return NULL;\r
- buflen = buf.len;\r
- assert(buf.buf != 0 && buflen > 0);\r
-\r
- if (recvlen < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "negative buffersize in recv_into");\r
- goto error;\r
- }\r
- if (recvlen == 0) {\r
- /* If nbytes was not specified, use the buffer's length */\r
- recvlen = buflen;\r
- }\r
-\r
- /* Check if the buffer is large enough */\r
- if (buflen < recvlen) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "buffer too small for requested bytes");\r
- goto error;\r
- }\r
-\r
- /* Call the guts */\r
- readlen = sock_recv_guts(s, buf.buf, recvlen, flags);\r
- if (readlen < 0) {\r
- /* Return an error. */\r
- goto error;\r
- }\r
-\r
- PyBuffer_Release(&buf);\r
- /* Return the number of bytes read. Note that we do not do anything\r
- special here in the case that readlen < recvlen. */\r
- return PyInt_FromSsize_t(readlen);\r
-\r
-error:\r
- PyBuffer_Release(&buf);\r
- return NULL;\r
-}\r
-\r
-PyDoc_STRVAR(recv_into_doc,\r
-"recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\\r
-\n\\r
-A version of recv() that stores its data into a buffer rather than creating \n\\r
-a new string. Receive up to buffersize bytes from the socket. If buffersize \n\\r
-is not specified (or 0), receive up to the size available in the given buffer.\n\\r
-\n\\r
-See recv() for documentation about the flags.");\r
-\r
-\r
-/*\r
- * This is the guts of the recvfrom() and recvfrom_into() methods, which reads\r
- * into a char buffer. If you have any inc/def ref to do to the objects that\r
- * contain the buffer, do it in the caller. This function returns the number\r
- * of bytes successfully read. If there was an error, it returns -1. Note\r
- * that it is also possible that we return a number of bytes smaller than the\r
- * request bytes.\r
- *\r
- * 'addr' is a return value for the address object. Note that you must decref\r
- * it yourself.\r
- */\r
-static ssize_t\r
-sock_recvfrom_guts(PySocketSockObject *s, char* cbuf, int len, int flags,\r
- PyObject** addr)\r
-{\r
- sock_addr_t addrbuf;\r
- int timeout;\r
- ssize_t n = -1;\r
- socklen_t addrlen;\r
-\r
- *addr = NULL;\r
-\r
- if (!getsockaddrlen(s, &addrlen))\r
- return -1;\r
-\r
- if (!IS_SELECTABLE(s)) {\r
- select_error();\r
- return -1;\r
- }\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- memset(&addrbuf, 0, addrlen);\r
- timeout = internal_select_ex(s, 0, interval);\r
- if (!timeout) {\r
-#ifndef MS_WINDOWS\r
-#if defined(PYOS_OS2) && !defined(PYCC_GCC)\r
- n = recvfrom(s->sock_fd, cbuf, len, flags,\r
- SAS2SA(&addrbuf), &addrlen);\r
-#else\r
- n = recvfrom(s->sock_fd, cbuf, len, flags,\r
- (void *) &addrbuf, &addrlen);\r
-#endif\r
-#else\r
- n = recvfrom(s->sock_fd, cbuf, len, flags,\r
- SAS2SA(&addrbuf), &addrlen);\r
-#endif\r
- }\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return -1;\r
- }\r
- END_SELECT_LOOP(s)\r
- if (n < 0) {\r
- s->errorhandler();\r
- return -1;\r
- }\r
-\r
- if (!(*addr = makesockaddr(s->sock_fd, SAS2SA(&addrbuf),\r
- addrlen, s->sock_proto)))\r
- return -1;\r
-\r
- return n;\r
-}\r
-\r
-/* s.recvfrom(nbytes [,flags]) method */\r
-\r
-static PyObject *\r
-sock_recvfrom(PySocketSockObject *s, PyObject *args)\r
-{\r
- PyObject *buf = NULL;\r
- PyObject *addr = NULL;\r
- PyObject *ret = NULL;\r
- int recvlen, flags = 0;\r
- ssize_t outlen;\r
-\r
- if (!PyArg_ParseTuple(args, "i|i:recvfrom", &recvlen, &flags))\r
- return NULL;\r
-\r
- if (recvlen < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "negative buffersize in recvfrom");\r
- return NULL;\r
- }\r
-\r
- buf = PyString_FromStringAndSize((char *) 0, recvlen);\r
- if (buf == NULL)\r
- return NULL;\r
-\r
- outlen = sock_recvfrom_guts(s, PyString_AS_STRING(buf),\r
- recvlen, flags, &addr);\r
- if (outlen < 0) {\r
- goto finally;\r
- }\r
-\r
- if (outlen != recvlen) {\r
- /* We did not read as many bytes as we anticipated, resize the\r
- string if possible and be successful. */\r
- if (_PyString_Resize(&buf, outlen) < 0)\r
- /* Oopsy, not so successful after all. */\r
- goto finally;\r
- }\r
-\r
- ret = PyTuple_Pack(2, buf, addr);\r
-\r
-finally:\r
- Py_XDECREF(buf);\r
- Py_XDECREF(addr);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(recvfrom_doc,\r
-"recvfrom(buffersize[, flags]) -> (data, address info)\n\\r
-\n\\r
-Like recv(buffersize, flags) but also return the sender's address info.");\r
-\r
-\r
-/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */\r
-\r
-static PyObject *\r
-sock_recvfrom_into(PySocketSockObject *s, PyObject *args, PyObject* kwds)\r
-{\r
- static char *kwlist[] = {"buffer", "nbytes", "flags", 0};\r
-\r
- int recvlen = 0, flags = 0;\r
- ssize_t readlen;\r
- Py_buffer buf;\r
- int buflen;\r
-\r
- PyObject *addr = NULL;\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "w*|ii:recvfrom_into",\r
- kwlist, &buf,\r
- &recvlen, &flags))\r
- return NULL;\r
- buflen = buf.len;\r
-\r
- if (recvlen < 0) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "negative buffersize in recvfrom_into");\r
- goto error;\r
- }\r
- if (recvlen == 0) {\r
- /* If nbytes was not specified, use the buffer's length */\r
- recvlen = buflen;\r
- } else if (recvlen > buflen) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "nbytes is greater than the length of the buffer");\r
- goto error;\r
- }\r
-\r
- readlen = sock_recvfrom_guts(s, buf.buf, recvlen, flags, &addr);\r
- if (readlen < 0) {\r
- /* Return an error */\r
- goto error;\r
- }\r
-\r
- PyBuffer_Release(&buf);\r
- /* Return the number of bytes read and the address. Note that we do\r
- not do anything special here in the case that readlen < recvlen. */\r
- return Py_BuildValue("lN", readlen, addr);\r
-\r
-error:\r
- Py_XDECREF(addr);\r
- PyBuffer_Release(&buf);\r
- return NULL;\r
-}\r
-\r
-PyDoc_STRVAR(recvfrom_into_doc,\r
-"recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\\r
-\n\\r
-Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.");\r
-\r
-\r
-/* s.send(data [,flags]) method */\r
-\r
-static PyObject *\r
-sock_send(PySocketSockObject *s, PyObject *args)\r
-{\r
- char *buf;\r
- int len, n = -1, flags = 0, timeout;\r
- Py_buffer pbuf;\r
-\r
- if (!PyArg_ParseTuple(args, "s*|i:send", &pbuf, &flags))\r
- return NULL;\r
-\r
- if (!IS_SELECTABLE(s)) {\r
- PyBuffer_Release(&pbuf);\r
- return select_error();\r
- }\r
- buf = pbuf.buf;\r
- len = pbuf.len;\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 1, interval);\r
- if (!timeout)\r
-#ifdef __VMS\r
- n = sendsegmented(s->sock_fd, buf, len, flags);\r
-#else\r
- n = send(s->sock_fd, buf, len, flags);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- if (timeout == 1) {\r
- PyBuffer_Release(&pbuf);\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return NULL;\r
- }\r
- END_SELECT_LOOP(s)\r
-\r
- PyBuffer_Release(&pbuf);\r
- if (n < 0)\r
- return s->errorhandler();\r
- return PyInt_FromLong((long)n);\r
-}\r
-\r
-PyDoc_STRVAR(send_doc,\r
-"send(data[, flags]) -> count\n\\r
-\n\\r
-Send a data string to the socket. For the optional flags\n\\r
-argument, see the Unix manual. Return the number of bytes\n\\r
-sent; this may be less than len(data) if the network is busy.");\r
-\r
-\r
-/* s.sendall(data [,flags]) method */\r
-\r
-static PyObject *\r
-sock_sendall(PySocketSockObject *s, PyObject *args)\r
-{\r
- char *buf;\r
- int len, n = -1, flags = 0, timeout, saved_errno;\r
- Py_buffer pbuf;\r
-\r
- if (!PyArg_ParseTuple(args, "s*|i:sendall", &pbuf, &flags))\r
- return NULL;\r
- buf = pbuf.buf;\r
- len = pbuf.len;\r
-\r
- if (!IS_SELECTABLE(s)) {\r
- PyBuffer_Release(&pbuf);\r
- return select_error();\r
- }\r
-\r
- do {\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 1, interval);\r
- n = -1;\r
- if (!timeout) {\r
-#ifdef __VMS\r
- n = sendsegmented(s->sock_fd, buf, len, flags);\r
-#else\r
- n = send(s->sock_fd, buf, len, flags);\r
-#endif\r
- }\r
- Py_END_ALLOW_THREADS\r
- if (timeout == 1) {\r
- PyBuffer_Release(&pbuf);\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return NULL;\r
- }\r
- END_SELECT_LOOP(s)\r
- /* PyErr_CheckSignals() might change errno */\r
- saved_errno = errno;\r
- /* We must run our signal handlers before looping again.\r
- send() can return a successful partial write when it is\r
- interrupted, so we can't restrict ourselves to EINTR. */\r
- if (PyErr_CheckSignals()) {\r
- PyBuffer_Release(&pbuf);\r
- return NULL;\r
- }\r
- if (n < 0) {\r
- /* If interrupted, try again */\r
- if (saved_errno == EINTR)\r
- continue;\r
- else\r
- break;\r
- }\r
- buf += n;\r
- len -= n;\r
- } while (len > 0);\r
- PyBuffer_Release(&pbuf);\r
-\r
- if (n < 0)\r
- return s->errorhandler();\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(sendall_doc,\r
-"sendall(data[, flags])\n\\r
-\n\\r
-Send a data string to the socket. For the optional flags\n\\r
-argument, see the Unix manual. This calls send() repeatedly\n\\r
-until all data is sent. If an error occurs, it's impossible\n\\r
-to tell how much data has been sent.");\r
-\r
-\r
-/* s.sendto(data, [flags,] sockaddr) method */\r
-\r
-static PyObject *\r
-sock_sendto(PySocketSockObject *s, PyObject *args)\r
-{\r
- Py_buffer pbuf;\r
- PyObject *addro;\r
- char *buf;\r
- Py_ssize_t len;\r
- sock_addr_t addrbuf;\r
- int addrlen, flags, timeout;\r
- long n = -1;\r
- int arglen;\r
-\r
- flags = 0;\r
- arglen = PyTuple_Size(args);\r
- switch(arglen) {\r
- case 2:\r
- PyArg_ParseTuple(args, "s*O:sendto", &pbuf, &addro);\r
- break;\r
- case 3:\r
- PyArg_ParseTuple(args, "s*iO:sendto", &pbuf, &flags, &addro);\r
- break;\r
- default:\r
- PyErr_Format(PyExc_TypeError, "sendto() takes 2 or 3"\r
- " arguments (%d given)", arglen);\r
- }\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- buf = pbuf.buf;\r
- len = pbuf.len;\r
-\r
- if (!IS_SELECTABLE(s)) {\r
- PyBuffer_Release(&pbuf);\r
- return select_error();\r
- }\r
-\r
- if (!getsockaddrarg(s, addro, SAS2SA(&addrbuf), &addrlen)) {\r
- PyBuffer_Release(&pbuf);\r
- return NULL;\r
- }\r
-\r
- BEGIN_SELECT_LOOP(s)\r
- Py_BEGIN_ALLOW_THREADS\r
- timeout = internal_select_ex(s, 1, interval);\r
- if (!timeout)\r
- n = sendto(s->sock_fd, buf, len, flags, SAS2SA(&addrbuf), addrlen);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (timeout == 1) {\r
- PyBuffer_Release(&pbuf);\r
- PyErr_SetString(socket_timeout, "timed out");\r
- return NULL;\r
- }\r
- END_SELECT_LOOP(s)\r
- PyBuffer_Release(&pbuf);\r
- if (n < 0)\r
- return s->errorhandler();\r
- return PyInt_FromLong((long)n);\r
-}\r
-\r
-PyDoc_STRVAR(sendto_doc,\r
-"sendto(data[, flags], address) -> count\n\\r
-\n\\r
-Like send(data, flags) but allows specifying the destination address.\n\\r
-For IP sockets, the address is a pair (hostaddr, port).");\r
-\r
-\r
-/* s.shutdown(how) method */\r
-\r
-static PyObject *\r
-sock_shutdown(PySocketSockObject *s, PyObject *arg)\r
-{\r
- int how;\r
- int res;\r
-\r
- how = _PyInt_AsInt(arg);\r
- if (how == -1 && PyErr_Occurred())\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = shutdown(s->sock_fd, how);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return s->errorhandler();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(shutdown_doc,\r
-"shutdown(flag)\n\\r
-\n\\r
-Shut down the reading side of the socket (flag == SHUT_RD), the writing side\n\\r
-of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).");\r
-\r
-#if defined(MS_WINDOWS) && defined(SIO_RCVALL)\r
-static PyObject*\r
-sock_ioctl(PySocketSockObject *s, PyObject *arg)\r
-{\r
- unsigned long cmd = SIO_RCVALL;\r
- PyObject *argO;\r
- DWORD recv;\r
-\r
- if (!PyArg_ParseTuple(arg, "kO:ioctl", &cmd, &argO))\r
- return NULL;\r
-\r
- switch (cmd) {\r
- case SIO_RCVALL: {\r
- unsigned int option = RCVALL_ON;\r
- if (!PyArg_ParseTuple(arg, "kI:ioctl", &cmd, &option))\r
- return NULL;\r
- if (WSAIoctl(s->sock_fd, cmd, &option, sizeof(option),\r
- NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {\r
- return set_error();\r
- }\r
- return PyLong_FromUnsignedLong(recv); }\r
- case SIO_KEEPALIVE_VALS: {\r
- struct tcp_keepalive ka;\r
- if (!PyArg_ParseTuple(arg, "k(kkk):ioctl", &cmd,\r
- &ka.onoff, &ka.keepalivetime, &ka.keepaliveinterval))\r
- return NULL;\r
- if (WSAIoctl(s->sock_fd, cmd, &ka, sizeof(ka),\r
- NULL, 0, &recv, NULL, NULL) == SOCKET_ERROR) {\r
- return set_error();\r
- }\r
- return PyLong_FromUnsignedLong(recv); }\r
- default:\r
- PyErr_Format(PyExc_ValueError, "invalid ioctl command %d", cmd);\r
- return NULL;\r
- }\r
-}\r
-PyDoc_STRVAR(sock_ioctl_doc,\r
-"ioctl(cmd, option) -> long\n\\r
-\n\\r
-Control the socket with WSAIoctl syscall. Currently supported 'cmd' values are\n\\r
-SIO_RCVALL: 'option' must be one of the socket.RCVALL_* constants.\n\\r
-SIO_KEEPALIVE_VALS: 'option' is a tuple of (onoff, timeout, interval).");\r
-\r
-#endif\r
-\r
-/* List of methods for socket objects */\r
-\r
-static PyMethodDef sock_methods[] = {\r
- {"accept", (PyCFunction)sock_accept, METH_NOARGS,\r
- accept_doc},\r
- {"bind", (PyCFunction)sock_bind, METH_O,\r
- bind_doc},\r
- {"close", (PyCFunction)sock_close, METH_NOARGS,\r
- close_doc},\r
- {"connect", (PyCFunction)sock_connect, METH_O,\r
- connect_doc},\r
- {"connect_ex", (PyCFunction)sock_connect_ex, METH_O,\r
- connect_ex_doc},\r
-#ifndef NO_DUP\r
- {"dup", (PyCFunction)sock_dup, METH_NOARGS,\r
- dup_doc},\r
-#endif\r
- {"fileno", (PyCFunction)sock_fileno, METH_NOARGS,\r
- fileno_doc},\r
-#ifdef HAVE_GETPEERNAME\r
- {"getpeername", (PyCFunction)sock_getpeername,\r
- METH_NOARGS, getpeername_doc},\r
-#endif\r
- {"getsockname", (PyCFunction)sock_getsockname,\r
- METH_NOARGS, getsockname_doc},\r
- {"getsockopt", (PyCFunction)sock_getsockopt, METH_VARARGS,\r
- getsockopt_doc},\r
-#if defined(MS_WINDOWS) && defined(SIO_RCVALL)\r
- {"ioctl", (PyCFunction)sock_ioctl, METH_VARARGS,\r
- sock_ioctl_doc},\r
-#endif\r
- {"listen", (PyCFunction)sock_listen, METH_O,\r
- listen_doc},\r
-#ifndef NO_DUP\r
- {"makefile", (PyCFunction)sock_makefile, METH_VARARGS,\r
- makefile_doc},\r
-#endif\r
- {"recv", (PyCFunction)sock_recv, METH_VARARGS,\r
- recv_doc},\r
- {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,\r
- recv_into_doc},\r
- {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,\r
- recvfrom_doc},\r
- {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,\r
- recvfrom_into_doc},\r
- {"send", (PyCFunction)sock_send, METH_VARARGS,\r
- send_doc},\r
- {"sendall", (PyCFunction)sock_sendall, METH_VARARGS,\r
- sendall_doc},\r
- {"sendto", (PyCFunction)sock_sendto, METH_VARARGS,\r
- sendto_doc},\r
- {"setblocking", (PyCFunction)sock_setblocking, METH_O,\r
- setblocking_doc},\r
- {"settimeout", (PyCFunction)sock_settimeout, METH_O,\r
- settimeout_doc},\r
- {"gettimeout", (PyCFunction)sock_gettimeout, METH_NOARGS,\r
- gettimeout_doc},\r
- {"setsockopt", (PyCFunction)sock_setsockopt, METH_VARARGS,\r
- setsockopt_doc},\r
- {"shutdown", (PyCFunction)sock_shutdown, METH_O,\r
- shutdown_doc},\r
-#ifdef RISCOS\r
- {"sleeptaskw", (PyCFunction)sock_sleeptaskw, METH_O,\r
- sleeptaskw_doc},\r
-#endif\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-/* SockObject members */\r
-static PyMemberDef sock_memberlist[] = {\r
- {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"},\r
- {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"},\r
- {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"},\r
- {"timeout", T_DOUBLE, offsetof(PySocketSockObject, sock_timeout), READONLY, "the socket timeout"},\r
- {0},\r
-};\r
-\r
-/* Deallocate a socket object in response to the last Py_DECREF().\r
- First close the file description. */\r
-\r
-static void\r
-sock_dealloc(PySocketSockObject *s)\r
-{\r
- if (s->sock_fd != -1)\r
- (void) SOCKETCLOSE(s->sock_fd);\r
- if (s->weakreflist != NULL)\r
- PyObject_ClearWeakRefs((PyObject *)s);\r
- Py_TYPE(s)->tp_free((PyObject *)s);\r
-}\r
-\r
-\r
-static PyObject *\r
-sock_repr(PySocketSockObject *s)\r
-{\r
- char buf[512];\r
- long sock_fd;\r
- /* On Windows, this test is needed because SOCKET_T is unsigned */\r
- if (s->sock_fd == INVALID_SOCKET) {\r
- sock_fd = -1;\r
- }\r
-#if SIZEOF_SOCKET_T > SIZEOF_LONG\r
- else if (s->sock_fd > LONG_MAX) {\r
- /* this can occur on Win64, and actually there is a special\r
- ugly printf formatter for decimal pointer length integer\r
- printing, only bother if necessary*/\r
- PyErr_SetString(PyExc_OverflowError,\r
- "no printf formatter to display "\r
- "the socket descriptor in decimal");\r
- return NULL;\r
- }\r
-#endif\r
- else\r
- sock_fd = (long)s->sock_fd;\r
- PyOS_snprintf(\r
- buf, sizeof(buf),\r
- "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",\r
- sock_fd, s->sock_family,\r
- s->sock_type,\r
- s->sock_proto);\r
- return PyString_FromString(buf);\r
-}\r
-\r
-\r
-/* Create a new, uninitialized socket object. */\r
-\r
-static PyObject *\r
-sock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)\r
-{\r
- PyObject *new;\r
-\r
- new = type->tp_alloc(type, 0);\r
- if (new != NULL) {\r
- ((PySocketSockObject *)new)->sock_fd = -1;\r
- ((PySocketSockObject *)new)->sock_timeout = -1.0;\r
- ((PySocketSockObject *)new)->errorhandler = &set_error;\r
- ((PySocketSockObject *)new)->weakreflist = NULL;\r
- }\r
- return new;\r
-}\r
-\r
-\r
-/* Initialize a new socket object. */\r
-\r
-/*ARGSUSED*/\r
-static int\r
-sock_initobj(PyObject *self, PyObject *args, PyObject *kwds)\r
-{\r
- PySocketSockObject *s = (PySocketSockObject *)self;\r
- SOCKET_T fd;\r
- int family = AF_INET, type = SOCK_STREAM, proto = 0;\r
- static char *keywords[] = {"family", "type", "proto", 0};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwds,\r
- "|iii:socket", keywords,\r
- &family, &type, &proto))\r
- return -1;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- fd = socket(family, type, proto);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (fd == INVALID_SOCKET) {\r
- set_error();\r
- return -1;\r
- }\r
- init_sockobject(s, fd, family, type, proto);\r
-\r
- return 0;\r
-\r
-}\r
-\r
-\r
-/* Type object for socket objects. */\r
-\r
-static PyTypeObject sock_type = {\r
- PyVarObject_HEAD_INIT(0, 0) /* Must fill in type value later */\r
- "_socket.socket", /* tp_name */\r
- sizeof(PySocketSockObject), /* tp_basicsize */\r
- 0, /* tp_itemsize */\r
- (destructor)sock_dealloc, /* tp_dealloc */\r
- 0, /* tp_print */\r
- 0, /* tp_getattr */\r
- 0, /* tp_setattr */\r
- 0, /* tp_compare */\r
- (reprfunc)sock_repr, /* tp_repr */\r
- 0, /* tp_as_number */\r
- 0, /* tp_as_sequence */\r
- 0, /* tp_as_mapping */\r
- 0, /* tp_hash */\r
- 0, /* tp_call */\r
- 0, /* tp_str */\r
- PyObject_GenericGetAttr, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- 0, /* tp_as_buffer */\r
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */\r
- sock_doc, /* tp_doc */\r
- 0, /* tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- offsetof(PySocketSockObject, weakreflist), /* tp_weaklistoffset */\r
- 0, /* tp_iter */\r
- 0, /* tp_iternext */\r
- sock_methods, /* tp_methods */\r
- sock_memberlist, /* tp_members */\r
- 0, /* tp_getset */\r
- 0, /* tp_base */\r
- 0, /* tp_dict */\r
- 0, /* tp_descr_get */\r
- 0, /* tp_descr_set */\r
- 0, /* tp_dictoffset */\r
- sock_initobj, /* tp_init */\r
- PyType_GenericAlloc, /* tp_alloc */\r
- sock_new, /* tp_new */\r
- PyObject_Del, /* tp_free */\r
-};\r
-\r
-\r
-/* Python interface to gethostname(). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_gethostname(PyObject *self, PyObject *unused)\r
-{\r
- char buf[1024];\r
- int res;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = gethostname(buf, (int) sizeof buf - 1);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return set_error();\r
- buf[sizeof buf - 1] = '\0';\r
- return PyString_FromString(buf);\r
-}\r
-\r
-PyDoc_STRVAR(gethostname_doc,\r
-"gethostname() -> string\n\\r
-\n\\r
-Return the current host name.");\r
-\r
-\r
-/* Python interface to gethostbyname(name). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_gethostbyname(PyObject *self, PyObject *args)\r
-{\r
- char *name;\r
- sock_addr_t addrbuf;\r
-\r
- if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))\r
- return NULL;\r
- if (setipaddr(name, SAS2SA(&addrbuf), sizeof(addrbuf), AF_INET) < 0)\r
- return NULL;\r
- return makeipaddr(SAS2SA(&addrbuf), sizeof(struct sockaddr_in));\r
-}\r
-\r
-PyDoc_STRVAR(gethostbyname_doc,\r
-"gethostbyname(host) -> address\n\\r
-\n\\r
-Return the IP address (a string of the form '255.255.255.255') for a host.");\r
-\r
-\r
-/* Convenience function common to gethostbyname_ex and gethostbyaddr */\r
-\r
-static PyObject *\r
-gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)\r
-{\r
- char **pch;\r
- PyObject *rtn_tuple = (PyObject *)NULL;\r
- PyObject *name_list = (PyObject *)NULL;\r
- PyObject *addr_list = (PyObject *)NULL;\r
- PyObject *tmp;\r
-\r
- if (h == NULL) {\r
- /* Let's get real error message to return */\r
-#ifndef RISCOS\r
- set_herror(h_errno);\r
-#else\r
- PyErr_SetString(socket_error, "host not found");\r
-#endif\r
- return NULL;\r
- }\r
-\r
- if (h->h_addrtype != af) {\r
- /* Let's get real error message to return */\r
- PyErr_SetString(socket_error,\r
- (char *)strerror(EAFNOSUPPORT));\r
-\r
- return NULL;\r
- }\r
-\r
- switch (af) {\r
-\r
- case AF_INET:\r
- if (alen < sizeof(struct sockaddr_in))\r
- return NULL;\r
- break;\r
-\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- if (alen < sizeof(struct sockaddr_in6))\r
- return NULL;\r
- break;\r
-#endif\r
-\r
- }\r
-\r
- if ((name_list = PyList_New(0)) == NULL)\r
- goto err;\r
-\r
- if ((addr_list = PyList_New(0)) == NULL)\r
- goto err;\r
-\r
- /* SF #1511317: h_aliases can be NULL */\r
- if (h->h_aliases) {\r
- for (pch = h->h_aliases; *pch != NULL; pch++) {\r
- int status;\r
- tmp = PyString_FromString(*pch);\r
- if (tmp == NULL)\r
- goto err;\r
-\r
- status = PyList_Append(name_list, tmp);\r
- Py_DECREF(tmp);\r
-\r
- if (status)\r
- goto err;\r
- }\r
- }\r
-\r
- for (pch = h->h_addr_list; *pch != NULL; pch++) {\r
- int status;\r
-\r
- switch (af) {\r
-\r
- case AF_INET:\r
- {\r
- struct sockaddr_in sin;\r
- memset(&sin, 0, sizeof(sin));\r
- sin.sin_family = af;\r
-#ifdef HAVE_SOCKADDR_SA_LEN\r
- sin.sin_len = sizeof(sin);\r
-#endif\r
- memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));\r
- tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));\r
-\r
- if (pch == h->h_addr_list && alen >= sizeof(sin))\r
- memcpy((char *) addr, &sin, sizeof(sin));\r
- break;\r
- }\r
-\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- {\r
- struct sockaddr_in6 sin6;\r
- memset(&sin6, 0, sizeof(sin6));\r
- sin6.sin6_family = af;\r
-#ifdef HAVE_SOCKADDR_SA_LEN\r
- sin6.sin6_len = sizeof(sin6);\r
-#endif\r
- memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));\r
- tmp = makeipaddr((struct sockaddr *)&sin6,\r
- sizeof(sin6));\r
-\r
- if (pch == h->h_addr_list && alen >= sizeof(sin6))\r
- memcpy((char *) addr, &sin6, sizeof(sin6));\r
- break;\r
- }\r
-#endif\r
-\r
- default: /* can't happen */\r
- PyErr_SetString(socket_error,\r
- "unsupported address family");\r
- return NULL;\r
- }\r
-\r
- if (tmp == NULL)\r
- goto err;\r
-\r
- status = PyList_Append(addr_list, tmp);\r
- Py_DECREF(tmp);\r
-\r
- if (status)\r
- goto err;\r
- }\r
-\r
- rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);\r
-\r
- err:\r
- Py_XDECREF(name_list);\r
- Py_XDECREF(addr_list);\r
- return rtn_tuple;\r
-}\r
-\r
-\r
-/* Python interface to gethostbyname_ex(name). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_gethostbyname_ex(PyObject *self, PyObject *args)\r
-{\r
- char *name;\r
- struct hostent *h;\r
-#ifdef ENABLE_IPV6\r
- struct sockaddr_storage addr;\r
-#else\r
- struct sockaddr_in addr;\r
-#endif\r
- struct sockaddr *sa;\r
- PyObject *ret;\r
-#ifdef HAVE_GETHOSTBYNAME_R\r
- struct hostent hp_allocated;\r
-#ifdef HAVE_GETHOSTBYNAME_R_3_ARG\r
- struct hostent_data data;\r
-#else\r
- char buf[16384];\r
- int buf_len = (sizeof buf) - 1;\r
- int errnop;\r
-#endif\r
-#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)\r
- int result;\r
-#endif\r
-#endif /* HAVE_GETHOSTBYNAME_R */\r
-\r
- if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))\r
- return NULL;\r
- if (setipaddr(name, (struct sockaddr *)&addr, sizeof(addr), AF_INET) < 0)\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
-#ifdef HAVE_GETHOSTBYNAME_R\r
-#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)\r
- result = gethostbyname_r(name, &hp_allocated, buf, buf_len,\r
- &h, &errnop);\r
-#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)\r
- h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);\r
-#else /* HAVE_GETHOSTBYNAME_R_3_ARG */\r
- memset((void *) &data, '\0', sizeof(data));\r
- result = gethostbyname_r(name, &hp_allocated, &data);\r
- h = (result != 0) ? NULL : &hp_allocated;\r
-#endif\r
-#else /* not HAVE_GETHOSTBYNAME_R */\r
-#ifdef USE_GETHOSTBYNAME_LOCK\r
- PyThread_acquire_lock(netdb_lock, 1);\r
-#endif\r
- h = gethostbyname(name);\r
-#endif /* HAVE_GETHOSTBYNAME_R */\r
- Py_END_ALLOW_THREADS\r
- /* Some C libraries would require addr.__ss_family instead of\r
- addr.ss_family.\r
- Therefore, we cast the sockaddr_storage into sockaddr to\r
- access sa_family. */\r
- sa = (struct sockaddr*)&addr;\r
- ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr),\r
- sa->sa_family);\r
-#ifdef USE_GETHOSTBYNAME_LOCK\r
- PyThread_release_lock(netdb_lock);\r
-#endif\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(ghbn_ex_doc,\r
-"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\\r
-\n\\r
-Return the true host name, a list of aliases, and a list of IP addresses,\n\\r
-for a host. The host argument is a string giving a host name or IP number.");\r
-\r
-\r
-/* Python interface to gethostbyaddr(IP). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_gethostbyaddr(PyObject *self, PyObject *args)\r
-{\r
-#ifdef ENABLE_IPV6\r
- struct sockaddr_storage addr;\r
-#else\r
- struct sockaddr_in addr;\r
-#endif\r
- struct sockaddr *sa = (struct sockaddr *)&addr;\r
- char *ip_num;\r
- struct hostent *h;\r
- PyObject *ret;\r
-#ifdef HAVE_GETHOSTBYNAME_R\r
- struct hostent hp_allocated;\r
-#ifdef HAVE_GETHOSTBYNAME_R_3_ARG\r
- struct hostent_data data;\r
-#else\r
- /* glibcs up to 2.10 assume that the buf argument to\r
- gethostbyaddr_r is 8-byte aligned, which at least llvm-gcc\r
- does not ensure. The attribute below instructs the compiler\r
- to maintain this alignment. */\r
- char buf[16384] Py_ALIGNED(8);\r
- int buf_len = (sizeof buf) - 1;\r
- int errnop;\r
-#endif\r
-#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)\r
- int result;\r
-#endif\r
-#endif /* HAVE_GETHOSTBYNAME_R */\r
- char *ap;\r
- int al;\r
- int af;\r
-\r
- if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))\r
- return NULL;\r
- af = AF_UNSPEC;\r
- if (setipaddr(ip_num, sa, sizeof(addr), af) < 0)\r
- return NULL;\r
- af = sa->sa_family;\r
- ap = NULL;\r
- switch (af) {\r
- case AF_INET:\r
- ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;\r
- al = sizeof(((struct sockaddr_in *)sa)->sin_addr);\r
- break;\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;\r
- al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);\r
- break;\r
-#endif\r
- default:\r
- PyErr_SetString(socket_error, "unsupported address family");\r
- return NULL;\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
-#ifdef HAVE_GETHOSTBYNAME_R\r
-#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)\r
- result = gethostbyaddr_r(ap, al, af,\r
- &hp_allocated, buf, buf_len,\r
- &h, &errnop);\r
-#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)\r
- h = gethostbyaddr_r(ap, al, af,\r
- &hp_allocated, buf, buf_len, &errnop);\r
-#else /* HAVE_GETHOSTBYNAME_R_3_ARG */\r
- memset((void *) &data, '\0', sizeof(data));\r
- result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);\r
- h = (result != 0) ? NULL : &hp_allocated;\r
-#endif\r
-#else /* not HAVE_GETHOSTBYNAME_R */\r
-#ifdef USE_GETHOSTBYNAME_LOCK\r
- PyThread_acquire_lock(netdb_lock, 1);\r
-#endif\r
- h = gethostbyaddr(ap, al, af);\r
-#endif /* HAVE_GETHOSTBYNAME_R */\r
- Py_END_ALLOW_THREADS\r
- ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);\r
-#ifdef USE_GETHOSTBYNAME_LOCK\r
- PyThread_release_lock(netdb_lock);\r
-#endif\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(gethostbyaddr_doc,\r
-"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\\r
-\n\\r
-Return the true host name, a list of aliases, and a list of IP addresses,\n\\r
-for a host. The host argument is a string giving a host name or IP number.");\r
-\r
-\r
-/* Python interface to getservbyname(name).\r
- This only returns the port number, since the other info is already\r
- known or not useful (like the list of aliases). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_getservbyname(PyObject *self, PyObject *args)\r
-{\r
- char *name, *proto=NULL;\r
- struct servent *sp;\r
- if (!PyArg_ParseTuple(args, "s|s:getservbyname", &name, &proto))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- sp = getservbyname(name, proto);\r
- Py_END_ALLOW_THREADS\r
- if (sp == NULL) {\r
- PyErr_SetString(socket_error, "service/proto not found");\r
- return NULL;\r
- }\r
- return PyInt_FromLong((long) ntohs(sp->s_port));\r
-}\r
-\r
-PyDoc_STRVAR(getservbyname_doc,\r
-"getservbyname(servicename[, protocolname]) -> integer\n\\r
-\n\\r
-Return a port number from a service name and protocol name.\n\\r
-The optional protocol name, if given, should be 'tcp' or 'udp',\n\\r
-otherwise any protocol will match.");\r
-\r
-\r
-/* Python interface to getservbyport(port).\r
- This only returns the service name, since the other info is already\r
- known or not useful (like the list of aliases). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_getservbyport(PyObject *self, PyObject *args)\r
-{\r
- int port;\r
- char *proto=NULL;\r
- struct servent *sp;\r
- if (!PyArg_ParseTuple(args, "i|s:getservbyport", &port, &proto))\r
- return NULL;\r
- if (port < 0 || port > 0xffff) {\r
- PyErr_SetString(\r
- PyExc_OverflowError,\r
- "getservbyport: port must be 0-65535.");\r
- return NULL;\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- sp = getservbyport(htons((short)port), proto);\r
- Py_END_ALLOW_THREADS\r
- if (sp == NULL) {\r
- PyErr_SetString(socket_error, "port/proto not found");\r
- return NULL;\r
- }\r
- return PyString_FromString(sp->s_name);\r
-}\r
-\r
-PyDoc_STRVAR(getservbyport_doc,\r
-"getservbyport(port[, protocolname]) -> string\n\\r
-\n\\r
-Return the service name from a port number and protocol name.\n\\r
-The optional protocol name, if given, should be 'tcp' or 'udp',\n\\r
-otherwise any protocol will match.");\r
-\r
-/* Python interface to getprotobyname(name).\r
- This only returns the protocol number, since the other info is\r
- already known or not useful (like the list of aliases). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_getprotobyname(PyObject *self, PyObject *args)\r
-{\r
- char *name;\r
- struct protoent *sp;\r
-#ifdef __BEOS__\r
-/* Not available in BeOS yet. - [cjh] */\r
- PyErr_SetString(socket_error, "getprotobyname not supported");\r
- return NULL;\r
-#else\r
- if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- sp = getprotobyname(name);\r
- Py_END_ALLOW_THREADS\r
- if (sp == NULL) {\r
- PyErr_SetString(socket_error, "protocol not found");\r
- return NULL;\r
- }\r
- return PyInt_FromLong((long) sp->p_proto);\r
-#endif\r
-}\r
-\r
-PyDoc_STRVAR(getprotobyname_doc,\r
-"getprotobyname(name) -> integer\n\\r
-\n\\r
-Return the protocol number for the named protocol. (Rarely used.)");\r
-\r
-\r
-#ifdef HAVE_SOCKETPAIR\r
-/* Create a pair of sockets using the socketpair() function.\r
- Arguments as for socket() except the default family is AF_UNIX if\r
- defined on the platform; otherwise, the default is AF_INET. */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_socketpair(PyObject *self, PyObject *args)\r
-{\r
- PySocketSockObject *s0 = NULL, *s1 = NULL;\r
- SOCKET_T sv[2];\r
- int family, type = SOCK_STREAM, proto = 0;\r
- PyObject *res = NULL;\r
-\r
-#if defined(AF_UNIX)\r
- family = AF_UNIX;\r
-#else\r
- family = AF_INET;\r
-#endif\r
- if (!PyArg_ParseTuple(args, "|iii:socketpair",\r
- &family, &type, &proto))\r
- return NULL;\r
- /* Create a pair of socket fds */\r
- if (socketpair(family, type, proto, sv) < 0)\r
- return set_error();\r
- s0 = new_sockobject(sv[0], family, type, proto);\r
- if (s0 == NULL)\r
- goto finally;\r
- s1 = new_sockobject(sv[1], family, type, proto);\r
- if (s1 == NULL)\r
- goto finally;\r
- res = PyTuple_Pack(2, s0, s1);\r
-\r
-finally:\r
- if (res == NULL) {\r
- if (s0 == NULL)\r
- SOCKETCLOSE(sv[0]);\r
- if (s1 == NULL)\r
- SOCKETCLOSE(sv[1]);\r
- }\r
- Py_XDECREF(s0);\r
- Py_XDECREF(s1);\r
- return res;\r
-}\r
-\r
-PyDoc_STRVAR(socketpair_doc,\r
-"socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\\r
-\n\\r
-Create a pair of socket objects from the sockets returned by the platform\n\\r
-socketpair() function.\n\\r
-The arguments are the same as for socket() except the default family is\n\\r
-AF_UNIX if defined on the platform; otherwise, the default is AF_INET.");\r
-\r
-#endif /* HAVE_SOCKETPAIR */\r
-\r
-\r
-#ifndef NO_DUP\r
-/* Create a socket object from a numeric file description.\r
- Useful e.g. if stdin is a socket.\r
- Additional arguments as for socket(). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_fromfd(PyObject *self, PyObject *args)\r
-{\r
- PySocketSockObject *s;\r
- SOCKET_T fd;\r
- int family, type, proto = 0;\r
- if (!PyArg_ParseTuple(args, "iii|i:fromfd",\r
- &fd, &family, &type, &proto))\r
- return NULL;\r
- /* Dup the fd so it and the socket can be closed independently */\r
- fd = dup(fd);\r
- if (fd < 0)\r
- return set_error();\r
- s = new_sockobject(fd, family, type, proto);\r
- return (PyObject *) s;\r
-}\r
-\r
-PyDoc_STRVAR(fromfd_doc,\r
-"fromfd(fd, family, type[, proto]) -> socket object\n\\r
-\n\\r
-Create a socket object from a duplicate of the given\n\\r
-file descriptor.\n\\r
-The remaining arguments are the same as for socket().");\r
-\r
-#endif /* NO_DUP */\r
-\r
-\r
-static PyObject *\r
-socket_ntohs(PyObject *self, PyObject *args)\r
-{\r
- int x1, x2;\r
-\r
- if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {\r
- return NULL;\r
- }\r
- if (x1 < 0) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "can't convert negative number to unsigned long");\r
- return NULL;\r
- }\r
- x2 = (unsigned int)ntohs((unsigned short)x1);\r
- return PyInt_FromLong(x2);\r
-}\r
-\r
-PyDoc_STRVAR(ntohs_doc,\r
-"ntohs(integer) -> integer\n\\r
-\n\\r
-Convert a 16-bit integer from network to host byte order.");\r
-\r
-\r
-static PyObject *\r
-socket_ntohl(PyObject *self, PyObject *arg)\r
-{\r
- unsigned long x;\r
-\r
- if (PyInt_Check(arg)) {\r
- x = PyInt_AS_LONG(arg);\r
- if (x == (unsigned long) -1 && PyErr_Occurred())\r
- return NULL;\r
- if ((long)x < 0) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "can't convert negative number to unsigned long");\r
- return NULL;\r
- }\r
- }\r
- else if (PyLong_Check(arg)) {\r
- x = PyLong_AsUnsignedLong(arg);\r
- if (x == (unsigned long) -1 && PyErr_Occurred())\r
- return NULL;\r
-#if SIZEOF_LONG > 4\r
- {\r
- unsigned long y;\r
- /* only want the trailing 32 bits */\r
- y = x & 0xFFFFFFFFUL;\r
- if (y ^ x)\r
- return PyErr_Format(PyExc_OverflowError,\r
- "long int larger than 32 bits");\r
- x = y;\r
- }\r
-#endif\r
- }\r
- else\r
- return PyErr_Format(PyExc_TypeError,\r
- "expected int/long, %s found",\r
- Py_TYPE(arg)->tp_name);\r
- if (x == (unsigned long) -1 && PyErr_Occurred())\r
- return NULL;\r
- return PyLong_FromUnsignedLong(ntohl(x));\r
-}\r
-\r
-PyDoc_STRVAR(ntohl_doc,\r
-"ntohl(integer) -> integer\n\\r
-\n\\r
-Convert a 32-bit integer from network to host byte order.");\r
-\r
-\r
-static PyObject *\r
-socket_htons(PyObject *self, PyObject *args)\r
-{\r
- int x1, x2;\r
-\r
- if (!PyArg_ParseTuple(args, "i:htons", &x1)) {\r
- return NULL;\r
- }\r
- if (x1 < 0) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "can't convert negative number to unsigned long");\r
- return NULL;\r
- }\r
- x2 = (unsigned int)htons((unsigned short)x1);\r
- return PyInt_FromLong(x2);\r
-}\r
-\r
-PyDoc_STRVAR(htons_doc,\r
-"htons(integer) -> integer\n\\r
-\n\\r
-Convert a 16-bit integer from host to network byte order.");\r
-\r
-\r
-static PyObject *\r
-socket_htonl(PyObject *self, PyObject *arg)\r
-{\r
- unsigned long x;\r
-\r
- if (PyInt_Check(arg)) {\r
- x = PyInt_AS_LONG(arg);\r
- if (x == (unsigned long) -1 && PyErr_Occurred())\r
- return NULL;\r
- if ((long)x < 0) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "can't convert negative number to unsigned long");\r
- return NULL;\r
- }\r
- }\r
- else if (PyLong_Check(arg)) {\r
- x = PyLong_AsUnsignedLong(arg);\r
- if (x == (unsigned long) -1 && PyErr_Occurred())\r
- return NULL;\r
-#if SIZEOF_LONG > 4\r
- {\r
- unsigned long y;\r
- /* only want the trailing 32 bits */\r
- y = x & 0xFFFFFFFFUL;\r
- if (y ^ x)\r
- return PyErr_Format(PyExc_OverflowError,\r
- "long int larger than 32 bits");\r
- x = y;\r
- }\r
-#endif\r
- }\r
- else\r
- return PyErr_Format(PyExc_TypeError,\r
- "expected int/long, %s found",\r
- Py_TYPE(arg)->tp_name);\r
- return PyLong_FromUnsignedLong(htonl((unsigned long)x));\r
-}\r
-\r
-PyDoc_STRVAR(htonl_doc,\r
-"htonl(integer) -> integer\n\\r
-\n\\r
-Convert a 32-bit integer from host to network byte order.");\r
-\r
-/* socket.inet_aton() and socket.inet_ntoa() functions. */\r
-\r
-PyDoc_STRVAR(inet_aton_doc,\r
-"inet_aton(string) -> packed 32-bit IP representation\n\\r
-\n\\r
-Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\\r
-binary format used in low-level network functions.");\r
-\r
-static PyObject*\r
-socket_inet_aton(PyObject *self, PyObject *args)\r
-{\r
-#ifndef INADDR_NONE\r
-#define INADDR_NONE (-1)\r
-#endif\r
-#ifdef HAVE_INET_ATON\r
- struct in_addr buf;\r
-#endif\r
-\r
-#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)\r
-#if (SIZEOF_INT != 4)\r
-#error "Not sure if in_addr_t exists and int is not 32-bits."\r
-#endif\r
- /* Have to use inet_addr() instead */\r
- unsigned int packed_addr;\r
-#endif\r
- char *ip_addr;\r
-\r
- if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr))\r
- return NULL;\r
-\r
-\r
-#ifdef HAVE_INET_ATON\r
-\r
-#ifdef USE_INET_ATON_WEAKLINK\r
- if (inet_aton != NULL) {\r
-#endif\r
- if (inet_aton(ip_addr, &buf))\r
- return PyString_FromStringAndSize((char *)(&buf),\r
- sizeof(buf));\r
-\r
- PyErr_SetString(socket_error,\r
- "illegal IP address string passed to inet_aton");\r
- return NULL;\r
-\r
-#ifdef USE_INET_ATON_WEAKLINK\r
- } else {\r
-#endif\r
-\r
-#endif\r
-\r
-#if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)\r
-\r
- /* special-case this address as inet_addr might return INADDR_NONE\r
- * for this */\r
- if (strcmp(ip_addr, "255.255.255.255") == 0) {\r
- packed_addr = 0xFFFFFFFF;\r
- } else {\r
-\r
- packed_addr = inet_addr(ip_addr);\r
-\r
- if (packed_addr == INADDR_NONE) { /* invalid address */\r
- PyErr_SetString(socket_error,\r
- "illegal IP address string passed to inet_aton");\r
- return NULL;\r
- }\r
- }\r
- return PyString_FromStringAndSize((char *) &packed_addr,\r
- sizeof(packed_addr));\r
-\r
-#ifdef USE_INET_ATON_WEAKLINK\r
- }\r
-#endif\r
-\r
-#endif\r
-}\r
-\r
-PyDoc_STRVAR(inet_ntoa_doc,\r
-"inet_ntoa(packed_ip) -> ip_address_string\n\\r
-\n\\r
-Convert an IP address from 32-bit packed binary format to string format");\r
-\r
-static PyObject*\r
-socket_inet_ntoa(PyObject *self, PyObject *args)\r
-{\r
- char *packed_str;\r
- int addr_len;\r
- struct in_addr packed_addr;\r
-\r
- if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {\r
- return NULL;\r
- }\r
-\r
- if (addr_len != sizeof(packed_addr)) {\r
- PyErr_SetString(socket_error,\r
- "packed IP wrong length for inet_ntoa");\r
- return NULL;\r
- }\r
-\r
- memcpy(&packed_addr, packed_str, addr_len);\r
-\r
- return PyString_FromString(inet_ntoa(packed_addr));\r
-}\r
-\r
-#ifdef HAVE_INET_PTON\r
-\r
-PyDoc_STRVAR(inet_pton_doc,\r
-"inet_pton(af, ip) -> packed IP address string\n\\r
-\n\\r
-Convert an IP address from string format to a packed string suitable\n\\r
-for use with low-level network functions.");\r
-\r
-static PyObject *\r
-socket_inet_pton(PyObject *self, PyObject *args)\r
-{\r
- int af;\r
- char* ip;\r
- int retval;\r
-#ifdef ENABLE_IPV6\r
- char packed[MAX(sizeof(struct in_addr), sizeof(struct in6_addr))];\r
-#else\r
- char packed[sizeof(struct in_addr)];\r
-#endif\r
- if (!PyArg_ParseTuple(args, "is:inet_pton", &af, &ip)) {\r
- return NULL;\r
- }\r
-\r
-#if !defined(ENABLE_IPV6) && defined(AF_INET6)\r
- if(af == AF_INET6) {\r
- PyErr_SetString(socket_error,\r
- "can't use AF_INET6, IPv6 is disabled");\r
- return NULL;\r
- }\r
-#endif\r
-\r
- retval = inet_pton(af, ip, packed);\r
- if (retval < 0) {\r
- PyErr_SetFromErrno(socket_error);\r
- return NULL;\r
- } else if (retval == 0) {\r
- PyErr_SetString(socket_error,\r
- "illegal IP address string passed to inet_pton");\r
- return NULL;\r
- } else if (af == AF_INET) {\r
- return PyString_FromStringAndSize(packed,\r
- sizeof(struct in_addr));\r
-#ifdef ENABLE_IPV6\r
- } else if (af == AF_INET6) {\r
- return PyString_FromStringAndSize(packed,\r
- sizeof(struct in6_addr));\r
-#endif\r
- } else {\r
- PyErr_SetString(socket_error, "unknown address family");\r
- return NULL;\r
- }\r
-}\r
-\r
-PyDoc_STRVAR(inet_ntop_doc,\r
-"inet_ntop(af, packed_ip) -> string formatted IP address\n\\r
-\n\\r
-Convert a packed IP address of the given family to string format.");\r
-\r
-static PyObject *\r
-socket_inet_ntop(PyObject *self, PyObject *args)\r
-{\r
- int af;\r
- char* packed;\r
- int len;\r
- const char* retval;\r
-#ifdef ENABLE_IPV6\r
- char ip[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN) + 1];\r
-#else\r
- char ip[INET_ADDRSTRLEN + 1];\r
-#endif\r
-\r
- /* Guarantee NUL-termination for PyString_FromString() below */\r
- memset((void *) &ip[0], '\0', sizeof(ip));\r
-\r
- if (!PyArg_ParseTuple(args, "is#:inet_ntop", &af, &packed, &len)) {\r
- return NULL;\r
- }\r
-\r
- if (af == AF_INET) {\r
- if (len != sizeof(struct in_addr)) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "invalid length of packed IP address string");\r
- return NULL;\r
- }\r
-#ifdef ENABLE_IPV6\r
- } else if (af == AF_INET6) {\r
- if (len != sizeof(struct in6_addr)) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "invalid length of packed IP address string");\r
- return NULL;\r
- }\r
-#endif\r
- } else {\r
- PyErr_Format(PyExc_ValueError,\r
- "unknown address family %d", af);\r
- return NULL;\r
- }\r
-\r
- retval = inet_ntop(af, packed, ip, sizeof(ip));\r
- if (!retval) {\r
- PyErr_SetFromErrno(socket_error);\r
- return NULL;\r
- } else {\r
- return PyString_FromString(retval);\r
- }\r
-\r
- /* NOTREACHED */\r
- PyErr_SetString(PyExc_RuntimeError, "invalid handling of inet_ntop");\r
- return NULL;\r
-}\r
-\r
-#endif /* HAVE_INET_PTON */\r
-\r
-/* Python interface to getaddrinfo(host, port). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_getaddrinfo(PyObject *self, PyObject *args)\r
-{\r
- struct addrinfo hints, *res;\r
- struct addrinfo *res0 = NULL;\r
- PyObject *hobj = NULL;\r
- PyObject *pobj = (PyObject *)NULL;\r
- char pbuf[30];\r
- char *hptr, *pptr;\r
- int family, socktype, protocol, flags;\r
- int error;\r
- PyObject *all = (PyObject *)NULL;\r
- PyObject *single = (PyObject *)NULL;\r
- PyObject *idna = NULL;\r
-\r
- family = socktype = protocol = flags = 0;\r
- family = AF_UNSPEC;\r
- if (!PyArg_ParseTuple(args, "OO|iiii:getaddrinfo",\r
- &hobj, &pobj, &family, &socktype,\r
- &protocol, &flags)) {\r
- return NULL;\r
- }\r
- if (hobj == Py_None) {\r
- hptr = NULL;\r
- } else if (PyUnicode_Check(hobj)) {\r
- idna = PyObject_CallMethod(hobj, "encode", "s", "idna");\r
- if (!idna)\r
- return NULL;\r
- hptr = PyString_AsString(idna);\r
- } else if (PyString_Check(hobj)) {\r
- hptr = PyString_AsString(hobj);\r
- } else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "getaddrinfo() argument 1 must be string or None");\r
- return NULL;\r
- }\r
- if (PyInt_Check(pobj) || PyLong_Check(pobj)) {\r
- long value = PyLong_AsLong(pobj);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", value);\r
- pptr = pbuf;\r
- } else if (PyString_Check(pobj)) {\r
- pptr = PyString_AsString(pobj);\r
- } else if (pobj == Py_None) {\r
- pptr = (char *)NULL;\r
- } else {\r
- PyErr_SetString(socket_error,\r
- "getaddrinfo() argument 2 must be integer or string");\r
- goto err;\r
- }\r
-#if defined(__APPLE__) && defined(AI_NUMERICSERV)\r
- if ((flags & AI_NUMERICSERV) && (pptr == NULL || (pptr[0] == '0' && pptr[1] == 0))) {\r
- /* On OSX upto at least OSX 10.8 getaddrinfo crashes\r
- * if AI_NUMERICSERV is set and the servname is NULL or "0".\r
- * This workaround avoids a segfault in libsystem.\r
- */\r
- pptr = "00";\r
- }\r
-#endif\r
- memset(&hints, 0, sizeof(hints));\r
- hints.ai_family = family;\r
- hints.ai_socktype = socktype;\r
- hints.ai_protocol = protocol;\r
- hints.ai_flags = flags;\r
- Py_BEGIN_ALLOW_THREADS\r
- ACQUIRE_GETADDRINFO_LOCK\r
- error = getaddrinfo(hptr, pptr, &hints, &res0);\r
- Py_END_ALLOW_THREADS\r
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */\r
- if (error) {\r
- set_gaierror(error);\r
- goto err;\r
- }\r
-\r
- all = PyList_New(0);\r
- if (all == NULL)\r
- goto err;\r
- for (res = res0; res; res = res->ai_next) {\r
- PyObject *addr =\r
- makesockaddr(-1, res->ai_addr, res->ai_addrlen, protocol);\r
- if (addr == NULL)\r
- goto err;\r
- single = Py_BuildValue("iiisO", res->ai_family,\r
- res->ai_socktype, res->ai_protocol,\r
- res->ai_canonname ? res->ai_canonname : "",\r
- addr);\r
- Py_DECREF(addr);\r
- if (single == NULL)\r
- goto err;\r
-\r
- if (PyList_Append(all, single))\r
- goto err;\r
- Py_XDECREF(single);\r
- }\r
- Py_XDECREF(idna);\r
- if (res0)\r
- freeaddrinfo(res0);\r
- return all;\r
- err:\r
- Py_XDECREF(single);\r
- Py_XDECREF(all);\r
- Py_XDECREF(idna);\r
- if (res0)\r
- freeaddrinfo(res0);\r
- return (PyObject *)NULL;\r
-}\r
-\r
-PyDoc_STRVAR(getaddrinfo_doc,\r
-"getaddrinfo(host, port [, family, socktype, proto, flags])\n\\r
- -> list of (family, socktype, proto, canonname, sockaddr)\n\\r
-\n\\r
-Resolve host and port into addrinfo struct.");\r
-\r
-/* Python interface to getnameinfo(sa, flags). */\r
-\r
-/*ARGSUSED*/\r
-static PyObject *\r
-socket_getnameinfo(PyObject *self, PyObject *args)\r
-{\r
- PyObject *sa = (PyObject *)NULL;\r
- int flags;\r
- char *hostp;\r
- int port;\r
- unsigned int flowinfo, scope_id;\r
- char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];\r
- struct addrinfo hints, *res = NULL;\r
- int error;\r
- PyObject *ret = (PyObject *)NULL;\r
-\r
- flags = flowinfo = scope_id = 0;\r
- if (!PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags))\r
- return NULL;\r
- if (!PyTuple_Check(sa)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "getnameinfo() argument 1 must be a tuple");\r
- return NULL;\r
- }\r
- if (!PyArg_ParseTuple(sa, "si|II",\r
- &hostp, &port, &flowinfo, &scope_id))\r
- return NULL;\r
- if (flowinfo > 0xfffff) {\r
- PyErr_SetString(PyExc_OverflowError,\r
- "getsockaddrarg: flowinfo must be 0-1048575.");\r
- return NULL;\r
- }\r
- PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);\r
- memset(&hints, 0, sizeof(hints));\r
- hints.ai_family = AF_UNSPEC;\r
- hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */\r
- Py_BEGIN_ALLOW_THREADS\r
- ACQUIRE_GETADDRINFO_LOCK\r
- error = getaddrinfo(hostp, pbuf, &hints, &res);\r
- Py_END_ALLOW_THREADS\r
- RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */\r
- if (error) {\r
- set_gaierror(error);\r
- goto fail;\r
- }\r
- if (res->ai_next) {\r
- PyErr_SetString(socket_error,\r
- "sockaddr resolved to multiple addresses");\r
- goto fail;\r
- }\r
- switch (res->ai_family) {\r
- case AF_INET:\r
- {\r
- if (PyTuple_GET_SIZE(sa) != 2) {\r
- PyErr_SetString(socket_error,\r
- "IPv4 sockaddr must be 2 tuple");\r
- goto fail;\r
- }\r
- break;\r
- }\r
-#ifdef ENABLE_IPV6\r
- case AF_INET6:\r
- {\r
- struct sockaddr_in6 *sin6;\r
- sin6 = (struct sockaddr_in6 *)res->ai_addr;\r
- sin6->sin6_flowinfo = htonl(flowinfo);\r
- sin6->sin6_scope_id = scope_id;\r
- break;\r
- }\r
-#endif\r
- }\r
- error = getnameinfo(res->ai_addr, res->ai_addrlen,\r
- hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);\r
- if (error) {\r
- set_gaierror(error);\r
- goto fail;\r
- }\r
- ret = Py_BuildValue("ss", hbuf, pbuf);\r
-\r
-fail:\r
- if (res)\r
- freeaddrinfo(res);\r
- return ret;\r
-}\r
-\r
-PyDoc_STRVAR(getnameinfo_doc,\r
-"getnameinfo(sockaddr, flags) --> (host, port)\n\\r
-\n\\r
-Get host and port for a sockaddr.");\r
-\r
-\r
-/* Python API to getting and setting the default timeout value. */\r
-\r
-static PyObject *\r
-socket_getdefaulttimeout(PyObject *self)\r
-{\r
- if (defaulttimeout < 0.0) {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- else\r
- return PyFloat_FromDouble(defaulttimeout);\r
-}\r
-\r
-PyDoc_STRVAR(getdefaulttimeout_doc,\r
-"getdefaulttimeout() -> timeout\n\\r
-\n\\r
-Returns the default timeout in seconds (float) for new socket objects.\n\\r
-A value of None indicates that new socket objects have no timeout.\n\\r
-When the socket module is first imported, the default is None.");\r
-\r
-static PyObject *\r
-socket_setdefaulttimeout(PyObject *self, PyObject *arg)\r
-{\r
- double timeout;\r
-\r
- if (arg == Py_None)\r
- timeout = -1.0;\r
- else {\r
- timeout = PyFloat_AsDouble(arg);\r
- if (timeout < 0.0) {\r
- if (!PyErr_Occurred())\r
- PyErr_SetString(PyExc_ValueError,\r
- "Timeout value out of range");\r
- return NULL;\r
- }\r
- }\r
-\r
- defaulttimeout = timeout;\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(setdefaulttimeout_doc,\r
-"setdefaulttimeout(timeout)\n\\r
-\n\\r
-Set the default timeout in seconds (float) for new socket objects.\n\\r
-A value of None indicates that new socket objects have no timeout.\n\\r
-When the socket module is first imported, the default is None.");\r
-\r
-\r
-/* List of functions exported by this module. */\r
-\r
-static PyMethodDef socket_methods[] = {\r
- {"gethostbyname", socket_gethostbyname,\r
- METH_VARARGS, gethostbyname_doc},\r
- {"gethostbyname_ex", socket_gethostbyname_ex,\r
- METH_VARARGS, ghbn_ex_doc},\r
- {"gethostbyaddr", socket_gethostbyaddr,\r
- METH_VARARGS, gethostbyaddr_doc},\r
- {"gethostname", socket_gethostname,\r
- METH_NOARGS, gethostname_doc},\r
- {"getservbyname", socket_getservbyname,\r
- METH_VARARGS, getservbyname_doc},\r
- {"getservbyport", socket_getservbyport,\r
- METH_VARARGS, getservbyport_doc},\r
- {"getprotobyname", socket_getprotobyname,\r
- METH_VARARGS, getprotobyname_doc},\r
-#ifndef NO_DUP\r
- {"fromfd", socket_fromfd,\r
- METH_VARARGS, fromfd_doc},\r
-#endif\r
-#ifdef HAVE_SOCKETPAIR\r
- {"socketpair", socket_socketpair,\r
- METH_VARARGS, socketpair_doc},\r
-#endif\r
- {"ntohs", socket_ntohs,\r
- METH_VARARGS, ntohs_doc},\r
- {"ntohl", socket_ntohl,\r
- METH_O, ntohl_doc},\r
- {"htons", socket_htons,\r
- METH_VARARGS, htons_doc},\r
- {"htonl", socket_htonl,\r
- METH_O, htonl_doc},\r
- {"inet_aton", socket_inet_aton,\r
- METH_VARARGS, inet_aton_doc},\r
- {"inet_ntoa", socket_inet_ntoa,\r
- METH_VARARGS, inet_ntoa_doc},\r
-#ifdef HAVE_INET_PTON\r
- {"inet_pton", socket_inet_pton,\r
- METH_VARARGS, inet_pton_doc},\r
- {"inet_ntop", socket_inet_ntop,\r
- METH_VARARGS, inet_ntop_doc},\r
-#endif\r
- {"getaddrinfo", socket_getaddrinfo,\r
- METH_VARARGS, getaddrinfo_doc},\r
- {"getnameinfo", socket_getnameinfo,\r
- METH_VARARGS, getnameinfo_doc},\r
- {"getdefaulttimeout", (PyCFunction)socket_getdefaulttimeout,\r
- METH_NOARGS, getdefaulttimeout_doc},\r
- {"setdefaulttimeout", socket_setdefaulttimeout,\r
- METH_O, setdefaulttimeout_doc},\r
- {NULL, NULL} /* Sentinel */\r
-};\r
-\r
-\r
-#ifdef RISCOS\r
-#define OS_INIT_DEFINED\r
-\r
-static int\r
-os_init(void)\r
-{\r
- _kernel_swi_regs r;\r
-\r
- r.r[0] = 0;\r
- _kernel_swi(0x43380, &r, &r);\r
- taskwindow = r.r[0];\r
-\r
- return 1;\r
-}\r
-\r
-#endif /* RISCOS */\r
-\r
-\r
-#ifdef MS_WINDOWS\r
-#define OS_INIT_DEFINED\r
-\r
-/* Additional initialization and cleanup for Windows */\r
-\r
-static void\r
-os_cleanup(void)\r
-{\r
- WSACleanup();\r
-}\r
-\r
-static int\r
-os_init(void)\r
-{\r
- WSADATA WSAData;\r
- int ret;\r
- char buf[100];\r
- ret = WSAStartup(0x0101, &WSAData);\r
- switch (ret) {\r
- case 0: /* No error */\r
- Py_AtExit(os_cleanup);\r
- return 1; /* Success */\r
- case WSASYSNOTREADY:\r
- PyErr_SetString(PyExc_ImportError,\r
- "WSAStartup failed: network not ready");\r
- break;\r
- case WSAVERNOTSUPPORTED:\r
- case WSAEINVAL:\r
- PyErr_SetString(\r
- PyExc_ImportError,\r
- "WSAStartup failed: requested version not supported");\r
- break;\r
- default:\r
- PyOS_snprintf(buf, sizeof(buf),\r
- "WSAStartup failed: error code %d", ret);\r
- PyErr_SetString(PyExc_ImportError, buf);\r
- break;\r
- }\r
- return 0; /* Failure */\r
-}\r
-\r
-#endif /* MS_WINDOWS */\r
-\r
-\r
-#ifdef PYOS_OS2\r
-#define OS_INIT_DEFINED\r
-\r
-/* Additional initialization for OS/2 */\r
-\r
-static int\r
-os_init(void)\r
-{\r
-#ifndef PYCC_GCC\r
- char reason[64];\r
- int rc = sock_init();\r
-\r
- if (rc == 0) {\r
- return 1; /* Success */\r
- }\r
-\r
- PyOS_snprintf(reason, sizeof(reason),\r
- "OS/2 TCP/IP Error# %d", sock_errno());\r
- PyErr_SetString(PyExc_ImportError, reason);\r
-\r
- return 0; /* Failure */\r
-#else\r
- /* No need to initialize sockets with GCC/EMX */\r
- return 1; /* Success */\r
-#endif\r
-}\r
-\r
-#endif /* PYOS_OS2 */\r
-\r
-\r
-#ifndef OS_INIT_DEFINED\r
-static int\r
-os_init(void)\r
-{\r
- return 1; /* Success */\r
-}\r
-#endif\r
-\r
-\r
-/* C API table - always add new things to the end for binary\r
- compatibility. */\r
-static\r
-PySocketModule_APIObject PySocketModuleAPI =\r
-{\r
- &sock_type,\r
- NULL\r
-};\r
-\r
-\r
-/* Initialize the _socket module.\r
-\r
- This module is actually called "_socket", and there's a wrapper\r
- "socket.py" which implements some additional functionality. On some\r
- platforms (e.g. Windows and OS/2), socket.py also implements a\r
- wrapper for the socket type that provides missing functionality such\r
- as makefile(), dup() and fromfd(). The import of "_socket" may fail\r
- with an ImportError exception if os-specific initialization fails.\r
- On Windows, this does WINSOCK initialization. When WINSOCK is\r
- initialized successfully, a call to WSACleanup() is scheduled to be\r
- made at exit time.\r
-*/\r
-\r
-PyDoc_STRVAR(socket_doc,\r
-"Implementation module for socket operations.\n\\r
-\n\\r
-See the socket module for documentation.");\r
-\r
-PyMODINIT_FUNC\r
-init_socket(void)\r
-{\r
- PyObject *m, *has_ipv6;\r
-\r
- if (!os_init())\r
- return;\r
-\r
- Py_TYPE(&sock_type) = &PyType_Type;\r
- m = Py_InitModule3(PySocket_MODULE_NAME,\r
- socket_methods,\r
- socket_doc);\r
- if (m == NULL)\r
- return;\r
-\r
- socket_error = PyErr_NewException("socket.error",\r
- PyExc_IOError, NULL);\r
- if (socket_error == NULL)\r
- return;\r
- PySocketModuleAPI.error = socket_error;\r
- Py_INCREF(socket_error);\r
- PyModule_AddObject(m, "error", socket_error);\r
- socket_herror = PyErr_NewException("socket.herror",\r
- socket_error, NULL);\r
- if (socket_herror == NULL)\r
- return;\r
- Py_INCREF(socket_herror);\r
- PyModule_AddObject(m, "herror", socket_herror);\r
- socket_gaierror = PyErr_NewException("socket.gaierror", socket_error,\r
- NULL);\r
- if (socket_gaierror == NULL)\r
- return;\r
- Py_INCREF(socket_gaierror);\r
- PyModule_AddObject(m, "gaierror", socket_gaierror);\r
- socket_timeout = PyErr_NewException("socket.timeout",\r
- socket_error, NULL);\r
- if (socket_timeout == NULL)\r
- return;\r
- Py_INCREF(socket_timeout);\r
- PyModule_AddObject(m, "timeout", socket_timeout);\r
- Py_INCREF((PyObject *)&sock_type);\r
- if (PyModule_AddObject(m, "SocketType",\r
- (PyObject *)&sock_type) != 0)\r
- return;\r
- Py_INCREF((PyObject *)&sock_type);\r
- if (PyModule_AddObject(m, "socket",\r
- (PyObject *)&sock_type) != 0)\r
- return;\r
-\r
-#ifdef ENABLE_IPV6\r
- has_ipv6 = Py_True;\r
-#else\r
- has_ipv6 = Py_False;\r
-#endif\r
- Py_INCREF(has_ipv6);\r
- PyModule_AddObject(m, "has_ipv6", has_ipv6);\r
-\r
- /* Export C API */\r
- if (PyModule_AddObject(m, PySocket_CAPI_NAME,\r
- PyCapsule_New(&PySocketModuleAPI, PySocket_CAPSULE_NAME, NULL)\r
- ) != 0)\r
- return;\r
-\r
- /* Address families (we only support AF_INET and AF_UNIX) */\r
-#ifdef AF_UNSPEC\r
- PyModule_AddIntConstant(m, "AF_UNSPEC", AF_UNSPEC);\r
-#endif\r
- PyModule_AddIntConstant(m, "AF_INET", AF_INET);\r
-#ifdef AF_INET6\r
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6);\r
-#endif /* AF_INET6 */\r
-#if defined(AF_UNIX)\r
- PyModule_AddIntConstant(m, "AF_UNIX", AF_UNIX);\r
-#endif /* AF_UNIX */\r
-#ifdef AF_AX25\r
- /* Amateur Radio AX.25 */\r
- PyModule_AddIntConstant(m, "AF_AX25", AF_AX25);\r
-#endif\r
-#ifdef AF_IPX\r
- PyModule_AddIntConstant(m, "AF_IPX", AF_IPX); /* Novell IPX */\r
-#endif\r
-#ifdef AF_APPLETALK\r
- /* Appletalk DDP */\r
- PyModule_AddIntConstant(m, "AF_APPLETALK", AF_APPLETALK);\r
-#endif\r
-#ifdef AF_NETROM\r
- /* Amateur radio NetROM */\r
- PyModule_AddIntConstant(m, "AF_NETROM", AF_NETROM);\r
-#endif\r
-#ifdef AF_BRIDGE\r
- /* Multiprotocol bridge */\r
- PyModule_AddIntConstant(m, "AF_BRIDGE", AF_BRIDGE);\r
-#endif\r
-#ifdef AF_ATMPVC\r
- /* ATM PVCs */\r
- PyModule_AddIntConstant(m, "AF_ATMPVC", AF_ATMPVC);\r
-#endif\r
-#ifdef AF_AAL5\r
- /* Reserved for Werner's ATM */\r
- PyModule_AddIntConstant(m, "AF_AAL5", AF_AAL5);\r
-#endif\r
-#ifdef AF_X25\r
- /* Reserved for X.25 project */\r
- PyModule_AddIntConstant(m, "AF_X25", AF_X25);\r
-#endif\r
-#ifdef AF_INET6\r
- PyModule_AddIntConstant(m, "AF_INET6", AF_INET6); /* IP version 6 */\r
-#endif\r
-#ifdef AF_ROSE\r
- /* Amateur Radio X.25 PLP */\r
- PyModule_AddIntConstant(m, "AF_ROSE", AF_ROSE);\r
-#endif\r
-#ifdef AF_DECnet\r
- /* Reserved for DECnet project */\r
- PyModule_AddIntConstant(m, "AF_DECnet", AF_DECnet);\r
-#endif\r
-#ifdef AF_NETBEUI\r
- /* Reserved for 802.2LLC project */\r
- PyModule_AddIntConstant(m, "AF_NETBEUI", AF_NETBEUI);\r
-#endif\r
-#ifdef AF_SECURITY\r
- /* Security callback pseudo AF */\r
- PyModule_AddIntConstant(m, "AF_SECURITY", AF_SECURITY);\r
-#endif\r
-#ifdef AF_KEY\r
- /* PF_KEY key management API */\r
- PyModule_AddIntConstant(m, "AF_KEY", AF_KEY);\r
-#endif\r
-#ifdef AF_NETLINK\r
- /* */\r
- PyModule_AddIntConstant(m, "AF_NETLINK", AF_NETLINK);\r
- PyModule_AddIntConstant(m, "NETLINK_ROUTE", NETLINK_ROUTE);\r
-#ifdef NETLINK_SKIP\r
- PyModule_AddIntConstant(m, "NETLINK_SKIP", NETLINK_SKIP);\r
-#endif\r
-#ifdef NETLINK_W1\r
- PyModule_AddIntConstant(m, "NETLINK_W1", NETLINK_W1);\r
-#endif\r
- PyModule_AddIntConstant(m, "NETLINK_USERSOCK", NETLINK_USERSOCK);\r
- PyModule_AddIntConstant(m, "NETLINK_FIREWALL", NETLINK_FIREWALL);\r
-#ifdef NETLINK_TCPDIAG\r
- PyModule_AddIntConstant(m, "NETLINK_TCPDIAG", NETLINK_TCPDIAG);\r
-#endif\r
-#ifdef NETLINK_NFLOG\r
- PyModule_AddIntConstant(m, "NETLINK_NFLOG", NETLINK_NFLOG);\r
-#endif\r
-#ifdef NETLINK_XFRM\r
- PyModule_AddIntConstant(m, "NETLINK_XFRM", NETLINK_XFRM);\r
-#endif\r
-#ifdef NETLINK_ARPD\r
- PyModule_AddIntConstant(m, "NETLINK_ARPD", NETLINK_ARPD);\r
-#endif\r
-#ifdef NETLINK_ROUTE6\r
- PyModule_AddIntConstant(m, "NETLINK_ROUTE6", NETLINK_ROUTE6);\r
-#endif\r
- PyModule_AddIntConstant(m, "NETLINK_IP6_FW", NETLINK_IP6_FW);\r
-#ifdef NETLINK_DNRTMSG\r
- PyModule_AddIntConstant(m, "NETLINK_DNRTMSG", NETLINK_DNRTMSG);\r
-#endif\r
-#ifdef NETLINK_TAPBASE\r
- PyModule_AddIntConstant(m, "NETLINK_TAPBASE", NETLINK_TAPBASE);\r
-#endif\r
-#endif /* AF_NETLINK */\r
-#ifdef AF_ROUTE\r
- /* Alias to emulate 4.4BSD */\r
- PyModule_AddIntConstant(m, "AF_ROUTE", AF_ROUTE);\r
-#endif\r
-#ifdef AF_ASH\r
- /* Ash */\r
- PyModule_AddIntConstant(m, "AF_ASH", AF_ASH);\r
-#endif\r
-#ifdef AF_ECONET\r
- /* Acorn Econet */\r
- PyModule_AddIntConstant(m, "AF_ECONET", AF_ECONET);\r
-#endif\r
-#ifdef AF_ATMSVC\r
- /* ATM SVCs */\r
- PyModule_AddIntConstant(m, "AF_ATMSVC", AF_ATMSVC);\r
-#endif\r
-#ifdef AF_SNA\r
- /* Linux SNA Project (nutters!) */\r
- PyModule_AddIntConstant(m, "AF_SNA", AF_SNA);\r
-#endif\r
-#ifdef AF_IRDA\r
- /* IRDA sockets */\r
- PyModule_AddIntConstant(m, "AF_IRDA", AF_IRDA);\r
-#endif\r
-#ifdef AF_PPPOX\r
- /* PPPoX sockets */\r
- PyModule_AddIntConstant(m, "AF_PPPOX", AF_PPPOX);\r
-#endif\r
-#ifdef AF_WANPIPE\r
- /* Wanpipe API Sockets */\r
- PyModule_AddIntConstant(m, "AF_WANPIPE", AF_WANPIPE);\r
-#endif\r
-#ifdef AF_LLC\r
- /* Linux LLC */\r
- PyModule_AddIntConstant(m, "AF_LLC", AF_LLC);\r
-#endif\r
-\r
-#ifdef USE_BLUETOOTH\r
- PyModule_AddIntConstant(m, "AF_BLUETOOTH", AF_BLUETOOTH);\r
- PyModule_AddIntConstant(m, "BTPROTO_L2CAP", BTPROTO_L2CAP);\r
- PyModule_AddIntConstant(m, "BTPROTO_HCI", BTPROTO_HCI);\r
- PyModule_AddIntConstant(m, "SOL_HCI", SOL_HCI);\r
-#if !defined(__NetBSD__) && !defined(__DragonFly__)\r
- PyModule_AddIntConstant(m, "HCI_FILTER", HCI_FILTER);\r
-#endif\r
-#if !defined(__FreeBSD__)\r
-#if !defined(__NetBSD__) && !defined(__DragonFly__)\r
- PyModule_AddIntConstant(m, "HCI_TIME_STAMP", HCI_TIME_STAMP);\r
-#endif\r
- PyModule_AddIntConstant(m, "HCI_DATA_DIR", HCI_DATA_DIR);\r
- PyModule_AddIntConstant(m, "BTPROTO_SCO", BTPROTO_SCO);\r
-#endif\r
- PyModule_AddIntConstant(m, "BTPROTO_RFCOMM", BTPROTO_RFCOMM);\r
- PyModule_AddStringConstant(m, "BDADDR_ANY", "00:00:00:00:00:00");\r
- PyModule_AddStringConstant(m, "BDADDR_LOCAL", "00:00:00:FF:FF:FF");\r
-#endif\r
-\r
-#ifdef AF_PACKET\r
- PyModule_AddIntMacro(m, AF_PACKET);\r
-#endif\r
-#ifdef PF_PACKET\r
- PyModule_AddIntMacro(m, PF_PACKET);\r
-#endif\r
-#ifdef PACKET_HOST\r
- PyModule_AddIntMacro(m, PACKET_HOST);\r
-#endif\r
-#ifdef PACKET_BROADCAST\r
- PyModule_AddIntMacro(m, PACKET_BROADCAST);\r
-#endif\r
-#ifdef PACKET_MULTICAST\r
- PyModule_AddIntMacro(m, PACKET_MULTICAST);\r
-#endif\r
-#ifdef PACKET_OTHERHOST\r
- PyModule_AddIntMacro(m, PACKET_OTHERHOST);\r
-#endif\r
-#ifdef PACKET_OUTGOING\r
- PyModule_AddIntMacro(m, PACKET_OUTGOING);\r
-#endif\r
-#ifdef PACKET_LOOPBACK\r
- PyModule_AddIntMacro(m, PACKET_LOOPBACK);\r
-#endif\r
-#ifdef PACKET_FASTROUTE\r
- PyModule_AddIntMacro(m, PACKET_FASTROUTE);\r
-#endif\r
-\r
-#ifdef HAVE_LINUX_TIPC_H\r
- PyModule_AddIntConstant(m, "AF_TIPC", AF_TIPC);\r
-\r
- /* for addresses */\r
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAMESEQ", TIPC_ADDR_NAMESEQ);\r
- PyModule_AddIntConstant(m, "TIPC_ADDR_NAME", TIPC_ADDR_NAME);\r
- PyModule_AddIntConstant(m, "TIPC_ADDR_ID", TIPC_ADDR_ID);\r
-\r
- PyModule_AddIntConstant(m, "TIPC_ZONE_SCOPE", TIPC_ZONE_SCOPE);\r
- PyModule_AddIntConstant(m, "TIPC_CLUSTER_SCOPE", TIPC_CLUSTER_SCOPE);\r
- PyModule_AddIntConstant(m, "TIPC_NODE_SCOPE", TIPC_NODE_SCOPE);\r
-\r
- /* for setsockopt() */\r
- PyModule_AddIntConstant(m, "SOL_TIPC", SOL_TIPC);\r
- PyModule_AddIntConstant(m, "TIPC_IMPORTANCE", TIPC_IMPORTANCE);\r
- PyModule_AddIntConstant(m, "TIPC_SRC_DROPPABLE", TIPC_SRC_DROPPABLE);\r
- PyModule_AddIntConstant(m, "TIPC_DEST_DROPPABLE",\r
- TIPC_DEST_DROPPABLE);\r
- PyModule_AddIntConstant(m, "TIPC_CONN_TIMEOUT", TIPC_CONN_TIMEOUT);\r
-\r
- PyModule_AddIntConstant(m, "TIPC_LOW_IMPORTANCE",\r
- TIPC_LOW_IMPORTANCE);\r
- PyModule_AddIntConstant(m, "TIPC_MEDIUM_IMPORTANCE",\r
- TIPC_MEDIUM_IMPORTANCE);\r
- PyModule_AddIntConstant(m, "TIPC_HIGH_IMPORTANCE",\r
- TIPC_HIGH_IMPORTANCE);\r
- PyModule_AddIntConstant(m, "TIPC_CRITICAL_IMPORTANCE",\r
- TIPC_CRITICAL_IMPORTANCE);\r
-\r
- /* for subscriptions */\r
- PyModule_AddIntConstant(m, "TIPC_SUB_PORTS", TIPC_SUB_PORTS);\r
- PyModule_AddIntConstant(m, "TIPC_SUB_SERVICE", TIPC_SUB_SERVICE);\r
-#ifdef TIPC_SUB_CANCEL\r
- /* doesn't seem to be available everywhere */\r
- PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL);\r
-#endif\r
- PyModule_AddIntConstant(m, "TIPC_WAIT_FOREVER", TIPC_WAIT_FOREVER);\r
- PyModule_AddIntConstant(m, "TIPC_PUBLISHED", TIPC_PUBLISHED);\r
- PyModule_AddIntConstant(m, "TIPC_WITHDRAWN", TIPC_WITHDRAWN);\r
- PyModule_AddIntConstant(m, "TIPC_SUBSCR_TIMEOUT", TIPC_SUBSCR_TIMEOUT);\r
- PyModule_AddIntConstant(m, "TIPC_CFG_SRV", TIPC_CFG_SRV);\r
- PyModule_AddIntConstant(m, "TIPC_TOP_SRV", TIPC_TOP_SRV);\r
-#endif\r
-\r
- /* Socket types */\r
- PyModule_AddIntConstant(m, "SOCK_STREAM", SOCK_STREAM);\r
- PyModule_AddIntConstant(m, "SOCK_DGRAM", SOCK_DGRAM);\r
-#ifndef __BEOS__\r
-/* We have incomplete socket support. */\r
- PyModule_AddIntConstant(m, "SOCK_RAW", SOCK_RAW);\r
- PyModule_AddIntConstant(m, "SOCK_SEQPACKET", SOCK_SEQPACKET);\r
-#if defined(SOCK_RDM)\r
- PyModule_AddIntConstant(m, "SOCK_RDM", SOCK_RDM);\r
-#endif\r
-#endif\r
-\r
-#ifdef SO_DEBUG\r
- PyModule_AddIntConstant(m, "SO_DEBUG", SO_DEBUG);\r
-#endif\r
-#ifdef SO_ACCEPTCONN\r
- PyModule_AddIntConstant(m, "SO_ACCEPTCONN", SO_ACCEPTCONN);\r
-#endif\r
-#ifdef SO_REUSEADDR\r
- PyModule_AddIntConstant(m, "SO_REUSEADDR", SO_REUSEADDR);\r
-#endif\r
-#ifdef SO_EXCLUSIVEADDRUSE\r
- PyModule_AddIntConstant(m, "SO_EXCLUSIVEADDRUSE", SO_EXCLUSIVEADDRUSE);\r
-#endif\r
-\r
-#ifdef SO_KEEPALIVE\r
- PyModule_AddIntConstant(m, "SO_KEEPALIVE", SO_KEEPALIVE);\r
-#endif\r
-#ifdef SO_DONTROUTE\r
- PyModule_AddIntConstant(m, "SO_DONTROUTE", SO_DONTROUTE);\r
-#endif\r
-#ifdef SO_BROADCAST\r
- PyModule_AddIntConstant(m, "SO_BROADCAST", SO_BROADCAST);\r
-#endif\r
-#ifdef SO_USELOOPBACK\r
- PyModule_AddIntConstant(m, "SO_USELOOPBACK", SO_USELOOPBACK);\r
-#endif\r
-#ifdef SO_LINGER\r
- PyModule_AddIntConstant(m, "SO_LINGER", SO_LINGER);\r
-#endif\r
-#ifdef SO_OOBINLINE\r
- PyModule_AddIntConstant(m, "SO_OOBINLINE", SO_OOBINLINE);\r
-#endif\r
-#ifdef SO_REUSEPORT\r
- PyModule_AddIntConstant(m, "SO_REUSEPORT", SO_REUSEPORT);\r
-#endif\r
-#ifdef SO_SNDBUF\r
- PyModule_AddIntConstant(m, "SO_SNDBUF", SO_SNDBUF);\r
-#endif\r
-#ifdef SO_RCVBUF\r
- PyModule_AddIntConstant(m, "SO_RCVBUF", SO_RCVBUF);\r
-#endif\r
-#ifdef SO_SNDLOWAT\r
- PyModule_AddIntConstant(m, "SO_SNDLOWAT", SO_SNDLOWAT);\r
-#endif\r
-#ifdef SO_RCVLOWAT\r
- PyModule_AddIntConstant(m, "SO_RCVLOWAT", SO_RCVLOWAT);\r
-#endif\r
-#ifdef SO_SNDTIMEO\r
- PyModule_AddIntConstant(m, "SO_SNDTIMEO", SO_SNDTIMEO);\r
-#endif\r
-#ifdef SO_RCVTIMEO\r
- PyModule_AddIntConstant(m, "SO_RCVTIMEO", SO_RCVTIMEO);\r
-#endif\r
-#ifdef SO_ERROR\r
- PyModule_AddIntConstant(m, "SO_ERROR", SO_ERROR);\r
-#endif\r
-#ifdef SO_TYPE\r
- PyModule_AddIntConstant(m, "SO_TYPE", SO_TYPE);\r
-#endif\r
-#ifdef SO_SETFIB\r
- PyModule_AddIntConstant(m, "SO_SETFIB", SO_SETFIB);\r
-#endif\r
-\r
- /* Maximum number of connections for "listen" */\r
-#ifdef SOMAXCONN\r
- PyModule_AddIntConstant(m, "SOMAXCONN", SOMAXCONN);\r
-#else\r
- PyModule_AddIntConstant(m, "SOMAXCONN", 5); /* Common value */\r
-#endif\r
-\r
- /* Flags for send, recv */\r
-#ifdef MSG_OOB\r
- PyModule_AddIntConstant(m, "MSG_OOB", MSG_OOB);\r
-#endif\r
-#ifdef MSG_PEEK\r
- PyModule_AddIntConstant(m, "MSG_PEEK", MSG_PEEK);\r
-#endif\r
-#ifdef MSG_DONTROUTE\r
- PyModule_AddIntConstant(m, "MSG_DONTROUTE", MSG_DONTROUTE);\r
-#endif\r
-#ifdef MSG_DONTWAIT\r
- PyModule_AddIntConstant(m, "MSG_DONTWAIT", MSG_DONTWAIT);\r
-#endif\r
-#ifdef MSG_EOR\r
- PyModule_AddIntConstant(m, "MSG_EOR", MSG_EOR);\r
-#endif\r
-#ifdef MSG_TRUNC\r
- PyModule_AddIntConstant(m, "MSG_TRUNC", MSG_TRUNC);\r
-#endif\r
-#ifdef MSG_CTRUNC\r
- PyModule_AddIntConstant(m, "MSG_CTRUNC", MSG_CTRUNC);\r
-#endif\r
-#ifdef MSG_WAITALL\r
- PyModule_AddIntConstant(m, "MSG_WAITALL", MSG_WAITALL);\r
-#endif\r
-#ifdef MSG_BTAG\r
- PyModule_AddIntConstant(m, "MSG_BTAG", MSG_BTAG);\r
-#endif\r
-#ifdef MSG_ETAG\r
- PyModule_AddIntConstant(m, "MSG_ETAG", MSG_ETAG);\r
-#endif\r
-\r
- /* Protocol level and numbers, usable for [gs]etsockopt */\r
-#ifdef SOL_SOCKET\r
- PyModule_AddIntConstant(m, "SOL_SOCKET", SOL_SOCKET);\r
-#endif\r
-#ifdef SOL_IP\r
- PyModule_AddIntConstant(m, "SOL_IP", SOL_IP);\r
-#else\r
- PyModule_AddIntConstant(m, "SOL_IP", 0);\r
-#endif\r
-#ifdef SOL_IPX\r
- PyModule_AddIntConstant(m, "SOL_IPX", SOL_IPX);\r
-#endif\r
-#ifdef SOL_AX25\r
- PyModule_AddIntConstant(m, "SOL_AX25", SOL_AX25);\r
-#endif\r
-#ifdef SOL_ATALK\r
- PyModule_AddIntConstant(m, "SOL_ATALK", SOL_ATALK);\r
-#endif\r
-#ifdef SOL_NETROM\r
- PyModule_AddIntConstant(m, "SOL_NETROM", SOL_NETROM);\r
-#endif\r
-#ifdef SOL_ROSE\r
- PyModule_AddIntConstant(m, "SOL_ROSE", SOL_ROSE);\r
-#endif\r
-#ifdef SOL_TCP\r
- PyModule_AddIntConstant(m, "SOL_TCP", SOL_TCP);\r
-#else\r
- PyModule_AddIntConstant(m, "SOL_TCP", 6);\r
-#endif\r
-#ifdef SOL_UDP\r
- PyModule_AddIntConstant(m, "SOL_UDP", SOL_UDP);\r
-#else\r
- PyModule_AddIntConstant(m, "SOL_UDP", 17);\r
-#endif\r
-#ifdef IPPROTO_IP\r
- PyModule_AddIntConstant(m, "IPPROTO_IP", IPPROTO_IP);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPROTO_IP", 0);\r
-#endif\r
-#ifdef IPPROTO_HOPOPTS\r
- PyModule_AddIntConstant(m, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);\r
-#endif\r
-#ifdef IPPROTO_ICMP\r
- PyModule_AddIntConstant(m, "IPPROTO_ICMP", IPPROTO_ICMP);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPROTO_ICMP", 1);\r
-#endif\r
-#ifdef IPPROTO_IGMP\r
- PyModule_AddIntConstant(m, "IPPROTO_IGMP", IPPROTO_IGMP);\r
-#endif\r
-#ifdef IPPROTO_GGP\r
- PyModule_AddIntConstant(m, "IPPROTO_GGP", IPPROTO_GGP);\r
-#endif\r
-#ifdef IPPROTO_IPV4\r
- PyModule_AddIntConstant(m, "IPPROTO_IPV4", IPPROTO_IPV4);\r
-#endif\r
-#ifdef IPPROTO_IPV6\r
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);\r
-#endif\r
-#ifdef IPPROTO_IPIP\r
- PyModule_AddIntConstant(m, "IPPROTO_IPIP", IPPROTO_IPIP);\r
-#endif\r
-#ifdef IPPROTO_TCP\r
- PyModule_AddIntConstant(m, "IPPROTO_TCP", IPPROTO_TCP);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPROTO_TCP", 6);\r
-#endif\r
-#ifdef IPPROTO_EGP\r
- PyModule_AddIntConstant(m, "IPPROTO_EGP", IPPROTO_EGP);\r
-#endif\r
-#ifdef IPPROTO_PUP\r
- PyModule_AddIntConstant(m, "IPPROTO_PUP", IPPROTO_PUP);\r
-#endif\r
-#ifdef IPPROTO_UDP\r
- PyModule_AddIntConstant(m, "IPPROTO_UDP", IPPROTO_UDP);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPROTO_UDP", 17);\r
-#endif\r
-#ifdef IPPROTO_IDP\r
- PyModule_AddIntConstant(m, "IPPROTO_IDP", IPPROTO_IDP);\r
-#endif\r
-#ifdef IPPROTO_HELLO\r
- PyModule_AddIntConstant(m, "IPPROTO_HELLO", IPPROTO_HELLO);\r
-#endif\r
-#ifdef IPPROTO_ND\r
- PyModule_AddIntConstant(m, "IPPROTO_ND", IPPROTO_ND);\r
-#endif\r
-#ifdef IPPROTO_TP\r
- PyModule_AddIntConstant(m, "IPPROTO_TP", IPPROTO_TP);\r
-#endif\r
-#ifdef IPPROTO_IPV6\r
- PyModule_AddIntConstant(m, "IPPROTO_IPV6", IPPROTO_IPV6);\r
-#endif\r
-#ifdef IPPROTO_ROUTING\r
- PyModule_AddIntConstant(m, "IPPROTO_ROUTING", IPPROTO_ROUTING);\r
-#endif\r
-#ifdef IPPROTO_FRAGMENT\r
- PyModule_AddIntConstant(m, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);\r
-#endif\r
-#ifdef IPPROTO_RSVP\r
- PyModule_AddIntConstant(m, "IPPROTO_RSVP", IPPROTO_RSVP);\r
-#endif\r
-#ifdef IPPROTO_GRE\r
- PyModule_AddIntConstant(m, "IPPROTO_GRE", IPPROTO_GRE);\r
-#endif\r
-#ifdef IPPROTO_ESP\r
- PyModule_AddIntConstant(m, "IPPROTO_ESP", IPPROTO_ESP);\r
-#endif\r
-#ifdef IPPROTO_AH\r
- PyModule_AddIntConstant(m, "IPPROTO_AH", IPPROTO_AH);\r
-#endif\r
-#ifdef IPPROTO_MOBILE\r
- PyModule_AddIntConstant(m, "IPPROTO_MOBILE", IPPROTO_MOBILE);\r
-#endif\r
-#ifdef IPPROTO_ICMPV6\r
- PyModule_AddIntConstant(m, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);\r
-#endif\r
-#ifdef IPPROTO_NONE\r
- PyModule_AddIntConstant(m, "IPPROTO_NONE", IPPROTO_NONE);\r
-#endif\r
-#ifdef IPPROTO_DSTOPTS\r
- PyModule_AddIntConstant(m, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);\r
-#endif\r
-#ifdef IPPROTO_XTP\r
- PyModule_AddIntConstant(m, "IPPROTO_XTP", IPPROTO_XTP);\r
-#endif\r
-#ifdef IPPROTO_EON\r
- PyModule_AddIntConstant(m, "IPPROTO_EON", IPPROTO_EON);\r
-#endif\r
-#ifdef IPPROTO_PIM\r
- PyModule_AddIntConstant(m, "IPPROTO_PIM", IPPROTO_PIM);\r
-#endif\r
-#ifdef IPPROTO_IPCOMP\r
- PyModule_AddIntConstant(m, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);\r
-#endif\r
-#ifdef IPPROTO_VRRP\r
- PyModule_AddIntConstant(m, "IPPROTO_VRRP", IPPROTO_VRRP);\r
-#endif\r
-#ifdef IPPROTO_BIP\r
- PyModule_AddIntConstant(m, "IPPROTO_BIP", IPPROTO_BIP);\r
-#endif\r
-/**/\r
-#ifdef IPPROTO_RAW\r
- PyModule_AddIntConstant(m, "IPPROTO_RAW", IPPROTO_RAW);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPROTO_RAW", 255);\r
-#endif\r
-#ifdef IPPROTO_MAX\r
- PyModule_AddIntConstant(m, "IPPROTO_MAX", IPPROTO_MAX);\r
-#endif\r
-\r
- /* Some port configuration */\r
-#ifdef IPPORT_RESERVED\r
- PyModule_AddIntConstant(m, "IPPORT_RESERVED", IPPORT_RESERVED);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPORT_RESERVED", 1024);\r
-#endif\r
-#ifdef IPPORT_USERRESERVED\r
- PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);\r
-#else\r
- PyModule_AddIntConstant(m, "IPPORT_USERRESERVED", 5000);\r
-#endif\r
-\r
- /* Some reserved IP v.4 addresses */\r
-#ifdef INADDR_ANY\r
- PyModule_AddIntConstant(m, "INADDR_ANY", INADDR_ANY);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_ANY", 0x00000000);\r
-#endif\r
-#ifdef INADDR_BROADCAST\r
- PyModule_AddIntConstant(m, "INADDR_BROADCAST", INADDR_BROADCAST);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_BROADCAST", 0xffffffff);\r
-#endif\r
-#ifdef INADDR_LOOPBACK\r
- PyModule_AddIntConstant(m, "INADDR_LOOPBACK", INADDR_LOOPBACK);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_LOOPBACK", 0x7F000001);\r
-#endif\r
-#ifdef INADDR_UNSPEC_GROUP\r
- PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_UNSPEC_GROUP", 0xe0000000);\r
-#endif\r
-#ifdef INADDR_ALLHOSTS_GROUP\r
- PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP",\r
- INADDR_ALLHOSTS_GROUP);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_ALLHOSTS_GROUP", 0xe0000001);\r
-#endif\r
-#ifdef INADDR_MAX_LOCAL_GROUP\r
- PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP",\r
- INADDR_MAX_LOCAL_GROUP);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);\r
-#endif\r
-#ifdef INADDR_NONE\r
- PyModule_AddIntConstant(m, "INADDR_NONE", INADDR_NONE);\r
-#else\r
- PyModule_AddIntConstant(m, "INADDR_NONE", 0xffffffff);\r
-#endif\r
-\r
- /* IPv4 [gs]etsockopt options */\r
-#ifdef IP_OPTIONS\r
- PyModule_AddIntConstant(m, "IP_OPTIONS", IP_OPTIONS);\r
-#endif\r
-#ifdef IP_HDRINCL\r
- PyModule_AddIntConstant(m, "IP_HDRINCL", IP_HDRINCL);\r
-#endif\r
-#ifdef IP_TOS\r
- PyModule_AddIntConstant(m, "IP_TOS", IP_TOS);\r
-#endif\r
-#ifdef IP_TTL\r
- PyModule_AddIntConstant(m, "IP_TTL", IP_TTL);\r
-#endif\r
-#ifdef IP_RECVOPTS\r
- PyModule_AddIntConstant(m, "IP_RECVOPTS", IP_RECVOPTS);\r
-#endif\r
-#ifdef IP_RECVRETOPTS\r
- PyModule_AddIntConstant(m, "IP_RECVRETOPTS", IP_RECVRETOPTS);\r
-#endif\r
-#ifdef IP_RECVDSTADDR\r
- PyModule_AddIntConstant(m, "IP_RECVDSTADDR", IP_RECVDSTADDR);\r
-#endif\r
-#ifdef IP_RETOPTS\r
- PyModule_AddIntConstant(m, "IP_RETOPTS", IP_RETOPTS);\r
-#endif\r
-#ifdef IP_MULTICAST_IF\r
- PyModule_AddIntConstant(m, "IP_MULTICAST_IF", IP_MULTICAST_IF);\r
-#endif\r
-#ifdef IP_MULTICAST_TTL\r
- PyModule_AddIntConstant(m, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);\r
-#endif\r
-#ifdef IP_MULTICAST_LOOP\r
- PyModule_AddIntConstant(m, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);\r
-#endif\r
-#ifdef IP_ADD_MEMBERSHIP\r
- PyModule_AddIntConstant(m, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);\r
-#endif\r
-#ifdef IP_DROP_MEMBERSHIP\r
- PyModule_AddIntConstant(m, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);\r
-#endif\r
-#ifdef IP_DEFAULT_MULTICAST_TTL\r
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_TTL",\r
- IP_DEFAULT_MULTICAST_TTL);\r
-#endif\r
-#ifdef IP_DEFAULT_MULTICAST_LOOP\r
- PyModule_AddIntConstant(m, "IP_DEFAULT_MULTICAST_LOOP",\r
- IP_DEFAULT_MULTICAST_LOOP);\r
-#endif\r
-#ifdef IP_MAX_MEMBERSHIPS\r
- PyModule_AddIntConstant(m, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);\r
-#endif\r
-\r
- /* IPv6 [gs]etsockopt options, defined in RFC2553 */\r
-#ifdef IPV6_JOIN_GROUP\r
- PyModule_AddIntConstant(m, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);\r
-#endif\r
-#ifdef IPV6_LEAVE_GROUP\r
- PyModule_AddIntConstant(m, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);\r
-#endif\r
-#ifdef IPV6_MULTICAST_HOPS\r
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);\r
-#endif\r
-#ifdef IPV6_MULTICAST_IF\r
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);\r
-#endif\r
-#ifdef IPV6_MULTICAST_LOOP\r
- PyModule_AddIntConstant(m, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);\r
-#endif\r
-#ifdef IPV6_UNICAST_HOPS\r
- PyModule_AddIntConstant(m, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);\r
-#endif\r
- /* Additional IPV6 socket options, defined in RFC 3493 */\r
-#ifdef IPV6_V6ONLY\r
- PyModule_AddIntConstant(m, "IPV6_V6ONLY", IPV6_V6ONLY);\r
-#endif\r
- /* Advanced IPV6 socket options, from RFC 3542 */\r
-#ifdef IPV6_CHECKSUM\r
- PyModule_AddIntConstant(m, "IPV6_CHECKSUM", IPV6_CHECKSUM);\r
-#endif\r
-#ifdef IPV6_DONTFRAG\r
- PyModule_AddIntConstant(m, "IPV6_DONTFRAG", IPV6_DONTFRAG);\r
-#endif\r
-#ifdef IPV6_DSTOPTS\r
- PyModule_AddIntConstant(m, "IPV6_DSTOPTS", IPV6_DSTOPTS);\r
-#endif\r
-#ifdef IPV6_HOPLIMIT\r
- PyModule_AddIntConstant(m, "IPV6_HOPLIMIT", IPV6_HOPLIMIT);\r
-#endif\r
-#ifdef IPV6_HOPOPTS\r
- PyModule_AddIntConstant(m, "IPV6_HOPOPTS", IPV6_HOPOPTS);\r
-#endif\r
-#ifdef IPV6_NEXTHOP\r
- PyModule_AddIntConstant(m, "IPV6_NEXTHOP", IPV6_NEXTHOP);\r
-#endif\r
-#ifdef IPV6_PATHMTU\r
- PyModule_AddIntConstant(m, "IPV6_PATHMTU", IPV6_PATHMTU);\r
-#endif\r
-#ifdef IPV6_PKTINFO\r
- PyModule_AddIntConstant(m, "IPV6_PKTINFO", IPV6_PKTINFO);\r
-#endif\r
-#ifdef IPV6_RECVDSTOPTS\r
- PyModule_AddIntConstant(m, "IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);\r
-#endif\r
-#ifdef IPV6_RECVHOPLIMIT\r
- PyModule_AddIntConstant(m, "IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);\r
-#endif\r
-#ifdef IPV6_RECVHOPOPTS\r
- PyModule_AddIntConstant(m, "IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);\r
-#endif\r
-#ifdef IPV6_RECVPKTINFO\r
- PyModule_AddIntConstant(m, "IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);\r
-#endif\r
-#ifdef IPV6_RECVRTHDR\r
- PyModule_AddIntConstant(m, "IPV6_RECVRTHDR", IPV6_RECVRTHDR);\r
-#endif\r
-#ifdef IPV6_RECVTCLASS\r
- PyModule_AddIntConstant(m, "IPV6_RECVTCLASS", IPV6_RECVTCLASS);\r
-#endif\r
-#ifdef IPV6_RTHDR\r
- PyModule_AddIntConstant(m, "IPV6_RTHDR", IPV6_RTHDR);\r
-#endif\r
-#ifdef IPV6_RTHDRDSTOPTS\r
- PyModule_AddIntConstant(m, "IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);\r
-#endif\r
-#ifdef IPV6_RTHDR_TYPE_0\r
- PyModule_AddIntConstant(m, "IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);\r
-#endif\r
-#ifdef IPV6_RECVPATHMTU\r
- PyModule_AddIntConstant(m, "IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);\r
-#endif\r
-#ifdef IPV6_TCLASS\r
- PyModule_AddIntConstant(m, "IPV6_TCLASS", IPV6_TCLASS);\r
-#endif\r
-#ifdef IPV6_USE_MIN_MTU\r
- PyModule_AddIntConstant(m, "IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);\r
-#endif\r
-\r
- /* TCP options */\r
-#ifdef TCP_NODELAY\r
- PyModule_AddIntConstant(m, "TCP_NODELAY", TCP_NODELAY);\r
-#endif\r
-#ifdef TCP_MAXSEG\r
- PyModule_AddIntConstant(m, "TCP_MAXSEG", TCP_MAXSEG);\r
-#endif\r
-#ifdef TCP_CORK\r
- PyModule_AddIntConstant(m, "TCP_CORK", TCP_CORK);\r
-#endif\r
-#ifdef TCP_KEEPIDLE\r
- PyModule_AddIntConstant(m, "TCP_KEEPIDLE", TCP_KEEPIDLE);\r
-#endif\r
-#ifdef TCP_KEEPINTVL\r
- PyModule_AddIntConstant(m, "TCP_KEEPINTVL", TCP_KEEPINTVL);\r
-#endif\r
-#ifdef TCP_KEEPCNT\r
- PyModule_AddIntConstant(m, "TCP_KEEPCNT", TCP_KEEPCNT);\r
-#endif\r
-#ifdef TCP_SYNCNT\r
- PyModule_AddIntConstant(m, "TCP_SYNCNT", TCP_SYNCNT);\r
-#endif\r
-#ifdef TCP_LINGER2\r
- PyModule_AddIntConstant(m, "TCP_LINGER2", TCP_LINGER2);\r
-#endif\r
-#ifdef TCP_DEFER_ACCEPT\r
- PyModule_AddIntConstant(m, "TCP_DEFER_ACCEPT", TCP_DEFER_ACCEPT);\r
-#endif\r
-#ifdef TCP_WINDOW_CLAMP\r
- PyModule_AddIntConstant(m, "TCP_WINDOW_CLAMP", TCP_WINDOW_CLAMP);\r
-#endif\r
-#ifdef TCP_INFO\r
- PyModule_AddIntConstant(m, "TCP_INFO", TCP_INFO);\r
-#endif\r
-#ifdef TCP_QUICKACK\r
- PyModule_AddIntConstant(m, "TCP_QUICKACK", TCP_QUICKACK);\r
-#endif\r
-\r
-\r
- /* IPX options */\r
-#ifdef IPX_TYPE\r
- PyModule_AddIntConstant(m, "IPX_TYPE", IPX_TYPE);\r
-#endif\r
-\r
- /* get{addr,name}info parameters */\r
-#ifdef EAI_ADDRFAMILY\r
- PyModule_AddIntConstant(m, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);\r
-#endif\r
-#ifdef EAI_AGAIN\r
- PyModule_AddIntConstant(m, "EAI_AGAIN", EAI_AGAIN);\r
-#endif\r
-#ifdef EAI_BADFLAGS\r
- PyModule_AddIntConstant(m, "EAI_BADFLAGS", EAI_BADFLAGS);\r
-#endif\r
-#ifdef EAI_FAIL\r
- PyModule_AddIntConstant(m, "EAI_FAIL", EAI_FAIL);\r
-#endif\r
-#ifdef EAI_FAMILY\r
- PyModule_AddIntConstant(m, "EAI_FAMILY", EAI_FAMILY);\r
-#endif\r
-#ifdef EAI_MEMORY\r
- PyModule_AddIntConstant(m, "EAI_MEMORY", EAI_MEMORY);\r
-#endif\r
-#ifdef EAI_NODATA\r
- PyModule_AddIntConstant(m, "EAI_NODATA", EAI_NODATA);\r
-#endif\r
-#ifdef EAI_NONAME\r
- PyModule_AddIntConstant(m, "EAI_NONAME", EAI_NONAME);\r
-#endif\r
-#ifdef EAI_OVERFLOW\r
- PyModule_AddIntConstant(m, "EAI_OVERFLOW", EAI_OVERFLOW);\r
-#endif\r
-#ifdef EAI_SERVICE\r
- PyModule_AddIntConstant(m, "EAI_SERVICE", EAI_SERVICE);\r
-#endif\r
-#ifdef EAI_SOCKTYPE\r
- PyModule_AddIntConstant(m, "EAI_SOCKTYPE", EAI_SOCKTYPE);\r
-#endif\r
-#ifdef EAI_SYSTEM\r
- PyModule_AddIntConstant(m, "EAI_SYSTEM", EAI_SYSTEM);\r
-#endif\r
-#ifdef EAI_BADHINTS\r
- PyModule_AddIntConstant(m, "EAI_BADHINTS", EAI_BADHINTS);\r
-#endif\r
-#ifdef EAI_PROTOCOL\r
- PyModule_AddIntConstant(m, "EAI_PROTOCOL", EAI_PROTOCOL);\r
-#endif\r
-#ifdef EAI_MAX\r
- PyModule_AddIntConstant(m, "EAI_MAX", EAI_MAX);\r
-#endif\r
-#ifdef AI_PASSIVE\r
- PyModule_AddIntConstant(m, "AI_PASSIVE", AI_PASSIVE);\r
-#endif\r
-#ifdef AI_CANONNAME\r
- PyModule_AddIntConstant(m, "AI_CANONNAME", AI_CANONNAME);\r
-#endif\r
-#ifdef AI_NUMERICHOST\r
- PyModule_AddIntConstant(m, "AI_NUMERICHOST", AI_NUMERICHOST);\r
-#endif\r
-#ifdef AI_NUMERICSERV\r
- PyModule_AddIntConstant(m, "AI_NUMERICSERV", AI_NUMERICSERV);\r
-#endif\r
-#ifdef AI_MASK\r
- PyModule_AddIntConstant(m, "AI_MASK", AI_MASK);\r
-#endif\r
-#ifdef AI_ALL\r
- PyModule_AddIntConstant(m, "AI_ALL", AI_ALL);\r
-#endif\r
-#ifdef AI_V4MAPPED_CFG\r
- PyModule_AddIntConstant(m, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);\r
-#endif\r
-#ifdef AI_ADDRCONFIG\r
- PyModule_AddIntConstant(m, "AI_ADDRCONFIG", AI_ADDRCONFIG);\r
-#endif\r
-#ifdef AI_V4MAPPED\r
- PyModule_AddIntConstant(m, "AI_V4MAPPED", AI_V4MAPPED);\r
-#endif\r
-#ifdef AI_DEFAULT\r
- PyModule_AddIntConstant(m, "AI_DEFAULT", AI_DEFAULT);\r
-#endif\r
-#ifdef NI_MAXHOST\r
- PyModule_AddIntConstant(m, "NI_MAXHOST", NI_MAXHOST);\r
-#endif\r
-#ifdef NI_MAXSERV\r
- PyModule_AddIntConstant(m, "NI_MAXSERV", NI_MAXSERV);\r
-#endif\r
-#ifdef NI_NOFQDN\r
- PyModule_AddIntConstant(m, "NI_NOFQDN", NI_NOFQDN);\r
-#endif\r
-#ifdef NI_NUMERICHOST\r
- PyModule_AddIntConstant(m, "NI_NUMERICHOST", NI_NUMERICHOST);\r
-#endif\r
-#ifdef NI_NAMEREQD\r
- PyModule_AddIntConstant(m, "NI_NAMEREQD", NI_NAMEREQD);\r
-#endif\r
-#ifdef NI_NUMERICSERV\r
- PyModule_AddIntConstant(m, "NI_NUMERICSERV", NI_NUMERICSERV);\r
-#endif\r
-#ifdef NI_DGRAM\r
- PyModule_AddIntConstant(m, "NI_DGRAM", NI_DGRAM);\r
-#endif\r
-\r
- /* shutdown() parameters */\r
-#ifdef SHUT_RD\r
- PyModule_AddIntConstant(m, "SHUT_RD", SHUT_RD);\r
-#elif defined(SD_RECEIVE)\r
- PyModule_AddIntConstant(m, "SHUT_RD", SD_RECEIVE);\r
-#else\r
- PyModule_AddIntConstant(m, "SHUT_RD", 0);\r
-#endif\r
-#ifdef SHUT_WR\r
- PyModule_AddIntConstant(m, "SHUT_WR", SHUT_WR);\r
-#elif defined(SD_SEND)\r
- PyModule_AddIntConstant(m, "SHUT_WR", SD_SEND);\r
-#else\r
- PyModule_AddIntConstant(m, "SHUT_WR", 1);\r
-#endif\r
-#ifdef SHUT_RDWR\r
- PyModule_AddIntConstant(m, "SHUT_RDWR", SHUT_RDWR);\r
-#elif defined(SD_BOTH)\r
- PyModule_AddIntConstant(m, "SHUT_RDWR", SD_BOTH);\r
-#else\r
- PyModule_AddIntConstant(m, "SHUT_RDWR", 2);\r
-#endif\r
-\r
-#ifdef SIO_RCVALL\r
- {\r
- DWORD codes[] = {SIO_RCVALL, SIO_KEEPALIVE_VALS};\r
- const char *names[] = {"SIO_RCVALL", "SIO_KEEPALIVE_VALS"};\r
- int i;\r
- for(i = 0; i<sizeof(codes)/sizeof(*codes); ++i) {\r
- PyObject *tmp;\r
- tmp = PyLong_FromUnsignedLong(codes[i]);\r
- if (tmp == NULL)\r
- return;\r
- PyModule_AddObject(m, names[i], tmp);\r
- }\r
- }\r
- PyModule_AddIntConstant(m, "RCVALL_OFF", RCVALL_OFF);\r
- PyModule_AddIntConstant(m, "RCVALL_ON", RCVALL_ON);\r
- PyModule_AddIntConstant(m, "RCVALL_SOCKETLEVELONLY", RCVALL_SOCKETLEVELONLY);\r
-#ifdef RCVALL_IPLEVEL\r
- PyModule_AddIntConstant(m, "RCVALL_IPLEVEL", RCVALL_IPLEVEL);\r
-#endif\r
-#ifdef RCVALL_MAX\r
- PyModule_AddIntConstant(m, "RCVALL_MAX", RCVALL_MAX);\r
-#endif\r
-#endif /* _MSTCPIP_ */\r
-\r
- /* Initialize gethostbyname lock */\r
-#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)\r
- netdb_lock = PyThread_allocate_lock();\r
-#endif\r
-}\r
-\r
-\r
-#ifndef HAVE_INET_PTON\r
-#if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)\r
-\r
-/* Simplistic emulation code for inet_pton that only works for IPv4 */\r
-/* These are not exposed because they do not set errno properly */\r
-\r
-int\r
-inet_pton(int af, const char *src, void *dst)\r
-{\r
- if (af == AF_INET) {\r
-#if (SIZEOF_INT != 4)\r
-#error "Not sure if in_addr_t exists and int is not 32-bits."\r
-#endif\r
- unsigned int packed_addr;\r
- packed_addr = inet_addr(src);\r
- if (packed_addr == INADDR_NONE)\r
- return 0;\r
- memcpy(dst, &packed_addr, 4);\r
- return 1;\r
- }\r
- /* Should set errno to EAFNOSUPPORT */\r
- return -1;\r
-}\r
-\r
-const char *\r
-inet_ntop(int af, const void *src, char *dst, socklen_t size)\r
-{\r
- if (af == AF_INET) {\r
- struct in_addr packed_addr;\r
- if (size < 16)\r
- /* Should set errno to ENOSPC. */\r
- return NULL;\r
- memcpy(&packed_addr, src, sizeof(packed_addr));\r
- return strncpy(dst, inet_ntoa(packed_addr), size);\r
- }\r
- /* Should set errno to EAFNOSUPPORT */\r
- return NULL;\r
-}\r
-\r
-#endif\r
-#endif\r
projects / mirror_edk2.git / blobdiff