sys/lib/python/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     # All _delegate_methods must also be initialized here.
 143     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
 144     __getattr__ = _dummy
 145
 146 class _socketobject(object):
 147
 148     __doc__ = _realsocket.__doc__
 149
 150     __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
 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         for method in _delegate_methods:
 157             setattr(self, method, getattr(_sock, method))
 158
 159     def close(self):
 160         self._sock = _closedsocket()
 161         dummy = self._sock._dummy
 162         for method in _delegate_methods:
 163             setattr(self, method, 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     family = property(lambda self: self._sock.family, doc="the socket family")
 185     type = property(lambda self: self._sock.type, doc="the socket type")
 186     proto = property(lambda self: self._sock.proto, doc="the socket protocol")
 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                  "_close"]
 206
 207     def __init__(self, sock, mode='rb', bufsize=-1, close=False):
 208         self._sock = sock
 209         self.mode = mode # Not actually used in this version
 210         if bufsize < 0:
 211             bufsize = self.default_bufsize
 212         self.bufsize = bufsize
 213         self.softspace = False
 214         if bufsize == 0:
 215             self._rbufsize = 1
 216         elif bufsize == 1:
 217             self._rbufsize = self.default_bufsize
 218         else:
 219             self._rbufsize = bufsize
 220         self._wbufsize = bufsize
 221         self._rbuf = "" # A string
 222         self._wbuf = [] # A list of strings
 223         self._close = close
 224
 225     def _getclosed(self):
 226         return self._sock is None
 227     closed = property(_getclosed, doc="True if the file is closed")
 228
 229     def close(self):
 230         try:
 231             if self._sock:
 232                 self.flush()
 233         finally:
 234             if self._close:
 235                 self._sock.close()
 236             self._sock = None
 237
 238     def __del__(self):
 239         try:
 240             self.close()
 241         except:
 242             # close() may fail if __init__ didn't complete
 243             pass
 244
 245     def flush(self):
 246         if self._wbuf:
 247             buffer = "".join(self._wbuf)
 248             self._wbuf = []
 249             self._sock.sendall(buffer)
 250
 251     def fileno(self):
 252         return self._sock.fileno()
 253
 254     def write(self, data):
 255         data = str(data) # XXX Should really reject non-string non-buffers
 256         if not data:
 257             return
 258         self._wbuf.append(data)
 259         if (self._wbufsize == 0 or
 260             self._wbufsize == 1 and '\n' in data or
 261             self._get_wbuf_len() >= self._wbufsize):
 262             self.flush()
 263
 264     def writelines(self, list):
 265         # XXX We could do better here for very long lists
 266         # XXX Should really reject non-string non-buffers
 267         self._wbuf.extend(filter(None, map(str, list)))
 268         if (self._wbufsize <= 1 or
 269             self._get_wbuf_len() >= self._wbufsize):
 270             self.flush()
 271
 272     def _get_wbuf_len(self):
 273         buf_len = 0
 274         for x in self._wbuf:
 275             buf_len += len(x)
 276         return buf_len
 277
 278     def read(self, size=-1):
 279         data = self._rbuf
 280         if size < 0:
 281             # Read until EOF
 282             buffers = []
 283             if data:
 284                 buffers.append(data)
 285             self._rbuf = ""
 286             if self._rbufsize <= 1:
 287                 recv_size = self.default_bufsize
 288             else:
 289                 recv_size = self._rbufsize
 290             while True:
 291                 data = self._sock.recv(recv_size)
 292                 if not data:
 293                     break
 294                 buffers.append(data)
 295             return "".join(buffers)
 296         else:
 297             # Read until size bytes or EOF seen, whichever comes first
 298             buf_len = len(data)
 299             if buf_len >= size:
 300                 self._rbuf = data[size:]
 301                 return data[:size]
 302             buffers = []
 303             if data:
 304                 buffers.append(data)
 305             self._rbuf = ""
 306             while True:
 307                 left = size - buf_len
 308                 recv_size = max(self._rbufsize, left)
 309                 data = self._sock.recv(recv_size)
 310                 if not data:
 311                     break
 312                 buffers.append(data)
 313                 n = len(data)
 314                 if n >= left:
 315                     self._rbuf = data[left:]
 316                     buffers[-1] = data[:left]
 317                     break
 318                 buf_len += n
 319             return "".join(buffers)
 320
 321     def readline(self, size=-1):
 322         data = self._rbuf
 323         if size < 0:
 324             # Read until \n or EOF, whichever comes first
 325             if self._rbufsize <= 1:
 326                 # Speed up unbuffered case
 327                 assert data == ""
 328                 buffers = []
 329                 recv = self._sock.recv
 330                 while data != "\n":
 331                     data = recv(1)
 332                     if not data:
 333                         break
 334                     buffers.append(data)
 335                 return "".join(buffers)
 336             nl = data.find('\n')
 337             if nl >= 0:
 338                 nl += 1
 339                 self._rbuf = data[nl:]
 340                 return data[:nl]
 341             buffers = []
 342             if data:
 343                 buffers.append(data)
 344             self._rbuf = ""
 345             while True:
 346                 data = self._sock.recv(self._rbufsize)
 347                 if not data:
 348                     break
 349                 buffers.append(data)
 350                 nl = data.find('\n')
 351                 if nl >= 0:
 352                     nl += 1
 353                     self._rbuf = data[nl:]
 354                     buffers[-1] = data[:nl]
 355                     break
 356             return "".join(buffers)
 357         else:
 358             # Read until size bytes or \n or EOF seen, whichever comes first
 359             nl = data.find('\n', 0, size)
 360             if nl >= 0:
 361                 nl += 1
 362                 self._rbuf = data[nl:]
 363                 return data[:nl]
 364             buf_len = len(data)
 365             if buf_len >= size:
 366                 self._rbuf = data[size:]
 367                 return data[:size]
 368             buffers = []
 369             if data:
 370                 buffers.append(data)
 371             self._rbuf = ""
 372             while True:
 373                 data = self._sock.recv(self._rbufsize)
 374                 if not data:
 375                     break
 376                 buffers.append(data)
 377                 left = size - buf_len
 378                 nl = data.find('\n', 0, left)
 379                 if nl >= 0:
 380                     nl += 1
 381                     self._rbuf = data[nl:]
 382                     buffers[-1] = data[:nl]
 383                     break
 384                 n = len(data)
 385                 if n >= left:
 386                     self._rbuf = data[left:]
 387                     buffers[-1] = data[:left]
 388                     break
 389                 buf_len += n
 390             return "".join(buffers)
 391
 392     def readlines(self, sizehint=0):
 393         total = 0
 394         list = []
 395         while True:
 396             line = self.readline()
 397             if not line:
 398                 break
 399             list.append(line)
 400             total += len(line)
 401             if sizehint and total >= sizehint:
 402                 break
 403         return list
 404
 405     # Iterator protocols
 406
 407     def __iter__(self):
 408         return self
 409
 410     def next(self):
 411         line = self.readline()
 412         if not line:
 413             raise StopIteration
 414         return line