C ++外部程序IO

Question

I need to run an external program from within a c++ application. I need the output from that program (i want to see it while the program is still running) and it also needs to get input.

What is the best and most elegant way to redirect the IO? Should it be running in it's own thread? Any examples?

It's running on OSX.

I implemented it like this:

ProgramHandler::ProgramHandler(std::string prog): program(prog){
// Create two pipes
std::cout << "Created Class\n";
pipe(pipe1);
pipe(pipe2);

int id = fork();

std::cout << "id: " << id << std::endl;

if (id == 0)
{
    // In child
    // Close current `stdin` and `stdout` file handles
    close(fileno(stdin));
    close(fileno(stdout));

    // Duplicate pipes as new `stdin` and `stdout`
    dup2(pipe1[0], fileno(stdin));
    dup2(pipe2[1], fileno(stdout));

    // We don't need the other ends of the pipes, so close them
    close(pipe1[1]);
    close(pipe2[0]);

    // Run the external program
    execl("/bin/ls", "bin/ls");
    char buffer[30];
    while (read(pipe1[0], buffer, 30)) {
        std::cout << "Buf: " << buffer << std::endl;
    }
}
else
{
    // We don't need the read-end of the first pipe (the childs `stdin`)
    // or the write-end of the second pipe (the childs `stdout`)
    close(pipe1[0]);
    close(pipe2[1]);


    // Now you can write to `pipe1[1]` and it will end up as `stdin` in the child
    // Read from `pipe2[0]` to read from the childs `stdout`
}

}

but as an output i get this:

Created Class

id: 84369

id: 0

I don't understand why it s called twice and why it wont fork the first time. What am I doing/understanding wrong.

Answer 1

If using a POSIX system (like OSX or Linux) then you have to learn the system calls pipe , fork , close , dup2 and exec .

What you do is create two pipes, one for reading from the external application and one for writing. Then you fork to create a new process, and in the child process you set up the pipes as stdin and stdout and then call exec which replaces the child process with an external program using your new stdin and stdout file handles. In the parent process you can not read the output from the child process, and write to its input.

In pseudo-code:

// Create two pipes
pipe(pipe1);
pipe(pipe2);

if (fork() == 0)
{
    // In child
    // Close current `stdin` and `stdout` file handles
    close(FILENO_STDIN);
    close(FILENO_STDOUT);

    // Duplicate pipes as new `stdin` and `stdout`
    dup2(pipe1[0], FILENO_STDIN);
    dup2(pipe2[1], FILENO_STDOUT);

    // We don't need the other ends of the pipes, so close them
    close(pipe1[1]);
    close(pipe2[0]);

    // Run the external program
    exec("/some/program", ...);
}
else
{
    // We don't need the read-end of the first pipe (the childs `stdin`)
    // or the write-end of the second pipe (the childs `stdout`)
    close(pipe1[0]);
    close(pipe2[1]);

    // Now you can write to `pipe1[1]` and it will end up as `stdin` in the child
    // Read from `pipe2[0]` to read from the childs `stdout`
}

Read the manual pages of the system calls for more information about them. You also need to add error checking as all of these system calls may fail.

Answer 2

Well there is a pretty standard way to do this. In general you would like to fork the process and to close the standard I/O (fd 0,1) of the child. Before forking have create two pipes, after forking close the standard input and output in the child and connect them to the pipe, using dup.

Pseudo code, shows only one side of the connection, I'm sure you can figure out the other side.

int main(){
     int fd[2]; // file descriptors
     pipe(fd);

      // Fork child process
      if (fork() == 0){
            char buffer [80];
            close(1);
            dup(fd[1]); // this will take the first free discriptor, the one you just closed. 
            close(fd[1]); // clean up
        }else{
           close(0);
           dup(fd[0]);
           close(fd[0]);
        }    
        return 0;
    }

After you have the pipe set up and one of the parent threads waiting on a select or something, you can call exec for your external tool and have all the data flowing.

Answer 3

The basic approach to communicate with a different program on POSIX systems is to setup a pipe() , then fork() your program, close() and dup() file descriptors into the correct location, and finally to exec??() the desired executable.

Once this is done, you have your two programs connected with suitable streams. Unfortunately, this doesn't deal with any form of asynchronous processing of the two programs. That is, it is likely that you either want to access the created file descriptor with suitable asynchronous and non-blocking operations (ie, setup the various file descriptors to be non-blocking and/or access them only when poll() yields results indicating that you can access them). If there is just that one executable it may be easier to control it from a separate thread, though.

Answer 4

A different approach (and if you are also writing the external program) is to use shared memory. Something along the lines of (pseudo code)

// create shared memory
int l_shmid = shmget(key, size ,0600 | IPC_CREAT);

if(l_shmid < 0) 
  ERROR

// attach to shared memory
dataptr* ptr = (dataptr*)shmat(l_shmid, NULL, 0600);

// run external program
pid_t l_pid = fork();

if(l_pid == (pid_t)-1)
{
  ERROR

  // detach & delete shared mem
  shmdt(ptr);
  shmctl(l_shmid, 
         IPC_RMID,
         (shmid_ds *)NULL);
  return;
}
else if(l_pid == 0)
{
    // child: 
    execl(path,
          args,
          NULL); 
    return;
}

// wait for the external program to finish
int l_stat(0);
waitpid(l_pid, &l_stat, 0);

// read from shmem
memset(mydata, ..,..);
memcpy(mydata, ptr, ...);

// detach & close shared mem
shmdt(ptr);
shmctl(l_shmid, 
       IPC_RMID,
       (shmid_ds *)NULL);

Your external program can write to shared memory in a similar way. No need for pipes & reading/writing/selecting etc.