Bonjour,
je suis en train d'apprendre la programmation réseau, pour cette occasion j'ai codé un programme de chat rudimentaire
Quand j'exécute le code sur le même appareil tout va bien. Mais quand je l’exécute sur deux appareil différents (qui sont néanmoins sur le même réseau local) le client ne peut pas se connecter.
serveur:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
import socket, sys, threading
 
HOST = ""
PORT = 55555
 
class ThreadClient(threading.Thread):
    """gérer connexion client"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion2 = conn
 
    def run(self):
        #global dictionnairePseudo
        #Dialogue vec le client
        nom = self.getName()
        while True:
            try:
                msgClient = self.connexion2.recv(1024).decode()
            except socket.error:
                break
            if not msgClient or msgClient.lower() == "fin":
                break
 
            msgClient2 = msgClient.split("&#&#")
            if msgClient2[0] == "Pseudo":
                dictionnairePseudo[nom] = msgClient2[1]
                print(f"\033[0;36mClient {dictionnairePseudo[nom]} ({nom}) connecté avec l'adresse IP {adresse[0]} et le port {adresse[1]}\n {len(conn_client)} connectés\033[0m")
 
                message = "\033[0;31mServeur\033[0m > Vous êtes connecté... Vous pouvez désormais envoyer des messages"
                connexion.send(message.encode())
            else:
                msg = dictionnairePseudo[nom] + " > " + msgClient
                print(msg)
                #envoyer le message à tout les autres clients
                for cle in conn_client:
                    if cle != nom:
                        conn_client[cle].send(msg.encode())
 
        #femeture connexion
        print(f"\033[0;31mClient {dictionnairePseudo[nom]} ({nom}) déconnecté\n {len(conn_client) - 1} connectés\033[0m")
        del conn_client[nom]
        del dictionnairePseudo[nom]
        self.connexion2.close()
 
 
#Initialisation serveur
connexionPrincipale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    connexionPrincipale.bind((HOST,PORT))
except socket.error:
    print("\033[0;31mLa liaison a échoué...\033[0m")
    sys.exit()
 
print("Serveur prêt, en attente de requêtes...")
connexionPrincipale.listen(5)
 
#attente de connexion
conn_client = {}
dictionnairePseudo = {}
while True:
    connexion, adresse = connexionPrincipale.accept()
 
 
    thread = ThreadClient(connexion)
    thread.start()
    #Mémoriser connexion
    id = thread.getName()
    conn_client[id] = connexion
client:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
import socket, sys, threading, time
 
HOST = 'localhost'
PORT = 55555
 
class ThreadReception(threading.Thread):
    """reception des messages"""
    def __init__(self,conn):
        threading.Thread.__init__(self)
        self.connexion = conn
 
    def run(self):
        global entre
        while True:
            try:
                msg_recu = self.connexion.recv(1024).decode()
            except socket.error:
                break
            if entre == True:
                entre = 0
                print()
            print(msg_recu)
            if msg_recu == "" or msg_recu.lower() == "fin":
                break
 
        thEmission.join(timeout=0)
        print("\033[0;31mConnexion interrompue.\033[0m")
        self.connexion.close()
 
class ThreadEmission(threading.Thread):
    """émission des messages"""
    def __init__(self,conn):
        threading.Thread.__init__(self)
        self.connexion = conn
 
    def run(self):
        global entre
        while True:
            try:
                entre = 1
                msg_envoye = input("Votre message: ")
                entre = 0
                self.connexion.send(msg_envoye.encode())
            except socket.error:
                break
 
#Progrmme principal
entre = 1
Pseudo = input("Saisissez un Pseudo: ")
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    connexion.connect((HOST, PORT))
except socket.error:
    print(f"\033[0;31mLa connexion au serveur {HOST} sur le port {PORT} a échoué !\033[0m")
    sys.exit()
print("\033[0;36mConnexion établie auprès du serveur.\033[0m")
 
try:
    connexion.send(("Pseudo&#&#" + Pseudo).encode())
except socket.error:
    None
 
time.sleep(0.5)
#lancement thread pour gérer simultanément l'émission et la récéption des messages.
thReception = ThreadReception(connexion)
thEmission = ThreadEmission(connexion)
thReception.start()
thEmission.start()
PS: ligne 4 des deux scripts: j'ai tenté de remplacer "" et "localhost" par l'adresse IP local de mon ordinateur hébergent le programme serveur
dans les deux cas la connexion ne se fait pas si l'ordinateur hébergent le serveur et le client sont différents

PS2: Mon script n'est pas commenté et donc n'est pas très lisible; dite moi si une partie du code n'est pas claire
Avez-vous une idée de mon/mes erreurs ?