Discussion :

[mcdonald]

bonjour,

J ai décidé de créer un programme pour transférer des fichier d un ordinateur a un autre voici le prog.

Sa c'est le serveur celui qui va devoire réceptionner le fichier:

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
 
 
HOST = '192.168.1.33'
PORT = 50000
 
import socket, sys, threading, os
 
class ThreadClient(threading.Thread):
    '''dérivation d'un objet thread pour gérer la connexion avec un client'''
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn
 
    def run(self):
        # Dialogue avec le client :
        nom = self.getName()            # Chaque thread possède un nom
        while 1:
            msgClient = self.connexion.recv(1024)
            lf = int(msgClient)
            print lf
            msgClient = self.connexion.recv(1024)
            nfichier = msgClient
            a = 0
            donnee = ""
            while a < 100:
                a = a+1
                msgClient = self.connexion.recv(lf/100)
                donnee = donnee + msgClient
                for cle in conn_client:
                    conn_client[cle].send(str(a-1))
                print a-1
            msgClient = self.connexion.recv(lf)
            donnee = donnee + msgClient
            for cle in conn_client:
                conn_client[cle].send(str(100))
            print "100"
 
            if msgClient.upper() == "FIN" or msgClient == "":
                break
            ############### reconstitution du fichier #############
            dest = open(nfichier, 'wb')
            dest.write(donnee)
            dest.close()
            ############### reconstitution du fichier #############
 
        # Fermeture de la connexion :
        self.connexion.close()      # couper la connexion côté serveur
        del conn_client[nom]        # suppr. son entrée dans le dictionnaire
        print "Client %s déconnecté." % nom
        # Le thread se termine ici    
 
 
def emission():
    class ThreadEmission(threading.Thread):
        while 1:
            # Faire suivre le message à tous les autres clients :
            message_serveur = raw_input()
            for cle in conn_client:
                conn_client[cle].send(message_serveur)
 
 
 
 
 
 
# Initialisation du serveur - Mise en place du socket :
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    mySocket.bind((HOST, PORT))
except socket.error:
    print "La liaison du socket à l'adresse choisie a échoué."
    sys.exit()
print "Serveur prêt, en attente de requêtes ..."
mySocket.listen(5)
 
# Attente et prise en charge des connexions demandées par les clients :
conn_client = {}                # dictionnaire des connexions clients
while 1:    
    connexion, adresse = mySocket.accept()
    # Créer un nouvel objet thread pour gérer la connexion :
    th = ThreadClient(connexion)
    th.start()
    # Mémoriser la connexion dans le dictionnaire : 
    it = th.getName()        # identifiant du thread
    conn_client[it] = connexion
    print "Client %s connecté, adresse IP %s, port %s." %\
           (it, adresse[0], adresse[1])
    # Dialogue avec le client :
    #connexion.send("Vous êtes connecté. Envoyez vos messages.")
    emission()

Sa c est le client celui qui dois envoyé le fichier:

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
from Tkinter import *
import tkFileDialog 
from tkFileDialog import *
import tkMessageBox
from tkMessageBox import *
import os.path
import  Tkinter as Tk
from random import randrange
import os.path
 
import socket, sys, threading, time
 
donnee = ""
nfichier = ""
pourcent = 0
progression100 = ""
 
fen1 = ""
temps = 0
b = 0
 
def parcourir():
    global donnee, nfichier
    nfichier = tkFileDialog.askopenfilename(filetypes = [("Choisis un fichier","*.*")], initialdir="C:/")
    textl.configure(text = "Le fichier fait " + str(os.path.getsize(nfichier)) + " octets")
 
    f = open(nfichier, "rb")
    donnee = f.read()
    f.close()
 
 
def ok():
    global fen1, donnee, nfichier, pourcent, progression100, pboutton, text, textl, text2, entry, ok, temps, b  
 
    HOST = entry.get()
    PORT = 50000
    connect12 = 1
 
    class ThreadReception(threading.Thread):
        global pourcent, progression100, fen1, text, temps, nfichier, b
        """objet thread gérant la réception des messages"""
        def __init__(self, conn):
            threading.Thread.__init__(self)
            self.connexion = conn           # réf. du socket de connexion
 
        def run(self):
            global progression100, fen1, text, temps, nfichier, b         
            a = 0
            while a < 100:
                a = a+1
                message_recu = self.connexion.recv(len(str(a-1)))
                octets = (a * ((os.path.getsize(nfichier))/100))/(time.clock()-temps)
                textl.configure(text = str(octets) + " o/s")                      
                text.configure(text = str(message_recu) + " %")
 
            message_recu = self.connexion.recv(1024)
            text.configure(text = str(message_recu) + " %")                
 
            b = b+1
            print "FIN"
            th_R._Thread__stop()
 
    class ThreadEmission(threading.Thread):
        global temps, b
        """objet thread gérant l'émission des messages"""
        def __init__(self, conn):
            threading.Thread.__init__(self)
            self.connexion = conn           # réf. du socket de connexion
 
        def run(self):
            global temps, b
            self.connexion.send(str(os.path.getsize(nfichier)))
            print str(os.path.getsize(nfichier))
            temps = time.clock()
            self.connexion.send(os.path.basename(nfichier))
 
            self.connexion.send(donnee)
 
            b = b+1             
            print "FIN2"
            th_E._Thread__stop()
 
    if donnee == "":
        tkMessageBox.showinfo("Fichier incorrecte", "Clique sur parcourir ... pour choisir un fichier à envoyer !") 
    else:       
        # Programme principal - Établissement de la connexion :
        connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            connexion.connect((HOST, PORT))
        except socket.error:
            connect12 = 0
        if connect12 == 0:
            tkMessageBox.showinfo("La connexion a échoué", "L'adresse IP du destinataire est fausse ou il n'est pas disponible pour le momment !") 
        else:
            print "FENETRE 1 DETRUIT"
            fen1.title("Transfer en cours")
            textl.configure(text = "x o/s")
            text.grid(row = 0, padx = 100, pady = 10)
            textl.grid(row = 1, padx = 100, pady = 10)
 
            pboutton.destroy()
            text2.destroy()
            entry.destroy()
            ok.destroy()
            # Dialogue avec le serveur : on lance deux threads pour gérer
            # indépendamment l'émission et la réception des messages :
            th_E = ThreadEmission(connexion)
            th_R = ThreadReception(connexion)
            th_E.start()
            th_R.start()
 
            c = 0
            while c < 1:
                if b == 2:
                    tkMessageBox.showinfo("Fichier envoyé", "Le fichier a été correctement envoyer !   ")
                    connexion.close()
                    fen1.destroy()
                    break
 
 
 
 
 
fen1 = Tk.Tk()
fen1.title("Envoie de fichier")
 
text = Label(fen1, text = "Choisis le fichier à envoyer")
text.grid(row = 0, padx = 50, pady = 20)
pboutton = Button(fen1, text = "   Parcourire ...   ", command = parcourir)
pboutton.grid(row = 5, column = 0, padx = 10 , pady = 0)
textl = Label(text = "")
textl.grid(row = 8, pady = 20)
text2 = Label(text = "HOST")
text2.grid(row = 9)
entry = Entry(fen1)
entry.grid(row = 10)
ok = Button(fen1, text = "      Envoyer     ", command = ok)
ok.grid(row = 11, pady = 20)
 
 
fen1. mainloop()

Quand j ouvre le serveur est le client sur mon ordinateur tout va bien le fichier est envoyer et receptionner.

Le probleme c est quand le serveur est sur mon ordi et que le client est sur un autre ordi le connection n'arrive pas a s'etablire.


Merci de votre aide

[DiGiTAL_MiDWAY]

met
HOST = '0.0.0.0'

[mcdonald]

Sa va toujours pas

[naxelas]

Quand j ouvre le serveur est le client sur mon ordinateur tout va bien le fichier est envoyer et receptionner.

Le probleme c est quand le serveur est sur mon ordi et que le client est sur un autre ordi le connection n'arrive pas a s'etablire.

Tu travailles en réseau local, ou bien le client est un hôte distant? Dans ce dernier cas, tu es derrière un router?

[mcdonald]

Le client est un hôte distant. Donc je dois faire quoi.

[naxelas]

Alors la machine de ton serveur doit être accessible depuis l'extérieur.
Tu dois connaître ton IP.
Si tu es directement connecté à internet ça devrait aller.
Si tu es derrière un router tu dois le configurer pour qu'il redirige le port 50000 vers ta machine. (il semble que cela soit ton cas, donc redirige le port 50000 vers ta machine, 192.168.1.33)

[mcdonald]

Or un routeur bloque par défaut tout connection entrante différente du port 80 sauf si une régle a été créée pour ouvrir un port.

J ai trouvé sa sur un site donc j ai aisayer de mettre 80 pour le port mais sa va toujours pas.

[DiGiTAL_MiDWAY]

c normal il faut que tu mette le port que ton application utilise, le 50000

[mcdonald]

(il semble que cela soit ton cas, donc redirige le port 50000 vers ta machine, 192.168.1.33)

Oui mais comment ? Merci

[naxelas]

Ca doit être indiqué dans le manuel de configuration de ton router.