def addNoeudDNS(ipport, ipportNoeud):
error = 0
if autresFonctions.verifIPPORT(ipport):
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
logs.addLogs("Connection established with the DNS")
# =cmd DNS AddDNSExt ipport ******
request = "=cmd DNS AddDNSExt ipport " + ipportNoeud
request = request.encode()
connexion_avec_serveur.send(request)
message = connexion_avec_serveur.recv(1024)
connexion_avec_serveur.close()
if message == "=cmd IPPORTDejaUtilise":
error = 5
print(
str(c("red")) +
"The peer DNS is already known by the receiver." +
str(c("")))
elif message == "=cmd SUCCESS":
print(
str(c("green")) +
"The DNS pair has been added to the receiver base." +
str(c("")))
else:
print(
str(c("red")) +
"An undetermined error occurred. Please try again later or change DNS peer."
+ str(c("")))
error = 1
else:
error += 1
return error
def searchNDD(url):
# Fonction qui vérifie si le nom de file envoyé est plus petit qu'un SHA256
# Si c'est le cas, il va chercher chez les noeuds de DNS si ils connaissent ce nom de domaine
# Renvoie un SHA256
sha = ""
if len(url) <= 64:
# Ce n'est pas un nom de file, car il est plus petit qu'un SHA256
tableau = searchNoeud("DNS", 25)
for noeud in tableau:
noeud = str(noeud[0])
error = 0
connexion_avec_serveur = autresFonctions.connectionClient(noeud)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
sendCmd = b""
sendCmd = "=cmd DNS searchSHA ndd " + url
sendCmd = sendCmd.encode()
connexion_avec_serveur.send(sendCmd)
rcvCmd = connexion_avec_serveur.recv(1024)
rcvCmd = rcvCmd.decode()
connexion_avec_serveur.close()
if rcvCmd != "=cmd NNDInconnu" and rcvCmd != "=cmd ERROR":
# On a trouvé !!
sha = rcvCmd
break
return sha
def run(self):
error = 0
autresFonctions.verifFiles()
i = 0
while i < 50:
i += 1
self.conn = autresFonctions.connectionClient(self.ip, self.port)
if self.conn != "=cmd ERROR":
break
else:
time.sleep(0.2)
if str(self.conn) == "=cmd ERROR":
error += 1
else:
# Vérifier que l'on a le fichier
try:
tailleFichier = os.path.getsize("HOSTEDFILES/" + self.file)
if tailleFichier < 1:
error += 1
logs.addLogs("ERROR : The file is empty in upFile")
except Exception:
logs.addLogs("ERROR : The file doesn't exist")
error += 1
if error == 0:
# On peut continuer
sendCmd = "=cmd StartTransfer size " + str(tailleFichier)
self.conn.send(sendCmd.encode())
#Maintenant, on vérifie si le file peut être envoyé en une seule foie, ou si il faut le "découper"
pathFichier = "HOSTEDFILES/" + self.file
if tailleFichier > 1024:
#Le file doit être découpé avant d'être envoyé
fich = open(pathFichier, "rb")
num = 0
nbPaquets = math.ceil(tailleFichier / 1024)
deplacementFichier = 0
while num < nbPaquets:
fich.seek(
deplacementFichier, 0
) # on se deplace par rapport au numero de caractere (de 1024 a 1024 octets)
donnees = fich.read(
1024) # Lecture du file en 1024 octets
self.conn.send(
donnees) # Envoi du file par paquet de 1024 octets
num = num + 1
deplacementFichier = deplacementFichier + 1024
else:
#Le file peut être envoyé en une seule fois
fich = open(pathFichier, "rb")
donnees = fich.read() # Lecture du file
self.conn.send(donnees) # Envoi du file
self.conn.close()
if error != 0:
logs.addLogs("ERROR : An error has occured in upFile (" +
str(error) + ").")
f = open(".TEMP/" + str(self.temp), "w")
f.write(str(error))
f.close()
def majDNS(ipportNoeud=""):
# Fonction pour noeud DNS qui permet de mettre à jour toute sa base avec un autre noeud
BDD.verifExistBDD()
problem = 0
conn = sqlite3.connect('WTP.db')
cursor = conn.cursor()
ipport = ""
if ipportNoeud == "":
try:
cursor.execute(
"""SELECT IP FROM Noeuds WHERE Fonction = 'DNS' ORDER BY RANDOM() LIMIT 1"""
)
rows = cursor.fetchall()
conn.close()
except Exception as e:
conn.rollback()
logs.addLogs(
"DNS : ERROR : Problem with the database (majDNS()):" + str(e))
problem += 1
else:
for row in rows:
ipport = row[0]
else:
ipport = ipportNoeud
if ipport != "":
# Maintenant on va demander au noeud DNS distant d'envoyer toutes ses entrées DNS pour
# Que l'on puisse ensuite analyser, et ajouter/mettre à jour notre base
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) != "=cmd ERROR":
sendCmd = b""
sendCmd = "=cmd DNS syncBase"
connexion_avec_serveur.send(sendCmd.encode())
rcvCmd = connexion_avec_serveur.recv(1024)
rcvCmd = rcvCmd.decode()
connexion_avec_serveur.close()
# Le noeud renvoie le nom du fichier à télécharger
# Et son IP:PortPrincipal, sinon =cmd ERROR
if rcvCmd != "=cmd ERROR":
# =cmd Filename ****** ipport ******
filename = rcvCmd[14:rcvCmd.find(" ipport ")]
ipport = rcvCmd[rcvCmd.find(" ipport ") + 8:]
ip = ipport[:ipport.find(":")]
port = ipport[ipport.find(":") + 1:]
error += fctsClient.CmdDemandeFichier(ip, port, filename)
if error == 0:
echangeListes.filetoTable(filename, "DNS")
else:
problem += 1
else:
problem += 1
else:
problem += 1
else:
problem += 1
return problem
def CmdDemandeNoeud(ip, port):
error = 0
connNoeud = autresFonctions.connectionClient(ip, port)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs(
"INFO : Connection with peer etablished on port {}".format(port))
request = "=cmd DemandeNoeud"
request = request.encode()
connNoeud.send(request)
rcvCmd = connNoeud.recv(1024)
connNoeud.close()
error += echangeNoeuds.DemandeNoeuds(str(rcvCmd))
return error
def sayHello():
# Fonction dont le but est d'avertir des noeuds importants de sa présence
error = 0
ipPortMe = autresFonctions.connaitreIP()
connNoeud = autresFonctions.connectionClient(ipport)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs("INFO : Connection with VPN peer etablished")
request = "=cmd HELLO " + ipPortMe
request = request.encode()
connNoeud.send(request)
print(connNoeud.recv(1024))
connNoeud.close()
return error
def CmdDemandeListeNoeuds(ip, port):
sendCmd = "=cmd DemandeListeNoeuds"
error = 0
connNoeud = autresFonctions.connectionClient(ip, port)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs(
"INFO : Connection with peer etablished on port {}".format(port))
sendCmd = sendCmd.encode()
connNoeud.send(sendCmd)
fileName = connNoeud.recv(1024)
connNoeud.close()
error += CmdDemandeFichier(ip, port, fileName.decode())
echangeListes.filetoTable(fileName.decode(), "Noeuds")
return error
def CmdDemandeStatut(ip, port):
error = 0
# On demande le statut du noeud (Simple, Parser, DNS, VPN, Main)
connNoeud = autresFonctions.connectionClient(ip, port)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs(
"INFO : Connection with peer etablished on port {}".format(port))
sendCmd = "=cmd status"
connNoeud.send(sendCmd.encode())
statut = connNoeud.recv(1024)
connNoeud.close()
if (statut[:5] == "=cmd "):
statut = statut[5:] # On enlève "=cmd "
else:
error += 1
if error != 0:
return error
return statut
def supprNDD(ipport, ndd, password):
error = 0
if autresFonctions.verifIPPORT(ipport):
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
logs.addLogs("Connection established with the DNS")
# =cmd DNS supprNDD ndd ****** pass ******
request = "=cmd DNS supprNDD ndd " + str(ndd) + " pass " + str(
password)
request = request.encode()
connexion_avec_serveur.send(request)
message = connexion_avec_serveur.recv(1024)
if message != "=cmd SUCCESS":
error += 1
connexion_avec_serveur.close()
else:
error += 1
return error
def VPN(demande, ipPortVPN, ipPortExt):
error = 0
if autresFonctions.verifIPPORT(ipPortExt) and reg.match(ipPortVPN):
ip = ipPortVPN[:ipPortVPN.find(":")]
port = ipPortVPN[ipPortVPN.find(":") + 1:]
connNoeud = autresFonctions.connectionClient(ip, port)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs(
"INFO : Connection with VPN peer etablished on port {}".format(
port))
# =cmd VPN noeud 127.0.0.1:5555 request =cmd DemandeFichier
request = "=cmd VPN noeud " + ipPortExt + " request " + demande
request = request.encode()
connNoeud.send(request)
print(connNoeud.recv(1024))
connNoeud.close()
# Maintenant que l'on a demandé au VPN d'executer la demande, il faut recuperer les donnnées
# Pour cela, il faut analyser la request initiale
if request[:19] == "=cmd DemandeFichier":
# =cmd DemandeFichier nom sha256.ext
error += CmdDemandeFichier(ip, port, request[24:])
elif request[:17] == "=cmd DemandeNoeud":
CmdDemandeNoeud(ip, port)
elif request[:28] == "=cmd DemandeListeFichiersExt":
CmdDemandeListeFichiers(ip, port, 1)
elif request[:25] == "=cmd DemandeListeFichiers":
CmdDemandeListeFichiers(ip, port)
elif request[:23] == "=cmd DemandeListeNoeuds":
CmdDemandeListeNoeuds(ip, port)
elif request[:22] == "=cmd rechercher":
# =cmd rechercher nom SHA256.ext
search.rechercheFichierEntiere(sendCmd[20:])
else:
logs.addLogs("ERROR : Unknown request (VPN()) : " +
str(request))
error += 1
else:
error += 1
return error
def maj(ipport=""):
# Fonction pour noeud DNS qui permet de mettre à jour toute sa base avec un autre noeud
BDD.verifExistBDD()
error = 0
if ipport == "":
ipport = str(config.readConfFile("Blacklist"))
else:
if ipport != "":
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) != "=cmd ERROR":
sendCmd = b""
sendCmd = "=cmd BlackList sync"
connexion_avec_serveur.send(sendCmd.encode())
rcvCmd = connexion_avec_serveur.recv(1024)
rcvCmd = rcvCmd.decode()
connexion_avec_serveur.close()
# Le noeud renvoie le nom du fichier à télécharger
# Et son IP:PortPrincipal, sinon =cmd ERROR
if rcvCmd != "=cmd ERROR":
# =cmd Filename ****** ipport ******
filename = rcvCmd[14:rcvCmd.find(" ipport ")]
ipport = rcvCmd[rcvCmd.find(" ipport ") + 8:]
ip = ipport[:ipport.find(":")]
port = ipport[ipport.find(":") + 1:]
error += fctsClient.CmdDemandeFichier(ip, port, filename)
if error == 0:
echangeListes.filetoTable(filename, "BlackList")
else:
error += 1
else:
error += 1
else:
error += 1
else:
error += 1
logs.addLogs("ERROR : No peer ip was found in Blacklist.maj()")
return error
def searchBlackList(name, Isrank=False):
rank = 0
rank = search.chercherInfo("Blacklist", name)
if rank == 0:
ipport = str(config.readConfFile("Blacklist"))
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) != "=cmd ERROR":
sendCmd = "=cmd BlackList name " + str(name)
connexion_avec_serveur.send(sendCmd.encode())
rcvCmd = connexion_avec_serveur.recv(1024)
rcvCmd = rcvCmd.decode()
connexion_avec_serveur.close()
rank = rcvCmd
# Le noeud renvoie le nom du fichier à télécharger
# Et son IP:PortPrincipal, sinon =cmd ERROR
else:
logs.addLogs("ERROR : Can not check the " + str(name) +
" item in the blacklist")
return 0
if Isrank:
return rank
if rank == 0:
return 0
return 1
def CmdDemandeFichier(ip, port, file):
if blacklist.searchBlackList(file) != 0:
logs.addLogs("ERROR : This file is part of the Blacklist : " +
str(file))
return 1
error = 0
connNoeud = autresFonctions.connectionClient(ip, port)
if str(connNoeud) == "=cmd ERROR":
error += 1
else:
logs.addLogs(
"INFO : Connection with peer etablished on port {}".format(port))
# Il faut trouver un port libre pour que le noeud donneur
# puisse se connecter à ce noeud sur le bon port
freePort = autresFonctions.portLibre(
int(config.readConfFile("miniPort")))
temp = str(time.time())
thrdDown = echangeFichiers.downFile(file, int(freePort), temp)
thrdDown.start()
newIPPort = str(autresFonctions.connaitreIP()) + ":" + str(freePort)
sendCmd = "=cmd DemandeFichier nom " + str(file) + " ipport " + str(
newIPPort)
connNoeud.send(sendCmd.encode())
connNoeud.close()
thrdDown.join()
# Lire le fichier temporaire pour savoir si il y a eut des erreurs
try:
f = open(".TEMP/" + temp, "r")
error += int(f.read())
f.close()
os.remove(".TEMP/" + temp)
except Exception as e:
error += 1
logs.addLogs("ERROR : An error occured in CmdDemandeFichier : " +
str(e))
return error
def modifNDD(ipport, ndd, adress, password):
error = 0
if autresFonctions.verifIPPORT(ipport):
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
logs.addLogs("Connection established with the DNS")
# =cmd DNS modifNDD ndd ****** adress ****** pass ******
request = "=cmd DNS modifNDD ndd " + str(ndd) + " adress " + str(
adress) + " pass " + str(password)
request = request.encode()
connexion_avec_serveur.send(request)
message = connexion_avec_serveur.recv(1024)
connexion_avec_serveur.close()
error = 0
if message == "=cmd IPPORTDejaUtilise":
error = 5
print(
str(c("red")) +
"Le noeud DNS est déjà connu par le receveur." +
str(c("")))
elif message == "=cmd SUCCESS":
print(
str(c("green")) +
"Le noeud DNS a bien été ajouté à la base du receveur." +
str(c("")))
else:
print(
str(c("red")) +
"An undetermined error occurred. Please try again later or change DNS peer."
+ str(c("")))
error += 1
else:
error += 1
return error
def addNDD(ipport, sha, ndd, password):
error = 0
if autresFonctions.verifIPPORT(ipport): # Si ipport est un ip:port
connexion_avec_serveur = autresFonctions.connectionClient(ipport)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
logs.addLogs("Connection established with the DNS")
# =cmd DNS AddDNS sha ******* ndd ******* pass *******
request = "=cmd DNS AddDNS sha " + str(sha) + " ndd " + str(
ndd) + " pass " + str(password)
request = request.encode()
connexion_avec_serveur.send(request)
message = connexion_avec_serveur.recv(1024)
connexion_avec_serveur.close()
if message == "=cmd NDDDejaUtilise":
error = 5
print(
str(c("red")) + "The domain name is already used." +
str(c("")) +
" If it belongs to you, you can modify it provided you know the password."
)
elif message == "=cmd SUCCESS":
print(
str(c("green")) +
"The domain name and address SHA256 have been associated."
+ str(c("")))
else:
print(
str(c("red")) +
"An undetermined error occurred. Please try again later or change DNS peer."
+ str(c("")))
error = 1
else:
error += 1
return error
def searchFile(fileName):
# Fonction qui a pour but de chercher sur le réseau un file
# Il faut d'abord chercher dans la BDD, et si il n'y est pas on cherche plus spécifiquement
# IPpeerPort est la variable qui contient l'IP Port du noeud qui possède le file
BDD.verifExistBDD()
IPpeerPort = ""
conn = sqlite3.connect('WTP.db')
cursor = conn.cursor()
# On va chercher dans les files hébergés
try:
cursor.execute("""SELECT id FROM Fichiers WHERE Nom = ?""",
(fileName, ))
except Exception as e:
logs.addLogs("ERROR : Problem with database (searchFile()):" + str(e))
rows = cursor.fetchall()
for row in rows:
boucle += 1
# Le file est hébergé par le noeud qui le cherche
ipPortIci = "127.0.0.1:" + str(config.readConfFile("defaultPort"))
IPpeerPort = ipPortIci
# Si le file n'a pas été trouvé
# Il faut chercher dans les files connus externes
try:
cursor.execute("""SELECT IP FROM FichiersExt WHERE Nom = ?""",
(fileName, ))
except Exception as e:
logs.addLogs("ERROR : Problem with database (searchFile()):" + str(e))
else:
rows = cursor.fetchall()
for row in rows:
# Le file est hébergé par un noeud connu
IPpeerPort = str(row)
if IPpeerPort == "":
# Il faut demander aux noeuds que l'on connait
tblNoeuds = BDD.aleatoire("Noeuds", "IP", 10)
# On a 10 noeuds dans le tableau
# Maintenant, il faut vérifier que au moins la moitiée des noeuds choisis aléatoirement
# sont des noeuds "simple", puis mettre les noeuds "simple" au début du tableau
tableauNoeudsSimple = []
tableauSuperNoeuds = []
for noeud in tblNoeuds:
# On verifie chaque noeud
fonctionNoeud = chercherInfo("Noeuds", noeud)
if fonctionNoeud == "simple":
tableauNoeudsSimple.append(noeud)
if fonctionNoeud == "supernoeud" or fonctionNoeud == "DNS":
tableauSuperNoeuds.append(noeud)
if len(tableauNoeudsSimple) < 6:
# Il n'y a pas assez de noeuds simples dans la liste,
# Il faut aller en rechercher
logs.addLogs("WARNING : Not enough simple peers")
# On ajoute les super noeuds après les noeuds simples
tblNoeuds = tableauNoeudsSimple + tableauSuperNoeuds
for noeudActuel in tblNoeuds:
# À chaque noeud on demande si il a le file ou s'il connait un noeud qui l'a
# Maintenant on se connecte au noeud
error = 0
connexion_avec_serveur = autresFonctions.connectionClient(
noeudActuel)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
sendCmd = b""
sendCmd = "=cmd rechercherFichier nom " + fileName
sendCmd = sendCmd.encode()
connexion_avec_serveur.send(sendCmd)
rcvCmd = connexion_avec_serveur.recv(1024)
rcvCmd = rcvCmd.decode()
connexion_avec_serveur.close()
if rcvCmd != "0":
IPpeerPort = rcvCmd
break
return IPpeerPort # Peut retourner "" si il ne trouve pas d'hébergeur
# Le noeud est un DNS, on lance la fonction.
ThrdDNS = ServDNS()
ThrdDNS.start()
if (str(config.readConfFile("VPN")) == "True"):
# Le noeud est un VPN, on lance la fonction.
ThrdVPN = ServVPN()
ThrdVPN.start()
#ThrdBrd = Bridge()
#ThrdBrd.start()
# On indique notre présence à quelques parseurs
tableau = BDD.aleatoire("Noeuds", "IP", 15, "Parser")
if isinstance(tableau, list) and tableau:
# On envoi la request à chaque noeud sélectionné
for peerIP in tableau:
peerIP = peerIP[0]
connNoeud = autresFonctions.connectionClient(peerIP)
if str(connNoeud) != "=cmd ERROR":
logs.addLogs("INFO : Connection with peer etablished")
request = "=cmd newPeerNetwork ip " + str(
config.readConfFile("MyIP")) + str(
config.readConfFile("defaultPort"))
request = request.encode()
connNoeud.send(request)
rcvCmd = connNoeud.recv(1024)
connNoeud.close()
if rcvCmd == "=cmd noParser":
# Il faut changer le paramètre du noeud, il n'est pas parseur mais simple
BDD.supprEntree("Noeuds", peerIP)
BDD.ajouterEntree("Noeuds", peerIP)
elif rcvCmd != "=cmd peerAdded":
# Une erreur s'est produite
def cmdLauncher(userCmd):
error = 0
if userCmd == "help":
# Afficher toutes les options
documentation.mini()
elif userCmd == "update":
# Vérifier les MAJ
status = loader("Work in progress")
status.start()
#maj.verifMAJ()
#maj.verifSources()
status.stop()
status.join()
print(c("green") + "Done." + c(""))
elif userCmd == "stats":
# Affiche les statistiques
print("Number of peers in the database : " +
str(stats.compterStats("NbNoeuds")))
print("Number of special peers in the database : " +
str(stats.compterStats("NbSN")))
print("Number of external files in the database : " +
str(stats.compterStats("NbFichiersExt")))
print("Number of files on this hard drive : " +
str(stats.compterStats("NbFichiers")))
print("Size of all files : " +
str(stats.compterStats("PoidsFichiers")))
print("Number of peers lists sent : " +
str(stats.compterStats("NbEnvsLstNoeuds")))
print("Number of file lists sent : " +
str(stats.compterStats("NbEnvsLstFichiers")))
print("Number of external file lists sent : " +
str(stats.compterStats("NbEnvsLstFichiersExt")))
print("Number of files sent : " +
str(stats.compterStats("NbEnvsFichiers")))
print("Number of presence requests received : " +
str(stats.compterStats("NbPresence")))
print("Number of files received : " +
str(stats.compterStats("NbReceptFichiers")))
elif userCmd == "config":
# Modifier le fichier de configuration
config.modifConfig()
elif userCmd == "dns":
# Entrer dans le programme de configuration du DNS
thrdDNS = DNSConfig()
thrdDNS.start()
thrdDNS.join()
elif userCmd == "exit":
# On arrète WTP
print(
"Pro tip : You can also stop WTP at any time by pressing Ctrl + C."
)
return -1
elif userCmd == "doc":
# On affiche la documentation
documentation.maxi()
elif userCmd == "checkFiles":
# On vérifie immédiatement dans ADDFILES, HOSTEDFILES et .TEMP
status = loader("Work in progress")
status.start()
fctsMntc.checkIntruders()
fctsMntc.creerFichier()
fctsMntc.supprTemp()
status.stop()
status.join()
print(c("green") + "Done." + c(""))
elif userCmd == "delAll":
print(
"Are you sure you want to delete everything ?\nAll configuration, database, hosted files will be lost."
)
print("You will not be able to go back.")
if str(input("If you are sure, enter DeleteAll\n>> ")) == "DeleteAll":
print(
"We are sorry to see you go.\nWe hope to see you very soon !\nIf you have comments to send to you, please contact us via our website :\nhttps://myrasp.fr/WTP"
)
status = loader("Work in progress")
status.start()
shutil.rmtree(str(os.getcwd()) + "/HOSTEDFILES")
shutil.rmtree(str(os.getcwd()) + "/ADDFILES")
os.remove(str(os.getcwd()) + "/.extinctionWTP")
os.remove(str(os.getcwd()) + "/.TempMaintenance24H")
os.remove(str(os.getcwd()) + "/.TempMaintenance5M")
logs.rapportErreur()
os.remove(str(os.getcwd()) + "/logs.txt")
os.remove(str(os.getcwd()) + "/wtp.conf")
status.stop()
status.join()
return -1
print(
"You scared us!\nFortunately, you have not passed the dark side of the force!"
)
elif userCmd == "majDNS":
print(
"You want to update the DNS database.\nIf you are crazy, you can enter crazy to update with a random peer."
)
ipport = str(
input("With which DNS do you want to update ? (IP:Port)\n>> "))
# Vérifier le noeud
if autresFonctions.verifIPPORT(ipport):
# C'est un IPPort
co = autresFonctions.connectionClient(ipport)
if co != "=cmd ERROR":
sendCmd = "=cmd status"
co.send(sendCmd.encode())
rcvCmd = co.recv(1024).decode()
co.close()
if rcvCmd == "=cmd DNS":
e = dns.majDNS(ipport)
if int(e) > 0:
print(c("red") + "An error occured." + c(""))
else:
print(c("green") + "Done." + c(""))
else:
print(c("red") + "This peer isn't DNS." + c(""))
print(c("red") + "Unable to connect to this peer." + c(""))
elif ipport == "crazy":
print(
"DISCLAMER : Some peers can be controlled by malicious people who can perform phishing attacks"
)
rep = str(input("Are you sure ? (y/N)\n>>"))
if rep == "y" or rep == "Y":
e = dns.majDNS()
if int(e) > 0:
print(c("red") + "An error occured." + c(""))
else:
print(c("green") + "Done." + c(""))
else:
print(
"You scared us!\nFortunately, you have not passed the dark side of the force!"
)
else:
print(c("red") + "It's not an ip:port" + c(""))
elif userCmd == "client":
# Possibilité de faire des demandes en console
error = 0
sendCmd = ""
print(
"You can now write requests and send them to the peers you want.")
print("Exit this wizard and enter doc for more information.")
while sendCmd != "exit":
sendCmd = str(
input(
"What is your request ? (exit for quit this wizard)\n>> "))
if sendCmd == "doc":
documentation.maxi()
elif sendCmd != "exit":
host = str(
input(
"What is the IP of the peer that you want to contact ? > "
))
try:
port = int(
input(
"What is the Port of the peer that you want to contact ? > "
))
except ValueError:
print(
c("red") + "It isn't a port (between 1024 and 65535)" +
c(""))
else:
if sendCmd == "=cmd DemandeNoeud":
error += fctsClient.CmdDemandeNoeud(host, port)
elif sendCmd[:19] == "=cmd DemandeFichier":
# =cmd DemandeFichier nom sha256.ext
error += fctsClient.CmdDemandeFichier(
host, port, sendCmd[24:])
elif sendCmd == "=cmd DemandeListeNoeuds":
error += fctsClient.CmdDemandeListeNoeuds(host, port)
elif sendCmd == "=cmd DemandeListeFichiers":
error += fctsClient.CmdDemandeListeFichiers(host, port)
elif sendCmd[:19] == "=cmd rechercher nom":
# =cmd rechercher nom SHA256.ext
sortie = search.rechercheFichierEntiere(sendCmd[20:])
ipport = sortie[:sortie.find(";")]
sha = sortie[sortie.find(";") + 1:]
if autresFonctions.verifIPPORT(ipport):
# C'est un IPPort
# On envoi vers la fonction qui télécharge le file
ip = ipport[:ipport.find(":")]
port = int(ipport[ipport.find(":") + 1:])
error += fctsClient.CmdDemandeFichier(
ip, int(port), sha)
else:
# C'est une erreur
print(sortie)
error += 1
else:
error = 0
connexion_avec_serveur = autresFonctions.connectionClient(
host, port)
if str(connexion_avec_serveur) == "=cmd ERROR":
error += 1
else:
connexion_avec_serveur.send(sendCmd.encode())
rcvCmd = connexion_avec_serveur.recv(1024).decode()
connexion_avec_serveur.close()
print(rcvCmd)
if int(error) == 0:
print(c("green") + "Done." + c(""))
else:
print(
c("red") + "An error occured. (" + str(error) +
")" + c(""))
else:
break
elif userCmd == "add":
# L'utilisateur veut ajouter quelque chose
categorie = str(input("What do you want to add ?\n>>> "))
if categorie == "peer":
ipport = str(input("What is the IP:Port of the peer ?\n>>> "))
error = BDD.ajouterEntree("Noeud", ipport)
if error == 0:
print(c("green") + "Done." + c(""))
else:
print(c("red") + "An error occured (" + str(error) + ").")
else:
print(c("red") + "Your input is unknown." + c(""))
print(
c("cian") + "You can enter help for more information." + c(""))
elif userCmd == "blacklist":
blckLst = clientBlacklist.configBlckLst()
blckLst.start()
blckLst.join()
else:
print(c("red") + "Unknown request." + c(""))
return 0
def creerFichier():
# Fonction qui va s'executer via la maintenance assez régulièrement
# Elle regarde dans le dossier ADDFILES si il y a des files
# Si oui, elle les copie dans le dossier HOSTEDFILES, les renomme de type SHA256.extention
# Elle envoie vers la fonction contenue dans BDD.py qui va ajouter les files à la base de données
# Et pour finir, elle supprime les files ajoutés de façon à ce que le dossier ADDFILES soit vide.
repertoire = "ADDFILES"
# Vérifier si le dossier ADDFILES existe, sinon le créer
try:
os.makedirs("ADDFILES")
except OSError:
if not os.path.isdir("ADDFILES"):
raise
# Vérifier si le dossier HOSTEDFILES existe, sinon le créer
try:
os.makedirs("HOSTEDFILES")
except OSError:
if not os.path.isdir("HOSTEDFILES"):
raise
dirs = os.listdir(repertoire)
# This would print all the files and directories
for file in dirs:
file = repertoire + "/" + file
if os.path.isfile(file):
# L'élément est un file, c'est bon (et pas un dossier)
try:
with open(file, "rb") as fluxLecture:
contenu = fluxLecture.read()
fluxLecture.close()
except UnicodeDecodeError:
logs.addLogs("ERROR : The file is not supported : " +
str(file))
os.remove(file)
else:
shaFichier = hashlib.sha256(str(contenu).encode()).hexdigest()
osef, extention = os.path.splitext(file)
filename = shaFichier + extention
fileDir = "HOSTEDFILES/" + filename
fluxEcriture = open(fileDir, "wb")
fluxEcriture.write(contenu)
fluxEcriture.close()
os.remove(file)
# L'ajouter à la BDD
BDD.ajouterEntree("Fichiers", filename)
logs.addLogs(
"INFO : A new hosted file has been added successfully : " +
filename)
# On transmet à quelques noeuds l'information
tableau = BDD.aleatoire("Noeuds", "IP", 15, "Parser")
if isinstance(tableau, list) and len(tableau) == 15:
# On envoi la request à chaque noeud sélectionné
for peerIP in tableau:
connNoeud = autresFonctions.connectionClient(peerIP)
if str(connNoeud) != "=cmd ERROR":
logs.addLogs(
"INFO : Connection with peer etablished")
request = "=cmd newFileNetwork name " + filename + " ip " + str(
config.readConfFile("MyIP")) + str(
config.readConfFile("defaultPort"))
request = request.encode()
connNoeud.send(request)
rcvCmd = connNoeud.recv(1024)
connNoeud.close()
if rcvCmd == "=cmd noParser":
# Il faut changer le paramètre du noeud, il n'est pas parseur mais simple
BDD.supprEntree("Noeuds", peerIP)
BDD.ajouterEntree("Noeuds", peerIP)
elif rcvCmd != "=cmd fileAdded":
# Une erreur s'est produite
logs.addLogs(
"ERROR : The request was not recognized in creerFichier() : "
+ str(rcvCmd))
else:
logs.addLogs(
"ERROR : An error occured in creerFichier() : "
+ str(connNoeud))
else:
# Une erreur s'est produite
logs.addLogs(
"ERROR : There is not enough IP in creerFichier() : " +
str(tableau))
