home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / BitTorrent / Encrypter.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  17.0 KB  |  526 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from cStringIO import StringIO
  5. from binascii import b2a_hex
  6. from socket import error as socketerror
  7. protocol_name = 'BitTorrent protocol'
  8.  
  9. def toint(s):
  10.     return long(b2a_hex(s), 16)
  11.  
  12.  
  13. def tobinary(i):
  14.     return chr(i >> 24) + chr(i >> 16 & 255) + chr(i >> 8 & 255) + chr(i & 255)
  15.  
  16.  
  17. class Connection:
  18.     
  19.     def __init__(self, Encoder, connection, id, is_local):
  20.         self.encoder = Encoder
  21.         self.connection = connection
  22.         self.id = id
  23.         self.locally_initiated = is_local
  24.         self.complete = False
  25.         self.closed = False
  26.         self.buffer = StringIO()
  27.         self.next_len = 1
  28.         self.next_func = self.read_header_len
  29.         if self.locally_initiated:
  30.             connection.write(chr(len(protocol_name)) + protocol_name + chr(0) * 8 + self.encoder.download_id)
  31.             if self.id is not None:
  32.                 connection.write(self.encoder.my_id)
  33.             
  34.         
  35.  
  36.     
  37.     def get_ip(self):
  38.         return self.connection.get_ip()
  39.  
  40.     
  41.     def get_id(self):
  42.         return self.id
  43.  
  44.     
  45.     def is_locally_initiated(self):
  46.         return self.locally_initiated
  47.  
  48.     
  49.     def is_flushed(self):
  50.         return self.connection.is_flushed()
  51.  
  52.     
  53.     def read_header_len(self, s):
  54.         if ord(s) != len(protocol_name):
  55.             return None
  56.         
  57.         return (len(protocol_name), self.read_header)
  58.  
  59.     
  60.     def read_header(self, s):
  61.         if s != protocol_name:
  62.             return None
  63.         
  64.         return (8, self.read_reserved)
  65.  
  66.     
  67.     def read_reserved(self, s):
  68.         return (20, self.read_download_id)
  69.  
  70.     
  71.     def read_download_id(self, s):
  72.         if s != self.encoder.download_id:
  73.             return None
  74.         
  75.         if not self.locally_initiated:
  76.             self.connection.write(chr(len(protocol_name)) + protocol_name + chr(0) * 8 + self.encoder.download_id + self.encoder.my_id)
  77.         
  78.         return (20, self.read_peer_id)
  79.  
  80.     
  81.     def read_peer_id(self, s):
  82.         if not self.id:
  83.             if s == self.encoder.my_id:
  84.                 return None
  85.             
  86.             for v in self.encoder.connections.values():
  87.                 if s and v.id == s:
  88.                     return None
  89.                     continue
  90.             
  91.             self.id = s
  92.             if self.locally_initiated:
  93.                 self.connection.write(self.encoder.my_id)
  94.             else:
  95.                 self.encoder.everinc = True
  96.         elif s != self.id:
  97.             return None
  98.         
  99.         self.complete = True
  100.         self.encoder.connecter.connection_made(self)
  101.         return (4, self.read_len)
  102.  
  103.     
  104.     def read_len(self, s):
  105.         l = toint(s)
  106.         if l > self.encoder.max_len:
  107.             return None
  108.         
  109.         return (l, self.read_message)
  110.  
  111.     
  112.     def read_message(self, s):
  113.         if s != '':
  114.             self.encoder.connecter.got_message(self, s)
  115.         
  116.         return (4, self.read_len)
  117.  
  118.     
  119.     def read_dead(self, s):
  120.         pass
  121.  
  122.     
  123.     def close(self):
  124.         if not self.closed:
  125.             self.connection.close()
  126.             self.sever()
  127.         
  128.  
  129.     
  130.     def sever(self):
  131.         self.closed = True
  132.         del self.encoder.connections[self.connection]
  133.         if self.complete:
  134.             self.encoder.connecter.connection_lost(self)
  135.         
  136.  
  137.     
  138.     def send_message(self, message):
  139.         self.connection.write(tobinary(len(message)) + message)
  140.  
  141.     
  142.     def data_came_in(self, s):
  143.         while True:
  144.             if self.closed:
  145.                 return None
  146.             
  147.             i = self.next_len - self.buffer.tell()
  148.             if i > len(s):
  149.                 self.buffer.write(s)
  150.                 return None
  151.             
  152.             self.buffer.write(s[:i])
  153.             s = s[i:]
  154.             m = self.buffer.getvalue()
  155.             self.buffer.reset()
  156.             self.buffer.truncate()
  157.             
  158.             try:
  159.                 x = self.next_func(m)
  160.             except:
  161.                 self.next_len = 1
  162.                 self.next_func = self.read_dead
  163.                 raise 
  164.  
  165.             if x is None:
  166.                 self.close()
  167.                 return None
  168.             
  169.             (self.next_len, self.next_func) = x
  170.  
  171.  
  172.  
  173. class Encoder:
  174.     
  175.     def __init__(self, connecter, raw_server, my_id, max_len, schedulefunc, keepalive_delay, download_id, max_initiate = 40):
  176.         self.raw_server = raw_server
  177.         self.connecter = connecter
  178.         self.my_id = my_id
  179.         self.max_len = max_len
  180.         self.schedulefunc = schedulefunc
  181.         self.keepalive_delay = keepalive_delay
  182.         self.download_id = download_id
  183.         self.max_initiate = max_initiate
  184.         self.everinc = False
  185.         self.connections = { }
  186.         self.spares = []
  187.         schedulefunc(self.send_keepalives, keepalive_delay)
  188.  
  189.     
  190.     def send_keepalives(self):
  191.         self.schedulefunc(self.send_keepalives, self.keepalive_delay)
  192.         for c in self.connections.values():
  193.             if c.complete:
  194.                 c.send_message('')
  195.                 continue
  196.         
  197.  
  198.     
  199.     def start_connection(self, dns, id):
  200.         if id:
  201.             if id == self.my_id:
  202.                 return None
  203.             
  204.             for v in self.connections.values():
  205.                 if v.id == id:
  206.                     return None
  207.                     continue
  208.             
  209.         
  210.         if len(self.connections) >= self.max_initiate:
  211.             if len(self.spares) < self.max_initiate and dns not in self.spares:
  212.                 self.spares.append(dns)
  213.             
  214.             return None
  215.         
  216.         
  217.         try:
  218.             c = self.raw_server.start_connection(dns)
  219.             self.connections[c] = Connection(self, c, id, True)
  220.         except socketerror:
  221.             pass
  222.  
  223.  
  224.     
  225.     def _start_connection(self, dns, id):
  226.         
  227.         def foo(self = self, dns = dns, id = id):
  228.             self.start_connection(dns, id)
  229.  
  230.         self.schedulefunc(foo, 0)
  231.  
  232.     
  233.     def got_id(self, connection):
  234.         for v in self.connections.values():
  235.             if connection is not v and connection.id == v.id:
  236.                 connection.close()
  237.                 return None
  238.                 continue
  239.         
  240.         self.connecter.connection_made(connection)
  241.  
  242.     
  243.     def ever_got_incoming(self):
  244.         return self.everinc
  245.  
  246.     
  247.     def external_connection_made(self, connection):
  248.         self.connections[connection] = Connection(self, connection, None, False)
  249.  
  250.     
  251.     def connection_flushed(self, connection):
  252.         c = self.connections[connection]
  253.         if c.complete:
  254.             self.connecter.connection_flushed(c)
  255.         
  256.  
  257.     
  258.     def connection_lost(self, connection):
  259.         self.connections[connection].sever()
  260.         while len(self.connections) < self.max_initiate and self.spares:
  261.             self.start_connection(self.spares.pop(), None)
  262.  
  263.     
  264.     def data_came_in(self, connection, data):
  265.         self.connections[connection].data_came_in(data)
  266.  
  267.  
  268.  
  269. class DummyConnecter:
  270.     
  271.     def __init__(self):
  272.         self.log = []
  273.         self.close_next = False
  274.  
  275.     
  276.     def connection_made(self, connection):
  277.         self.log.append(('made', connection))
  278.  
  279.     
  280.     def connection_lost(self, connection):
  281.         self.log.append(('lost', connection))
  282.  
  283.     
  284.     def connection_flushed(self, connection):
  285.         self.log.append(('flushed', connection))
  286.  
  287.     
  288.     def got_message(self, connection, message):
  289.         self.log.append(('got', connection, message))
  290.         if self.close_next:
  291.             connection.close()
  292.         
  293.  
  294.  
  295.  
  296. class DummyRawServer:
  297.     
  298.     def __init__(self):
  299.         self.connects = []
  300.  
  301.     
  302.     def start_connection(self, dns):
  303.         c = DummyRawConnection()
  304.         self.connects.append((dns, c))
  305.         return c
  306.  
  307.  
  308.  
  309. class DummyRawConnection:
  310.     
  311.     def __init__(self):
  312.         self.closed = False
  313.         self.data = []
  314.         self.flushed = True
  315.  
  316.     
  317.     def get_ip(self):
  318.         return 'fake.ip'
  319.  
  320.     
  321.     def is_flushed(self):
  322.         return self.flushed
  323.  
  324.     
  325.     def write(self, data):
  326.         self.data.append(data)
  327.  
  328.     
  329.     def close(self):
  330.         self.closed = True
  331.  
  332.     
  333.     def pop(self):
  334.         r = ''.join(self.data)
  335.         del self.data[:]
  336.         return r
  337.  
  338.  
  339.  
  340. def dummyschedule(a, b):
  341.     pass
  342.  
  343.  
  344. def test_messages_in_and_out():
  345.     c = DummyConnecter()
  346.     rs = DummyRawServer()
  347.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  348.     c1 = DummyRawConnection()
  349.     e.external_connection_made(c1)
  350.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20)
  351.     e.data_came_in(c1, 'b' * 20)
  352.     ch = c.log[0][1]
  353.     del c.log[:]
  354.     ch.send_message('abc')
  355.     e.data_came_in(c1, chr(0) * 3 + chr(3) + 'def')
  356.     del c.log[:]
  357.  
  358.  
  359. def test_flushed():
  360.     c = DummyConnecter()
  361.     rs = DummyRawServer()
  362.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  363.     c1 = DummyRawConnection()
  364.     e.external_connection_made(c1)
  365.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20)
  366.     e.connection_flushed(c1)
  367.     e.data_came_in(c1, 'b' * 20)
  368.     ch = c.log[0][1]
  369.     del c.log[:]
  370.     e.connection_flushed(c1)
  371.     c1.flushed = False
  372.  
  373.  
  374. def test_wrong_header_length():
  375.     c = DummyConnecter()
  376.     rs = DummyRawServer()
  377.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  378.     c1 = DummyRawConnection()
  379.     e.external_connection_made(c1)
  380.     e.data_came_in(c1, chr(5) * 30)
  381.  
  382.  
  383. def test_wrong_header():
  384.     c = DummyConnecter()
  385.     rs = DummyRawServer()
  386.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  387.     c1 = DummyRawConnection()
  388.     e.external_connection_made(c1)
  389.     e.data_came_in(c1, chr(len(protocol_name)) + 'a' * len(protocol_name))
  390.  
  391.  
  392. def test_wrong_download_id():
  393.     c = DummyConnecter()
  394.     rs = DummyRawServer()
  395.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  396.     c1 = DummyRawConnection()
  397.     e.external_connection_made(c1)
  398.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'e' * 20)
  399.  
  400.  
  401. def test_wrong_other_id():
  402.     c = DummyConnecter()
  403.     rs = DummyRawServer()
  404.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  405.     e.start_connection('dns', 'o' * 20)
  406.     c1 = rs.connects[0][1]
  407.     del rs.connects[:]
  408.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'b' * 20)
  409.  
  410.  
  411. def test_over_max_len():
  412.     c = DummyConnecter()
  413.     rs = DummyRawServer()
  414.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  415.     c1 = DummyRawConnection()
  416.     e.external_connection_made(c1)
  417.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  418.     ch = c.log[0][1]
  419.     del c.log[:]
  420.     e.data_came_in(c1, chr(1) + chr(0) * 3)
  421.  
  422.  
  423. def test_keepalive():
  424.     s = []
  425.     
  426.     def sched(interval, thing, s = s):
  427.         s.append((interval, thing))
  428.  
  429.     c = DummyConnecter()
  430.     rs = DummyRawServer()
  431.     e = Encoder(c, rs, 'a' * 20, 500, sched, 30, 'd' * 20)
  432.     kfunc = s[0][0]
  433.     del s[:]
  434.     c1 = DummyRawConnection()
  435.     e.external_connection_made(c1)
  436.     kfunc()
  437.     del s[:]
  438.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  439.     del c.log[:]
  440.     kfunc()
  441.  
  442.  
  443. def test_swallow_keepalive():
  444.     c = DummyConnecter()
  445.     rs = DummyRawServer()
  446.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  447.     c1 = DummyRawConnection()
  448.     e.external_connection_made(c1)
  449.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  450.     del c.log[:]
  451.     e.data_came_in(c1, chr(0) * 4)
  452.  
  453.  
  454. def test_local_close():
  455.     c = DummyConnecter()
  456.     rs = DummyRawServer()
  457.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  458.     c1 = DummyRawConnection()
  459.     e.external_connection_made(c1)
  460.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  461.     ch = c.log[0][1]
  462.     del c.log[:]
  463.     ch.close()
  464.     del c.log[:]
  465.  
  466.  
  467. def test_local_close_in_message_receive():
  468.     c = DummyConnecter()
  469.     rs = DummyRawServer()
  470.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  471.     c1 = DummyRawConnection()
  472.     e.external_connection_made(c1)
  473.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  474.     ch = c.log[0][1]
  475.     del c.log[:]
  476.     c.close_next = True
  477.     e.data_came_in(c1, chr(0) * 3 + chr(4) + 'abcd')
  478.  
  479.  
  480. def test_remote_close():
  481.     c = DummyConnecter()
  482.     rs = DummyRawServer()
  483.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  484.     c1 = DummyRawConnection()
  485.     e.external_connection_made(c1)
  486.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  487.     ch = c.log[0][1]
  488.     del c.log[:]
  489.     e.connection_lost(c1)
  490.  
  491.  
  492. def test_partial_data_in():
  493.     c = DummyConnecter()
  494.     rs = DummyRawServer()
  495.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  496.     c1 = DummyRawConnection()
  497.     e.external_connection_made(c1)
  498.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 4)
  499.     e.data_came_in(c1, chr(0) * 4 + 'd' * 20 + 'c' * 10)
  500.     e.data_came_in(c1, 'c' * 10)
  501.     del c.log[:]
  502.  
  503.  
  504. def test_ignore_connect_of_extant():
  505.     c = DummyConnecter()
  506.     rs = DummyRawServer()
  507.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  508.     c1 = DummyRawConnection()
  509.     e.external_connection_made(c1)
  510.     e.data_came_in(c1, chr(len(protocol_name)) + protocol_name + chr(0) * 8 + 'd' * 20 + 'o' * 20)
  511.     del c.log[:]
  512.     e.start_connection('dns', 'o' * 20)
  513.  
  514.  
  515. def test_ignore_connect_to_self():
  516.     c = DummyConnecter()
  517.     rs = DummyRawServer()
  518.     e = Encoder(c, rs, 'a' * 20, 500, dummyschedule, 30, 'd' * 20)
  519.     c1 = DummyRawConnection()
  520.     e.start_connection('dns', 'a' * 20)
  521.  
  522.  
  523. def test_conversion():
  524.     pass
  525.  
  526.