home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Freeware / Miro 1.0 / Miro_Installer.exe / xulrunner / python / socket.py < prev    next >
Encoding:
Python Source  |  2006-08-03  |  13.3 KB  |  414 lines
  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
  414.