Sending a process id from client to server - c

Question

My task is to write a client program that writes a struct with a privateFIFO name (FIFO_XXXX, where XXXX is the pid that we get from the getpid( ) function) to the server. Then, have the server read the privateFIFO name and write a message back to the client. i.e., Read the message and print it on the client side. I am having trouble sending the FIFO_XXXX to the server program and also writing a message from the server back to client.
client code:
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int main (void)
{
struct values
{
char privateFIFO[14];
int intbuff;
}input;
int fda; // common FIFO to read to write to server
int fdb; // Private FIFO to read from server
int clientID;
int retbuff;
char temp[14];
clientID = getpid();
strcpy(input.privateFIFO, "FIFO_");
sprintf(temp, "%d", clientID);
strcat(input.privateFIFO, temp);
printf("\nFIFO name is %s", input.privateFIFO);
// Open common FIFO to write to server
if((fda=open("FIFO_to_server", O_WRONLY))<0)
printf("cant open fifo to write");
write(fda, &input, sizeof(input)); // write the struct to the server
close(fda);
// Open private FIFO to read
if((fdb=open(input.privateFIFO, O_RDONLY))<0)
read(fdb, &retbuff, sizeof(retbuff));
printf("\nAll done!\n");
close(fdb);
}
server code:
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
struct values
{
char privateFIFO[14];
int intbuff;
}input;
int main (void)
{
int fda; //common FIFO to read from client
int fdb; //private FIFO to write to client
int retbuff;
int output;
// create the common FIFO
if ((mkfifo("FIFO_to_server",0666)<0 && errno != EEXIST))
{
perror("cant create FIFO_to_server");
exit(-1);
}
// open the common FIFO
if((fda=open("FIFO_to_server", O_RDONLY))<0)
printf("cant open fifo to write");
output = read(fda, &input, sizeof(input));
// create the private FIFO
if ((mkfifo(input.privateFIFO, 0666)<0 && errno != EEXIST))
{
perror("cant create privateFIFO_to_server");
exit(-1);
}
printf("Private FIFO received from the client and sent back from server is: %d", output);
//open private FIFO to write to client
if((fdb=open(input.privateFIFO, O_WRONLY))<0)
printf("cant open fifo to read");
write(fdb, &retbuff, sizeof(retbuff));
close(fda);
unlink("FIFO_to_server");
close(fdb);
unlink(input.privateFIFO);
}

Answer 1

Use IPC message Queues. It better and simple. Indeed, This mechanism manages synchronization between read and write operations, concurrent access, ...:
The Writer Process:
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
// structure for message queue
struct mesg_buffer {
long mesg_type;
char mesg_text[100];
} message;
int main()
{
key_t QueueKey;
int msgid;
// ftok : generate a unique OPC key
QueueKey = ftok("FIFO_XXXX", 65);
// msgget creates a message queue and returns identifier
msgid = msgget(QueueKey, 0666 | IPC_CREAT);
// Sending Data
message.mesg_type = 1;
printf("Write Data : ");
gets(message.mesg_text);
// msgsnd : Send message to the queue
msgsnd(msgid, &message, sizeof(message), 0);
// display the message
printf("Data send is : %s \n", message.mesg_text);
return 0;
}
The Reader Process:
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
// structure for message queue
struct mesg_buffer {
long mesg_type;
char mesg_text[100];
} message;
int main()
{
key_t QueueKey;
int msgid;
// ftok to generate unique key
QueueKey = ftok("FIFO_XXXX", 65);
// msgget creates a message queue and returns identifier
msgid = msgget(QueueKey, 0666 | IPC_CREAT);
// msgrcv to receive message
msgrcv(msgid, &message, sizeof(message), 1, 0);
// display the message
printf("Data Received is : %s \n", message.mesg_text);
// IPC_RMID : destroy the message queue
msgctl(msgid, IPC_RMID, NULL);
return 0;
}
Remarque:
Be aware that a process can be both writer and reader. To do this, two message queues must be created for each process. the first allows for example to receive, the second to write. If you really want to separate read / write spaces for each process.