home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / socket.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2004-02-22  |  14KB  |  449 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.3)
  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. fromfd() -- create a socket object from an open file descriptor [*]
  13. gethostname() -- return the current hostname
  14. gethostbyname() -- map a hostname to its IP number
  15. gethostbyaddr() -- map an IP number or hostname to DNS info
  16. getservbyname() -- map a service name and a protocol name to a port number
  17. getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
  18. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  19. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  20. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  21. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  22. ssl() -- secure socket layer support (only available if configured)
  23. socket.getdefaulttimeout() -- get the default timeout value
  24. socket.setdefaulttimeout() -- set the default timeout value
  25.  
  26.  [*] not available on all platforms!
  27.  
  28. Special objects:
  29.  
  30. SocketType -- type object for socket objects
  31. error -- exception raised for I/O errors
  32. has_ipv6 -- boolean value indicating if IPv6 is supported
  33.  
  34. Integer constants:
  35.  
  36. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  37. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  38.  
  39. Many other constants may be defined; these may be used in calls to
  40. the setsockopt() and getsockopt() methods.
  41. """
  42. import _socket
  43. from _socket import *
  44. _have_ssl = False
  45.  
  46. try:
  47.     import _ssl
  48.     from _ssl import *
  49.     _have_ssl = True
  50. except ImportError:
  51.     pass
  52.  
  53. import os
  54. import sys
  55.  
  56. try:
  57.     from errno import EBADF
  58. except ImportError:
  59.     EBADF = 9
  60.  
  61. __all__ = [
  62.     '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 _have_ssl:
  69.     _realssl = ssl
  70.     
  71.     def ssl(sock, keyfile = None, certfile = None):
  72.         if hasattr(sock, '_sock'):
  73.             sock = sock._sock
  74.         
  75.         return _realssl(sock, keyfile, certfile)
  76.  
  77.  
  78. if sys.platform.lower().startswith('win'):
  79.     errorTab = { }
  80.     errorTab[10004] = 'The operation was interrupted.'
  81.     errorTab[10009] = 'A bad file handle was passed.'
  82.     errorTab[10013] = 'Permission denied.'
  83.     errorTab[10014] = 'A fault occurred on the network??'
  84.     errorTab[10022] = 'An invalid operation was attempted.'
  85.     errorTab[10035] = 'The socket operation would block'
  86.     errorTab[10036] = 'A blocking operation is already in progress.'
  87.     errorTab[10048] = 'The network address is in use.'
  88.     errorTab[10054] = 'The connection has been reset.'
  89.     errorTab[10058] = 'The network has been shut down.'
  90.     errorTab[10060] = 'The operation timed out.'
  91.     errorTab[10061] = 'Connection refused.'
  92.     errorTab[10063] = 'The name is too long.'
  93.     errorTab[10064] = 'The host is down.'
  94.     errorTab[10065] = 'The host is unreachable.'
  95.     __all__.append('errorTab')
  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.     is returned.
  106.     '''
  107.     name = name.strip()
  108.     if not name or name == '0.0.0.0':
  109.         name = gethostname()
  110.     
  111.     
  112.     try:
  113.         (hostname, aliases, ipaddrs) = gethostbyaddr(name)
  114.     except error:
  115.         pass
  116.  
  117.     aliases.insert(0, hostname)
  118.     for name in aliases:
  119.         if '.' in name:
  120.             break
  121.             continue
  122.     else:
  123.         name = hostname
  124.     return name
  125.  
  126. _socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'sendall', 'setblocking', 'settimeout', 'gettimeout', 'shutdown')
  127. if sys.platform == 'riscos':
  128.     _socketmethods = _socketmethods + ('sleeptaskw',)
  129.  
  130.  
  131. class _closedsocket(object):
  132.     __slots__ = []
  133.     
  134.     def _dummy(*args):
  135.         raise error(EBADF, 'Bad file descriptor')
  136.  
  137.     send = recv = sendto = recvfrom = __getattr__ = _dummy
  138.  
  139.  
  140. class _socketobject(object):
  141.     __doc__ = _realsocket.__doc__
  142.     __slots__ = [
  143.         '_sock',
  144.         'send',
  145.         'recv',
  146.         'sendto',
  147.         'recvfrom']
  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.         self.send = self._sock.send
  155.         self.recv = self._sock.recv
  156.         self.sendto = self._sock.sendto
  157.         self.recvfrom = self._sock.recvfrom
  158.  
  159.     
  160.     def close(self):
  161.         self._sock = _closedsocket()
  162.         self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
  163.  
  164.     close.__doc__ = _realsocket.close.__doc__
  165.     
  166.     def accept(self):
  167.         (sock, addr) = self._sock.accept()
  168.         return (_socketobject(_sock = sock), addr)
  169.  
  170.     accept.__doc__ = _realsocket.accept.__doc__
  171.     
  172.     def dup(self):
  173.         '''dup() -> socket object
  174.  
  175.         Return a new socket object connected to the same system resource.'''
  176.         return _socketobject(_sock = self._sock)
  177.  
  178.     
  179.     def makefile(self, mode = 'r', bufsize = -1):
  180.         '''makefile([mode[, bufsize]]) -> file object
  181.  
  182.         Return a regular file object corresponding to the socket.  The mode
  183.         and bufsize arguments are as for the built-in open() function.'''
  184.         return _fileobject(self._sock, mode, bufsize)
  185.  
  186.     _s = 'def %s(self, *args): return self._sock.%s(*args)\n\n%s.__doc__ = _realsocket.%s.__doc__\n'
  187.     for _m in _socketmethods:
  188.         exec _s % (_m, _m, _m, _m)
  189.     
  190.     del _m
  191.     del _s
  192.  
  193. socket = SocketType = _socketobject
  194.  
  195. class _fileobject(object):
  196.     '''Faux file object attached to a socket object.'''
  197.     default_bufsize = 8192
  198.     name = '<socket>'
  199.     __slots__ = [
  200.         'mode',
  201.         'bufsize',
  202.         'softspace',
  203.         '_sock',
  204.         '_rbufsize',
  205.         '_wbufsize',
  206.         '_rbuf',
  207.         '_wbuf']
  208.     
  209.     def __init__(self, sock, mode = 'rb', bufsize = -1):
  210.         self._sock = sock
  211.         self.mode = mode
  212.         if bufsize < 0:
  213.             bufsize = self.default_bufsize
  214.         
  215.         self.bufsize = bufsize
  216.         self.softspace = False
  217.         if bufsize == 0:
  218.             self._rbufsize = 1
  219.         elif bufsize == 1:
  220.             self._rbufsize = self.default_bufsize
  221.         else:
  222.             self._rbufsize = bufsize
  223.         self._wbufsize = bufsize
  224.         self._rbuf = ''
  225.         self._wbuf = []
  226.  
  227.     
  228.     def _getclosed(self):
  229.         return self._sock is not None
  230.  
  231.     closed = property(_getclosed, doc = 'True if the file is closed')
  232.     
  233.     def close(self):
  234.         
  235.         try:
  236.             if self._sock:
  237.                 self.flush()
  238.         finally:
  239.             self._sock = None
  240.  
  241.  
  242.     
  243.     def __del__(self):
  244.         
  245.         try:
  246.             self.close()
  247.         except:
  248.             pass
  249.  
  250.  
  251.     
  252.     def flush(self):
  253.         if self._wbuf:
  254.             buffer = ''.join(self._wbuf)
  255.             self._wbuf = []
  256.             self._sock.sendall(buffer)
  257.         
  258.  
  259.     
  260.     def fileno(self):
  261.         return self._sock.fileno()
  262.  
  263.     
  264.     def write(self, data):
  265.         data = str(data)
  266.         if not data:
  267.             return None
  268.         
  269.         self._wbuf.append(data)
  270.         if not self._wbufsize == 0:
  271.             if self._wbufsize == 1 and '\n' in data or self._get_wbuf_len() >= self._wbufsize:
  272.                 self.flush()
  273.             
  274.  
  275.     
  276.     def writelines(self, list):
  277.         self._wbuf.extend(filter(None, map(str, list)))
  278.         if self._wbufsize <= 1 or self._get_wbuf_len() >= self._wbufsize:
  279.             self.flush()
  280.         
  281.  
  282.     
  283.     def _get_wbuf_len(self):
  284.         buf_len = 0
  285.         for x in self._wbuf:
  286.             buf_len += len(x)
  287.         
  288.         return buf_len
  289.  
  290.     
  291.     def read(self, size = -1):
  292.         data = self._rbuf
  293.         if size < 0:
  294.             buffers = []
  295.             if data:
  296.                 buffers.append(data)
  297.             
  298.             self._rbuf = ''
  299.             if self._rbufsize <= 1:
  300.                 recv_size = self.default_bufsize
  301.             else:
  302.                 recv_size = self._rbufsize
  303.             while True:
  304.                 data = self._sock.recv(recv_size)
  305.                 if not data:
  306.                     break
  307.                 
  308.                 buffers.append(data)
  309.             return ''.join(buffers)
  310.         else:
  311.             buf_len = len(data)
  312.             if buf_len >= size:
  313.                 self._rbuf = data[size:]
  314.                 return data[:size]
  315.             
  316.             buffers = []
  317.             if data:
  318.                 buffers.append(data)
  319.             
  320.             self._rbuf = ''
  321.             while True:
  322.                 left = size - buf_len
  323.                 recv_size = max(self._rbufsize, left)
  324.                 data = self._sock.recv(recv_size)
  325.                 if not data:
  326.                     break
  327.                 
  328.                 buffers.append(data)
  329.                 n = len(data)
  330.                 if n >= left:
  331.                     self._rbuf = data[left:]
  332.                     buffers[-1] = data[:left]
  333.                     break
  334.                 
  335.                 buf_len += n
  336.             return ''.join(buffers)
  337.  
  338.     
  339.     def readline(self, size = -1):
  340.         data = self._rbuf
  341.         if size < 0:
  342.             if self._rbufsize <= 1:
  343.                 if not data == '':
  344.                     raise AssertionError
  345.                 buffers = []
  346.                 recv = self._sock.recv
  347.                 while data != '\n':
  348.                     data = recv(1)
  349.                     if not data:
  350.                         break
  351.                     
  352.                     buffers.append(data)
  353.                 return ''.join(buffers)
  354.             
  355.             nl = data.find('\n')
  356.             if nl >= 0:
  357.                 nl += 1
  358.                 self._rbuf = data[nl:]
  359.                 return data[:nl]
  360.             
  361.             buffers = []
  362.             if data:
  363.                 buffers.append(data)
  364.             
  365.             self._rbuf = ''
  366.             while True:
  367.                 data = self._sock.recv(self._rbufsize)
  368.                 if not data:
  369.                     break
  370.                 
  371.                 buffers.append(data)
  372.                 nl = data.find('\n')
  373.                 if nl >= 0:
  374.                     nl += 1
  375.                     self._rbuf = data[nl:]
  376.                     buffers[-1] = data[:nl]
  377.                     break
  378.                     continue
  379.             return ''.join(buffers)
  380.         else:
  381.             nl = data.find('\n', 0, size)
  382.             if nl >= 0:
  383.                 nl += 1
  384.                 self._rbuf = data[nl:]
  385.                 return data[:nl]
  386.             
  387.             buf_len = len(data)
  388.             if buf_len >= size:
  389.                 self._rbuf = data[size:]
  390.                 return data[:size]
  391.             
  392.             buffers = []
  393.             if data:
  394.                 buffers.append(data)
  395.             
  396.             self._rbuf = ''
  397.             while True:
  398.                 data = self._sock.recv(self._rbufsize)
  399.                 if not data:
  400.                     break
  401.                 
  402.                 buffers.append(data)
  403.                 left = size - buf_len
  404.                 nl = data.find('\n', 0, left)
  405.                 if nl >= 0:
  406.                     nl += 1
  407.                     self._rbuf = data[nl:]
  408.                     buffers[-1] = data[:nl]
  409.                     break
  410.                 
  411.                 n = len(data)
  412.                 if n >= left:
  413.                     self._rbuf = data[left:]
  414.                     buffers[-1] = data[:left]
  415.                     break
  416.                 
  417.                 buf_len += n
  418.             return ''.join(buffers)
  419.  
  420.     
  421.     def readlines(self, sizehint = 0):
  422.         total = 0
  423.         list = []
  424.         while True:
  425.             line = self.readline()
  426.             if not line:
  427.                 break
  428.             
  429.             list.append(line)
  430.             total += len(line)
  431.             if sizehint and total >= sizehint:
  432.                 break
  433.                 continue
  434.         return list
  435.  
  436.     
  437.     def __iter__(self):
  438.         return self
  439.  
  440.     
  441.     def next(self):
  442.         line = self.readline()
  443.         if not line:
  444.             raise StopIteration
  445.         
  446.         return line
  447.  
  448.  
  449.