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() -- mape 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

    28 

    29  [*] not available on all platforms!

    30 

    31 Special objects:

    32 

    33 SocketType -- type object for socket objects

    34 error -- exception raised for I/O errors

    35 has_ipv6 -- boolean value indicating if IPv6 is supported

    36 

    37 Integer constants:

    38 

    39 AF_INET, AF_UNIX -- socket domains (first argument to socket() call)

    40 SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)

    41 

    42 Many other constants may be defined; these may be used in calls to

    43 the setsockopt() and getsockopt() methods.

    44 """

    45 

    46 import _socket

    47 from _socket import *

    48 

    49 try:

    50     import _ssl

    51 except ImportError:

    52     # no SSL support

    53     pass

    54 else:

    55     def ssl(sock, keyfile=None, certfile=None):

    56         # we do an internal import here because the ssl

    57         # module imports the socket module

    58         import ssl as _realssl

    59         warnings.warn("socket.ssl() is deprecated.  Use ssl.wrap_socket() instead.",

    60                       DeprecationWarning, stacklevel=2)

    61         return _realssl.sslwrap_simple(sock, keyfile, certfile)

    62 

    63     # we need to import the same constants we used to...

    64     from _ssl import SSLError as sslerror

    65     from _ssl import \

    66          RAND_add, \

    67          RAND_egd, \

    68          RAND_status, \

    69          SSL_ERROR_ZERO_RETURN, \

    70          SSL_ERROR_WANT_READ, \

    71          SSL_ERROR_WANT_WRITE, \

    72          SSL_ERROR_WANT_X509_LOOKUP, \

    73          SSL_ERROR_SYSCALL, \

    74          SSL_ERROR_SSL, \

    75          SSL_ERROR_WANT_CONNECT, \

    76          SSL_ERROR_EOF, \

    77          SSL_ERROR_INVALID_ERROR_CODE

    78 

    79 import os, sys, warnings

    80 

    81 try:

    82     from cStringIO import StringIO

    83 except ImportError:

    84     from StringIO import StringIO

    85 

    86 try:

    87     from errno import EBADF

    88 except ImportError:

    89     EBADF = 9

    90 

    91 __all__ = ["getfqdn"]

    92 __all__.extend(os._get_exports_list(_socket))

    93 

    94 

    95 _realsocket = socket

    96 

    97 # WSA error codes

    98 if sys.platform.lower().startswith("win"):

    99     errorTab = {}

   100     errorTab[10004] = "The operation was interrupted."

   101     errorTab[10009] = "A bad file handle was passed."

   102     errorTab[10013] = "Permission denied."

   103     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT

   104     errorTab[10022] = "An invalid operation was attempted."

   105     errorTab[10035] = "The socket operation would block"

   106     errorTab[10036] = "A blocking operation is already in progress."

   107     errorTab[10048] = "The network address is in use."

   108     errorTab[10054] = "The connection has been reset."

   109     errorTab[10058] = "The network has been shut down."

   110     errorTab[10060] = "The operation timed out."

   111     errorTab[10061] = "Connection refused."

   112     errorTab[10063] = "The name is too long."

   113     errorTab[10064] = "The host is down."

   114     errorTab[10065] = "The host is unreachable."

   115     __all__.append("errorTab")

   116 

   117 

   118 

   119 def getfqdn(name=''):

   120     """Get fully qualified domain name from name.

   121 

   122     An empty argument is interpreted as meaning the local host.

   123 

   124     First the hostname returned by gethostbyaddr() is checked, then

   125     possibly existing aliases. In case no FQDN is available, hostname

   126     from gethostname() is returned.

   127     """

   128     name = name.strip()

   129     if not name or name == '0.0.0.0':

   130         name = gethostname()

   131     try:

   132         hostname, aliases, ipaddrs = gethostbyaddr(name)

   133     except error:

   134         pass

   135     else:

   136         aliases.insert(0, hostname)

   137         for name in aliases:

   138             if '.' in name:

   139                 break

   140         else:

   141             name = hostname

   142     return name

   143 

   144 

   145 _socketmethods = (

   146     'bind', 'connect', 'connect_ex', 'fileno', 'listen',

   147     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',

   148     'sendall', 'setblocking',

   149     'settimeout', 'gettimeout', 'shutdown')

   150 

   151 if os.name == "nt":

   152     _socketmethods = _socketmethods + ('ioctl',)

   153 

   154 if sys.platform == "riscos":

   155     _socketmethods = _socketmethods + ('sleeptaskw',)

   156 

   157 # All the method names that must be delegated to either the real socket

   158 # object or the _closedsocket object.

   159 _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",

   160                      "send", "sendto")

   161 

   162 class _closedsocket(object):

   163     __slots__ = []

   164     def _dummy(*args):

   165         raise error(EBADF, 'Bad file descriptor')

   166     # All _delegate_methods must also be initialized here.

   167     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy

   168     __getattr__ = _dummy

   169 

   170 # Wrapper around platform socket objects. This implements

   171 # a platform-independent dup() functionality. The

   172 # implementation currently relies on reference counting

   173 # to close the underlying socket object.

   174 class _socketobject(object):

   175 

   176     __doc__ = _realsocket.__doc__

   177 

   178     __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)

   179 

   180     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):

   181         if _sock is None:

   182             _sock = _realsocket(family, type, proto)

   183         self._sock = _sock

   184         for method in _delegate_methods:

   185             setattr(self, method, getattr(_sock, method))

   186 

   187     def close(self):

   188         self._sock = _closedsocket()

   189         dummy = self._sock._dummy

   190         for method in _delegate_methods:

   191             setattr(self, method, dummy)

   192     close.__doc__ = _realsocket.close.__doc__

   193 

   194     def accept(self):

   195         sock, addr = self._sock.accept()

   196         return _socketobject(_sock=sock), addr

   197     accept.__doc__ = _realsocket.accept.__doc__

   198 

   199     def dup(self):

   200         """dup() -> socket object

   201 

   202         Return a new socket object connected to the same system resource."""

   203         return _socketobject(_sock=self._sock)

   204 

   205     def makefile(self, mode='r', bufsize=-1):

   206         """makefile([mode[, bufsize]]) -> file object

   207 

   208         Return a regular file object corresponding to the socket.  The mode

   209         and bufsize arguments are as for the built-in open() function."""

   210         return _fileobject(self._sock, mode, bufsize)

   211 

   212     family = property(lambda self: self._sock.family, doc="the socket family")

   213     type = property(lambda self: self._sock.type, doc="the socket type")

   214     proto = property(lambda self: self._sock.proto, doc="the socket protocol")

   215 

   216     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"

   217           "%s.__doc__ = _realsocket.%s.__doc__\n")

   218     for _m in _socketmethods:

   219         exec _s % (_m, _m, _m, _m)

   220     del _m, _s

   221 

   222 socket = SocketType = _socketobject

   223 

   224 class _fileobject(object):

   225     """Faux file object attached to a socket object."""

   226 

   227     default_bufsize = 8192

   228     name = "<socket>"

   229 

   230     __slots__ = ["mode", "bufsize", "softspace",

   231                  # "closed" is a property, see below

   232                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf",

   233                  "_close"]

   234 

   235     def __init__(self, sock, mode='rb', bufsize=-1, close=False):

   236         self._sock = sock

   237         self.mode = mode # Not actually used in this version

   238         if bufsize < 0:

   239             bufsize = self.default_bufsize

   240         self.bufsize = bufsize

   241         self.softspace = False

   242         # _rbufsize is the suggested recv buffer size.  It is *strictly*

   243         # obeyed within readline() for recv calls.  If it is larger than

   244         # default_bufsize it will be used for recv calls within read().

   245         if bufsize == 0:

   246             self._rbufsize = 1

   247         elif bufsize == 1:

   248             self._rbufsize = self.default_bufsize

   249         else:

   250             self._rbufsize = bufsize

   251         self._wbufsize = bufsize

   252         # We use StringIO for the read buffer to avoid holding a list

   253         # of variously sized string objects which have been known to

   254         # fragment the heap due to how they are malloc()ed and often

   255         # realloc()ed down much smaller than their original allocation.

   256         self._rbuf = StringIO()

   257         self._wbuf = [] # A list of strings

   258         self._close = close

   259 

   260     def _getclosed(self):

   261         return self._sock is None

   262     closed = property(_getclosed, doc="True if the file is closed")

   263 

   264     def close(self):

   265         try:

   266             if self._sock:

   267                 self.flush()

   268         finally:

   269             if self._close:

   270                 self._sock.close()

   271             self._sock = None

   272 

   273     def __del__(self):

   274         try:

   275             self.close()

   276         except:

   277             # close() may fail if __init__ didn't complete

   278             pass

   279 

   280     def flush(self):

   281         if self._wbuf:

   282             buffer = "".join(self._wbuf)

   283             self._wbuf = []

   284             self._sock.sendall(buffer)

   285 

   286     def fileno(self):

   287         return self._sock.fileno()

   288 

   289     def write(self, data):

   290         data = str(data) # XXX Should really reject non-string non-buffers

   291         if not data:

   292             return

   293         self._wbuf.append(data)

   294         if (self._wbufsize == 0 or

   295             self._wbufsize == 1 and '\n' in data or

   296             self._get_wbuf_len() >= self._wbufsize):

   297             self.flush()

   298 

   299     def writelines(self, list):

   300         # XXX We could do better here for very long lists

   301         # XXX Should really reject non-string non-buffers

   302         self._wbuf.extend(filter(None, map(str, list)))

   303         if (self._wbufsize <= 1 or

   304             self._get_wbuf_len() >= self._wbufsize):

   305             self.flush()

   306 

   307     def _get_wbuf_len(self):

   308         buf_len = 0

   309         for x in self._wbuf:

   310             buf_len += len(x)

   311         return buf_len

   312 

   313     def read(self, size=-1):

   314         # Use max, disallow tiny reads in a loop as they are very inefficient.

   315         # We never leave read() with any leftover data from a new recv() call

   316         # in our internal buffer.

   317         rbufsize = max(self._rbufsize, self.default_bufsize)

   318         # Our use of StringIO rather than lists of string objects returned by

   319         # recv() minimizes memory usage and fragmentation that occurs when

   320         # rbufsize is large compared to the typical return value of recv().

   321         buf = self._rbuf

   322         buf.seek(0, 2)  # seek end

   323         if size < 0:

   324             # Read until EOF

   325             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.

   326             while True:

   327                 data = self._sock.recv(rbufsize)

   328                 if not data:

   329                     break

   330                 buf.write(data)

   331             return buf.getvalue()

   332         else:

   333             # Read until size bytes or EOF seen, whichever comes first

   334             buf_len = buf.tell()

   335             if buf_len >= size:

   336                 # Already have size bytes in our buffer?  Extract and return.

   337                 buf.seek(0)

   338                 rv = buf.read(size)

   339                 self._rbuf = StringIO()

   340                 self._rbuf.write(buf.read())

   341                 return rv

   342 

   343             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.

   344             while True:

   345                 left = size - buf_len

   346                 # recv() will malloc the amount of memory given as its

   347                 # parameter even though it often returns much less data

   348                 # than that.  The returned data string is short lived

   349                 # as we copy it into a StringIO and free it.  This avoids

   350                 # fragmentation issues on many platforms.

   351                 data = self._sock.recv(left)

   352                 if not data:

   353                     break

   354                 n = len(data)

   355                 if n == size and not buf_len:

   356                     # Shortcut.  Avoid buffer data copies when:

   357                     # - We have no data in our buffer.

   358                     # AND

   359                     # - Our call to recv returned exactly the

   360                     #   number of bytes we were asked to read.

   361                     return data

   362                 if n == left:

   363                     buf.write(data)

   364                     del data  # explicit free

   365                     break

   366                 assert n <= left, "recv(%d) returned %d bytes" % (left, n)

   367                 buf.write(data)

   368                 buf_len += n

   369                 del data  # explicit free

   370                 #assert buf_len == buf.tell()

   371             return buf.getvalue()

   372 

   373     def readline(self, size=-1):

   374         buf = self._rbuf

   375         buf.seek(0, 2)  # seek end

   376         if buf.tell() > 0:

   377             # check if we already have it in our buffer

   378             buf.seek(0)

   379             bline = buf.readline(size)

   380             if bline.endswith('\n') or len(bline) == size:

   381                 self._rbuf = StringIO()

   382                 self._rbuf.write(buf.read())

   383                 return bline

   384             del bline

   385         if size < 0:

   386             # Read until \n or EOF, whichever comes first

   387             if self._rbufsize <= 1:

   388                 # Speed up unbuffered case

   389                 buf.seek(0)

   390                 buffers = [buf.read()]

   391                 self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.

   392                 data = None

   393                 recv = self._sock.recv

   394                 while data != "\n":

   395                     data = recv(1)

   396                     if not data:

   397                         break

   398                     buffers.append(data)

   399                 return "".join(buffers)

   400 

   401             buf.seek(0, 2)  # seek end

   402             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.

   403             while True:

   404                 data = self._sock.recv(self._rbufsize)

   405                 if not data:

   406                     break

   407                 nl = data.find('\n')

   408                 if nl >= 0:

   409                     nl += 1

   410                     buf.write(data[:nl])

   411                     self._rbuf.write(data[nl:])

   412                     del data

   413                     break

   414                 buf.write(data)

   415             return buf.getvalue()

   416         else:

   417             # Read until size bytes or \n or EOF seen, whichever comes first

   418             buf.seek(0, 2)  # seek end

   419             buf_len = buf.tell()

   420             if buf_len >= size:

   421                 buf.seek(0)

   422                 rv = buf.read(size)

   423                 self._rbuf = StringIO()

   424                 self._rbuf.write(buf.read())

   425                 return rv

   426             self._rbuf = StringIO()  # reset _rbuf.  we consume it via buf.

   427             while True:

   428                 data = self._sock.recv(self._rbufsize)

   429                 if not data:

   430                     break

   431                 left = size - buf_len

   432                 # did we just receive a newline?

   433                 nl = data.find('\n', 0, left)

   434                 if nl >= 0:

   435                     nl += 1

   436                     # save the excess data to _rbuf

   437                     self._rbuf.write(data[nl:])

   438                     if buf_len:

   439                         buf.write(data[:nl])

   440                         break

   441                     else:

   442                         # Shortcut.  Avoid data copy through buf when returning

   443                         # a substring of our first recv().

   444                         return data[:nl]

   445                 n = len(data)

   446                 if n == size and not buf_len:

   447                     # Shortcut.  Avoid data copy through buf when

   448                     # returning exactly all of our first recv().

   449                     return data

   450                 if n >= left:

   451                     buf.write(data[:left])

   452                     self._rbuf.write(data[left:])

   453                     break

   454                 buf.write(data)

   455                 buf_len += n

   456                 #assert buf_len == buf.tell()

   457             return buf.getvalue()

   458 

   459     def readlines(self, sizehint=0):

   460         total = 0

   461         list = []

   462         while True:

   463             line = self.readline()

   464             if not line:

   465                 break

   466             list.append(line)

   467             total += len(line)

   468             if sizehint and total >= sizehint:

   469                 break

   470         return list

   471 

   472     # Iterator protocols

   473 

   474     def __iter__(self):

   475         return self

   476 

   477     def next(self):

   478         line = self.readline()

   479         if not line:

   480             raise StopIteration

   481         return line

   482 

   483 _GLOBAL_DEFAULT_TIMEOUT = object()

   484 

   485 def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT):

   486     """Connect to *address* and return the socket object.

   487 

   488     Convenience function.  Connect to *address* (a 2-tuple ``(host,

   489     port)``) and return the socket object.  Passing the optional

   490     *timeout* parameter will set the timeout on the socket instance

   491     before attempting to connect.  If no *timeout* is supplied, the

   492     global default timeout setting returned by :func:`getdefaulttimeout`

   493     is used.

   494     """

   495 

   496     msg = "getaddrinfo returns an empty list"

   497     host, port = address

   498     for res in getaddrinfo(host, port, 0, SOCK_STREAM):

   499         af, socktype, proto, canonname, sa = res

   500         sock = None

   501         try:

   502             sock = socket(af, socktype, proto)

   503             if timeout is not _GLOBAL_DEFAULT_TIMEOUT:

   504                 sock.settimeout(timeout)

   505             sock.connect(sa)

   506             return sock

   507 

   508         except error, msg:

   509             if sock is not None:

   510                 sock.close()

   511 

   512     raise error, msg