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