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