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