Read cout and write to cin of a process with boost::process - c++

Question

I'm trying to spawn a shell and read the stdout and stderr, and let the user run commands by writing to stdin. I can't seem to read from stdout or stderr, and writing to stdin also apparently doesn't do anything.
If I don't try redirecting any of stdin, stdout, or stderr, it spawns a normal shell like I'd expect. However, redirecting them just makes everything vanish. The >> just hangs mysteriously. I pull from the child's stdout and just put it right back into the actual stdout, so I'd expect at lease something like my username to show up, but like I said, it just blocks because there must be nothing in the buffer.
boost::process::child shell;
boost::process::opstream instream;
boost::process::ipstream errstream;
boost::process::ipstream outstream;
void console_out_read()
{
char ch;
do
{
outstream >> ch;
std::cout << ch;
}
while(true);
}
void console_err_read()
{
char ch;
do
{
errstream >> ch;
std::cerr << ch;
}
while(true);
}
void console_in_write()
{
int ch;
do
{
std::cin >> ch;
instream << ch;
}
while(true);
}
int main()
{
std::error_code ec;
shell = boost::process::child("bash",
boost::process::std_out > outstream,
boost::process::std_err > errstream,
boost::process::std_in < instream,
ec);
boost::thread cro(console_out_read);
boost::thread cre(console_err_read);
boost::thread cwi(console_in_write);
shell.wait();
return 0;
}

Answer 1

There are several issues with the code you posted.
First, in console_in_write you declared ch to be an int instead of a char. That means that std::cin will only accept things that look like numbers for it. This leads to std::cin getting into an error state if you enter anything but a number.
Second, even after changing ch to be a char, std::cin >> ch will never read a newline character because the formatted input operations discard whitespace. The easiest solution to this problem would be to use std::getline to read line-by-line instead of char-by-char and just write a newline after each line you read.
Third, boost's pipe streams are fully-buffered. That means that you need to flush the stream after you write a newline so that the data gets send to your child process. Otherwise you'll type a command and nothing will happen because the data is just sitting in the stream's buffer.
Fourth, std::threads must be joined or detached before they go out of scope. Since you don't currently do so with your I/O threads, as soon as your subprocess exits the parent will crash.
Putting these all together, I would expect a minimal example to look something like this:
boost::process::child shell;
boost::process::opstream instream;
boost::process::ipstream errstream;
boost::process::ipstream outstream;
void console_out_read()
{
std::string line;
while (std::getline(outstream, line))
{
std::cout << line << '\n';
}
}
void console_err_read()
{
std::string line;
while (std::getline(errstream, line))
{
std::cout << line << '\n';
}
}
void console_in_write()
{
std::string line;
while (std::getline(std::cin, line))
{
instream << line << std::endl;
if (line == "exit") return;
}
}
int main()
{
std::error_code ec;
shell = boost::process::child("bash",
boost::process::std_out > outstream,
boost::process::std_err > errstream,
boost::process::std_in < instream,
ec);
std::thread cro(console_out_read);
std::thread cre(console_err_read);
std::thread cwi(console_in_write);
shell.wait();
cro.join();
cre.join();
cwi.join();
}