read() stdout from child in infinite loop - c

Question

I am forking a child which will run an infinite loop and do some things. Text will be printed to stdout with printf when the child is in a 'ready' status. I am redirecting the child's stdout with a pipe so the parent can see it. When this text prints I would like the parent to be unblocked.
The problem seems to be that the read() call will stay blocked even after the printf() call.
Here is some sample code I am working with:
parent:
#include <stdio.h>
#include <unistd.h>
int main()
{
int fd[2];
pipe(fd);
char buffer[256];
switch(fork())
{
case -1:
printf("fork failed\n");
_exit(1);
case 0:
printf("Starting progtest...\n");
close(fd[0]);
dup2(fd[1], STDOUT_FILENO);
close(fd[1]);
execl("progtest", "progtest", NULL);
perror("exec failed");
_exit(1);
}
close(fd[1]);
read(fd[0], &buffer, sizeof(buffer));
close(fd[0]);
printf("buffer: %s\n", buffer);
}
child:
#include <stdio.h>
int main()
{
printf("ready\n");
while(1)
{
// stuff happens here
}
return 0;
}
I'm pretty sure the pipe is set up correctly. If I remove the infinite loop the parent will unblock and print "ready".
Is there any way I can use read() while the child is still running? Am I going about this incorrectly by using pipes? I need to do this twice with two different status messages.

Answer 1

It seems you are trying to perform inter process communication (IPC). There is no 1 to 1 communication syncronization with reads/write, the parent or child can write as much as they want to the file descriptor at once, and since they are running asynchronously you must ensure you are ready to deal with this.
Normally this is done by sending a header with each message that is a fixed size, containing the length of the payload. For example:
protocol header
#include <stdint.h>
struct Message
{
uint8_t length; // assuming a maximum message length of 255 bytes, adjust as needed.
};
You can define extra things here, usually it's a good idea to include the version, perhaps a sequence ID, etc. It is important that if you are communicating across a network, this header's size is absolute on all hardware implementations, so the use of stdint defines is required to ensure compatibility between architectures. It is also a good idea to ensure the endian is consistent if working across architectures also.
sending a message
const char data[] = "example";
// create a buffer large enough to pack the header and data into it
const uint8_t len = strlen(data) + 1;
char buffer[sizeof(struct Message) + len];
// populate the header
struct Message *m = (struct Message *)buffer;
m->length = len;
// copy in the payload after the header
memcpy(buffer + sizeof(struct Message), data, len);
// write the packed buffer
write(fd, buffer, sizeof(struct Message) + len);
reading a message
struct Message m;
if (read(fd, &m, sizeof(struct Message)) != sizeof(struct Message))
{
fprintf(stderr, "Failed to read the header\n");
exit(1);
}
// If required perform validation on the header here
ssize_t offset = 0;
char data[m.length];
while(offset < m.length)
{
ssize_t r = read(fd, data + offset, m.length - offset);
if (r < 0)
{
fprintf(stderr, "Read of message body failed\n");
exit(1);
}
if (r == 0)
{
fprintf(stderr, "The sender closed the connection\n");
exit(1);
}
offset += r;
}
printf("Message Length: %u, Message Data: %s\n", m.length, data);
The while loop to read is requires as the data may have been split up into chunks if the sender exceeded the write buffer and is now blocking waiting to write the remainder. The header can also be split across chunks and ideally should also be read using the same technique, but for brevity I have left this out.