Read/write alternately in subprocess stdout/stdin - c

Question

I have two executable. The first one (target) print data to stdout, read data from stdin and print another data to stdout. The second one (wrapper) is a wrapper of the first one. It forks, it changes child stdin and stdout then execute target.
I want that wrapper gets target's stdout, print it, send data to target's stdin and get last target's data. But the command block without printing anything.
The target code (I have one constraint, I can't modify this code):
#include <stdio.h>
int main(){
char buffer[0x100] = { 0 };
printf("First line\n");
printf("Input:");
scanf("%s", buffer);
printf("Last line\n");
return 0;
}
The wrapper code:
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#define READING_IDX 0
#define READING_IDX 0
#define WRITING_IDX 1
int main(int argc, char *argv[], char *env[]){
pid_t pid = 0;
int pipeStdin[2] = {0};
int pipeStdout[2] = {0};
char buffer[1024] = {0};
int ret = 0;
if (pipe(pipeStdout) == -1){
perror("pipe");
return 1;
}
if (pipe(pipeStdin) == -1){
perror("pipe");
return 1;
}
if ((pid = fork()) == -1){
perror("fork");
return 1;
}
else if (pid == 0){
close(pipeStdin[WRITING_IDX]);
close(pipeStdout[READING_IDX]);
if (dup2(
pipeStdin[READING_IDX],
STDIN_FILENO
) == -1){
perror("dup2");
return 1;
}
if (dup2(
pipeStdout[WRITING_IDX],
STDOUT_FILENO
) == -1){
perror("dup2");
return 1;
}
if (execve(
"./target",
argv + 1,
env
) == -1){
perror("execve");
return 1;
}
}
else{
close(pipeStdin[READING_IDX]);
close(pipeStdout[WRITING_IDX]);
ret = read(
pipeStdout[READING_IDX],
buffer,
1023);
if(ret == -1){
perror("read");
return 1;
}
printf("%d\n", ret);
buffer[ret] = 0;
printf("%s\n", buffer);
ret = write(
pipeStdin[WRITING_IDX],
"Response\n",
sizeof("Response\n")
);
}
return 0;
}
I build this two executable with:
gcc -o target target.c && gcc -o wrapper wrapper.c
Thanks to any help.
I see that child process block at read syscall. I think it is at the scanf line. But target does not write any data.
The strace logs:
>! execve("./wrapper", ["./wrapper"], 0x7ffca81b4f78 /* 50 vars */) = 0
brk(NULL) = 0x55bc56890000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (Aucun fichier ou dossier de ce type)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=310009, ...}) = 0
mmap(NULL, 310009, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f28eaf36000
close(3) = 0
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\260A\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1820400, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f28eaf34000
mmap(NULL, 1832960, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f28ead74000
mprotect(0x7f28ead96000, 1654784, PROT_NONE) = 0
mmap(0x7f28ead96000, 1339392, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x22000) = 0x7f28ead96000
mmap(0x7f28eaedd000, 311296, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x169000) = 0x7f28eaedd000
mmap(0x7f28eaf2a000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1b5000) = 0x7f28eaf2a000
mmap(0x7f28eaf30000, 14336, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f28eaf30000
close(3) = 0
arch_prctl(ARCH_SET_FS, 0x7f28eaf35500) = 0
mprotect(0x7f28eaf2a000, 16384, PROT_READ) = 0
mprotect(0x55bc55a1b000, 4096, PROT_READ) = 0
mprotect(0x7f28eafa9000, 4096, PROT_READ) = 0
munmap(0x7f28eaf36000, 310009) = 0
pipe([3, 4]) = 0
pipe([5, 6]) = 0
clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f28eaf357d0) = 13384
strace: Process 13384 attached
[pid 13383] close(5 <unfinished ...>
[pid 13384] close(6 <unfinished ...>
[pid 13383] <... close resumed> ) = 0
[pid 13384] <... close resumed> ) = 0
[pid 13383] close(4 <unfinished ...>
[pid 13384] close(3 <unfinished ...>
[pid 13383] <... close resumed> ) = 0
[pid 13384] <... close resumed> ) = 0
[pid 13383] read(3, <unfinished ...>
[pid 13384] dup2(5, 0) = 0
[pid 13384] dup2(4, 1) = 1
[pid 13384] execve("./target", [], 0x7ffec0e88de8 /* 50 vars */) = 0
[pid 13384] brk(NULL) = 0x5564da73c000
[pid 13384] access("/etc/ld.so.preload", R_OK) = -1 ENOENT (Aucun fichier ou dossier de ce type)
[pid 13384] openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
[pid 13384] fstat(3, {st_mode=S_IFREG|0644, st_size=310009, ...}) = 0
[pid 13384] mmap(NULL, 310009, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fbfc376b000
[pid 13384] close(3) = 0
[pid 13384] openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
[pid 13384] read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\260A\2\0\0\0\0\0"..., 832) = 832
[pid 13384] fstat(3, {st_mode=S_IFREG|0755, st_size=1820400, ...}) = 0
[pid 13384] mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fbfc3769000
[pid 13384] mmap(NULL, 1832960, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fbfc35a9000
[pid 13384] mprotect(0x7fbfc35cb000, 1654784, PROT_NONE) = 0
[pid 13384] mmap(0x7fbfc35cb000, 1339392, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x22000) = 0x7fbfc35cb000
[pid 13384] mmap(0x7fbfc3712000, 311296, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x169000) = 0x7fbfc3712000
[pid 13384] mmap(0x7fbfc375f000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1b5000) = 0x7fbfc375f000
[pid 13384] mmap(0x7fbfc3765000, 14336, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fbfc3765000
[pid 13384] close(3) = 0
[pid 13384] arch_prctl(ARCH_SET_FS, 0x7fbfc376a500) = 0
[pid 13384] mprotect(0x7fbfc375f000, 16384, PROT_READ) = 0
[pid 13384] mprotect(0x5564d8c2f000, 4096, PROT_READ) = 0
[pid 13384] mprotect(0x7fbfc37de000, 4096, PROT_READ) = 0
[pid 13384] munmap(0x7fbfc376b000, 310009) = 0
[pid 13384] fstat(1, {st_mode=S_IFIFO|0600, st_size=0, ...}) = 0
[pid 13384] brk(NULL) = 0x5564da73c000
[pid 13384] brk(0x5564da75d000) = 0x5564da75d000
[pid 13384] fstat(0, {st_mode=S_IFIFO|0600, st_size=0, ...}) = 0
[pid 13384] read(0, kolk
<unfinished ...>
[pid 13383] <... read resumed> 0x7ffec0e888d0, 1023) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
[pid 13383] --- SIGWINCH {si_signo=SIGWINCH, si_code=SI_KERNEL} ---
[pid 13383] read(3, <unfinished ...>
[pid 13384] <... read resumed> 0x5564da73d270, 4096) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
[pid 13384] --- SIGWINCH {si_signo=SIGWINCH, si_code=SI_KERNEL} ---
[pid 13384] read(0, <unfinished ...>
[pid 13383] <... read resumed> 0x7ffec0e888d0, 1023) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
[pid 13384] <... read resumed> 0x5564da73d270, 4096) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
[pid 13383] --- SIGWINCH {si_signo=SIGWINCH, si_code=SI_KERNEL} ---
[pid 13384] --- SIGWINCH {si_signo=SIGWINCH, si_code=SI_KERNEL} ---
[pid 13383] read(3, <unfinished ...>
[pid 13384] read(0,

Answer 1

Your problem is with stdio buffering, and if you could modify the target, you would just do:
#include <stdio.h>
int main(){
char buffer[0x100] = { 0 };
printf("First line\n");
printf("Input:");
fflush(stdout); // this is what you'd add
scanf("%s", buffer);
printf("Last line\n");
return 0;
}
That is a bug in the target. Here's how it plays out:
printf("First line\n"); - The text First line\n is put into the stdio's stdout buffer. Interactive programs have a TTY for stdout, and when that's the case, if stdio sees a \n, it flushes the stdout buffer. But you're writing into a pipe, so stdio doesn't buffer by line, but rather by some arbitrary size, e.g. 4096 bytes.
printf("Input:"); - The text Input: is put into the stdio's stdout buffer. The buffer now contains 17 characters.
If fflush(stdout); is called, then newline or not - stdio will flush its stdout buffer to the system's stdout file descriptor, at which point it is written to the pipe.
but since the target doesn't call it:
scanf("%s", buffer); - The target blocks, waiting for input.
Control switches to the wrapper:
read(pipeStdout[READING_IDX], buffer, 1023); - Nothing has been yet written by the target to its stdout, so the wrappers stdin is empty. That means read() blocks until there's any input.
That's where your program hangs. If the target called fflush() then the pipe would have contained 17 characters and read() would have succeeded.
Unfortunately, adding setbuf(stdout, NULL) to the wrapper doesn't work, because execve(2) destroys that buffer and creates a new one in the new process image.
On Linux, there's a program called stdbuf which fixes that. You can verify by running your wrapper as follows:
stdbuf -o 0 ./wrapper
Apparently the way stdbuf works is by running the sub-program with an LD_PRELOAD library that calls setbuf(3).
I don't think it's reasonable to try and do that yourself, but since your question is tagged with linux, you can replace your
if (execve(
"./target",
argv + 1,
env
) == -1){
perror("execve");
return 1;
}
with:
if (system("stdbuf -o 0 ./target") == -1){
perror("system");
return 1;
}
And that would workaround the bug in the target.
However, once you've done that, you'll get the following output:
17
First line
Input:
Whereas it should be:
17
First line
Input:
10
Last line
(10 being the length of Response\n).
I Assume that you want to interleave this interaction because the writes from the wrapper have to be related to the writes from the target.
But you wouldn't know when the target finished writing its part - it could stop writing due to scheduling, or because the pipe buffer is full, or because it just takes long to produce output.
You actually need a protocol between the wrapper and the target - something that signifies "end of message, like "roger that, over".
But given, again, that you can't change the target, for the purpose of this question we will have to assume that:
There are only 3 operations (from the POV of the wrapper: read-write-read).
All communication fits in all the buffers - the wrappers' read buffer (1023 bytes), the target's read buffer (0x100 bytes), the system's pipe buffer (usually 4096 bytes) and any of stdio's stdin buffers.
Everything is happy and peachy, there are no short reads or short writes.
Under these conditions, you just need to add the last read:
ret = read(
pipeStdout[READING_IDX],
buffer,
1023);
if(ret == -1){
perror("read");
return 1;
}
printf("read ret: %d\n", ret);
buffer[ret] = 0;
printf("read buf: '%s'\n", buffer);
ret = write(
pipeStdin[WRITING_IDX],
"Response\n",
sizeof("Response\n")
);
ret = read(
pipeStdout[READING_IDX],
buffer,
1023);
if(ret == -1){
perror("read");
return 1;
}
printf("read ret: %d\n", ret);
buffer[ret] = 0;
printf("read buf: '%s'\n", buffer);
(I added read buf and read ret for clarity).