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