wrapper.c

Go to the documentation of this file.

/*
 
  $Id: wrapper.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS 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 3 of the License, or
  any later version.
 
  PIPS 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 PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
 * UNIX wrapper around tpips for jpips, for signal management.
 * Under special comments on the pipe, signals are sent to tpips.
 * I could not use popen() because I found no way to access the pid
 * of the child process. Basically this is a re-implementation of popen().
 *
 * stdin TPIPS -w [stdout -> stdin] TPIPS stdout
 *
 * The full picture with jpips:
 *
 *                                         -> kill/signal ->
 *       -> OutputStream/stdin -> TPIPS -w -> out/stdin   ->
 * JPIPS                                                     TPIPS
 *       <- InputStream/stdout <----------------------------
 *
 *
 * What we might have some day:
 *
 * tty <-> EMACS <-> JPIPS > TPIPS -W s> TPIPS <-> XTERM 
 *                         <---------------+
 *
 * @author Fabien Coelho (with some advises from Ronan Keryell)
 */
 
/* UNIX headers.
 */
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
 
/* Standard C headers.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#define SIZE            1024                            /* buffer size */
 
#define SIGNAL_TAG      "# jpips send signal to tpips "
 
/* available tags
 */
#define CHECKPOINT      "CHECKPOINT"
#define INTERRUPT       "INTERRUPT"
#define KILLNOW         "EXIT"
#define ABORTIT         "ABORT"
 
#define WRAPPER         "[tpips_wrapper] "
 
#define starts_with(s1, s2) (strncmp(s1, s2, strlen(s2))==0) /* a la java */
 
/* global because needed in tpw_fatal_error.
 */
static pid_t tpips_pid = 0;
 
/* Enable log with -DLOG for debug.
 */
static void tpw_log(
#ifndef LOG
  __attribute__((__unused__))
#endif
  char * message)
{
#if defined(LOG)
    fprintf(stderr, WRAPPER "%s\n", message);
    fflush(stderr);
#endif
}
 
static void tpw_fatal_error(char * message)
{
    fprintf(stderr, WRAPPER "fatal error: %s\n", message);
    fflush(stderr);
    kill(tpips_pid, SIGKILL);
    exit(1);
}
 
/* checks returned value for most system commands (-1 and errno set).
 */
static void tpw_check_perror(int en, char * message)
{
    if (en==-1)
    {
        perror(message);
        tpw_fatal_error(message);
    }
}
 
#define tpw_check(what, comment) \
        tpw_log(comment), tpw_check_perror(what, comment)
#define KILL(pid,sig) if (pid!=0) { tpw_check(kill(pid,sig),"kill()"); }
 
typedef void (*sig_handler_t)(int);
 
/* signal handler for tpips_wrapper.
 * basically forwards signals to tpips.
 * tries to stop tpips before exiting.
 * stops if tpips is stopped.
 */
static void tpw_sig_handler(int sn /* signal number */)
{
    /* these signals are traced.
     */
    fprintf(stderr, WRAPPER "signal %d caught!\n", sn);
    fflush(stderr);
 
    switch (sn)
    {
    case SIGHUP:
    case SIGINT:
    case SIGTERM:
    case SIGUSR1:
    case SIGUSR2:
        /* forward signals to tpips.
         */
        KILL(tpips_pid, sn); 
        break;
    case SIGQUIT:
    case SIGABRT:
    case SIGCHLD: /* tpips stopped. */
    case SIGPIPE: /* idem? */
        fprintf(stderr, WRAPPER "killing tpips...\n");
        fflush(stderr);
        KILL(tpips_pid, SIGKILL);
        exit(2);
        break;
    default:
        fprintf(stderr, WRAPPER "unexpected signal (%d)\n", sn);
        tpw_fatal_error("unexpected signal");
    }
 
    /* reset signal handler.
     */
    (void) signal(sn, tpw_sig_handler);
}
 
/* special handlers for tpips wrapper.
 */
static void tpw_set_sig_handlers(void)
{
    (void) signal(SIGHUP,  tpw_sig_handler);
    (void) signal(SIGINT,  tpw_sig_handler);
    (void) signal(SIGTERM, tpw_sig_handler);
 
    (void) signal(SIGUSR1, tpw_sig_handler);
    (void) signal(SIGUSR2, tpw_sig_handler);
 
    (void) signal(SIGQUIT, tpw_sig_handler);
    (void) signal(SIGABRT, tpw_sig_handler);
    (void) signal(SIGCHLD, tpw_sig_handler);
    (void) signal(SIGPIPE, tpw_sig_handler);
}
 
static FILE * in_from_wrapper = NULL;
static FILE * out_to_tpips = NULL;
 
/* fork, with stdout-stdin link kept
 * @return the created pid.
 * should be in_from_jpips instead of stdin?
 * what about out_to_jpips and the wrapper???
 * fdopen() might be of some help.
 */
static pid_t tpw_fork_inout(void)
{
   int filedes[2];
   pid_t process;
   
   /* create pipe. 
    */
   tpw_check(pipe(filedes), "pipe()");
 
   /* fork 
    */
   process = fork();
   tpw_check(process, "fork()");
 
   if (process==0)
   {
       /* CHILD
        */
       in_from_wrapper = fdopen(filedes[0], "r");
       if (!in_from_wrapper) tpw_check(-1, "fdopen()");
       
       tpw_check(dup2(filedes[0], 0), "dup2()"); /* stdin = in_from_wrapper; */
   }
   else
   {
       /* PARENT 
        */
       out_to_tpips = fdopen(filedes[1], "w");
       if (!out_to_tpips) tpw_check(-1, "fdopen()");
   }
 
   if (process) 
   {
       /* the output might be interleaved with tpips output...
        * maybe I should lock stderr.
        */
       fprintf(stderr, WRAPPER "started, tpips pid is %d\n", (int) process);
       fflush(stderr);
   }
 
   tpw_log("tpw_fork_inout() done");
 
   return process;
}
 
/* @return a line from "in", or NULL at EOF.
 * @caution a pointer to a static buffer is returned!
 */
static char * tpw_read_line(FILE * in)
{
    static char buffer[SIZE]; 
    int c=0, i=0;
 
    while (c != '\n' && i<SIZE-1 && (c = getc(in))!=EOF)
        buffer[i++] = (char) c;
 
    if (i==0) return NULL;
 
    buffer[i++] = '\0';
    return buffer;
}
 
/* send line to tpips.
 */
static void tpw_send_string_to_tpips(char * line)
{
    if (!out_to_tpips) 
        tpw_fatal_error("no out_to_tpips");
 
    fputs(line, out_to_tpips);
    fflush(out_to_tpips);
    
    /* could send a signal to tpips to warn about the incoming command.
     * it would be read from in_from_wrapper only.
     */
}
 
/* fork a tpips to goes on, while the current process acts as a wrapper,
 * which forwards orders, and perform some special signal handling.
 */
void tpips_wrapper(void)
{
    char * line;
 
    tpips_pid = tpw_fork_inout();
 
    /* the child is a new tpips, it keeps on executing...
     * the parent just acts as a wrapper, it never returns from here.
     */
    if (tpips_pid==0) return; /* CHILD is tpips and returns. */
 
    /* code for the WRAPPER starts here. the PARENT.
     */
 
    /* special handlers.
     */
    tpw_set_sig_handlers();
 
    while ((line = tpw_read_line(stdin)))
    {
        /* forward to tpips.
         * how to ensure that tpips is alive?
         * SIGCHLD and SIGPIPE are caught.
         */
        tpw_send_string_to_tpips(line);
 
        /* handle signals.
         */
        if (starts_with(line, SIGNAL_TAG))
        {
            line += strlen(SIGNAL_TAG);
 
            if (starts_with(line, CHECKPOINT)) {
                KILL(tpips_pid, SIGUSR1);
            } else if (starts_with(line, INTERRUPT)) {
                KILL(tpips_pid, SIGINT);
            } else if (starts_with(line, ABORTIT)) {
                KILL(tpips_pid, SIGABRT);
            } else if (starts_with(line, KILLNOW)) {
                KILL(tpips_pid, SIGUSR2);
            } else {
                tpw_fatal_error(line);
            }
        }
    }
 
    /* stop tpips on EOF.
     */
    tpw_log("exiting...");
    fputs("exit\n", stdout);
    fclose(stdout);
    KILL(tpips_pid, SIGKILL);
 
    exit(0); /* wrapper mission done. */
}