Ficha de Avaliação n.º 2 (ScOMP)

eleitor.c

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

#include "semaforos.h"

int main(int argc, char *argv[]) {
	key_t key;
	int shmid, semid, sem, pos;
	int *data;
	int *aponta[10];
	       
	if(*argv[1] == 's' || *argv[1] == 'n') {

		/* cria a chave com base no ficheiro votar.txt */
        	if ((key = ftok("votar.txt", 0)) == -1) {
            		perror("ftok");
            		exit(1);
        	}

		/* cria uma ligação à zona de memória partilhada */
        	if ((shmid = shmget(key, sizeof(char), 0666) == -1)) {
        	    perror("shmget");
        	    exit(1);
        	}

		/* cria o semáforo que irá controlar o número de eleitores */
		semid=cria_semaforo(0,1);
		printf("criou o semaforo\n");

		/* mapeamento da zona de memória partilhada */
        	data = shmat(shmid, (void *)0, 0);
        	if (data == (int *)(-1)) {
        	    perror("shmat");
        	    exit(1);
        	}

		/* controlo de acesso dos eleitores através dos semáforos */
		sem=ocupa_recursos(semid,1);
		*aponta = (int *) data;	
        	printf("A escrever o voto: \"%s\"\n", argv[1]);
		pos=*aponta[0];	// controle do número de pessoas que já votaram.
		pos++;

		/* escrita do voto no vector. (s = 1, n = 0)*/
		if(*argv[1] == 's')
			*aponta[pos]=1;
		else
			*aponta[pos]=0;

		*aponta[0]=pos; // incremento da posição na região de memória partilhada
		printf("O valor que esta na regiao de memoria partilhada e %d\n",*aponta[0]);

		//desliga da zona de memoria partilhada
        	if (shmdt(data) == -1) {
        	    perror("shmdt");
        	    exit(1);
        	}

		printf("O seu voto foi aceite.\n%s",argv[1]);
	} else {
		fprintf(stderr, "Voto invalido!\n");
		exit(2);
	}

	return(0);
}

juiz.c

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

#include "semaforos.h"

int main() {
	int sem, semid;
	void *memoria_partilhada = (void *) 0;
	int *aponta[10]; //apontador para a região de memória partilhada.

	int shmid;
	key_t key;

	/* cria a chave a partir do ficheiro votar.txt */
	key=ftok("votar.txt", 0);
	shmid = shmget(key, sizeof(int)*10, 0666 | IPC_CREAT);
	if (shmid == -1) {
		printf("Erro ao criar chave. \n");
		exit(-1);
	}

	/* cria uma ligação à zona de memória partilhada */
	memoria_partilhada = shmat(shmid, (void *) 0, 0);
	if (memoria_partilhada == (void *) -1) {
		printf("Erro ao fazer shmat\n");
		exit(-1);
	}

	/* cria o semáforo que irá controlar o número de eleitores */
	semid=cria_semaforo(0,1);
	printf("criou o semaforo\n");
	*aponta = (int *) memoria_partilhada;
	aponta[0]=0;\

	/* ciclo de votos. espera que 9 eleitores votem. */
	do {
		sem=ocupa_recursos(semid,1);
		*aponta = (int *) memoria_partilhada;
		printf("O valor que está na regiao de memoria partilhada é %d\n",*aponta[0]);
		sem=liberta_recursos(semid,1);
		sleep(2);
	} while(*aponta[0]<9);

	int k;
	int sim=0,nao=0;

	/* faz a contagem dos votos recebidos */
	for(k =1;k<*aponta[0];k++) {
		if(*aponta[k]==1)
			sim++;
		else
			nao++;
	}

	/* imprime lado vencedor */
	if(sim>nao)
		printf("Ganhou o sim com %d votos", sim);
	else
		printf("Ganhou o nao com %d votos", nao);

	/* desliga-se da zona de memória partilhada */
    	if (shmdt(memoria_partilhada) == -1) {
        	perror("shmdt");
        	exit(1);
	}

	/* destrói a região de memória partilhada */
	if (shmctl(shmid, IPC_RMID, 0) == -1) {
		printf("Erro ao remover região de memória partilhada.");
		exit(-1);
	}

	return (0);
}

semaforo.c

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

/*****************************************************************************/

union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
    struct seminfo *__buf;
};

/*****************************************************************************/

int cria_semaforo(int chave, int n_recursos)
{
	int sem_id;
	union semun seu;

	if ((sem_id=semget((key_t)chave,1,0666|IPC_CREAT|IPC_EXCL)) == -1)
		return (semget(chave,1,0666));

	seu.val=n_recursos;

	if(semctl(sem_id,0,SETVAL,seu)==-1)
		return -1;

	return sem_id;
}

/*****************************************************************************/

int ocupa_recursos(int sem_id, int n_recursos)
{
	struct sembuf down;

	down.sem_num=0;
	down.sem_op=-n_recursos; //negativo ocupa, positivo liberta

	if(semop(sem_id,&down,1)==-1)
	    return -1;
	else
		return 1;
}

/*****************************************************************************/

int liberta_recursos(int sem_id, int n_recursos)
{
	struct sembuf up;

	up.sem_num=0;
	up.sem_op=n_recursos;

	if(semop(sem_id,&up,1)==-1)
		return -1;
	else
		return 1;
}

/*****************************************************************************/

int remove_semaforo(int sem_id)
{
	union semun arg;
	
	if(semctl(sem_id,0,IPC_RMID,arg)==-1)
		return -1;
	else
		return 1;
}

/*****************************************************************************/

int valor_semaforo(int sem_id)
{
	return semctl(sem_id,0,GETVAL,NULL); //GETVAL devolve o valor do semaforo.
}

/*****************************************************************************/

int set_valor_semaforo(int sem_id, int valor)
{
	union semun arg;
	arg.val=valor;
	return (semctl(sem_id,0,SETVAL,arg)); //SETVAL inicia o valor do semaforo com arg.valor
}

/*****************************************************************************/

semaforo.h

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>
#include <sys/sem.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include "semaforos.c"

/*****************************************************************************/

int cria_semaforo(int chave, int n_recursos); 

/*****************************************************************************/ 

int ocupa_recursos(int sem_id, int n_recursos); 

/*****************************************************************************/

int liberta_recursos(int sem_id, int n_recursos); 

/*****************************************************************************/

int remove_semaforo(int sem_id);

/*****************************************************************************/

int valor_semaforo(int sem_id);

/*****************************************************************************/

int set_valor_semaforo(int sem_id, int valor);

/*****************************************************************************/