Exemplo n.º 1
0
	def run(self):

		c = Conn(port=self.port)

		peer = c.initializeSocket()

		while True: # Ciclo di connessioni

			other_peer, addr = peer.accept()

			t = Worker(other_peer)
			t.start()
Exemplo n.º 2
0
    def run(self):

        c = Conn(port=3000)
        peersocket = c.initializeSocket()

        while True:

            other_peersocket, addr = peersocket.accept()

            totalBit = int(other_peersocket.recv(8).decode())

            tot = totalBit
            byte = []

            # Blocchi completi
            while totalBit >= 8:

                byte.append(255)
                totalBit -= 8

            # Blocco incompleto (finale)
            if totalBit > 0:

                lastBlock = (1 << totalBit) - 1

                byte.append(int('{:08b}'.format(lastBlock)[::-1], 2))

            ###################

            # INSERISCI QUI ALTRI BLOCCHI PER POTER AVERE PESI DIVERSI

            ###################

            box = ceil(tot / 8)
            print('peers pronti: ', str(len(byte) // box).zfill(5))
            other_peersocket.send(str(box).zfill(8).encode())  # Numero blocchi
            other_peersocket.send(str(tot).zfill(8).encode())  # Numero bit
            other_peersocket.send(str(len(byte) //
                                      box).zfill(8).encode())  # Numero peers

            charAscii = ''
            for el in byte:

                charAscii = charAscii + chr(el)

            a = other_peersocket.send(codecs.encode(charAscii, 'iso-8859-1'))
            print('scritto: ', a)
            other_peersocket.close()
Exemplo n.º 3
0
    def body(self):
        open_conn = Conn(port=3000)
        peersocket = open_conn.initializeSocket()
        db = dataBase()
        c = ['black']
        db.create("tracker")

        # check logged
        pN = plot_net()
        res = db.checkLogged()
        if (res):
            for r in res:
                c.append('green')
                ip = Util.ip_deformatting(r[0], r[1])
                pN.addPeer(ip[0], c)
                pause(0.5)

        while True:
            Util.printLog("###### IN ATTESA DI UNA RICHIESTA #######")
            other_peersocket, addr = peersocket.accept()
            if addr[0][:2] == "::":
                addrPack = addr[0][7:]
                Util.printLog("Richiesta in arrivo da: " + addrPack)
            else:
                addrPack = addr[0]
                Util.printLog("Richiesta in arrivo da: " + addrPack)

            recv_type = other_peersocket.recv(4)

            if (len(recv_type) != 0):
                self.bytes_read = len(recv_type)
                while (self.bytes_read < 4):
                    recv_type += other_peersocket.recv(4 - self.bytes_read)
                    self.bytes_read = len(recv_type)
                Util.printLog("RICHIESTA IN ENTRATA AL TRACKER → " +
                              str(recv_type.decode()))

                # LOGIN ---
                if (recv_type.decode() == "LOGI"):
                    recv_packet = other_peersocket.recv(60)
                    self.bytes_read = len(recv_packet)
                    while (self.bytes_read < 60):
                        recv_packet += other_peersocket.recv(60 -
                                                             self.bytes_read)
                        self.bytes_read = len(recv_packet)

                    th_LOGIN = t_login(other_peersocket, recv_packet.decode())
                    th_LOGIN.start()

                    c.append('green')
                    ip = Util.ip_deformatting(recv_packet[:55].decode(),
                                              recv_packet[55:].decode())
                    pN.addPeer(ip[0], c)
                    pause(1)

                # LOGOUT ---
                if (recv_type.decode() == "LOGO"):
                    recv_packet = other_peersocket.recv(16)
                    self.bytes_read = len(recv_packet)
                    while (self.bytes_read < 16):
                        recv_packet += other_peersocket.recv(16 -
                                                             self.bytes_read)
                        self.bytes_read = len(recv_packet)

                    addr = db.getPeerBySid(recv_packet.decode())
                    if (addr):
                        ip = Util.ip_deformatting(addr[0], addr[1])

                        t_LOGOUT = t_logout(other_peersocket,
                                            recv_packet.decode())
                        t_LOGOUT.start()
                        t_LOGOUT.join()
                        Util.printLog(t_LOGOUT.statusLogout)
                        if (t_LOGOUT.statusLogout == "ALOG"):
                            pN.removePeer(ip[0], c)
                            pause(1)

                # LOOK ---
                if (recv_type.decode() == "LOOK"):
                    Util.printLog("\n→ ARRIVO LOOK ←\n")
                    t_LOOK = t_look(other_peersocket)
                    t_LOOK.start()

                # FCHU ---
                if (recv_type.decode() == "FCHU"):
                    #Util.printLog("\n→ ARRIVO FCHU ←\n")
                    th_FCHU = t_fchu(other_peersocket)
                    th_FCHU.start()

                # ADDR ---
                if (recv_type.decode() == "ADDR"):
                    Util.printLog("\n→ ARRIVO ADDR ←\n")
                    th_ADDR = t_addr(other_peersocket)
                    th_ADDR.start()

                # RPAD ---
                if (recv_type.decode() == "RPAD"):
                    #Util.printLog("\n→ ARRIVO RPAD ←\n")
                    th_RPAD = t_rpad(other_peersocket)
                    th_RPAD.start()
            print(Util.globalDict)