How to implement a logger function as a child process in c? - c

Question

I've been struggling to implement a logger function in C that records when messages are written to a text file using communication via a pipe. In the simplified implementation below I'm trying to write messages from the parent process and print them from the child process without the file I/O but I don't ever get the child printfs.
In my main function, I spawn the logger by calling spawn_logger which forks a child process (log_message) that will run continuously. The parent process returns to the main, starts to send messages through the pipe, and finally kills the child process.
The main function:
int main(void){
spawn_logger();
char wmsg[] = "Greetings";
send_message(wmsg);
strcpy(wmsg, "Hello");
send_message(wmsg);
kill_child();
return 0;
}
The spawn_logger function:
// global vars
pid_t pid;
int fd[2];
int spawn_logger() {
if (pipe(fd) == -1) {
printf("Pipe failed\n");
return -1;
}
pid = fork();
if (pid < 0) { // fork error
printf("fork failed");
return -1;
}
if (pid > 0) { // parent process
close(fd[READ_END]);
return 0; // return to main
}
// child process
// spawn the receiver process
log_message();
// the receiver process will never reach this point
return 0;
}
The send_message function:
int send_message(char message[]){
// do something with the message
// e.g. write in a file
printf("Message by parent sent: %s \n", message);
// write the message to logger process
int n = strlen(message) + 1;
write(fd[WRITE_END], &n, sizeof(int));
write(fd[WRITE_END], &message, sizeof(char) * strlen(message));
return 0;
}
The log_message and kill_child functions:
// global vars
extern pid_t pid;
extern int fd[2];
int log_message(){
//child process
// will read from the pipe every time the parent process writes to it
close(fd[WRITE_END]);
int n;
char *message;
// read messages until parent process closes the pipe
while (read(fd[READ_END], &n, sizeof(int)) > 0) {
message = malloc(sizeof(char) * n);
read(fd[READ_END], &message, sizeof(char) * n);
printf("Message by logger received: %s \n", message);
}
close(fd[READ_END]);
exit(0);
}
int kill_child(){
close(fd[WRITE_END]);
kill(pid, SIGKILL);
return 0;
}
When I run the program all I get are the print messages printf("Message by parent sent: %s \n", message); and I think the problem comes from log_message.
I thought the child process would remain stuck in the while loop trying to read the buffer as long as the parent's write end is open but while debugging the child process in Clion I noticed that once it reaches the first line the program just stops. When I debug the parent process it just goes over all the writing instructions without any broken pipe errors.
How can I fix that? Thanks in advance for the help.

Answer 1

You don't send the null-terminator.
But the value of n includes the null-terminator.
This means that the child process will wait forever for the null-terminator that never comes.
There's an even worse problem: You use &message when sending the message.
This is worse, because message is not the array but a pointer to the first character of the array. So &message is a pointer to the pointer. So you write the pointer itself, plus some indeterminate data.
Drop the pointer-to operator & from that call to write:
write(fd[WRITE_END], message, n);
Note that I also updated the above to send the null-terminator.

Answer 2

After solving the issues pointed out by by andrew-henle and some-programmer-dude, I found the following solution to work the best.
int log_message(){ //child process
close(fd[WRITE_END]);
char buffer[BUFSIZ];
char message[BUFSIZ];
FILE * log;
log = fopen("gateway.log", "a");
// read is looping over every byte in the pipe
// and is a blocking call until there's something to read
// or the pipe is closed
while(read( fd[READ_END], buffer, BUFSIZ) > 0 ) {
int j = 0;
memset(message, ' ', BUFSIZ); // make sure its empty
// look for null terminator in buffer
for(int i= 0; i < BUFSIZ; i++){
// copy every byte until the null terminator
message[i-j] = buffer[i];
if(buffer[i] == '\0'){
if(message[0] != '\0'){
printf("Message by logger received: %s \n", message);
}
buffer[i] = ' ';
// reset j such that i - j is 0 for the next char of the buffer
j = i + 1;
}
}
memset(message, ' ', BUFSIZ); // clear message
}
fclose(log); // for now, we'll open and close the log file every time
close(fd[READ_END]);
kill(getpid(), SIGSEGV);
return 0;