home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / common / AsyncSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  14.9 KB  |  519 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from threading import currentThread
  5. import collections
  6. import socket
  7. import errno
  8. import warnings
  9. from socket import _socket as socket
  10. import threading
  11. import AsyncoreThread
  12. import util
  13. from util.primitives.synchronization import lock as util_lock
  14. import traceback
  15. import sys
  16. import logging
  17. log = logging.getLogger('AsyncSocket')
  18. from asynchat import async_chat as _async_chat, find_prefix_at_end
  19. from asyncore import compact_traceback
  20. import asyncore
  21. _ok_errors = set((asyncore.EINPROGRESS, asyncore.EALREADY, asyncore.EWOULDBLOCK))
  22.  
  23. class async_chat(_async_chat):
  24.     
  25.     def connect(self, address):
  26.         self.connected = False
  27.         err = self.socket.connect_ex(address)
  28.         if err in _ok_errors:
  29.             return None
  30.         if err in (0, asyncore.EISCONN):
  31.             self.addr = address
  32.             self.handle_connect_event()
  33.         else:
  34.             raise socket.error, (err, asyncore.errorcode.get(err, 'unknown'))
  35.         return err in _ok_errors
  36.  
  37.     
  38.     def recv(self, buffer_size):
  39.         
  40.         try:
  41.             data = self.socket.recv(buffer_size)
  42.             if not data:
  43.                 self.handle_close()
  44.                 return ''
  45.             return data
  46.         except socket.error:
  47.             why = None
  48.             if why.args[0] == errno.EWOULDBLOCK:
  49.                 pass
  50.             elif why.args[0] in [
  51.                 errno.ECONNRESET,
  52.                 errno.ENOTCONN,
  53.                 errno.ESHUTDOWN,
  54.                 errno.ECONNABORTED]:
  55.                 self.handle_close()
  56.                 return ''
  57.             raise 
  58.  
  59.  
  60.     
  61.     def handle_read(self):
  62.         
  63.         try:
  64.             data = self.recv(self.ac_in_buffer_size)
  65.         except socket.error:
  66.             why = None
  67.             self.handle_error(why)
  68.             return None
  69.  
  70.         if data:
  71.             self.process_data(data)
  72.         
  73.  
  74.     
  75.     def process_data(self, data):
  76.         self.ac_in_buffer = self.ac_in_buffer + data
  77.         while self.ac_in_buffer:
  78.             lb = len(self.ac_in_buffer)
  79.             terminator = self.get_terminator()
  80.             if not terminator:
  81.                 self.collect_incoming_data(self.ac_in_buffer)
  82.                 self.ac_in_buffer = ''
  83.                 continue
  84.             if isinstance(terminator, int) or isinstance(terminator, long):
  85.                 n = terminator
  86.                 if lb < n:
  87.                     self.collect_incoming_data(self.ac_in_buffer)
  88.                     self.ac_in_buffer = ''
  89.                     self.terminator = self.terminator - lb
  90.                 else:
  91.                     self.collect_incoming_data(self.ac_in_buffer[:n])
  92.                     self.ac_in_buffer = self.ac_in_buffer[n:]
  93.                     self.terminator = 0
  94.                     self.found_terminator()
  95.             lb < n
  96.             terminator_len = len(terminator)
  97.             index = self.ac_in_buffer.find(terminator)
  98.             if index != -1:
  99.                 if index > 0:
  100.                     self.collect_incoming_data(self.ac_in_buffer[:index])
  101.                 
  102.                 self.ac_in_buffer = self.ac_in_buffer[index + terminator_len:]
  103.                 self.found_terminator()
  104.                 continue
  105.             index = find_prefix_at_end(self.ac_in_buffer, terminator)
  106.             if index:
  107.                 if index != lb:
  108.                     self.collect_incoming_data(self.ac_in_buffer[:-index])
  109.                     self.ac_in_buffer = self.ac_in_buffer[-index:]
  110.                 
  111.                 break
  112.                 continue
  113.             self.collect_incoming_data(self.ac_in_buffer)
  114.             self.ac_in_buffer = ''
  115.  
  116.  
  117.  
  118. class AsyncSocket(object, async_chat):
  119.     
  120.     def __init__(self, conn = None, family = socket.AF_INET, type = socket.SOCK_STREAM):
  121.         object.__init__(self)
  122.         self._lock = threading.RLock()
  123.         self._AsyncSocket__refcount = 0
  124.         self._proxy_setup = False
  125.         self._AsyncSocket__proxysocket = None
  126.         self._handlers = []
  127.         self.data = ''
  128.         self.family = family
  129.         self.type = type
  130.         if conn is False:
  131.             async_chat.__init__(self)
  132.             self._AsyncSocket__refcount += 1
  133.             AsyncoreThread.start()
  134.         elif conn is None:
  135.             async_chat.__init__(self)
  136.             self.make_socket(family = family, type = type)
  137.         else:
  138.             async_chat.__init__(self, conn)
  139.             self._AsyncSocket__refcount += 1
  140.             AsyncoreThread.start()
  141.  
  142.     
  143.     def make_socket(self, proxy = True, family = socket.AF_INET, type = socket.SOCK_STREAM):
  144.         if getattr(self, '_fileno', None) is not None:
  145.             self.del_channel()
  146.         
  147.         if proxy:
  148.             proxy = util.GetProxyInfo()
  149.         
  150.         self.create_socket(family, type)
  151.         self._AsyncSocket__refcount += 1
  152.         AsyncoreThread.start()
  153.  
  154.     make_socket = util_lock(make_socket)
  155.     
  156.     def bind(self, addr):
  157.         retval = self.socket.bind(addr)
  158.         self.addr = self.socket.getsockname()
  159.         return retval
  160.  
  161.     socketbind = bind
  162.     
  163.     def log_info(self, message, type = 'info'):
  164.         if __debug__ or type != 'info':
  165.             etype = sys.exc_info()[0]
  166.             if etype is not None:
  167.                 traceback.print_exc()
  168.             
  169.         
  170.  
  171.     
  172.     def connect(self, address, use_proxy = True, callback = None):
  173.         if not self.family == socket.AF_INET and self.type == socket.SOCK_STREAM:
  174.             use_proxy = False
  175.         
  176.         if use_proxy:
  177.             proxyinfo = self.GetProxyInfo()
  178.         else:
  179.             proxyinfo = { }
  180.         log.info('asyncsocket.connect%r', address)
  181.         if isinstance(self, ProxySocket):
  182.             log.info('\t\twas already a proxy socket')
  183.             old_error = (None, callback.error)
  184.             
  185.             callback.error = lambda : (self.handle_close(), old_error())
  186.             async_chat.connect(self, address)
  187.         elif not (self._proxy_setup) and proxyinfo:
  188.             log.info('\t\tneed to setup proxies')
  189.             sck = self.socket
  190.             self.del_channel()
  191.             psck = ProxySocket(proxyinfo, sck, self.set_socket)
  192.             self._AsyncSocket__proxysocket = psck
  193.             import common
  194.             if common.pref('socket.retry_noproxy', type = bool, default = sys.DEV):
  195.                 
  196.                 def retry_noproxy(*a):
  197.                     log.info('Retry no proxy: %r', self)
  198.                     self._AsyncSocket__proxysocket = None
  199.                     self.make_socket(proxy = False, family = self.family, type = self.type)
  200.                     AsyncSocket.connect(self, address, use_proxy = False, callback = callback)
  201.  
  202.                 psck.connect(address, success = callback.success, error = retry_noproxy)
  203.             else:
  204.                 psck.connect(address, callback = callback)
  205.         elif self._proxy_setup:
  206.             log.info('\t\tproxy was already setup, calling handle_connect')
  207.             self.handle_connect_event()
  208.         elif not proxyinfo:
  209.             log.info('\t\tno proxy neecessary')
  210.             self._proxy_setup = True
  211.             (None, AsyncoreThread.call_later)((lambda : async_chat.connect(self, address)), callback = callback, verbose = False)
  212.         else:
  213.             log.info('\t\terrr you didnt finish')
  214.  
  215.     connect = util.callsback(connect)
  216.     
  217.     def set_socket(self, sock, map = None):
  218.         async_chat.set_socket(self, sock, map)
  219.         return self
  220.  
  221.     
  222.     def GetProxyInfo(self):
  223.         return util.GetProxyInfo()
  224.  
  225.     
  226.     def close(self):
  227.         
  228.         def _doit():
  229.             log.info('closing socket %r', self)
  230.             psck = self._AsyncSocket__proxysocket
  231.             if psck is not None:
  232.                 log.info('Closing proxy socket: %r', psck)
  233.                 psck.close()
  234.             
  235.             self._AsyncSocket__proxysocket = None
  236.             async_chat.close(self)
  237.  
  238.         AsyncoreThread.call_later(_doit)
  239.  
  240.     
  241.     def close_when_done(self):
  242.         (AsyncoreThread.call_later,)((lambda : async_chat.close_when_done(self)))
  243.  
  244.     
  245.     def collect_incoming_data(self, data):
  246.         self.data += data
  247.  
  248.     
  249.     def push_handler(self, h):
  250.         self._handlers.append(h)
  251.  
  252.     
  253.     def pop_handler(self):
  254.         self._handlers.pop()
  255.  
  256.     
  257.     def found_terminator(self):
  258.         data = self.data
  259.         self.data = ''
  260.         return self.handle_data(data)
  261.  
  262.     
  263.     def handle_data(self, data):
  264.         if self._handlers:
  265.             return self._handlers[-1](data)
  266.         return data
  267.  
  268.     
  269.     def handle_close(self):
  270.         while self._handlers:
  271.             self.pop_handler()
  272.  
  273.     
  274.     def handle_error(self, e = None):
  275.         if getattr(e, 'verbose', True):
  276.             traceback.print_exc()
  277.         
  278.         log.error('Exception for %r: %r', self, e)
  279.         if e is None:
  280.             self.close()
  281.             return None
  282.         
  283.         try:
  284.             raise e
  285.         except socket.error:
  286.             e is None
  287.             e is None
  288.             log.critical('Closing socket %r due to socket error', self)
  289.             self.close()
  290.         except Exception:
  291.             log.error('Unexpected exception in AsyncSocket.handle_error: %r', e)
  292.         except:
  293.             e is None
  294.  
  295.  
  296.     
  297.     def handle_expt(self):
  298.         log.critical('%r: handle_expt (OOB data)...closing', self)
  299.         self.close()
  300.  
  301.     
  302.     def handle_error(self, e = None):
  303.         (nil, t, v, tbinfo) = compact_traceback()
  304.         
  305.         try:
  306.             self_repr = repr(self)
  307.         except:
  308.             self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
  309.  
  310.         self.log_info('uncaptured python exception, closing channel %s (%s:%s %s)' % (self_repr, t, v, tbinfo), 'error')
  311.         self.close()
  312.  
  313.     
  314.     def _repr(self):
  315.         return ''
  316.  
  317.     
  318.     def __repr__(self):
  319.         
  320.         try:
  321.             sock = self.socket.getsockname()
  322.         except Exception:
  323.             sock = 'ERROR'
  324.  
  325.         sock = '%s:%s' % sock
  326.         
  327.         try:
  328.             peer = self.socket.getpeername()
  329.         except Exception:
  330.             peer = 'ERROR'
  331.  
  332.         peer = '%s:%s' % peer
  333.         return '<%s %s->%s r:%s w:%s %s at 0x%08X>' % (type(self).__name__, sock, peer, self.readable(), self.writable(), self._repr(), id(self))
  334.  
  335.  
  336.  
  337. class AsyncServer(AsyncSocket):
  338.     SocketClass = AsyncSocket
  339.     
  340.     def __init__(self):
  341.         super(AsyncServer, self).__init__()
  342.         self.socket = None
  343.  
  344.     
  345.     def bind(self, host = '', port = 0):
  346.         self._hostport = (host, port)
  347.         self.make_socket(proxy = False)
  348.         super(AsyncServer, self).bind(self._hostport)
  349.         return self.getsockname()
  350.  
  351.     
  352.     def getsockname(self):
  353.         return self.socket.getsockname()
  354.  
  355.     
  356.     def handle_accept(self):
  357.         accepted = self.accept()
  358.         if accepted is None:
  359.             return None
  360.         (conn, address) = accepted
  361.         sck = self.SocketClass(conn)
  362.         sck.handle_connect_event()
  363.         return sck
  364.  
  365.  
  366. from proxysockets import ProxySocket
  367.  
  368. class AsyncUdpSocket(AsyncSocket):
  369.     
  370.     def __init__(self, conn = None, family = socket.AF_INET, type = socket.SOCK_DGRAM):
  371.         AsyncSocket.__init__(self, conn, family, type)
  372.         self.connected = False
  373.         self.discard_buffers()
  374.  
  375.     
  376.     def on_connect(self):
  377.         if self.connected:
  378.             return None
  379.         self.handle_connect_event()
  380.  
  381.     
  382.     def make_socket(self, proxy = False, family = socket.AF_INET, type = socket.SOCK_DGRAM):
  383.         return AsyncSocket.make_socket(self, proxy, family, type)
  384.  
  385.     
  386.     def sendto(self, data, addr):
  387.         if not data:
  388.             return None
  389.         
  390.         try:
  391.             result = self.socket.sendto(data, addr)
  392.             return result
  393.         except socket.error:
  394.             data
  395.             why = data
  396.             if why[0] == errno.EWOULDBLOCK:
  397.                 return 0
  398.             raise 
  399.             return 0
  400.             why[0] == errno.EWOULDBLOCK
  401.  
  402.  
  403.     
  404.     def recvfrom(self, buffer_size):
  405.         data = ''
  406.         addr = ('', 0)
  407.         
  408.         try:
  409.             (data, addr) = self.socket.recvfrom(buffer_size)
  410.         except socket.error:
  411.             why = None
  412.             if why[0] in (errno.ECONNRESET, errno.EWOULDBLOCK):
  413.                 pass
  414.             elif why[0] in (errno.ENOTCONN, errno.ESHUTDOWN):
  415.                 self.handle_close()
  416.             else:
  417.                 raise 
  418.             why[0] in (errno.ECONNRESET, errno.EWOULDBLOCK)
  419.  
  420.         return (data, addr)
  421.  
  422.     
  423.     def handle_read(self):
  424.         
  425.         try:
  426.             (data, addr) = self.recvfrom(self.ac_in_buffer_size)
  427.         except socket.error:
  428.             why = None
  429.             self.handle_error(why)
  430.             return None
  431.  
  432.         if data:
  433.             self.collect_incoming_data(data, addr)
  434.         
  435.  
  436.     
  437.     def push_with_producer(self, prod):
  438.         if type(prod) is str:
  439.             raise TypeError()
  440.         type(prod) is str
  441.         AsyncSocket.push_with_producer(self, prod)
  442.  
  443.     
  444.     def push(self, prod):
  445.         if type(prod) is str:
  446.             raise TypeError()
  447.         type(prod) is str
  448.         AsyncSocket.push(self, prod)
  449.  
  450.     
  451.     def refill_buffer(self):
  452.         while self.producer_fifo and self.connected:
  453.             first = self.producer_fifo.popleft()
  454.             if not first:
  455.                 data = first
  456.                 addr = ('', 0)
  457.             elif isinstance(first, tuple):
  458.                 (data, addr) = first
  459.             else:
  460.                 from_prod = first.more()
  461.                 if isinstance(from_prod, tuple):
  462.                     (data, addr) = from_prod
  463.                 else:
  464.                     data = from_prod
  465.                     addr = self.endpoint
  466.                 if data is None:
  467.                     continue
  468.                 if data is sentinel:
  469.                     self.producer_fifo.appendleft(first)
  470.                     return None
  471.                 self.producer_fifo.appendleft(first)
  472.                 self.producer_fifo.appendleft((data, addr))
  473.             if data is None:
  474.                 self.handle_close()
  475.                 return None
  476.             self.ac_out_buffer.append((data, addr))
  477.             return None
  478.             continue
  479.             data is None
  480.  
  481.     
  482.     def initiate_send(self):
  483.         if not self.ac_out_buffer:
  484.             self.refill_buffer()
  485.         
  486.         if not self.ac_out_buffer:
  487.             return None
  488.         
  489.         try:
  490.             num_sent = self.sendto(*self.ac_out_buffer[0])
  491.         except socket.error:
  492.             self.ac_out_buffer
  493.             e = self.ac_out_buffer
  494.             self.handle_error(e)
  495.             return None
  496.  
  497.         if num_sent:
  498.             del self.ac_out_buffer[0]
  499.         
  500.  
  501.     
  502.     def discard_buffers(self):
  503.         self.ac_in_buffer = []
  504.         self.ac_out_buffer = []
  505.         while self.producer_fifo:
  506.             self.producer_fifo.popleft()
  507.  
  508.     
  509.     def readable(self):
  510.         return self.connected
  511.  
  512.     
  513.     def writable(self):
  514.         if len(self.ac_out_buffer) == 0 and len(self.producer_fifo) == 0:
  515.             pass
  516.         return not (self.connected)
  517.  
  518.  
  519.