Double pipe to save output to file in C - c

Question

I have created something like "linux pipe" to redirect output from one program to another and it's working like a charm. But now I want to save final output to a file. On the internet I saw that I need to create double pipe, but everything I create is not working.
Here is my actual code of "pipe":
int pipes[2];
int pid;
pipe(pipes);
if(pid=fork()){
int fd = open("t.txt", O_CREAT | O_TRUNC | O_RDWR, 0644);
if (fd < 0) {
perror("open()");
exit(EXIT_FAILURE);
}
close(pipes[1]);
dup2(pipes[0],STDIN_FILENO);
execvp(sec_command[0],sec_command);
}
else{
close(pipes[0]);
dup2(pipes[1],STDOUT_FILENO);
execvp(first_command[0],first_command);
}
Thanks

Answer 1

No. You don't need to. You just need to do a second dup2 in the child process (which will be capturing its input from the pipe) to the file descriptor of the file you want the output to go. You haven't post a Minimal, Reproducible Example, and your code is wrong (it execs in the parent and child process) so i've tried to work a complete solution. Here it is:
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
pid_t
subcommand_to_file(
char **subcommand_args,
char *file)
{
int pipes[2];
pipe(pipes);
pid_t pid = fork();
if (pid < 0) {
perror("fork");
return -1;
} else if (pid == 0) { /* child */
int fd = open(file,
O_CREAT | O_TRUNC | O_RDWR,
0666); /* permissions controled by umask */
if (fd < 0) {
perror("open");
exit(EXIT_FAILURE);
}
close(pipes[1]); /* close output descriptor of pipe */
dup2(pipes[0], STDIN_FILENO); /* redirect input */
close(pipes[0]); /* not needed after dup2 */
dup2(fd, STDOUT_FILENO); /* rediect output */
close(fd); /* not needed after dup2 */
execvp(subcommand_args[0], subcommand_args);
perror("execvp");
exit(EXIT_FAILURE);
}
/* parent */
close(pipes[0]); /* close input descriptor of pipe */
dup2(pipes[1], STDOUT_FILENO);
close(pipes[1]); /* not needed, after dup */
return pid; /* so if you want to wait for the child */
}
int
main( int argc,
char **argv)
{
int opt;
char file[256];
/* default value for filename */
snprintf(file, sizeof file, "%s.out", argv[0]);
while ((opt = getopt(argc, argv, "f:")) != EOF) {
switch (opt) {
case 'f':
strncpy(file, optarg, sizeof file);
break;
}
}
argc -= optind;
argv += optind;
pid_t child = subcommand_to_file(argv, file);
if (child < 0) {
fprintf(stderr,
"subcommand_to_file: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
/* copy input to output to pass stdin to subprocess */
int c;
while((c = getchar()) != EOF) {
putchar(c);
}
close(STDOUT_FILENO);
wait(NULL);
fprintf(stderr, "%s terminated\n", argv[0]);
exit(EXIT_SUCCESS);
}
The above program is called as
$ a.out -f output_file command [args ...]
and will end when the command program is finished. Just try
$ a.out -f out.txt echo a b c
and you will get
$ cat out.txt
a b c
$ _