int main (int argc, char *argv[]) {
DIR *dirp;
struct dirent *dp;
dirp=malloc(sizeof(DIR));
if(dirp==NULL) {
exit_on_error("malloc");
}
dp=malloc(sizeof(struct dirent));
if(dp==NULL) {
exit_on_error("malloc");
}
char name[]=".";
dirp = opendir(name);
if(dirp==NULL) {
exit_on_error("opendir");
}
int count=0;
while ((dp = readdir(dirp)) != NULL) {
if (dp->d_type==DT_REG) {
count++;
}
}
printf ("%d fichiers
int err = closedir(dirp);
if(err<0) {
exit_on_error("closedir");
}
}
void validar_num() {
sem_id = semget(7345, 1, 0);
exit_on_error(sem_id, "Ligação");
int encontrou=0;
printf("Número do aluno:\n");
fgets(numero, 50, stdin);
numero[strlen(numero)-1]='\0';
status_s = semop(sem_id, &DOWN, 1);
exit_on_error(status_s, "DOWN");
for (i=0; i<500; i++) {
if (p[i].num_aluno == atoi(numero)) {
printf("O nome do aluno é %s\n", p[i].nome);
encontrou=1;
break;
}
}
status_s=semop(sem_id, &UP, 1);
exit_on_error(status_s, "UP");
if (encontrou==0) {
printf("Esse número não existe na memória.\n");
validar_num();
}
}
static void init(scicos_block *block)
{
FILE * fp;
double * pData;
char filename[30];
int i;
int npts=block->ipar[0];
if(npts==0) {
fprintf(stderr, "Error - Data length is 0!\n");
exit_on_error();
}
pData=(double *) calloc(npts,sizeof(double));
par_getstr(filename,block->ipar,3,block->ipar[2]);
fp=fopen(filename,"r");
if(fp!=NULL){
block->ipar[1]=0;
for(i=0;i<npts;i++) {
if(feof(fp)) break;
fscanf(fp,"%lf",&(pData[i]));
}
fclose(fp);
}
else{
fprintf(stderr, "File %s not found!\n",filename);
exit_on_error();
}
*block->work=(void *) pData;
}
/* main() */
int main(int argc, char *argv[])
{
DBusConnection *conn = NULL;
DBusMessage *msg_query = NULL;
DBusMessage *msg_reply = NULL;
DBusError error;
const char *xml_data = NULL;
int return_code;
/* Initialize the error state. */
dbus_error_init(&error);
/* Connect to user-session D-Bus */
fprintf(stdout, "Connecting to Session D-Bus\n");
conn = dbus_bus_get(DBUS_BUS_SESSION, &error);
exit_on_error("Failed to open user-session bus.\n", &error);
/* Print unique name */
fprintf(stdout, "D-Bus unique name: %s\n", \
dbus_bus_get_unique_name(conn));
/* Request well-know name on the session bus */
return_code = dbus_bus_request_name(conn, DBUS_CLIENT_NAME, \
DBUS_NAME_FLAG_REPLACE_EXISTING, \
&error);
exit_on_error("Failed to get well-known name.", &error);
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != return_code)
exit(EXIT_FAILURE);
/* Send "Introspect" message */
msg_query = dbus_message_new_method_call(DBUS_SERVER_NAME, /* Target */
DBUS_OBJECT_PATH, /* Object */
DBUS_IFACE_INTRO, /* Interface */
"Introspect"); /* Method name */
msg_reply = dbus_connection_send_with_reply_and_block(conn, msg_query, 1000, &error);
exit_on_error("Failed to send Introspect message.", &error);
/* Get the string argument from Introspect call */
dbus_message_get_args(msg_reply, &error, DBUS_TYPE_STRING, \
&xml_data, DBUS_TYPE_INVALID);
/* Print message information */
fprintf(stdout, "Object Path \t= %s\n", dbus_message_get_path(msg_query));
fprintf(stdout, "Interface \t= %s\n", dbus_message_get_interface(msg_query));
fprintf(stdout, "Message \t= %s\n", dbus_message_get_member(msg_query));
fprintf(stdout, "Introspect xml_data:\n%s\n", xml_data);
/* Free messages */
dbus_message_unref(msg_query);
dbus_message_unref(msg_reply);
/* Free the connection. */
dbus_connection_unref(conn);
return EXIT_SUCCESS;
}
void recebe_msg() {
msg_id=msgget(96975, 0);
exit_on_error(msg_id, "Ligação");
printf("À espera de uma mensagem...\n");
status = msgrcv(msg_id, &receber_msg, sizeof(receber_msg.dados), enviar_msg.dados.pid_passageiro, 0);
exit_on_error (status, "Recepção");
printf("O pid do condutor é %d\n", receber_msg.dados.pid_condutor);
}
int rtRegisterScope(const char *name, int n, int ID )
{
int i;
int nscope;
rt_sched_lock();
nscope = NSCOPE++;
rt_sched_unlock();
if( nscope>= MAX_SCOPES ){
fprintf(stderr,"Error: Scopes exceed %d \n",MAX_SCOPES);
return -1;
}
if ( ID <= 0 )
fprintf(stderr,"Warning: scopes ID must be positive\n");
for (i = 0; i < MAX_SCOPES; i++) {
if (rtaiScope[i].ID == ID)
fprintf(stderr,"Warning: two or more scopes have the same ID(%d)\n",ID);
}
sprintf(rtaiScope[nscope].MBXname, "%s%d", TargetMbxID, nscope);
rtaiScope[nscope].ntraces = n;
rtaiScope[nscope].ID = ID;
rtaiScope[nscope].mbx= (MBX *) RT_typed_named_mbx_init(0,0,rtaiScope[nscope].MBXname,(MBX_RTAI_SCOPE_SIZE/((n+1)*sizeof(float)))*((n+1)*sizeof(float)),FIFO_Q);
if(rtaiScope[nscope].mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
strncpyz(rtaiScope[nscope].name, name, MAX_NAME_SIZE);
return 0;
}
int rtRegisterMeter(const char *name, int n, int ID )
{
int i;
int nmeter;
rt_sched_lock();
nmeter = NMETERS++;
rt_sched_unlock();
if( nmeter >= MAX_METERS ){
fprintf(stderr,"Error: Meters exceed %d \n",MAX_METERS);
return -1;
}
if ( ID <= 0 )
fprintf(stderr,"Warning: meters ID must be positive\n");
for (i = 0; i < MAX_METERS; i++) {
if (rtaiMeter[i].ID == ID)
fprintf(stderr,"Warning: two or more meters have the same ID(%d)\n",ID);
}
sprintf(rtaiMeter[nmeter].MBXname, "%s%d", TargetMeterMbxID, nmeter);
rtaiMeter[nmeter].ntraces = n;
rtaiMeter[nmeter].ID = ID;
rtaiMeter[nmeter].mbx= (MBX *) RT_typed_named_mbx_init(0,0,rtaiMeter[nmeter].MBXname,(MBX_RTAI_METER_SIZE/((n+1)*sizeof(float)))*((n+1)*sizeof(float)),FIFO_Q);
if(rtaiMeter[nmeter].mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
strncpyz(rtaiMeter[nmeter].name, name, MAX_NAME_SIZE);
return 0;
}
static void init(scicos_block *block)
{
char str[20];
struct MbxSif * mbx = (struct MbxSif *) malloc(sizeof(struct MbxSif));
int nch=block->nin;
par_getstr(str,block->ipar,2,block->ipar[0]);
strcpy(mbx->mbxName,str);
par_getstr(str,block->ipar,2+block->ipar[0],block->ipar[1]);
struct sockaddr_in addr;
if(!strcmp(str,"0")) {
mbx->tNode = 0;
mbx->tPort = 0;
}
else {
inet_aton(str, &addr.sin_addr);
mbx->tNode = addr.sin_addr.s_addr;
while ((mbx->tPort = rt_request_port(mbx->tNode)) <= 0
&& mbx->tPort != -EINVAL);
}
mbx->mbx = (MBX *) RT_typed_named_mbx_init(mbx->tNode,mbx->tPort,mbx->mbxName,nch*sizeof(double),FIFO_Q);
if(mbx->mbx == NULL) {
fprintf(stderr, "Error in getting %s mailbox address\n", mbx->mbxName);
exit_on_error();
}
*block->work=(void *) mbx;
}
int rtRegisterLed(const char *name, int n, int ID )
{
int i;
int nled;
rt_sched_lock();
nled = NLEDS++;
rt_sched_unlock();
if( nled >= MAX_LEDS ){
fprintf(stderr,"Error: Leds exceed %d \n",MAX_LEDS);
return -1;
}
if ( ID <= 0 )
fprintf(stderr,"Warning: leds ID must be positive\n");
for (i = 0; i < MAX_LEDS; i++) {
if (rtaiLed[i].ID == ID)
fprintf(stderr,"Warning: two or more leds have the same ID(%d)\n",ID);
}
sprintf(rtaiLed[nled].MBXname, "%s%d", TargetLedMbxID, nled);
rtaiLed[nled].nleds= n;
rtaiLed[nled].ID = ID;
rtaiLed[nled].mbx= (MBX *) RT_typed_named_mbx_init(0,0,rtaiLed[nled].MBXname,(MBX_RTAI_LED_SIZE/((n+1)*sizeof(float)))*((n+1)*sizeof(float)),FIFO_Q);
if(rtaiLed[nled].mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
strncpyz(rtaiLed[nled].name, name, MAX_NAME_SIZE);
return 0;
}
Socket::Socket(sockaddr_in addr,int nonblocking)
{
this->sockfd=socket(AF_INET,SOCK_STREAM,0);
if (sockfd<0){
exit_on_error(errno,"failed to create socket");
}
int on=1;
setsockopt(this->sockfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
if(bind(this->sockfd,(struct sockaddr*)&addr,sizeof(addr))!=0){
exit_on_error(errno,"failed to bind socket");
}
if(nonblocking!=BLOCKING){
setNonBlocking(this->sockfd);
}
}
int Socket::listen(int backlog)
{
if(::listen(this->sockfd,backlog)!=0){
exit_on_error(errno,"failed to listen");
}
return this->sockfd;
}
int main (int argc, char *argv[]) {
DIR *dirp;
struct dirent *dp;
char name[]=".";
dirp = opendir(name);
if(dirp==NULL) {
exit_on_error("opendir");
}
while ((dp = readdir(dirp)) != NULL) {
printf("%s\n",dp->d_name);
}
int err = closedir(dirp);
if(err<0) {
exit_on_error("closedir");
}
}
uint32_t Socket::getlocalhost(char*ip,size_t size)
{
struct sockaddr_in laddr;
socklen_t laddr_len=sizeof(laddr);
::getsockname(this->sockfd,(struct sockaddr*)&laddr,&laddr_len);
if (NULL==inet_ntop(AF_INET,&laddr.sin_addr.s_addr,ip,size)){
exit_on_error(errno,"failed to convert binary ip to string");
}
return laddr.sin_addr.s_addr;
}
void envia_msg() {
char l[100];
time_t t=time(NULL);
printf("Indique o local de encontro.\n");
fgets(l, 100, stdin);
l[strlen(l)-1] = '\0';
msg_id = msgget (96975, 0);
exit_on_error (msg_id, "Criação/Ligação");
strcpy(enviar_msg.dados.local_encontro, l);
enviar_msg.tipo = 1;
enviar_msg.dados.pid_passageiro = getpid();
enviar_msg.dados.data = t;
status = msgsnd( msg_id, &enviar_msg, sizeof(enviar_msg.dados), 0);
exit_on_error (status, "Erro no envio\n");
printf("Mensagem enviada!\n");
}
int leggitemp()
{
int fd;
int end;
char temp;
uint8_t buffer[2];
int16_t data;
double temperature;
// Open I2C device
if ((fd = open(device, O_RDWR)) < 0) exit_on_error ("Can't open I2C device");
// Set I2C slave address
if (ioctl(fd, I2C_SLAVE,I2C_ADDR) < 0) exit_on_error ("Can't talk to slave");
// Read from MAX6635 (from Power-up default register)
printf("Reading from MAX6635 at address 0x%.2X on %s\n", I2C_ADDR, device);
while(1)
{
if (read(fd,buffer,2) != 2) exit_on_error ("Failed to read from the i2c bus");
// printf("Data read from Power-up default register: 0x%.2X%.2X\n", buffer[0], buffer[1],buffer[2]);
data = buffer[0];
data = data << 8;
data = data | buffer[1];
data = data >> 3;
temperature = MAX6635_RES * data;
printf("Temperatura: %2.1f °C\n", temperature);
// end = scanf ("%c", &temp);
// printf("Premuto: ", end);
sleep(1);
}
close(fd);
return (0);
}
int main() {
int id=shmget(7345, 500*sizeof(Tpassageiro), 0);
exit_on_error(id, "Ligação");
printf("Ligado a memoria\n", id);
p = shmat (id, 0, 0 );
exit_on_null(p, "shmat");
validar_num();
envia_msg();
recebe_msg();
exit(0);
}
void initialize()
{
if (signal(SIGCHLD, SIG_IGN) == SIG_ERR)
{
exit_on_error("signal(SIGCHLD, SIG_IGN)\n");
}
if (!load_mysql_info())
{
exit_on_error("failed to load mysql account infomation\n");
}
if (false && drop_privileges() == false)
{
exit_on_error("failed to set privileges\n");
}
if (logger_start() == -1)
{
exit_on_error("Can't create a logger process\n");
}
}
Socket::Socket(int sockfd,int nonblocking)
{
if (sockfd<0){
this->sockfd=socket(AF_INET,SOCK_STREAM,0);
if(this->sockfd<0){
exit_on_error(errno,"failed to create socket");
}
if (nonblocking!=BLOCKING){
setNonBlocking(this->sockfd);
}
}else{
this->sockfd=sockfd;
}
}
int main(void)
{
initialize();
int server_socket = create_socket(PORT);
if (server_socket == -1)
{
exit_on_error("Can't create a socket\n");
}
printf("ready to serve!\n");
service_forever(server_socket, todolist);
return 0;
}
Socket Socket::accept(int nonblocking)
{
struct sockaddr_in addr;
socklen_t addr_length=sizeof(addr);
int conn_sockfd=::accept(this->sockfd,(struct sockaddr*)&addr,&addr_length);
if (conn_sockfd<0){
exit_on_error(errno,"failed to accept connection");
}
if(nonblocking!=BLOCKING){
setNonBlocking(conn_sockfd);
}
return Socket(conn_sockfd,nonblocking);
}
void acabou(int sinal) {
int id_mem = shmget(73452, 500 * sizeof(Tcondutor), 0);
exit_on_error(id_mem, "shmget");
Tcondutor *p = shmat(id_mem, 0, 0);
exit_on_null(p, "shmat");
int i;
for(i = 0; i < 500; i++) {
if(n == p[i].num_aluno) {
p[i].activo = 0;
printf("Fora de serviço\n");
printf("Saiu\n");
exit(0);
}
}
}
static void init(scicos_block *block)
{
char name[7];
int nch = GetNin(block);
int nt = nch+1;
MBX *mbx;
rtRegisterScope(Getint8OparPtrs(block,1), (char**)&block->oparptr[1], nch);
get_a_name(TargetMbxID,name);
mbx = (MBX *) RT_typed_named_mbx_init(0,0,name,(MBX_RTAI_SCOPE_SIZE/(nt*sizeof(double)))*(nt*sizeof(double)),FIFO_Q);
if(mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
*(block->work) = mbx;
}
static void init(scicos_block *block)
{
char ledName[20];
char name[7];
int nch = GetNin(block);
int * ipar = GetIparPtrs(block);
MBX *mbx;
par_getstr(ledName,ipar,1,ipar[0]);
rtRegisterLed(ledName,nch);
get_a_name(TargetLedMbxID,name);
mbx = (MBX *) RT_typed_named_mbx_init(0,0,name,MBX_RTAI_LED_SIZE/sizeof(unsigned int)*sizeof(unsigned int),FIFO_Q);
if(mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
*(block->work) = mbx;
}
int rtRegisterLogData(const char *name, int nrow, int ncol, int ID)
{
int i;
int nlogs;
rt_sched_lock();
nlogs = NLOGS++;
rt_sched_unlock();
if( nlogs >= MAX_LOGS ){
fprintf(stderr,"Error: Logs exceed %d \n",MAX_LOGS);
return -1;
}
if ( ID <= 0 )
fprintf(stderr,"Warning: logs ID must be positive\n");
for (i = 0; i < MAX_LOGS; i++) {
if (rtaiLogData[i].ID == ID)
fprintf(stderr,"Warning: two or more logs have the same ID(%d)\n",ID);
}
sprintf(rtaiLogData[nlogs].MBXname, "%s%d", TargetLogMbxID, nlogs);
rtaiLogData[nlogs].nrow = nrow;
rtaiLogData[nlogs].ncol = ncol;
rtaiLogData[nlogs].ID = ID;
rtaiLogData[nlogs].mbx= (MBX *) RT_typed_named_mbx_init(0,0,rtaiLogData[nlogs].MBXname,(MBX_RTAI_LOG_SIZE/((ncol*nrow)*sizeof(float)))*((ncol*nrow)*sizeof(float)),FIFO_Q);
if(rtaiLogData[nlogs].mbx == NULL) {
fprintf(stderr, "Cannot init mailbox\n");
exit_on_error();
}
strncpyz(rtaiLogData[nlogs].name, name, MAX_NAME_SIZE);
return 0;
}
/* fetch a new db tree on root */
static int fetch_db_tree(DB_NODE **p_root,struct mpd_connection *conn)
{
if (*p_root)
return 1;
/* create root */
DB_NODE *root = (DB_NODE*)malloc(sizeof(DB_NODE));
root->type = DB_DIRECTORY;
/* use calloc for root->uri to ease free_db_tree() */
root->uri = (char *)calloc(2,sizeof(char));
strncpy(root->uri,"/",1);
root->rating = 0;
root->duration = 0;
root->p = NULL;
root->s = NULL;
root->c = NULL;
root->num_c = 0;
/* set top node */
DB_NODE *top = root;
if (!mpd_send_list_all_meta(conn,"/")) {
clear_or_exit_on_error(conn);
return 1;
}
/* add nodes recursively */
struct mpd_entity *entity;
while ((entity = mpd_recv_entity(conn))) {
DB_NODE *node = (DB_NODE*)malloc(sizeof(DB_NODE));
const char *name = NULL;
switch (mpd_entity_get_type(entity)) {
case MPD_ENTITY_TYPE_DIRECTORY:
node->type = DB_DIRECTORY;
name = mpd_directory_get_path(mpd_entity_get_directory(entity));
assert (name && strlen(name));
node->uri = (char *)calloc(strlen(name)+1,sizeof(char));
strncpy(node->uri,name,strlen(name));
node->rating = 0;
node->duration = 0;
break;
case MPD_ENTITY_TYPE_SONG:
node->type = DB_SONG;
name = mpd_song_get_uri(mpd_entity_get_song(entity));
assert (name && strlen(name));
node->uri = (char *)calloc(strlen(name)+1,sizeof(char));
strncpy(node->uri,name,strlen(name));
node->rating = 0;
node->duration = mpd_song_get_duration(mpd_entity_get_song(entity));
break;
case MPD_ENTITY_TYPE_PLAYLIST:
node->type = DB_PLAYLIST;
name = mpd_playlist_get_path(mpd_entity_get_playlist(entity));
assert (name && strlen(name));
node->uri = (char *)calloc(strlen(name)+1,sizeof(char));
strncpy(node->uri,name,strlen(name));
node->rating = 0;
node->duration = 0;
break;
case MPD_ENTITY_TYPE_UNKNOWN:
break;
}
/* backtrace top until it's parent of node */
while (top != root && !(strstr(node->uri,top->uri) && node->uri[strlen(top->uri)] == '/'))
top = top->p;
/* if current top already has chlidren */
if (top->c) {
DB_NODE *node2 = top->c;
/* find the last child */
while (node2->s)
node2 = node2->s;
node2->s = node;
node->p = node2->p;
node->p->num_c++;
} else {
top->c = node;
node->p = top;
node->p->num_c++;
}
/* no child, no next sibling */
node->c = NULL;
node->s = NULL;
node->num_c = 0;
/* update top node */
if (node->type == DB_DIRECTORY)
top = node;
mpd_entity_free(entity);
}
if (mpd_connection_get_error(conn) == MPD_ERROR_SUCCESS)
mpd_response_finish(conn);
else if (!mpd_connection_clear_error(conn))
exit_on_error(conn);
*p_root = root;
return 0;
}
static void init(scicos_block *block)
{
struct ADCOMDev * comdev = (struct ADCOMDev *) malloc(sizeof(struct ADCOMDev));
*block->work = (void *)comdev;
char devName[15];
char board[50];
comedi_krange krange;
comdev->channel = block->ipar[0];
comdev->range = block->ipar[1];
comdev->aref = block->ipar[2];
comdev->index = block->ipar[3];
sprintf(devName,"/dev/comedi%d", comdev->index);
if (!ComediDev[comdev->index]) {
comdev->dev = comedi_open(devName);
if (!(comdev->dev)) {
fprintf(stderr, "COMEDI %s open failed\n", devName);
exit_on_error();
return;
}
rt_comedi_get_board_name(comdev->dev, board);
printf("COMEDI %s (%s) opened.\n\n", devName, board);
ComediDev[comdev->index] = comdev->dev;
} else
comdev->dev = ComediDev[comdev->index];
if ((comdev->subdev = comedi_find_subdevice_by_type(comdev->dev, COMEDI_SUBD_AI, 0)) < 0) {
fprintf(stderr, "Comedi find_subdevice failed (No analog input)\n");
comedi_close(comdev->dev);
exit_on_error();
return;
}
if (!ComediDev_AIInUse[comdev->index] && comedi_lock(comdev->dev, comdev->subdev) < 0) {
fprintf(stderr, "Comedi lock failed for subdevice %d\n", comdev->subdev);
comedi_close(comdev->dev);
exit_on_error();
return;
}
if (comdev->channel >= comedi_get_n_channels(comdev->dev, comdev->subdev)) {
fprintf(stderr, "Comedi channel not available for subdevice %d\n", comdev->subdev);
comedi_unlock(comdev->dev, comdev->subdev);
comedi_close(comdev->dev);
exit_on_error();
return;
}
if ((comedi_get_krange(comdev->dev, comdev->subdev, comdev->channel, comdev->range, &krange)) < 0) {
fprintf(stderr, "Comedi get_range failed for subdevice %d\n", comdev->subdev);
comedi_unlock(comdev->dev, comdev->subdev);
comedi_close(comdev->dev);
exit_on_error();
return;
}
#ifdef SOFTCALIB
int flags;
if ((flags = comedi_get_subdevice_flags(comdev->dev, comdev->subdev)) < 0) {
fprintf(stderr, "Comedi get_subdevice_flags failed for subdevice %d\n", comdev->subdev);
} else {
if (flags & SDF_SOFT_CALIBRATED) {/* board uses software calibration */
if ((comdev->use_softcal = get_softcal_coef(devName, comdev->subdev,
comdev->channel, comdev->range, 0, comdev->coefficients)) == 0)
fprintf(stderr, "No software calibration found for AI Channel %d\n",comdev->channel);
}
}
#endif
ComediDev_InUse[comdev->index]++;
ComediDev_AIInUse[comdev->index]++;
comdev->maxdata = comedi_get_maxdata(comdev->dev, comdev->subdev, comdev->channel);
comdev->range_min = (double)(krange.min)*1.e-6;
comdev->range_max = (double)(krange.max)*1.e-6;
printf("AI Channel %d - Range : %1.2f [V] - %1.2f [V]%s\n\n", comdev->channel,
comdev->range_min, comdev->range_max, (comdev->use_softcal)?" Software calibration used":"");
}
void down(int id) {
struct sembuf DOWN = {0, -1, 0};
int semStatus = semop(id, &DOWN, 1);
exit_on_error(semStatus, "DOWN");
}
void up(int id) {
struct sembuf UP = {0, 1, 0};
int semStatus = semop(id, &UP, 1);
exit_on_error(semStatus, "UP");
}
main() {
signal(SIGINT,acabou);
// ligar ao semáforo
int semid = semget(73452, 1, 0);
exit_on_error(semid, "semget");
// ligar à memória partilhada
int id_mem = shmget(73452, 500 * sizeof(Tcondutor), 0);
exit_on_error(id_mem, "shmget");
printf("Ligado à memória\n");
// Erro do ponteiro
Tcondutor *p = shmat(id_mem, 0, 0);
exit_on_null(p, "shmat");
// input do número do condutor
char num_aluno[100];
printf("Número de condutor: ");
fgets(num_aluno, 100, stdin);
n = atoi (num_aluno);
// percorrer a memória partilhada de 500 pos
// se o número da memória é igual ao inserido
int i;
printf("Número inserido: %d\n", n);
down(semid); // down do semáforo
for(i = 0; i < 500; i++) {
if( n == p[i].num_aluno) {
p[i].activo = 1; // ativar o condutor
printf("Condutor ativo\n");
p[i].disponivel_desde = time(NULL); // data atual
p[i].PID = getpid(); // o seu PID
printf("Já és condutor: %s\nA tua matrícula é: %s\n", p[i].nome,p[i].matricula);
break;
}
}
up(semid); // up do semáforo
// ligar à fila de mensagens
int id_msg = msgget(96975, 0);
exit_on_error(id_msg, "Erro no msgget");
printf("Ligado à fila\n");
// ao receber a mensagem 2
MsgCorrida m;
while(1) {
// recebe mensagem 2 do tipo pid
int status = msgrcv(id_msg, &m, sizeof(m.dados), getpid(), 0);
exit_on_error(status, "Erro ao receber mensagem 2");
printf("Mensagem 2 recebida\n");
// imprimir o pid do passageiro
printf("O PID do passageiro é: %d\n", m.dados.pid_passageiro);
// enviar a mensagem 3
char local[100];
m.tipo = m.dados.pid_passageiro; // tipo com o PID do passageiro
m.dados.pid_condutor = getpid(); // PID do condutor com o meu PID
printf("Meu PID: %d\n", getpid()); // confirmar o meu pid com o Admin e o Passageiro
printf("Minha localização: ");
fgets(local, 100, stdin); // minha localização
local[ strlen(local) - 1 ] = '\0';
status = msgsnd(id_msg, &m, sizeof(m.dados), 0);
exit_on_error(status, "Erro ao enviar mensagem 3");
printf("Mensagem 3 enviada\n");
// espera de 1-20s
srand(time(NULL));
sleep(rand() %20 + 1);
// pede o valor da corrida
char val[10];
printf("Valor da corrida: ");
fgets(val, 10, stdin);
val[ strlen(val) - 1 ] = '\0';
// enviar mensagem 4 com recibo
m.tipo = 1;
m.dados.pid_passageiro = m.dados.pid_passageiro;
strcpy(m.dados.local_encontro, local);
m.dados.valor = atof(val);
status = msgsnd(id_msg, &m, sizeof(m.dados), 0);
exit_on_error(status, "Erro ao enviar mensagem 4");
printf("Mensagem 4 enviada\n");
}
acabou(SIGINT); // Sinal do Ctrl C
}
