/*
 * Programme de simulation de "Pirates"
 * "Pirates" pose un problème de type Lecteur/rédacteur avec un besoin de
 * priorités égales entre le rédacteur et les lecteurs, Barbe-Noire étant
 * le rédacteur, ses lieutenants étant des lecteurs.
 */

#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>


/*
 * Définition des clés pour les ipc (de maniere à toujours prendre les memes
 * et s'eviter des ipcrm pendant la phase de test)
 */

/* Pour la mémoire partagée */
#define SHMKEY1 31

/* Pour les sémaphores, prendre 40, 41, ... */
#define SEMKEY1 41
#define SEMKEY2 42
#define SEMKEY3 43

/*
 * Definition des pirates
 */

typedef struct {
  char nom[32];/* Nom du pirate */
  int nbFois;  /* Nb fois que le pirate a son comportement */
  int ta;      /* Valeur du temps t indice a */
  int tc;      /* Valeur du temps t indice c */
} pirate_t;

/* Barbe-Noire */
pirate_t barbeNoire = {"Barbe-Noire", 10, 5, 3};

/* Lieutenants */

#define NBLIEUTENANT 3

pirate_t lieutenant[NBLIEUTENANT] = {
  {"Le Borgne"         , 10, 1, 1},
  {"Long Jean d'Argent", 10, 2, 2},
  {"Rackham le Rose"   , 10, 4, 4}
};

/*
 * Variables liées au paradigme lecteur/rédacteur (les noms sont repris
 * du cours).
 */

/* Compteur du nombre de lecteurs */
int *nl;

/* Les différents sémaphores */
int mutexG;
int mutexL;
int fifo;

/*
 * Fonction d'allocation d'un sémaphore de clé key et de valeur
 * initiale initVal
 */
int semAlloc(int key, int initVal){
  int semId;
  semId = semget(key, 1, IPC_CREAT|0600);
  if (semId == -1) {
    perror("semget");
    exit(2);
  }
  if (semctl(semId, 0, SETVAL, initVal) == -1) {
    perror("semctl");
    exit(2);
  }
  return semId;
}

/*
 * Procédures P et V pour manipulation du sémaphore de rang 0 des objets
 * sémaphores
 */
void P(int semId){
  struct sembuf aBuf = {0, -1, 0};
  if (semop(semId, &aBuf, 1) == -1){
    perror("semop P");
    exit(2);
  }
}

void V(int semId){
  struct sembuf aBuf = {0, +1, 0};
  if (semop(semId, &aBuf, 1) == -1){
    perror("semop V");
    exit(2);
  }
}

/* 
 * Procédure de simultation du comportement du lieutenant numéro num
 */
void lieut(int num){
  int i;
  for (i=0 ; i<lieutenant[num].nbFois ; i++){
    printf("%s essaye d'entrer dans la cale\n",
	   lieutenant[num].nom);
    P(fifo);
    P(mutexL);
    *nl += 1;
    if (*nl == 1) {
      P(mutexG);
    }
    V(mutexL);
    V(fifo);
    printf("%s admire le trésor dans la cale pendant %d seconde(s)\n",
	   lieutenant[num].nom,
	   lieutenant[num].ta);
    sleep(lieutenant[num].ta);
    printf("%s sort de la cale\n",
	   lieutenant[num].nom);
    P(mutexL);
    *nl -= 1;
    if (*nl == 0) {
      V(mutexG);
    }
    V(mutexL);
    printf("%s cuve son rhum pendant %d seconde(s)\n",
	   lieutenant[num].nom,
	   lieutenant[num].tc);
    sleep(lieutenant[num].tc);
  }
  printf("%s meurt\n",
	 lieutenant[num].nom );
}  

/* 
 * Procédure de simultation du comportement de Barbe-Noire
 */
void barbe(){
  int i;
  for (i=0 ; i<barbeNoire.nbFois ; i++){
    printf("%s essaye d'entrer dans la cale\n",
	   barbeNoire.nom);
    P(fifo);
    P(mutexG);
    V(fifo);
    printf("%s admire le trésor dans la cale pendant %d seconde(s)\n",
	   barbeNoire.nom,
	   barbeNoire.ta);
    sleep(barbeNoire.ta);
    printf("%s sort de la cale\n",
	   barbeNoire.nom);
    V(mutexG);
    printf("%s cuve son rhum pendant %d seconde(s)\n",
	   barbeNoire.nom,
	   barbeNoire.tc);
    sleep(barbeNoire.tc);
  }
  printf("%s meurt\n",
	 barbeNoire.nom );
}

/*
 * Programme principal
 */
int main() {
  int i;
  int pid;
  int shmId;

  /* 
   *Initialisations
   */

  /* Création et attachement de la zone de mémoire partagée nl */
  shmId = shmget(SHMKEY1, sizeof(int), 0700|IPC_CREAT);
  if (shmId < 0) {
    perror("shmget");
    exit(-1);
  }
  nl = (int *)shmat(shmId, 0, 0);
  if (nl < (int *) 0) {
    perror("shmat");
    exit(1);
  }
  *nl = 0;
  
  /* Création des sémaphores */
  mutexG = semAlloc(SEMKEY1, 1);
  mutexL = semAlloc(SEMKEY2, 1);
  fifo   = semAlloc(SEMKEY3, 1);

  /* Fork des lieutenants */
  for (i=0 ; i<NBLIEUTENANT ; i++) {
    pid = fork();
    switch (pid) {
    case -1 :
      fprintf(stderr, "echec de fork\n");
      exit(1);
    case 0 : /* enfant */
      lieut(i);
      /* Détachement de la zone de mémoire partagée */
      if (shmdt((char *) nl) < 0){
	perror("shmdt");
	exit(1);
      }
      return 0;
    default : /* parent */
      break;
    }
  }

  /* On est le parent qui a declenché tous les enfants ==> on prend le */
  /* rôle de Barbe-Noire                                               */
  barbe();

  /* Barbe-Noire attend que tous ses lieutenants soient morts avant de */
  /* mourir                                                            */
  for (i=0 ; i<NBLIEUTENANT ; i++) {
    int status;
    if (wait(&status) == -1){
      perror("wait");
      exit(1);
    }
  }

  /* Détachement,puis suppression de la zone de mémoire partagée */
  if (shmdt((char *) nl) < 0){
    perror("shmdt");
    exit(1);
  }
  if (shmctl(shmId, IPC_RMID, NULL) < 0){
    perror("shmctl");
    exit(1);
  }

  /* Libération des sémaphores */
  if (semctl(mutexG, 0, IPC_RMID, NULL) < 0) {
    perror("semctl");
    exit(1);
  }
  if (semctl(mutexL, 0, IPC_RMID, NULL) < 0) {
    perror("semctl");
    exit(1);
  }
  if (semctl(fifo, 0, IPC_RMID, NULL) < 0) {
    perror("semctl");
    exit(1);
  }

  return 0;
}