Backspace character gets added in FIFO - c

Question

I am learning about FIFOs and have written an iterative server that takes requests from multiple clients. The clients request for a file by writing to the server's well known fifo. The server reads from it's FIFO and puts the contents of the requested file in the a new FIFO which the client reads from. I run the server. When I run the client for the first time, things work as expected and the client reads the contents of the file. When I run the client for the 2nd time, the message from the client gets prefixed with a backspace character. I have no idea where this backspace is coming from. Any ideas?
This is the server code:
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<sys/types.h>
#include<fcntl.h>
#include<stdlib.h>
#include"fifo.h"
#define SERVFIFO "/tmp/fifo.serv"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
int main(int argc, char** argv) {
int readfifo, dummywrite, filefd, writefd, n;
int clientpid;
char buff[MAXLINE], *spaceptr, fifoname[MAXLINE];
if (mkfifo(SERVFIFO, FILE_MODE) < 0 && errno != EEXIST) {
printf("Can't create %s", SERVFIFO);
}
readfifo = open(SERVFIFO, O_RDONLY, 0);
dummywrite = open(SERVFIFO, O_WRONLY, 0);
while ((n = Readline(readfifo, buff, MAXLINE)) > 0) {
printf("Read data from the fifo:%s and the length is:%d and the character is:%d\n", buff, strlen(buff), buff[0]);
if (buff[n - 1] == '\n') {
n--;
printf("I am also omitting the newline\n");
}
buff[n] = '\0';
printf("Buff just after read is:%s and length is %d", buff, strlen(buff));
if ((spaceptr = strchr(buff, ' ')) == NULL) {
printf("Bad request from client");
continue;
}
printf("Found the space:%c\n", *(spaceptr + 1));
*spaceptr++ = '\0';
printf("The value of buffer now is:%s and the length of buffer is:%d and the culprit is %d\n", buff, strlen(buff), *(buff + 0));
clientpid = atol(buff);
printf("The client pid is %ld\n", clientpid);
snprintf(fifoname, sizeof(fifoname), "/tmp/fifoname.%ld", clientpid);
if (mkfifo(fifoname, FILE_MODE) < 0 && errno != EEXIST) {
perror("Can't create the fifo");
continue;
}
printf("Successfully created fifo %s for client\n", fifoname);
if ((writefd = open(fifoname, O_WRONLY, 0)) < 0) {
printf("Cannot open %s", fifoname);
continue;
}
if ((filefd = open(spaceptr, O_RDONLY, 0)) < 0) {
printf("Error opening file\n");
continue;
}
else {
while ((n = read(filefd, buff, MAXLINE))) {
write(writefd, buff, n);
}
close(filefd);
close(writefd);
}
}
}
This is the client code:
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
#include<sys/types.h>
#include<fcntl.h>
#include<stdlib.h>
#define SERVER_FIFO "/tmp/fifo.serv"
#define MAXLINE 100
#define MSG "%ld sup.c"
#define READFIFO "/tmp/fifoname.%ld"
int main(int argc, char** argv) {
int writefifo, readfifo, n;
char buff[MAXLINE];
pid_t self_pid = getpid();
printf("Started client with PID:%ld\n", self_pid);
writefifo = open(SERVER_FIFO, O_WRONLY, 0);
snprintf(buff, sizeof(buff), MSG, self_pid);
printf("The message to be written to the server is:%s and the length of the message is %d\n", buff, strlen(buff));
if ((n = write(writefifo, buff, sizeof(buff))) != sizeof(buff)) {
perror("Unable to write to server fifo");
exit(0);
}
printf("Message written to the server; Waiting to read contents\n");
snprintf(buff, sizeof(buff), READFIFO, self_pid);
readfifo = open(buff, O_RDONLY, 0);
while ((n = read(readfifo, buff, MAXLINE))) {
write(STDOUT_FILENO, buff, n);
}
close(readfifo);
close(writefifo);
unlink(buff);
}

Answer 1

Maybe this is a chopped up version of your real program because this doesn't display the behavior you describe. A couple of things:
(1) In the server
readfifo = open(SERVFIFO, O_RDONLY, 0);
dummywrite = open(SERVFIFO, O_WRONLY, 0);
I assume you knew that if you open the well-known fifo without something on the other end the open will block. This still blocks on the O_RONLY open because in normal circumstances you will run the server before any clients. If you want to avoid blocking just open it once as read/write.
(2) In the client
snprintf(buff, sizeof(buff), READFIFO, self_pid);
readfifo = open(buff, O_RDONLY, 0);
This is not doing what you think. Your client writes a message to the server's fifo and the server creates the client's fifo with mkfifo. Since the client runs first that fifo is not going to exist when you do this open. You are, in effect, trying to open a plain file (that doesn't exist) as READ ONLY. You can't read a file that doesn't exist so this open fails but since you don't check the open status you don't know it.
(3) unlink your FIFOs when you are done with them.