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() -- 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 errno import EBADF
  83 except ImportError:
  84     EBADF = 9
  85
  86 __all__ = ["getfqdn"]
  87 __all__.extend(os._get_exports_list(_socket))
  88
  89
  90 _realsocket = socket
  91
  92 # WSA error codes
  93 if sys.platform.lower().startswith("win"):
  94     errorTab = {}
  95     errorTab[10004] = "The operation was interrupted."
  96     errorTab[10009] = "A bad file handle was passed."
  97     errorTab[10013] = "Permission denied."
  98     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  99     errorTab[10022] = "An invalid operation was attempted."
 100     errorTab[10035] = "The socket operation would block"
 101     errorTab[10036] = "A blocking operation is already in progress."
 102     errorTab[10048] = "The network address is in use."
 103     errorTab[10054] = "The connection has been reset."
 104     errorTab[10058] = "The network has been shut down."
 105     errorTab[10060] = "The operation timed out."
 106     errorTab[10061] = "Connection refused."
 107     errorTab[10063] = "The name is too long."
 108     errorTab[10064] = "The host is down."
 109     errorTab[10065] = "The host is unreachable."
 110     __all__.append("errorTab")
 111
 112
 113
 114 def getfqdn(name=''):
 115     """Get fully qualified domain name from name.
 116
 117     An empty argument is interpreted as meaning the local host.
 118
 119     First the hostname returned by gethostbyaddr() is checked, then
 120     possibly existing aliases. In case no FQDN is available, hostname
 121     from gethostname() is returned.
 122     """
 123     name = name.strip()
 124     if not name or name == '0.0.0.0':
 125         name = gethostname()
 126     try:
 127         hostname, aliases, ipaddrs = gethostbyaddr(name)
 128     except error:
 129         pass
 130     else:
 131         aliases.insert(0, hostname)
 132         for name in aliases:
 133             if '.' in name:
 134                 break
 135         else:
 136             name = hostname
 137     return name
 138
 139
 140 _socketmethods = (
 141     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
 142     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
 143     'sendall', 'setblocking',
 144     'settimeout', 'gettimeout', 'shutdown')
 145
 146 if os.name == "nt":
 147     _socketmethods = _socketmethods + ('ioctl',)
 148
 149 if sys.platform == "riscos":
 150     _socketmethods = _socketmethods + ('sleeptaskw',)
 151
 152 # All the method names that must be delegated to either the real socket
 153 # object or the _closedsocket object.
 154 _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",
 155                      "send", "sendto")
 156
 157 class _closedsocket(object):
 158     __slots__ = []
 159     def _dummy(*args):
 160         raise error(EBADF, 'Bad file descriptor')
 161     # All _delegate_methods must also be initialized here.
 162     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
 163     __getattr__ = _dummy
 164
 165 # Wrapper around platform socket objects. This implements
 166 # a platform-independent dup() functionality. The
 167 # implementation currently relies on reference counting
 168 # to close the underlying socket object.
 169 class _socketobject(object):
 170
 171     __doc__ = _realsocket.__doc__
 172
 173     __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
 174
 175     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
 176         if _sock is None:
 177             _sock = _realsocket(family, type, proto)
 178         self._sock = _sock
 179         for method in _delegate_methods:
 180             setattr(self, method, getattr(_sock, method))
 181
 182     def close(self):
 183         self._sock = _closedsocket()
 184         dummy = self._sock._dummy
 185         for method in _delegate_methods:
 186             setattr(self, method, dummy)
 187     close.__doc__ = _realsocket.close.__doc__
 188
 189     def accept(self):
 190         sock, addr = self._sock.accept()
 191         return _socketobject(_sock=sock), addr
 192     accept.__doc__ = _realsocket.accept.__doc__
 193
 194     def dup(self):
 195         """dup() -> socket object
 196
 197         Return a new socket object connected to the same system resource."""
 198         return _socketobject(_sock=self._sock)
 199
 200     def makefile(self, mode='r', bufsize=-1):
 201         """makefile([mode[, bufsize]]) -> file object
 202
 203         Return a regular file object corresponding to the socket.  The mode
 204         and bufsize arguments are as for the built-in open() function."""
 205         return _fileobject(self._sock, mode, bufsize)
 206
 207     family = property(lambda self: self._sock.family, doc="the socket family")
 208     type = property(lambda self: self._sock.type, doc="the socket type")
 209     proto = property(lambda self: self._sock.proto, doc="the socket protocol")
 210
 211     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
 212           "%s.__doc__ = _realsocket.%s.__doc__\n")
 213     for _m in _socketmethods:
 214         exec _s % (_m, _m, _m, _m)
 215     del _m, _s
 216
 217 socket = SocketType = _socketobject
 218
 219 class _fileobject(object):
 220     """Faux file object attached to a socket object."""
 221
 222     default_bufsize = 8192
 223     name = "<socket>"
 224
 225     __slots__ = ["mode", "bufsize", "softspace",
 226                  # "closed" is a property, see below
 227                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf",
 228                  "_close"]
 229
 230     def __init__(self, sock, mode='rb', bufsize=-1, close=False):
 231         self._sock = sock
 232         self.mode = mode # Not actually used in this version
 233         if bufsize < 0:
 234             bufsize = self.default_bufsize
 235         self.bufsize = bufsize
 236         self.softspace = False
 237         if bufsize == 0:
 238             self._rbufsize = 1
 239         elif bufsize == 1:
 240             self._rbufsize = self.default_bufsize
 241         else:
 242             self._rbufsize = bufsize
 243         self._wbufsize = bufsize
 244         self._rbuf = "" # A string
 245         self._wbuf = [] # A list of strings
 246         self._close = close
 247
 248     def _getclosed(self):
 249         return self._sock is None
 250     closed = property(_getclosed, doc="True if the file is closed")
 251
 252     def close(self):
 253         try:
 254             if self._sock:
 255                 self.flush()
 256         finally:
 257             if self._close:
 258                 self._sock.close()
 259             self._sock = None
 260
 261     def __del__(self):
 262         try:
 263             self.close()
 264         except:
 265             # close() may fail if __init__ didn't complete
 266             pass
 267
 268     def flush(self):
 269         if self._wbuf:
 270             buffer = "".join(self._wbuf)
 271             self._wbuf = []
 272             self._sock.sendall(buffer)
 273
 274     def fileno(self):
 275         return self._sock.fileno()
 276
 277     def write(self, data):
 278         data = str(data) # XXX Should really reject non-string non-buffers
 279         if not data:
 280             return
 281         self._wbuf.append(data)
 282         if (self._wbufsize == 0 or
 283             self._wbufsize == 1 and '\n' in data or
 284             self._get_wbuf_len() >= self._wbufsize):
 285             self.flush()
 286
 287     def writelines(self, list):
 288         # XXX We could do better here for very long lists
 289         # XXX Should really reject non-string non-buffers
 290         self._wbuf.extend(filter(None, map(str, list)))
 291         if (self._wbufsize <= 1 or
 292             self._get_wbuf_len() >= self._wbufsize):
 293             self.flush()
 294
 295     def _get_wbuf_len(self):
 296         buf_len = 0
 297         for x in self._wbuf:
 298             buf_len += len(x)
 299         return buf_len
 300
 301     def read(self, size=-1):
 302         data = self._rbuf
 303         if size < 0:
 304             # Read until EOF
 305             buffers = []
 306             if data:
 307                 buffers.append(data)
 308             self._rbuf = ""
 309             if self._rbufsize <= 1:
 310                 recv_size = self.default_bufsize
 311             else:
 312                 recv_size = self._rbufsize
 313             while True:
 314                 data = self._sock.recv(recv_size)
 315                 if not data:
 316                     break
 317                 buffers.append(data)
 318             return "".join(buffers)
 319         else:
 320             # Read until size bytes or EOF seen, whichever comes first
 321             buf_len = len(data)
 322             if buf_len >= size:
 323                 self._rbuf = data[size:]
 324                 return data[:size]
 325             buffers = []
 326             if data:
 327                 buffers.append(data)
 328             self._rbuf = ""
 329             while True:
 330                 left = size - buf_len
 331                 recv_size = max(self._rbufsize, left)
 332                 data = self._sock.recv(recv_size)
 333                 if not data:
 334                     break
 335                 buffers.append(data)
 336                 n = len(data)
 337                 if n >= left:
 338                     self._rbuf = data[left:]
 339                     buffers[-1] = data[:left]
 340                     break
 341                 buf_len += n
 342             return "".join(buffers)
 343
 344     def readline(self, size=-1):
 345         data = self._rbuf
 346         if size < 0:
 347             # Read until \n or EOF, whichever comes first
 348             if self._rbufsize <= 1:
 349                 # Speed up unbuffered case
 350                 assert data == ""
 351                 buffers = []
 352                 recv = self._sock.recv
 353                 while data != "\n":
 354                     data = recv(1)
 355                     if not data:
 356                         break
 357                     buffers.append(data)
 358                 return "".join(buffers)
 359             nl = data.find('\n')
 360             if nl >= 0:
 361                 nl += 1
 362                 self._rbuf = data[nl:]
 363                 return data[:nl]
 364             buffers = []
 365             if data:
 366                 buffers.append(data)
 367             self._rbuf = ""
 368             while True:
 369                 data = self._sock.recv(self._rbufsize)
 370                 if not data:
 371                     break
 372                 buffers.append(data)
 373                 nl = data.find('\n')
 374                 if nl >= 0:
 375                     nl += 1
 376                     self._rbuf = data[nl:]
 377                     buffers[-1] = data[:nl]
 378                     break
 379             return "".join(buffers)
 380         else:
 381             # Read until size bytes or \n or EOF seen, whichever comes first
 382             nl = data.find('\n', 0, size)
 383             if nl >= 0:
 384                 nl += 1
 385                 self._rbuf = data[nl:]
 386                 return data[:nl]
 387             buf_len = len(data)
 388             if buf_len >= size:
 389                 self._rbuf = data[size:]
 390                 return data[:size]
 391             buffers = []
 392             if data:
 393                 buffers.append(data)
 394             self._rbuf = ""
 395             while True:
 396                 data = self._sock.recv(self._rbufsize)
 397                 if not data:
 398                     break
 399                 buffers.append(data)
 400                 left = size - buf_len
 401                 nl = data.find('\n', 0, left)
 402                 if nl >= 0:
 403                     nl += 1
 404                     self._rbuf = data[nl:]
 405                     buffers[-1] = data[:nl]
 406                     break
 407                 n = len(data)
 408                 if n >= left:
 409                     self._rbuf = data[left:]
 410                     buffers[-1] = data[:left]
 411                     break
 412                 buf_len += n
 413             return "".join(buffers)
 414
 415     def readlines(self, sizehint=0):
 416         total = 0
 417         list = []
 418         while True:
 419             line = self.readline()
 420             if not line:
 421                 break
 422             list.append(line)
 423             total += len(line)
 424             if sizehint and total >= sizehint:
 425                 break
 426         return list
 427
 428     # Iterator protocols
 429
 430     def __iter__(self):
 431         return self
 432
 433     def next(self):
 434         line = self.readline()
 435         if not line:
 436             raise StopIteration
 437         return line
 438
 439
 440 def create_connection(address, timeout=None):
 441     """Connect to address (host, port) with an optional timeout.
 442
 443     Provides access to socketobject timeout for higher-level
 444     protocols.  Passing a timeout will set the timeout on the
 445     socket instance (if not present, or passed as None, the
 446     default global timeout setting will be used).
 447     """
 448
 449     msg = "getaddrinfo returns an empty list"
 450     host, port = address
 451     for res in getaddrinfo(host, port, 0, SOCK_STREAM):
 452         af, socktype, proto, canonname, sa = res
 453         sock = None
 454         try:
 455             sock = socket(af, socktype, proto)
 456             if timeout is not None:
 457                 sock.settimeout(timeout)
 458             sock.connect(sa)
 459             return sock
 460
 461         except error, msg:
 462             if sock is not None:
 463                 sock.close()
 464
 465     raise error, msg