[C] Gestione "uscita navi dal porto"

[superiso]

questo è il file canale.c

#include "libporto.h"

int senso_unico;    //indirizzo del pool di semafori del senso unico alternato

/* gestore del segnale */
void handler_int(int num_segnale) {
	if (semctl(senso_unico, 0, GETVAL, 0) == 1)
	{
		printf("\n------------------------------\n");
		printf("ENTRATA NAVI NEL PORTO\n");
		printf("------------------------------\n");
		semctl(senso_unico, 0, SETVAL, 0);    //semaforo entrata porto: verde
	    semctl(senso_unico, 1, SETVAL, 1);    //semaforo uscita porto: rosso 
	}
	else
	{
		printf("\n------------------------------\n");
		printf("USCITA NAVI DAL PORTO\n");
		printf("------------------------------\n");
		semctl(senso_unico, 0, SETVAL, 1);    //semaforo entrata porto: rosso
	    semctl(senso_unico, 1, SETVAL, 0);    //semaforo uscita porto: verde 
	}
}

/* main */
int main()
{
	int pid_capitaneria;    //pid della capitaneria
	int pid_nave;    //pid della nave
	msgpid capitaneria_pid;    //messaggio con pid della capitaneria
	msgpid nave_pid;    //messaggio con pid della nave
	
	printf("Il pid di canale è: %d\n", getpid());    //stampa il pid del processo

	invia_pid(getpid(), "CANALE", PID_CANALE);    //invia il pid agli altri processi
	invia_pid(getpid(), "CANALE", PID_CANALE);
	
	printf("Attendo i pid degli altri due processi\n");
	
	//esegue finché non ottiene i pid dei due processi complementari
	do{
		if(strcmp(capitaneria_pid.mittente, "CAPITANERIA") != 0)
		{
			capitaneria_pid = ricevi_pid(PID_CAPITANERIA);    //riceve il messaggio
			pid_capitaneria = capitaneria_pid.p_npid;    //assegna il pid
		}
		if(strcmp(nave_pid.mittente, "NAVE") != 0)
		{
			nave_pid = ricevi_pid(PID_NAVE);    //riceve il messaggio
			pid_nave = nave_pid.p_npid;    //assegna il pid
		}
	} while(strcmp(capitaneria_pid.mittente, "CAPITANERIA") != 0 || strcmp(nave_pid.mittente, "NAVE") != 0);
	
	printf("PID_CAPITANERIA è %d\n", pid_capitaneria);
	printf("PID_NAVE è %d\n", pid_nave);
	
	senso_unico = crea_semafori(2, SEMALT);
	semctl(senso_unico, 0, SETVAL, 1);    //entrata verde
	semctl(senso_unico, 1, SETVAL, 0);    //uscita rosso
	
	signal(SIGALRM, handler_int);

	while(1){
		alarm(3);
		sleep(1000);
	}
		
	return 0;
}

questo è il file capitaneria.c

#include "libporto.h" 

msg dati_nave;   //contiene il messaggio ricevuto dalla nave
boat *mem_cond;    //puntatore alla memoria condivisa
int i = 0;    //indice per la memoria condivisa


/* gestore del segnale */
void handler_int(int num_segnale) 
{
	dati_nave = ricevi_msg();    //riceve il messaggio da nave
	printf("   $ La nave <%s> trasporta %d tonnellate di %s e attenderà nel porto per %d ore\n", dati_nave.info.nome_nave, dati_nave.info.quantita, dati_nave.info.carico.merce, dati_nave.info.ore);
	salva_msg(mem_cond, dati_nave, i);
	i++;
}

/* main */
int main()
{
	int pid_canale;    //pid del canale
	int pid_nave;    //pid della nave
	msgpid canale_pid;    //messaggio con pid del canale
	msgpid nave_pid;    //messaggio con pid dela nave
	int coda;    //variabile di controllo per la coda messaggi
	
	mem_cond = crea_memcond();
	coda = crea_codamsg();
	if(coda == -1)
	{
		printf("***  ERRORE CREAZIONE CODA MESSAGGI  ***");
		return 0;
	}
			
	printf("Il pid di capitaneria è: %d\n", getpid());    //stampa il pid del processo

	invia_pid(getpid(), "CAPITANERIA", PID_CAPITANERIA);    //invia il pid agli altri processi
	invia_pid(getpid(), "CAPITANERIA", PID_CAPITANERIA);
	
	printf("Attendo i pid degli altri due processi\n");
	
	//esegue finché non ottiene i pid dei due processi complementari
	do{
		if(strcmp(canale_pid.mittente, "CANALE") != 0)
		{
			canale_pid = ricevi_pid(PID_CANALE);    //riceve il messaggio
			pid_canale = canale_pid.p_npid;    //assegna il pid
		}
		if(strcmp(nave_pid.mittente, "NAVE") != 0)
		{
			nave_pid = ricevi_pid(PID_NAVE);    //riceve il messaggio
			pid_nave = nave_pid.p_npid;    //assegna il pid
		}
	} while(strcmp(canale_pid.mittente, "CANALE") != 0 || strcmp(nave_pid.mittente, "NAVE") != 0);
	
	printf("PID_CANALE è %d\n", pid_canale);
	printf("PID_NAVE è %d\n", pid_nave);
	
	signal(SIGINT, handler_int);
	
	while(1){
		sleep(1000);
	}
	
	return 0;
}

questo è il file nave.c

#include "libporto.h"

int main()
{
	int pid_canale;    //pid del canale
	int pid_capitaneria;    //pid della capitaneria
	int num_navi;    //numero di navi create
	int i;    //indice per il ciclo for
	int pid;	//pid per la fork()
	int wait_son;		//wait()
	int senso_unico;    //indirizzo del pool di semafori del senso unico alternato
	int sem_cont;    //indirizzo del semaforo contatore
	boat nave;    //struttura contenente i dati della nave
	msgpid canale_pid;    //messaggio con pid del canale
	msgpid capitaneria_pid;    //messaggio con pid della capitaneria
	
	sem_cont = crea_semafori(1, SEMCONT);    //crea il semaforo contatore
	semctl(sem_cont, 0, SETVAL, 10);    //inizializza il semaforo contatore
	
	printf("Il pid di nave è: %d\n", getpid());    //stampa il pid del processo	
	
	invia_pid(getpid(), "NAVE", PID_NAVE);    //invia il pid agli altri processi
	invia_pid(getpid(), "NAVE", PID_NAVE);
	
	printf("Attendo i pid degli altri due processi\n");
	
	printf("Quante navi vuoi gestire? ");
	scanf("%d", &num_navi);
	
	//esegue finché non ottiene i pid dei due processi complementari
	do{
		if(strcmp(canale_pid.mittente, "CANALE") != 0)
		{
			canale_pid = ricevi_pid(PID_CANALE);    //riceve il messaggio
			pid_canale = canale_pid.p_npid;    //assegna il pid
		}
		
		if(strcmp(capitaneria_pid.mittente, "CAPITANERIA") != 0)
		{
			capitaneria_pid = ricevi_pid(PID_CAPITANERIA);    //riceve il messaggio
			pid_capitaneria = capitaneria_pid.p_npid;    //assegna il pid
		}
	} while(strcmp(canale_pid.mittente, "CANALE") != 0 || strcmp(capitaneria_pid.mittente, "CAPITANERIA") != 0);
	
	printf("PID_CANALE è %d\n", pid_canale);
	printf("PID_CAPITANERIA è %d\n", pid_capitaneria);
	
	senso_unico = semget(SEMALT, 0, 0);
	
	for(i = 1; i <= num_navi;)    //ciclo for necessario per creare i processi figlio
	{    //APERTURA FOR
		
		pid = fork();    //fork() su pid per creare il figlio
		if(pid)    //if(pid != 0) entro nel codice del processo padre
		{    //APERTURA IF-THEN(1)
			printf("SUN EL PARE\n");
			i++;    //incremento l'indice del ciclo for per evitare il loop
			fflush(stdout);    //chiude lo stream
						
			wait_son = wait(0);	//il processo padre aspetta la terminazione del processo figlio
			fflush(stdout);    //chiude lo stream
			
		}    //CHIUSURA IF-THEN(1)
		else    //if(pid == 0) entro nel codice del processo figlio
		{    //APERTURA IF-ELSE(1)
			
			printf("SONO IL FIGLIO\n");
			S(senso_unico, 0);    //controllo per l'accesso al porto
			P(sem_cont, 0);    //decremento il valore del semaforo
			nave = crea_nave(i);    //creazione della nave
			invia_msg(getpid(), nave);    //invio messaggio a capitaneria
			kill(pid_capitaneria, SIGINT);    //uccide il processo
			sleep(nave.ore);

			//S(senso_unico, 1);
			//V(sem_cont, 0);
			
			i = num_navi + 1;    //incremento dell'indice per l'uscita dal ciclo
			fflush(stdout);    //chiude lo stream

				
		}    //CHIUSURA IF-ELSE(1)
	}    //CHIUSURA FOR
	
	return 0;
}

[superiso]

questo è il file libporto.c

#include "libporto.h"

/* invia il pid di un processo */
void invia_pid(int pid, char *mit, int num_coda)
{
	int num_quid;
	msgpid pid_snd;
	ssize_t val_snd;
	
	num_quid = msgget(num_coda, IPC_CREAT | 0666);
	
	pid_snd.p_npid = pid;
	pid_snd.p_type = 1;
	strcpy(pid_snd.mittente, mit);

	val_snd = msgsnd(num_quid, &pid_snd, sizeof(msgpid) - sizeof(long), 0);

	if(val_snd == -1)
		printf("*** ERRORE INVIO PID ***\n");
		
	return;
}

/* riceve il pid di un altro processo */
msgpid ricevi_pid(int num_coda)
{
	msgpid pid_rcv;
	ssize_t val_rcv;
	int num_quid;
	
	num_quid = msgget(num_coda, 0);
		
	val_rcv = msgrcv(num_quid, &pid_rcv, sizeof(msgpid) - sizeof(long), 1, 0);
	
	return pid_rcv;
}

/* crea il pool di semafori necessaria per la gestione dell'entrata ed uscita delle navi al porto */
int crea_semafori(int n, int id_sem)
{
	int s_uid;    //risultato della semget()
	
	s_uid = semget(id_sem, n, IPC_CREAT | 0666);
	
	if(s_uid == -1)
		return -1;
	else
		return s_uid;
}

/* wait:  ottiene la risorsa in mutua esclusione */
int P(int semid, int semnum) 
{
    struct sembuf cmd;
    
	cmd.sem_num = semnum;       
    cmd.sem_op = -1;               
    cmd.sem_flg = 0; 
    
	return semop(semid, &cmd, 1);          
}

/* gestisce il traffico nel senso unico alternato */
int S(int semid, int semnum) 
{
    struct sembuf cmd;
    
	cmd.sem_num = semnum;       
    cmd.sem_op = 0;               
    cmd.sem_flg = 0; 
    
	return semop(semid, &cmd, 1);          
}

/* signal: rilascia la risora */
int V(int semid, int semnum) 
{
	struct sembuf cmd;
    
    cmd.sem_num = semnum;
    cmd.sem_op = 1;                             
	cmd.sem_flg = 0;
    
	return semop(semid, &cmd, 1);
}

/* assegna in modo casuale ad ogni nave un tipo di merce */
prodotto get_carico()
{
	prodotto mercanzia;    //struttura con il tipo di merce
    int valore;    //numero casuale	per assegnare una merce	
	
	srand(getpid());    //senza questo il random restituisce sempre lo stesso num
    valore = rand() % 10 + 1;    //assegna un valore casuale da 1 a 10 alla variabile valore

	switch(valore)    //inizializza il tipo di merce in base al risultato di random
	{
		case 1: 
				strcpy(mercanzia.merce, "arance");
				mercanzia.attesa = ARANCE;
				break;

		case 2: 
				strcpy(mercanzia.merce, "acciaio");
				mercanzia.attesa = ACCIAIO;
				break;

		case 3: 
				strcpy(mercanzia.merce, "GPL");
				mercanzia.attesa = GPL;
				break;

		case 4: 
				strcpy(mercanzia.merce, "pesce");
				mercanzia.attesa = PESCE;
				break;

		case 5: 
				strcpy(mercanzia.merce, "benzina");
				mercanzia.attesa = BENZINA;
				break;
				
		case 6: 
				strcpy(mercanzia.merce, "cereali");
				mercanzia.attesa = CEREALI;
				break;
				
		case 7: 
				strcpy(mercanzia.merce, "rifiuti");
				mercanzia.attesa = RIFIUTI;
				break;
				
		case 8: 
				strcpy(mercanzia.merce, "banane");
				mercanzia.attesa = BANANE;
				break;
				
		case 9: 
				strcpy(mercanzia.merce, "ferro");
				mercanzia.attesa = FERRO;
				break;

		case 10:
				strcpy(mercanzia.merce, "legname");
				mercanzia.attesa = LEGNAME;
				break;
				
		default:
				printf("*****ERRORE*****\n"); 
				break;
	}

	return mercanzia;    //restituisce il prodotto
}

/* assegna in modo casuale ad ogni nave una quantità di merce */
int get_quantita()
{
    int n;    //numero delle navi
    
	srand(getpid());    //senza questo il random restituisce sempre lo stesso num
    n = rand() % 1000 + 500;    //assegna un valore casuale da 500 a 1000 alla variabile n
    
	return n;    //restituisce la quantità trasportata
}

/* assegna in modo casuale ad ogni nave un nome */
char *get_nomenave()
{
    char name[25];    //struttura con il nome della nave			
	int valore;    //numero casuale	per assegnare un nome	
	
	srand(getpid());    //senza questo il random restituisce sempre lo stesso num
    valore = rand() % 10 + 1;    //assegna un valore casuale da 1 a 10 alla variabile valore

	switch(valore)    //inizializza il nome della nave in base al risultato di random
	{
		case 1: 
				strcpy(name, "Bismarck");
				break;

		case 2: 
				strcpy(name, "Calypso");
				break;

		case 3: 
				strcpy(name, "Endeavour");
				break;

		case 4: 
				strcpy(name, "HMS Victory");
				break;

		case 5: 
				strcpy(name, "Knock Nevis");
				break;
				
		case 6: 
				strcpy(name, "Moby Prince");
				break;

		case 7: 
				strcpy(name, "Principessa Mafalda");
				break;

		case 8: 
				strcpy(name, "RMS Lusitania");
				break;

		case 9: 
				strcpy(name, "Thistlegorm");
				break;

		case 10: 
				strcpy(name, "USS Constitution");
				break;

		default:
				printf("*****ERRORE*****\n"); 
				break;
	}

	return name;    //restituisce il nome della nave
}

/* crea in modo casuale un numero di navi da un minimo di 1 ad un massimo di 15 
int get_numnavi()
{
    int n;    //numero delle navi
    
	srand(getpid());    //senza questo il random restituisce sempre lo stesso num
    n = rand() % 15 + 7;    //assegna un valore casuale da 1 a 15 alla variabile n
    
	return n;    //restituisce il numero di navi
}*/

/* crea una nave */
boat crea_nave(int val)
{
	boat barca;    //struttura con la nave da creare
	int temp; //double
		
	barca.id_nave = getpid();    //assegna all'identificatore della nave l'identificatore del processo
	barca.carico = get_carico();    //assegna un tipo random di merce 
	strcpy(barca.nome_nave, get_nomenave());    //assegna un nome random
	barca.quantita = get_quantita();    //assegna una quantità random
	temp = barca.quantita/500;
	barca.ore = barca.carico.attesa*temp;
	printf("\n------------------------------------------------------------------------------\n");
	printf("   § Identificatore nave ---> %d **\n", val);    //stampa l'identificatore della nave
	printf("   § Nome della nave ---> %s **\n", barca.nome_nave);    //stampa il nome della nave
	printf("   § Merce contenuta sulla nave ---> %s **\n", barca.carico.merce);    //stampa la merce trasportata dalla nave
	printf("   § Quantità di merce contenuta sulla nave ---> %d tonnellate **\n", barca.quantita);    //stampa la quantità della merce
	printf("   § Tempo di permanenza della nave nel porto ---> %d ore **\n", barca.ore);    //stampa il tempo di scarico della merce dalla nave
	printf("------------------------------------------------------------------------------\n");
	fflush(stdout);    //chiude lo stream
	
	return barca;    //ritorna la nave appena creata
}

/* crea la coda di messaggi necessaria per le comunicazioni tra nave e capitaneria */
int crea_codamsg()
{
	int q_uid;    //risultato della msgget()
	
	q_uid = msgget(ID_CODA, IPC_CREAT | 0666);
	
	if(q_uid == -1)
		return -1;
	else
		return q_uid;	
}
	
/* invia messaggi per le comunicazioni tra nave e capitaneria */
int invia_msg(int num_pid, boat barca)
{
	msg sms_snd;
	int val_snd;
	int num_quid;
	
	num_quid = msgget(ID_CODA, 0);
	
	sms_snd.npid = num_pid;
	sms_snd.type = 1;
	sms_snd.info = barca;
	
	val_snd = msgsnd(num_quid, &sms_snd, (sizeof(msg) - sizeof(long)), 0);
	
	if(val_snd == -1)
	{
		printf("***  ERRORE INVIO MESSAGGIO  ***\n");
		return 0;
	}
	else
	{
		printf("   - INVIO MESSAGGIO DALLA NAVE NUMERO %d ESEGUITO CORRETTAMENTE **\n", sms_snd.npid);
		return 1;
	}
}

/* riceve messaggi scambiati tra nave e capitaneria */
msg ricevi_msg()
{
	msg sms_rcv;
	ssize_t val_rcv;
	int num_quid;
	
	num_quid = msgget(ID_CODA, 0);
		
	val_rcv = msgrcv(num_quid, &sms_rcv, (sizeof(msg) - sizeof(long)), 1, 0);
	
	if(val_rcv == 0)
		printf("***  ERRORE RICEZIONE MESSAGGIO  ***\n");
	else
		printf("\n   - RICEZIONE MESSAGGIO DALLA NAVE NUMERO %d ESEGUITA CORRETTAMENTE **\n", sms_rcv.npid);
	return sms_rcv;
}

/* crea la memoria condivisa e ne restituisce il puntatore */
boat *crea_memcond()
{
	boat *s;
	int shmid;
	
	shmid = shmget(ID_MEM, sizeof(boat) - sizeof(long), IPC_CREAT | 0666);	
	s = (boat *) shmat(shmid, NULL, 0);

	return s;
}

/* salva i messaggi nella coda di messaggi */
void salva_msg(boat *s, msg sms_nave, int n)
{
	s[n] = sms_nave.info;
}

/* stampa i messaggi presenti nella coda di messaggi */
void stampa_codamsg(boat *s, int n)
{
	int j;
	
	for(j = 0; j <= n; j++)
		printf("  ***la nave si chiamava %s\n", s[j].nome_nave);
}

e questo è il file libporto.h

#ifndef molo
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/wait.h> 
#define molo
#define ID_CODA 1357
#define PID_CANALE 1234
#define PID_CAPITANERIA 5678
#define PID_NAVE 9012
#define SEMALT 5768
#define SEMCONT 9495
#define ID_MEM 8485

/*assegnamento tempo di scarico in ore in base a 500 tonnellate di merce*/
#define CEREALI 1
#define ARANCE 2
#define BANANE 3
#define PESCE 4
#define RIFIUTI 5
#define LEGNAME 6
#define FERRO 7
#define ACCIAIO 8
#define BENZINA 9
#define GPL 10

typedef struct {
	int attesa;	
	char merce[25];
} prodotto;

typedef struct {
	prodotto carico;
	int id_nave;
	int quantita; //double
	int ore;  //double
	char nome_nave[25];
} boat;

typedef struct {
	long type;
	int npid;
	boat info;
} msg;

typedef struct {
	long p_type;
	int p_npid;
	char mittente[11];
} msgpid;


void invia_pid(int, char *, int);
msgpid ricevi_pid(int);
int crea_semafori(int, int);
prodotto get_carico();
int get_quantita();
char *get_nomenave();
boat crea_nave(int);
int P(int, int);
int V(int, int);
int S(int, int);
int invia_msg(int, boat);
int crea_codamsg();
msg ricevi_msg();
boat *crea_memcond();
void salva_msg(boat *, msg, int);
void stampa_codamsg(boat *, int);
#endif

[ant_alt]

uhm pensavo che il progetto fosse un poco poco meno articolato

cmq se il tuo dubbio principale è come forkare ma eseguire simultaneamente i processi, i segnali credo siano una buona soluzione, anche se hanno i loro inconvenienti..
documentati sulle funzioni waitpid e ovviamente signal

[superiso]

volevo due dritte sull'alarm xk nn riesco a farlo girare.. ossia riceve un segnale e il programma si blocca li..
sai spiegarmi un po l'alarm()?grazie

[ant_alt]

Originariamente inviato da superiso
volevo due dritte sull'alarm xk nn riesco a farlo girare.. ossia riceve un segnale e il programma si blocca li..
sai spiegarmi un po l'alarm()?grazie

"La funzione alarm(sec) invia al processo corrente il segnale SIGALRM dopo che siano trascorsi sec secondi"

è come ogni altro segnale col suo bravo handler

[superiso]

ok dici di inserire un alarm dopo la kill in nave.c?

[ant_alt]

Originariamente inviato da superiso
ok dici di inserire un alarm dopo la kill in nave.c?

quale kill?
ok finalmente ho capito che non ci capiamo perchè non hai ben capito come si usano i segnali
ora non ho a disposizione linux, appena posso posto

[ant_alt]

programma base per i segnali

#include<unistd.h>
#include<stdio.h>
#include<signal.h>

void handler(int x){
if(SIGALRM==x) printf("sono il padre e ogni due secondi ricevo SIGALRM\n");
if(SIGINT==x) printf("sono il padre e mi hai mandato SIGINT ( ctrl+c )\n");
if(SIGCHLD==x) printf("sono il padre, sono passati 10 sec e mi è morto il figlio\n");
}
int main(){
int pid=fork();
if(pid==0){
printf("sono il figlio, aspetto 10 sec e mi ammazzo (avvertendo mio padre con SIGCHLD)\n");
sleep(3);
_exit(0);
}
else{
signal(SIGALRM,&handler); //con signal() installo i gestori
signal(SIGINT,&handler);
signal(SIGCHLD,&handler);
while(1){alarm(2);pause();}
}
}

SIGALRM lo manda alarm()
SIGINT come molti altri segnali lo mandi con combinazioni di tastiera
SIGCHLD viene mandato automaticamente al padre quando gli muore un figlio

spero di averti chiarito