Python BTConnection.read_handshake_medium_rare方法代码示例

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
class ConnecterConnection:

    def __init__(self,port):
        self.s = BTConnection('localhost',port)
        self.s.read_handshake_medium_rare()
        self.connection = EncrypterConnection(self.s.get_his_id())

    def get_my_id(self):
        return self.s.get_my_id()

    def get_unauth_peer_id(self):
        return self.s.get_his_id()

    def is_locally_initiated(self):
        return True

    def send_message(self,msg):
        self.s.send(msg)
        
    def get_message(self):
        return self.s.recv()

    def set_permid(self,x):
        pass

    def set_auth_peer_id(self,x):
        pass

    def close(self):
        self.s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_good(self,msg_gen_func,options=None,infohash=None):
        if options is None and infohash is None:
            s = BTConnection('localhost',self.hisport)
        elif options is None:
            s = BTConnection('localhost',self.hisport,user_infohash=infohash)
        elif infohash is None:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options)
        else:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options,user_infohash=infohash)
        msg = msg_gen_func()
        s.send(msg)
        s.read_handshake_medium_rare()
        time.sleep(5)

        # Tribler should send an EXTEND message back
        try:
            s.s.settimeout(10.0)
            resp = s.recv()
            self.assert_(len(resp) > 0)
            print >>sys.stderr,"test: Got reply",getMessageName(resp[0])
            self.assert_(resp[0] == EXTEND)
            self.check_tribler_extend_hs(resp[1:])
            #s.close()
        except socket.timeout:
            print >> sys.stderr,"test: Timeout, bad, peer didn't reply with EXTEND message"
            self.assert_(False)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
 def subtest_old_tribler(self):
     # The tracker gives Tribler
     try:
         self.myss.settimeout(10.0)
         conn, addr = self.myss.accept()
         options = '\x00\x00\x00\x00\x00\x10\x00\x00'
         s = BTConnection('',0,conn,user_option_pattern=options,user_infohash=self.infohash,myid=self.myid)
         s.read_handshake_medium_rare()
         
         # Seeing that we're an T<=3.5.0 peer, he should directly 
         # initiate an overlay conn with us
         conn2, addr2 = self.myss.accept()
         s2 = OLConnection(self.my_keypair,'',0,conn2,self.mylistenport)
 
         time.sleep(5)
         # the other side should not have closed the connection, as
         # this is all valid, so this should not throw an exception:
         s.send('bla')
         s.close()
         s2.send('bla')
         s2.close()
         print >> sys.stderr,"test: Good, Tribler made overlay conn with us"
     except socket.timeout:
         print >> sys.stderr,"test: Bad, Tribler did not attempt to start an overlay conn with us"
         self.assert_(False)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def test_all(self):
        """ 
            I want to start a Tribler client once and then connect to
            it many times. So there must be only one test method
            to prevent setUp() from creating a new client every time.

            The code is constructed so unittest will show the name of the
            (sub)test where the error occured in the traceback it prints.
        """

        # myid needs to identify the connection as Tribler in order to
        # get the 'same' bit added.f
        myid = TRIBLER_PEERID_LETTER + "".join(map(chr, range(19)))

        # Create a fake other client, so the EXTEND ut_pex won't be empty
        msg2 = self.create_good_nontribler_extend_hs(listenport=4321)
        s2 = BTConnection('localhost',self.hisport,mylistenport=4321,user_option_pattern='\x00\x00\x00\x00\x00\x10\x00\x00',user_infohash=self.infohash,myid=myid)
        s2.read_handshake_medium_rare()
        s2.send(msg2)
        self.subtest_good_nontribler_ut_pex()
        self.subtest_good_nontribler_ut_pex_diff_id()
        self.subtest_good_tribler_ut_pex()
        self.subtest_bad_ut_pex()

        # now we add a second non-tribler peer. this peer should also
        # be in the pex message but should not have the 'same' bit set
        myid = "X" + "".join(map(chr, range(19)))
        msg3 = self.create_good_nontribler_extend_hs(listenport=4322)
        s3 = BTConnection('localhost',self.hisport,mylistenport=4322,user_option_pattern='\x00\x00\x00\x00\x00\x10\x00\x00',user_infohash=self.infohash,myid=myid)
        s3.read_handshake_medium_rare()
        s3.send(msg3)
        self.subtest_good_nontribler_ut_pex_same_and_nonsame()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
 def _test_response1(self,ss,gen_resp1,good):
     print >>sys.stderr,"test: myserver running:",gen_resp1
     conn, addr = ss.accept()
     s = BTConnection('',0,conn)
     s.read_handshake_medium_rare()
     # Read challenge
     msg = s.recv()
     self.testcase.assert_(msg[0] == CHALLENGE)
     randomB = bdecode(msg[1:])
     self.testcase.assert_(type(randomB) == StringType)
     self.testcase.assert_(len(randomB) == random_size)
     [randomA,resp1_data] = gen_resp1(randomB,s.get_his_id())
     s.send(resp1_data)
     if good:
         # Read response2
         msg = s.recv()
         self.testcase.assert_(msg[0] == RESPONSE2)
         self.check_response2(msg[1:],randomA,randomB,s.get_my_id())
         # the connection should be intact, so this should not throw an
         # exception:
         time.sleep(5)
         s.send('bla')
         s.close()
     else:
         time.sleep(5)
         # the other side should not our bad RESPONSE1 this and close the 
         # connection
         msg = s.recv()
         self.testcase.assert_(len(msg)==0)
         s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
 def _test_bad(self,gen_drequest_func):
     options = '\x00\x00\x00\x00\x00\x10\x00\x00'
     s = BTConnection('localhost',self.hisport,user_option_pattern=options,user_infohash=self.infohash)
     print >> sys.stderr,"\ntest: ",gen_drequest_func
     
     hsmsg = self.create_good_tribler_extend_hs_v2()
     s.send(hsmsg)
     
     msg = gen_drequest_func()
     s.send(msg)
     time.sleep(5)
     
     # the other side should not like this and close the connection
     try:
         s.s.settimeout(10.0)
         s.read_handshake_medium_rare(close_ok = True)
         while True:
             resp = s.recv()
             if len(resp) > 0:
                 print >>sys.stderr,"test: Got",getMessageName(resp[0]),"from peer"
                 self.assert_(resp[0] == EXTEND or resp[0]==UNCHOKE)
             else:
                 self.assert_(len(resp)==0)
                 s.close()
                 break
     except socket.timeout:
         print >> sys.stderr,"test: Timeout, bad, peer didn't close connection"
         self.assert_(False)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def singtest_connect_overlay(self):
        """ 
        """
        # 1. Accept the data connection Tribler wants to establish with us
        self.myss.settimeout(10.0)
        conn, addr = self.myss.accept()
        s = BTConnection('',0,conn,user_infohash=self.infohash,myid=self.myid)
        s.read_handshake_medium_rare()

        extmsg = self.create_good_tribler_extend_hs()
        s.send(extmsg)
        resp = s.recv()
        self.assert_(len(resp) > 0)
        print >> sys.stderr,"test: Data conn replies",getMessageName(resp[0])
        
        # 2. Tribler should now try to establish an overlay connection with us
        self.myss.settimeout(10.0)
        conn, addr = self.myss.accept()
        options = '\x00\x00\x00\x00\x00\x00\x00\x00'
        s2 = OLConnection(self.my_keypair,'',0,conn,mylistenport=self.mylistenport)

        # Desired behaviour is that the accept() succeeds. If not it will time
        # out, and throw an exception, causing this test to fail.
        time.sleep(3)
        
        s.close()
        s2.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def bad_request_and_disconnect(self, payload):
        conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
        conn.send(self.create_good_extend_handshake())
        conn.read_handshake_medium_rare()
        metadata_id = self.read_extend_handshake(conn)

        conn.send(EXTEND + chr(metadata_id) + bencode(payload))
        self.read_extend_metadata_close(conn)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_good_request(self):
        options = "\x00\x00\x00\x00\x00\x10\x00\x00"
        myid = Rand.rand_bytes(20)

        s = BTConnection("localhost", self.hisport, user_option_pattern=options, user_infohash=self.infohash, myid=myid)
        msg = self.create_good_nontribler_extend_hs()
        s.send(msg)
        s.read_handshake_medium_rare()

        # Tribler should send an EXTEND message back
        try:
            print >> sys.stderr, "test: Waiting for reply"
            s.s.settimeout(10.0)
            resp = s.recv()
            self.assert_(len(resp) > 0)
            print >> sys.stderr, "test: Got reply", getMessageName(resp[0])
            self.assert_(resp[0] == EXTEND)
            self.check_tribler_extend_hs(resp[1:])

            # 1. Pretend we're leecher: send INTERESTED
            msg = INTERESTED
            s.send(msg)
            print >> sys.stderr, "test: Pretend we are leecher"
            while True:
                resp = s.recv()
                self.assert_(len(resp) > 0)
                print >> sys.stderr, "test: Got reply2", getMessageName(resp[0])
                if resp[0] == EXTEND:
                    print >> sys.stderr, "test: Got EXTEND type", getMessageName(resp[1])
                self.assert_(resp[0] == UNCHOKE or resp[0] == BITFIELD or resp[0] == EXTEND or resp[0] == HAVE)
                if resp[0] == UNCHOKE:
                    # 2. Reply with REQUESTs
                    for index in range(0, self.numpieces):
                        plen = self.get_piece_length(index)

                        for begin in range(0, plen, 2 ** 14):
                            length = self.get_chunk_length(index, begin)
                            print >> sys.stderr, "RETRIEVE", index, begin, length
                            chunkid = (index, begin, length)
                            msg = self.create_request(chunkid)
                            s.send(msg)

                    # s.send(NOT_INTERESTED)

                elif resp[0] == EXTEND and resp[1] == HASHPIECE:
                    done = self.check_hashpiece(resp)
                    if done:
                        break
                elif resp[0] == BITFIELD:
                    self.check_bitfield(resp)

            # s.close()
        except socket.timeout:
            print >> sys.stderr, "test: Timeout, bad, peer didn't reply in time"
            self.assert_(False)

        time.sleep(3)
        s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_good(self,msg_gen_func,options=None,infohash=None,g2g_id=G2G_ID):
        if options is None and infohash is None:
            s = BTConnection('localhost',self.hisport)
        elif options is None:
            s = BTConnection('localhost',self.hisport,user_infohash=infohash)
        elif infohash is None:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options)
        else:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options,user_infohash=infohash)
            
        if DEBUG:
            print "test: Creating test HS message",msg_gen_func,"g2g_id",g2g_id
        msg = msg_gen_func(g2g_id=g2g_id)
        s.send(msg)
        s.read_handshake_medium_rare()

        # Send our g2g_v2 message to Tribler
        msg = self.create_good_g2g_v2(g2g_id=g2g_id)
        s.send(msg)
        
        time.sleep(5)

        # Tribler should send an EXTEND HS message back
        try:
            s.s.settimeout(10.0)
            resp = s.recv()
            self.assert_(len(resp) > 0)
            self.assert_(resp[0] == EXTEND)
            self.check_tribler_extend_hs_v2(resp[1:])
        except socket.timeout:
            print >> sys.stderr,"test: Timeout, bad, peer didn't reply with EXTEND HS message"
            self.assert_(False)

        # Tribler should send an g2g_v2 message after a while
        print "test: Setting 60 second timeout to see if Tribler sends periodic g2g_v2"
        
        # Extreme h4xor
        connlist = self.d.sd.dow.connecter.connections.values()[:]
        piece = '\xab' * (2 ** 14)
        for conn in connlist:
            conn.queue_g2g_piece_xfer(0,0,piece)
        
        try:
            s.s.settimeout(70.0)
            while True:
                resp = s.recv()
                self.assert_(len(resp) > 0)
                print "test: Tribler returns",getMessageName(resp[0])
                if resp[0] == EXTEND:
                    self.check_g2g_v2(resp[1:],g2g_id=g2g_id)
                    s.close()
                    break
        except socket.timeout:
            print >> sys.stderr,"test: Timeout, bad, peer didn't reply with EXTEND g2g_v2 message"
            self.assert_(False)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_good(self, msg_gen_func, options=None, infohash=None):

        print >> sys.stderr, "test: test good, gen_func", msg_gen_func

        if options is None and infohash is None:
            s = BTConnection("localhost", self.hisport, myid=self.myid)
        elif options is None:
            s = BTConnection("localhost", self.hisport, user_infohash=infohash, myid=self.myid)
        elif infohash is None:
            s = BTConnection("localhost", self.hisport, user_option_pattern=options, myid=self.myid)
        else:
            s = BTConnection(
                "localhost", self.hisport, user_option_pattern=options, user_infohash=infohash, myid=self.myid
            )
        msg = msg_gen_func()
        s.send(msg)
        s.read_handshake_medium_rare()
        time.sleep(5)

        # Tribler should send an EXTEND message back
        try:
            s.s.settimeout(10.0)
            resp = s.recv()
            self.assert_(len(resp) > 0)
            print >> sys.stderr, "test: Got reply", getMessageName(resp[0])
            self.assert_(resp[0] == EXTEND)
            self.check_tribler_extend_hs(resp[1:])
            # s.close()
        except socket.timeout:
            print >> sys.stderr, "test: Timeout, bad, peer didn't reply with EXTEND message"
            self.assert_(False)

        # Tribler should try to connect to our internal interface
        self.destss.settimeout(10.0)
        conn, addr = self.destss.accept()
        s2 = BTConnection("", 0, conn, user_infohash=self.infohash, myid=self.myid)
        s2.send(INTERESTED)
        s2.read_handshake_medium_rare()

        # Is it him?
        self.assert_(s.hisid == s2.hisid)

        # He should close original conn
        try:
            while True:
                resp = s.recv()
                if len(resp) > 0:
                    print >> sys.stderr, "test: Got data on internal conn", getMessageName(resp[0])
                else:
                    break
        except socket.timeout:
            self.assert_(False)

        self.assert_(True)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def subtest_good_flood(self):
        conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
        conn.send(self.create_good_extend_handshake())
        conn.read_handshake_medium_rare()
        metadata_id = self.read_extend_handshake(conn)

        for counter in xrange(len(self.metadata_list) * 2):
            piece = counter % len(self.metadata_list)
            conn.send(self.create_good_extend_metadata_request(metadata_id, piece))

            if counter > len(self.metadata_list):
                self.read_extend_metadata_reject(conn, piece)
            else:
                self.read_extend_metadata_reply(conn, piece)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_good(self,msg_gen_func,options=None,infohash=None,pex_id=1,connections={"tribler":1,"non-tribler":0}):
        if options is None and infohash is None:
            s = BTConnection('localhost',self.hisport)
        elif options is None:
            s = BTConnection('localhost',self.hisport,user_infohash=infohash)
        elif infohash is None:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options)
        else:
            s = BTConnection('localhost',self.hisport,user_option_pattern=options,user_infohash=infohash)
            
        if DEBUG:
            print "test: Creating test HS message",msg_gen_func,"pex_id",pex_id
        msg = msg_gen_func(pex_id=pex_id)
        s.send(msg)
        s.read_handshake_medium_rare()

        # Send our ut_pex message to Tribler
        msg = self.create_good_ut_pex()
        s.send(msg)
        
        time.sleep(5)

        # Tribler should send an EXTEND HS message back
        try:
            s.s.settimeout(10.0)
            resp = s.recv()
            self.assert_(len(resp) > 0)
            self.assert_(resp[0] == EXTEND)
            self.check_tribler_extend_hs(resp[1:])
        except socket.timeout:
            print >> sys.stderr,time.asctime(),'-', "test: Timeout, bad, peer didn't reply with EXTEND HS message"
            self.assert_(False)

        # Tribler should send an ut_pex message after a while
        print "test: Setting 60 second timeout to see if Tribler sends periodic ut_pex"
        try:
            s.s.settimeout(70.0)
            while True:
                resp = s.recv()
                self.assert_(len(resp) > 0)
                print "test: Tribler returns",getMessageName(resp[0])
                if resp[0] == EXTEND:
                    self.check_ut_pex(resp[1:],pex_id,connections)
                    s.close()
                    break
        except socket.timeout:
            print >> sys.stderr,time.asctime(),'-', "test: Timeout, bad, peer didn't reply with EXTEND ut_pex message"
            self.assert_(False)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def _test_dreply(self,gen_dreply,good,diff_ips_test=False):
        for i in range(self.NLISTENERS):
            print >> sys.stderr,"test: waiting for #",i,"listenport",self.mylistenport[i]
            conn, addr = self.myss[i].accept()
            s = OLConnection(self.mykeypairs[i],'',0,conn,self.mylistenport[i])
            while True:
                msg = s.recv()
                self.assert_(len(msg) > 0)
                print >> sys.stderr,"test: Received overlay message",getMessageName(msg[0])
                if msg[0] == DIALBACK_REQUEST:
                    break
            self.assert_(msg[0] == DIALBACK_REQUEST)
            self.check_drequest(msg[1:])
            
            # Proper behaviour is to try to send a reply using a new return connection
            s2 = BTConnection('localhost',self.hisport,mylistenport=self.mylistenport[i],user_infohash=dialback_infohash)
            s2.read_handshake_medium_rare(close_ok = True)
            if gen_dreply is not None:
                resp = gen_dreply(i)
                print >> sys.stderr,"test: sending DIALBACK_REPLY #",i
                s2.send(resp)
            time.sleep(2)
            # the other side should always close the 
            # connection, either because we're done or he didn't like our
            # bad DIALBACK_REPLY message
            msg = s2.recv()
            if len(msg) > 0:
                print >> sys.stderr,"test: Received unexpected data",getMessageName(msg[0])
            self.assert_(len(msg)==0)
            s2.close()

            # Not really necessary, but helps with test_dialback_active2
            s.close()


        ext_ip = self.session.get_external_ip()
        print >>sys.stderr,"test: External IP address after test is",ext_ip
        
        if diff_ips_test:
            if self.config.sessconfig['dialback_trust_superpeers'] == 1:
                good = True
            else:
                good = False
                
        if good:
            self.assert_(ext_ip == REPLY_IP)
        else:
            self.assert_(ext_ip == self.myoriginalip)

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import read_handshake_medium_rare [as 别名]
    def subtest_good_request(self):
        conn = BTConnection("localhost", self.hisport, user_infohash=self.tdef.get_infohash())
        conn.send(self.create_good_extend_handshake())
        conn.read_handshake_medium_rare()
        metadata_id = self.read_extend_handshake(conn)

        # request metadata block 0, 2, 3, and the last
        conn.send(self.create_good_extend_metadata_request(metadata_id, 0))
        conn.send(self.create_good_extend_metadata_request(metadata_id, 2))
        conn.send(self.create_good_extend_metadata_request(metadata_id, 3))
        conn.send(self.create_good_extend_metadata_request(metadata_id, len(self.metadata_list) - 1))

        self.read_extend_metadata_reply(conn, 0)
        self.read_extend_metadata_reply(conn, 2)
        self.read_extend_metadata_reply(conn, 3)
        self.read_extend_metadata_reply(conn, len(self.metadata_list) - 1)