home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / jabber / filetransfer / S5BFileXferHandler.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  10.0 KB  |  243 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from jabber.objects.si_filetransfer import SI_FileTransfer
  5. from util.Events import EventMixin
  6. from pyxmpp.expdict import ExpiringDictionary
  7. from common.timeoutsocket import TimeoutSocketMulti
  8. from util.net import SocketEventMixin
  9. import common
  10. import util.primitives.structures as structures
  11. from struct import pack, unpack
  12. from functools import partial
  13. from jabber.objects.si import SI_NS
  14. from jabber.objects.bytestreams import BYTESTREAMS_NS, ByteStreams
  15. from hashlib import sha1
  16. from pyxmpp.jid import JID
  17. from pyxmpp.iq import Iq
  18. import logging
  19.  
  20. class ProxyFailure(StopIteration):
  21.     pass
  22.  
  23.  
  24. class ByteStream(EventMixin):
  25.     events = EventMixin.events | set(('stream_connected', 'stream_connect_failed', 'stream_rejected', 'stream_data_recieved', 'stream_closed', 'stream_error'))
  26.  
  27.  
  28. class INByteStream(ByteStream):
  29.     
  30.     def __init__(self, si_ft, jabber_protocol):
  31.         ByteStream.__init__(self)
  32.         self.si_ft = si_ft
  33.         self.j = jabber_protocol
  34.  
  35.  
  36.  
  37. class SOCKS5Bytestream(INByteStream):
  38.     log = logging.getLogger('jabber.filetrans.s5bxferhandler')
  39.     
  40.     def accept_stream(self, hosts_bytestreams, from_, to_, id):
  41.         self.from_ = from_
  42.         self.to_ = to_
  43.         self.respond_id = id
  44.         self.hosts_bytestreams = hosts_bytestreams
  45.         self.my_sock = S5BOutgoingSocket(hosts_bytestreams, from_, to_)
  46.         self.my_sock.bind_event('connected', self.on_succ)
  47.         self.my_sock.bind_event('connection_failed', self.on_fail)
  48.         self.my_sock.get_connect()
  49.  
  50.     
  51.     def on_fail(self):
  52.         self.log.warning('S5BFileXferHandler connect failed')
  53.         i = Iq(to_jid = self.from_, from_jid = self.to_, stanza_type = 'error', stanza_id = self.respond_id, error_cond = u'item-not-found')
  54.         self.j.send(i)
  55.         self.event('stream_connect_failed')
  56.  
  57.     
  58.     def on_succ(self, num_tries_taken, sock):
  59.         host_used = self.hosts_bytestreams.hosts[num_tries_taken - 1].jid
  60.         self.my_sock = sock
  61.         i2 = Iq(to_jid = self.from_, stanza_type = 'result', stanza_id = self.respond_id)
  62.         b = ByteStreams()
  63.         b.host_used = JID(host_used)
  64.         b.as_xml(i2.get_node())
  65.         self.my_sock.found_terminator = self.close
  66.         self.my_sock.collect_incoming_data = self.collect_incoming_data
  67.         self.my_sock.set_terminator(self.si_ft.file.size)
  68.         self.my_sock.bind_event('socket_closed', self.closed)
  69.         self.my_sock.bind_event('socket_error', self.stream_error)
  70.         self.j.send(i2)
  71.         self.log.info('S5BFileXferHandler connect succeeded to %s', host_used)
  72.         self.event('stream_connected')
  73.  
  74.     
  75.     def stream_error(self):
  76.         self.event('stream_error')
  77.         self.unbind_all()
  78.  
  79.     
  80.     def collect_incoming_data(self, data):
  81.         self.event('stream_data_recieved', data)
  82.  
  83.     
  84.     def close(self):
  85.         
  86.         try:
  87.             self.my_sock.close()
  88.         except:
  89.             pass
  90.  
  91.         self.closed()
  92.  
  93.     
  94.     def timed_out(self):
  95.         self.event('stream_connect_failed')
  96.         self.close()
  97.  
  98.     
  99.     def closed(self):
  100.         self.event('stream_closed')
  101.         self.unbind_all()
  102.  
  103.     
  104.     def unbind_all(self):
  105.         if hasattr(self, 'my_sock'):
  106.             self.my_sock.unbind('connected', self.on_succ)
  107.             self.my_sock.unbind('connection_failed', self.on_fail)
  108.             self.my_sock.unbind('socket_closed', self.closed)
  109.             self.my_sock.unbind('socket_error', self.stream_error)
  110.         
  111.  
  112.  
  113.  
  114. class S5BRecvHandler(object):
  115.     
  116.     def __init__(self, j):
  117.         self.d = ExpiringDictionary(60)
  118.         self.j = j
  119.  
  120.     
  121.     def register_handlers(self):
  122.         self.j.stream.set_iq_set_handler('query', BYTESTREAMS_NS, self.handleSI)
  123.         self.j.idle_loop += self.d.expire
  124.  
  125.     
  126.     def handleSI(self, stanza):
  127.         print 'handleSI called'
  128.         b = ByteStreams(stanza.get_query())
  129.         sid = b.sid
  130.         
  131.         try:
  132.             s5b = self.d.pop(sid)
  133.         except KeyError:
  134.             return False
  135.  
  136.         s5b.accept_stream(b, stanza.get_from(), stanza.get_to(), stanza.get_id())
  137.         return True
  138.  
  139.     
  140.     def waitfor(self, stanza):
  141.         si_ft = SI_FileTransfer(stanza.xpath_eval('si:si', {
  142.             'si': SI_NS })[0])
  143.         print 'waiting for stream for ', si_ft
  144.         s5b = SOCKS5Bytestream(si_ft, self.j)
  145.         self.d.set_item(si_ft.sid, s5b, timeout_callback = s5b.timed_out)
  146.         return s5b
  147.  
  148.     __call__ = waitfor
  149.  
  150.  
  151. class S5BOutgoingSocketOne(common.TimeoutSocketOne, SocketEventMixin):
  152.     
  153.     def __init__(self, *a, **k):
  154.         SocketEventMixin.__init__(self)
  155.         common.TimeoutSocketOne.__init__(self, *a, **k)
  156.  
  157.     
  158.     def succ(self):
  159.         self.proc(self.s5b_ok())
  160.  
  161.     
  162.     def s5b_ok(self):
  163.         yield (2, pack('BBB', 5, 1, 0))
  164.         ok = None
  165.         (_head, authmethod) = unpack('BB', ok)
  166.         if authmethod != 0:
  167.             raise ProxyFailure()
  168.         authmethod != 0
  169.         out = pack('!BBBBB40sH', 5, 1, 0, 3, 40, self.hash, 0)
  170.         in_fmt = ('!BBBB', 's5head', 'status', 'reserved', 'addrtype')
  171.         yield (4, out)
  172.         in_ = None
  173.         head = structures.unpack_named(*in_fmt + (in_,))
  174.         if head.addrtype == 3:
  175.             yield (1, '')
  176.             head.addrlen = None
  177.             head.addrlen = ord(head.addrlen)
  178.             if head.addrlen > 0:
  179.                 yield (head.addrlen, '')
  180.                 address = None
  181.             else:
  182.                 address = ''
  183.         
  184.         yield (2, '')
  185.         _port = None
  186.         if head.status != 0:
  187.             raise ProxyFailure()
  188.         head.status != 0
  189.  
  190.     
  191.     def proc(self, gen):
  192.         
  193.         try:
  194.             (to_read, out_bytes) = gen.send(self.data)
  195.         except ProxyFailure:
  196.             return self.do_fail()
  197.             except StopIteration:
  198.                 return common.TimeoutSocketOne.succ(self)
  199.             else:
  200.                 bytes = str(out_bytes)
  201.                 if out_bytes:
  202.                     self.push(bytes)
  203.                 
  204.  
  205.         self.data = ''
  206.         self.found_terminator = partial(self.proc, gen)
  207.         if isinstance(to_read, int):
  208.             self.set_terminator(to_read)
  209.         else:
  210.             self.set_terminator(to_read._size())
  211.  
  212.  
  213.  
  214. class S5BOutgoingSocket(SocketEventMixin):
  215.     
  216.     def __init__(self, hosts_bytestreams, from_, to_):
  217.         SocketEventMixin.__init__(self)
  218.         self.log = logging.getLogger('S5BOutgoingSocket')
  219.         self.log.warning('S5BOutgoingSocket')
  220.         shosts = hosts_bytestreams.hosts
  221.         self.addys = [ (host.host, host.port) for host in shosts ]
  222.         self.sid = hosts_bytestreams.sid
  223.         self.hash = sha1(self.sid + from_.as_utf8() + to_.as_utf8()).hexdigest()
  224.         self.t = TimeoutSocketMulti()
  225.         
  226.         self._on_failure = lambda : self.event('connection_failed')
  227.  
  228.     
  229.     def provide_data(self, sock):
  230.         sock.hash = self.hash
  231.  
  232.     
  233.     def connected(self, sock):
  234.         sock.reassign()
  235.         self.sock = sock
  236.         self.event('connected', self.t.attempts, sock)
  237.  
  238.     
  239.     def get_connect(self):
  240.         self.t.tryconnect(self.addys, self.connected, self._on_failure, 2, cls = S5BOutgoingSocketOne, provide_init = self.provide_data)
  241.  
  242.  
  243.