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 try:
  58     from errno import EBADF
  59 except ImportError:
  60     EBADF = 9
  61
  62 __all__ = ["getfqdn"]
  63 __all__.extend(os._get_exports_list(_socket))
  64 if _have_ssl:
  65     __all__.extend(os._get_exports_list(_ssl))
  66
  67 _realsocket = socket
  68 if _have_ssl:
  69     _realssl = ssl
  70     def ssl(sock, keyfile=None, certfile=None):
  71         if hasattr(sock, "_sock"):
  72             sock = sock._sock
  73         return _realssl(sock, keyfile, certfile)
  74
  75 # WSA error codes
  76 if sys.platform.lower().startswith("win"):
  77     errorTab = {}
  78     errorTab[10004] = "The operation was interrupted."
  79     errorTab[10009] = "A bad file handle was passed."
  80     errorTab[10013] = "Permission denied."
  81     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  82     errorTab[10022] = "An invalid operation was attempted."
  83     errorTab[10035] = "The socket operation would block"
  84     errorTab[10036] = "A blocking operation is already in progress."
  85     errorTab[10048] = "The network address is in use."
  86     errorTab[10054] = "The connection has been reset."
  87     errorTab[10058] = "The network has been shut down."
  88     errorTab[10060] = "The operation timed out."
  89     errorTab[10061] = "Connection refused."
  90     errorTab[10063] = "The name is too long."
  91     errorTab[10064] = "The host is down."
  92     errorTab[10065] = "The host is unreachable."
  93     __all__.append("errorTab")
  94
  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     'sendall', 'setblocking',
 135     'settimeout', 'gettimeout', 'shutdown')
 136
 137 if sys.platform == "riscos":
 138     _socketmethods = _socketmethods + ('sleeptaskw',)
 139
 140 class _closedsocket(object):
 141     __slots__ = []
 142     def _dummy(*args):
 143         raise error(EBADF, 'Bad file descriptor')
 144     send = recv = sendto = recvfrom = __getattr__ = _dummy
 145
 146 class _socketobject(object):
 147
 148     __doc__ = _realsocket.__doc__
 149
 150     __slots__ = ["_sock", "send", "recv", "sendto", "recvfrom"]
 151
 152     def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
 153         if _sock is None:
 154             _sock = _realsocket(family, type, proto)
 155         self._sock = _sock
 156         self.send = self._sock.send
 157         self.recv = self._sock.recv
 158         self.sendto = self._sock.sendto
 159         self.recvfrom = self._sock.recvfrom
 160
 161     def close(self):
 162         self._sock = _closedsocket()
 163         self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
 164     close.__doc__ = _realsocket.close.__doc__
 165
 166     def accept(self):
 167         sock, addr = self._sock.accept()
 168         return _socketobject(_sock=sock), addr
 169     accept.__doc__ = _realsocket.accept.__doc__
 170
 171     def dup(self):
 172         """dup() -> socket object
 173
 174         Return a new socket object connected to the same system resource."""
 175         return _socketobject(_sock=self._sock)
 176
 177     def makefile(self, mode='r', bufsize=-1):
 178         """makefile([mode[, bufsize]]) -> file object
 179
 180         Return a regular file object corresponding to the socket.  The mode
 181         and bufsize arguments are as for the built-in open() function."""
 182         return _fileobject(self._sock, mode, bufsize)
 183
 184     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
 185           "%s.__doc__ = _realsocket.%s.__doc__\n")
 186     for _m in _socketmethods:
 187         exec _s % (_m, _m, _m, _m)
 188     del _m, _s
 189
 190 socket = SocketType = _socketobject
 191
 192 class _fileobject(object):
 193     """Faux file object attached to a socket object."""
 194
 195     default_bufsize = 8192
 196     name = "<socket>"
 197
 198     __slots__ = ["mode", "bufsize", "softspace",
 199                  # "closed" is a property, see below
 200                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
 201
 202     def __init__(self, sock, mode='rb', bufsize=-1):
 203         self._sock = sock
 204         self.mode = mode # Not actually used in this version
 205         if bufsize < 0:
 206             bufsize = self.default_bufsize
 207         self.bufsize = bufsize
 208         self.softspace = False
 209         if bufsize == 0:
 210             self._rbufsize = 1
 211         elif bufsize == 1:
 212             self._rbufsize = self.default_bufsize
 213         else:
 214             self._rbufsize = bufsize
 215         self._wbufsize = bufsize
 216         self._rbuf = "" # A string
 217         self._wbuf = [] # A list of strings
 218
 219     def _getclosed(self):
 220         return self._sock is not None
 221     closed = property(_getclosed, doc="True if the file is closed")
 222
 223     def close(self):
 224         try:
 225             if self._sock:
 226                 self.flush()
 227         finally:
 228             self._sock = None
 229
 230     def __del__(self):
 231         try:
 232             self.close()
 233         except:
 234             # close() may fail if __init__ didn't complete
 235             pass
 236
 237     def flush(self):
 238         if self._wbuf:
 239             buffer = "".join(self._wbuf)
 240             self._wbuf = []
 241             self._sock.sendall(buffer)
 242
 243     def fileno(self):
 244         return self._sock.fileno()
 245
 246     def write(self, data):
 247         data = str(data) # XXX Should really reject non-string non-buffers
 248         if not data:
 249             return
 250         self._wbuf.append(data)
 251         if (self._wbufsize == 0 or
 252             self._wbufsize == 1 and '\n' in data or
 253             self._get_wbuf_len() >= self._wbufsize):
 254             self.flush()
 255
 256     def writelines(self, list):
 257         # XXX We could do better here for very long lists
 258         # XXX Should really reject non-string non-buffers
 259         self._wbuf.extend(filter(None, map(str, list)))
 260         if (self._wbufsize <= 1 or
 261             self._get_wbuf_len() >= self._wbufsize):
 262             self.flush()
 263
 264     def _get_wbuf_len(self):
 265         buf_len = 0
 266         for x in self._wbuf:
 267             buf_len += len(x)
 268         return buf_len
 269
 270     def read(self, size=-1):
 271         data = self._rbuf
 272         if size < 0:
 273             # Read until EOF
 274             buffers = []
 275             if data:
 276                 buffers.append(data)
 277             self._rbuf = ""
 278             if self._rbufsize <= 1:
 279                 recv_size = self.default_bufsize
 280             else:
 281                 recv_size = self._rbufsize
 282             while True:
 283                 data = self._sock.recv(recv_size)
 284                 if not data:
 285                     break
 286                 buffers.append(data)
 287             return "".join(buffers)
 288         else:
 289             # Read until size bytes or EOF seen, whichever comes first
 290             buf_len = len(data)
 291             if buf_len >= size:
 292                 self._rbuf = data[size:]
 293                 return data[:size]
 294             buffers = []
 295             if data:
 296                 buffers.append(data)
 297             self._rbuf = ""
 298             while True:
 299                 left = size - buf_len
 300                 recv_size = max(self._rbufsize, left)
 301                 data = self._sock.recv(recv_size)
 302                 if not data:
 303                     break
 304                 buffers.append(data)
 305                 n = len(data)
 306                 if n >= left:
 307                     self._rbuf = data[left:]
 308                     buffers[-1] = data[:left]
 309                     break
 310                 buf_len += n
 311             return "".join(buffers)
 312
 313     def readline(self, size=-1):
 314         data = self._rbuf
 315         if size < 0:
 316             # Read until \n or EOF, whichever comes first
 317             if self._rbufsize <= 1:
 318                 # Speed up unbuffered case
 319                 assert data == ""
 320                 buffers = []
 321                 recv = self._sock.recv
 322                 while data != "\n":
 323                     data = recv(1)
 324                     if not data:
 325                         break
 326                     buffers.append(data)
 327                 return "".join(buffers)
 328             nl = data.find('\n')
 329             if nl >= 0:
 330                 nl += 1
 331                 self._rbuf = data[nl:]
 332                 return data[:nl]
 333             buffers = []
 334             if data:
 335                 buffers.append(data)
 336             self._rbuf = ""
 337             while True:
 338                 data = self._sock.recv(self._rbufsize)
 339                 if not data:
 340                     break
 341                 buffers.append(data)
 342                 nl = data.find('\n')
 343                 if nl >= 0:
 344                     nl += 1
 345                     self._rbuf = data[nl:]
 346                     buffers[-1] = data[:nl]
 347                     break
 348             return "".join(buffers)
 349         else:
 350             # Read until size bytes or \n or EOF seen, whichever comes first
 351             nl = data.find('\n', 0, size)
 352             if nl >= 0:
 353                 nl += 1
 354                 self._rbuf = data[nl:]
 355                 return data[:nl]
 356             buf_len = len(data)
 357             if buf_len >= size:
 358                 self._rbuf = data[size:]
 359                 return data[:size]
 360             buffers = []
 361             if data:
 362                 buffers.append(data)
 363             self._rbuf = ""
 364             while True:
 365                 data = self._sock.recv(self._rbufsize)
 366                 if not data:
 367                     break
 368                 buffers.append(data)
 369                 left = size - buf_len
 370                 nl = data.find('\n', 0, left)
 371                 if nl >= 0:
 372                     nl += 1
 373                     self._rbuf = data[nl:]
 374                     buffers[-1] = data[:nl]
 375                     break
 376                 n = len(data)
 377                 if n >= left:
 378                     self._rbuf = data[left:]
 379                     buffers[-1] = data[:left]
 380                     break
 381                 buf_len += n
 382             return "".join(buffers)
 383
 384     def readlines(self, sizehint=0):
 385         total = 0
 386         list = []
 387         while True:
 388             line = self.readline()
 389             if not line:
 390                 break
 391             list.append(line)
 392             total += len(line)
 393             if sizehint and total >= sizehint:
 394                 break
 395         return list
 396
 397     # Iterator protocols
 398
 399     def __iter__(self):
 400         return self
 401
 402     def next(self):
 403         line = self.readline()
 404         if not line:
 405             raise StopIteration
 406         return line