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