home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / common / AsyncSocket.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  13.3 KB  |  478 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.             psck.connect(address, callback = callback)
  194.         elif self._proxy_setup:
  195.             log.info('\t\tproxy was already setup, calling handle_connect')
  196.             self.handle_connect_event()
  197.         elif not proxyinfo:
  198.             log.info('\t\tno proxy neecessary')
  199.             self._proxy_setup = True
  200.             (None, AsyncoreThread.call_later)((lambda : async_chat.connect(self, address)), callback = callback, verbose = False)
  201.         else:
  202.             log.info('\t\terrr you didnt finish')
  203.  
  204.     connect = util.callsback(connect)
  205.     
  206.     def set_socket(self, sock, map = None):
  207.         async_chat.set_socket(self, sock, map)
  208.         return self
  209.  
  210.     
  211.     def GetProxyInfo(self):
  212.         return util.GetProxyInfo()
  213.  
  214.     
  215.     def close(self):
  216.         
  217.         def _doit():
  218.             log.info('closing socket %r', self)
  219.             psck = self._AsyncSocket__proxysocket
  220.             if psck is not None:
  221.                 log.info('Closing proxy socket: %r', psck)
  222.                 psck.close()
  223.             
  224.             self._AsyncSocket__proxysocket = None
  225.             async_chat.close(self)
  226.  
  227.         AsyncoreThread.call_later(_doit)
  228.  
  229.     
  230.     def close_when_done(self):
  231.         (AsyncoreThread.call_later,)((lambda : async_chat.close_when_done(self)))
  232.  
  233.     
  234.     def collect_incoming_data(self, data):
  235.         self.data += data
  236.  
  237.     
  238.     def push_handler(self, h):
  239.         self._handlers.append(h)
  240.  
  241.     
  242.     def pop_handler(self):
  243.         self._handlers.pop()
  244.  
  245.     
  246.     def found_terminator(self):
  247.         data = self.data
  248.         self.data = ''
  249.         return self.handle_data(data)
  250.  
  251.     
  252.     def handle_data(self, data):
  253.         if self._handlers:
  254.             return self._handlers[-1](data)
  255.         return data
  256.  
  257.     
  258.     def handle_close(self):
  259.         while self._handlers:
  260.             self.pop_handler()
  261.  
  262.     
  263.     def handle_error(self, e = None):
  264.         if getattr(e, 'verbose', True):
  265.             traceback.print_exc()
  266.         
  267.         log.error('Exception for %r: %r', self, e)
  268.         if e is None:
  269.             self.close()
  270.             return None
  271.         
  272.         try:
  273.             raise e
  274.         except socket.error:
  275.             e is None
  276.             e is None
  277.             log.critical('Closing socket %r due to socket error', self)
  278.             self.close()
  279.         except Exception:
  280.             log.error('Unexpected exception in AsyncSocket.handle_error: %r', e)
  281.         except:
  282.             e is None
  283.  
  284.  
  285.     
  286.     def handle_expt(self):
  287.         log.critical('%r: handle_expt (OOB data)...closing', self)
  288.         self.close()
  289.  
  290.     
  291.     def handle_error(self, e = None):
  292.         (nil, t, v, tbinfo) = compact_traceback()
  293.         
  294.         try:
  295.             self_repr = repr(self)
  296.         except:
  297.             self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
  298.  
  299.         self.log_info('uncaptured python exception, closing channel %s (%s:%s %s)' % (self_repr, t, v, tbinfo), 'error')
  300.         self.close()
  301.  
  302.     
  303.     def _repr(self):
  304.         return ''
  305.  
  306.     
  307.     def __repr__(self):
  308.         
  309.         try:
  310.             sock = self.socket.getsockname()
  311.         except Exception:
  312.             sock = 'ERROR'
  313.  
  314.         sock = '%s:%s' % sock
  315.         
  316.         try:
  317.             peer = self.socket.getpeername()
  318.         except Exception:
  319.             peer = 'ERROR'
  320.  
  321.         peer = '%s:%s' % peer
  322.         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))
  323.  
  324.  
  325. from proxysockets import ProxySocket
  326.  
  327. class AsyncUdpSocket(AsyncSocket):
  328.     
  329.     def __init__(self, conn = None, family = socket.AF_INET, type = socket.SOCK_DGRAM):
  330.         AsyncSocket.__init__(self, conn, family, type)
  331.         self.connected = False
  332.         self.discard_buffers()
  333.  
  334.     
  335.     def on_connect(self):
  336.         if self.connected:
  337.             return None
  338.         self.handle_connect_event()
  339.  
  340.     
  341.     def make_socket(self, proxy = False, family = socket.AF_INET, type = socket.SOCK_DGRAM):
  342.         return AsyncSocket.make_socket(self, proxy, family, type)
  343.  
  344.     
  345.     def sendto(self, data, addr):
  346.         if not data:
  347.             return None
  348.         
  349.         try:
  350.             result = self.socket.sendto(data, addr)
  351.             return result
  352.         except socket.error:
  353.             data
  354.             why = data
  355.             if why[0] == errno.EWOULDBLOCK:
  356.                 return 0
  357.             raise 
  358.             return 0
  359.             why[0] == errno.EWOULDBLOCK
  360.  
  361.  
  362.     
  363.     def recvfrom(self, buffer_size):
  364.         data = ''
  365.         addr = ('', 0)
  366.         
  367.         try:
  368.             (data, addr) = self.socket.recvfrom(buffer_size)
  369.         except socket.error:
  370.             why = None
  371.             if why[0] in (errno.ECONNRESET, errno.EWOULDBLOCK):
  372.                 pass
  373.             elif why[0] in (errno.ENOTCONN, errno.ESHUTDOWN):
  374.                 self.handle_close()
  375.             else:
  376.                 raise 
  377.             why[0] in (errno.ECONNRESET, errno.EWOULDBLOCK)
  378.  
  379.         return (data, addr)
  380.  
  381.     
  382.     def handle_read(self):
  383.         
  384.         try:
  385.             (data, addr) = self.recvfrom(self.ac_in_buffer_size)
  386.         except socket.error:
  387.             why = None
  388.             self.handle_error(why)
  389.             return None
  390.  
  391.         if data:
  392.             self.collect_incoming_data(data, addr)
  393.         
  394.  
  395.     
  396.     def push_with_producer(self, prod):
  397.         if type(prod) is str:
  398.             raise TypeError()
  399.         type(prod) is str
  400.         AsyncSocket.push_with_producer(self, prod)
  401.  
  402.     
  403.     def push(self, prod):
  404.         if type(prod) is str:
  405.             raise TypeError()
  406.         type(prod) is str
  407.         AsyncSocket.push(self, prod)
  408.  
  409.     
  410.     def refill_buffer(self):
  411.         while self.producer_fifo and self.connected:
  412.             first = self.producer_fifo.popleft()
  413.             if not first:
  414.                 data = first
  415.                 addr = ('', 0)
  416.             elif isinstance(first, tuple):
  417.                 (data, addr) = first
  418.             else:
  419.                 from_prod = first.more()
  420.                 if isinstance(from_prod, tuple):
  421.                     (data, addr) = from_prod
  422.                 else:
  423.                     data = from_prod
  424.                     addr = self.endpoint
  425.                 if data is None:
  426.                     continue
  427.                 if data is sentinel:
  428.                     self.producer_fifo.appendleft(first)
  429.                     return None
  430.                 self.producer_fifo.appendleft(first)
  431.                 self.producer_fifo.appendleft((data, addr))
  432.             if data is None:
  433.                 self.handle_close()
  434.                 return None
  435.             self.ac_out_buffer.append((data, addr))
  436.             return None
  437.             continue
  438.             data is None
  439.  
  440.     
  441.     def initiate_send(self):
  442.         if not self.ac_out_buffer:
  443.             self.refill_buffer()
  444.         
  445.         if not self.ac_out_buffer:
  446.             return None
  447.         
  448.         try:
  449.             num_sent = self.sendto(*self.ac_out_buffer[0])
  450.         except socket.error:
  451.             self.ac_out_buffer
  452.             e = self.ac_out_buffer
  453.             self.handle_error(e)
  454.             return None
  455.  
  456.         if num_sent:
  457.             del self.ac_out_buffer[0]
  458.         
  459.  
  460.     
  461.     def discard_buffers(self):
  462.         self.ac_in_buffer = []
  463.         self.ac_out_buffer = []
  464.         while self.producer_fifo:
  465.             self.producer_fifo.popleft()
  466.  
  467.     
  468.     def readable(self):
  469.         return self.connected
  470.  
  471.     
  472.     def writable(self):
  473.         if len(self.ac_out_buffer) == 0 and len(self.producer_fifo) == 0:
  474.             pass
  475.         return not (self.connected)
  476.  
  477.  
  478.