Parent reads operations from file and the child sums it with bc - c

Question

I'm trying to make a program where the parent reads from a file some operations, passes them to the child with a pipe, and the child makes all the operations with bc. Later on, the child has to pass it back to the parent and this one has to write it on a file.
However, when I execute it, I don't get any result and don't know where the problem is. The child seems to receive the operation correctly, but with 'EXT' character.
My code works perfectly when the parent doesn't read from the file, the problem is when I try to read from a file.
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define EOL '\n'
int main(int argc, char *argv[]){
int tube1[2];
int tube2[2];
int fID;
pipe(tube1);
pipe(tube2);
if(argc != 2){
perror("./yourProgram.c [origin]");
exit(EXIT_FAILURE);
}
if (fork() == 0){
//Child Process
close(tube1[1]); // writing end of the pipe
dup2(tube1[0], 0); // stdin ----> pipe reading end
close(tube2[0]); // reading end of the pipe
dup2(tube2[1], 1); // stdout ---> pipe writing end
//Execute and write the output in the tube2
execlp("bc", "bc", "-q", NULL);
}else {
//Parent Process
close(tube1[0]); // reading end of the pipe
//dup2(tube1[1], 1); // stdout ---> pipe writing end
close(tube2[1]); // reading end of the pipe
//dup2(tube1[1], 1); // stdout ---> pipe writing end
//Files
//Destiny
char *destiny = "final.txt";
int destinyFile = open(destiny, O_WRONLY | O_CREAT | O_TRUNC, 0644);
//Origin
char *origin = argv[1];
int originFile = open(origin, O_RDONLY);
//Variables
char block;
char result;
char buffer[4096];
int i = 0;
int numbytes;
while(numbytes = read(originFile, &block, sizeof(block)) > 0){
if(block == EOL){
//Write on the tube, so the child can read it
if(write(tube1[1], buffer, strlen(buffer)) == -1){
perror("error en write en pipe");
exit(EXIT_FAILURE);
}
//Read the child's answer
while(numbytes = read(tube2[0], &result, 1) > 0){
if(result != EOL){
//Concatenate strings as: 'X + Y = Result \n'
char str[80];
strcat(str, buffer);
strcat(str, " = ");
strcat(str, &result);
strcat(str, "\n");
//Write the result in the Final File
if(write(destinyFile, str, strlen(str)) == -1){
perror("error en write en stdout");
exit(EXIT_FAILURE);
}
}else
continue;
}
//Reset Buffer
buffer[0] = '\0';
i = 0;
}else{
buffer[i] = block;
i = i + 1;
}
}
}
}
And the file from where I read is:
2+3
4*5
8/2
quit

Answer 1

This code fixes the critical problems noted in the comments (but not the performance issues from reading one byte at a time). If the calculation produces a result that's big enough, bc splits its output over multiple lines (calculating factorial 100, for example). The code does not attempt to deal with that. Also, some operations produce no output. For example, c=2345 produces no output. The program does not handle this, either.
You aren't closing enough file descriptors in the child.
Rule of thumb: If you
dup2()
one end of a pipe to standard input or standard output, close both ends
of the pipe as soon as possible.
That means before using any of the
exec*()
family of functions in particular.
The rule of thumb also includes using
dup()
or
fcntl()
with F_DUPFD.
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define EOL '\n'
int main(int argc, char *argv[])
{
int tube1[2]; // Parent -> child
int tube2[2]; // Child -> parent
if (argc != 2)
{
perror("./yourProgram.c origin");
exit(EXIT_FAILURE);
}
pipe(tube1);
pipe(tube2);
if (fork() == 0)
{
// Child Process
dup2(tube1[0], 0); // stdin ----> pipe reading end
close(tube1[0]); // reading end of the pipe to child
close(tube1[1]); // writing end of the pipe to child
dup2(tube2[1], 1); // stdout ---> pipe writing end
close(tube2[0]); // reading end of the pipe to parent
close(tube2[1]); // writing end of the pipe to parent
// Execute and write the output in the tube2
execlp("bc", "bc", "-q", NULL);
perror("bc");
exit(EXIT_FAILURE);
}
else
{
// Parent Process
close(tube1[0]); // reading end of the pipe to child
close(tube2[1]); // writing end of the pipe to parent
// Files
// Destiny
char *destiny = "final.txt";
int destinyFile = open(destiny, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (destinyFile < 0)
{
perror(destiny);
exit(EXIT_FAILURE);
}
// Origin
char *origin = argv[1];
int originFile = open(origin, O_RDONLY);
if (originFile < 0)
{
perror(origin);
exit(EXIT_FAILURE);
}
// Variables
char block;
char result;
char buffer[256];
int i = 0;
int numbytes;
while ((numbytes = read(originFile, &block, sizeof(block))) > 0)
{
buffer[i++] = block;
//printf("Block: [%.*s]\n", i, buffer);
if (block == EOL)
{
// Write on the tube, so the child can read it
if (write(tube1[1], buffer, i) == -1)
{
perror("error en write en pipe");
exit(EXIT_FAILURE);
}
buffer[i-1] = '\0';
// Read the child's answer
int j = 0;
char reply[256];
while ((numbytes = read(tube2[0], &result, sizeof(result))) > 0)
{
reply[j++] = result;
//printf("Reply: [%.*s]\n", j, reply);
if (result == EOL)
{
// Concatenate strings as: 'X + Y = Result \n'
char str[256];
str[0] = '\0';
strcat(str, buffer);
strcat(str, " = ");
strcat(str, reply);
// Write the result in the Final File
if (write(destinyFile, str, strlen(str)) == -1)
{
perror("error en write en stdout");
exit(EXIT_FAILURE);
}
printf("Response: [%.*s]\n", j-1, reply);
break;
}
}
// Reset Buffer
i = 0;
}
}
close(tube1[1]);
close(tube2[0]);
}
return 0;
}
Given the sample input file:
2+3
4*5
8/2
quit
the output on the screen is:
Response: [5]
Response: [20]
Response: [4]
and the output in final.txt is:
2+3 = 5
4*5 = 20
8/2 = 4