Transfert de fichier

**Creuvard** · 17/10/2006, 20h52

Bonsoir

Voila je m'essaie au transfert de fichier via socket, Client/Serveur
Je débute en programmation, donc ne soyez pas trop dure

Plusieurs serveurs sont en fonction, et possède chacun plusieurs fichiers. Certains fichiers sont donc présents plusieurs fois sur l'emsemble du réseau.

Le client demande auX serveurs de lui envoyer une partie de fichier.

Exemple: Si le fichier est présent sur 2 serveurs différents il demande au premier de lui envoyer la première partie et au second la seconde partie.

Voici donc mes 2 problèmes:

1) Mon premier problèmes est la manière donc mon client copie le fichier sur le disque. Exemple avec le téléchargement de mon " /etc/fstab "

Code :

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

2) Mon second problème est que l'enregistrement du flux envoyé par le second serveur efface ce qui a été enregistré par le premier, au lieu de le mettre a la suite.

Morceau de code des serveurs responsable de l'envoye de 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
 
         int debut, fin;
         char buffer[512];
        if (( fichier_src = open (nom, O_RDONLY)) == -1)
        {
                perror("open() ");
                exit(EXIT_FAILURE);
        }
        /* On se place a l'endroit qui va bien dans le binaire */
        lseek(fichier_src, debut, SEEK_SET);
        current = debut; /* Détermination de la position courante dans la fichier */
        bzero(buffer, 512);
        nb_lu = read(fichier_src, buffer, 512);
        while (( ( nb_lu > 0)  && (nb_lu < fin - current ) ))//( current <= fin ))
        {
                printf("Current: %d\n", current);
                if( ( write(socket, buffer, strlen(buffer))) == -1)
                {
                        perror("write() ");
                }
                current = current + nb_lu;
                printf("CURRENT: %d\n", current);
                bzero(buffer, 512);
        }
        bzero(buffer, 512);
        printf("Il reste %d d'octets a envoyé\n", fin - current);
        read(fichier_src, buffer, fin - current);
        printf("Buf: %s\n", buffer);
        if( ( write(socket, buffer, strlen(buffer))) == -1)
        {
                perror("write() ");
        }
        close(fichier_src);

Morceau de code du client responsable du téléchargement de fichiers (dans un thread ) :

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
 
 
        int pos_depart, pos_fin;
        int fichier_dst;
        if (( fichier_dst = open (titre, O_CREAT | O_WRONLY, 0666)) == -1)
        {
                perror("open () ");
                exit(-1);
        }
        /* On se place a la fin ce qui mettra des 0 partout la ou */
        /* il y aura du vide                                                           */
        int fin;
        if ((pos_fin = lseek( fichier_dst, fin, SEEK_SET)) == -1)
        {
                perror("lseek() ");
                exit (1);
        }
        printf("On a mis a 0 jusqua le position: %d\n", pos_fin);
 
        /* On se met au debut du trou afin de remplacer les 0 */
        int debut;
        if ((pos_depart = lseek( fichier_dst, debut, SEEK_SET)) == -1)
        {
                perror("lseek() ");
                exit (1);
        }
        printf("On se met sur la position de depart: %d\n", pos_depart);
        char *END_GET="]";
        char *GET="[";
        char *get_recep[512];
        while ( read (socket_id, &get_recep, sizeof(char)) == 1 )
        {
                if (!strcmp(get_recep, GET))
                {
                        printf("Telechargement du data du serveur \"%s\"\n", serveur);
                }
                else
                if (!strcmp(get_recep, END_GET))
                {
                        printf("\t [ ok ]\n");
                        break;
                }
                else
                {
                        write(fichier_dst, get_recep, fin - debut);
                        fprintf(stdout, "%s", get_recep); // Ca ca marche
                }
 
        }
        //close(fichier_dst);
        shutdown(socket_id, 2);
        close (socket_id);

Le client utilise des threads, chaque thread se connecte à un serveur recoit le flux le met a sa place (normalement ) dans le fichier et se termine.

Voila si vous aviez une piste pour m'aider à me sortir duu pétrin j'en serais ravi

**Médinoc** · 18/10/2006, 10h53

Mais c'est une épidémie!
C'est au moins le troisième thread que je vois où des gens utilisent les fonctions de fichier POSIX au lieu de celles de stdio.h...

De plus, tu utilises read/write alors que le fichier est certainement ouvert en mode texte : Est-ce bien ce que tu voulais faire ?
PS: On ne sait pas comment est initialisé "debut", en fait il y a pas mal de choses qu'on ne sait pas...

**Creuvard** · 18/10/2006, 12h27

Salut

J'ai rajouter quelques trucs qui manquait (comme " debut" ......)

Mes fichiers sont ouvert avec la fonction open(), donc je pense pas que le fichier soit ouvert en mode texte ? si ?

Pour mon choix d'utiliser les fonctions open() et read() , c'est aprés avoir lue ce post , pour la fonction write() , elle est mentionnée dans le man de open() donc je l'ai utilisé sans trop me poser de questions.

Voila

**Médinoc** · 18/10/2006, 13h29

open() ouvre en mode texte si on ne spécifie pas O_BINARY.
Mais sous un OS unixoïde, il est vrai que ça change rarement grand-chose.
Et je persiste à dire qu'utiliser fopen() serait plus portable, tout comme utiliser send() et recv() sur les sockets.

**Creuvard** · 18/10/2006, 19h09

Ok je vais donc tenter de modifier tout ca avec les fonctions adéquates.

Par contre est-ce que ces fonctions vont régler mes problèmes ?

Pour ce qui est de l'utilisation de de lseek() pour faire mon fichier a trou ( je sais pas si on appel ca comme ca ) je suis tout de même obligé d'utiliser open() non ?

**Emmanuel Delahaye** · 18/10/2006, 20h20

Envoyé par Creuvard

Pour ce qui est de l'utilisation de de lseek() pour faire mon fichier a trou ( je sais pas si on appel ca comme ca ) je suis tout de même obligé d'utiliser open() non ?

Non : fseek() fonctionne avec les f-functions (fopen() etc.).

**Creuvard** · 18/10/2006, 20h35

Daccord mais lseek() ?

Je comprend pas trop ce que tu veux me dire

**Emmanuel Delahaye** · 18/10/2006, 20h37

Envoyé par Creuvard

Daccord mais lseek() ?

Je comprend pas trop ce que tu veux me dire

Si tu utilises les fonctions standards (fopen() etc.) tu peux utiliser fseek() à la place de lseek().

**Creuvard** · 21/10/2006, 19h38

Merci à vous pour ces conseils.
J'ai modifié les fonctioins non standart.

Morceau de code des serveurs responsable de l'envoye de 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
 
        int debut, fin;
        FILE *fichier_src;
        if (( fichier_src = fopen (nom, "rb")) == -1)
        {
                perror("fopen() ");
                exit(EXIT_FAILURE);
        }
 
        /* On se place a l'endroit qui va bien dans le binaire */
        fseek(fichier_src, debut, SEEK_SET);
        current = debut; /* Détermination de la position courante dans la fichier */
 
        bzero(buffer, BUFSIZE);
        nb_lu = fread( buffer, sizeof(char), BUFSIZE, fichier_src);
        int nb_send;
        int inc = 1;
        while (( ( nb_lu > 0)  && (nb_lu < fin - current ) ))
        {
                if( (nb_send = send(socket, buffer, nb_lu, 0)) == -1)
                {
 
                        perror("send() ");
                        exit(-1);
                }
                printf("nb_send(boucle) \'%d \' = %d\n", inc, nb_send);
                if (nb_send == -1 )
                        perror("send () ");
                current = current + nb_lu;
                bzero(buffer, BUFSIZE);
                inc ++;
                if (fin - current < BUFSIZE)
                {
                        break;
                }
                else
                        nb_lu = fread( buffer, sizeof(char), BUFSIZE, fichier_src);
        }
        bzero(buffer, BUFSIZE);
        fread( buffer, sizeof(char), fin - current, fichier_src);
        if( ( nb_send = send(socket, buffer, fin - current, 0)) == -1)
        {
                perror("write() ");
        }
        printf("nb_send = %d\n", nb_send);
        close(fichier_src);

Morceau de code du client responsable du téléchargement de fichiers (dans un thread ) :

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
 
/* Préparation de l'écriture sur le disque du fichier télécharger */
        FILE *fichier_dst;
        if (( fichier_dst = fopen (titre, "ab")) == -1)
        {
                perror("fopen() ");
                exit (-1);
        }
        int pos_depart, pos_fin;
        /* On se place a la fin ce qui mettra des 0 partout la ou */
        /* il y aura du vide                                      */
        if (pos_fin = fseek(fichier_dst, fin, SEEK_SET) == -1)
        {
                perror("fseek() ");
                exit(-1);
        }
        printf("On a mis a 0 jusqua le position: %d\n", pos_fin);
        /* On se met au debut du trou afin de remplacer les 0 */
        if (pos_depart = fseek(fichier_dst, debut, SEEK_SET) == -1)
        {
                perror("fseek() ");
                exit(-1);
        }
        printf("On se met a la position de depart: %d\n", pos_depart);
 
        /****************************************************/
        /* Envoie de la commande "/get " au serveur distant */
        /****************************************************/
        if ( send(socket_id, cmd, sizeof(cmd), 0) == -1)
        {
                perror("reception_liste> write()");
                exit(1);
        }
 
        /*******************************************/
        /* Écoute de la socket et annalyse de ce   */
        /* qu'envoie le serveur.                   */
        /*******************************************/
 
        int nb_recv = 0;
        char *get_recep[BUFSIZE];
        int nb_fcntl;
        while ( ( nb_recv = recv (socket_id, get_recep, sizeof(char), 0)) > 0)
        {        
                        fprintf(fichier_dst, "%s", get_recep);
        }
        fclose(fichier_dst);
        shutdown(socket_id, 2);
        close (socket_id);

Je suis maintenant confronté à un nouveau problème.
Le téléchargement de petit fichier marche parfaitement, (exemple mon fstab de 2038 Octets) signature sha1 faisant fois, mais une fois que je commence a avoir de plus gros fichiers (2.9 Mo pour mon fichier de test), il me manque une partie de fichier.

La chose qui me chiffone est que si je télécharge uniquement le première partie du fichier que ce soit sur le premier serveur (Gentoo/Linux) ou sur le second (OpenBSD) il me télécharge exactement le même nombre d'octets (signature sha1 faisant fois). Ors ce nombre d'octets ne correspont pas a ce que je lui demandé de télécharger. ( 2813445 au lieu de 2903164 )

Bref je ne sais pas trop ou regarder.

Si vous aviez une piste, ou une partie de code sur laquelle je pourrais me pencher.

**Médinoc** · 21/10/2006, 20h32

Tu utilises fprintf() au lieu de fwrite()...

**Creuvard** · 24/10/2006, 00h11

Merci

J'ai donc remplacé le fprintf() par du fwrite().

Code :

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

1
2
 
fwrite(&get_recep, sizeof(char), 1, fichier_dst);

Mon problème est que maintenant le fichier télécharger fait un octets de plus que le fichier original. (2903165 au lieu de 2903164)

Cela dit le fichier (un mp3 en l'ocurence) est maintenant lisible, ce qui n'était pas le cas avant.

**Médinoc** · 24/10/2006, 11h09

Essaie de trouver ou est l'octet en plus et ce qu'il vaut (il est sûrement au début ou à la fin).
Tu peux utiliser un programme de comparaison pour ça...

Une fois que tu auras localisé le problème, il sera plus facile de le corriger...

**Emmanuel Delahaye** · 24/10/2006, 11h17

Envoyé par Creuvard

Code :

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

1
2
 
fwrite(&get_recep, sizeof(char), 1, fichier_dst);

On dirait que tu fais des transferts octet par octet, ce n'est pas efficace. Pourquoi ne pas utiliser les blocs, c'est fait pour.

**Creuvard** · 24/10/2006, 12h56

@Médinoc: En effet cet octet se trouve a la fin du fichier, je pensais l'avoir mis

@Emmanuel Delahaye:

Envoyé par Emmanuel Delahaye

Pourquoi ne pas utiliser les blocs, c'est fait pour.

En effet je me demandais pourquoi la fonction "recv()" me renvoyait la valeur 1 à chaque fois, comme j'étais apriori prés du but j'ai pas cherché plus loins

J'ai donc changé quelques "trucs".

Coté 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
 
#define BUFSIZE 1024;
        int nb_lu;
        bzero(buffer, BUFSIZE);
        nb_lu = fread( buffer, sizeof(char), BUFSIZE, fichier_src);
        int nb_send;
        while (( ( nb_lu > 0)  && (nb_lu < fin - current ) ))
        {
                if( (nb_send = send(socket, buffer, nb_lu, 0)) == -1)
                {
                        perror("send() ");
                        exit(-1);
                }
                if (nb_send == -1 )
                        perror("send () ");
                current = current + nb_lu;
                bzero(buffer, BUFSIZE);
                if (fin - current < BUFSIZE)
                        break;
                else
                        nb_lu = fread( buffer, sizeof(char), BUFSIZE, fichier_src);
        }
        bzero(buffer, BUFSIZE);
        fread( buffer, sizeof(char), fin - current, fichier_src);
        if( ( nb_send = send(socket, buffer, fin - current, 0)) == -1)
                perror("write() ");
        close(fichier_src);

Coté Client:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#define BUFSIZE 1024;
        char *get_recep[BUFSIZE];
        while ( ( nb_recv = recv (socket_id, get_recep, BUFSIZE, 0)) != 0)
        {
                        fwrite(&get_recep, sizeof(char), strlen(get_recep), fichier_dst);
        }
        fclose(fichier_dst);
        shutdown(socket_id, 2);
        close (socket_id);

J'ai l'impression que tout est a peu pres correcte pour ce qui est du serveur, en revanche coté client je me perd un peu avec les fonctions "recv()" et "fwrite()".

Voici ce que je comprend, aprés lecture des man.
recv (socket_id, get_recep, BUFSIZE, 0) -> Je recoie de la socket "socket_id" un message de BUFSIZE octets que je met dans get_recep.

fwrite(&get_recep, sizeof(char), strlen(get_recep), fichier_dst) -> J'écrit dans fichier_dst le contenue du buffer get_recep les strlen(get_recep) octets recue par la fonction recv().

Bref c'est pas trés clair dans ma tête.

**Emmanuel Delahaye** · 24/10/2006, 13h09

Envoyé par Creuvard

Voici ce que je comprend, aprés lecture des man.
recv (socket_id, get_recep, BUFSIZE, 0) -> Je recoie de la socket "socket_id" un message de BUFSIZE octets que je met dans get_recep.

fwrite(&get_recep, sizeof(char), strlen(get_recep), fichier_dst) -> J'écrit dans fichier_dst le contenue du buffer get_recep les strlen(get_recep) octets recue par la fonction recv().

Bref c'est pas trés clair dans ma tête.

Tu n'as absolument pas le droit d'utiliser strlen() sur autre chose que des chaines de caractères valides (rien de tel dans un fichier binaire...).

La réception, c'est simple :

Code :

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

1
2
3
 
nb = recv(...)
fwrite (... nb ...);

tout simplement.

De même, à l'émission :

Code :

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

1
2
3
 
nb = fread(...)
send (... nb...)

**Creuvard** · 24/10/2006, 18h55

@Emmanuel Delahaye: Merci. Mon fichier fait mantenant le même nombre d'octet sur le serveur et sur chez le client.

Lorsque je fait un téléchargement d'un petit fichier (en l'ocurence mon fstab ) qui a une taille de 2038 Octets le téléchargement se passe bien et le fichier reste identique (vérifié avec sha1).

Ors quand je télécharge un gros fichier de 405307688 Octets le fichier téléchargé par le client a le même nombre d'octet, mais en revanche pas la même signature sha1. Le fichier (une vidéo) présent sur le client n'est lisible que durant la première minute (il en comporte 58).

Ce qui me parrait bizare c'est que sur LES serveurs je lis le fichier source par paquet de 512 Octets.
Dans le cas du fstab:

Le premier serveur doit envoyer la première partie, de "0 à 1019"
Le premier paquet est donc de 512 Octets, le second est quand à lui de 507

Le second serveur envoye la seconde partie, de "1019 à 2038"
idem pour la taille des paquets.

Dans le cas d'un fichier plus gros a part le nombre de paquets je vois pas trop ce qui change et ce qui fait que cela ne me donne pas le même fichiers.

Je pense que mon problème est que je travaille sur le même fichier depuis différent thread.

Edit: La solution que je viens de trouver est la suivante. Chaque partie de fichier téléchargée est indépendante, (ex: binaire1_part1, binaire1_part2...). Une fois les téléchargement fini je les concatène via une commande UNIX ( cat bianire1_part2 >> binaire1_part1 )) et la je retrouve la même signature sha1.

Ce que je pensais fair au début c'étais créer un espace que je remplirais au fure et à mesure du téléchargement (depuis différents threads) , comme une partition virtuel avec Xen ou vmware.

Y a t'il une solution simple pour implémenter ce genre de chose , ou est-ce mieux de concaténer les différentes parties? bien que trop conssomatrice d'espace a mon gout

Transfert de fichier

Réseau C

Discussions similaires

Partager

Partager