| # Wrapper module for _socket, providing some additional facilities |
| # implemented in Python. |
| |
| """\ |
| This module provides socket operations and some related functions. |
| On Unix, it supports IP (Internet Protocol) and Unix domain sockets. |
| On other systems, it only supports IP. Functions specific for a |
| socket are available as methods of the socket object. |
| |
| Functions: |
| |
| socket() -- create a new socket object |
| socketpair() -- create a pair of new socket objects [*] |
| fromfd() -- create a socket object from an open file descriptor [*] |
| fromshare() -- create a socket object from data received from socket.share() [*] |
| gethostname() -- return the current hostname |
| gethostbyname() -- map a hostname to its IP number |
| gethostbyaddr() -- map an IP number or hostname to DNS info |
| getservbyname() -- map a service name and a protocol name to a port number |
| getprotobyname() -- map a protocol name (e.g. 'tcp') to a number |
| ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order |
| htons(), htonl() -- convert 16, 32 bit int from host to network byte order |
| inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format |
| inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89) |
| socket.getdefaulttimeout() -- get the default timeout value |
| socket.setdefaulttimeout() -- set the default timeout value |
| create_connection() -- connects to an address, with an optional timeout and |
| optional source address. |
| |
| [*] not available on all platforms! |
| |
| Special objects: |
| |
| SocketType -- type object for socket objects |
| error -- exception raised for I/O errors |
| has_ipv6 -- boolean value indicating if IPv6 is supported |
| |
| IntEnum constants: |
| |
| AF_INET, AF_UNIX -- socket domains (first argument to socket() call) |
| SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument) |
| |
| Integer constants: |
| |
| Many other constants may be defined; these may be used in calls to |
| the setsockopt() and getsockopt() methods. |
| """ |
| |
| import _socket |
| from _socket import * |
| |
| import os, sys, io, selectors |
| from enum import IntEnum, IntFlag |
| |
| try: |
| import errno |
| except ImportError: |
| errno = None |
| EBADF = getattr(errno, 'EBADF', 9) |
| EAGAIN = getattr(errno, 'EAGAIN', 11) |
| EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', 11) |
| |
| __all__ = ["fromfd", "getfqdn", "create_connection", "create_server", |
| "has_dualstack_ipv6", "AddressFamily", "SocketKind"] |
| __all__.extend(os._get_exports_list(_socket)) |
| |
| # Set up the socket.AF_* socket.SOCK_* constants as members of IntEnums for |
| # nicer string representations. |
| # Note that _socket only knows about the integer values. The public interface |
| # in this module understands the enums and translates them back from integers |
| # where needed (e.g. .family property of a socket object). |
| |
| IntEnum._convert_( |
| 'AddressFamily', |
| __name__, |
| lambda C: C.isupper() and C.startswith('AF_')) |
| |
| IntEnum._convert_( |
| 'SocketKind', |
| __name__, |
| lambda C: C.isupper() and C.startswith('SOCK_')) |
| |
| IntFlag._convert_( |
| 'MsgFlag', |
| __name__, |
| lambda C: C.isupper() and C.startswith('MSG_')) |
| |
| IntFlag._convert_( |
| 'AddressInfo', |
| __name__, |
| lambda C: C.isupper() and C.startswith('AI_')) |
| |
| _LOCALHOST = '127.0.0.1' |
| _LOCALHOST_V6 = '::1' |
| |
| |
| def _intenum_converter(value, enum_klass): |
| """Convert a numeric family value to an IntEnum member. |
| |
| If it's not a known member, return the numeric value itself. |
| """ |
| try: |
| return enum_klass(value) |
| except ValueError: |
| return value |
| |
| _realsocket = socket |
| |
| # WSA error codes |
| if sys.platform.lower().startswith("win"): |
| errorTab = {} |
| errorTab[6] = "Specified event object handle is invalid." |
| errorTab[8] = "Insufficient memory available." |
| errorTab[87] = "One or more parameters are invalid." |
| errorTab[995] = "Overlapped operation aborted." |
| errorTab[996] = "Overlapped I/O event object not in signaled state." |
| errorTab[997] = "Overlapped operation will complete later." |
| errorTab[10004] = "The operation was interrupted." |
| errorTab[10009] = "A bad file handle was passed." |
| errorTab[10013] = "Permission denied." |
| errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT |
| errorTab[10022] = "An invalid operation was attempted." |
| errorTab[10024] = "Too many open files." |
| errorTab[10035] = "The socket operation would block" |
| errorTab[10036] = "A blocking operation is already in progress." |
| errorTab[10037] = "Operation already in progress." |
| errorTab[10038] = "Socket operation on nonsocket." |
| errorTab[10039] = "Destination address required." |
| errorTab[10040] = "Message too long." |
| errorTab[10041] = "Protocol wrong type for socket." |
| errorTab[10042] = "Bad protocol option." |
| errorTab[10043] = "Protocol not supported." |
| errorTab[10044] = "Socket type not supported." |
| errorTab[10045] = "Operation not supported." |
| errorTab[10046] = "Protocol family not supported." |
| errorTab[10047] = "Address family not supported by protocol family." |
| errorTab[10048] = "The network address is in use." |
| errorTab[10049] = "Cannot assign requested address." |
| errorTab[10050] = "Network is down." |
| errorTab[10051] = "Network is unreachable." |
| errorTab[10052] = "Network dropped connection on reset." |
| errorTab[10053] = "Software caused connection abort." |
| errorTab[10054] = "The connection has been reset." |
| errorTab[10055] = "No buffer space available." |
| errorTab[10056] = "Socket is already connected." |
| errorTab[10057] = "Socket is not connected." |
| errorTab[10058] = "The network has been shut down." |
| errorTab[10059] = "Too many references." |
| errorTab[10060] = "The operation timed out." |
| errorTab[10061] = "Connection refused." |
| errorTab[10062] = "Cannot translate name." |
| errorTab[10063] = "The name is too long." |
| errorTab[10064] = "The host is down." |
| errorTab[10065] = "The host is unreachable." |
| errorTab[10066] = "Directory not empty." |
| errorTab[10067] = "Too many processes." |
| errorTab[10068] = "User quota exceeded." |
| errorTab[10069] = "Disk quota exceeded." |
| errorTab[10070] = "Stale file handle reference." |
| errorTab[10071] = "Item is remote." |
| errorTab[10091] = "Network subsystem is unavailable." |
| errorTab[10092] = "Winsock.dll version out of range." |
| errorTab[10093] = "Successful WSAStartup not yet performed." |
| errorTab[10101] = "Graceful shutdown in progress." |
| errorTab[10102] = "No more results from WSALookupServiceNext." |
| errorTab[10103] = "Call has been canceled." |
| errorTab[10104] = "Procedure call table is invalid." |
| errorTab[10105] = "Service provider is invalid." |
| errorTab[10106] = "Service provider failed to initialize." |
| errorTab[10107] = "System call failure." |
| errorTab[10108] = "Service not found." |
| errorTab[10109] = "Class type not found." |
| errorTab[10110] = "No more results from WSALookupServiceNext." |
| errorTab[10111] = "Call was canceled." |
| errorTab[10112] = "Database query was refused." |
| errorTab[11001] = "Host not found." |
| errorTab[11002] = "Nonauthoritative host not found." |
| errorTab[11003] = "This is a nonrecoverable error." |
| errorTab[11004] = "Valid name, no data record requested type." |
| errorTab[11005] = "QoS receivers." |
| errorTab[11006] = "QoS senders." |
| errorTab[11007] = "No QoS senders." |
| errorTab[11008] = "QoS no receivers." |
| errorTab[11009] = "QoS request confirmed." |
| errorTab[11010] = "QoS admission error." |
| errorTab[11011] = "QoS policy failure." |
| errorTab[11012] = "QoS bad style." |
| errorTab[11013] = "QoS bad object." |
| errorTab[11014] = "QoS traffic control error." |
| errorTab[11015] = "QoS generic error." |
| errorTab[11016] = "QoS service type error." |
| errorTab[11017] = "QoS flowspec error." |
| errorTab[11018] = "Invalid QoS provider buffer." |
| errorTab[11019] = "Invalid QoS filter style." |
| errorTab[11020] = "Invalid QoS filter style." |
| errorTab[11021] = "Incorrect QoS filter count." |
| errorTab[11022] = "Invalid QoS object length." |
| errorTab[11023] = "Incorrect QoS flow count." |
| errorTab[11024] = "Unrecognized QoS object." |
| errorTab[11025] = "Invalid QoS policy object." |
| errorTab[11026] = "Invalid QoS flow descriptor." |
| errorTab[11027] = "Invalid QoS provider-specific flowspec." |
| errorTab[11028] = "Invalid QoS provider-specific filterspec." |
| errorTab[11029] = "Invalid QoS shape discard mode object." |
| errorTab[11030] = "Invalid QoS shaping rate object." |
| errorTab[11031] = "Reserved policy QoS element type." |
| __all__.append("errorTab") |
| |
| |
| class _GiveupOnSendfile(Exception): pass |
| |
| |
| class socket(_socket.socket): |
| |
| """A subclass of _socket.socket adding the makefile() method.""" |
| |
| __slots__ = ["__weakref__", "_io_refs", "_closed"] |
| |
| def __init__(self, family=-1, type=-1, proto=-1, fileno=None): |
| # For user code address family and type values are IntEnum members, but |
| # for the underlying _socket.socket they're just integers. The |
| # constructor of _socket.socket converts the given argument to an |
| # integer automatically. |
| if fileno is None: |
| if family == -1: |
| family = AF_INET |
| if type == -1: |
| type = SOCK_STREAM |
| if proto == -1: |
| proto = 0 |
| _socket.socket.__init__(self, family, type, proto, fileno) |
| self._io_refs = 0 |
| self._closed = False |
| |
| def __enter__(self): |
| return self |
| |
| def __exit__(self, *args): |
| if not self._closed: |
| self.close() |
| |
| def __repr__(self): |
| """Wrap __repr__() to reveal the real class name and socket |
| address(es). |
| """ |
| closed = getattr(self, '_closed', False) |
| s = "<%s.%s%s fd=%i, family=%s, type=%s, proto=%i" \ |
| % (self.__class__.__module__, |
| self.__class__.__qualname__, |
| " [closed]" if closed else "", |
| self.fileno(), |
| self.family, |
| self.type, |
| self.proto) |
| if not closed: |
| try: |
| laddr = self.getsockname() |
| if laddr: |
| s += ", laddr=%s" % str(laddr) |
| except error: |
| pass |
| try: |
| raddr = self.getpeername() |
| if raddr: |
| s += ", raddr=%s" % str(raddr) |
| except error: |
| pass |
| s += '>' |
| return s |
| |
| def __getstate__(self): |
| raise TypeError(f"cannot pickle {self.__class__.__name__!r} object") |
| |
| def dup(self): |
| """dup() -> socket object |
| |
| Duplicate the socket. Return a new socket object connected to the same |
| system resource. The new socket is non-inheritable. |
| """ |
| fd = dup(self.fileno()) |
| sock = self.__class__(self.family, self.type, self.proto, fileno=fd) |
| sock.settimeout(self.gettimeout()) |
| return sock |
| |
| def accept(self): |
| """accept() -> (socket object, address info) |
| |
| Wait for an incoming connection. Return a new socket |
| representing the connection, and the address of the client. |
| For IP sockets, the address info is a pair (hostaddr, port). |
| """ |
| fd, addr = self._accept() |
| sock = socket(self.family, self.type, self.proto, fileno=fd) |
| # Issue #7995: if no default timeout is set and the listening |
| # socket had a (non-zero) timeout, force the new socket in blocking |
| # mode to override platform-specific socket flags inheritance. |
| if getdefaulttimeout() is None and self.gettimeout(): |
| sock.setblocking(True) |
| return sock, addr |
| |
| def makefile(self, mode="r", buffering=None, *, |
| encoding=None, errors=None, newline=None): |
| """makefile(...) -> an I/O stream connected to the socket |
| |
| The arguments are as for io.open() after the filename, except the only |
| supported mode values are 'r' (default), 'w' and 'b'. |
| """ |
| # XXX refactor to share code? |
| if not set(mode) <= {"r", "w", "b"}: |
| raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) |
| writing = "w" in mode |
| reading = "r" in mode or not writing |
| assert reading or writing |
| binary = "b" in mode |
| rawmode = "" |
| if reading: |
| rawmode += "r" |
| if writing: |
| rawmode += "w" |
| raw = SocketIO(self, rawmode) |
| self._io_refs += 1 |
| if buffering is None: |
| buffering = -1 |
| if buffering < 0: |
| buffering = io.DEFAULT_BUFFER_SIZE |
| if buffering == 0: |
| if not binary: |
| raise ValueError("unbuffered streams must be binary") |
| return raw |
| if reading and writing: |
| buffer = io.BufferedRWPair(raw, raw, buffering) |
| elif reading: |
| buffer = io.BufferedReader(raw, buffering) |
| else: |
| assert writing |
| buffer = io.BufferedWriter(raw, buffering) |
| if binary: |
| return buffer |
| text = io.TextIOWrapper(buffer, encoding, errors, newline) |
| text.mode = mode |
| return text |
| |
| if hasattr(os, 'sendfile'): |
| |
| def _sendfile_use_sendfile(self, file, offset=0, count=None): |
| self._check_sendfile_params(file, offset, count) |
| sockno = self.fileno() |
| try: |
| fileno = file.fileno() |
| except (AttributeError, io.UnsupportedOperation) as err: |
| raise _GiveupOnSendfile(err) # not a regular file |
| try: |
| fsize = os.fstat(fileno).st_size |
| except OSError as err: |
| raise _GiveupOnSendfile(err) # not a regular file |
| if not fsize: |
| return 0 # empty file |
| # Truncate to 1GiB to avoid OverflowError, see bpo-38319. |
| blocksize = min(count or fsize, 2 ** 30) |
| timeout = self.gettimeout() |
| if timeout == 0: |
| raise ValueError("non-blocking sockets are not supported") |
| # poll/select have the advantage of not requiring any |
| # extra file descriptor, contrarily to epoll/kqueue |
| # (also, they require a single syscall). |
| if hasattr(selectors, 'PollSelector'): |
| selector = selectors.PollSelector() |
| else: |
| selector = selectors.SelectSelector() |
| selector.register(sockno, selectors.EVENT_WRITE) |
| |
| total_sent = 0 |
| # localize variable access to minimize overhead |
| selector_select = selector.select |
| os_sendfile = os.sendfile |
| try: |
| while True: |
| if timeout and not selector_select(timeout): |
| raise _socket.timeout('timed out') |
| if count: |
| blocksize = count - total_sent |
| if blocksize <= 0: |
| break |
| try: |
| sent = os_sendfile(sockno, fileno, offset, blocksize) |
| except BlockingIOError: |
| if not timeout: |
| # Block until the socket is ready to send some |
| # data; avoids hogging CPU resources. |
| selector_select() |
| continue |
| except OSError as err: |
| if total_sent == 0: |
| # We can get here for different reasons, the main |
| # one being 'file' is not a regular mmap(2)-like |
| # file, in which case we'll fall back on using |
| # plain send(). |
| raise _GiveupOnSendfile(err) |
| raise err from None |
| else: |
| if sent == 0: |
| break # EOF |
| offset += sent |
| total_sent += sent |
| return total_sent |
| finally: |
| if total_sent > 0 and hasattr(file, 'seek'): |
| file.seek(offset) |
| else: |
| def _sendfile_use_sendfile(self, file, offset=0, count=None): |
| raise _GiveupOnSendfile( |
| "os.sendfile() not available on this platform") |
| |
| def _sendfile_use_send(self, file, offset=0, count=None): |
| self._check_sendfile_params(file, offset, count) |
| if self.gettimeout() == 0: |
| raise ValueError("non-blocking sockets are not supported") |
| if offset: |
| file.seek(offset) |
| blocksize = min(count, 8192) if count else 8192 |
| total_sent = 0 |
| # localize variable access to minimize overhead |
| file_read = file.read |
| sock_send = self.send |
| try: |
| while True: |
| if count: |
| blocksize = min(count - total_sent, blocksize) |
| if blocksize <= 0: |
| break |
| data = memoryview(file_read(blocksize)) |
| if not data: |
| break # EOF |
| while True: |
| try: |
| sent = sock_send(data) |
| except BlockingIOError: |
| continue |
| else: |
| total_sent += sent |
| if sent < len(data): |
| data = data[sent:] |
| else: |
| break |
| return total_sent |
| finally: |
| if total_sent > 0 and hasattr(file, 'seek'): |
| file.seek(offset + total_sent) |
| |
| def _check_sendfile_params(self, file, offset, count): |
| if 'b' not in getattr(file, 'mode', 'b'): |
| raise ValueError("file should be opened in binary mode") |
| if not self.type & SOCK_STREAM: |
| raise ValueError("only SOCK_STREAM type sockets are supported") |
| if count is not None: |
| if not isinstance(count, int): |
| raise TypeError( |
| "count must be a positive integer (got {!r})".format(count)) |
| if count <= 0: |
| raise ValueError( |
| "count must be a positive integer (got {!r})".format(count)) |
| |
| def sendfile(self, file, offset=0, count=None): |
| """sendfile(file[, offset[, count]]) -> sent |
| |
| Send a file until EOF is reached by using high-performance |
| os.sendfile() and return the total number of bytes which |
| were sent. |
| *file* must be a regular file object opened in binary mode. |
| If os.sendfile() is not available (e.g. Windows) or file is |
| not a regular file socket.send() will be used instead. |
| *offset* tells from where to start reading the file. |
| If specified, *count* is the total number of bytes to transmit |
| as opposed to sending the file until EOF is reached. |
| File position is updated on return or also in case of error in |
| which case file.tell() can be used to figure out the number of |
| bytes which were sent. |
| The socket must be of SOCK_STREAM type. |
| Non-blocking sockets are not supported. |
| """ |
| try: |
| return self._sendfile_use_sendfile(file, offset, count) |
| except _GiveupOnSendfile: |
| return self._sendfile_use_send(file, offset, count) |
| |
| def _decref_socketios(self): |
| if self._io_refs > 0: |
| self._io_refs -= 1 |
| if self._closed: |
| self.close() |
| |
| def _real_close(self, _ss=_socket.socket): |
| # This function should not reference any globals. See issue #808164. |
| _ss.close(self) |
| |
| def close(self): |
| # This function should not reference any globals. See issue #808164. |
| self._closed = True |
| if self._io_refs <= 0: |
| self._real_close() |
| |
| def detach(self): |
| """detach() -> file descriptor |
| |
| Close the socket object without closing the underlying file descriptor. |
| The object cannot be used after this call, but the file descriptor |
| can be reused for other purposes. The file descriptor is returned. |
| """ |
| self._closed = True |
| return super().detach() |
| |
| @property |
| def family(self): |
| """Read-only access to the address family for this socket. |
| """ |
| return _intenum_converter(super().family, AddressFamily) |
| |
| @property |
| def type(self): |
| """Read-only access to the socket type. |
| """ |
| return _intenum_converter(super().type, SocketKind) |
| |
| if os.name == 'nt': |
| def get_inheritable(self): |
| return os.get_handle_inheritable(self.fileno()) |
| def set_inheritable(self, inheritable): |
| os.set_handle_inheritable(self.fileno(), inheritable) |
| else: |
| def get_inheritable(self): |
| return os.get_inheritable(self.fileno()) |
| def set_inheritable(self, inheritable): |
| os.set_inheritable(self.fileno(), inheritable) |
| get_inheritable.__doc__ = "Get the inheritable flag of the socket" |
| set_inheritable.__doc__ = "Set the inheritable flag of the socket" |
| |
| def fromfd(fd, family, type, proto=0): |
| """ fromfd(fd, family, type[, proto]) -> socket object |
| |
| Create a socket object from a duplicate of the given file |
| descriptor. The remaining arguments are the same as for socket(). |
| """ |
| nfd = dup(fd) |
| return socket(family, type, proto, nfd) |
| |
| if hasattr(_socket.socket, "share"): |
| def fromshare(info): |
| """ fromshare(info) -> socket object |
| |
| Create a socket object from the bytes object returned by |
| socket.share(pid). |
| """ |
| return socket(0, 0, 0, info) |
| __all__.append("fromshare") |
| |
| if hasattr(_socket, "socketpair"): |
| |
| def socketpair(family=None, type=SOCK_STREAM, proto=0): |
| """socketpair([family[, type[, proto]]]) -> (socket object, socket object) |
| |
| Create a pair of socket objects from the sockets returned by the platform |
| socketpair() function. |
| The arguments are the same as for socket() except the default family is |
| AF_UNIX if defined on the platform; otherwise, the default is AF_INET. |
| """ |
| if family is None: |
| try: |
| family = AF_UNIX |
| except NameError: |
| family = AF_INET |
| a, b = _socket.socketpair(family, type, proto) |
| a = socket(family, type, proto, a.detach()) |
| b = socket(family, type, proto, b.detach()) |
| return a, b |
| |
| else: |
| |
| # Origin: https://gist.github.com/4325783, by Geert Jansen. Public domain. |
| def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0): |
| if family == AF_INET: |
| host = _LOCALHOST |
| elif family == AF_INET6: |
| host = _LOCALHOST_V6 |
| else: |
| raise ValueError("Only AF_INET and AF_INET6 socket address families " |
| "are supported") |
| if type != SOCK_STREAM: |
| raise ValueError("Only SOCK_STREAM socket type is supported") |
| if proto != 0: |
| raise ValueError("Only protocol zero is supported") |
| |
| # We create a connected TCP socket. Note the trick with |
| # setblocking(False) that prevents us from having to create a thread. |
| lsock = socket(family, type, proto) |
| try: |
| lsock.bind((host, 0)) |
| lsock.listen() |
| # On IPv6, ignore flow_info and scope_id |
| addr, port = lsock.getsockname()[:2] |
| csock = socket(family, type, proto) |
| try: |
| csock.setblocking(False) |
| try: |
| csock.connect((addr, port)) |
| except (BlockingIOError, InterruptedError): |
| pass |
| csock.setblocking(True) |
| ssock, _ = lsock.accept() |
| except: |
| csock.close() |
| raise |
| finally: |
| lsock.close() |
| return (ssock, csock) |
| __all__.append("socketpair") |
| |
| socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object) |
| Create a pair of socket objects from the sockets returned by the platform |
| socketpair() function. |
| The arguments are the same as for socket() except the default family is AF_UNIX |
| if defined on the platform; otherwise, the default is AF_INET. |
| """ |
| |
| _blocking_errnos = { EAGAIN, EWOULDBLOCK } |
| |
| class SocketIO(io.RawIOBase): |
| |
| """Raw I/O implementation for stream sockets. |
| |
| This class supports the makefile() method on sockets. It provides |
| the raw I/O interface on top of a socket object. |
| """ |
| |
| # One might wonder why not let FileIO do the job instead. There are two |
| # main reasons why FileIO is not adapted: |
| # - it wouldn't work under Windows (where you can't used read() and |
| # write() on a socket handle) |
| # - it wouldn't work with socket timeouts (FileIO would ignore the |
| # timeout and consider the socket non-blocking) |
| |
| # XXX More docs |
| |
| def __init__(self, sock, mode): |
| if mode not in ("r", "w", "rw", "rb", "wb", "rwb"): |
| raise ValueError("invalid mode: %r" % mode) |
| io.RawIOBase.__init__(self) |
| self._sock = sock |
| if "b" not in mode: |
| mode += "b" |
| self._mode = mode |
| self._reading = "r" in mode |
| self._writing = "w" in mode |
| self._timeout_occurred = False |
| |
| def readinto(self, b): |
| """Read up to len(b) bytes into the writable buffer *b* and return |
| the number of bytes read. If the socket is non-blocking and no bytes |
| are available, None is returned. |
| |
| If *b* is non-empty, a 0 return value indicates that the connection |
| was shutdown at the other end. |
| """ |
| self._checkClosed() |
| self._checkReadable() |
| if self._timeout_occurred: |
| raise OSError("cannot read from timed out object") |
| while True: |
| try: |
| return self._sock.recv_into(b) |
| except timeout: |
| self._timeout_occurred = True |
| raise |
| except error as e: |
| if e.args[0] in _blocking_errnos: |
| return None |
| raise |
| |
| def write(self, b): |
| """Write the given bytes or bytearray object *b* to the socket |
| and return the number of bytes written. This can be less than |
| len(b) if not all data could be written. If the socket is |
| non-blocking and no bytes could be written None is returned. |
| """ |
| self._checkClosed() |
| self._checkWritable() |
| try: |
| return self._sock.send(b) |
| except error as e: |
| # XXX what about EINTR? |
| if e.args[0] in _blocking_errnos: |
| return None |
| raise |
| |
| def readable(self): |
| """True if the SocketIO is open for reading. |
| """ |
| if self.closed: |
| raise ValueError("I/O operation on closed socket.") |
| return self._reading |
| |
| def writable(self): |
| """True if the SocketIO is open for writing. |
| """ |
| if self.closed: |
| raise ValueError("I/O operation on closed socket.") |
| return self._writing |
| |
| def seekable(self): |
| """True if the SocketIO is open for seeking. |
| """ |
| if self.closed: |
| raise ValueError("I/O operation on closed socket.") |
| return super().seekable() |
| |
| def fileno(self): |
| """Return the file descriptor of the underlying socket. |
| """ |
| self._checkClosed() |
| return self._sock.fileno() |
| |
| @property |
| def name(self): |
| if not self.closed: |
| return self.fileno() |
| else: |
| return -1 |
| |
| @property |
| def mode(self): |
| return self._mode |
| |
| def close(self): |
| """Close the SocketIO object. This doesn't close the underlying |
| socket, except if all references to it have disappeared. |
| """ |
| if self.closed: |
| return |
| io.RawIOBase.close(self) |
| self._sock._decref_socketios() |
| self._sock = None |
| |
| |
| def getfqdn(name=''): |
| """Get fully qualified domain name from name. |
| |
| An empty argument is interpreted as meaning the local host. |
| |
| First the hostname returned by gethostbyaddr() is checked, then |
| possibly existing aliases. In case no FQDN is available, hostname |
| from gethostname() is returned. |
| """ |
| name = name.strip() |
| if not name or name == '0.0.0.0': |
| name = gethostname() |
| try: |
| hostname, aliases, ipaddrs = gethostbyaddr(name) |
| except error: |
| pass |
| else: |
| aliases.insert(0, hostname) |
| for name in aliases: |
| if '.' in name: |
| break |
| else: |
| name = hostname |
| return name |
| |
| |
| _GLOBAL_DEFAULT_TIMEOUT = object() |
| |
| def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT, |
| source_address=None): |
| """Connect to *address* and return the socket object. |
| |
| Convenience function. Connect to *address* (a 2-tuple ``(host, |
| port)``) and return the socket object. Passing the optional |
| *timeout* parameter will set the timeout on the socket instance |
| before attempting to connect. If no *timeout* is supplied, the |
| global default timeout setting returned by :func:`getdefaulttimeout` |
| is used. If *source_address* is set it must be a tuple of (host, port) |
| for the socket to bind as a source address before making the connection. |
| A host of '' or port 0 tells the OS to use the default. |
| """ |
| |
| host, port = address |
| err = None |
| for res in getaddrinfo(host, port, 0, SOCK_STREAM): |
| af, socktype, proto, canonname, sa = res |
| sock = None |
| try: |
| sock = socket(af, socktype, proto) |
| if timeout is not _GLOBAL_DEFAULT_TIMEOUT: |
| sock.settimeout(timeout) |
| if source_address: |
| sock.bind(source_address) |
| sock.connect(sa) |
| # Break explicitly a reference cycle |
| err = None |
| return sock |
| |
| except error as _: |
| err = _ |
| if sock is not None: |
| sock.close() |
| |
| if err is not None: |
| try: |
| raise err |
| finally: |
| # Break explicitly a reference cycle |
| err = None |
| else: |
| raise error("getaddrinfo returns an empty list") |
| |
| |
| def has_dualstack_ipv6(): |
| """Return True if the platform supports creating a SOCK_STREAM socket |
| which can handle both AF_INET and AF_INET6 (IPv4 / IPv6) connections. |
| """ |
| if not has_ipv6 \ |
| or not hasattr(_socket, 'IPPROTO_IPV6') \ |
| or not hasattr(_socket, 'IPV6_V6ONLY'): |
| return False |
| try: |
| with socket(AF_INET6, SOCK_STREAM) as sock: |
| sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 0) |
| return True |
| except error: |
| return False |
| |
| |
| def create_server(address, *, family=AF_INET, backlog=None, reuse_port=False, |
| dualstack_ipv6=False): |
| """Convenience function which creates a SOCK_STREAM type socket |
| bound to *address* (a 2-tuple (host, port)) and return the socket |
| object. |
| |
| *family* should be either AF_INET or AF_INET6. |
| *backlog* is the queue size passed to socket.listen(). |
| *reuse_port* dictates whether to use the SO_REUSEPORT socket option. |
| *dualstack_ipv6*: if true and the platform supports it, it will |
| create an AF_INET6 socket able to accept both IPv4 or IPv6 |
| connections. When false it will explicitly disable this option on |
| platforms that enable it by default (e.g. Linux). |
| |
| >>> with create_server(('', 8000)) as server: |
| ... while True: |
| ... conn, addr = server.accept() |
| ... # handle new connection |
| """ |
| if reuse_port and not hasattr(_socket, "SO_REUSEPORT"): |
| raise ValueError("SO_REUSEPORT not supported on this platform") |
| if dualstack_ipv6: |
| if not has_dualstack_ipv6(): |
| raise ValueError("dualstack_ipv6 not supported on this platform") |
| if family != AF_INET6: |
| raise ValueError("dualstack_ipv6 requires AF_INET6 family") |
| sock = socket(family, SOCK_STREAM) |
| try: |
| # Note about Windows. We don't set SO_REUSEADDR because: |
| # 1) It's unnecessary: bind() will succeed even in case of a |
| # previous closed socket on the same address and still in |
| # TIME_WAIT state. |
| # 2) If set, another socket is free to bind() on the same |
| # address, effectively preventing this one from accepting |
| # connections. Also, it may set the process in a state where |
| # it'll no longer respond to any signals or graceful kills. |
| # See: msdn2.microsoft.com/en-us/library/ms740621(VS.85).aspx |
| if os.name not in ('nt', 'cygwin') and \ |
| hasattr(_socket, 'SO_REUSEADDR'): |
| try: |
| sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) |
| except error: |
| # Fail later on bind(), for platforms which may not |
| # support this option. |
| pass |
| if reuse_port: |
| sock.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1) |
| if has_ipv6 and family == AF_INET6: |
| if dualstack_ipv6: |
| sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 0) |
| elif hasattr(_socket, "IPV6_V6ONLY") and \ |
| hasattr(_socket, "IPPROTO_IPV6"): |
| sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 1) |
| try: |
| sock.bind(address) |
| except error as err: |
| msg = '%s (while attempting to bind on address %r)' % \ |
| (err.strerror, address) |
| raise error(err.errno, msg) from None |
| if backlog is None: |
| sock.listen() |
| else: |
| sock.listen(backlog) |
| return sock |
| except error: |
| sock.close() |
| raise |
| |
| |
| def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0): |
| """Resolve host and port into list of address info entries. |
| |
| Translate the host/port argument into a sequence of 5-tuples that contain |
| all the necessary arguments for creating a socket connected to that service. |
| host is a domain name, a string representation of an IPv4/v6 address or |
| None. port is a string service name such as 'http', a numeric port number or |
| None. By passing None as the value of host and port, you can pass NULL to |
| the underlying C API. |
| |
| The family, type and proto arguments can be optionally specified in order to |
| narrow the list of addresses returned. Passing zero as a value for each of |
| these arguments selects the full range of results. |
| """ |
| # We override this function since we want to translate the numeric family |
| # and socket type values to enum constants. |
| addrlist = [] |
| for res in _socket.getaddrinfo(host, port, family, type, proto, flags): |
| af, socktype, proto, canonname, sa = res |
| addrlist.append((_intenum_converter(af, AddressFamily), |
| _intenum_converter(socktype, SocketKind), |
| proto, canonname, sa)) |
| return addrlist |