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
  25  [*] not available on all platforms!
  26
  27 Special objects:
  28
  29 SocketType -- type object for socket objects
  30 error -- exception raised for I/O errors
  31
  32 Integer constants:
  33
  34 AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  35 SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  36
  37 Many other constants may be defined; these may be used in calls to
  38 the setsockopt() and getsockopt() methods.
  39 """
  40
  41 from _socket import *
  42
  43 import os, sys
  44
  45 __all__ = ["getfqdn"]
  46 import _socket
  47 __all__.extend(os._get_exports_list(_socket))
  48
  49 if (sys.platform.lower().startswith("win")
  50     or (hasattr(os, 'uname') and os.uname()[0] == "BeOS")
  51     or (sys.platform=="riscos")):
  52
  53     _realsocketcall = _socket.socket
  54
  55     def socket(family, type, proto=0):
  56         return _socketobject(_realsocketcall(family, type, proto))
  57
  58     try:
  59         _realsslcall = _socket.ssl
  60     except AttributeError:
  61         pass # No ssl
  62     else:
  63         def ssl(sock, keyfile=None, certfile=None):
  64             if hasattr(sock, "_sock"):
  65                 sock = sock._sock
  66             return _realsslcall(sock, keyfile, certfile)
  67
  68
  69 # WSA error codes
  70 if sys.platform.lower().startswith("win"):
  71     errorTab = {}
  72     errorTab[10004] = "The operation was interrupted."
  73     errorTab[10009] = "A bad file handle was passed."
  74     errorTab[10013] = "Permission denied."
  75     errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  76     errorTab[10022] = "An invalid operation was attempted."
  77     errorTab[10035] = "The socket operation would block"
  78     errorTab[10036] = "A blocking operation is already in progress."
  79     errorTab[10048] = "The network address is in use."
  80     errorTab[10054] = "The connection has been reset."
  81     errorTab[10058] = "The network has been shut down."
  82     errorTab[10060] = "The operation timed out."
  83     errorTab[10061] = "Connection refused."
  84     errorTab[10063] = "The name is too long."
  85     errorTab[10064] = "The host is down."
  86     errorTab[10065] = "The host is unreachable."
  87     __all__.append("errorTab")
  88 del os, sys
  89
  90
  91 def getfqdn(name=''):
  92     """Get fully qualified domain name from name.
  93
  94     An empty argument is interpreted as meaning the local host.
  95
  96     First the hostname returned by gethostbyaddr() is checked, then
  97     possibly existing aliases. In case no FQDN is available, hostname
  98     is returned.
  99     """
 100     name = name.strip()
 101     if not name or name == '0.0.0.0':
 102         name = gethostname()
 103     try:
 104         hostname, aliases, ipaddrs = gethostbyaddr(name)
 105     except error:
 106         pass
 107     else:
 108         aliases.insert(0, hostname)
 109         for name in aliases:
 110             if '.' in name:
 111                 break
 112         else:
 113             name = hostname
 114     return name
 115
 116
 117 #
 118 # These classes are used by the socket() defined on Windows and BeOS
 119 # platforms to provide a best-effort implementation of the cleanup
 120 # semantics needed when sockets can't be dup()ed.
 121 #
 122 # These are not actually used on other platforms.
 123 #
 124
 125 _socketmethods = (
 126     'bind', 'connect', 'connect_ex', 'fileno', 'listen',
 127     'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
 128     'recv', 'recvfrom', 'send', 'sendall', 'sendto', 'setblocking', 'shutdown')
 129
 130 class _socketobject:
 131
 132     def __init__(self, sock):
 133         self._sock = sock
 134
 135     def close(self):
 136         self._sock = _closedsocket()
 137
 138     def __del__(self):
 139         self.close()
 140
 141     def accept(self):
 142         sock, addr = self._sock.accept()
 143         return _socketobject(sock), addr
 144
 145     def dup(self):
 146         return _socketobject(self._sock)
 147
 148     def makefile(self, mode='r', bufsize=-1):
 149         return _fileobject(self._sock, mode, bufsize)
 150
 151     _s = "def %s(self, *args): return self._sock.%s(*args)\n\n"
 152     for _m in _socketmethods:
 153         exec _s % (_m, _m)
 154
 155
 156 class _closedsocket:
 157
 158     def __getattr__(self, name):
 159         raise error(9, 'Bad file descriptor')
 160
 161
 162 class _fileobject:
 163
 164     def __init__(self, sock, mode, bufsize):
 165         self._sock = sock
 166         self._mode = mode
 167         if bufsize < 0:
 168             bufsize = 512
 169         self._rbufsize = max(1, bufsize)
 170         self._wbufsize = bufsize
 171         self._wbuf = self._rbuf = ""
 172
 173     def close(self):
 174         try:
 175             if self._sock:
 176                 self.flush()
 177         finally:
 178             self._sock = 0
 179
 180     def __del__(self):
 181         self.close()
 182
 183     def flush(self):
 184         if self._wbuf:
 185             self._sock.send(self._wbuf)
 186             self._wbuf = ""
 187
 188     def fileno(self):
 189         return self._sock.fileno()
 190
 191     def write(self, data):
 192         self._wbuf = self._wbuf + data
 193         if self._wbufsize == 1:
 194             if '\n' in data:
 195                 self.flush()
 196         else:
 197             if len(self._wbuf) >= self._wbufsize:
 198                 self.flush()
 199
 200     def writelines(self, list):
 201         filter(self._sock.send, list)
 202         self.flush()
 203
 204     def read(self, n=-1):
 205         if n >= 0:
 206             k = len(self._rbuf)
 207             if n <= k:
 208                 data = self._rbuf[:n]
 209                 self._rbuf = self._rbuf[n:]
 210                 return data
 211             n = n - k
 212             L = [self._rbuf]
 213             self._rbuf = ""
 214             while n > 0:
 215                 new = self._sock.recv(max(n, self._rbufsize))
 216                 if not new: break
 217                 k = len(new)
 218                 if k > n:
 219                     L.append(new[:n])
 220                     self._rbuf = new[n:]
 221                     break
 222                 L.append(new)
 223                 n = n - k
 224             return "".join(L)
 225         k = max(512, self._rbufsize)
 226         L = [self._rbuf]
 227         self._rbuf = ""
 228         while 1:
 229             new = self._sock.recv(k)
 230             if not new: break
 231             L.append(new)
 232             k = min(k*2, 1024**2)
 233         return "".join(L)
 234
 235     def readline(self, limit=-1):
 236         data = ""
 237         i = self._rbuf.find('\n')
 238         while i < 0 and not (0 < limit <= len(self._rbuf)):
 239             new = self._sock.recv(self._rbufsize)
 240             if not new: break
 241             i = new.find('\n')
 242             if i >= 0: i = i + len(self._rbuf)
 243             self._rbuf = self._rbuf + new
 244         if i < 0: i = len(self._rbuf)
 245         else: i = i+1
 246         if 0 <= limit < len(self._rbuf): i = limit
 247         data, self._rbuf = self._rbuf[:i], self._rbuf[i:]
 248         return data
 249
 250     def readlines(self, sizehint = 0):
 251         total = 0
 252         list = []
 253         while 1:
 254             line = self.readline()
 255             if not line: break
 256             list.append(line)
 257             total += len(line)
 258             if sizehint and total >= sizehint:
 259                 break
 260         return list