Discussion :

[Creuvard]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#
 
/
e
t
c
/
f
s
t
a
b

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]

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]

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]

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]

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]

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.).