// Exécuté lorsqu'une transaction a fini son éxécution
void ReservationExpiree(int Sig)
{
if (kill(Borne, SIGNAL_RESERVATION_ANNULEE))
TraceErreur("Erreur lors de l'envoi du signal d'annulation");
else
TraceErreur("Transaction expirée");
exit(1);
}
int main() {
char pass[MAX_PASSWORD_SIZE];
int idSemOuverture, idShm, hdServerPid, notConnected, choix;
pid_t server_id;
do {
strcpy(pass, getpass("Mot de passe administrateur: "));
if(notConnected = strcmp(pass, ADMIN_PASSWORD)) {
Trace("Mauvais mot de passe.");
}
} while(notConnected);
Trace("\tRecuperation du semaphore 'Ouverture'");
if ((idSemOuverture = semget(SEM_OPEN_KEY, 1, 0)) == -1) {
TraceErreur("\tErreur de semget()");
Sortie(1, idShm);
}
// On sait que le PID est à jour dans le fichier, car l'admin ne se lance pas si le server n'est pas lancé.
// Et si le server est lancé, le pid dans le fichier est à jour.
Trace("\tRecuperation du pid du serveur");
if ((hdServerPid = open("data/Server.pid", O_RDONLY)) == -1) {
TraceErreur("\t(Serveur) Erreur d'ouverture du fichier data/Server.pid");
Sortie(1, idShm);
}
read(hdServerPid, &server_id, sizeof(pid_t));
close(hdServerPid);
Trace("\tCreation d'une memoire partagee");
if ((idShm = shmget(SHARED_MEM_KEY, sizeof(char) * SHARED_MEM_SIZE, IPC_CREAT | IPC_EXCL | 0600)) == 0) {
TraceErreur("Erreur de shmget(%d)", errno);
Sortie(1, idShm);
}
while(1) {
choix = menu();
switch(choix) {
case 0:
Sortie(0, idShm);
case 1:
fermer_bibli(idSemOuverture);
break;
case 2:
ouvrir_bibli(idSemOuverture);
break;
case 3:
broadcast(server_id, idShm);
break;
}
}
return 0;
}
void bookReturnedHandler(int sig) {
MESSAGELIVRE Msg;
if ((msgrcv(idQ, &Msg, sizeof(MESSAGELIVRE) - sizeof(long), getpid(), 0)) == -1) {
TraceErreur("(Main) Erreur de msgrcv()...");
exit(1);
}
Trace("(Main) %d livres recus...", Msg.Requete);
F1->BookAvailableNotification(Msg.L, Msg.Requete);
}
int main(int argc, char *argv[])
{
struct sigaction sigAction;
Trace("(Main) Debut de l'application (%ld)", getpid());
if ((idQ = msgget(IPC_KEY,0)) == -1) {
TraceErreur("(Main) Erreur de recuperation de la file");
exit(1);
}
sigAction.sa_handler = quitHandler;
sigemptyset(&sigAction.sa_mask);
sigAction.sa_flags = 0;
Trace("(Main) Armement de SIGINT (quitHandler)");
if(sigaction(SIGINT, &sigAction, NULL) == -1) {
TraceErreur("(Main) Erreur d'armement de SIGINT");
exit(1);
}
Trace("(Main) Armement de SIGQUIT (quitHandler)");
if(sigaction(SIGQUIT, &sigAction, NULL) == -1) {
TraceErreur("(Main) Erreur d'armement de SIGQUIT");
exit(1);
}
Trace("(Main) Armement de SIGUSR1 (notConnectedHandler)");
sigAction.sa_handler = notConnectedHandler;
if(sigaction(SIGUSR1, &sigAction, NULL) == -1) {
TraceErreur("(Main) Erreur d'armement de SIGUSR1");
exit(1);
}
Trace("(Main) Armement de SIGPWR (bookReturnedHandler)");
sigAction.sa_handler = bookReturnedHandler;
if(sigaction(SIGPWR, &sigAction, NULL) == -1) {
TraceErreur("(Main) Erreur d'armement de SIGPWR");
exit(1);
}
Trace("(Main) Armement de SIGUSR2 (broadcastHandler)");
sigAction.sa_handler = broadcastHandler;
if(sigaction(SIGUSR2, &sigAction, NULL) == -1) {
TraceErreur("(Main) Erreur d'armement de SIGUSR2");
exit(1);
}
Trace("(Main) Recuperation de la memoire partagee");
if ((idShm = shmget(SHARED_MEM_KEY, SHARED_MEM_SIZE, 0)) == 0) {
TraceErreur("Erreur de shmget()");
}
QApplication appl(argc,argv);
F1 = new FenetreSaisie();
F1->show();
return appl.exec();
}
pid_t GetPidServeur()
{
int file;
pid_t Pid;
Pid=getpid();
if((file = open("Serveur.pid",O_RDONLY)) == -1)
{
TraceErreur("(Serveur) Erreur ouverture Serveur.pid");
Sortie(1);
}
read(file,&Pid,sizeof(pid_t));
if(close(file))
{
TraceErreur("(Serveur) Erreur Fermeture Serveur.pid");
Sortie(1);
}
return(Pid);
}
// Déverrouille l'acces au fichier du nombre de places
void DeverrouillerPlaces(int file)
{
struct flock lock;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0; // Tout le fichier
if (fcntl(file, F_SETLK, &lock)) {
TraceErreur("Erreur lors de la suppression du verrou");
exit(1);
}
}
void BorneReservation::Annuler()
{
Trace("BorneReservation::Annuler()");
MESSAGE msg;
msg.dest = ProcessReservation;
msg.type = ANNULER;
msg.sender = getpid();
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0) {
TraceErreur("Erreur de msgsnd()...");
exit(1);
}
Trace("Annulation envoyée à %d", (int) ProcessReservation);
AfficherMenuPrincipal(0);
}
int main()
{
int idM=NULL;
pid_t PidServeur;
char Message[180], *pShm;
struct sembuf SemBuff[1];
PidServeur=GetPidServeur();
//Creation memoire partagée
if((idM = shmget(CLER,sizeof(Message),IPC_EXCL|IPC_CREAT|0600))==-1)
{
printf("Erreur de création de mem");
exit(1);
}
while(1)
{
switch(Menu())
{
case 1://FERMER BIBLIOTHEQUE
//initialisation du serveur
int idSem;
if((idSem = semget(CLES,0,0))==-1)
{
TraceErreur("Erreur initialisation semaphores");
Sortie(0);
}
SemBuff[0].sem_num=1;
SemBuff[0].sem_op=-1;
SemBuff[0].sem_flg=0;
if(semop(idSem,SemBuff,1))
{
TraceErreur("Erreur operation semaphores1");
Sortie(0);
}
printf("La Bibliothèque va se fermer\n");
SemBuff[0].sem_num=0;
SemBuff[0].sem_op=0;
SemBuff[0].sem_flg=0;
if(semop(idSem,SemBuff,1))
{
TraceErreur("Erreur operation semaphores2");
Sortie(0);
}
printf("La Bibliothèque est fermée\n");
if(idM!=NULL)
shmctl(idM,IPC_RMID,0);
kill(PidServeur,SIGINT);
//*******Fin Sem**********
break;
case 2://ENVOYER UN MESSAGE
printf("\t (Admin) dans Envoyer message\n");
if((pShm = (char*)shmat(idM,0,0)) == (char *)-1)//Attacher Mémoire partagée
printf("(Admin) Erreur shmat");
printf("Entrer le message que vous voulez envoyer:\n");
fflush(stdin);
gets(Message);
printf("\ngets: %s\n",Message);
strcpy(pShm,Message);
shmdt(pShm);//Détacher memoire partagée
kill(PidServeur,SIGUSR1);// Envoyer signal au serveur
break;
case 3:
if(idM!=NULL)//Effacer Memoire partagée si elle existe
{
shmctl(idM,IPC_RMID,0);
}
Sortie(0);
break;
}
}
}
void BorneReservation::Selectionner()
{
Trace("BorneReservation::Selectionner()");
char choixBuff[80];
char placesBuff[80];
int choix, nPlaces;
strcpy(choixBuff, lineChoix->text());
choix = atoi(choixBuff);
strcpy(placesBuff, lineNbPlaces->text());
nPlaces = atoi(placesBuff);
if (choix) {
MESSAGE msg;
msg.sender = getpid();
if (nPlaces <= 0) { // Consultation des événements disponibles d'un type
MENU menu = { choix, 0 };
// Annule une consultation en cours
if (ProcessReservation != 0)
this->Annuler();
// Demande la liste d'un type d'événement
msg.dest = SERVER_RECV;
msg.type = CONSULTER_EVENTS;
msg.data.menu = menu;
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0) {
TraceErreur("Erreur de msgsnd()...");
exit(1);
}
Trace("Message de listage des événements emis\n");
// Reçoit la liste des événements
if (msgrcv(IdQueue, &msg, MESSAGE_SIZE, getpid(), 0) == -1) {
TraceErreur("Erreur de msgrcv()...");
exit(1);
}
// Affiche la liste des événements
textMenu->clear();
ProcessReservation = msg.sender;
char buff[1000];
buff[0] = '\0';
Trace("Evénements reçus de %d", ProcessReservation);
for (int i = 0; i < MAX_EVENTS; i++) {
if (msg.data.events[i].nom[0] != '\0') {
char tempBuff[1000];
sprintf(tempBuff, "%2d - %-20s%s %-20s %3d\n",
i + 1, msg.data.events[i].nom, msg.data.events[i].date,
msg.data.events[i].localisation, msg.data.events[i].libre);
strcat(buff, tempBuff);
}
}
AffichageMenu(buff);
} else { // Réservation des places
Trace("Emission à %d", (int) ProcessReservation);
msg.dest = ProcessReservation;
msg.type = RESERVATION;
msg.data.menu.choix = choix;
msg.data.menu.nPlaces = nPlaces;
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0) {
TraceErreur("Erreur de msgsnd()...");
exit(1);
}
AffichageMenu("En attente de la réponse du serveur ...\n" // FIXME
"Cela peut prendre une vingtaine de secondes");
// Valide la réservation
if (msgrcv(IdQueue, &msg, MESSAGE_SIZE, getpid(), 0) == -1) {
TraceErreur("Erreur de msgrcv()...");
exit(1);
}
if (msg.type == OK)
AffichageMenu("Comfirmez la réservation, vous avez 20 secondes");
else if (msg.type == STOCK_INSUFFISANT) {
TraceErreur("Il n'y a plus assez de place pour l'événement");
AfficherMenuPrincipal(0);
}
}
}
}
int main(int argc,char *argv[])
{
int rc;
int idPid,hdFich;
MSCONCERT C;
DEMANDE D;
idPid = getpid();
idQ = atoi(argv[1]);
hdFich = atoi(argv[2]);
if ((rc = msgrcv(idQ,&C,sizeof(C) - sizeof(long),getpid(),0)) < 0)
{ TraceErreur("Erreur de Recieve()sur %d",idQ);
return 1;
}
Trace("MessageRecu");
if (lseek(hdFich, 0,0) == -1)
{ Trace("\t(Reservation) Erreur de lseek()");
return 1;
}
int i = 0;
while (read(hdFich,&C.Concert[i],sizeof(CONCERT)) > 0)
i++;
Trace("Nombre de concerts : %d",i);
Trace("Renvoie a %d",C.idProcess);
C.lType = C.idProcess;
C.idProcess = getpid();
if (msgsnd(idQ,&C,i * sizeof(CONCERT) + sizeof(pid_t) +sizeof(int),0) == -1)
{ TraceErreur("Erreur de Send() ...(%d)",C.lType);
return 1;
}
idPid = getpid();
D.lType = getpid();
D.idProcess = getpid();
Trace("attend");
if ((rc = msgrcv(idQ,&D,sizeof(D) - sizeof(long),getpid(),0)) < 0)
{ TraceErreur("Erreur de Recieve()sur %d",idQ);
return 1;
}
if (D.Request == ANNULER) exit(0);
Trace("recu message concert %d nbplaces %d",D.Message[0],D.Message[1]);
lseek(hdFich,(D.Message[0] - 1)* sizeof(CONCERT),SEEK_SET);
if(read(hdFich,&Element,sizeof(CONCERT)) < 0) exit(1);
// verifier si stock correcte
// ...
// Attend une confirmation
///...
int S1 = D.Message[0] - 1,S2 = D.Message[1];
if (D.Request == ANNULER) exit(0);
Trace("Nouveau stock avant%d",Element.Libre);
Element.Libre -= S2;
Trace("stock apres %d",Element.Libre);
lseek(hdFich,S1* sizeof(CONCERT),SEEK_SET);
write(hdFich,&Element,sizeof(CONCERT));
Trace("fin ");
exit(0);
}
int main(int argc, char *argv[])
{
MESSAGE msg;
// Récupération des informations de la ligne de commande
EVENT_TYPE eventType;
Borne = atoi(argv[1]);
strcpy(eventType.nom, argv[2]);
IdQueue = atoi(argv[3]);
// Remet à zéro les signaux
struct sigaction Action;
Action.sa_flags = 0;
sigemptyset(&Action.sa_mask);
// Initialise le signal d'alarme pour l'expiration de la reservation
Action.sa_handler = ReservationExpiree;
sigaction(SIGALRM, &Action, NULL);
// Charge la liste des événements
Trace("Lit les informations sur les %s", eventType.nom);
EVENT events[MAX_EVENTS];
char eventsDir[200];
strcpy(eventsDir, EVENTS_DIR);
strcat(eventsDir, "/");
strcat(eventsDir, eventType.nom);
strcat(eventsDir, "/");
ListerEvenements(events, eventsDir);
// Envoi de la liste des événements du type
Trace("Transmet la liste des événements");
msg.dest = Borne;
msg.sender = getpid();
msg.type = LISTE_EVENTS;
memcpy(msg.data.events, events, sizeof events);
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0) {
TraceErreur("Erreur de msgsnd() ...");
exit(1);
}
// Recoit l'événement à réserver
alarm(DELAI_RESERVATION); // Laisse 20 secondes à l'utilisateur
if (msgrcv(IdQueue, &msg, MESSAGE_SIZE, getpid(), 0) == -1) {
TraceErreur("Erreur de msgrcv()...");
exit(1);
}
alarm(0);
if (msg.type == ANNULER) {
TraceErreur("Réservation annulée");
exit(1);
}
Trace("Réserve %d places pour %s", msg.data.menu.nPlaces,
events[msg.data.menu.choix - 1].nom);
// Vérifie si le nombre de place est disponible,
// verrouille le fichier de places
char nomFichierPlaces[200];
strcpy(nomFichierPlaces, eventsDir);
strcat(nomFichierPlaces, events[msg.data.menu.choix - 1].nom);
strcat(nomFichierPlaces, "/places");
int fichierPlaces;
if ((fichierPlaces = open(nomFichierPlaces, O_RDWR)) == -1) {
TraceErreur("Erreur d'ouverture de fichier");
exit(1);
}
VerrouillerPlaces(fichierPlaces);
int placesDemandees = msg.data.menu.nPlaces;
int placesLibres = LireNbrePlaces(fichierPlaces);
msg.dest = Borne;
msg.sender = getpid();
if (placesDemandees > placesLibres) { // Stock insuffisant
msg.type = STOCK_INSUFFISANT;
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0)
TraceErreur("Erreur de msgsnd() ...");
TraceErreur("Réservation annulée : stock insufisant");
exit(1);
} else { // Demande de confirmation
msg.type = OK;
if (msgsnd(IdQueue, &msg, MESSAGE_SIZE, 0) != 0) {
TraceErreur("Erreur de msgsnd() ...");
exit(1);
}
Trace("Demande de confirmation de la réservation envoyée");
}
// Recoit la confirmation
alarm(DELAI_RESERVATION); // Laisse 20 secondes à l'utilisateur
if (msgrcv(IdQueue, &msg, MESSAGE_SIZE, getpid(), 0) == -1) {
TraceErreur("Erreur de msgrcv()...");
exit(1);
}
alarm(0);
if (msg.type == ANNULER) {
TraceErreur("Réservation annulée");
exit(1);
} else {
EcrireNbrePlaces(fichierPlaces, placesLibres - placesDemandees);
Trace("Réservation validée");
}
DeverrouillerPlaces(fichierPlaces);
close(fichierPlaces);
exit(0);
}