Python BTConnection.close方法代码示例

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import close [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 close [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 close [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 close [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 close [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 close [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 close [as 别名]
 def _test_bad_challenge(self, gen_chal_func):
     s = BTConnection("localhost", self.hisport)
     s.read_handshake()
     [rB, chal_data] = gen_chal_func()
     s.send(chal_data)
     time.sleep(5)
     # the other side should not like this and close the connection
     msg = s.recv()
     self.assert_(len(msg) == 0)
     s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import close [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 close [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 close [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 close [as 别名]
 def _test_bad_response2(self, gen_resp2_func):
     print >>sys.stderr, time.asctime(), "-", "test: bad response2", gen_resp2_func
     s = BTConnection("localhost", self.hisport)
     s.read_handshake()
     [rB, chal_data] = self.create_good_challenge()
     s.send(chal_data)
     resp1_data = s.recv()
     self.assert_(resp1_data[0] == RESPONSE1)
     resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
     resp2_data = gen_resp2_func(rB, resp1_dict, s.get_his_id())
     s.send(resp2_data)
     time.sleep(5)
     # the other side should not like this and close the connection
     msg = s.recv()
     self.assert_(len(msg) == 0)
     s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import close [as 别名]
 def subtest_good_challenge_response2(self):
     """ 
         test good challenge and response2 messages
     """
     print >>sys.stderr, time.asctime(), "-", "test: good challenge/response"
     s = BTConnection("localhost", self.hisport)
     s.read_handshake()
     [rB, chal_data] = self.create_good_challenge()
     s.send(chal_data)
     resp1_data = s.recv()
     self.assert_(resp1_data[0] == RESPONSE1)
     resp1_dict = self.check_response1(resp1_data[1:], rB, s.get_my_id())
     resp2_data = self.create_good_response2(rB, resp1_dict, s.get_his_id())
     s.send(resp2_data)
     time.sleep(10)
     # 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()

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

    def __init__(self,my_keypair,hostname,port,opensock=None,mylistenport=481,myoversion=None):
        """ If opensock is not None, we assume this is a connection we
            accepted, and he initiates the Challenge/Response
        """

        self.my_keypair = my_keypair
        self.b = BTConnection(hostname,port,opensock,mylistenport=mylistenport,myoversion=myoversion)
        if opensock:
            self.b.read_handshake_medium_rare()
            # Read challenge
            msg = self.b.recv()
            assert(msg[0] == CHALLENGE)
            randomB = bdecode(msg[1:])
            [randomA,resp1_data] = self.create_good_response1(randomB,self.b.get_his_id())
            self.b.send(resp1_data)
            # Read response2
            msg = self.b.recv()
            assert(msg[0] == RESPONSE2)
        else:
            self.b.read_handshake()
            [rB,chal_data] = self.create_good_challenge()
            self.b.send(chal_data)
            resp1_data = self.b.recv()
            if DEBUG:
                print >>sys.stderr,"olconn: recv",len(resp1_data),"bytes"
            resp1_dict = bdecode(resp1_data[1:])
            resp2_data = self.create_good_response2(rB,resp1_dict,self.b.get_his_id())
            self.b.send(resp2_data)
            if DEBUG:
                print >>sys.stderr,"olconn: sent",len(resp2_data),"bytes"

    def get_my_fake_listen_port(self):
        return self.b.get_my_fake_listen_port()

    #
    # Cut 'n paste from TestPermIDs 
    #
    def create_good_challenge(self):
        r = "".zfill(cr_random_size)
        return [r,self.create_challenge_payload(r)]

    def create_good_response2(self,rB,resp1_dict,hisid):
        resp2 = {}
        resp2['certB'] = str(self.my_keypair.pub().get_der())
        resp2['A'] = hisid
        sig_list = [rB,resp1_dict['rA'],hisid]
        sig_data = bencode(sig_list)
        sig_hash = sha(sig_data).digest()
        sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
        resp2['SB'] = sig_asn1
        return self.create_response2_payload(resp2)

    def create_challenge_payload(self,r):
        return CHALLENGE+bencode(r)

    def create_response2_payload(self,dict):
        return RESPONSE2+bencode(dict)


    #
    # Cut 'n paste from TestPermIDResponse1
    #
    def create_good_response1(self,rB,hisid):
        resp1 = {}
        resp1['certA'] = str(self.my_keypair.pub().get_der())
        resp1['rA'] = "".zfill(cr_random_size)
        resp1['B'] = hisid
        sig_list = [resp1['rA'],rB,hisid]
        sig_data = bencode(sig_list)
        sig_hash = sha(sig_data).digest()
        sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash))
        resp1['SA'] = sig_asn1
        return [resp1['rA'],self.create_response1_payload(resp1)]

    def create_response1_payload(self,dict):
        return RESPONSE1+bencode(dict)



    def send(self,data):
        """ send length-prefixed message """
        self.b.send(data)

    def recv(self):
        """ received length-prefixed message """
        return self.b.recv()

    def close(self):
        self.b.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import close [as 别名]
    def _test_bad(self, msg_gen_func, oldstyle):
        print >> sys.stderr, "test: test_BAD: Create EXTEND HS", repr(msg_gen_func), oldstyle
        if oldstyle:
            options = None
            exthsmsg = self.create_good_tribler_extend_hs()
        else:
            options = "\x00\x00\x00\x00\x00\x10\x00\x00"
            exthsmsg = self.create_good_nontribler_extend_hs()

        s = BTConnection("localhost", self.hisport, user_option_pattern=options, user_infohash=self.infohash)
        s.send(exthsmsg)
        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 seeder: send BITFIELD and UNCHOKE
            msg = BITFIELD + self.seederbitfieldstr
            s.send(msg)
            msg = UNCHOKE
            s.send(msg)
            print >> sys.stderr, "test: Pretend we are seeder"
            while True:
                resp = s.recv()
                self.assert_(len(resp) > 0)
                print >> sys.stderr, "test: Got reply 2", getMessageName(resp[0])
                self.assert_(
                    resp[0] == REQUEST
                    or resp[0] == INTERESTED
                    or resp[0] == UNCHOKE
                    or resp[0] == HAVE
                    or resp[0] == NOT_INTERESTED
                )
                if resp[0] == REQUEST:
                    chunkid = self.check_request(resp)

                    # 2. Reply to REQUEST with *bad* HASHPIECE
                    msg = msg_gen_func(chunkid)
                    if oldstyle:
                        if len(msg) == 1:
                            msg = ""
                        else:
                            msg = msg[1:]  # Strip EXTEND byte
                    s.send(msg)
                    break

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

        time.sleep(3)
        # Should have closed the connection
        try:
            s.send(UNCHOKE)
            self.assert_(False)
        except:
            print_exc()

        s.close()

# 需要导入模块: from btconn import BTConnection [as 别名]
# 或者: from btconn.BTConnection import close [as 别名]
    def _test_good(self, msg_gen_func, oldstyle, extend_hs_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)
        print >> sys.stderr, "test: test_good: Create EXTEND HS"
        msg = extend_hs_gen_func()
        print >> sys.stderr, "test: test_good: Sending EXTEND HS", repr(msg)
        s.send(msg)
        print >> sys.stderr, "test: test_good: Waiting for BT HS"
        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 seeder: send BITFIELD and UNCHOKE
            msg = BITFIELD + self.seederbitfieldstr
            s.send(msg)
            msg = UNCHOKE
            s.send(msg)
            print >> sys.stderr, "test: Pretend we are seeder"
            while True:
                resp = s.recv()
                self.assert_(len(resp) > 0)
                print >> sys.stderr, "test: Got reply2", getMessageName(resp[0])
                self.assert_(
                    resp[0] == REQUEST
                    or resp[0] == INTERESTED
                    or resp[0] == UNCHOKE
                    or resp[0] == HAVE
                    or resp[0] == NOT_INTERESTED
                )
                if resp[0] == REQUEST:
                    chunkid = self.check_request(resp)

                    # 2. Reply to REQUEST with HASHPIECE (oldstyle) or Tr_hashpiece
                    msg = msg_gen_func(oldstyle, chunkid)
                    s.send(msg)
                elif resp[0] == NOT_INTERESTED:
                    break

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

        destfn = os.path.join(self.config_path, "file2.wmv")
        sf = open(self.sourcefn, "rb")
        df = open(destfn, "rb")
        n = self.tdef.get_piece_length()
        while True:
            sdata = sf.read(n)
            if len(sdata) == 0:
                break
            ddata = df.read(n)
            self.assert_(sdata == ddata)

        time.sleep(3)
        s.close()