Bonjour,
j'ai un programme client serveur de reservation de places de spectacles à terminer, et je suis bloqué.
 
En détail :
- Dans le cas d'une consultation, les clients envoient des requêtes de consultation du nombre de places restantes pour un spectacle (nom, date), et recoivent en retour nb_dispo du serveur de consultation.
- Dans le cas d'une réservation, les clients envoient des requêtes de réservation (nom, date, nb_place) et recoivent du serveur de réservation, un acquitement si cela est possible (nb_dispo >= nb_place).
 
Les contraintes :
1. Clients et Serveurs sont sur une même machine
2. Le processus père du serveur de réservation créé un fils dont le code exécutable recouvre celui du père. C'est donc un execl qui va faire le boulot.
3. Les infos des spectacle (sorte de BDD) sont stockées dans un segment de mémoire partagée.
 
j'ai donc choisit comme moyen de communication :
-entre les clients et les serveurs : les Files de Messages; une pour la consultation (clé 17) et une pour la réservation (clé 314).
-entre le père et son fils (serveur consultation et réservation): 1 tube anonyme.
 
j'en suis au serveur de consultation, quand le fils lance l'execl. Comment récupérer le résultat ??? (càd nb_dispo)
 
Voici ce que j'ai déjà fait :
 
Les structures des messages:
 
A_Consultation :
 
Requête :
 
struct requete_cons
{
long  letype ;      /* destinataire du message */
pid_t  mon_pid ;  /* N° PID de l’expéditeur */
char   nom[512] ; /* nom du spectacle */
char  date[8];; /* date du spectacle jjmmaaaa */
} ;
 
Réponse :
 
struct reponse_cons
{
long  letype ;
int   nb_dispo ; /* nombre de places disponibles */
} ;
 
B_Réservation :
 
Requête :
 
struct requete_resa {
long letype ;        /* destinataire du message */
pid_t mon_pid ;    /* N° PID de l’expéditeur */
char  nom[512] ;   /* nom du spectacle */
char date[8];         /* date du spectacle jjmmaaaa */
int  nb_places   /* nombre de places à réserver */
} ;
 
Réponse :
 
struct reponse_resa
{
long  letype ;
short etat ;  /* résultat de la réservation */
} ;
 
Les processus CLIENTS
 
a - le processus client Consultation :
 
Main ( )
{
Int msqid ;
Msqid = msgget (17,0)
Requete_cons.letype = 1 ;
Requete_cons.mon_pid = getpid ( ) ;
Msgsnd (msqid , requete_cons , ___ ) ;
Msgrcv (msqid , reponse_cons , getpid ( )  ) :
Exit ( )
}
 
b - le processus client Réservation :
 
Main ( )
{
Int msqid ;
Msqid = msgget (314,0)
Requete_resa.letype = 2 ;
Requete_resa.mon_pid = getpid ( ) ;
Msgsnd (msqid , requete_resa , ___ ) ;
Msgrcv (msqid , reponse_resa , getpid ( )  ) :
Exit ( )
}
 
Les processus SERVEUR:
 
c- le processus serveur Consultation:
 
# include …
# define CLE 17
Main ( )
{
Int msqid ;
int tube[2] ;
Pid_t retour ;
Msqid = msgget (17, IPC_CREAT | IPC_EXCL | 0660 )
Msgrcv (msqid , requete_cons , 1 , ___ ) ;
 
Pipe (tube) ;      /* ouverture du tube */
Retour = fork ( ) ;
 
If (retour == 0)
{                   /* LE FILS */
close ( tube [1] ) ;     /* pas d’écriture sur le tube */
read ( tube [0] , ………    /* lecture sur le tube */
execl (« /home/steph/applis/consult.exe », « consult.exe », ___ ) ;
msgsnd ( msqid , nb_dispo, ____ ) ;  /* envoi résultat de consult.exe */
close ( tube [0] ) ;     /* pas de lecture sur le tube */
exit ( ) ;
 
else
{        /* LE PÈRE */
close ( tube [0] ) ;     /* pas de lecture sur le tube */
write( tube [1], requete_cons, ???)  /* écriture  requete sur le tube */
close ( tube [1] ) ;
wait ( ) ;
}

Pas la peine de créer 2 topic
Et utilises les balises [cpp] on y verra plus clair

 
Quand un processus lance un "execl", il est automatiquement remplacé par le nouveau processus. Donc à partir de ton "execl", ton fils n'existe plus (c'est à dire que si tu écris du code après l'execl, ce code ne sera jamais exécuté).
 
Maintenant, tu te trouves avec deux programmes indépendants. Le père et le pgm lancé par l'execl. Si tu veux les faire communiquer, ben tu as le choix entre pipe, sockets, shm ou msq.

tu veux pas m'en expliquer un peu plus ? Tu sais, c'est la première fois que je fais de la programmation système...

C'est pas de la programmation système, c'est de l'application Unixoide...

Bon, ne sachant pas trop si c'est correct, je fais une hypothèse:
l'appli lancée par l'execl effectuer la réservation et renvoyer le résultat par msgsn(....), donc directement dans la file de message à destination du client. Ca peut se faire ?

Euh... je sais pas si tes primitives "msgsn" sont équivalents à celles que je connais (à savoir "msq" ). Mais si tes deux programmes ont moyen de travailler sur la même file de messages (par la même clef je pense) alors il n'y a aucun problème.
 
De toute façon il faut considérer que ton pgm lancé par "execl" et ton client sont deux programmes distincts. S'ils doivent communiquer ensemble il leur faut utiliser des outils standards de communication inter processus

Si je peux me permettre, c'est pas ce que j'appelle une appli client/serveur... C'est plutôt une appli multi-processus... Même pas multi-user apparement.

Bon les gars, on va pas s'étendre sur la philosophie du problème qu'on ma imposé. Il est clair qu'il est techniquement tordu, et pédagogiquement... mystère (j'aurai mon partiel avant que ce projet soit corrigé... fort, non ?). Ceci dit, il me faut finir. Dernière info, je ne dois pas détailler la mémoire partagée (pas vu en cours).
 
voilà ce que je propose pour mon exec, que j'ai appelé consult :
- Attachement à la mémoire partagée  
- Recherche des informations dans la mémoire partagée  
- construction de reponse_cons : pid_client, nom, date, nb_dispo
- Détachement de la mémoire partagée
- envoi du message dans la MSQ 17
 
Pour la réservation, prog resa.exe :
- Pose d'un sémaphore sur la mémoire partagée.  
- Attachement à la mémoire partagée  
- Recherche des informations dans la mémoire partagée  
- si nb_place >= nb_dispo, alors réserver_places
- nb_dispo = nb_dispo_nb_place
- construction de  reponse_resa : pid_client, etat = « OK »
- Dépose du sémaphore  
- Détachement de la mémoire partagée
- Envoi du message dans la MSQ 314
 
???

Mémoire partagée: Tu définis un pointeur de type "char *pt" puis tu fais "pt=shmat(...)". A partir de ce pointeur, tu as à ta disposition une zone de "n" octets (comme malloc) mais d'autres pgm y ont aussi accès par la même méthode => mémoire partagée. Ne pas oublier de faire "shmdt(pt)" dès que t'en as plus besoin.
http://fr.lang.free.fr/cours/IPC_Csyst_v1.0.pdf
 

 
A voir si le 1er pgm n'a pas besoin que le sémaphore soit libre...