execbox.cc

Go to the documentation of this file.

/*
Copyright (C) 2002 The Exult Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "execbox.h"
#include <iostream> /* Debugging only */
#include <string>

using std::cout;
using std::endl;

#ifndef WIN32

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

/*
 *  Create.
 */

Exec_process::Exec_process
  (
  ) : child_stdin(-1), child_stdout(-1), child_stderr(-1),
      child_pid(-1), reader(0),
      stdout_tag(-1), stderr_tag(-1)
  {
  }

/*
 *  Clean up.
 */

Exec_process::~Exec_process
  (
  )
  {
  kill_child();
  }

/*
 *  End process and close pipes.
 */

void Exec_process::kill_child
  (
  )
  {
  if (child_pid > 0)
    kill(child_pid, SIGINT);
  if (child_stdin >= 0)
    close(child_stdin);
  if (child_stdout >= 0)
    close(child_stdout);
  if (child_stderr >= 0)
    close(child_stderr);
  if (stdout_tag >= 0)
    gdk_input_remove(stdout_tag);
  if (stderr_tag >= 0)
    gdk_input_remove(stderr_tag);
  child_pid = child_stdin = child_stdout = child_stderr = 
  stdout_tag = stderr_tag = -1;
  }

/*
 *  Read from child & call client routine.
 */

static void Read_from_child
  (
  gpointer data,      // ->Exex_process
  gint id,      // Pipe ID.
  GdkInputCondition condition
  )
  {
  Exec_process *ex = (Exec_process *) data;
  ex->read_from_child(id);
  }
void Exec_process::read_from_child
  (
  int id        // Pipe to read from.
  )
  {
  char buf[1024];
  int len;
  while ((len = read(id, buf, sizeof(buf))) > 0)
    if (reader)
      (*reader)(buf, len, 0, reader_data);
  int exit_code;
  if (!check_child(exit_code))  // Child done?
    {
    kill_child();   // Clean up.
    if (reader)   // Tell client.
      (*reader)(0, 0, exit_code, reader_data);
    }
  }



/*
 *  Close a pipe.
 */

inline void Close_pipe
  (
  int p[2]
  )
  {
  if (p[0] >= 0) close(p[0]);
  if (p[1] >= 0) close(p[1]);
  }

/*
 *  Close 3 sets of pipes.
 */

static void Close_pipes
  (
  int p0[2], int p1[2], int p2[2]
  )
  {
  Close_pipe(p0);
  Close_pipe(p1);
  Close_pipe(p2);
  }

/*
 *  Execute a new process.
 *
 *  Output: False if failed.
 */

bool Exec_process::exec
  (
  const char *file,     // PATH will be searched.
  char *argv[],     // Args.  1st is filename, last is 0.
  Reader_fun rfun,    // Called when child writes, exits.
  void *udata     // User_data for rfun.
  )
  {
  reader = rfun;      // Store callback.
  reader_data = udata;
          // Pipes for talking to child:
  int stdin_pipe[2], stdout_pipe[2], stderr_pipe[2];
  stdin_pipe[0] = stdin_pipe[1] = stdout_pipe[0] = stdout_pipe[1] = 
  stderr_pipe[0] = stderr_pipe[1] = -1;
  kill_child();     // Kill running process.
          // Create pipes.
  if (pipe(stdin_pipe) != 0 || pipe(stdout_pipe) != 0 ||
      pipe(stderr_pipe) != 0)
    {     // Error.
    Close_pipes(stdin_pipe, stdout_pipe, stderr_pipe);
    return false;
    }
  child_pid = fork();   // Split in two.
  if (child_pid == -1)    // Failed?
    {
    Close_pipes(stdin_pipe, stdout_pipe, stderr_pipe);
    return false;
    }
  if (child_pid == 0)   // Are we the child?
    {
    close(0);   // Want to read from the pipe.
    dup(stdin_pipe[0]);
    Close_pipe(stdin_pipe); // Done with these.
    close(1);   // Write to stdout through pipe.
    dup(stdout_pipe[1]);
    Close_pipe(stdout_pipe);
    close(2);   // Write to stderr through pipe.
    dup(stderr_pipe[1]);
    Close_pipe(stderr_pipe);
    execvp(file, argv); // Become the new command.
    exit(-1);   // Gets here if exec failed.
    }
          // HERE, we're the parent.
  child_stdin = stdin_pipe[1];  // Writing here goes to child stdin.
  close(stdin_pipe[0]);
  child_stdout = stdout_pipe[0];  // This gets child's stdout.
  close(stdout_pipe[1]);
  child_stderr = stderr_pipe[0];
  close(stderr_pipe[1]);
cout << "Child_stdout is " << child_stdout << ", Child_stderr is " <<
    child_stderr << endl;
  stdout_tag = gdk_input_add(child_stdout,
      GDK_INPUT_READ, Read_from_child, this);
  stderr_tag = gdk_input_add(child_stderr,
      GDK_INPUT_READ, Read_from_child, this);
  return true;
  }

/*
 *  See if child is still alive.
 *
 *  Output: True if child is still running.
 *    If false, exit code is returned in 'exit_code'.
 */

bool Exec_process::check_child
  (
  int& exit_code      // Exit code returned.
  )
  {
  if (child_pid < 0)
    return false;   // No child.
  int status;
          // Don't wait.
  int ret = waitpid(child_pid, &status, WNOHANG);
  if (ret != child_pid)
    return true;    // Still running.
  else
    {
    cout << "Exec_box:  Child done." << endl;
    exit_code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
    return false;
    }
  }

#endif

/*
 *  Create.
 */

Exec_box::Exec_box
  (
  GtkTextView *b,
  GtkStatusbar *s,
  Exec_done_fun dfun,   // Called when child exits.
  gpointer udata      // Passed to dfun.
  ) : box(b), status(s), done_fun(dfun), user_data(udata)
  {
  executor = new Exec_process;
  status_ctx = gtk_statusbar_get_context_id(status, "execstatus");
          // Keep one msg. always on stack.
  gtk_statusbar_push(status, status_ctx, "");
  }

/*
 *  Close.
 */

Exec_box::~Exec_box
  (
  )
  {
  delete executor;    // Kills child.
  }

/*
 *  Show status.
 */

void Exec_box::show_status
  (
  const char *msg
  )
  {
  gtk_statusbar_pop(status, status_ctx);
  gtk_statusbar_push(status, status_ctx, msg);
  }

/*
 *  Read from child & display in the text box.
 */

static void Exec_callback
  (
  char *data,     // Data read, or NULL.
  int datalen,      // Length, or 0 if child exited.
  int exit_code,      // Exit code if datalen = 0.
  void *user_data     // ->Exex_box
  )
  {
  Exec_box *box = (Exec_box *) user_data;
  box->read_from_child(data, datalen, exit_code);
  }
void Exec_box::read_from_child
  (
  char *data,     // Data read, or NULL.
  int datalen,      // Length, or 0 if child exited.
  int exit_code     // Exit code if datalen = 0.
  )
  {
  if (datalen > 0)
    {
    GtkTextBuffer *buffer = gtk_text_view_get_buffer(box);
    gtk_text_buffer_insert_at_cursor(buffer,data,datalen);
    return;
    }
  if (exit_code == 0)   // Child is done, so check result.
    show_status("Done:  Success");
  else
    show_status("Done:  Errors occurred");
  if (done_fun)
    done_fun(exit_code, this, user_data);
  }

/*
 *  Add a message to the box.
 */

void Exec_box::add_message
  (
  const char *txt
  )
  {
  GtkTextBuffer *buffer = gtk_text_view_get_buffer(box);
  gtk_text_buffer_insert_at_cursor(buffer,txt,strlen(txt));
  }

/*
 *  Execute a new process.
 *
 *  Output: False if failed.
 */

bool Exec_box::exec
  (
  const char *file,     // PATH will be searched.
  char *argv[]      // Args.  1st is filename, last is 0.
  )
  {
  GtkTextBuffer *buffer = gtk_text_view_get_buffer(box);
  gtk_text_buffer_set_text(buffer, "", 0);  // Clear out old text
  if (!executor->exec(file, argv, Exec_callback, this))
    return false;
  return true;
  }

/*
 *  End process.
 */

void Exec_box::kill_child
  (
  )
  {
  executor->kill_child();
  }

---