AppPkg/Applications/Python/Python-2.7.10/Lib/socket.py

   1 # Wrapper module for _socket, providing some additional facilities
   2 # implemented in Python.
   3
   4 """\
   5 This module provides socket operations and some related functions.
   6 On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
   7 On other systems, it only supports IP. Functions specific for a
   8 socket are available as methods of the socket object.
   9
  10 Functions:
  11
  12 socket() -- create a new socket object
  13 socketpair() -- create a pair of new socket objects [*]
  14 fromfd() -- create a socket object from an open file descriptor [*]
  15 gethostname() -- return the current hostname
  16 gethostbyname() -- map a hostname to its IP number
  17 gethostbyaddr() -- map an IP number or hostname to DNS info
  18 getservbyname() -- map a service name and a protocol name to a port number
  19 getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
  20 ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  21 htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  22 inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  23 inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  24 ssl() -- secure socket layer support (only available if configured)
  25 socket.getdefaulttimeout() -- get the default timeout value
  26 socket.setdefaulttimeout() -- set the default timeout value
  27 create_connection() -- connects to an address, with an optional timeout and
  28                        optional source address.
  29
  30  [*] not available on all platforms!
  31
  32 Special objects:
  33
  34 SocketType -- type object for socket objects
  35 error -- exception raised for I/O errors
  36 has_ipv6 -- boolean value indicating if IPv6 is supported
  37
  38 Integer constants:
  39
  40 AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  41 SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  42
  43 Many other constants may be defined; these may be used in calls to
  44 the setsockopt() and getsockopt() methods.
  45 """
  46
  47 import _socket
  48 from _socket import *
  49 from functools import partial
  50 from types import MethodType
  51
  52 try:
  53     import _ssl
  54 except ImportError:
  55     # no SSL support
  56     pass
  57 else:
  58     def ssl(sock, keyfile=None, certfile=None):
  59         # we do an internal import here because the ssl
  60         # module imports the socket module
  61         import ssl as _realssl
  62         warnings.warn("socket.ssl() is deprecated.  Use ssl.wrap_socket() instead.",
  63                       DeprecationWarning, stacklevel=2)
  64         return _realssl.sslwrap_simple(sock, keyfile, certfile)
  65
  66     # we need to import the same constants we used to...
  67     from _ssl import SSLError as sslerror
  68     from _ssl import \
  69          RAND_add, \
  70          RAND_status, \
  71          SSL_ERROR_ZERO_RETURN, \
  72          SSL_ERROR_WANT_READ, \
  73          SSL_ERROR_WANT_WRITE, \
  74          SSL_ERROR_WANT_X509_LOOKUP, \
  75          SSL_ERROR_SYSCALL, \
  76          SSL_ERROR_SSL, \
  77          SSL_ERROR_WANT_CONNECT, \
  78          SSL_ERROR_EOF, \
  79          SSL_ERROR_INVALID_ERROR_CODE
  80     try:
  81         from _ssl import RAND_egd
  82     except ImportError:
  83         # LibreSSL does not provide RAND_egd
  84         pass
  85
  86 import os, sys, warnings
  87
  88 try:
  89     from cStringIO import StringIO
  90 except ImportError:
  91     from StringIO import StringIO
  92
  93 try:
  94     import errno
  95 except ImportError:
  96     errno = None
  97 EBADF = getattr(errno, 'EBADF', 9)
  98 EINTR = getattr(errno, 'EINTR', 4)
  99
 100 __all__ = ["getfqdn", "create_connection"]
 101 __all__.extend(os._get_exports_list(_socket))
 102
 103
 104 _realsocket = socket
 105
 106 # WSA error codes
 107 if sys.platform.lower().startswith("win"):
 108     errorTab = {}
 109     errorTab[10004] = "The operation was interrupted."
 110     errorTab[10009] = "A bad file handle was passed."
 111     errorTab[10013] = "Permission denied."
 112     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
 113     errorTab[10022] = "An invalid operation was attempted."
 114     errorTab[10035] = "The socket operation would block"
 115     errorTab[10036] = "A blocking operation is already in progress."
 116     errorTab[10048] = "The network address is in use."
 117     errorTab[10054] = "The connection has been reset."
 118     errorTab[10058] = "The network has been shut down."
 119     errorTab[10060] = "The operation timed out."
 120     errorTab[10061] = "Connection refused."
 121     errorTab[10063] = "The name is too long."
 122     errorTab[10064] = "The host is down."
 123     errorTab[10065] = "The host is unreachable."
 124     __all__.append("errorTab")
 125
 126
 127
 128 def getfqdn(name=''):
 129     """Get fully qualified domain name from name.
 130
 131     An empty argument is interpreted as meaning the local host.
 132
 133     First the hostname returned by gethostbyaddr() is checked, then
 134     possibly existing aliases. In case no FQDN is available, hostname
 135     from gethostname() is returned.
 136     """
 137     name = name.strip()
 138     if not name or name == '0.0.0.0':
 139         name = gethostname()
 140     try:
 141         hostname, aliases, ipaddrs = gethostbyaddr(name)
 142     except error:
 143         pass
 144     else:
 145         aliases.insert(0, hostname)
 146         for name in aliases:
 147             if '.' in name:
 148                 break
 149         else:
 150             name = hostname
 151     return name
 152
 153
 154 _socketmethods = (
 155     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
 156     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
 157     'sendall', 'setblocking',
 158     'settimeout', 'gettimeout', 'shutdown')
 159
 160 if os.name == "nt":
 161     _socketmethods = _socketmethods + ('ioctl',)
 162
 163 if sys.platform == "riscos":
 164     _socketmethods = _socketmethods + ('sleeptaskw',)
 165
 166 # All the method names that must be delegated to either the real socket
 167 # object or the _closedsocket object.
 168 _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",
 169                      "send", "sendto")
 170
 171 class _closedsocket(object):
 172     __slots__ = []
 173     def _dummy(*args):
 174         raise error(EBADF, 'Bad file descriptor')
 175     # All _delegate_methods must also be initialized here.
 176     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
 177     __getattr__ = _dummy
 178
 179 # Wrapper around platform socket objects. This implements
 180 # a platform-independent dup() functionality. The
 181 # implementation currently relies on reference counting
 182 # to close the underlying socket object.
 183 class _socketobject(object):
 184
 185     __doc__ = _realsocket.__doc__
 186
 187     __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
 188
 189     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
 190         if _sock is None:
 191             _sock = _realsocket(family, type, proto)
 192         self._sock = _sock
 193         for method in _delegate_methods:
 194             setattr(self, method, getattr(_sock, method))
 195
 196     def close(self, _closedsocket=_closedsocket,
 197               _delegate_methods=_delegate_methods, setattr=setattr):
 198         # This function should not reference any globals. See issue #808164.
 199         self._sock = _closedsocket()
 200         dummy = self._sock._dummy
 201         for method in _delegate_methods:
 202             setattr(self, method, dummy)
 203     close.__doc__ = _realsocket.close.__doc__
 204
 205     def accept(self):
 206         sock, addr = self._sock.accept()
 207         return _socketobject(_sock=sock), addr
 208     accept.__doc__ = _realsocket.accept.__doc__
 209
 210     def dup(self):
 211         """dup() -> socket object
 212
 213         Return a new socket object connected to the same system resource."""
 214         return _socketobject(_sock=self._sock)
 215
 216     def makefile(self, mode='r', bufsize=-1):
 217         """makefile([mode[, bufsize]]) -> file object
 218
 219         Return a regular file object corresponding to the socket.  The mode
 220         and bufsize arguments are as for the built-in open() function."""
 221         return _fileobject(self._sock, mode, bufsize)
 222
 223     family = property(lambda self: self._sock.family, doc="the socket family")
 224     type = property(lambda self: self._sock.type, doc="the socket type")
 225     proto = property(lambda self: self._sock.proto, doc="the socket protocol")
 226
 227 def meth(name,self,*args):
 228     return getattr(self._sock,name)(*args)
 229
 230 for _m in _socketmethods:
 231     p = partial(meth,_m)
 232     p.__name__ = _m
 233     p.__doc__ = getattr(_realsocket,_m).__doc__
 234     m = MethodType(p,None,_socketobject)
 235     setattr(_socketobject,_m,m)
 236
 237 socket = SocketType = _socketobject
 238
 239 class _fileobject(object):
 240     """Faux file object attached to a socket object."""
 241
 242     default_bufsize = 8192
 243     name = "<socket>"
 244
 245     __slots__ = ["mode", "bufsize", "softspace",
 246                  # "closed" is a property, see below
 247                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", "_wbuf_len",
 248                  "_close"]
 249
 250     def __init__(self, sock, mode='rb', bufsize=-1, close=False):
 251         self._sock = sock
 252         self.mode = mode # Not actually used in this version
 253         if bufsize < 0:
 254             bufsize = self.default_bufsize
 255         self.bufsize = bufsize
 256         self.softspace = False
 257         # _rbufsize is the suggested recv buffer size.  It is *strictly*
 258         # obeyed within readline() for recv calls.  If it is larger than
 259         # default_bufsize it will be used for recv calls within read().
 260         if bufsize == 0:
 261             self._rbufsize = 1
 262         elif bufsize == 1:
 263             self._rbufsize = self.default_bufsize
 264         else:
 265             self._rbufsize = bufsize
 266         self._wbufsize = bufsize
 267         # We use StringIO for the read buffer to avoid holding a list
 268         # of variously sized string objects which have been known to
 269         # fragment the heap due to how they are malloc()ed and often
 270         # realloc()ed down much smaller than their original allocation.
 271         self._rbuf = StringIO()
 272         self._wbuf = [] # A list of strings
 273         self._wbuf_len = 0
 274         self._close = close
 275
 276     def _getclosed(self):
 277         return self._sock is None
 278     closed = property(_getclosed, doc="True if the file is closed")
 279
 280     def close(self):
 281         try:
 282             if self._sock:
 283                 self.flush()
 284         finally:
 285             if self._close:
 286                 self._sock.close()
 287             self._sock = None
 288
 289     def __del__(self):
 290         try:
 291             self.close()
 292         except:
 293             # close() may fail if __init__ didn't complete
 294             pass
 295
 296     def flush(self):
 297         if self._wbuf:
 298             data = "".join(self._wbuf)
 299             self._wbuf = []
 300             self._wbuf_len = 0
 301             buffer_size = max(self._rbufsize, self.default_bufsize)
 302             data_size = len(data)
 303             write_offset = 0
 304             view = memoryview(data)
 305             try:
 306                 while write_offset < data_size:
 307                     self._sock.sendall(view[write_offset:write_offset+buffer_size])
 308                     write_offset += buffer_size
 309             finally:
 310                 if write_offset < data_size:
 311                     remainder = data[write_offset:]
 312                     del view, data  # explicit free
 313                     self._wbuf.append(remainder)
 314                     self._wbuf_len = len(remainder)
 315
 316     def fileno(self):
 317         return self._sock.fileno()
 318
 319     def write(self, data):
 320         data = str(data) # XXX Should really reject non-string non-buffers
 321         if not data:
 322             return
 323         self._wbuf.append(data)
 324         self._wbuf_len += len(data)
 325         if (self._wbufsize == 0 or
 326             (self._wbufsize == 1 and '\n' in data) or
 327             (self._wbufsize > 1 and self._wbuf_len >= self._wbufsize)):
 328             self.flush()
 329
 330     def writelines(self, list):
 331         # XXX We could do better here for very long lists
 332         # XXX Should really reject non-string non-buffers
 333         lines = filter(None, map(str, list))
 334         self._wbuf_len += sum(map(len, lines))
 335         self._wbuf.extend(lines)
 336         if (self._wbufsize <= 1 or
 337             self._wbuf_len >= self._wbufsize):
 338             self.flush()
 339
 340     def read(self, size=-1):
 341         # Use max, disallow tiny reads in a loop as they are very inefficient.
 342         # We never leave read() with any leftover data from a new recv() call
 343         # in our internal buffer.
 344         rbufsize = max(self._rbufsize, self.default_bufsize)
 345         # Our use of StringIO rather than lists of string objects returned by
 346         # recv() minimizes memory usage and fragmentation that occurs when
 347         # rbufsize is large compared to the typical return value of recv().
 348         buf = self._rbuf
 349         buf.seek(0, 2)  # seek end
 350         if size < 0:
 351             # Read until EOF
 352             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
 353             while True:
 354                 try:
 355                     data = self._sock.recv(rbufsize)
 356                 except error, e:
 357                     if e.args[0] == EINTR:
 358                         continue
 359                     raise
 360                 if not data:
 361                     break
 362                 buf.write(data)
 363             return buf.getvalue()
 364         else:
 365             # Read until size bytes or EOF seen, whichever comes first
 366             buf_len = buf.tell()
 367             if buf_len >= size:
 368                 # Already have size bytes in our buffer?  Extract and return.
 369                 buf.seek(0)
 370                 rv = buf.read(size)
 371                 self._rbuf = StringIO()
 372                 self._rbuf.write(buf.read())
 373                 return rv
 374
 375             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
 376             while True:
 377                 left = size - buf_len
 378                 # recv() will malloc the amount of memory given as its
 379                 # parameter even though it often returns much less data
 380                 # than that.  The returned data string is short lived
 381                 # as we copy it into a StringIO and free it.  This avoids
 382                 # fragmentation issues on many platforms.
 383                 try:
 384                     data = self._sock.recv(left)
 385                 except error, e:
 386                     if e.args[0] == EINTR:
 387                         continue
 388                     raise
 389                 if not data:
 390                     break
 391                 n = len(data)
 392                 if n == size and not buf_len:
 393                     # Shortcut.  Avoid buffer data copies when:
 394                     # - We have no data in our buffer.
 395                     # AND
 396                     # - Our call to recv returned exactly the
 397                     #   number of bytes we were asked to read.
 398                     return data
 399                 if n == left:
 400                     buf.write(data)
 401                     del data  # explicit free
 402                     break
 403                 assert n <= left, "recv(%d) returned %d bytes" % (left, n)
 404                 buf.write(data)
 405                 buf_len += n
 406                 del data  # explicit free
 407                 #assert buf_len == buf.tell()
 408             return buf.getvalue()
 409
 410     def readline(self, size=-1):
 411         buf = self._rbuf
 412         buf.seek(0, 2)  # seek end
 413         if buf.tell() > 0:
 414             # check if we already have it in our buffer
 415             buf.seek(0)
 416             bline = buf.readline(size)
 417             if bline.endswith('\n') or len(bline) == size:
 418                 self._rbuf = StringIO()
 419                 self._rbuf.write(buf.read())
 420                 return bline
 421             del bline
 422         if size < 0:
 423             # Read until \n or EOF, whichever comes first
 424             if self._rbufsize <= 1:
 425                 # Speed up unbuffered case
 426                 buf.seek(0)
 427                 buffers = [buf.read()]
 428                 self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
 429                 data = None
 430                 recv = self._sock.recv
 431                 while True:
 432                     try:
 433                         while data != "\n":
 434                             data = recv(1)
 435                             if not data:
 436                                 break
 437                             buffers.append(data)
 438                     except error, e:
 439                         # The try..except to catch EINTR was moved outside the
 440                         # recv loop to avoid the per byte overhead.
 441                         if e.args[0] == EINTR:
 442                             continue
 443                         raise
 444                     break
 445                 return "".join(buffers)
 446
 447             buf.seek(0, 2)  # seek end
 448             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
 449             while True:
 450                 try:
 451                     data = self._sock.recv(self._rbufsize)
 452                 except error, e:
 453                     if e.args[0] == EINTR:
 454                         continue
 455                     raise
 456                 if not data:
 457                     break
 458                 nl = data.find('\n')
 459                 if nl >= 0:
 460                     nl += 1
 461                     buf.write(data[:nl])
 462                     self._rbuf.write(data[nl:])
 463                     del data
 464                     break
 465                 buf.write(data)
 466             return buf.getvalue()
 467         else:
 468             # Read until size bytes or \n or EOF seen, whichever comes first
 469             buf.seek(0, 2)  # seek end
 470             buf_len = buf.tell()
 471             if buf_len >= size:
 472                 buf.seek(0)
 473                 rv = buf.read(size)
 474                 self._rbuf = StringIO()
 475                 self._rbuf.write(buf.read())
 476                 return rv
 477             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.
 478             while True:
 479                 try:
 480                     data = self._sock.recv(self._rbufsize)
 481                 except error, e:
 482                     if e.args[0] == EINTR:
 483                         continue
 484                     raise
 485                 if not data:
 486                     break
 487                 left = size - buf_len
 488                 # did we just receive a newline?
 489                 nl = data.find('\n', 0, left)
 490                 if nl >= 0:
 491                     nl += 1
 492                     # save the excess data to _rbuf
 493                     self._rbuf.write(data[nl:])
 494                     if buf_len:
 495                         buf.write(data[:nl])
 496                         break
 497                     else:
 498                         # Shortcut.  Avoid data copy through buf when returning
 499                         # a substring of our first recv().
 500                         return data[:nl]
 501                 n = len(data)
 502                 if n == size and not buf_len:
 503                     # Shortcut.  Avoid data copy through buf when
 504                     # returning exactly all of our first recv().
 505                     return data
 506                 if n >= left:
 507                     buf.write(data[:left])
 508                     self._rbuf.write(data[left:])
 509                     break
 510                 buf.write(data)
 511                 buf_len += n
 512                 #assert buf_len == buf.tell()
 513             return buf.getvalue()
 514
 515     def readlines(self, sizehint=0):
 516         total = 0
 517         list = []
 518         while True:
 519             line = self.readline()
 520             if not line:
 521                 break
 522             list.append(line)
 523             total += len(line)
 524             if sizehint and total >= sizehint:
 525                 break
 526         return list
 527
 528     # Iterator protocols
 529
 530     def __iter__(self):
 531         return self
 532
 533     def next(self):
 534         line = self.readline()
 535         if not line:
 536             raise StopIteration
 537         return line
 538
 539 _GLOBAL_DEFAULT_TIMEOUT = object()
 540
 541 def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
 542                       source_address=None):
 543     """Connect to *address* and return the socket object.
 544
 545     Convenience function.  Connect to *address* (a 2-tuple ``(host,
 546     port)``) and return the socket object.  Passing the optional
 547     *timeout* parameter will set the timeout on the socket instance
 548     before attempting to connect.  If no *timeout* is supplied, the
 549     global default timeout setting returned by :func:`getdefaulttimeout`
 550     is used.  If *source_address* is set it must be a tuple of (host, port)
 551     for the socket to bind as a source address before making the connection.
 552     An host of '' or port 0 tells the OS to use the default.
 553     """
 554
 555     host, port = address
 556     err = None
 557     for res in getaddrinfo(host, port, 0, SOCK_STREAM):
 558         af, socktype, proto, canonname, sa = res
 559         sock = None
 560         try:
 561             sock = socket(af, socktype, proto)
 562             if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
 563                 sock.settimeout(timeout)
 564             if source_address:
 565                 sock.bind(source_address)
 566             sock.connect(sa)
 567             return sock
 568
 569         except error as _:
 570             err = _
 571             if sock is not None:
 572                 sock.close()
 573
 574     if err is not None:
 575         raise err
 576     else:
 577         raise error("getaddrinfo returns an empty list")