wrapper.c File Reference

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

Include dependency graph for wrapper.c:

Go to the source code of this file.

Macros
#define	SIZE   1024 /**buffer size */
	UNIX headers. More...
#define	SIGNAL_TAG   "# jpips send signal to tpips "
#define	CHECKPOINT   "CHECKPOINT"
	available tags More...
#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 */
#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()"); }

Typedefs
typedef void(*	sig_handler_t) (int)

Functions
static void	tpw_log (__attribute__((__unused__)) char *message)
	Enable log with -DLOG for debug. More...
static void	tpw_fatal_error (char *message)
static void	tpw_check_perror (int en, char *message)
	checks returned value for most system commands (-1 and errno set). More...
static void	tpw_sig_handler (int sn)
	signal handler for tpips_wrapper. More...
static void	tpw_set_sig_handlers (void)
	special handlers for tpips wrapper. More...
static pid_t	tpw_fork_inout (void)
	fork, with stdout-stdin link kept More...
static char *	tpw_read_line (FILE *in)
static void	tpw_send_string_to_tpips (char *line)
	send line to tpips. More...
void	tpips_wrapper (void)
	fork a tpips to goes on, while the current process acts as a wrapper, which forwards orders, and perform some special signal handling. More...

Variables
static pid_t	tpips_pid = 0
	global because needed in tpw_fatal_error. More...
static FILE *	in_from_wrapper = NULL
static FILE *	out_to_tpips = NULL

Macro Definition Documentation

ABORTIT

#define ABORTIT   "ABORT"

Definition at line 73 of file wrapper.c.

CHECKPOINT

#define CHECKPOINT   "CHECKPOINT"

available tags

Definition at line 70 of file wrapper.c.

INTERRUPT

#define INTERRUPT   "INTERRUPT"

Definition at line 71 of file wrapper.c.

KILL

#define KILL	(		pid,
			sig
	)		if (pid!=0) { tpw_check(kill(pid,sig),"kill()"); }

Definition at line 118 of file wrapper.c.

KILLNOW

#define KILLNOW   "EXIT"

Definition at line 72 of file wrapper.c.

SIGNAL_TAG

#define SIGNAL_TAG   "# jpips send signal to tpips "

Definition at line 66 of file wrapper.c.

SIZE

#define SIZE   1024 /**buffer size */

UNIX headers.

Standard C headers.

Definition at line 64 of file wrapper.c.

starts_with

#define starts_with	(		s1,
			s2
	)		(strncmp(s1, s2, strlen(s2))==0) /**a la java */

Definition at line 77 of file wrapper.c.

tpw_check

#define tpw_check	(		what,
			comment
	)		tpw_log(comment), tpw_check_perror(what, comment)

Definition at line 116 of file wrapper.c.

WRAPPER

#define WRAPPER   "[tpips_wrapper] "

Definition at line 75 of file wrapper.c.

Typedef Documentation

sig_handler_t

typedef void(* sig_handler_t) (int)

Definition at line 120 of file wrapper.c.

Function Documentation

tpips_wrapper()

void tpips_wrapper

(

void

)

fork a tpips to goes on, while the current process acts as a wrapper, which forwards orders, and perform some special signal handling.

wrapper.c

the child is a new tpips, it keeps on executing... the parent just acts as a wrapper, it never returns from here.

CHILD is tpips and returns.

code for the WRAPPER starts here. the PARENT.

special handlers.

forward to tpips. how to ensure that tpips is alive? SIGCHLD and SIGPIPE are caught.

handle signals.

stop tpips on EOF.

wrapper mission done.

Definition at line 270 of file wrapper.c.

{
    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. */
}

References ABORTIT, CHECKPOINT, exit, INTERRUPT, KILL, KILLNOW, line, SIGNAL_TAG, starts_with, tpips_pid, tpw_fatal_error(), tpw_fork_inout(), tpw_log(), tpw_read_line(), tpw_send_string_to_tpips(), and tpw_set_sig_handlers().

Referenced by parse_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_check_perror()

static void tpw_check_perror ( int  en, char *  message  )

static

checks returned value for most system commands (-1 and errno set).

Definition at line 107 of file wrapper.c.

{
    if (en==-1)
    {
        perror(message);
        tpw_fatal_error(message);
    }
}

References tpw_fatal_error().

Here is the call graph for this function:

tpw_fatal_error()

static void tpw_fatal_error ( char *  message )

static

Definition at line 97 of file wrapper.c.

{
    fprintf(stderr, WRAPPER "fatal error: %s\n", message);
    fflush(stderr);
    kill(tpips_pid, SIGKILL);
    exit(1);
}

References exit, fprintf(), tpips_pid, and WRAPPER.

Referenced by tpips_wrapper(), tpw_check_perror(), tpw_send_string_to_tpips(), and tpw_sig_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_fork_inout()

static pid_t tpw_fork_inout ( void  )

static

fork, with stdout-stdin link kept

Returns

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.

create pipe.

fork

CHILD

stdin = in_from_wrapper;

PARENT

the output might be interleaved with tpips output... maybe I should lock stderr.

Definition at line 190 of file wrapper.c.

{
   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;
}

References fprintf(), in_from_wrapper, out_to_tpips, tpw_check, tpw_log(), and WRAPPER.

Referenced by tpips_wrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_log()

static void tpw_log ( __attribute__((__unused__)) char *  message )

static

Enable log with -DLOG for debug.

Definition at line 85 of file wrapper.c.

{
#if defined(LOG)
    fprintf(stderr, WRAPPER "%s\n", message);
    fflush(stderr);
#endif
}

References fprintf(), and WRAPPER.

Referenced by tpips_wrapper(), and tpw_fork_inout().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_read_line()

static char* tpw_read_line ( FILE *  in )

static

Returns

a line from "in", or NULL at EOF. @caution a pointer to a static buffer is returned!

Definition at line 238 of file wrapper.c.

{
    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;
}

References buffer, and SIZE.

Referenced by tpips_wrapper().

Here is the caller graph for this function:

tpw_send_string_to_tpips()

static void tpw_send_string_to_tpips ( char *  line )

static

send line to tpips.

could send a signal to tpips to warn about the incoming command. it would be read from in_from_wrapper only.

Definition at line 254 of file wrapper.c.

{
    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.
     */
}

References line, out_to_tpips, and tpw_fatal_error().

Referenced by tpips_wrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_set_sig_handlers()

static void tpw_set_sig_handlers ( void  )

static

special handlers for tpips wrapper.

Definition at line 166 of file wrapper.c.

{
    (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);
}

References tpw_sig_handler().

Referenced by tpips_wrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

tpw_sig_handler()

static void tpw_sig_handler ( int  sn )

static

signal handler for tpips_wrapper.

basically forwards signals to tpips. tries to stop tpips before exiting. stops if tpips is stopped.

these signals are traced.

forward signals to tpips.

tpips stopped.

idem?

reset signal handler.

Parameters

sn	signal number

Definition at line 127 of file wrapper.c.

{
    /* 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);
}

References exit, fprintf(), KILL, tpips_pid, tpw_fatal_error(), and WRAPPER.

Referenced by tpw_set_sig_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

in_from_wrapper

FILE* in_from_wrapper = NULL

static

Definition at line 181 of file wrapper.c.

Referenced by tpw_fork_inout().

out_to_tpips

FILE* out_to_tpips = NULL

static

Definition at line 182 of file wrapper.c.

Referenced by tpw_fork_inout(), and tpw_send_string_to_tpips().

tpips_pid

pid_t tpips_pid = 0

static

global because needed in tpw_fatal_error.

Definition at line 81 of file wrapper.c.

Referenced by tpips_wrapper(), tpw_fatal_error(), and tpw_sig_handler().