def LOGO(self):
db = dataBaseSuper()
Util.printLog("DENTRO A THREADLOGO")
Util.lock.acquire()
Util.printLog("SESSION ID LOGOUT: " + str(self.sessionid))
self.info = db.retrieveLOGIN(self.sessionid)
self.count = db.deleteFROMpeer(self.sessionid)
Util.printLog("NUMERO DI FILE ELIMINATI ----> " + str(self.count))
Util.lock.release()
Util.printLog("[ALGO] disconnessione dell'utente: " + self.sessionid +
", file eliminati: " + str(self.count))
del db
self.answer(self.count, self.info)
def run(self):
self.sessionid = self.pkt_del[4:20]
self.md5 = self.pkt_del[20:52]
db = dataBaseSuper()
Util.lock.acquire()
find = db.retrieveFILE(self.sessionid, self.md5)
if (find == 0):
Util.lock.release()
Util.printLog("[DEFF] non ho trovato nessun file caricato da: " +
self.sessionid + " con il seguente md5: " + self.md5)
else:
db.deleteFILE(self.sessionid, self.md5)
Util.lock.release()
Util.printLog("[DEFF] ho eliminato il file caricato da: " +
self.sessionid + " con il seguente md5: " + self.md5)
del db
def run(self):
self.sessionid = self.pkt_ins[4:20]
self.md5 = self.pkt_ins[20:52]
self.filename = self.pkt_ins[52:]
db = dataBaseSuper()
Util.lock.acquire()
find = db.retrieveFILE(self.sessionid, self.md5)
if (find == 0):
db.insertFILE(self.sessionid, self.md5, self.filename)
db.updateFILE(self.filename, self.md5)
Util.lock.release()
Util.printLog("[ADFF] l'utente con il seguente SessionID: " +
self.sessionid + "ha aggiunto il file: " +
self.filename)
else:
db.updateFILE(self.filename, self.md5)
Util.lock.release()
Util.printLog("[ADFF] aggiornato nome file in : " + self.filename)
del db
def run(self):
self.pktid = self.from_peer[4:20]
self.ip = self.from_peer[20:75]
self.peer_port = self.from_peer[75:80]
self.ttl = int(self.from_peer[80:82])
self.string = self.from_peer[82:].strip()
db = dataBaseSuper()
Util.lock.acquire()
res = db.retrieveCounterRequest(self.pktid, self.ip)
Util.printLog("THREADQUER DI RES ----------_> " + str(res))
if (res == 0):
self.timestamp = time.time()
db.insertRequest(self.pktid, self.ip, self.timestamp)
Util.lock.release()
self.do(db, self.pktid, self.ip, self.timestamp, Util.lock,
self.string, self.peer_port, self.ttl, self.from_peer[82:],
self.ip_request)
else:
before = db.retrieveRequestTimestamp(self.pktid, self.ip)
Util.lock.release()
now = time.time()
if ((now - before) < 20):
Util.printLog(
'[QUER]: non faccio nulla perchè ho già elaborato la richiesta\n'
)
del db
else:
self.timestamp = time.time()
Util.lock.acquire()
db.updateTimestamp(self.pktid, self.ip)
Util.lock.release()
self.do(db, self.pktid, self.ip, self.timestamp, Util.lock,
self.string, self.peer_port, self.ttl,
self.from_peer[82:], self.ip_request)
def run(self):
db = dataBase()
file_find = []
#ricavo i superpeer a cui sono collegato e inoltro la richiesta nella rete
superpeers = db.retrieveSuperPeers()
config = db.retrieveConfig(('selfV4', 'selfV6'))
Util.globalLock.acquire()
Util.statusRequest[self.packet[4:20]] = True
Util.printLog("DIZIONARIO GLOBALE SETTATO ---> " +
str(Util.statusRequest[self.packet[4:20]]))
Util.globalLock.release()
if (superpeers):
for sp in superpeers:
ipv4, ipv6, port = Util.ip_deformatting(sp[0], sp[1])
if (ipv4 != config.selfV4):
conn = Conn(ipv4, ipv6, port)
if (conn.connection()):
conn.s.send(self.packet.encode())
conn.deconnection()
Util.printLog("INVIO QUER VERSO " + str(ipv4) +
" RIUSCITO")
else:
Util.printLog(
"INVIO QUER FALLITO VERSO IL SUPER... PROBABILMENTE "
+ str(ipv4) + " E' OFFLINE")
continue
cond = th.Condition()
cond.acquire()
cond.wait(20)
cond.release()
Util.globalLock.acquire()
Util.statusRequest[self.packet[4:20]] = False
Util.printLog("PASSATI 20 SECONDI.. DIZIONARIO ---> " +
str(Util.statusRequest[self.packet[4:20]]))
Util.globalLock.release()
#controllo tra i peer loggati a me prima di inoltrare la quer nella rete
dbS = dataBaseSuper()
localFile = dbS.findInLocalSP(self.packet[82:])
Util.printLog("LOCALFILE " + str(localFile))
#creazione pacchetto di AFIN passati i 20 secondi
addrPeer = db.retrievePeerSid(self.sid)
Util.printLog("ADDRPEER " + str(addrPeer))
resp = db.retrieveResponse(self.packet[4:20])
ipv4, ipv6, port = Util.ip_deformatting(addrPeer[0][0], addrPeer[0][1])
for f in resp:
file_find.append(f[3])
for ff in localFile:
file_find.append(ff[1])
seen = set()
uniq = []
for x in file_find:
if x not in seen:
uniq.append(x)
seen.add(x)
toPeer = "AFIN" + str(len(seen)).zfill(3)
connP = Conn(ipv4, ipv6, port)
if (connP.connection()):
connP.s.send(toPeer.encode())
buffer_md5 = ''
for i in resp:
count = 0
ll = []
md5 = i[3]
if (md5 == buffer_md5):
continue
for j in resp:
if (md5 in j):
count = count + 1
add = j[1] + j[2]
ll.append(add)
if (count == 1):
toPeer = md5 + i[4] + str(count).zfill(3) + i[1] + i[2]
connP.s.send(toPeer.encode())
Util.printLog("PACCHETTO AFIN 1-----> " + str(toPeer))
elif (count > 1):
buffer_md5 = md5
toPeer = md5 + i[4] + str(count)
for l in ll:
toPeer = toPeer + l
connP.s.send(toPeer.encode())
Util.printLog("PACCHETTO AFIN 2+-----> " + str(toPeer))
buffer_md5_l = ''
if (localFile): # se la lista non è vuota entro nel ciclo
k = 0
for lf in localFile:
count = 0
ll2 = []
md5 = lf[1]
Util.printLog("localfile in for " + str(lf))
addrLocalPeer = db.retrievePeerSid(lf[0])
if (md5 == buffer_md5_l):
continue
for j in localFile:
if (md5 in j):
addrLocalPeer_dub = db.retrievePeerSid(j[0])
count = count + 1
add = addrLocalPeer_dub[0][0] + addrLocalPeer_dub[0][1]
ll2.append(add)
Util.printLog("addrLocalPeer " + str(addrLocalPeer))
if (count == 1):
toPeer = lf[1] + lf[2] + str(1).zfill(
3) + addrLocalPeer[0][0] + addrLocalPeer[0][1]
k = k + 1
connP.s.send(toPeer.encode())
Util.printLog("PACCHETTO AFIN 1 LOCAL-----> " +
str(toPeer))
elif (count > 1):
buffer_md5_l = md5
toPeer = lf[1] + lf[2] + str(count).zfill(3)
for l2 in ll2:
toPeer = toPeer + l2
connP.s.send(toPeer.encode())
Util.printLog("PACCHETTO AFIN 1+ LOCAL-----> " +
str(toPeer))
connP.deconnection()
def run(self):
db = dataBase()
dbs = dataBaseSuper()
self.config = db.retrieveAllConfig()
peersocket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
peersocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
peersocket.bind(('', self.port))
peersocket.listen(20)
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)
# SUPE ---
if (recv_type.decode() == "SUPE"):
Util.printLog('Ricevo SUPE da: ' + addrPack)
recv_packet = other_peersocket.recv(78) # 82 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 78):
recv_packet += other_peersocket.recv(78 -
self.bytes_read)
self.bytes_read = len(recv_packet)
Util.printLog("FINITO LETTURA SUPE, AVVIO THREAD SUPE")
pkt = recv_type + recv_packet
th_SUPE = ThreadSUPE(pkt.decode(), self.ipv4, self.ipv6,
addrPack)
th_SUPE.start()
# ASUP ---
elif (recv_type.decode() == "ASUP"):
Util.printLog("Ricevuto ASUP da: " + addrPack)
recv_packet = other_peersocket.recv(76) # 80 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 76):
recv_packet += other_peersocket.recv(76 -
self.bytes_read)
self.bytes_read = len(recv_packet)
Util.lock.acquire()
db.insertSuperPeers(recv_packet[16:71].decode(),
recv_packet[71:].decode())
db.insertResponse(recv_packet[:16].decode(),
recv_packet[16:71].decode(),
recv_packet[71:].decode(), "null",
"null")
Util.lock.release()
# QUER ---
elif (recv_type.decode() == "QUER"):
Util.printLog('Ricevo QUER da: ' + addrPack)
recv_packet = other_peersocket.recv(98) # 102 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 98):
Util.printLog(str(self.bytes_read))
recv_packet += other_peersocket.recv(98 -
self.bytes_read)
self.bytes_read = len(recv_packet)
Util.printLog("NUMERO LETTO : " + str(len(recv_packet)))
pkt = recv_type + recv_packet
Util.printLog("QUER RICEVUTO: " + pkt.decode())
th_QUER = ThreadQUER(pkt.decode(), addrPack)
th_QUER.start()
# AFIN ---
elif (recv_type.decode() == "AFIN"):
recv_packet = other_peersocket.recv(
3) # numero di md5 ottenuti
self.bytes_read = len(recv_packet)
Util.printLog("RICEVUTO AFIN")
while (self.bytes_read < 3):
recv_packet += other_peersocket.recv(3 -
self.bytes_read)
self.bytes_read = len(recv_packet)
recv_afin = Recv_Afin(int(recv_packet.decode()),
other_peersocket)
recv_afin.start()
# FIND ---
elif (recv_type.decode() == "FIND"):
recv_packet = other_peersocket.recv(36) # 40 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 36):
recv_packet += other_peersocket.recv(36 -
self.bytes_read)
self.bytes_read = len(recv_packet)
pktid = Util.ip_packet16()
addr = Util.ip_formatting(self.ipv4, self.ipv6, self.port)
Util.printLog("RICEVUTO FIND E TRASFORMO IN QUER " +
str(recv_packet[16:].decode()))
new_packet = "QUER" + pktid + addr + str(self.ttl).zfill(
2) + recv_packet[16:].decode().ljust(20)
Util.printLog("====> PACCHETTO DI QUER <====")
Util.printLog(str(new_packet))
Util.printLog("=============================")
th_FIND = ThreadFIND(new_packet, recv_packet[:16].decode())
th_FIND.start()
# AQUE ---
elif (recv_type.decode() == "AQUE"):
recv_packet = other_peersocket.recv(208) # 212 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 208):
recv_packet += other_peersocket.recv(208 -
self.bytes_read)
self.bytes_read = len(recv_packet)
Util.printLog("RICEVO GLI AQUE DALLA RETE")
recv_packet = recv_type + recv_packet
t_RESP = thread_Response(recv_packet.decode())
t_RESP.start()
# ADFF ---
elif (recv_type.decode() == "ADFF"):
recv_packet = other_peersocket.recv(148) # 152 - 4
self.bytes_read = len(recv_packet)
Util.printLog("LUNGHEZZA LETTURA AGG FILE " +
str(self.bytes_read))
while (self.bytes_read < 148):
Util.printLog("I'M HERE")
recv_packet += other_peersocket.recv(148 -
self.bytes_read)
self.bytes_read = len(recv_packet)
recv_packet = recv_type + recv_packet
Util.printLog("AGGIUNTO FILE AL SUPERPEER")
th_INS = ThreadINS(recv_packet.decode())
th_INS.start()
# DEFF ---
elif (recv_type.decode() == "DEFF"):
recv_packet = other_peersocket.recv(48) # 52 - 4
self.bytes_read = len(recv_packet)
while (self.bytes_read < 48):
recv_packet += other_peersocket.recv(48 -
self.bytes_read)
self.bytes_read = len(recv_packet)
recv_packet = recv_type + recv_packet
Util.printLog("ELIMINATO FILE AL SUPERPEER")
th_DEL = ThreadDEL(recv_packet.decode())
th_DEL.start()
# LOGI ---
elif (recv_type.decode() == "LOGI"):
recv_packet = other_peersocket.recv(60) # 64 - 4
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_ALGI = ThreadALGI(recv_packet[:55].decode(),
recv_packet[55:].decode(),
other_peersocket)
th_ALGI.ALGI()
Util.printLog("FINE LOGIN NEL CENTRAL THREAD")
# LOGO ---
elif (recv_type.decode() == "LOGO"):
recv_packet = other_peersocket.recv(16) # 20 - 4
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)
recv_packet = recv_type + recv_packet
Util.printLog("LOGOUT DAL SUPERPEER")
th_LOGO = ThreadLOGO(recv_packet.decode(),
other_peersocket)
th_LOGO.LOGO()
# UPLOAD ---
elif (recv_type.decode() == "RETR"):
recv_packet = other_peersocket.recv(32) # 36 - 4
Util.printLog("RICEVUTA RICHIESTA DI DOWNLOAD DI " +
recv_packet.decode() + " DALLA RETE")
self.bytes_read = len(recv_packet)
while (self.bytes_read < 32):
Util.printLog("DENTRO AL CICLO DEL RETR")
recv_packet += other_peersocket.recv(32 -
self.bytes_read)
self.bytes_read = len(recv_packet)
th_UPLOAD = Upload(self.port, recv_packet.decode(),
other_peersocket)
th_UPLOAD.start()
th_UPLOAD.join()
# EXIT ---
elif (recv_type.decode() == "EXIT"):
sys.exit()
if (recv_type.decode() not in ['AFIN', 'FIND']):
other_peersocket.close()