Discussion :

[nilslauwers]

Bonjour, je fais un transfert de fichier entre Debian(serveur) et Mac(client).
Les fichiers sont bien transférés sauf le dernier, le plus gros (6Ko), qui est coupé au milieu, à la réception le fichier ne fait plus que 3Ko.

J'ai fais le même test entre deux mac et je n'ai pas ce problème!

le script serveur sur Debian:

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
 
class ClientThread(threading.Thread):
    def __init__(self, ip, port, clientsocket):
    def envoi(self):
        print("envoi")
        print("Connection de %s %s" % (self.ip, self.port, ))
        maliste = ['iax.conf','meetme.conf','users.conf','extensions.conf']
        x = 0
        while 1:
            r = clientsocket.recv(2048)
            if r == b"":
                break
            fichier = open(r, 'r')
            shutil.copyfile(r, sousDossierLogs+'/'+ maliste[x])
            f = fichier.read(999999999)
            data = encrypt(f)
            self.clientsocket.send(data)
            fichier.close()
            x += 1
        print("Client déconnecté...")
        self.clientsocket.close()

et le script de réception (sur le Mac)

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
 
def telechargementFichier(host,port, dossier):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    flagServ = "EEEEEEEE"
    s.send(flagServ.encode())
    maliste = ['iax.conf','meetme.conf','users.conf','extensions.conf']
    x = 0
    while x < 4 :
        fileName = dossierS + '/' + maliste[x]
        s.send(fileName.encode())
        file = dossier + '/' + maliste[x]
        print(file)
        r = s.recv(999999999)
        print(r)
        d = decrypt(r)
        print(d)
        with open(file,'a') as _file:
            _file.write(d)
            _file.close()
        x += 1
    s.close()

Auriez-vous une piste pour régler ce problème?
Merci!

[nilslauwers]

De plus, l'erreur obtenue change:
parfois il n'indique pas d'erreur mais le dernier fichier reçu (le plus gros, 6Ko) ne fais que la moitié de sa taille originale donc 3Ko,
parfois aucune erreur n'est indiquée mais le dernier fichier n'est pas du tout reçu (mais pourtant bien envoyé) et
parfois une erreur est indiquée à la réception: (la fonction de déchiffrement indique que le message n'est pas un multiple de 16 et donc bogue)

ValueError: Input strings must be a multiple of 16 in length

[tyrtamos]

Bonjour,

Je suis loin d'avoir tout épluché, mais j'ai au moins 2 remarques:

- script serveur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    def __init__(self, ip, port, clientsocket):
    def envoi(self):

=> Pb d'indentation.

- script de réception

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
        with open(file,'a') as _file:
            _file.write(d)
            _file.close()

Avec with, il ne faut pas utiliser close: la sortie du bloc de code sous with le déclenche automatiquement. Cela veut dire qu'il est lancé ici 2 fois.

[nilslauwers]

Salut tyrtamos,
merci de ta réponse.

Pour le script serveur, l'indentation est normale car les deux fonctions se trouvent dans une classe et je n'ai pas collé ici le contenu de la fonction __init__ pour ne pas être trop long...
Et pour le client, j'ai bien supprimé le _file.close(), merci pour cette info.

Mais mon problème reste tjs le même...

[wiztricks]

Salut,

De toutes façons, vous faîtes l'hypothèse que les données d'un fichier expédiées en un seul .send pourront être reçues par un seul .recv. En fait la pile TCP/IP peut fragmenter les données en fonction de plusieurs paramètres et vous devez éventuellement les ré-assembler vous même (via faire plusieurs .recv).

Pour tester çà, expédiez seulement le contenu du gros fichier et regarder en combien de .recv la pile IP les aura transmis.

- W

[Laurent 1973]

Question: Est-ce que des deux coté, c'est le même Python (2 ou 3)?

Je sais que par défaut, sur mac osx c'est py2 mais je me demande si sous debian ce ne serait pas py3.

Or en py3, les chaînes sont codé en unicode par défaut alors qu'en py2 c'est en chaîne normale.
Et il me semble que la différence de ces 2 types de chaînes c'est justement un rapport x2 en octet.

A vérifier.

[nilslauwers]

Hello, Merci de vos réponses!

@Laurent 1973, ça ne peut pas être ça car j'utilise python 3.4 sur les deux machines..

@wiztricks, est-ce possible que la pile TCP/IP fragmente différemment selon l'OS (Debian, OS X etc.) ? Car de Mac à Mac le problème n'apparait pas.
Je vais essayer cela.

Merci à vous.

[wiztricks]

@wiztricks, est-ce possible que la pile TCP/IP fragmente différemment selon l'OS (Debian, OS X etc.) ? Car de Mac à Mac le problème n'apparait pas.
Je vais essayer cela.

Si vous expédiez 10 000 bytes via TCP/IP sur Ethernet, la chose sera découpée en paquets dont la valeur ne dépassera pas le MTU. Pour Ethernet (voir URL) c'est autour de 1500 bytes.

Lorsque le récepteur récupère çà, il a le choix entre retourner 1500 bytes ou attendre un peu pour voir s'il y a "plus" et vous donner n*1500bytes. Ce qui change entre les OS c'est les algo. utilisés pour savoir quand on se débarrasse de la patate chaude (les bytes reçus qui n'ont pas été remontés mais qu'on ne peut garder indéfiniment car ca coûte en mémoire système).

De Mac à Mac sur le même Mac, on ne passe pas par le câble réseau... et il sera plus simple de passer l’adresse du gros buffer sans avoir à recopier quoi que ce soit (mais çà c'est la tambouille de la stack IP).

- W

[nilslauwers]

wiztricks, C'est exactement ça ! Merci, merci et merci !!

Maintenant j'ai du mal à visualiser comment je peux envoyer et recevoir 4 fichiers, dont la taille peut varier (l'utilisateur peut y ajouter/supprimer des données).
Et le gros problème est que je dois les chiffrer en AES avec la librairie PyCrypto et donc les fichiers ou morceaux de fichiers doivent êtres multiple de 16.
je ne vois pas bien comment je peux y arriver !?

Je suppose que je dois découper les fichiers en morceaux de 1024 octets et envoyer chaque morceaux séparément et compléter le dernier morceau si il n'est pas multiple de 16.
J'ai déjà la fonction de remplissage et chiffrement et déchiffrement:

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
 
#configuration AES
key = "AAAAAAAAAAAAAAAA"
cipher = AES.new(key)
 
def pad (s):
    return s + ((16 - len(s.encode('utf-8')) % 16) * "!")
def encrypt(plaintext):
    global cipher
    return cipher.encrypt(pad(plaintext))
def decrypt(ciphertext):
    global cipher
    dec = cipher.decrypt(ciphertext).decode('utf-8')
    l = dec.count("!")
    return dec[:len(dec)-l]

mais pour envoyer les fichiers par tranche de 1024, je vois pas trop comment...
Pour l'instant je fais ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
            f = fichier.read()
            data = encrypt(f)
            self.clientsocket.send(data)

pourrais tu me donner une piste?
(je vois bien: f =fichier.read(1024) mais pour lire les 1024 octets suivants...?)

Encore Merci!

[nilslauwers]

J'ai un début, mais je bloque:

je transfère un fichier par bloc de 1024octets (pour l'instant sans le chiffrement).
Mais à la réception, je ne parviens pas à sortir de la boucle (de réception et écriture du fichier):

l'envoi sur le 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
 
class ClientThread(threading.Thread):
    def __init__(self, ip, port, clientsocket):
        threading.Thread.__init__(self)
        self.ip = ip
        self.port = port
        self.clientsocket = clientsocket
 
        nomfichier = '/etc/asterisk/extensions.conf'
        octets = os.path.getsize(nomfichier)
        fichier = open(nomfichier, 'rb')
        num = 0
        while 1:
            if octets > 1024:
                for i in range(int(octets/1024)): #???Ici, il n’accepte pas les floats donc j'ai transformé en int, mais cela ne crée-t-il pas un problème??? 
                    fichier.seek(num,0)
                    donnees = fichier.read(1024)
                    self.clientsocket.send(donnees)
                    num += 1024
            else:
                donnees = fichier.read()
                self.clientsocket.send(donnees)
 
        fichier.close()
        self.clientsocket.close()

La réception sur le client: (C'est ici que je ne parviens pas à sortir de la boucle, pourtant je dois bien recevoir des bytes vides à la fin du fichier, non?)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('192.168.1.3', 1111))
file = '/Users/macbookpro15/Desktop/extensions.conf'
while 1:
    recu = s.recv(1024)
    if recu == b"":
        break
    with open(file,'a') as _file:
        _file.write(recu)
s.close()

que puis-je utiliser pour sortir de la boucle quand toutes les données ont été reçues?

Merci !

PS: Dois-je ouvrir une autre discussion pour cette question?

[wiztricks]

Salut,

La réception sur le client: (C'est ici que je ne parviens pas à sortir de la boucle, pourtant je dois bien recevoir des bytes vides à la fin du fichier, non?)

La programmation réseau, c'est un peu peu compliqué que lire et écrire dans des fichiers en mode "bourrin".
Lorsque vous écrivez:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while 1:
    recu = s.recv(1024)
    if recu == b"":
        break

recu sera égal à b"" lorsque l'émetteur fera un close de la connexion.

Pour le reste soyez cohérent avec vos découvertes: si le réseau ne garantit pas que N bytes transmis seront reçus en une seule lecture, c'est sûr qu'une valeur de N "petite" (comparé à celui de départ) réduira la probabilité de.... mais çà ne garantira rien: c'est juste un flux (stream) de bytes
=> impossible de dire que le dernier block du fichier sera celui qui est < N.

La seule solution serait que le récepteur sache combien de bytes il devra lire.
Reste à décider en combien de bytes encoder cela, les transmettre, les décoder et utiliser cette information pour contrôler le nombre de bytes à lire avant de fermer le fichier et passer à autre chose.

- W

[nilslauwers]

Bonjour wiztricks,

je me rends bien compte que mes questions sont bêtes et que ma façon de programmer n'est certainement pas très propre.
J'ai très peux de temps pour terminer ce projet et d'autres choses à faire sur le côté, ce qui me stresse et me fais poser des questions sans avoir assez cherché et réfléchi.
Et pour ça, je vous remercie beaucoup de prendre de votre temps pour me répondre.

Donc si j'ai compris (pas sur), ça ne sert à rien d'envoyer par paquet de 1024octets puisque le MTU du réseau n'est pas connu.
Il faut juste que ma boucle de réception connaisse la taille du fichier qu'elle reçoit pour savoir quand elle a reçu tous les paquets correspondants.
Je peux connaître la taille de mon fichier comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

octets = os.path.getsize(nomfichier)

et envoyer "octets" au récepteur.
je vais essayer cela, mais je crois que j'aurais un problème avec l'encodage et le chiffrement car la taille aura changée une fois encodé et chiffré.
Merci beaucoup.

[nilslauwers]

Je me réponds:

il est bien possible d'envoyer un gros fichier en un seul .send et de le récupérer avec une boucle infinie (while 1).
Il faut pour cela envoyer la taille du fichier original et sortir de la boucle de réception quand la taille du fichier reçu est égale à la taille du fichier original.

Par contre cela ne fonctionne pas avec un chiffrement en AES car le réseau découpe le fichier en paquets (dont la taille dépend du MTU) et le déchiffrement de ces paquets nécessite qu'ils aient une taille multiple de 16, ce qui n'est pas le cas.
Je n'ai pas encore la solution pour ce cas!

[wiztricks]

Salut,

Donc si j'ai compris (pas sur), ça ne sert à rien d'envoyer par paquet de 1024octets puisque le MTU du réseau n'est pas connu.
Il faut juste que ma boucle de réception connaisse la taille du fichier qu'elle reçoit pour savoir quand elle a reçu tous les paquets correspondants.

Relisez ce que j'ai écris: je ne parle pas de la taille du fichier mais du nombre de bytes que le récepteur doit lire avant de sortir de la boucle de lecture pour faire autre chose. Et si vous pouvez expédier vos données par blocs de 1024 bytes, côté récepteur, vous ne pouvez essayer de lire 1024 bytes mais si vous n'en recevez que 123, çà ne veut pas dire que le transfert est terminé (sauf si le nombre de bytes reçus correspond à celui "attendu").

je vais essayer cela, mais je crois que j'aurais un problème avec l'encodage et le chiffrement car la taille aura changée une fois encodé et chiffré.

Comme vous transmettez le nombre de bytes à récupérer dans la boucle de lecture, il faudra passer la taille du machin encodé et chiffré.
La seule difficulté là dedans c'est de définir comment transférer/récupérer la taille et s'en servir pour paramétrer la sortie de la boucle de lecture.

Pour pas vous em... vous pouvez expédier str(nbytes) + '\n' avant de balancer les données.
Côté récepteur, vous lisez caractère par caractère jusqu'à rencontrer le '\n'.
Vous appliquez "int" à la chaîne de caractères lue, et voilà les nbytes à lire.

- W

[nilslauwers]

Bonjour wiztricks,

je vois comment obtenir la taille du fichier avec os.path.getsize(fichier) mais je ne vois pas comment obtenir sa taille une fois encodé, et récupérer exactement ce nombre d'octets avant de passer au fichier suivant.

je transfère quatre fichiers et à chaque fois leur taille juste avant(sur 16octets comblés avec des "A"). A la réception je récupère les données et les écris dans le fichier jusqu'à ce que la taille du nouveau fichier égale celle de l'original, mais ça ne fonctionne pas car il dépasse la taille du fichier avant de sortir de la boucle d'écriture et donc il écrit la taille et le début du fichier suivant dans le premier..

J'ai compris que ça n'est pas comme ça que je dois faire mais je ne vois pas comment je peux arrêter la réception après x octets, et passer à la réception du fichier suivant.

Pourriez-vous m'indiquer la méthode que je dois utiliser?
Merci.

Réception:

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
 
    file = dossier + '/extensions.conf'
    taille = s.recv(16)
    taille = taille.decode()
    print(taille)
    a = taille.count("A")
    taille = int(taille[:len(taille) - a])
    print(taille)
    while 1:
        recu = s.recv(taille)
        with open(file,'ab') as _file:
            _file.write(recu)
        octets = os.path.getsize(file)
        print(octets)
        if octets == taille or octets > taille:
            print("break")
            break
 
    file = dossier + '/users.conf'
    taille = s.recv(16)
    taille = taille.decode()
    print(taille)
    a = taille.count("A")
    taille = int(taille[:len(taille) - a])
    print(taille)
    while 1:
        recu = s.recv(taille)
        with open(file,'ab') as _file:
            _file.write(recu)
        octets = os.path.getsize(file)
        print(octets)
        if octets == taille or octets > taille:
            print("break")
            break
 
    file = dossier + '/meetme.conf'
etc........

[nilslauwers]

Encore une question bête,

Pour la réception des fichiers, il suffit de lire les données reçues avec .recv(1) dans la boucle et d'écrire chaque byte dans le fichier , il est alors possible de sortir de cette boucle de réception quand la taille du nouveau fichier écrit égale celle du fichier original, simple quoi!
Dormir ça aide à voir plus clair..

[wiztricks]

Salut,

Lorsque vous écrivez:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
            f = fichier.read()
            data = encrypt(f)
            self.clientsocket.send(data)

La taille des données encryptées que vous allez transmettre sera len(data) et non la taille du fichier.

Pourriez-vous m'indiquer la méthode que je dois utiliser?

Il n'y a pas de méthode. Il faut apprendre à penser le problème avec des concepts de protocole, (architecture en) couches, interfaces,... et être suffisamment à l'aise côté "programmation" pour traduire çà en code (éventuellement en Python).

Lorsque vous écrivez:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
while 1:
        recu = s.recv(taille)
        with open(file,'ab') as _file:
            _file.write(recu)
        octets = os.path.getsize(file)
        print(octets)
        if octets == taille or octets > taille:
            print("break")
            break

vous pensez toujours "je reçois toutes les données et je les écris dans la foulée".

Vu ce que vous avons raconté, çà serait plutôt un truc du genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
bytes_read = 0
while bytes_read < expected:
       remaining = expected - bytes_read
       bufsiz = 1024 if remaining > 1024 else remaining
       data = s.recv(bufsiz)
       f.write(data)
       bytes_read += len(data)

Ca fonctionne mais ce n'est pas adapté à la programmation réseau: en cas de fermeture de la communication pour une raison x ou y, vous n'aurez écrit que le début du fichier.

- W

[nilslauwers]

Merci pour vos éclaircissements !

Il me reste un jour pour terminer ce travail, et je reprends ensuite les bases de la programmation python..

[wiztricks]

Salut,

Il me reste un jour pour terminer ce travail, et je reprends ensuite les bases de la programmation python..

Le seul intérêt de votre travail est de vous obliger à apprendre et à tester vos limites.
Pour transférer des fichiers de façon sécurisée, on utilisera plutôt des utilitaires éprouvés comme "sftp".
S'il faut "automatiser" les transferts, on peut se contenter de scripter avec "bash".
Avec Python, il faut installer la bibliothèque paramiko.
Dans tous les cas, on évite de coder les couches de bas niveau soi-même (sauf pour apprendre).

- W