pipe() x2 -> fork():
    [child] -> close(1), close(2) -> dup2(pipe1[1], 1), dup2(pipe2[1], 2) -> exec()
    [parent] -> read(pipe1[0]), read(pipe2[0])

close(1);
close(2);
open("stdout", O_CREAT | O_WRONLY, 0777);
open("stderr", O_CREAT | O_WRONLY, 0777);

$ cat /proc/sys/fs/pipe-max-size
1048576

bool runPipe(cwxString &fcommand, IStringConsumer* fout)  

static FILE * __openPipe(cwxString &fcommand){
	return popen(fcommand+ " 2>&1", "r"); //redirect stderr to stdout
	//return popen(fcommand, "r"); 
}

static int __closePipe(FILE* fpipe){
	return pclose(fpipe);
}


//read data from the opened pipe and close it at the end.
static bool __readPipeAndClose(FILE* fpipe, IStringConsumer* fout){
	if (fpipe == nullptr) return false;	/* Handle error */;

	const int __maxLen = 2000;

	char lbuf[__maxLen+2];
	while (fgets(lbuf,__maxLen,fpipe)){
		if(fout){
			fout->addString(wxString::FromUTF8(lbuf));
		}
	}

	int lstatus = __closePipe(fpipe);
	if (lstatus == -1) { /* Error reported by pclose() */
		return false;
	}
	if (!WIFEXITED(lstatus) ) return false;
	int lret  = WEXITSTATUS(lstatus);
	return lret == 0;
}

//create pipe and read it.
bool runPipe(cwxString &fcommand, IStringConsumer* fout){
	FILE* lfile = __openPipe(fcommand);
	if(lfile) __readPipeAndClose(lfile,fout);
	return lfile!=nullptr;
}

"Пошутить"?

"Не пошутить"?

#ifndef POPEN2_H
#define POPEN2_H

typedef struct {
	int	fd;
	char   *data;
	int	max_size;
	int	alloced;
	int	size;
	int	pipes[2];
} POpenStream;

typedef struct {
	int	      poll_fd;
	POpenStream **str;
	int	      nstr;
	const char   *what;
} POpen;

int popen2_init (POpen *);
int popen2_destroy (POpen *);
int popen2_add_stream (POpen *, POpenStream *, int nstream);
int popen2_exec (POpen *, const char *cmd, char *const argv[]);

#endif

#include <sys/types.h>
#include <sys/epoll.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include "popen2.h"

#ifdef MAX
#undef MAX
#endif
#define MAX(x,y) ((x) >= (y)? (x): (y))

int popen2_init (POpen *p)
{
	p->poll_fd = -1;
	p->str  = 0;
	p->nstr = 0;
	p->what = "";

	return 0;
}

int popen2_add_stream (POpen *p, POpenStream *s, int nstream)
{
	int i;

	p->str = (POpenStream**) realloc (p->str, sizeof *p->str * (p->nstr + nstream));\

	for (i = 0; i < nstream; i++) {
		p->str[p->nstr++] = s + i;
		s[i].pipes[0] = s[i].pipes[1] = -1;
	}

	return 0;
}

int popen2_destroy (POpen *p)
{
	POpenStream **s = p->str, **e = p->str + p->nstr;

	for (; s < e; s++) {
		if ((*s)->pipes[0] >= 0)
			close ((*s)->pipes[0]);
		if ((*s)->pipes[1] >= 0)
		    close ((*s)->pipes[1]);
		if ((*s)->alloced)
			free ((*s)->data);
	}

	free (p->str);
	p->str  = 0;
	p->nstr = 0;

	if (p->poll_fd >= 0) {
		close (p->poll_fd);
		p->poll_fd = -1;
	}

	return 0;
}

int popen2_exec (POpen *p, const char *path, char *const argv[])
{
	POpenStream **s = p->str, **e = p->str + p->nstr, *ss;
	int i, maxfd = -1, maxpipe = -1, n, l;
	struct epoll_event event_data, fdevents[10];
	long flags;
	char buf[1024];
	
	p->poll_fd = epoll_create1 (EPOLL_CLOEXEC);
	if (p->poll_fd == -1) {
		p->what = "epoll_create1";
		return -1;
	}

	for (i = 0; i < p->nstr; i++) {
		s = p->str + i;
		event_data.events   = EPOLLIN | EPOLLHUP;
		event_data.data.ptr = *s;
		if (pipe ((*s)->pipes) != 0) {
			p->what = "pipe";
			return -1;
		}
		if (epoll_ctl (p->poll_fd, EPOLL_CTL_ADD, (*s)->pipes[0], &event_data) != 0) {
			p->what = "epoll_ctl";
			return -1;
		}
	}

	pid_t pid = fork ();

	if (!pid) {				       // child
		for (s = p->str; s < e; s++)
			close ((*s)->pipes[0]);
		
		for (s = p->str; s < e; s++) {
			if (maxfd < 0 || maxfd < (*s)->fd)
				maxfd = (*s)->fd;
			if (maxpipe < 0 || maxpipe < (*s)->pipes[1])
				maxpipe = (*s)->pipes[1];
		}

		if (maxpipe < maxfd)
			maxpipe = maxfd;

		for (s = p->str; s < e; s++) {
			if ((*s)->pipes[1] <= maxfd) {
				dup2 ((*s)->pipes[1], ++maxpipe);
				close ((*s)->pipes[1]);
				(*s)->pipes[1] = maxpipe;
			}
		}
	
		for (s = p->str; s < e; s++) {
			if ((*s)->fd != (*s)->pipes[1])
				dup2 ((*s)->pipes[1], (*s)->fd);
		}

		execv (path, argv);
		perror ("exec");
		exit (1);
	}

	if (pid == -1) {
		p->what = "fork";
		return -1;
	}

	for (s = p->str; s < e; s++) {
		close ((*s)->pipes[1]);
		(*s)->pipes[1] = -1;
		flags = fcntl ((*s)->pipes[0], F_GETFL);
		if (flags == -1) {
			p->what = "fcntl(G_GETFL)";
			return -1;
		}
		if (fcntl ((*s)->pipes[0], F_SETFL, flags | O_NONBLOCK) == -1) {
			p->what = "fcntl(F_SETF,O_NONBLOCK)";
			return -1;
		}
	}

	while ((n = epoll_wait (p->poll_fd, fdevents, sizeof fdevents / sizeof fdevents[0], -1)) > 0) {
		for (i = 0; i < n; i++) {
			ss = (POpenStream*)fdevents[i].data.ptr;
			while ((l = read (ss->pipes[0], buf, sizeof buf)) > 0) {
				if (ss->size + l > ss->alloced) {
					ss->alloced = MAX (ss->alloced * 2, ss->size + l);
					ss->data = (char*)realloc (ss->data, ss->alloced);
					memmove (ss->data + ss->size, buf, l);
					ss->size += l;
				}
			}
			if (l == 0) {
				close (ss->pipes[0]);
				ss->pipes[0] = -1;
			} else if (l == -1) {
				if (errno != EAGAIN) {
					p->what = "read";
					return -1;
				} else continue;
			}
		}
		n = 0;
		for (s = p->str; s < e; s++)
			if ((*s)->pipes[0] != -1) {
				n = 1;
				break;
			}
		if (!n)
			break;
	}

	if (n < 0) {
		p->what = "epoll_wait";
		return -1;
	}

	close (p->poll_fd);
	p->poll_fd = -1;

	waitpid (pid, 0, 0);

	return 0;
}

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "popen2.h"

int main ()
{
	// POpenStream s1 = { 1 } , s2 = { 2 }, s5 = { 5 };
	POpenStream s[] = {
		{ 1 },
		{ 2 },
		{ 5 }
	};
	POpen po;
	int err;
	unsigned i;
	const char *cmd = "/bin/bash";
	char *const args[] = { "bash", "-c", "echo file descriptor 1: 111; "
			       "echo file descriptor 2: 222 1>&2; "
			       "echo file descriptor 5: 555 1>&5; "
			       "no-such-command", 0 };
	const char *sep = "";

	if (popen2_init (&po) != 0) {
		perror ("popen2_init");
		return 1;
	}

	// if (popen2_add_stream (&po, &s1, 1) != 0) {
	// 	fputs ("Add stream 's1' failed.", stderr);
	// 	return 1;
	// }

	// if (popen2_add_stream (&po, &s2, 1) != 0) {
	// 	fputs ("Add stream 's2' failed.", stderr);
	// 	return 1;
	// }

	// if (popen2_add_stream (&po, &s5, 1) != 0) {
	// 	fputs ("Add stream 's5' failed.", stderr);
	// 	return 1;
	// }

	if (popen2_add_stream (&po, s, 3) != 0) {
		fputs ("Add stream 's1' failed.", stderr);
		return 1;
	}

	if (popen2_exec (&po, cmd, args) != 0) {
		err = errno;
		fprintf (stderr, "popen2_exec() failed. %s:%s\n", po.what, strerror (err));
		return 1;
	}

	printf ("Command: %s\nArgs: [", cmd);
	for (i = 0; args[i]; i++, sep = ", ")
		printf ("%s\"%s\"", sep, args[i]);
	printf ("]\n");
	
	for (i = 0; i < sizeof s / sizeof s[0]; i++)
		printf ("fd %d: %d bytes [%.*s]\n",
			s[i].fd,
			s[i].size,
			s[i].size,
			s[i].data);

	// fprintf (stdout, "fd %d: %d bytes [%.*s]\n", s1.fd, s1.size, s1.size, s1.buf);
	// fprintf (stdout, "fd %d: %d bytes [%.*s]\n", s2.fd, s2.size, s2.size, s2.buf);
	// fprintf (stdout, "fd %d: %d bytes [%.*s]\n", s5.fd, s5.size, s5.size, s5.buf);

	popen2_destroy (&po);

	return 0;
}

Command: /bin/bash
Args: ["bash", "-c", "echo file descriptor 1: 111; echo file descriptor 2: 222 1>&2; echo file descriptor 5: 555 1>&5; no-such-command"]
fd 1: 23 bytes [file descriptor 1: 111
]
fd 2: 81 bytes [file descriptor 2: 222
bash: no-such-command: команда не найдена
]
fd 5: 23 bytes [file descriptor 5: 555
]

FILE * fout = popen(command, "r");
while (fgets(getsbuff, EXEC_READ_SIZE - 1, fout)) {
    printf("%s\n", getsbuff);
}
pclose(fout);