+++ /dev/null
-# Wrapper module for _socket, providing some additional facilities\r
-# implemented in Python.\r
-\r
-"""\\r
-This module provides socket operations and some related functions.\r
-On Unix, it supports IP (Internet Protocol) and Unix domain sockets.\r
-On other systems, it only supports IP. Functions specific for a\r
-socket are available as methods of the socket object.\r
-\r
-Functions:\r
-\r
-socket() -- create a new socket object\r
-socketpair() -- create a pair of new socket objects [*]\r
-fromfd() -- create a socket object from an open file descriptor [*]\r
-gethostname() -- return the current hostname\r
-gethostbyname() -- map a hostname to its IP number\r
-gethostbyaddr() -- map an IP number or hostname to DNS info\r
-getservbyname() -- map a service name and a protocol name to a port number\r
-getprotobyname() -- map a protocol name (e.g. 'tcp') to a number\r
-ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order\r
-htons(), htonl() -- convert 16, 32 bit int from host to network byte order\r
-inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format\r
-inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)\r
-ssl() -- secure socket layer support (only available if configured)\r
-socket.getdefaulttimeout() -- get the default timeout value\r
-socket.setdefaulttimeout() -- set the default timeout value\r
-create_connection() -- connects to an address, with an optional timeout and\r
- optional source address.\r
-\r
- [*] not available on all platforms!\r
-\r
-Special objects:\r
-\r
-SocketType -- type object for socket objects\r
-error -- exception raised for I/O errors\r
-has_ipv6 -- boolean value indicating if IPv6 is supported\r
-\r
-Integer constants:\r
-\r
-AF_INET, AF_UNIX -- socket domains (first argument to socket() call)\r
-SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)\r
-\r
-Many other constants may be defined; these may be used in calls to\r
-the setsockopt() and getsockopt() methods.\r
-"""\r
-\r
-import _socket\r
-from _socket import *\r
-from functools import partial\r
-from types import MethodType\r
-\r
-try:\r
- import _ssl\r
-except ImportError:\r
- # no SSL support\r
- pass\r
-else:\r
- def ssl(sock, keyfile=None, certfile=None):\r
- # we do an internal import here because the ssl\r
- # module imports the socket module\r
- import ssl as _realssl\r
- warnings.warn("socket.ssl() is deprecated. Use ssl.wrap_socket() instead.",\r
- DeprecationWarning, stacklevel=2)\r
- return _realssl.sslwrap_simple(sock, keyfile, certfile)\r
-\r
- # we need to import the same constants we used to...\r
- from _ssl import SSLError as sslerror\r
- from _ssl import \\r
- RAND_add, \\r
- RAND_egd, \\r
- RAND_status, \\r
- SSL_ERROR_ZERO_RETURN, \\r
- SSL_ERROR_WANT_READ, \\r
- SSL_ERROR_WANT_WRITE, \\r
- SSL_ERROR_WANT_X509_LOOKUP, \\r
- SSL_ERROR_SYSCALL, \\r
- SSL_ERROR_SSL, \\r
- SSL_ERROR_WANT_CONNECT, \\r
- SSL_ERROR_EOF, \\r
- SSL_ERROR_INVALID_ERROR_CODE\r
-\r
-import os, sys, warnings\r
-\r
-try:\r
- from cStringIO import StringIO\r
-except ImportError:\r
- from StringIO import StringIO\r
-\r
-try:\r
- import errno\r
-except ImportError:\r
- errno = None\r
-EBADF = getattr(errno, 'EBADF', 9)\r
-EINTR = getattr(errno, 'EINTR', 4)\r
-\r
-__all__ = ["getfqdn", "create_connection"]\r
-__all__.extend(os._get_exports_list(_socket))\r
-\r
-\r
-_realsocket = socket\r
-\r
-# WSA error codes\r
-if sys.platform.lower().startswith("win"):\r
- errorTab = {}\r
- errorTab[10004] = "The operation was interrupted."\r
- errorTab[10009] = "A bad file handle was passed."\r
- errorTab[10013] = "Permission denied."\r
- errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT\r
- errorTab[10022] = "An invalid operation was attempted."\r
- errorTab[10035] = "The socket operation would block"\r
- errorTab[10036] = "A blocking operation is already in progress."\r
- errorTab[10048] = "The network address is in use."\r
- errorTab[10054] = "The connection has been reset."\r
- errorTab[10058] = "The network has been shut down."\r
- errorTab[10060] = "The operation timed out."\r
- errorTab[10061] = "Connection refused."\r
- errorTab[10063] = "The name is too long."\r
- errorTab[10064] = "The host is down."\r
- errorTab[10065] = "The host is unreachable."\r
- __all__.append("errorTab")\r
-\r
-\r
-\r
-def getfqdn(name=''):\r
- """Get fully qualified domain name from name.\r
-\r
- An empty argument is interpreted as meaning the local host.\r
-\r
- First the hostname returned by gethostbyaddr() is checked, then\r
- possibly existing aliases. In case no FQDN is available, hostname\r
- from gethostname() is returned.\r
- """\r
- name = name.strip()\r
- if not name or name == '0.0.0.0':\r
- name = gethostname()\r
- try:\r
- hostname, aliases, ipaddrs = gethostbyaddr(name)\r
- except error:\r
- pass\r
- else:\r
- aliases.insert(0, hostname)\r
- for name in aliases:\r
- if '.' in name:\r
- break\r
- else:\r
- name = hostname\r
- return name\r
-\r
-\r
-_socketmethods = (\r
- 'bind', 'connect', 'connect_ex', 'fileno', 'listen',\r
- 'getpeername', 'getsockname', 'getsockopt', 'setsockopt',\r
- 'sendall', 'setblocking',\r
- 'settimeout', 'gettimeout', 'shutdown')\r
-\r
-if os.name == "nt":\r
- _socketmethods = _socketmethods + ('ioctl',)\r
-\r
-if sys.platform == "riscos":\r
- _socketmethods = _socketmethods + ('sleeptaskw',)\r
-\r
-# All the method names that must be delegated to either the real socket\r
-# object or the _closedsocket object.\r
-_delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",\r
- "send", "sendto")\r
-\r
-class _closedsocket(object):\r
- __slots__ = []\r
- def _dummy(*args):\r
- raise error(EBADF, 'Bad file descriptor')\r
- # All _delegate_methods must also be initialized here.\r
- send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy\r
- __getattr__ = _dummy\r
-\r
-# Wrapper around platform socket objects. This implements\r
-# a platform-independent dup() functionality. The\r
-# implementation currently relies on reference counting\r
-# to close the underlying socket object.\r
-class _socketobject(object):\r
-\r
- __doc__ = _realsocket.__doc__\r
-\r
- __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)\r
-\r
- def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):\r
- if _sock is None:\r
- _sock = _realsocket(family, type, proto)\r
- self._sock = _sock\r
- for method in _delegate_methods:\r
- setattr(self, method, getattr(_sock, method))\r
-\r
- def close(self, _closedsocket=_closedsocket,\r
- _delegate_methods=_delegate_methods, setattr=setattr):\r
- # This function should not reference any globals. See issue #808164.\r
- self._sock = _closedsocket()\r
- dummy = self._sock._dummy\r
- for method in _delegate_methods:\r
- setattr(self, method, dummy)\r
- close.__doc__ = _realsocket.close.__doc__\r
-\r
- def accept(self):\r
- sock, addr = self._sock.accept()\r
- return _socketobject(_sock=sock), addr\r
- accept.__doc__ = _realsocket.accept.__doc__\r
-\r
- def dup(self):\r
- """dup() -> socket object\r
-\r
- Return a new socket object connected to the same system resource."""\r
- return _socketobject(_sock=self._sock)\r
-\r
- def makefile(self, mode='r', bufsize=-1):\r
- """makefile([mode[, bufsize]]) -> file object\r
-\r
- Return a regular file object corresponding to the socket. The mode\r
- and bufsize arguments are as for the built-in open() function."""\r
- return _fileobject(self._sock, mode, bufsize)\r
-\r
- family = property(lambda self: self._sock.family, doc="the socket family")\r
- type = property(lambda self: self._sock.type, doc="the socket type")\r
- proto = property(lambda self: self._sock.proto, doc="the socket protocol")\r
-\r
-def meth(name,self,*args):\r
- return getattr(self._sock,name)(*args)\r
-\r
-for _m in _socketmethods:\r
- p = partial(meth,_m)\r
- p.__name__ = _m\r
- p.__doc__ = getattr(_realsocket,_m).__doc__\r
- m = MethodType(p,None,_socketobject)\r
- setattr(_socketobject,_m,m)\r
-\r
-socket = SocketType = _socketobject\r
-\r
-class _fileobject(object):\r
- """Faux file object attached to a socket object."""\r
-\r
- default_bufsize = 8192\r
- name = "<socket>"\r
-\r
- __slots__ = ["mode", "bufsize", "softspace",\r
- # "closed" is a property, see below\r
- "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", "_wbuf_len",\r
- "_close"]\r
-\r
- def __init__(self, sock, mode='rb', bufsize=-1, close=False):\r
- self._sock = sock\r
- self.mode = mode # Not actually used in this version\r
- if bufsize < 0:\r
- bufsize = self.default_bufsize\r
- self.bufsize = bufsize\r
- self.softspace = False\r
- # _rbufsize is the suggested recv buffer size. It is *strictly*\r
- # obeyed within readline() for recv calls. If it is larger than\r
- # default_bufsize it will be used for recv calls within read().\r
- if bufsize == 0:\r
- self._rbufsize = 1\r
- elif bufsize == 1:\r
- self._rbufsize = self.default_bufsize\r
- else:\r
- self._rbufsize = bufsize\r
- self._wbufsize = bufsize\r
- # We use StringIO for the read buffer to avoid holding a list\r
- # of variously sized string objects which have been known to\r
- # fragment the heap due to how they are malloc()ed and often\r
- # realloc()ed down much smaller than their original allocation.\r
- self._rbuf = StringIO()\r
- self._wbuf = [] # A list of strings\r
- self._wbuf_len = 0\r
- self._close = close\r
-\r
- def _getclosed(self):\r
- return self._sock is None\r
- closed = property(_getclosed, doc="True if the file is closed")\r
-\r
- def close(self):\r
- try:\r
- if self._sock:\r
- self.flush()\r
- finally:\r
- if self._close:\r
- self._sock.close()\r
- self._sock = None\r
-\r
- def __del__(self):\r
- try:\r
- self.close()\r
- except:\r
- # close() may fail if __init__ didn't complete\r
- pass\r
-\r
- def flush(self):\r
- if self._wbuf:\r
- data = "".join(self._wbuf)\r
- self._wbuf = []\r
- self._wbuf_len = 0\r
- buffer_size = max(self._rbufsize, self.default_bufsize)\r
- data_size = len(data)\r
- write_offset = 0\r
- view = memoryview(data)\r
- try:\r
- while write_offset < data_size:\r
- self._sock.sendall(view[write_offset:write_offset+buffer_size])\r
- write_offset += buffer_size\r
- finally:\r
- if write_offset < data_size:\r
- remainder = data[write_offset:]\r
- del view, data # explicit free\r
- self._wbuf.append(remainder)\r
- self._wbuf_len = len(remainder)\r
-\r
- def fileno(self):\r
- return self._sock.fileno()\r
-\r
- def write(self, data):\r
- data = str(data) # XXX Should really reject non-string non-buffers\r
- if not data:\r
- return\r
- self._wbuf.append(data)\r
- self._wbuf_len += len(data)\r
- if (self._wbufsize == 0 or\r
- self._wbufsize == 1 and '\n' in data or\r
- self._wbuf_len >= self._wbufsize):\r
- self.flush()\r
-\r
- def writelines(self, list):\r
- # XXX We could do better here for very long lists\r
- # XXX Should really reject non-string non-buffers\r
- lines = filter(None, map(str, list))\r
- self._wbuf_len += sum(map(len, lines))\r
- self._wbuf.extend(lines)\r
- if (self._wbufsize <= 1 or\r
- self._wbuf_len >= self._wbufsize):\r
- self.flush()\r
-\r
- def read(self, size=-1):\r
- # Use max, disallow tiny reads in a loop as they are very inefficient.\r
- # We never leave read() with any leftover data from a new recv() call\r
- # in our internal buffer.\r
- rbufsize = max(self._rbufsize, self.default_bufsize)\r
- # Our use of StringIO rather than lists of string objects returned by\r
- # recv() minimizes memory usage and fragmentation that occurs when\r
- # rbufsize is large compared to the typical return value of recv().\r
- buf = self._rbuf\r
- buf.seek(0, 2) # seek end\r
- if size < 0:\r
- # Read until EOF\r
- self._rbuf = StringIO() # reset _rbuf. we consume it via buf.\r
- while True:\r
- try:\r
- data = self._sock.recv(rbufsize)\r
- except error, e:\r
- if e.args[0] == EINTR:\r
- continue\r
- raise\r
- if not data:\r
- break\r
- buf.write(data)\r
- return buf.getvalue()\r
- else:\r
- # Read until size bytes or EOF seen, whichever comes first\r
- buf_len = buf.tell()\r
- if buf_len >= size:\r
- # Already have size bytes in our buffer? Extract and return.\r
- buf.seek(0)\r
- rv = buf.read(size)\r
- self._rbuf = StringIO()\r
- self._rbuf.write(buf.read())\r
- return rv\r
-\r
- self._rbuf = StringIO() # reset _rbuf. we consume it via buf.\r
- while True:\r
- left = size - buf_len\r
- # recv() will malloc the amount of memory given as its\r
- # parameter even though it often returns much less data\r
- # than that. The returned data string is short lived\r
- # as we copy it into a StringIO and free it. This avoids\r
- # fragmentation issues on many platforms.\r
- try:\r
- data = self._sock.recv(left)\r
- except error, e:\r
- if e.args[0] == EINTR:\r
- continue\r
- raise\r
- if not data:\r
- break\r
- n = len(data)\r
- if n == size and not buf_len:\r
- # Shortcut. Avoid buffer data copies when:\r
- # - We have no data in our buffer.\r
- # AND\r
- # - Our call to recv returned exactly the\r
- # number of bytes we were asked to read.\r
- return data\r
- if n == left:\r
- buf.write(data)\r
- del data # explicit free\r
- break\r
- assert n <= left, "recv(%d) returned %d bytes" % (left, n)\r
- buf.write(data)\r
- buf_len += n\r
- del data # explicit free\r
- #assert buf_len == buf.tell()\r
- return buf.getvalue()\r
-\r
- def readline(self, size=-1):\r
- buf = self._rbuf\r
- buf.seek(0, 2) # seek end\r
- if buf.tell() > 0:\r
- # check if we already have it in our buffer\r
- buf.seek(0)\r
- bline = buf.readline(size)\r
- if bline.endswith('\n') or len(bline) == size:\r
- self._rbuf = StringIO()\r
- self._rbuf.write(buf.read())\r
- return bline\r
- del bline\r
- if size < 0:\r
- # Read until \n or EOF, whichever comes first\r
- if self._rbufsize <= 1:\r
- # Speed up unbuffered case\r
- buf.seek(0)\r
- buffers = [buf.read()]\r
- self._rbuf = StringIO() # reset _rbuf. we consume it via buf.\r
- data = None\r
- recv = self._sock.recv\r
- while True:\r
- try:\r
- while data != "\n":\r
- data = recv(1)\r
- if not data:\r
- break\r
- buffers.append(data)\r
- except error, e:\r
- # The try..except to catch EINTR was moved outside the\r
- # recv loop to avoid the per byte overhead.\r
- if e.args[0] == EINTR:\r
- continue\r
- raise\r
- break\r
- return "".join(buffers)\r
-\r
- buf.seek(0, 2) # seek end\r
- self._rbuf = StringIO() # reset _rbuf. we consume it via buf.\r
- while True:\r
- try:\r
- data = self._sock.recv(self._rbufsize)\r
- except error, e:\r
- if e.args[0] == EINTR:\r
- continue\r
- raise\r
- if not data:\r
- break\r
- nl = data.find('\n')\r
- if nl >= 0:\r
- nl += 1\r
- buf.write(data[:nl])\r
- self._rbuf.write(data[nl:])\r
- del data\r
- break\r
- buf.write(data)\r
- return buf.getvalue()\r
- else:\r
- # Read until size bytes or \n or EOF seen, whichever comes first\r
- buf.seek(0, 2) # seek end\r
- buf_len = buf.tell()\r
- if buf_len >= size:\r
- buf.seek(0)\r
- rv = buf.read(size)\r
- self._rbuf = StringIO()\r
- self._rbuf.write(buf.read())\r
- return rv\r
- self._rbuf = StringIO() # reset _rbuf. we consume it via buf.\r
- while True:\r
- try:\r
- data = self._sock.recv(self._rbufsize)\r
- except error, e:\r
- if e.args[0] == EINTR:\r
- continue\r
- raise\r
- if not data:\r
- break\r
- left = size - buf_len\r
- # did we just receive a newline?\r
- nl = data.find('\n', 0, left)\r
- if nl >= 0:\r
- nl += 1\r
- # save the excess data to _rbuf\r
- self._rbuf.write(data[nl:])\r
- if buf_len:\r
- buf.write(data[:nl])\r
- break\r
- else:\r
- # Shortcut. Avoid data copy through buf when returning\r
- # a substring of our first recv().\r
- return data[:nl]\r
- n = len(data)\r
- if n == size and not buf_len:\r
- # Shortcut. Avoid data copy through buf when\r
- # returning exactly all of our first recv().\r
- return data\r
- if n >= left:\r
- buf.write(data[:left])\r
- self._rbuf.write(data[left:])\r
- break\r
- buf.write(data)\r
- buf_len += n\r
- #assert buf_len == buf.tell()\r
- return buf.getvalue()\r
-\r
- def readlines(self, sizehint=0):\r
- total = 0\r
- list = []\r
- while True:\r
- line = self.readline()\r
- if not line:\r
- break\r
- list.append(line)\r
- total += len(line)\r
- if sizehint and total >= sizehint:\r
- break\r
- return list\r
-\r
- # Iterator protocols\r
-\r
- def __iter__(self):\r
- return self\r
-\r
- def next(self):\r
- line = self.readline()\r
- if not line:\r
- raise StopIteration\r
- return line\r
-\r
-_GLOBAL_DEFAULT_TIMEOUT = object()\r
-\r
-def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,\r
- source_address=None):\r
- """Connect to *address* and return the socket object.\r
-\r
- Convenience function. Connect to *address* (a 2-tuple ``(host,\r
- port)``) and return the socket object. Passing the optional\r
- *timeout* parameter will set the timeout on the socket instance\r
- before attempting to connect. If no *timeout* is supplied, the\r
- global default timeout setting returned by :func:`getdefaulttimeout`\r
- is used. If *source_address* is set it must be a tuple of (host, port)\r
- for the socket to bind as a source address before making the connection.\r
- An host of '' or port 0 tells the OS to use the default.\r
- """\r
-\r
- host, port = address\r
- err = None\r
- for res in getaddrinfo(host, port, 0, SOCK_STREAM):\r
- af, socktype, proto, canonname, sa = res\r
- sock = None\r
- try:\r
- sock = socket(af, socktype, proto)\r
- if timeout is not _GLOBAL_DEFAULT_TIMEOUT:\r
- sock.settimeout(timeout)\r
- if source_address:\r
- sock.bind(source_address)\r
- sock.connect(sa)\r
- return sock\r
-\r
- except error as _:\r
- err = _\r
- if sock is not None:\r
- sock.close()\r
-\r
- if err is not None:\r
- raise err\r
- else:\r
- raise error("getaddrinfo returns an empty list")\r
projects / mirror_edk2.git / blobdiff