home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / python2.5 / socket.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-05-11  |  12.1 KB  |  459 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. """This module provides socket operations and some related functions.
  5. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  6. On other systems, it only supports IP. Functions specific for a
  7. socket are available as methods of the socket object.
  8.  
  9. Functions:
  10.  
  11. socket() -- create a new socket object
  12. socketpair() -- create a pair of new socket objects [*]
  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. import _socket
  44. from _socket import *
  45. _have_ssl = False
  46.  
  47. try:
  48.     import _ssl
  49.     from _ssl import *
  50.     _have_ssl = True
  51. except ImportError:
  52.     pass
  53.  
  54. import os
  55. import sys
  56.  
  57. try:
  58.     from errno import EBADF
  59. except ImportError:
  60.     EBADF = 9
  61.  
  62. __all__ = [
  63.     '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.     
  72.     def ssl(sock, keyfile = None, certfile = None):
  73.         if hasattr(sock, '_sock'):
  74.             sock = sock._sock
  75.         
  76.         return _realssl(sock, keyfile, certfile)
  77.  
  78.  
  79. if sys.platform.lower().startswith('win'):
  80.     errorTab = { }
  81.     errorTab[10004] = 'The operation was interrupted.'
  82.     errorTab[10009] = 'A bad file handle was passed.'
  83.     errorTab[10013] = 'Permission denied.'
  84.     errorTab[10014] = 'A fault occurred on the network??'
  85.     errorTab[10022] = 'An invalid operation was attempted.'
  86.     errorTab[10035] = 'The socket operation would block'
  87.     errorTab[10036] = 'A blocking operation is already in progress.'
  88.     errorTab[10048] = 'The network address is in use.'
  89.     errorTab[10054] = 'The connection has been reset.'
  90.     errorTab[10058] = 'The network has been shut down.'
  91.     errorTab[10060] = 'The operation timed out.'
  92.     errorTab[10061] = 'Connection refused.'
  93.     errorTab[10063] = 'The name is too long.'
  94.     errorTab[10064] = 'The host is down.'
  95.     errorTab[10065] = 'The host is unreachable.'
  96.     __all__.append('errorTab')
  97.  
  98.  
  99. def getfqdn(name = ''):
  100.     '''Get fully qualified domain name from name.
  101.  
  102.     An empty argument is interpreted as meaning the local host.
  103.  
  104.     First the hostname returned by gethostbyaddr() is checked, then
  105.     possibly existing aliases. In case no FQDN is available, hostname
  106.     from gethostname() is returned.
  107.     '''
  108.     name = name.strip()
  109.     if not name or name == '0.0.0.0':
  110.         name = gethostname()
  111.     
  112.     
  113.     try:
  114.         (hostname, aliases, ipaddrs) = gethostbyaddr(name)
  115.     except error:
  116.         pass
  117.  
  118.     aliases.insert(0, hostname)
  119.     for name in aliases:
  120.         if '.' in name:
  121.             break
  122.             continue
  123.     else:
  124.         name = hostname
  125.     return name
  126.  
  127. _socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'sendall', 'setblocking', 'settimeout', 'gettimeout', 'shutdown')
  128. if sys.platform == 'riscos':
  129.     _socketmethods = _socketmethods + ('sleeptaskw',)
  130.  
  131. _delegate_methods = ('recv', 'recvfrom', 'recv_into', 'recvfrom_into', 'send', 'sendto')
  132.  
  133. class _closedsocket(object):
  134.     __slots__ = []
  135.     
  136.     def _dummy(*args):
  137.         raise error(EBADF, 'Bad file descriptor')
  138.  
  139.     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
  140.     __getattr__ = _dummy
  141.  
  142.  
  143. class _socketobject(object):
  144.     __doc__ = _realsocket.__doc__
  145.     __slots__ = [
  146.         '_sock',
  147.         '__weakref__'] + list(_delegate_methods)
  148.     
  149.     def __init__(self, family = AF_INET, type = SOCK_STREAM, proto = 0, _sock = None):
  150.         if _sock is None:
  151.             _sock = _realsocket(family, type, proto)
  152.         
  153.         self._sock = _sock
  154.         for method in _delegate_methods:
  155.             setattr(self, method, getattr(_sock, method))
  156.         
  157.  
  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.         
  165.  
  166.     close.__doc__ = _realsocket.close.__doc__
  167.     
  168.     def accept(self):
  169.         (sock, addr) = self._sock.accept()
  170.         return (_socketobject(_sock = sock), addr)
  171.  
  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.     
  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.     family = property((lambda self: self._sock.family), doc = 'the socket family')
  189.     type = property((lambda self: self._sock.type), doc = 'the socket type')
  190.     proto = property((lambda self: self._sock.proto), doc = 'the socket protocol')
  191.     _s = 'def %s(self, *args): return self._sock.%s(*args)\n\n%s.__doc__ = _realsocket.%s.__doc__\n'
  192.     for _m in _socketmethods:
  193.         exec _s % (_m, _m, _m, _m)
  194.     
  195.     del _m
  196.     del _s
  197.  
  198. socket = SocketType = _socketobject
  199.  
  200. class _fileobject(object):
  201.     '''Faux file object attached to a socket object.'''
  202.     default_bufsize = 8192
  203.     name = '<socket>'
  204.     __slots__ = [
  205.         'mode',
  206.         'bufsize',
  207.         'softspace',
  208.         '_sock',
  209.         '_rbufsize',
  210.         '_wbufsize',
  211.         '_rbuf',
  212.         '_wbuf',
  213.         '_close']
  214.     
  215.     def __init__(self, sock, mode = 'rb', bufsize = -1, close = False):
  216.         self._sock = sock
  217.         self.mode = mode
  218.         if bufsize < 0:
  219.             bufsize = self.default_bufsize
  220.         
  221.         self.bufsize = bufsize
  222.         self.softspace = False
  223.         if bufsize == 0:
  224.             self._rbufsize = 1
  225.         elif bufsize == 1:
  226.             self._rbufsize = self.default_bufsize
  227.         else:
  228.             self._rbufsize = bufsize
  229.         self._wbufsize = bufsize
  230.         self._rbuf = ''
  231.         self._wbuf = []
  232.         self._close = close
  233.  
  234.     
  235.     def _getclosed(self):
  236.         return self._sock is None
  237.  
  238.     closed = property(_getclosed, doc = 'True if the file is closed')
  239.     
  240.     def close(self):
  241.         
  242.         try:
  243.             if self._sock:
  244.                 self.flush()
  245.         finally:
  246.             if self._close:
  247.                 self._sock.close()
  248.             
  249.             self._sock = None
  250.  
  251.  
  252.     
  253.     def __del__(self):
  254.         
  255.         try:
  256.             self.close()
  257.         except:
  258.             pass
  259.  
  260.  
  261.     
  262.     def flush(self):
  263.         if self._wbuf:
  264.             buffer = ''.join(self._wbuf)
  265.             self._wbuf = []
  266.             self._sock.sendall(buffer)
  267.         
  268.  
  269.     
  270.     def fileno(self):
  271.         return self._sock.fileno()
  272.  
  273.     
  274.     def write(self, data):
  275.         data = str(data)
  276.         if not data:
  277.             return None
  278.         
  279.         self._wbuf.append(data)
  280.         if not self._wbufsize == 0:
  281.             if self._wbufsize == 1 or '\n' in data or self._get_wbuf_len() >= self._wbufsize:
  282.                 self.flush()
  283.             
  284.  
  285.     
  286.     def writelines(self, list):
  287.         self._wbuf.extend(filter(None, map(str, list)))
  288.         if self._wbufsize <= 1 or self._get_wbuf_len() >= self._wbufsize:
  289.             self.flush()
  290.         
  291.  
  292.     
  293.     def _get_wbuf_len(self):
  294.         buf_len = 0
  295.         for x in self._wbuf:
  296.             buf_len += len(x)
  297.         
  298.         return buf_len
  299.  
  300.     
  301.     def read(self, size = -1):
  302.         data = self._rbuf
  303.         if size < 0:
  304.             buffers = []
  305.             if data:
  306.                 buffers.append(data)
  307.             
  308.             self._rbuf = ''
  309.             if self._rbufsize <= 1:
  310.                 recv_size = self.default_bufsize
  311.             else:
  312.                 recv_size = self._rbufsize
  313.             while True:
  314.                 data = self._sock.recv(recv_size)
  315.                 if not data:
  316.                     break
  317.                 
  318.                 buffers.append(data)
  319.             return ''.join(buffers)
  320.         else:
  321.             buf_len = len(data)
  322.             if buf_len >= size:
  323.                 self._rbuf = data[size:]
  324.                 return data[:size]
  325.             
  326.             buffers = []
  327.             if data:
  328.                 buffers.append(data)
  329.             
  330.             self._rbuf = ''
  331.             while True:
  332.                 left = size - buf_len
  333.                 recv_size = max(self._rbufsize, left)
  334.                 data = self._sock.recv(recv_size)
  335.                 if not data:
  336.                     break
  337.                 
  338.                 buffers.append(data)
  339.                 n = len(data)
  340.                 if n >= left:
  341.                     self._rbuf = data[left:]
  342.                     buffers[-1] = data[:left]
  343.                     break
  344.                 
  345.                 buf_len += n
  346.             return ''.join(buffers)
  347.  
  348.     
  349.     def readline(self, size = -1):
  350.         data = self._rbuf
  351.         if size < 0:
  352.             if self._rbufsize <= 1:
  353.                 if not data == '':
  354.                     raise AssertionError
  355.                 buffers = []
  356.                 recv = self._sock.recv
  357.                 while data != '\n':
  358.                     data = recv(1)
  359.                     if not data:
  360.                         break
  361.                     
  362.                     buffers.append(data)
  363.                 return ''.join(buffers)
  364.             
  365.             nl = data.find('\n')
  366.             if nl >= 0:
  367.                 nl += 1
  368.                 self._rbuf = data[nl:]
  369.                 return data[:nl]
  370.             
  371.             buffers = []
  372.             if data:
  373.                 buffers.append(data)
  374.             
  375.             self._rbuf = ''
  376.             while True:
  377.                 data = self._sock.recv(self._rbufsize)
  378.                 if not data:
  379.                     break
  380.                 
  381.                 buffers.append(data)
  382.                 nl = data.find('\n')
  383.                 if nl >= 0:
  384.                     nl += 1
  385.                     self._rbuf = data[nl:]
  386.                     buffers[-1] = data[:nl]
  387.                     break
  388.                     continue
  389.             return ''.join(buffers)
  390.         else:
  391.             nl = data.find('\n', 0, size)
  392.             if nl >= 0:
  393.                 nl += 1
  394.                 self._rbuf = data[nl:]
  395.                 return data[:nl]
  396.             
  397.             buf_len = len(data)
  398.             if buf_len >= size:
  399.                 self._rbuf = data[size:]
  400.                 return data[:size]
  401.             
  402.             buffers = []
  403.             if data:
  404.                 buffers.append(data)
  405.             
  406.             self._rbuf = ''
  407.             while True:
  408.                 data = self._sock.recv(self._rbufsize)
  409.                 if not data:
  410.                     break
  411.                 
  412.                 buffers.append(data)
  413.                 left = size - buf_len
  414.                 nl = data.find('\n', 0, left)
  415.                 if nl >= 0:
  416.                     nl += 1
  417.                     self._rbuf = data[nl:]
  418.                     buffers[-1] = data[:nl]
  419.                     break
  420.                 
  421.                 n = len(data)
  422.                 if n >= left:
  423.                     self._rbuf = data[left:]
  424.                     buffers[-1] = data[:left]
  425.                     break
  426.                 
  427.                 buf_len += n
  428.             return ''.join(buffers)
  429.  
  430.     
  431.     def readlines(self, sizehint = 0):
  432.         total = 0
  433.         list = []
  434.         while True:
  435.             line = self.readline()
  436.             if not line:
  437.                 break
  438.             
  439.             list.append(line)
  440.             total += len(line)
  441.             if sizehint and total >= sizehint:
  442.                 break
  443.                 continue
  444.         return list
  445.  
  446.     
  447.     def __iter__(self):
  448.         return self
  449.  
  450.     
  451.     def next(self):
  452.         line = self.readline()
  453.         if not line:
  454.             raise StopIteration
  455.         
  456.         return line
  457.  
  458.  
  459.