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 #
 125 # These classes are used by the socket() defined on Windows and BeOS
 126 # platforms to provide a best-effort implementation of the cleanup
 127 # semantics needed when sockets can't be dup()ed.
 128 #
 129 # These are not actually used on other platforms.
 130 #
 131
 132 _socketmethods = (
 133     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
 134     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
 135     'sendall', 'setblocking',
 136     'settimeout', 'gettimeout', 'shutdown')
 137
 138 if sys.platform == "riscos":
 139     _socketmethods = _socketmethods + ('sleeptaskw',)
 140
 141 class _closedsocket(object):
 142     __slots__ = []
 143     def _dummy(*args):
 144         raise error(EBADF, 'Bad file descriptor')
 145     send = recv = sendto = recvfrom = __getattr__ = _dummy
 146
 147 class _socketobject(object):
 148
 149     __doc__ = _realsocket.__doc__
 150
 151     __slots__ = ["_sock", "send", "recv", "sendto", "recvfrom",
 152                  "__weakref__"]
 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         self.send = self._sock.send
 159         self.recv = self._sock.recv
 160         self.sendto = self._sock.sendto
 161         self.recvfrom = self._sock.recvfrom
 162
 163     def close(self):
 164         self._sock = _closedsocket()
 165         self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
 166     close.__doc__ = _realsocket.close.__doc__
 167
 168     def accept(self):
 169         sock, addr = self._sock.accept()
 170         return _socketobject(_sock=sock), addr
 171     accept.__doc__ = _realsocket.accept.__doc__
 172
 173     def dup(self):
 174         """dup() -> socket object
 175
 176         Return a new socket object connected to the same system resource."""
 177         return _socketobject(_sock=self._sock)
 178
 179     def makefile(self, mode='r', bufsize=-1):
 180         """makefile([mode[, bufsize]]) -> file object
 181
 182         Return a regular file object corresponding to the socket.  The mode
 183         and bufsize arguments are as for the built-in open() function."""
 184         return _fileobject(self._sock, mode, bufsize)
 185
 186     _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
 187           "%s.__doc__ = _realsocket.%s.__doc__\n")
 188     for _m in _socketmethods:
 189         exec _s % (_m, _m, _m, _m)
 190     del _m, _s
 191
 192 socket = SocketType = _socketobject
 193
 194 class _fileobject(object):
 195     """Faux file object attached to a socket object."""
 196
 197     default_bufsize = 8192
 198     name = "<socket>"
 199
 200     __slots__ = ["mode", "bufsize", "softspace",
 201                  # "closed" is a property, see below
 202                  "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
 203
 204     def __init__(self, sock, mode='rb', bufsize=-1):
 205         self._sock = sock
 206         self.mode = mode # Not actually used in this version
 207         if bufsize < 0:
 208             bufsize = self.default_bufsize
 209         self.bufsize = bufsize
 210         self.softspace = False
 211         if bufsize == 0:
 212             self._rbufsize = 1
 213         elif bufsize == 1:
 214             self._rbufsize = self.default_bufsize
 215         else:
 216             self._rbufsize = bufsize
 217         self._wbufsize = bufsize
 218         self._rbuf = "" # A string
 219         self._wbuf = [] # A list of strings
 220
 221     def _getclosed(self):
 222         return self._sock is None
 223     closed = property(_getclosed, doc="True if the file is closed")
 224
 225     def close(self):
 226         try:
 227             if self._sock:
 228                 self.flush()
 229         finally:
 230             self._sock = None
 231
 232     def __del__(self):
 233         try:
 234             self.close()
 235         except:
 236             # close() may fail if __init__ didn't complete
 237             pass
 238
 239     def flush(self):
 240         if self._wbuf:
 241             buffer = "".join(self._wbuf)
 242             self._wbuf = []
 243             self._sock.sendall(buffer)
 244
 245     def fileno(self):
 246         return self._sock.fileno()
 247
 248     def write(self, data):
 249         data = str(data) # XXX Should really reject non-string non-buffers
 250         if not data:
 251             return
 252         self._wbuf.append(data)
 253         if (self._wbufsize == 0 or
 254             self._wbufsize == 1 and '\n' in data or
 255             self._get_wbuf_len() >= self._wbufsize):
 256             self.flush()
 257
 258     def writelines(self, list):
 259         # XXX We could do better here for very long lists
 260         # XXX Should really reject non-string non-buffers
 261         self._wbuf.extend(filter(None, map(str, list)))
 262         if (self._wbufsize <= 1 or
 263             self._get_wbuf_len() >= self._wbufsize):
 264             self.flush()
 265
 266     def _get_wbuf_len(self):
 267         buf_len = 0
 268         for x in self._wbuf:
 269             buf_len += len(x)
 270         return buf_len
 271
 272     def read(self, size=-1):
 273         data = self._rbuf
 274         if size < 0:
 275             # Read until EOF
 276             buffers = []
 277             if data:
 278                 buffers.append(data)
 279             self._rbuf = ""
 280             if self._rbufsize <= 1:
 281                 recv_size = self.default_bufsize
 282             else:
 283                 recv_size = self._rbufsize
 284             while True:
 285                 data = self._sock.recv(recv_size)
 286                 if not data:
 287                     break
 288                 buffers.append(data)
 289             return "".join(buffers)
 290         else:
 291             # Read until size bytes or EOF seen, whichever comes first
 292             buf_len = len(data)
 293             if buf_len >= size:
 294                 self._rbuf = data[size:]
 295                 return data[:size]
 296             buffers = []
 297             if data:
 298                 buffers.append(data)
 299             self._rbuf = ""
 300             while True:
 301                 left = size - buf_len
 302                 recv_size = max(self._rbufsize, left)
 303                 data = self._sock.recv(recv_size)
 304                 if not data:
 305                     break
 306                 buffers.append(data)
 307                 n = len(data)
 308                 if n >= left:
 309                     self._rbuf = data[left:]
 310                     buffers[-1] = data[:left]
 311                     break
 312                 buf_len += n
 313             return "".join(buffers)
 314
 315     def readline(self, size=-1):
 316         data = self._rbuf
 317         if size < 0:
 318             # Read until \n or EOF, whichever comes first
 319             if self._rbufsize <= 1:
 320                 # Speed up unbuffered case
 321                 assert data == ""
 322                 buffers = []
 323                 recv = self._sock.recv
 324                 while data != "\n":
 325                     data = recv(1)
 326                     if not data:
 327                         break
 328                     buffers.append(data)
 329                 return "".join(buffers)
 330             nl = data.find('\n')
 331             if nl >= 0:
 332                 nl += 1
 333                 self._rbuf = data[nl:]
 334                 return data[:nl]
 335             buffers = []
 336             if data:
 337                 buffers.append(data)
 338             self._rbuf = ""
 339             while True:
 340                 data = self._sock.recv(self._rbufsize)
 341                 if not data:
 342                     break
 343                 buffers.append(data)
 344                 nl = data.find('\n')
 345                 if nl >= 0:
 346                     nl += 1
 347                     self._rbuf = data[nl:]
 348                     buffers[-1] = data[:nl]
 349                     break
 350             return "".join(buffers)
 351         else:
 352             # Read until size bytes or \n or EOF seen, whichever comes first
 353             nl = data.find('\n', 0, size)
 354             if nl >= 0:
 355                 nl += 1
 356                 self._rbuf = data[nl:]
 357                 return data[:nl]
 358             buf_len = len(data)
 359             if buf_len >= size:
 360                 self._rbuf = data[size:]
 361                 return data[:size]
 362             buffers = []
 363             if data:
 364                 buffers.append(data)
 365             self._rbuf = ""
 366             while True:
 367                 data = self._sock.recv(self._rbufsize)
 368                 if not data:
 369                     break
 370                 buffers.append(data)
 371                 left = size - buf_len
 372                 nl = data.find('\n', 0, left)
 373                 if nl >= 0:
 374                     nl += 1
 375                     self._rbuf = data[nl:]
 376                     buffers[-1] = data[:nl]
 377                     break
 378                 n = len(data)
 379                 if n >= left:
 380                     self._rbuf = data[left:]
 381                     buffers[-1] = data[:left]
 382                     break
 383                 buf_len += n
 384             return "".join(buffers)
 385
 386     def readlines(self, sizehint=0):
 387         total = 0
 388         list = []
 389         while True:
 390             line = self.readline()
 391             if not line:
 392                 break
 393             list.append(line)
 394             total += len(line)
 395             if sizehint and total >= sizehint:
 396                 break
 397         return list
 398
 399     # Iterator protocols
 400
 401     def __iter__(self):
 402         return self
 403
 404     def next(self):
 405         line = self.readline()
 406         if not line:
 407             raise StopIteration
 408         return line