How to synchronize read and write in the pipe in C? - c

Question

Complete C beginner here.
I am trying to write some strings from the child process and read the strings in the parent process. But it looks like I haven't implemented the read and write properly. So my parent just reads the first string it gets. Below is my code
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <stdbool.h>
#include <ctype.h>
/* Function declaration */
bool isNumeric(char* str);
int main(int argc, char* argv[]) {
// Check if input is recieved
if (argc == 1) {
printf("Input not received!\n");
exit(1);
}
// Check if the input is an int
if (isNumeric(argv[1]) == 0) {
printf("Input is not an Integer!\n");
exit(1);
}
// Initialize pipe
int fd[2];
pid_t childpid;
pipe(fd);
childpid = fork();
if (childpid == -1) {
printf("fork failed");
exit(1);
}
else if (childpid > 0) {
char string[100];
close(fd[1]);
printf("PARENT START\n");
while (read(fd[0], string, sizeof(string)) > 0) {
printf("%s\n", string);
}
printf("PARENT END\n");
close(fd[0]);
}
else {
close(fd[0]);
char string[100];
string[0] = '\0';
printf("CHILD START\n");
for (int i = 0; i < 5; i++) {
sprintf(string, "%d", i);
write(fd[1], string, strlen(string)+1);
}
printf("CHILD END\n");
close(fd[1]);
exit(0);
}
}
The output is just
PARENT START
CHILD START
CHILD END
0
PARENT END
My expected output is
PARENT START
CHILD START
CHILD END
0
1
2
3
4
PARENT END
I spent hours trying to synchronize the process, but I couldn't figure out how to fix the problem.

Answer 1

You ignore the return value of read, so the call to printf stops at the first zero byte. You send the messages delimited by zero bytes. Where's the code to find the zero bytes in the received data and extract the messages from the pipe?
You have code to send a message. It separates the messages with a terminating zero byte. Where's the code to receive a message, searching the incoming stream of data for zero bytes and passing on the data prior to it as a message?
Here's some ugly, inefficient code to receive a message. It checks the incoming stream of bytes for the terminating zero byte. It returns 0 on end of file, negative on error and 1 on success.:
int recvMessage (int fd, char* buf, int len)
{
while (len > 0)
{
int r = read(fd, buf, 1);
if (r <= 0) // pipe closed or error
return r;
if (*buf == 0) // we received a terminating zero byte
return 1;
buf++;
len--;
}
return -2; // message larger than buffer
}

Answer 2

Five things you need to learn:
sizeof(string) doesn't return the length of a string, much less one you haven't read in yet! It always returns 100 in this case.
write is not guaranteed to write the number of bytes provided as its third argument. You need to call write repeatedly until the entire buffer you want to write has been written.
read is not guaranteed to read the number of bytes provided as its third argument. You need to call read repeatedly until you've read the desired number of bytes.
In this case, you don't want to read a specific number of bytes. You want to read until one of the character you've read is a NUL.
Unless you pass 1 for read's third parameter, you might end up reading too much. This is not a problem; you just need to factor that in the next time you read.
Writer
Replace
write(fd[1], string, strlen(string)+1);
with
char *p = string;
size_t n = strlen(string) + 1;
while (n > 0) {
ssize_t rv = write(fd[1], p, n);
if (rv == -1) {
perror("write");
exit(1);
}
n -= rv;
p += rv;
}
Reader
Replace
char string[100];
while (read(fd[0], string, sizeof(string)) > 0) {
...
}
with
#define BLOCK_SIZE 100
char *string = NULL;
size_t size = 0;
size_t len = 0;
while (1) {
// Increase the buffer size if necessary.
if (size < len + BLOCK_SIZE) {
char *tmp = realloc(string, len + BLOCK_SIZE);
if (!tmp) {
perror("realloc");
exit(1);
}
string = tmp;
}
// Read from the pipe.
ssize_t rv = read(fd[0], string+len, BLOCK_SIZE);
if (rv == -1) {
perror("read");
exit(1);
}
// Handle EOF
if (rv == 0)
break;
len += rv;
// Check if we've received a message (or even more than one).
while (1) {
for (size_t i=0; i<len; ++i) {
if (!string[i]) {
// Handle a message.
...
len -= i+1;
memmove(string, string+i+1, len);
break;
}
}
}
}
// Handle a partial message.
if (len) {
fprintf(stderr, "Premature EOF");
exit(1);
}
free(string);