Discussion :

[dreadjunk]

Salut,

Je suis en train de faire un client serveur en C sur windows. Le client envoie des données sur le serveur qui s'occupe des les écrires sur une BDD. Quand le serveur a récupérer toute les données il renvoit au client la longueur des données reçu pour vérifier qu'il n'y est pas d'erreur.

Au niveau de la reception des données sur le serveur et l'écriture sur la BDD aucun problème. J'ai rajouté récemment la fonction pour le serveur de renvoyé le nombre de caractère au client pour vérifier si il y a des erreurs et depuis le serveur et le client restent bloqués sur la fonction recv, comme si chacun attendais de recevoir un message ...

Est ce qu'il y a une procédure particulière a mettre en place quand on souhaite que son serveur puisse réceptionner des données et en envoyé? Comme déconnecté la connexion et la remettre en place ensuite?

Voici le code :

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
28
29
30
31
32
33
34
35
36
37
38
39
static int read_client(SOCKET sock, char *buffer)
{
    int n = 0;
    int compteur = 0;
 
    do
    {
        printf("test 5 \n");
        if((n = recv(sock, buffer, MAX_SIZE - 1, 0)) < 0) //problème ici, le serveur s'attends a recevoir quelque chose mais il reçoit rien !
        {
            printf("test 1 \n");
            n = 0;
            if(compteur == 0)
            {
                perror("recv()");
                exit(errno);
            }
        }
        compteur += n;
        buffer[n] = 0;
        printf("Longueur message : %i \n", n);
        printf("buffer : %s \n", buffer);
        if(n != 0)
        {
            query_mysql(buffer);
        }
        printf("test 4 \n");
    }
    while( n != 0);
 
    printf("test 2 \n");
    printf("longueur total message : %i \n", compteur);
    char str_compteur[16];
    sprintf(str_compteur, "%i", compteur);
    printf("str_compteur : %s \n", str_compteur);
    write_client(sock, str_compteur); //envoie le nombre de caractère du message reçu pour effectuer un test dessus
 
    return compteur;
}

Client :

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
static void read_and_send_file(SOCKET sock)
{
    FILE* fichier = NULL;
    char str[MAX_SIZE];
    int i = 0;
 
    fichier = fopen(PATH_TXT,"r");
    if(fichier != NULL)
    {
        while(fgets(str, MAX_SIZE, fichier) != NULL)
        {
            printf("nb boucle : %i \n", i);
            printf("str : %s \n", str);
            write_server(sock, str);
            i++;
        }
        fclose(fichier);
        char buffer[16];
        printf("test 1 \n");
        //recv_server(sock, buffer);
        printf("read_and_send_file buffer : %s \n", buffer);
    }
    else
    {
        perror("fopen");
    }
}

PS : le client stocke sur un fichier .txt les données avant de les envoyé.

Merci d'avance !

[Bousk]

Salut,

le serveur et le client restent bloqués sur la fonction recv, comme si chacun attendais de recevoir un message ...

Si c'est bloqué sur recv c'est exactement ce qu'il se passe oui.

Est ce qu'il y a une procédure particulière a mettre en place quand on souhaite que son serveur puisse réceptionner des données et en envoyé?

Il faut mettre en place une architecture du code cohérente. Si t'es bloqué sur recv c'est que tu ne devrais peut-être pas encore appeler recv ?

Comme déconnecté la connexion et la remettre en place ensuite?

Surtout pas, une connexion ça se maintient sinon.. ben t'es déconnecté.

Ton architecture du code est sûrement mauvaise. Le code client que tu montres ne montre pas grand chose. Ton code serveur n'a aucun send donc je vois pas bien où tu dis envoyer quelque chose ?
Tu peux aussi utiliser le mode non bloquant.
Et dans tous les cas, recv reçoit un maximum de données et rarement tout ce que tu attends : http://bousk.developpez.com/cours/re...-protocole/#LI

[Matt_Houston]

En TCP, renvoyer la quantité de données reçues est inutile : c'est déjà garanti par le protocole. Si tu cherches à doublement vérifier l'intégrité de ton message, joins-lui une clef de hachage (quelque chose de plus costaud qu'un CRC32, s'entend).

[dreadjunk]

Désolé Bousk j'ai oublié quelques bouts de programme, il est assez long ...

Matt_Houston, donc ca veut dire que a partir du moment ou les données sont envoyés en TCP on peut être sur qu'elles sont reçu ?
Je voulais mettre en place cette vérification pour pouvoir supprimer le fichier .txt qui contient toute les données après un envoie, mais si c'est le cas j'aurais juste a compter le nombre de fois ou l'envois s'effectue alors.

[Matt_Houston]

Le protocole te garantit que les paquets sont passés, oui, mais ne fait pas de vérification d'intégrité.

Tu as deux solutions pour mettre ça en place :

• l'implémenter a la mano dans la couche de ton application (bon courage) quitte à simplement calculer un hash ajouté en fin de message ;
• utiliser un protocole sécurisé (TLS) via une bibliothèque dédiée (GnuTLS, openssl..), qui t'apportera également le chiffrement et la résistance à la corruption volontaire (man-in-the-middle).

Si tu as ne serait-ce qu'une seule contrainte de sécurité pour ton application, seule la seconde solution est viable.

[dreadjunk]

Pas de problème de sécurité je vais alors essaye de vérifier un hash en fin de message ! Est ce qu'il existe des fonctions qui permettent de hasher des strings directement ou je dois créer moi même une table de hash?

Par contre, dans le cas ou la vérification est fausse, je vais devoir renvoyé un message a mon client pour lui demander de renvoyer le message, et donc j'en reviens a mon problème de base non?