Synchronizing pipe access for two way read/write - c

Question

I have a legacy piece of code where I am delegating certain logic to a child process. The requirement is that parent writes to the pipe and the child reads on it. After reading, child writes something to a new pipe and parent reads from it.
In the code below, function send() is called periodically by a dedicated thread in the parent process.
LaunchWorker() ensures that the child process is forked only on the first call to it.
1) I am not being able to figure out how to close the read and write ends of the two descriptors so that the old data written to the pipe is flushed on every write.
2) Also is calling pipe() twice needed for the two descriptors?
Any input to make this code work will be greatly appreciated.
Thanks!
typedef struct
{
WebClient* wc; // user defined class
string url;
string data;
size_t dataLen;
DownloadObserver* downloadCallback; // user defined class
string* token;
}Payload;
PayLoad pl;
static pid_t worker_pid = 0;
int fd1[2];
int fd2[2];
bool done = false;
void LaunchWorker()
{
if (worker_pid != 0)
{
return;
}
pipe(fd1);
pipe(fd2);
worker_pid = fork();
}
void send()
{
//populate pl;
LaunchWorker();
if (worker_pid == 0)
{
while(true)
{
close(fd1[1]);
close(fd2[0]);
int cr = read(fd1[0], &pl, sizeof(Payload));
if (cr > 0)
{
// Upload some data to a remote http endpoint - uses libcurl
//if upload success, done = true
int cw = write(fd2[1], &done, sizeof(bool));
if (cw > 0)
{
// success
}
else
{
// failure
}
}
else
{
// failure
}
}
}
else if (workper_pid > 0)
{
close(fd1[0]);
close(fd2[1]);
int pw = write(fd1[1], &pl, sizeof(Payload));
if (pw > 0)
{
int pr = read(fd2[0], &done, sizeof(bool));
if (pr > 0)
{
// do something with value read
}
else
{
// failure
}
}
else
{
failure
}
}
}

Answer 1

Firstly, you need to close the unused ends of the pipe immediately after the fork, so the parent should close the read end of fd1 and the write end of fd2 and the child should close the write end of fd1 and the read end of fd2. If you don't do this, the pipes will not be closed when you finish.
Then, when you want to stop everything, I would have the writer of each pipe close the write end of the pipe. i.e.
parent closes write end of fd1
child reads eof on fd1 and closes it
child closes the write end of fd2
parent reads eof on fd2 and closes it.
Or the other way around if the child initiates shut down.
Finally, the parent process should issue the wait system call to collect the exit result of the child.
And yes, you do need two pipes. Pipes are one way.