Prevent pipe from going into sub-shell of script - php

Question

I'm piping lines into a PHP script (see contrived example below). Alas the pipe unintentionally flows into the shell command in the script, thus nano doesn't run because it chokes on STDIN.
I want the shell command to run completely unrelated to the STDIN piped to the main script. So the PHP script should in a way "eat" the STDIN, so it doesn't reach the sub-shell. How do I fix this?
Note that exec(), system() and passthru() all give the same result.
$ echo -e "World\nEverybody" | php script.php
Hello World
Received SIGHUP or SIGTERM
Hello Everybody
Received SIGHUP or SIGTERM
script.php:
<?php
foreach(file("php://stdin") as $name) {
echo "Hello $name";
passthru("nano");
}
?>
Environment:
PHP 7.1.14 / PHP 5.6.30
GNU bash, version 3.2.57
GNU nano version 2.0.6

Answer 1

The pipe isn't really flowing into the sub-shells. In fact, nothing is flowing in. In order to connect nano's STDIN to the terminal, you pipe the controlling terminal (always /dev/tty) into nano, like this:
passthru("nano </dev/tty");
Here's an answer to your follow-up question. (Very good question IMO. My previous answer was slightly wrong in fact. STDIN does flow into the child processes.)
If the script consists of just passthru("nano") and you don't pipe anything into PHP, then nano works without </dev/tty. Why is this?
Linux behavior
In fact, child processes do inherit STDIN from their parent processes, but because of buffering, this isn't entirely clear sometimes. And since they inherit the same STDIN, when EOF is reached, they do whatever they do when EOF is reached (to see what nano does in this case, see below).
Let's take PHP out of the equation and see what we get when we turn buffering on or off. Here's some C code that will read from STDIN, system(), and read from STDIN again:
#include <stdio.h>
#include <stdlib.h>
int main() {
// setvbuf(stdin, NULL, _IONBF, 0 );
char buffer[32];
gets(buffer);
printf("Hello %s\n", buffer);
system("bash -c 'read FOO; echo This is bash, got $FOO'");
gets(buffer);
printf("Hello2 %s\n", buffer);
}
Compile (ignore the warnings about gets) and run:
$ cc -o script script.c
$ echo -e "Foo\nBar\nCar" | ./script
Hello Foo
This is bash, got
Hello2 Bar
bash didn't get anything. The gets after system magically got this input. Now uncomment the first line:
- // setvbuf(stdin, NULL, _IONBF, 0 );
+ setvbuf(stdin, NULL, _IONBF, 0 );
And we get:
$ cc -o script script.c
$ echo -e "Foo\nBar\nCar" | ./script
Hello Foo
This is bash, got Bar
Hello2 Car
This time bash got the second input. "Too long; didn't read": We do in fact have the same STDIN.
`nano` internals
First of all, you will find that nano's behavior is the same even if you take PHP out of the equation:
$ echo foo | nano
Received SIGHUP or SIGTERM
nano could in theory very well detect if we've got a terminal, and if we don't, attempt to open /dev/tty (it's just a regular open call). In fact, nano does this if you execute nano like this:
echo foo | nano -
The scoop_stdin function in src/nano.c takes care of this in version 2.9.4: http://git.savannah.gnu.org/cgit/nano.git/tree/src/nano.c?h=v2.9.4#n1122
And the finish_stdin_pager function in version 2.7.4: http://git.savannah.gnu.org/cgit/nano.git/tree/src/nano.c?h=v2.7.4#n1116)
So what happens when nano gets EOF? EOF in key input is handled like this:
Version 2.7.4: get_key_buffer() calls handle_hupterm(0) directly.
http://git.savannah.gnu.org/cgit/nano.git/tree/src/winio.c?h=v2.7.4#n207
Version 2.9.4: die(_("Too many errors from stdin"));
http://git.savannah.gnu.org/cgit/nano.git/tree/src/winio.c?h=v2.9.4#n207
(The reason I'm linking both is because the message changed at some point.)
I hope that sort of makes things clearer.