home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / msn / P2P / Bridges.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  23.3 KB  |  704 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from util.packable import Packable
  5. from util import Events
  6. import asynchat
  7. import socket
  8. import random
  9. import collections
  10. import struct
  11. import common
  12. import logging
  13. import util
  14. import util.net as net
  15. import util.Events as events
  16. import util.callbacks as callbacks
  17. log = logging.getLogger('msn.p2p.bridges')
  18.  
  19. def simplest_producer(data):
  20.     yield data
  21.     yield None
  22.  
  23.  
  24. class Bridge(events.EventMixin):
  25.     coolness = -1
  26.     bridge_name = None
  27.     
  28.     def get_connecter_factory(self, serving):
  29.         raise NotImplementedError
  30.  
  31.     
  32.     def get_socket_factory(self):
  33.         raise NotImplementedError
  34.  
  35.     
  36.     def set_ips(self, addrlist):
  37.         pass
  38.  
  39.  
  40.  
  41. class TcpBridge(Bridge):
  42.     bridge_name = 'TCPv1'
  43.     coolness = 10
  44.     
  45.     def get_connecter_factory(self, serving):
  46.         if serving:
  47.             return MSNTcpServer
  48.         return MSNTcpClient
  49.  
  50.     
  51.     def get_socket_factory(self):
  52.         return MSNDirectTcpSocket
  53.  
  54.  
  55.  
  56. class UdpBridge(Bridge):
  57.     coolness = 5
  58.     bridge_name = 'TRUDPv1'
  59.     events = Bridge.events | set(('on_message', 'on_close', 'on_error', 'on_send'))
  60.     
  61.     def __init__(self):
  62.         pass
  63.  
  64.     
  65.     def get_connecter_factory(self, serving):
  66.         if serving:
  67.             return MSNUdpServer
  68.         return MSNUdpClient
  69.  
  70.     
  71.     def get_socket_factory(self):
  72.         
  73.         def fac(connecter, data):
  74.             log.info('udp socket factory got %r, socket = %r', connecter, connecter.socket)
  75.             return connecter.socket
  76.  
  77.         return fac
  78.  
  79.  
  80.  
  81. class MSNDCSocket(common.socket, events.EventMixin):
  82.     events = events.EventMixin.events | set(('on_message', 'on_close', 'on_error', 'on_send'))
  83.     
  84.     def __init__(self, conn, prev_data = ''):
  85.         common.socket.__init__(self, conn)
  86.         self.set_terminator(self.hdr_size)
  87.         self.ac_in_buffer = prev_data
  88.         events.EventMixin.__init__(self)
  89.         self.data = ''
  90.         self.getting_hdr = True
  91.  
  92.     
  93.     def collect_incoming_data(self, data):
  94.         self.data += data
  95.  
  96.     
  97.     def handle_close(self):
  98.         self.event('on_close')
  99.         common.socket.handle_close(self)
  100.         self.close()
  101.  
  102.     
  103.     def handle_expt(self):
  104.         self.event('on_error')
  105.         common.socket.handle_expt(self)
  106.  
  107.     
  108.     def handle_error(self, e = None):
  109.         import traceback
  110.         traceback.print_exc()
  111.         self.event('on_error')
  112.         self.close()
  113.         common.socket.handle_error(self, e)
  114.  
  115.     
  116.     def localport(self):
  117.         
  118.         try:
  119.             return self.socket.getsockname()[1]
  120.         except:
  121.             return 0
  122.  
  123.  
  124.     localport = property(localport)
  125.     
  126.     def __repr__(self):
  127.         pn = None
  128.         
  129.         try:
  130.             pn = self.socket.getpeername()
  131.         finally:
  132.             return '<%s connected to %r>' % (self.__class__.__name__, pn)
  133.  
  134.  
  135.  
  136.  
  137. class MSNDirectUdpSocket(MSNDCSocket, common.AsyncSocket.AsyncUdpSocket):
  138.     send_delay_base = 0.2
  139.     send_delay_min = 1e-05
  140.     timeout = 45
  141.     p2p_overhead = 68
  142.     p2p_max_msg_size = 1384
  143.     
  144.     def send_delay(self):
  145.         delay = self.send_delay_base
  146.         if self._last_ack_time:
  147.             dt_last_ack = util.default_timer() - self._last_ack_time
  148.             delay = self.send_delay_base * dt_last_ack
  149.             if dt_last_ack > self.timeout:
  150.                 self._do_timeout = True
  151.             
  152.         
  153.         return max(self.send_delay_min, delay)
  154.  
  155.     send_delay = property(send_delay)
  156.     
  157.     def build_data(self, header, body, footer):
  158.         return ''.join((header, body))
  159.  
  160.     events = MSNDCSocket.events | set(('on_udp_message',))
  161.     
  162.     class Header(Packable):
  163.         
  164.         class Flags(object):
  165.             SYN = 65568
  166.             ACK = 65664
  167.             SYN_ACK = SYN | ACK
  168.  
  169.         fmt = ('sender_seq', 'I', 'recver_seq', 'I', 'flags', 'I', 'sender_msg_id', 'I', 'recver_msg_id', 'I')
  170.         byteorder = '<'
  171.  
  172.     hdr_size = Header.size
  173.     
  174.     def __init__(self, conn = None):
  175.         self._ips = None
  176.         self._connected = False
  177.         MSNDCSocket.__init__(self, None)
  178.         common.AsyncSocket.AsyncUdpSocket.__init__(self, conn)
  179.         self.re_init()
  180.  
  181.     
  182.     def re_init(self, sender_seq = None):
  183.         log.info('initializing %r', self)
  184.         self.state = self.Header(sender_seq = 0, recver_seq = 0, flags = self.Header.Flags.SYN, sender_msg_id = 0, recver_msg_id = 0)
  185.         self._do_timeout = False
  186.         self._current_sending = None
  187.         self._last_send = 0
  188.         self._next_msgid_incr = 484
  189.         if not sender_seq:
  190.             pass
  191.         self.state.sender_seq = random.randint(0, 2147483647)
  192.         self.state.sender_msg_id = random.randint(0, 2147483647)
  193.         self.discard_buffers()
  194.         log.info('%r initialized. self.state = %r', self, self.state)
  195.  
  196.     
  197.     def on_session_completed(self):
  198.         self.re_init()
  199.  
  200.     
  201.     def close(self):
  202.         log.info('Closing %r', self)
  203.         self.connected = False
  204.         self.discard_buffers()
  205.         common.AsyncSocket.AsyncUdpSocket.close(self)
  206.  
  207.     
  208.     def _send(self, data):
  209.         if data and self._current_sending and not self._current_sending[0][1]:
  210.             pass
  211.         
  212.         while self.ac_out_buffer and self.ac_out_buffer[0][0] == '':
  213.             if data:
  214.                 oldpkt = self.ac_out_buffer.pop(0)
  215.                 log.info('old packet %r will not be sent because of data: %r', oldpkt, data)
  216.                 continue
  217.             if data == '':
  218.                 return None
  219.             continue
  220.             data == ''
  221.         x = self.push_with_producer(net.GeneratorProducer(simplest_producer(data)))
  222.         return x
  223.  
  224.     
  225.     def set_ips(self, iplist):
  226.         if not self._ips:
  227.             self._ips = iplist
  228.         else:
  229.             raise ValueError("Can't set IPs again", self, self._ips, iplist)
  230.         return self._ips
  231.  
  232.     
  233.     def endpoint(self):
  234.         
  235.         try:
  236.             return self._ips[0]
  237.         except Exception:
  238.             return None
  239.  
  240.  
  241.     endpoint = property(endpoint)
  242.     
  243.     def discard_buffers(self):
  244.         self._last_ack_time = util.default_timer()
  245.         common.AsyncSocket.AsyncUdpSocket.discard_buffers(self)
  246.  
  247.     
  248.     def readable(self):
  249.         if bool(self._ips):
  250.             pass
  251.         return common.AsyncSocket.AsyncUdpSocket.readable(self)
  252.  
  253.     
  254.     def writable(self):
  255.         if util.default_timer() - self._last_send < self.send_delay:
  256.             return False
  257.         if bool(self._ips):
  258.             pass
  259.         return common.AsyncSocket.AsyncUdpSocket.writable(self)
  260.  
  261.     
  262.     def connect(self, callback = None):
  263.         log.info('%r.connect() called', self)
  264.         self._connect_cb = callback
  265.         
  266.         try:
  267.             log.info('binding udp socket')
  268.             self.socketbind(('', 0))
  269.         except Exception:
  270.             e = None
  271.             log.info('omg it broke: %r', e)
  272.             callback.error(e)
  273.             return None
  274.  
  275.         log.info('bind worked')
  276.         callback.success(self)
  277.         self.on_connect()
  278.  
  279.     connect = callbacks.callsback(connect)
  280.     
  281.     def getsockname(self):
  282.         log.info('Getting socket name for %r: %r', self, self.socket.getsockname())
  283.         return self.socket.getsockname()
  284.  
  285.     
  286.     def collect_incoming_data(self, data, addr):
  287.         if addr not in self._ips:
  288.             log.error('Ignoring data from unexpected source %r', addr)
  289.             return None
  290.         self._process_data(data, addr)
  291.  
  292.     
  293.     def get_next_message_id(self, hdr):
  294.         return hdr.sender_msg_id + self._next_msgid_incr
  295.  
  296.     
  297.     def _process_data(self, _data, addr):
  298.         (hdr, data) = _data
  299.         self.state.recver_msg_id = hdr.sender_msg_id
  300.         if (self.state.recver_seq == 0 or self.state.recver_seq <= hdr.sender_seq) and self.state.sender_seq <= hdr.recver_seq:
  301.             is_new_message = True
  302.         else:
  303.             is_new_message = False
  304.         self.state.recver_seq = hdr.sender_seq
  305.         self._next_msgid_incr = None if self._next_msgid_incr == 16 else 16
  306.         if is_new_message:
  307.             self.state.flags = hdr.Flags.ACK
  308.             if hdr.recver_seq == 0:
  309.                 self.state.flags |= hdr.flags
  310.             
  311.         
  312.         self.ack_message(hdr, data)
  313.         if not is_new_message:
  314.             return None
  315.         self.event('on_udp_message', hdr, data)
  316.         if data:
  317.             self.event('on_message', data)
  318.         
  319.  
  320.     
  321.     def ack_message(self, hdr, data):
  322.         if data or hdr.flags != hdr.Flags.ACK:
  323.             self._send('')
  324.         
  325.  
  326.     
  327.     def close_when_done(self):
  328.         self.close()
  329.  
  330.     
  331.     def initiate_send(self):
  332.         if self._do_timeout:
  333.             self._do_timeout = False
  334.             raise socket.timeout()
  335.         self._do_timeout
  336.         if not self.ac_out_buffer:
  337.             self.refill_buffer()
  338.         
  339.         if not data and self.ac_out_buffer:
  340.             return None
  341.         (header, final_data) = self.build_packet(hdr, data)
  342.         if hdr is None:
  343.             self._current_sending = ((header, data), addr)
  344.         
  345.         if not final_data:
  346.             return None
  347.         
  348.         try:
  349.             num_sent = self.sendto(final_data, addr)
  350.         except socket.error:
  351.             final_data
  352.             why = final_data
  353.             self.handle_error(why)
  354.             return None
  355.  
  356.         self._last_send = util.default_timer()
  357.  
  358.     
  359.     def build_packet(self, header, data):
  360.         if header is None:
  361.             if data:
  362.                 self.state.sender_seq += 1
  363.             
  364.             header = self.state.copy()
  365.         
  366.         header.recver_msg_id = self.state.recver_msg_id
  367.         header.sender_msg_id = self.state.sender_msg_id = self.get_next_message_id(header)
  368.         return (header, header.pack() + data)
  369.  
  370.     
  371.     def handle_read(self):
  372.         if self._do_timeout:
  373.             self._do_timeout = False
  374.             raise socket.timeout()
  375.         self._do_timeout
  376.         
  377.         try:
  378.             (data, addr) = self.recvfrom(8192)
  379.         except socket.error:
  380.             why = None
  381.             self.handle_error(why)
  382.             return None
  383.  
  384.         if not data:
  385.             return None
  386.         (header, pktdata) = self.Header.unpack(data)
  387.         self.check_ack(header, addr)
  388.         self.collect_incoming_data((header, pktdata), addr)
  389.  
  390.     
  391.     def check_ack(self, header, addr):
  392.         if self._current_sending is None:
  393.             return None
  394.         (myhdr, mydata) = ()
  395.         dest = self._current_sending
  396.         if dest == addr and header.recver_seq == myhdr.sender_seq:
  397.             
  398.             try:
  399.                 self.ac_out_buffer.remove((mydata, dest))
  400.             except ValueError:
  401.                 None if header.flags == header.Flags.ACK else self._current_sending is None
  402.                 None if header.flags == header.Flags.ACK else self._current_sending is None
  403.             except:
  404.                 None if header.flags == header.Flags.ACK else self._current_sending is None
  405.  
  406.             self._last_send = 0
  407.             self._last_ack_time = util.default_timer()
  408.             self._current_sending = None
  409.             self.event('on_send')
  410.         elif header.recver_seq < myhdr.sender_seq:
  411.             pass
  412.         else:
  413.             log.info('bad ack: %r != %r or (recvd %r) != (expected %r)', dest, addr, header.recver_seq, myhdr.sender_seq)
  414.  
  415.     
  416.     def handle_error(self, e = None):
  417.         import traceback
  418.         traceback.print_exc()
  419.         self.on_error()
  420.         self.event('on_error')
  421.         self.close()
  422.         common.AsyncSocket.AsyncUdpSocket.handle_error(self, e)
  423.  
  424.     
  425.     def on_error(self, e = None):
  426.         ccb = self._connect_cb
  427.         self._connect_cb = None
  428.         if ccb is not None:
  429.             ccb.error(e)
  430.         
  431.  
  432.  
  433.  
  434. class MSNDirectTcpSocket(MSNDCSocket):
  435.     hdr_size = 4
  436.     p2p_overhead = 52
  437.     p2p_max_msg_size = 1400
  438.     
  439.     def build_data(self, header, body, footer):
  440.         return ''.join((struct.pack('<I', len(header) + len(body)), header, body))
  441.  
  442.     
  443.     def found_terminator(self):
  444.         data = self.data
  445.         self.data = ''
  446.         self.getting_hdr = not (self.getting_hdr)
  447.         if not self.getting_hdr:
  448.             (next_term,) = struct.unpack('<I', data)
  449.             if next_term:
  450.                 self.set_terminator(next_term)
  451.             else:
  452.                 self.found_terminator()
  453.         else:
  454.             self.set_terminator(self.hdr_size)
  455.             self.event('on_message', data)
  456.  
  457.     
  458.     def _send(self, data):
  459.         log.log(5, '    MSNDirectTcpSocket Data out: %r', data[:100])
  460.         real_data = struct.pack('<I', len(data)) + data
  461.         return common.socket.push(self, real_data)
  462.  
  463.  
  464.  
  465. class MSNDCConnecter(events.EventMixin):
  466.     events = events.EventMixin.events | set(('timeout', 'connected', 'on_message', 'on_close', 'on_error', 'on_send', 'on_local_ip'))
  467.     
  468.     def __init__(self, ips = ()):
  469.         events.EventMixin.__init__(self)
  470.         self._ips = ips
  471.         self.data = ''
  472.  
  473.     
  474.     def connect(self):
  475.         raise NotImplementedError
  476.  
  477.     
  478.     def collect_incoming_data(self, data):
  479.         self.data += data
  480.  
  481.     
  482.     def bind(self, *a, **k):
  483.         return events.EventMixin.bind(self, *a, **k)
  484.  
  485.     
  486.     def _timeout(self):
  487.         pref = pref
  488.         import common
  489.         return pref('msn.direct.timeout', type = int, default = 5)
  490.  
  491.     _timeout = property(_timeout)
  492.     
  493.     def localport(self):
  494.         
  495.         try:
  496.             return self.socket.getsockname()[1]
  497.         except:
  498.             return 0
  499.  
  500.  
  501.     localport = property(localport)
  502.  
  503.  
  504. class MSNTcpServer(common.TimeoutSocket, MSNDCConnecter):
  505.     bind = MSNDCConnecter.bind
  506.     
  507.     def __init__(self):
  508.         common.TimeoutSocket.__init__(self, False)
  509.         MSNDCConnecter.__init__(self, ())
  510.         self.set_terminator(0)
  511.  
  512.     
  513.     def connect(self, callback = None):
  514.         self.tryaccept(('', 0), callback.success, callback.error, self._timeout)
  515.  
  516.     connect = callbacks.callsback(connect)
  517.     
  518.     def cleanup(self):
  519.         self.del_channel()
  520.         self.close()
  521.  
  522.     
  523.     def set_ips(self, ips):
  524.         pass
  525.  
  526.  
  527.  
  528. class MSNTcpClient(common.HydraSocket, MSNDCConnecter):
  529.     
  530.     def __init__(self, ips = ()):
  531.         common.HydraSocket.__init__(self)
  532.         MSNDCConnecter.__init__(self, ips)
  533.  
  534.     
  535.     def connect(self, callback = None):
  536.         self._callback = callback
  537.         self.tryconnect(self._ips, self.connected, callback.error, self._timeout, cls = BufferedTimeoutSocket)
  538.  
  539.     connect = callbacks.callsback(connect)
  540.     
  541.     def connected(self, sck):
  542.         data = 'foo\x00'
  543.         if sck.send(struct.pack('<I', len(data)) + data) != 4 + len(data):
  544.             sck.close()
  545.             self.on_fail()
  546.             log.warning('Send of "foo" failed')
  547.             return None
  548.         log.warning('Sent "foo"')
  549.         self._callback(sck)
  550.  
  551.     
  552.     def cleanup(self):
  553.         pass
  554.  
  555.  
  556.  
  557. class MSNUdpConnecter(MSNDCConnecter):
  558.     events = MSNDCConnecter.events | set(('on_message', 'on_close', 'on_error', 'on_send', 'on_local_ip'))
  559.     
  560.     class Phases:
  561.         START = 'start'
  562.         INITIAL_CONTACT = 'initial contact'
  563.         SYNCHRONIZE = 'sync'
  564.         DATA = 'data'
  565.  
  566.     
  567.     def __init__(self, ips = ()):
  568.         MSNDCConnecter.__init__(self, ips)
  569.         self._connect_cb = None
  570.         self.socket = MSNDirectUdpSocket()
  571.         self._waiting_for = 'start'
  572.  
  573.     
  574.     def set_ips(self, iplist):
  575.         self._ips = iplist
  576.         self.socket.set_ips(iplist)
  577.  
  578.     
  579.     def connect(self, callback = None):
  580.         self._connect_cb = callback
  581.         self.socket.connect(success = self._on_connect, error = self._on_error)
  582.  
  583.     connect = callbacks.callsback(connect)
  584.     
  585.     def _on_message(self, hdr, data):
  586.         initial = False
  587.         if self._waiting_for == self.Phases.INITIAL_CONTACT:
  588.             initial = True
  589.             self._waiting_for = self.Phases.SYNCHRONIZE
  590.         
  591.         if hdr.flags & hdr.Flags.SYN and self._waiting_for == self.Phases.SYNCHRONIZE:
  592.             if not initial:
  593.                 self._waiting_for = self.Phases.DATA
  594.                 self._on_udp_sync()
  595.             
  596.         
  597.         if data:
  598.             self.event('on_message', data)
  599.         
  600.  
  601.     
  602.     def _on_error(self, e = None):
  603.         ccb = self._connect_cb
  604.         self._connect_cb = None
  605.         if ccb is not None:
  606.             ccb.error(e)
  607.         
  608.  
  609.     
  610.     def attempt_contact(self):
  611.         pass
  612.  
  613.     
  614.     def _on_udp_sync(self):
  615.         log.info('udp sync')
  616.         self._connected = True
  617.         self._connect_cb = None
  618.         ccb = self._connect_cb
  619.         if ccb is not None:
  620.             log.info('calling %r', ccb.success)
  621.             ccb.success(self)
  622.         
  623.         self.event('connected')
  624.  
  625.     
  626.     def _on_connect(self, sck):
  627.         log.info('udp bridge on_connect. self._ips = %r, self.socket._ips = %r', self._ips, self.socket._ips)
  628.         self.socket.bind_event('on_udp_message', self._on_message)
  629.         self._waiting_for = self.Phases.INITIAL_CONTACT
  630.  
  631.     
  632.     def _init_gen(self):
  633.         while self._waiting_for == self.Phases.INITIAL_CONTACT:
  634.             for addr in self._ips:
  635.                 yield ('', addr)
  636.             
  637.  
  638.  
  639.  
  640. class MSNUdpClient(MSNUdpConnecter):
  641.     
  642.     def set_ips(self, iplist):
  643.         MSNUdpConnecter.set_ips(self, iplist)
  644.         log.info('Got ips for MSNUdpClient (%r). _waiting_for = %r', iplist, self._waiting_for)
  645.         if self._waiting_for == self.Phases.INITIAL_CONTACT:
  646.             self.attempt_contact()
  647.         
  648.  
  649.     
  650.     def _on_connect(self, sck):
  651.         MSNUdpConnecter._on_connect(self, sck)
  652.         self.event('on_local_ip', self, self.socket.getsockname())
  653.         self.attempt_contact()
  654.  
  655.     
  656.     def attempt_contact(self):
  657.         for ip in self._ips:
  658.             (_header, data) = self.socket.build_packet(None, '')
  659.             self.socket.sendto(data, ip)
  660.         
  661.  
  662.  
  663.  
  664. class MSNUdpServer(MSNUdpConnecter):
  665.     
  666.     def attempt_contact(self):
  667.         pass
  668.  
  669.     
  670.     def set_ips(self, iplist):
  671.         MSNUdpConnecter.set_ips(self, iplist)
  672.         log.info('Got ips for MSNUdpServer (%r). _waiting_for = %r', iplist, self._waiting_for)
  673.         if self._waiting_for == self.Phases.INITIAL_CONTACT:
  674.             self.attempt_contact()
  675.         
  676.  
  677.  
  678.  
  679. class BufferedTimeoutSocket(common.TimeoutSocket):
  680.     
  681.     def __init__(self, *a, **k):
  682.         common.TimeoutSocket.__init__(self, *a, **k)
  683.         self.set_terminator(0)
  684.         self._data = ''
  685.  
  686.     
  687.     def collect_incoming_data(self, data):
  688.         self._data += data
  689.  
  690.     
  691.     def recv(self, bytes):
  692.         if self._data:
  693.             data = self._data[:bytes]
  694.             self._data = self._data[bytes:]
  695.         else:
  696.             data = self.socket.recv(bytes)
  697.         return data
  698.  
  699.     
  700.     def handle_close(self):
  701.         self.socket.close()
  702.  
  703.  
  704.