Bonjour à tous,

Voici mon problème, je dois monter une architecture serveur client multi connexion (avec gestion de processus).

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
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include<unistd.h> 
#define SOCKET_ERROR -1
 
 
void traitementclient(int connfd)
{
                 time_t tempo;
                 char buff[50];
                 tempo=time(NULL);//releve le temps courant (en s)
                 snprintf(buff,sizeof(buff),"%.24s\n",ctime(&tempo));//convertit le temps en date
                 write(connfd,buff,sizeof(buff));
                 //sleep(7)
 
                 int n,sock_err;
                 while((n=read(connfd,buff,50))>0)
                 {
                         printf("Reception message serveur");
                         buff[n]='\0';
                         fputs(buff,stdout);
                         if(recv(connfd,buff,32,0)!= SOCKET_ERROR)
                                 printf("\nRecu:%s\n",buff);
                 }
 
 
 
 
 
}
 
main(int argc, char *argv[])
{
int listenfd,connfd,port,i;
socklen_t len;
struct sockaddr_in servaddr,cliaddr;
char adresseIP[16],buff[50];
time_t tempo;
 
// s'il n'y a pas 2 arguments sur la ligne de commande, on sort
 
if (argc!=2)
        {
        printf("Usage : serveur Port\n");
        exit(-1);
 
// creation de la socket TCP(SOCK_STREAM) sur IPv4(AF_INET)
// recuperation du descripteur de socket listenfd 
listenfd=socket(AF_INET,SOCK_STREAM,0);
 
// mise a zero de la structure servaddr
bzero(&servaddr,sizeof(servaddr));
 
// famille d'adresses : IPv4
servaddr.sin_family=AF_INET;
// adresse IP d'ecoute du serveur : INADDR_ANY (adresse wildcard)
// c'est-a-dire que le serveur ecoutera sur toutes ses interfaces
// on la range en ordre réseau avec htonl
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
// port d'ecoute du serveur : l'argument n°1
// on le convertit en entier avec atoi
// puis on le range en ordre reseau avec htons
servaddr.sin_port=htons(atoi(argv[1]));
 
// on lie la structure servaddr a la socket listenfd
// pour definir le port et l'adresse d'ecoute du serveur
if (bind(listenfd,(struct sockaddr *)& servaddr,sizeof(servaddr))<0)
        {
        perror("Erreur de bind");
        exit(-1);
        }
 
// on passe la socket en mode passif : elle devient capable d'attendre une connexion
listen(listenfd,10);
// boucle infinie du serveur
for(i=0;i<3;i++)
        {
        len=sizeof(cliaddr);
        // mise en attente de connexion
        // on recuperera dans cliaddr les coordonnees (adresse et port du client)
        // accept retourne un descripteur de socket connectée avec lequel on lire et ecrira dans la socket
        connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&len);
        // On recupere dans port le port de connexion du client
        // on le passe en ordre machine avec ntohs
        port=ntohs(cliaddr.sin_port);
        // on convertit l'adresse IP stockee en numerique dans cliaddr
        // en decimale pointee
        inet_ntop(AF_INET,&cliaddr.sin_addr,adresseIP,sizeof(adresseIP));
        // on affiche les coordonnees du client
        printf("connexion de %s, port %d\n",adresseIP,port);
 
 
 
////////Gestion processus////////
        pid_t n;
        printf("\nDebut processus\n");
        n=fork()
        printf("\n Le processus actuel est le n°%d, i=%d\n",getpid(),i); //père //fils
        if(n==0)
        {
                printf("\nJe suis le le fils :pid=%d, mon père est %d\n",getpid());
                i=10;
                printf("\nFils: pour moi, i=%d\n",i);
                printf("\n///////////////////////////////////////////////////////////\n");
                //Dans tempo le nombre de secondes ecoulees depuis le 01/01/1970
                tempo=time(NULL);
                //tranforme tempo en chaine de caracteres buff contenant date et l'heur
                snprintf(buff,sizeof(buff),"%.24s\n",ctime(&tempo));
                // on ecrit dans la socket la chaine buff
                write(connfd,buff,strlen(buff));
 
                close(listenfd);
                traitementclient(connfd);
                close(connfd);
                exit(0);
        }
        else if(n>0)
        {
                printf("Je suis le père : pid=%d, mon fils est %d\n",getpid(), n);
                printf("père : pour moi, i=%d\n",i);
        }
        else
        {
                printf("Erreur fork\n");
                exit(-1);
        }
 
 
        }
}

Le code 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
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
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
main(int argc, char **argv)
{
int sockfd,n,i;
char recu[50];
struct sockaddr_in servaddr;
 
if (argc!=3)
        {
        printf("Usage : client AdresseIP Port\n");
        exit(-1);
        }
 
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family=AF_INET;
servaddr.sin_port=htons(atoi(argv[2]));
inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
//transforme l'adresse IP X.X.X.X passée en parametre en adresse comprehensible
//par le systeme (32 bits)
 
for ( i = 0 ; i < 5 ; i++)
{
        if ( fork() == 0 )
        {
                if((sockfd=socket(AF_INET,SOCK_STREAM,0))!=0)
                {
                        char texte[32]="Hello world";
                        write(socket,texte,strlen(texte));      
 
                }
                if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
                {
                        printf("Erreur de socket\n");
                        exit(-1);
                }
 
                if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
                        printf("erreur de connexion");
 
                // le sleep n 
                sleep(5);
                while((n=read(sockfd,recu,50))>0)//quand le serveur clot la connexion, n=0
                {
                        recu[n]='\0';
                        fputs(recu,stdout);
                }
 
                char tempo[32]="Bonjour serveur";
                char buff[32];
                write(sockfd,tempo,strlen(tempo));      
                exit(0);
        }
}
}
Ma question est que le serveur écrit bien dans la socket d'envoyer la variable buff (le client la reçois bien) mais comment le client peu lui répondre ???
A l'aide d'un sendp ou lui ausi dois passer par le write.

Merci,