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 fromfd() -- create a socket object from an open file descriptor [*]
  14 gethostname() -- return the current hostname
  15 gethostbyname() -- map a hostname to its IP number
  16 gethostbyaddr() -- map an IP number or hostname to DNS info
  17 getservbyname() -- map a service name and a protocol name to a port number
  18 getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
  19 ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  20 htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  21 inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  22 inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  23 ssl() -- secure socket layer support (only available if configured)
  24 socket.getdefaulttimeout() -- get the default timeout value
  25 socket.setdefaulttimeout() -- set the default timeout value
  26
  27  [*] not available on all platforms!
  28
  29 Special objects:
  30
  31 SocketType -- type object for socket objects
  32 error -- exception raised for I/O errors
  33 has_ipv6 -- boolean value indicating if IPv6 is supported
  34
  35 Integer constants:
  36
  37 AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  38 SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  39
  40 Many other constants may be defined; these may be used in calls to
  41 the setsockopt() and getsockopt() methods.
  42 """
  43
  44 import _socket
  45 from _socket import *
  46
  47 _have_ssl = False
  48 try:
  49     import _ssl
  50     from _ssl import *
  51     _have_ssl = True
  52 except ImportError:
  53     pass
  54
  55 import os, sys
  56
  57 __all__ = ["getfqdn"]
  58 __all__.extend(os._get_exports_list(_socket))
  59 if _have_ssl:
  60     __all__.extend(os._get_exports_list(_ssl))
  61
  62 _realsocket = socket
  63 if (sys.platform.lower().startswith("win")
  64     or (hasattr(os, 'uname') and os.uname()[0] == "BeOS")
  65     or sys.platform=="riscos"):
  66
  67     if _have_ssl:
  68         _realssl = ssl
  69         def ssl(sock, keyfile=None, certfile=None):
  70             if hasattr(sock, "_sock"):
  71                 sock = sock._sock
  72             return _realssl(sock, keyfile, certfile)
  73
  74 # WSA error codes
  75 if sys.platform.lower().startswith("win"):
  76     errorTab = {}
  77     errorTab[10004] = "The operation was interrupted."
  78     errorTab[10009] = "A bad file handle was passed."
  79     errorTab[10013] = "Permission denied."
  80     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  81     errorTab[10022] = "An invalid operation was attempted."
  82     errorTab[10035] = "The socket operation would block"
  83     errorTab[10036] = "A blocking operation is already in progress."
  84     errorTab[10048] = "The network address is in use."
  85     errorTab[10054] = "The connection has been reset."
  86     errorTab[10058] = "The network has been shut down."
  87     errorTab[10060] = "The operation timed out."
  88     errorTab[10061] = "Connection refused."
  89     errorTab[10063] = "The name is too long."
  90     errorTab[10064] = "The host is down."
  91     errorTab[10065] = "The host is unreachable."
  92     __all__.append("errorTab")
  93
  94 del os, sys
  95
  96
  97 def getfqdn(name=''):
  98     """Get fully qualified domain name from name.
  99
 100     An empty argument is interpreted as meaning the local host.
 101
 102     First the hostname returned by gethostbyaddr() is checked, then
 103     possibly existing aliases. In case no FQDN is available, hostname
 104     is returned.
 105     """
 106     name = name.strip()
 107     if not name or name == '0.0.0.0':
 108         name = gethostname()
 109     try:
 110         hostname, aliases, ipaddrs = gethostbyaddr(name)
 111     except error:
 112         pass
 113     else:
 114         aliases.insert(0, hostname)
 115         for name in aliases:
 116             if '.' in name:
 117                 break
 118         else:
 119             name = hostname
 120     return name
 121
 122
 123 #
 124 # These classes are used by the socket() defined on Windows and BeOS
 125 # platforms to provide a best-effort implementation of the cleanup
 126 # semantics needed when sockets can't be dup()ed.
 127 #
 128 # These are not actually used on other platforms.
 129 #
 130
 131 _socketmethods = (
 132     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
 133     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
 134     'recv', 'recvfrom', 'send', 'sendall', 'sendto', 'setblocking',
 135     'settimeout', 'gettimeout', 'shutdown')
 136
 137 class _closedsocket(object):
 138     __slots__ = []
 139     def __getattr__(self, name):
 140         raise error(9, 'Bad file descriptor')
 141
 142 class _socketobject(object):
 143
 144     __doc__ = _realsocket.__doc__
 145
 146     __slots__ = ["_sock"]
 147
 148     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
 149         if _sock is None:
 150             _sock = _realsocket(family, type, proto)
 151         self._sock = _sock
 152
 153     def close(self):
 154         self._sock = _closedsocket()
 155     close.__doc__ = _realsocket.close.__doc__
 156
 157     def accept(self):
 158         sock, addr = self._sock.accept()
 159         return _socketobject(_sock=sock), addr
 160     accept.__doc__ = _realsocket.accept.__doc__
 161
 162     def dup(self):
 163         """dup() -> socket object
 164
 165         Return a new socket object connected to the same system resource."""
 166         return _socketobject(_sock=self._sock)
 167
 168     def makefile(self, mode='r', bufsize=-1):
 169         """makefile([mode[, bufsize]]) -> file object
 170
 171         Return a regular file object corresponding to the socket.  The mode
 172         and bufsize arguments are as for the built-in open() function."""
 173         return _fileobject(self._sock, mode, bufsize)
 174
 175     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
 176           "%s.__doc__ = _realsocket.%s.__doc__\n")
 177     for _m in _socketmethods:
 178         exec _s % (_m, _m, _m, _m)
 179     del _m, _s
 180
 181 socket = SocketType = _socketobject
 182
 183 class _fileobject(object):
 184     """Faux file object attached to a socket object."""
 185
 186     default_bufsize = 8192
 187     name = "<socket>"
 188
 189     __slots__ = ["mode", "bufsize", "softspace",
 190                  # "closed" is a property, see below
 191                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
 192
 193     def __init__(self, sock, mode='rb', bufsize=-1):
 194         self._sock = sock
 195         self.mode = mode # Not actually used in this version
 196         if bufsize < 0:
 197             bufsize = self.default_bufsize
 198         self.bufsize = bufsize
 199         self.softspace = False
 200         if bufsize == 0:
 201             self._rbufsize = 1
 202         elif bufsize == 1:
 203             self._rbufsize = self.default_bufsize
 204         else:
 205             self._rbufsize = bufsize
 206         self._wbufsize = bufsize
 207         self._rbuf = "" # A string
 208         self._wbuf = [] # A list of strings
 209
 210     def _getclosed(self):
 211         return self._sock is not None
 212     closed = property(_getclosed, doc="True if the file is closed")
 213
 214     def close(self):
 215         try:
 216             if self._sock:
 217                 self.flush()
 218         finally:
 219             self._sock = None
 220
 221     def __del__(self):
 222         self.close()
 223
 224     def flush(self):
 225         if self._wbuf:
 226             buffer = "".join(self._wbuf)
 227             self._wbuf = []
 228             self._sock.sendall(buffer)
 229
 230     def fileno(self):
 231         return self._sock.fileno()
 232
 233     def write(self, data):
 234         data = str(data) # XXX Should really reject non-string non-buffers
 235         if not data:
 236             return
 237         self._wbuf.append(data)
 238         if (self._wbufsize == 0 or
 239             self._wbufsize == 1 and '\n' in data or
 240             self._get_wbuf_len() >= self._wbufsize):
 241             self.flush()
 242
 243     def writelines(self, list):
 244         # XXX We could do better here for very long lists
 245         # XXX Should really reject non-string non-buffers
 246         self._wbuf.extend(filter(None, map(str, list)))
 247         if (self._wbufsize <= 1 or
 248             self._get_wbuf_len() >= self._wbufsize):
 249             self.flush()
 250
 251     def _get_wbuf_len(self):
 252         buf_len = 0
 253         for x in self._wbuf:
 254             buf_len += len(x)
 255         return buf_len
 256
 257     def read(self, size=-1):
 258         data = self._rbuf
 259         if size < 0:
 260             # Read until EOF
 261             buffers = []
 262             if data:
 263                 buffers.append(data)
 264             self._rbuf = ""
 265             if self._rbufsize <= 1:
 266                 recv_size = self.default_bufsize
 267             else:
 268                 recv_size = self._rbufsize
 269             while True:
 270                 data = self._sock.recv(recv_size)
 271                 if not data:
 272                     break
 273                 buffers.append(data)
 274             return "".join(buffers)
 275         else:
 276             # Read until size bytes or EOF seen, whichever comes first
 277             buf_len = len(data)
 278             if buf_len >= size:
 279                 self._rbuf = data[size:]
 280                 return data[:size]
 281             buffers = []
 282             if data:
 283                 buffers.append(data)
 284             self._rbuf = ""
 285             while True:
 286                 left = size - buf_len
 287                 recv_size = max(self._rbufsize, left)
 288                 data = self._sock.recv(recv_size)
 289                 if not data:
 290                     break
 291                 buffers.append(data)
 292                 n = len(data)
 293                 if n >= left:
 294                     self._rbuf = data[left:]
 295                     buffers[-1] = data[:left]
 296                     break
 297                 buf_len += n
 298             return "".join(buffers)
 299
 300     def readline(self, size=-1):
 301         data = self._rbuf
 302         if size < 0:
 303             # Read until \n or EOF, whichever comes first
 304             if self._rbufsize <= 1:
 305                 # Speed up unbuffered case
 306                 assert data == ""
 307                 buffers = []
 308                 recv = self._sock.recv
 309                 while data != "\n":
 310                     data = recv(1)
 311                     if not data:
 312                         break
 313                     buffers.append(data)
 314                 return "".join(buffers)
 315             nl = data.find('\n')
 316             if nl >= 0:
 317                 nl += 1
 318                 self._rbuf = data[nl:]
 319                 return data[:nl]
 320             buffers = []
 321             if data:
 322                 buffers.append(data)
 323             self._rbuf = ""
 324             while True:
 325                 data = self._sock.recv(self._rbufsize)
 326                 if not data:
 327                     break
 328                 buffers.append(data)
 329                 nl = data.find('\n')
 330                 if nl >= 0:
 331                     nl += 1
 332                     self._rbuf = data[nl:]
 333                     buffers[-1] = data[:nl]
 334                     break
 335             return "".join(buffers)
 336         else:
 337             # Read until size bytes or \n or EOF seen, whichever comes first
 338             nl = data.find('\n', 0, size)
 339             if nl >= 0:
 340                 nl += 1
 341                 self._rbuf = data[nl:]
 342                 return data[:nl]
 343             buf_len = len(data)
 344             if buf_len >= size:
 345                 self._rbuf = data[size:]
 346                 return data[:size]
 347             buffers = []
 348             if data:
 349                 buffers.append(data)
 350             self._rbuf = ""
 351             while True:
 352                 data = self._sock.recv(self._rbufsize)
 353                 if not data:
 354                     break
 355                 buffers.append(data)
 356                 left = size - buf_len
 357                 nl = data.find('\n', 0, left)
 358                 if nl >= 0:
 359                     nl += 1
 360                     self._rbuf = data[nl:]
 361                     buffers[-1] = data[:nl]
 362                     break
 363                 n = len(data)
 364                 if n >= left:
 365                     self._rbuf = data[left:]
 366                     buffers[-1] = data[:left]
 367                     break
 368                 buf_len += n
 369             return "".join(buffers)
 370
 371     def readlines(self, sizehint=0):
 372         total = 0
 373         list = []
 374         while True:
 375             line = self.readline()
 376             if not line:
 377                 break
 378             list.append(line)
 379             total += len(line)
 380             if sizehint and total >= sizehint:
 381                 break
 382         return list
 383
 384     # Iterator protocols
 385
 386     def __iter__(self):
 387         return self
 388
 389     def next(self):
 390         line = self.readline()
 391         if not line:
 392             raise StopIteration
 393         return line