home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / GestionFichiers / metamorphose / metamorphose2_0.8.2_setup.exe / metamorphose2.exe / socket.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2011-01-12  |  12KB  |  415 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import _socket
  5. from _socket import *
  6.  
  7. try:
  8.     import _ssl
  9. except ImportError:
  10.     pass
  11.  
  12.  
  13. def ssl(sock, keyfile = None, certfile = None):
  14.     import ssl as _realssl
  15.     warnings.warn('socket.ssl() is deprecated.  Use ssl.wrap_socket() instead.', DeprecationWarning, stacklevel = 2)
  16.     return _realssl.sslwrap_simple(sock, keyfile, certfile)
  17.  
  18. from _ssl import SSLError as sslerror
  19. from _ssl import RAND_add, RAND_egd, RAND_status, SSL_ERROR_ZERO_RETURN, SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE, SSL_ERROR_WANT_X509_LOOKUP, SSL_ERROR_SYSCALL, SSL_ERROR_SSL, SSL_ERROR_WANT_CONNECT, SSL_ERROR_EOF, SSL_ERROR_INVALID_ERROR_CODE
  20. import os
  21. import sys
  22. import warnings
  23.  
  24. try:
  25.     from cStringIO import StringIO
  26. except ImportError:
  27.     from StringIO import StringIO
  28.  
  29.  
  30. try:
  31.     from errno import EBADF
  32. except ImportError:
  33.     EBADF = 9
  34.  
  35. __all__ = [
  36.     'getfqdn',
  37.     'create_connection']
  38. __all__.extend(os._get_exports_list(_socket))
  39. _realsocket = socket
  40. if sys.platform.lower().startswith('win'):
  41.     errorTab = { }
  42.     errorTab[10004] = 'The operation was interrupted.'
  43.     errorTab[10009] = 'A bad file handle was passed.'
  44.     errorTab[10013] = 'Permission denied.'
  45.     errorTab[10014] = 'A fault occurred on the network??'
  46.     errorTab[10022] = 'An invalid operation was attempted.'
  47.     errorTab[10035] = 'The socket operation would block'
  48.     errorTab[10036] = 'A blocking operation is already in progress.'
  49.     errorTab[10048] = 'The network address is in use.'
  50.     errorTab[10054] = 'The connection has been reset.'
  51.     errorTab[10058] = 'The network has been shut down.'
  52.     errorTab[10060] = 'The operation timed out.'
  53.     errorTab[10061] = 'Connection refused.'
  54.     errorTab[10063] = 'The name is too long.'
  55.     errorTab[10064] = 'The host is down.'
  56.     errorTab[10065] = 'The host is unreachable.'
  57.     __all__.append('errorTab')
  58.  
  59.  
  60. def getfqdn(name = ''):
  61.     name = name.strip()
  62.     if not name or name == '0.0.0.0':
  63.         name = gethostname()
  64.     
  65.     
  66.     try:
  67.         (hostname, aliases, ipaddrs) = gethostbyaddr(name)
  68.     except error:
  69.         pass
  70.  
  71.     aliases.insert(0, hostname)
  72.     for name in aliases:
  73.         if '.' in name:
  74.             break
  75.             continue
  76.     else:
  77.         name = hostname
  78.     return name
  79.  
  80. _socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'sendall', 'setblocking', 'settimeout', 'gettimeout', 'shutdown')
  81. if os.name == 'nt':
  82.     _socketmethods = _socketmethods + ('ioctl',)
  83.  
  84. if sys.platform == 'riscos':
  85.     _socketmethods = _socketmethods + ('sleeptaskw',)
  86.  
  87. _delegate_methods = ('recv', 'recvfrom', 'recv_into', 'recvfrom_into', 'send', 'sendto')
  88.  
  89. class _closedsocket(object):
  90.     __slots__ = []
  91.     
  92.     def _dummy(*args):
  93.         raise error(EBADF, 'Bad file descriptor')
  94.  
  95.     send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
  96.     __getattr__ = _dummy
  97.  
  98.  
  99. class _socketobject(object):
  100.     __doc__ = _realsocket.__doc__
  101.     __slots__ = [
  102.         '_sock',
  103.         '__weakref__'] + list(_delegate_methods)
  104.     
  105.     def __init__(self, family = AF_INET, type = SOCK_STREAM, proto = 0, _sock = None):
  106.         if _sock is None:
  107.             _sock = _realsocket(family, type, proto)
  108.         
  109.         self._sock = _sock
  110.         for method in _delegate_methods:
  111.             setattr(self, method, getattr(_sock, method))
  112.         
  113.  
  114.     
  115.     def close(self):
  116.         self._sock = _closedsocket()
  117.         dummy = self._sock._dummy
  118.         for method in _delegate_methods:
  119.             setattr(self, method, dummy)
  120.         
  121.  
  122.     close.__doc__ = _realsocket.close.__doc__
  123.     
  124.     def accept(self):
  125.         (sock, addr) = self._sock.accept()
  126.         return (_socketobject(_sock = sock), addr)
  127.  
  128.     accept.__doc__ = _realsocket.accept.__doc__
  129.     
  130.     def dup(self):
  131.         return _socketobject(_sock = self._sock)
  132.  
  133.     
  134.     def makefile(self, mode = 'r', bufsize = -1):
  135.         return _fileobject(self._sock, mode, bufsize)
  136.  
  137.     family = property((lambda self: self._sock.family), doc = 'the socket family')
  138.     type = property((lambda self: self._sock.type), doc = 'the socket type')
  139.     proto = property((lambda self: self._sock.proto), doc = 'the socket protocol')
  140.     _s = 'def %s(self, *args): return self._sock.%s(*args)\n\n%s.__doc__ = _realsocket.%s.__doc__\n'
  141.     for _m in _socketmethods:
  142.         exec _s % (_m, _m, _m, _m)
  143.     
  144.     del _m
  145.     del _s
  146.  
  147. socket = SocketType = _socketobject
  148.  
  149. class _fileobject(object):
  150.     default_bufsize = 8192
  151.     name = '<socket>'
  152.     __slots__ = [
  153.         'mode',
  154.         'bufsize',
  155.         'softspace',
  156.         '_sock',
  157.         '_rbufsize',
  158.         '_wbufsize',
  159.         '_rbuf',
  160.         '_wbuf',
  161.         '_wbuf_len',
  162.         '_close']
  163.     
  164.     def __init__(self, sock, mode = 'rb', bufsize = -1, close = False):
  165.         self._sock = sock
  166.         self.mode = mode
  167.         if bufsize < 0:
  168.             bufsize = self.default_bufsize
  169.         
  170.         self.bufsize = bufsize
  171.         self.softspace = False
  172.         if bufsize == 0:
  173.             self._rbufsize = 1
  174.         elif bufsize == 1:
  175.             self._rbufsize = self.default_bufsize
  176.         else:
  177.             self._rbufsize = bufsize
  178.         self._wbufsize = bufsize
  179.         self._rbuf = StringIO()
  180.         self._wbuf = []
  181.         self._wbuf_len = 0
  182.         self._close = close
  183.  
  184.     
  185.     def _getclosed(self):
  186.         return self._sock is None
  187.  
  188.     closed = property(_getclosed, doc = 'True if the file is closed')
  189.     
  190.     def close(self):
  191.         
  192.         try:
  193.             if self._sock:
  194.                 self.flush()
  195.         finally:
  196.             if self._close:
  197.                 self._sock.close()
  198.             
  199.             self._sock = None
  200.  
  201.  
  202.     
  203.     def __del__(self):
  204.         
  205.         try:
  206.             self.close()
  207.         except:
  208.             pass
  209.  
  210.  
  211.     
  212.     def flush(self):
  213.         if self._wbuf:
  214.             buffer = ''.join(self._wbuf)
  215.             self._wbuf = []
  216.             self._wbuf_len = 0
  217.             self._sock.sendall(buffer)
  218.         
  219.  
  220.     
  221.     def fileno(self):
  222.         return self._sock.fileno()
  223.  
  224.     
  225.     def write(self, data):
  226.         data = str(data)
  227.         if not data:
  228.             return None
  229.         self._wbuf.append(data)
  230.         self._wbuf_len += len(data)
  231.         if not self._wbufsize == 0:
  232.             pass
  233.  
  234.     
  235.     def writelines(self, list):
  236.         lines = filter(None, map(str, list))
  237.         self._wbuf_len += sum(map(len, lines))
  238.         self._wbuf.extend(lines)
  239.         if self._wbufsize <= 1 or self._wbuf_len >= self._wbufsize:
  240.             self.flush()
  241.         
  242.  
  243.     
  244.     def _get_wbuf_len(self):
  245.         return self._wbuf_len
  246.  
  247.     
  248.     def read(self, size = -1):
  249.         rbufsize = max(self._rbufsize, self.default_bufsize)
  250.         buf = self._rbuf
  251.         buf.seek(0, 2)
  252.         if size < 0:
  253.             self._rbuf = StringIO()
  254.             while True:
  255.                 data = self._sock.recv(rbufsize)
  256.                 if not data:
  257.                     break
  258.                 
  259.                 buf.write(data)
  260.             return buf.getvalue()
  261.         buf_len = buf.tell()
  262.         if buf_len >= size:
  263.             buf.seek(0)
  264.             rv = buf.read(size)
  265.             self._rbuf = StringIO()
  266.             self._rbuf.write(buf.read())
  267.             return rv
  268.         self._rbuf = StringIO()
  269.         while True:
  270.             left = size - buf_len
  271.             data = self._sock.recv(left)
  272.             n = len(data)
  273.             if n == size and not buf_len:
  274.                 return data
  275.             buf.write(data)
  276.             buf_len += n
  277.             del data
  278.             continue
  279.             None if n == left else None if not data else size < 0
  280.         return buf.getvalue()
  281.  
  282.     
  283.     def readline(self, size = -1):
  284.         buf = self._rbuf
  285.         buf.seek(0, 2)
  286.         if buf.tell() > 0:
  287.             buf.seek(0)
  288.             bline = buf.readline(size)
  289.             if bline.endswith('\n') or len(bline) == size:
  290.                 self._rbuf = StringIO()
  291.                 self._rbuf.write(buf.read())
  292.                 return bline
  293.             del bline
  294.         
  295.         if size < 0:
  296.             if self._rbufsize <= 1:
  297.                 buf.seek(0)
  298.                 buffers = [
  299.                     buf.read()]
  300.                 self._rbuf = StringIO()
  301.                 data = None
  302.                 recv = self._sock.recv
  303.                 while data != '\n':
  304.                     data = recv(1)
  305.                     if not data:
  306.                         break
  307.                     
  308.                     buffers.append(data)
  309.                 return ''.join(buffers)
  310.             buf.seek(0, 2)
  311.             self._rbuf = StringIO()
  312.             while True:
  313.                 data = self._sock.recv(self._rbufsize)
  314.                 if not data:
  315.                     break
  316.                 
  317.                 nl = data.find('\n')
  318.                 if nl >= 0:
  319.                     nl += 1
  320.                     buf.write(data[:nl])
  321.                     self._rbuf.write(data[nl:])
  322.                     del data
  323.                     break
  324.                 
  325.                 buf.write(data)
  326.             return buf.getvalue()
  327.         buf.seek(0, 2)
  328.         buf_len = buf.tell()
  329.         if buf_len >= size:
  330.             buf.seek(0)
  331.             rv = buf.read(size)
  332.             self._rbuf = StringIO()
  333.             self._rbuf.write(buf.read())
  334.             return rv
  335.         self._rbuf = StringIO()
  336.         while True:
  337.             data = self._sock.recv(self._rbufsize)
  338.             left = size - buf_len
  339.             nl = data.find('\n', 0, left)
  340.             if nl >= 0:
  341.                 nl += 1
  342.                 self._rbuf.write(data[nl:])
  343.                 if buf_len:
  344.                     buf.write(data[:nl])
  345.                     break
  346.                 else:
  347.                     return data[:nl]
  348.             buf_len
  349.             n = len(data)
  350.             if n == size and not buf_len:
  351.                 return data
  352.             buf.write(data)
  353.             buf_len += n
  354.             continue
  355.             None if n >= left else None if not data else size < 0
  356.         return buf.getvalue()
  357.  
  358.     
  359.     def readlines(self, sizehint = 0):
  360.         total = 0
  361.         list = []
  362.         while True:
  363.             line = self.readline()
  364.             if not line:
  365.                 break
  366.             
  367.             list.append(line)
  368.             total += len(line)
  369.             if sizehint and total >= sizehint:
  370.                 break
  371.                 continue
  372.         return list
  373.  
  374.     
  375.     def __iter__(self):
  376.         return self
  377.  
  378.     
  379.     def next(self):
  380.         line = self.readline()
  381.         if not line:
  382.             raise StopIteration
  383.         line
  384.         return line
  385.  
  386.  
  387. _GLOBAL_DEFAULT_TIMEOUT = object()
  388.  
  389. def create_connection(address, timeout = _GLOBAL_DEFAULT_TIMEOUT):
  390.     msg = 'getaddrinfo returns an empty list'
  391.     (host, port) = address
  392.     for res in getaddrinfo(host, port, 0, SOCK_STREAM):
  393.         (af, socktype, proto, canonname, sa) = res
  394.         sock = None
  395.         
  396.         try:
  397.             sock = socket(af, socktype, proto)
  398.             if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  399.                 sock.settimeout(timeout)
  400.             
  401.             sock.connect(sa)
  402.             return sock
  403.         continue
  404.         except error:
  405.             msg = None
  406.             if sock is not None:
  407.                 sock.close()
  408.             
  409.             sock is not None
  410.         
  411.  
  412.     
  413.     raise error, msg
  414.  
  415.