Problème avec l'envoi de fichiers

**0v3rb1t** · 16/06/2007, 21h01

Bonjour.

Mon problème est que lorsque j'envoie un fichier par sockets, la taille de celui ci est pour le client très légèrement supérieure (quelques octets), le client ne sort également pas de la boucle de réception.

J'aimerai bien connaitre la cause de tous ces désagréments et je remercie tous ce qui voudront bien m'aider.

Voici mon code:

SERVEUR

main.c

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
 
#include <stdlib.h>
#include <stdio.h>
#include <winsock2.h>
#include "serveur.h"
 
 
int main(void)
{
    int err, ret;
    WSADATA wsa_data;
 
 
    err = WSAStartup(MAKEWORD(2,2), &wsa_data);
 
    if(!err)
    {
        err = serveur();
        WSACleanup();
    }
 
 
    if(err)
    {
        ret = EXIT_FAILURE;
    }
 
    else
    {
        ret = EXIT_SUCCESS;
    }
 
 
    return ret;
}

serveur.c

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
 
#include <stdio.h>
#include <winsock2.h>
#include "serveur.h"
#include "send_file.h"
#define FTP 21
 
 
int serveur(void)
{
    int err = 0;
    SOCKET serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if(serv_sock != INVALID_SOCKET)
    {
        int sock_err;
        SOCKADDR_IN sin;
 
        sin.sin_addr.s_addr = htonl(INADDR_ANY);
        sin.sin_family = AF_INET;
        sin.sin_port = htons(FTP);
 
        sock_err = bind(serv_sock, (SOCKADDR *)&sin, (int)sizeof(sin));
 
        if(sock_err != SOCKET_ERROR)
        {
            sock_err = listen(serv_sock, 1);
 
            if(sock_err != SOCKET_ERROR)
            {
                SOCKADDR_IN csin;
                SOCKET client_sock;
                int struct_size = (int)sizeof(csin);
 
                client_sock = accept(serv_sock, (SOCKADDR *)&csin, &struct_size);
 
                if(client_sock != INVALID_SOCKET)
                {
                    err = send_file(client_sock);
 
                    shutdown(client_sock, SD_BOTH);
                    closesocket(client_sock);
                    client_sock = INVALID_SOCKET;
                }
 
                else
                {
                    err = 1;
                }
            }
 
            else
            {
                err = 1;
            }
        }
 
        else
        {
            err = 1;
        }
 
        shutdown(serv_sock, SD_BOTH);
        closesocket(serv_sock);
        serv_sock = INVALID_SOCKET;
    }
 
    else
    {
        err = 1;
    }
 
     return err;
}

send_file.c

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
 
#include <stdio.h>
#include <string.h>
#include <winsock2.h>
#include "send_file.h"
#define BUF_SIZE 256
 
 
int send_file(SOCKET client_sock)
{
    int err = 0;
    FILE *pfile = NULL;
 
 
    pfile = fopen("C:\\tetris.jpg", "rb");
 
    if(pfile != NULL)
    {
        int sock_err;
        long file_size;
        char s_file_size[sizeof(long)+1] = "";
 
        fseek(pfile, 0, SEEK_END);
        file_size = ftell(pfile);
        rewind(pfile);
        sprintf(s_file_size, "%ld", file_size);
        s_file_size[sizeof(long)+1] = '\n';
 
        sock_err = send(client_sock, s_file_size, (int)strlen(s_file_size), 0);
 
        if(sock_err != SOCKET_ERROR)
        {
            size_t data_lenght;
            unsigned char data[BUF_SIZE] = "";
 
            while((data_lenght = fread(data, 1, BUF_SIZE, pfile)) != 0)
            {
                sock_err = send(client_sock, data, (int)data_lenght, 0);
 
                if(sock_err == SOCKET_ERROR)
                {
                    err = 1;
                    break;
                }
            }
            fclose(pfile);
        }
 
        else
        {
            err = 1;
        }
    }
 
    else
    {
        err = 1;
    }
 
    return err;
}

serveur.h

Code :

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

1
2
3
4
5
6
7
 
#ifndef SERVEUR
#define SERVEUR
 
int serveur(void);
 
#endif

send_file.h

Code :

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

1
2
3
4
5
6
7
 
#ifndef SEND_FILE
#define SEND_FILE
 
int send_file(SOCKET client_sock);
 
#endif

CLIENT

main.c

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
 
#include <stdlib.h>
#include <stdio.h>
#include <winsock2.h>
#include "client.h"
 
 
int main(void)
{
    int err, ret;
    WSADATA wsa_data;
 
 
    err = WSAStartup(MAKEWORD(2,2), &wsa_data);
 
    if(!err)
    {
        err = client();
        WSACleanup();
    }
 
 
    if(err)
    {
        ret = EXIT_FAILURE;
    }
 
    else
    {
        ret = EXIT_SUCCESS;
    }
 
 
    return ret;
}

client.c

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
 
#include <stdio.h>
#include <winsock2.h>
#include "client.h"
#include "clean.h"
#define FTP 21
#define BUF_SIZE 256
 
int client(void)
{
    int err = 0;
    SOCKET client_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if(client_sock != INVALID_SOCKET)
    {
        int sock_err;
        SOCKADDR_IN csin;
 
        csin.sin_addr.s_addr = htonl(INADDR_ANY);
        csin.sin_family = AF_INET;
        csin.sin_port = htons(FTP);
 
        sock_err = bind(client_sock, (SOCKADDR *)&csin, (int)sizeof(csin));
 
        if(sock_err != SOCKET_ERROR)
        {
            char IP_serveur[17] = "";
            SOCKADDR_IN sin;
 
            fgets(IP_serveur, sizeof(IP_serveur), stdin);
            clean(IP_serveur);
 
            sin.sin_addr.s_addr = inet_addr(IP_serveur);
            sin.sin_family = AF_INET;
            sin.sin_port = htons(FTP);
 
            sock_err = connect(client_sock, (SOCKADDR *)&sin, (int)sizeof(sin));
 
            if(sock_err != SOCKET_ERROR)
            {
                char s_file_size[9] = "";
 
                sock_err = recv(client_sock, s_file_size, (int)strlen(s_file_size), 0);
 
                if(sock_err != SOCKET_ERROR)
                {
                    long file_size;
                    FILE *p_file = NULL;
 
                    clean(s_file_size);
                    sscanf(s_file_size, "%ld", &file_size);
 
                    p_file = fopen("C:\\tetris_bis.jpg", "wb+");
 
                    if(p_file != NULL)
                    {
                        unsigned char data[BUF_SIZE] = "";
 
                        while(file_size > 0)
                        {
                            sock_err = recv(client_sock, data, (int)sizeof(data), 0);
 
                            if(sock_err == SOCKET_ERROR)
                            {
                                err = 1;
                                break;
                            }
 
                            fwrite(data, 1, (size_t)sock_err, p_file);
 
                            file_size -= sock_err;
                        }
 
                        fclose(p_file);
                    }
 
                    else
                    {
                        err = 1;
                    }
                }
 
                else
                {
                    err = 1;
                }
            }
 
            else
            {
                err = 1;
            }
        }
 
        else
        {
            err = 1;
        }
 
        shutdown(client_sock, SD_BOTH);
        closesocket(client_sock);
        client_sock = INVALID_SOCKET;
    }
 
    else
    {
        err = 1;
    }
 
    return err;
}

clean.c

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
 
#include <stdio.h>
#include <string.h>
#include "clean.h"
 
void clean(char string[])
{
    char *p_string = NULL;
 
    p_string = strchr(string, '\n');
 
    if(p_string)
    {
        *p_string = '\0';
    }
 
    else
    {
        int c;
        while((c = getchar()) != '\n' && c != EOF);
    }
}

client.h

Code :

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

1
2
3
4
5
6
7
 
#ifndef CLIENT
#define CLIENT
 
int client(void);
 
#endif

clean.h

Code :

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

1
2
3
4
5
6
7
 
#ifndef CLEAN
#define CLEAN
 
void clean(char string[]);
 
#endif

**PRomu@ld** · 18/06/2007, 10h12

la taille de celui ci est pour le client très légèrement supérieure (quelques octets

Je n'ai pas eu le courage de regarder ton code mais, il faut savoir que ce problème n'est pas forcément lié à ton programme. En fait, ça peut provenir du système de fichier cible. En effet, ce dernier arrondi la taille des fichiers de façon à ce qu'ils reposent sur un nombre entier de cluster. Un fichier de 1 octet va par exemple être stocker sur 4 octets. Ca ne vient peut-être pas de ça mais il faut l'avoir en tête.

**0v3rb1t** · 18/06/2007, 15h35

Le problème c'est que le fichier est corrompu.

**diogene** · 19/06/2007, 13h18

Code :

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

1
2
3
4
       char s_file_size[sizeof(long)+1] = "";
....
        sprintf(s_file_size, "%ld", file_size);
        s_file_size[sizeof(long)+1] = '\n';

- Il n'y a pas de rapport entre sizeof(long) de la définition de s_file_size et le nombre de caractères générés par le sprintf dans s_file_size -> débordement possible du buffer.
- Ecriture du '\n' en dehors du tableau s_file_size ->débordement certain du buffer

**0v3rb1t** · 19/06/2007, 19h19

Je suis vraiment c** pour faire ça!
En tout cas merci.

Problème avec l'envoi de fichiers

Réseau C

Discussions similaires

Partager

Partager