Communication programmes C

Bonjour à tous,

Voila j'utilise les sockets pour communiquer entre deux programmes, j'ai un programme serveur(il envoie les données )et un programme Client(il reçoit les données). La transmission des données marche bien.
J'ai voulu faire la même chose mais dans le sens contraire, modifier les données reçues par le client et les renvoyer au serveur, mais la par contre ça ne marche pas, et je suis un peu perdu, si quelqu'un peut m'aider svp.

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
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
 
int main(void)
{
        struct Etudiant
	{
		char nom[256];
		char prenom[256];
		int age;
	};
	typedef struct Etudiant Etudiant;
	Etudiant etudiant;
        WSADATA WSAData;
        int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
 
    /* Socket et contexte d'adressage du serveur */
        SOCKADDR_IN sin;
        SOCKET sock;
        socklen_t recsize = sizeof(sin);
        struct fd_set ensemble;
	struct timeval t;
    /* Socket et contexte d'adressage du client */
        SOCKADDR_IN csin;
        SOCKET csock;
        socklen_t crecsize = sizeof(csin);
        char buffer[32] = "hello serveur";
        int sock_err;
    /*******select***/
	int valret;
	int lenret;	
	t.tv_sec = 1;
	t.tv_usec = 0;
	FD_ZERO(&ensemble);
	FD_SET(sock,&ensemble);
 
	/******select******/
 
    if(!erreur)
    {
        /* Création d'une socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Si la socket est valide */
       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(23);         /* Listage du port */
            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", 23);
 
                /* 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", 23);        
 
                    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));
		    sprintf(etudiant.nom, "toto");
		    sprintf(etudiant.prenom, "titi");
		    etudiant.age = 26;
                    sock_err = send(csock, &etudiant, sizeof(etudiant), 0);
 
                    if(sock_err != SOCKET_ERROR)
                        printf("Chaine bien envoyée : %s\n",buffer);
                    else
                        printf("Erreur de transmission\n");
 
 
                    shutdown(csock, 2);
                }
 
			/************************Client---->Serveur*************************/
 
		valret = select(sock+1, &ensemble, 0, 0, &t);
 
		if(FD_ISSET(sock,&ensemble)!=0) // des données sont recues
		{
			lenret= recv(sock,&etudiant,sizeof(etudiant),0);
			 printf("Recu Serveur : %s\n",etudiant.nom);
		}
            }
 
            /* Fermeture de la socket */
            printf("Fermeture de la socket...\n");
            closesocket(sock);
            printf("Fermeture du serveur terminee\n");
        }
 
 
    }
     getchar();
 
    return EXIT_SUCCESS;
}
}

Et voila le 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
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
 
int main(void)
{
 
	struct Etudiant
	{
		char nom[256];
		char prenom[256];
		int age;
	};
	typedef struct Etudiant Etudiant;
	Etudiant etudiant;
 
        char buffer[32] = "hello serveur";
        SOCKADDR_IN csin;
        WSADATA WSAData;
        int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
        SOCKET sock;
	SOCKET sock2;
        SOCKADDR_IN sin;
	SOCKET csock;
	int sock_err =0;
	socklen_t recsize = sizeof(sin);
 
 
 
	if(!erreur)
		{
 
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
	sock2 = 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(23);
 
        /* Si l'on a réussi à se connecter */
        if(connect(sock, (SOCKADDR*)&sin, sizeof(sin)) != SOCKET_ERROR)
        {
            printf("Connection à %s sur le port %d\n", inet_ntoa(sin.sin_addr),  htons(sin.sin_port));
 
            /* Si l'on reçoit des informations : on les affiche à l'écran */
	if(recv(sock, &etudiant, sizeof(etudiant), 0) != SOCKET_ERROR)
          {
                printf("Recu client age: %d\n", etudiant.age);
		printf("Recu client nom: %s\n", etudiant.nom);
		printf("Recu client prenom: %s\n", etudiant.prenom);
 
           }
	}
        /* sinon, on affiche "Impossible de se connecter" */
        else
        {
            printf("Impossible de se connecter\n");
        }
	}
 
		/************************Client--->Serveur**********************/
 
 
		if(sock_err != SOCKET_ERROR)
		{
		sock_err = bind(sock, (SOCKADDR*)&sin, sizeof(sin));
		sock_err = send(sock, &etudiant, sizeof(etudiant), 0);
 
		 if(sock_err != SOCKET_ERROR)
            {
                /* Démarrage du listage (mode server) */
                sock_err = listen(sock, 5);
 
                printf("*****Client->Serveur*****Listage du port %d...\n", 23);
 
                /* Si la socket fonctionne */
                if(sock_err != SOCKET_ERROR)
                {
                    /* Attente pendant laquelle le client se connecte */
                    printf("*****Client->Serveur*****Patientez pendant que le client se connecte sur le port %d...\n", 23);        
		   csock = accept(sock, (SOCKADDR*)&csin, &recsize);
		   sprintf(etudiant.nom, "lilo");
		   sprintf(etudiant.prenom, "lili");
		   etudiant.age = 28;
                   sock_err = send(sock, &etudiant, sizeof(etudiant), 0);
		   if(sock_err != SOCKET_ERROR)
                        printf("Chaine bien envoyée : %s\n");
                    else
                        printf("Erreur de transmission\n");
 
                    shutdown(sock, 2);
                }
 
		 }
 
        /* On ferme la socket */
 
 	closesocket(sock);
    }
 
 
    getchar();
 
    return EXIT_SUCCESS;
}

Citation:

Envoyé par filoo85

ça ne marche pas

Mais encore ?

En fait j'arrive à envoyer les données Serveur->Client, donc dans la console Client j'ai bien etudiant.prénon= titi, etudiant.nom = toto etudiant.age = 26.
Mais par contre je n'arrive pas à envoyer les dennées Client->Serveur, il n'y a rien qui s'affiche.

quelqu'un pour m'aider svp :(

Est-ce que la ligne

Code:

printf("Recu Serveur : %s\n",etudiant.nom);

affiche quelque chose ? Ton timeout est de 1 seconde, c'est court, non?

Pourquoi utilises-tu 2 sockets (sock et csock) dans la 1ere moitié et un seul dans la 2nd ? Pourquoi faire un shutown sur csock alors que c'est le port d'échange ?

Remarque : tu as deux test if(!erreur) imbriqués. Je ne vois pas de modification de la variable erreur entre les 2 tests. Normal ?