How to create an unique Named Pipe for each Client - c

Question

I have a typical Client-Server architecture where the Server is constantly reading from the pipe to see if any Client has sent something. Usually what is done is that there's also a named pipe so that the Server is able to also send whatever it needs to the Client.
The problem I have is that I need to send a specific message to specific Clients, according to my needs. For example, at the moment, with Client A and Client B, if Client A sends a message through the pipe with "process", I need the Server to send back a reply with "OK" to Client A, but what happens is that a random one gets it (not really sure what happens here, but I assume that once one of the Client reads what's in the pipe, the other one won't be able to read it anymore).
How am I able to create a Named Pipe for each Client, so that the Server can send a specific message to a specific Client? Below is the code that I have:
Client.c
#define FIFO_FILE_1 "../tmp/fifo"
#define FIFO_FILE_2 "../tmp/fifo2"
int main(int argc, char *argv[]){
/*if(mkfifo("fif", 0666) < 0){
perror("mkfifo");
}*/
int client_to_server;
int server_to_client;
if((client_to_server = open(FIFO_FILE_1, O_WRONLY))<0){
perror("open fifo");
exit(1);
}
if((server_to_client = open(FIFO_FILE_2, O_RDONLY))<0){
perror("open fifo");
exit(1);
}
if(argc>2){
write(client_to_server, "process\n", 9);
}
int bytes_read = 0;
char buf[1024];
while(1){
while((bytes_read = read(server_to_client, buf, 1024)) > 0){
write(1,"Received",7);
}
}
close(client_to_server);
close(server_to_client);
unlink(FIFO_FILE_1);
unlink(FIFO_FILE_2);
return 0;
}
Server.c
#define FIFO_FILE_1 "../tmp/fifo"
#define FIFO_FILE_2 "../tmp/fifo2"
int main(int argc, char *argv[]){
// Create named pipes
if(mkfifo(FIFO_FILE_1, 0666) < 0){
perror("mkfifo");
}
if(mkfifo(FIFO_FILE_2, 0666) < 0){
perror("mkfifo");
}
int client_to_server;
int server_to_client;
if((client_to_server = open(FIFO_FILE_1, O_RDONLY))<0){
perror("open fifo");
exit(1);
}
if((server_to_client = open(FIFO_FILE_2, O_WRONLY))<0){
perror("open fifo");
exit(1);
}
char buf[1024];
char bufaux[1024];
while(1){
int n = readCommand(client_to_server, buf); //Just reads until \n, shouldn't matter for the problem
if (n<=0)
continue;
strcpy(bufaux,buf);
char * token = first_arg(bufaux); //Returns the token until it hits a space, in this case it will return "process".
if(strcmp(token,"process")==0){
write(server_to_client,"OK", 3);
}
close(client_to_server);
close(server_to_client);
unlink(FIFO_FILE_1);
unlink(FIFO_FILE_2);
return 0;
}
There's aditional functions that aren't shown, that are simply used to parse whatever comes through the Pipe from the Client. Just assume that strcmp(token,"process")==0 will always be true.
How and when would I create a Pipe for each Client? My idea was to send some sort of identifier whenever the Client sends the first message, that would then be used to write a message to that same Client.
Obviously the problem is much more complex, there's data in memory that is what's going to be sent into each specific Client, but as an example, consider I just need to send an "OK". Also, I can't use sockets.

Answer 1

A simple way to solve your problem is to let the clients create the pipes for the return messages.
You can use the PID of the process as part of the name to make it unique per process.
Then in the clients communication with the server, it always include the PID so the server knows which pipe to write the response to.