Sending messages using pipe - C - c

Question

I want to make NO_PROC processes, such that every process reads messages from its parent, and then writes those messages and one more message to its child, except in the case of the last process which writes its messages to stdout. So the i'th process will receive i-1 messages and will send to child i messages. I must use pipe to communication between processes. I wrote code but something is wrong and I can't find any bug :/. When NO_PROC = 5 I want the output to look like 4 lines with "my message", but in output I have one line: "my message" and 3 empty lines, like 3 messages are empty string :/. Note, err.h is my library which gives me function syserr() when something went wrong.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "err.h"
#define NO_PROC 5
#define BUF_SIZE 20
char message[] = "my message";
int parent;
char buf[BUF_SIZE];
int main()
{
for (int i = 0; i < NO_PROC; ++i) {
int pipe_dsc[2], buf_len;
if (pipe(pipe_dsc) == -1)
syserr("Error in pipe\n");
pid_t pid = fork();
if (pid == -1)
syserr("Error in fork\n");
else if (pid == 0)
parent = pipe_dsc[0];
else {
for (int j = 0; j < i; ++j) {
if ((buf_len = read(parent, buf, BUF_SIZE - 1)) == -1)
syserr("Error in read\n");
buf[buf_len < BUF_SIZE - 1 ? buf_len : BUF_SIZE - 1] = '\0';
if (i == NO_PROC - 1)
printf("%s\n", buf);
else if (write(pipe_dsc[1], buf, sizeof(buf)) != sizeof(buf))
syserr("Error in write\n");
}
if (i < NO_PROC - 1 && write(pipe_dsc[1], message, sizeof(message)) != sizeof(message))
syserr("Error in write\n");
if (wait(0) == -1)
syserr("Error in wait\n");
return 0;
}
}
}

Answer 1

I think your over complicating it and/or using the wrong approach. You don't have to send i messages to the ith process. Since the ith process is a copy (fork) of the i-1th process it has already received i-1 messages, and just needs one more. It's a rather symmetrical (and academic) problem.
Here is an example (robust error checking omitted). Note this relies on atomic pipe writes, which is fine as long as you not writing message greater that PIPE_BUF (see man pipe):
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
void syserr(char * msg) { printf("%s\n", msg); exit(1); }
#define NO_PROC 5
#define BUF_SIZE 100
char message[] = "my message ";
int main() {
int message_len = 0;
char buf[BUF_SIZE];
for (int i = 0; i < NO_PROC; ++i) {
int pipe_dsc[2], buf_len;
if (pipe(pipe_dsc) == -1) {
syserr("Error in pipe\n");
}
pid_t pid = fork();
if (pid == -1) {
syserr("Error in fork\n");
}
else if (pid == 0) {
close(pipe_dsc[1]);
int n = read(pipe_dsc[0], buf+message_len, sizeof(buf));
message_len = strlen(buf); // Assume message is null terminated string.
if(i == NO_PROC -1) {
printf("Process %i: received '%s'\n", i+1, buf);
}
}
else {
close(pipe_dsc[0]);
write(pipe_dsc[1], message, sizeof(message));
wait(0);
return 0;
}
}
}