Envoi et réception de données

Version imprimable

25/01/2012, 15h00
lilo_r

Envoi et réception de données

Bonjour à tous,

Voila j'utilise les sockets pour communiquer entre 2applications (1application C et une autre C++).
J'ai un code serveur qui me permet d'envoyer une chaine de caractère de l'application 1 vers l'application 2 (fonction socket_envoie(char buffer))
Et j'ai un code client dans l'application 2, qui me permet de traiter et afficher cette chaine de caractère.(fonction socker_reception()), et ça marche bien.

Mais si j'ai besoin d'envoyer plusieurs chaine de caractère, c'est à dire utiliser plusieurs fois la fonction socket_envoie(char buffer),je dois avoir
autant de fois la fonction socket_reception() de l'autre coté, sinon ça marche pas(les résultats ne s'affichent pas).

Donc comment je pourrai faire pour pouvoir utiliser socket_envoie(char buffer) autant de fois que je veux (dans mon code C), mais avoir de l'autre coté(code C++) une seule fois socket_reception() dans une boucle par exemple (j'ai pensé à une boucle mais je ne sais pas quels paramètres lui passé (condition d'arrêt etc...)).

Donc si vous avez des idées pour m'aider svp n'hésiter pas.

Merci d'avance.
25/01/2012, 15h20
mala92

Ca me parait tellement simple (pour l'envoi) que j'ai dû louper quelque chose.

je suppose que dans socket_reception tu as un recv, donc la fonction est bloquante tant que tu ne reçois pas de données.

tu peux nous mettre ton code pour qu'on puisse voir comment tu as fait.

Bonjour mala92 et merci pour ta réponse,

Voila mon code serveur:

Code:

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
int Socket_envoie(char buffer[])
{
 
    WSADATA WSAData;
    int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
 
 
    SOCKET sock;
    SOCKADDR_IN sin;
    SOCKET csock;
    SOCKADDR_IN csin;
    socklen_t recsize = sizeof(csin);
    int sock_err;
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Si la socket est valide */
        if(sock != INVALID_SOCKET)
        {
            printf("La socket %d est maintenant ouverte en mode TCP/IP\n", sock);
 
            /* Configuration */
            sin.sin_addr.s_addr    = htonl(INADDR_ANY);   /* Adresse IP automatique */
            sin.sin_family         = AF_INET;             /* Protocole familial (IP) */
            sin.sin_port           = htons(1600);    
 
            sock_err = bind(sock, (SOCKADDR*)&sin, sizeof(sin));
 
            /* Si la socket fonctionne */
            if(sock_err != SOCKET_ERROR)
            {
                /* Démarrage du listage (mode server) */
                sock_err = listen(sock, 5);
                printf("Listage du port %d...\n", 1600);
 
                /* Si la socket fonctionne */
                if(sock_err != SOCKET_ERROR)
                {
                    /* Attente pendant laquelle le client se connecte */
                    printf("Patientez pendant que le client se connecte sur le port %d...\n", 1600);        
 
                    csock = accept(sock, (SOCKADDR*)&csin, &recsize);
                    printf("Un client se connecte avec la socket %d de %s:%d\n", csock, inet_ntoa(csin.sin_addr), htons(csin.sin_port));
 
 
			send(csock,buffer ,sizeof(buffer), 0);
			if(sock_err != SOCKET_ERROR)
			{
                        printf("Chaine envoyee : %s\n",buffer);
 
			}
                    else
                        printf("Erreur de transmission\n");
		}  
 
            /* Fermeture de la socket */
            printf("Fermeture de la socket...\n");
 
            printf("Fermeture du serveur terminee\n");
        }
		}
 
 
         closesocket(sock);
            WSACleanup();
 
 
 
    /* On attend que l'utilisateur tape sur une touche, puis on ferme */
    //getchar();
	} 
return EXIT_SUCCESS;
 
}

Et voila mon code client:

Code:

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
int Socket_reception()
{
 
        WSADATA WSAData;
        int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
        SOCKET sock;
        SOCKADDR_IN sin;
        char buffer[100];
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Configuration de la connexion */
        sin.sin_addr.s_addr = inet_addr("127.0.0.1");
        sin.sin_family = AF_INET;
        sin.sin_port = htons(1600);
        fd_set readfs;
        /* Si l'on a réussi à se connecter */
        if(connect(sock, (SOCKADDR*)&sin, sizeof(sin)) != SOCKET_ERROR)
        {
 
	if(recv(sock, (char *)&buffer, sizeof(buffer), 0) != SOCKET_ERROR){
 
                    printf("%s\n",buffer);
                   // CMD::command(decoupage[i], &CARD_LIST::card_list);
 
                }
 
 
			  }
 
        //}
       // }
        /* sinon, on affiche "Impossible de se connecter" */
        else
        {
            printf("Impossible de se connecter client \n");
        }
 
        /* On ferme la socket */
        closesocket(sock);
 
 
           WSACleanup();
 
    }
 
    /* On attend que l'utilisateur tape sur une touche, puis on ferme */
 //  getchar();
 
    return EXIT_SUCCESS;
}

Voila donc dans mon main coté serveur:
si je fait:

Code:

1
2
3
4
5
6
7
int main()
{
 
	Socket_envoie("hello world");
	Socket_envoie("bonjour à tous");
	return 0;
}

et coté client:

Code:

1
2
3
4
5
6
7
8
int main()
{
 
	Socket_reception();
	Socket_reception();
	return 0;
 
}

Si je fait ça je reçois les deux chaine de caractère.

Mais ce que je veux c'est d'appeler Socket_reception(), une fois dans une boucle par exemple et pas autant de fois que socket_envoie est appelé.
Comme ça je peux utiliser socket_envoie autant de fois que je veux sans me soucier de la réception des données.
Donc j'ai pensé à une boucle mais je ne sais pas quels paramètres lui passé (condition d'arrêt etc...).

Merci d'avance.

25/01/2012, 17h03
mala92

Ok !!
Bon, dans un 1er temps, il faut extraire la partie initialisation de la partie "production".

Sur le serveur dans la fonction d'envoi il ne devrait y avoir (quasi) que le send. Idem côté client.
27/01/2012, 16h09
Mat.M

Citation:

Envoyé par lilo_r

Comme ça je peux utiliser socket_envoie autant de fois que je veux sans me soucier de la réception des données.
Donc j'ai pensé à une boucle mais je ne sais pas quels paramètres lui passé (condition d'arrêt etc...).

Merci d'avance.

Programmer les sockets c'est un poil pointu.
Oui il faut utiliser une boucle infinie un while(); Il faut côté serveur créer un thread avec _beginthread ou CreateThread qui écoute le socket ouvert constamment ; si tu reçois des données alors tu lances un EVENT avec SetEvent par exemple.
CreateThread lancera une ThreadProc où tu placeras la fonction recv et appeler SetEvent au besoin.

Pour sortir de la boucle on peut le faire avec WaitForSingleObject qui signale qu'un Event a été mis à TRUE ou bien une bête variable globale
Je conseille de se procurer le livre de Charles Petzold

Citation:

Si je fait ça je reçois les deux chaine de caractère

en local oui ça fonctionne....si tu as des grosses latences réseau ( "lags") tu risques d'être totalement désynchro