home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / jabber / filetransfer / socketserver.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  8.4 KB  |  258 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from struct import unpack, pack
  5. from jabber.filetransfer.S5BFileXferHandler import SocketEventMixin
  6. import functools
  7. import common
  8. from socket import AF_INET, SOCK_STREAM
  9. import AsyncoreThread
  10. from hashlib import sha1
  11. from functools import partial
  12. from threading import RLock
  13. from util import lock, get_ips_s
  14. from logging import getLogger
  15. log = getLogger('jabber.filetransfer.s5bserver')
  16.  
  17. class ProxyFailure(StopIteration):
  18.     pass
  19.  
  20.  
  21. def this(f):
  22.     
  23.     def wrapper1(self, *args, **kw):
  24.         return f(self(), *args, **kw)
  25.  
  26.     wrapper1 = (functools.wraps(f),)(wrapper1)
  27.     return wrapper1
  28.  
  29.  
  30. class JabberS5BServerSocket(common.socket):
  31.     _this = None
  32.     started = False
  33.     _lock = RLock()
  34.     bind_addr = ('', 0)
  35.     waiting_hashs = []
  36.     connected_hashs = { }
  37.     
  38.     def __init__(self, addr = None):
  39.         if self() is None:
  40.             if addr is not None:
  41.                 type(self).bind_addr = ('', 0)
  42.             
  43.             common.socket.__init__(self, False)
  44.             type(self)._this = self
  45.         
  46.  
  47.     
  48.     def __call__(self):
  49.         return type(self)._this
  50.  
  51.     
  52.     def start(self):
  53.         if not self.started:
  54.             self.started = True
  55.             self.create_socket(AF_INET, SOCK_STREAM)
  56.             
  57.             try:
  58.                 self.bind(self.bind_addr)
  59.             except Exception:
  60.                 e = None
  61.                 self.log_info('failed to bind on (%r, %r)' % self.bind_addr)
  62.                 raise e
  63.  
  64.             self.listen(5)
  65.             AsyncoreThread.start()
  66.         
  67.  
  68.     start = this(lock(start))
  69.     
  70.     def stop(self):
  71.         if self.started:
  72.             self.started = False
  73.             self.close()
  74.         
  75.  
  76.     stop = this(lock(stop))
  77.     
  78.     def handle_accept(self):
  79.         log.info('handle_accept')
  80.         accepted = self.accept()
  81.         self.listen(5)
  82.         (connected_socket, address) = accepted
  83.         self._on_accept(connected_socket, address)
  84.  
  85.     
  86.     def _on_accept(self, sock, addr):
  87.         log.info('accept from (%r, %r)', sock, addr)
  88.         S5BIncomingSocket(sock, addr, self)
  89.  
  90.     
  91.     def conn_id(self, stream_id, initiator_jid, target_sid):
  92.         return sha1(stream_id + initiator_jid.as_unicode() + target_sid.as_unicode()).hexdigest()
  93.  
  94.     
  95.     def __del__(self):
  96.         self.stop()
  97.         superdel = getattr(common.socket, '__del__', None)
  98.         if superdel is not None:
  99.             superdel(self)
  100.         
  101.  
  102.     __del__ = this(__del__)
  103.     
  104.     def add_hash(self, hash):
  105.         log.info('adding hash: %s', hash)
  106.         self.waiting_hashs.append(hash)
  107.         if not self.started:
  108.             self.start()
  109.         
  110.  
  111.     add_hash = this(lock(add_hash))
  112.     
  113.     def hash_waiting(self, hash, conn):
  114.         log.info('waiting hash: %s', hash)
  115.         self.waiting_hashs.remove(hash)
  116.         if not self.waiting_hashs:
  117.             self.stop()
  118.         
  119.         self.connected_hashs[hash] = conn
  120.  
  121.     hash_waiting = this(lock(hash_waiting))
  122.     
  123.     def check_hash(self, hash):
  124.         return hash in self.connected_hashs
  125.  
  126.     check_hash = this(lock(check_hash))
  127.     
  128.     def retrieve_hash(self, hash):
  129.         log.info('retrieving hash: %s', hash)
  130.         if hash in self.connected_hashs:
  131.             return self.connected_hashs.pop(hash)
  132.         
  133.         try:
  134.             self.waiting_hashs.remove(hash)
  135.             return False
  136.         except ValueError:
  137.             hash in self.connected_hashs
  138.             hash in self.connected_hashs
  139.             return None
  140.         finally:
  141.             pass
  142.  
  143.  
  144.     retrieve_hash = this(lock(retrieve_hash))
  145.     
  146.     def hosts(self):
  147.         port = self.socket.getsockname()[1]
  148.         return [ (ip, port) for ip in get_ips_s() ]
  149.  
  150.     hosts = property(this(hosts))
  151.  
  152.  
  153. class S5BIncomingSocket(common.socket, SocketEventMixin):
  154.     
  155.     def __init__(self, sock, addr, server):
  156.         SocketEventMixin.__init__(self)
  157.         common.socket.__init__(self, sock)
  158.         self.server = server
  159.         self.data = None
  160.         self.proc(self.s5b_ok())
  161.  
  162.     
  163.     def s5b_ok(self):
  164.         yield (2, None)
  165.         greeting = None
  166.         (_head, num_authmethods) = unpack('BB', greeting)
  167.         yield (num_authmethods, '')
  168.         methods = None
  169.         authmethods = unpack('%dB' % num_authmethods, methods)
  170.         if 0 not in authmethods:
  171.             yield (0, pack('BB', 5, 255))
  172.             raise ProxyFailure('bad auth methods')
  173.         0 not in authmethods
  174.         yield (4, pack('BB', 5, 0))
  175.         auth = None
  176.         (_head, tcp, reserved, type_) = unpack('4B', auth)
  177.         if not (_head == 5) and tcp == 1 and reserved == 0 and type_ == 3:
  178.             raise ProxyFailure('bad address header')
  179.         type_ == 3
  180.         yield (1, '')
  181.         (len_,) = None(unpack, 'B')
  182.         yield (len_ + 2, '')
  183.         (addr, _port) = None(unpack, '%dsH' % len_)
  184.         self.hash = addr
  185.         if self.server.check_hash(self.hash):
  186.             raise ProxyFailure('hash already connected')
  187.         self.server.check_hash(self.hash)
  188.         
  189.         self.collect_incoming_data = lambda _data: pass
  190.         strng = pack('=4B%dpH' % (len_ + 1,), 5, 0, 0, 3, addr, 0)
  191.         yield (False, strng)
  192.  
  193.     
  194.     def proc(self, gen):
  195.         
  196.         try:
  197.             (to_read, out_bytes) = gen.send(self.data)
  198.         except ProxyFailure:
  199.             self.close()
  200.             return None
  201.             except StopIteration:
  202.                 
  203.                 try:
  204.                     self.handle_expt = self.post_connect_expt
  205.                     self.handle_error = self.post_connect_error
  206.                     self.handle_close = self.post_connect_close
  207.                     self.do_disconnect = self.post_connect_disconnect
  208.                     self.server.hash_waiting(self.hash, self)
  209.                 except ValueError:
  210.                     self.close()
  211.  
  212.                 return None
  213.             else:
  214.                 bytes = str(out_bytes)
  215.                 print 'out_bytes', out_bytes, 'bytes', bytes
  216.                 if out_bytes:
  217.                     self.push(bytes)
  218.                 
  219.  
  220.         self.data = ''
  221.         self.found_terminator = partial(self.proc, gen)
  222.         if to_read is False:
  223.             log.info('found to_read is False, generator exhausted')
  224.             
  225.             self.found_terminator = lambda : pass
  226.             
  227.             self.collect_incoming_data = lambda _data: pass
  228.             self.set_terminator(0)
  229.             
  230.             try:
  231.                 self.handle_expt = self.post_connect_expt
  232.                 self.handle_error = self.post_connect_error
  233.                 self.handle_close = self.post_connect_close
  234.                 self.do_disconnect = self.post_connect_disconnect
  235.                 self.server.hash_waiting(self.hash, self)
  236.             except ValueError:
  237.                 self.close()
  238.             except:
  239.                 None<EXCEPTION MATCH>ValueError
  240.             
  241.  
  242.         None<EXCEPTION MATCH>ValueError
  243.         if isinstance(to_read, int):
  244.             self.set_terminator(to_read)
  245.         else:
  246.             self.set_terminator(to_read._size())
  247.  
  248.     
  249.     def collect_incoming_data(self, data):
  250.         self.data += data
  251.  
  252.     
  253.     def __del__(self):
  254.         self.close()
  255.         common.socket.__del__(self)
  256.  
  257.  
  258.