The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Поиск:  Каталог документации

Next Previous Contents

3. File procautostart.cpp

// From your browser save this file as text-file named as 'procautostart.cpp'.


//
// Program to monitor the unix processes
// and automatically re-start them if they die
//

#include <stdio.h>
#include <strings.h> // C strings
#include <unistd.h> // for getopt
#include <alloc.h> // for free

#include <errno.h> // for kill() - error numbers command
extern int errno;

#ifdef Linux
#include <asm/errno.h> // for kill() - error numbers command
#endif

#include <sys/types.h> // for kill() command
#include <signal.h> // for kill() command
#include <sys/wait.h> // for wait()
#include <stdlib.h> // for setenv()
#include <time.h> // for strftime()
#include <libgen.h> // for basename()

#include "debug.h"

#define BUFF_HUN        100
#define BUFF_THOU       1024
#define PR_INIT_VAL     -10
#define WAIT_FOR_SYS    5  // wait for process to start up
#define DEF_SL_SECS     6  // default sleep time
#define SAFE_MEM        10  // to avoid any possible memory leaks

#define LOG_NO          false  // do not output to logfile
#define LOG_YES         true  // do output to logfile
#define STD_ERR_NO      false  // do not print to std err
#define STD_ERR_YES     true  // do print to std err
#define DATE_NO         false  // do not print date
#define DATE_YES        true  // do print date

int start_process(char *commandline, char *args[], char **envp, pid_t proc_pid);
int fork2(pid_t parent_pid, unsigned long tsecs);
inline void error_msg(char *mesg_out, char *lg_file, bool pr_lg, bool std_err, bool pr_dt);

//////////////////////////////////////////////
// To test this program use --
// procautostart -n 5 -c 'monitor_test dummy1 -a dummy2 -b dummy3  ' &
//////////////////////////////////////////////
int main(int argc, char **argv, char **envp)
{
        unsigned long   sleep_sec, sleep_micro, sleep_nano;
        int     ch;
        pid_t   proc_pid;
        int pr_no = PR_INIT_VAL;
        char mon_log[40];
        char *pr_name = NULL, *cmd_line = NULL, **cmdargs = NULL;

        // you can turn on debug by editing Makefile and put -DDEBUG in gcc
        debug_("test debug", "this line"); 
        debug_("argc", argc); 

        // Use getpid() - man 2 getpid()
        proc_pid = getpid(); // get the Process ID of procautostart
        debug_("PID proc_pid", (int) proc_pid);

        // Create directory to hold log, temp files
        system("mkdir mon 1>/dev/null 2>/dev/null");

        sleep_sec = DEF_SL_SECS ; // default sleep time
        sleep_micro = 0; // default micro-sleep time
        sleep_nano = 0; // default nano-sleep time
        optarg = cmd_line = NULL;
        while ((ch = getopt(argc, argv, "n:m:o:h:c:")) != -1) // needs trailing colon :
        {
                switch (ch)
                {
                        case 'n':
                                debug_("scanned option n ", optarg);
                                sleep_sec = atoi(optarg);       
                                debug_("sleep_sec", sleep_sec);
                                break;
                        case 'm':
                                debug_("scanned option m ", optarg);
                                sleep_micro = atoi(optarg);     
                                debug_("sleep_micro", sleep_micro);
                                break;
                        case 'o':
                                debug_("scanned option o ", optarg);
                                sleep_nano = atoi(optarg);      
                                debug_("sleep_nano", sleep_nano);
                                break;
                        case 'c':
                                debug_("scanned option c ", optarg);
                                cmd_line = strdup(optarg); // does auto-malloc here
                                debug_("cmd_line", cmd_line);
                                break;
                        case 'h':
                                debug_("scanned option h ", optarg);
                                fprintf(stderr, "\nUsage : %s -n <sleep> -m <microsecond> -o <nanosecond> -c '<command>'\n", argv[0]);
                                exit(-1);
                                break;
                        default:
                                debug_("ch", "default");
                                fprintf(stderr, "\nUsage : %s -n <sleep> -m <microsecond> -o <nanosecond> -c '<command>'\n", argv[0]);
                                exit(-1);
                                break;
                }
        }

        if (cmd_line == NULL)
        {
                fprintf(stderr, "\ncmd_line is NULL");
                fprintf(stderr, "\nUsage : %s -n <sleep> -m <microsecond> -o <nanosecond> -c '<command>'\n", argv[0]);
                exit(-1);
        }
        else
        {
                // trim the trailing blanks -- otherwise problem in grep command
                int tmpii = strlen(cmd_line);
                for (int tmpjj = tmpii; tmpjj > -1; tmpjj--)
                {
                        if (cmd_line[tmpjj] == ' ')
                                cmd_line[tmpjj] = '\0';
                        else
                        if (cmd_line[tmpjj] == '&')  // discards amp-and .. we will be appending later
                                cmd_line[tmpjj] = '\0';
                        else
                        if (cmd_line[tmpjj] == '\0')
                                continue;
                        else
                        {
                                if (cmd_line[tmpjj] == '&') // Discard trailing & in command line
                                        cmd_line[tmpjj] = '\0';
                                break;
                        }
                }
                debug_("cmd_line", cmd_line);
        }

        //argv0 = (char *) strdup(argv[0]);
        //debug_("argv0", argv0); 

        // Start the process
        {
                // Find the command line args
                char *aa = strdup(cmd_line), *bb = NULL;
                cmdargs = (char **) (malloc(sizeof(char **) + SAFE_MEM));
                for (int tmpii = 0; ; tmpii++)
                {
                        // Allocate more memory ....
                        cmdargs = (char **) realloc(cmdargs, (sizeof(char **) * (tmpii+1) + SAFE_MEM)  );

                        if (tmpii == 0)
                                bb = strtok(aa, " ");
                        else
                                bb = strtok(NULL, " "); // subsequent calls must have NULL as first arg

                        if (bb == NULL)
                        {
                                cmdargs[tmpii] = bb;
                                break;
                        }
                        else
                        {
                                // Must malloc with strdup because aa, bb are 
                                // local vars in local scope!!
                                cmdargs[tmpii] = strdup(bb);
                        }

                        debug_("tmpii", tmpii);
                        debug_("cmdargs[tmpii]", (char *) cmdargs[tmpii]);
                }

                // In case execve you MUST NOT have trailing ampersand & in the command line!!
                //pr_no = start_process(cmd_line, NULL, NULL, proc_pid);  // Using execlp ...
                pr_no = start_process(cmdargs[0], & cmdargs[0], envp, proc_pid); // Using execve ....

                debug_("The child pid", pr_no);
                if (pr_no < 0)
                {
                        fprintf(stderr, "\nFatal Error: Failed to start the process\n");
                        exit(-1);
                }
                sleep(WAIT_FOR_SYS); // wait for the process to come up

                // Get process name - only the first word from cmd_line
                pr_name = strdup(basename(cmdargs[0])); // process name,  does auto-malloc here
        }

        // generate log file names
        {
                char    aa[21];

                strncpy(aa, pr_name, 20); aa[20] = '\0';
                // Define mon file-names - make it unique with combination of
                // process name and process id
                sprintf(mon_log, "mon/%s%d.log", aa, (int) proc_pid);
        }

        // Print out pid to log file
        if (pr_no > 0)
        {
                char aa[200];
                sprintf(aa, "Process ID of %s is %d", pr_name, pr_no);
                error_msg(aa, mon_log, LOG_YES, STD_ERR_NO, DATE_YES);
        }

        // monitors the process - restarts if process dies...
        bool process_died = false;
        char print_log[200];
        while (1)  // infinite loop - monitor every 6 seconds
        {
                //debug_("Monitoring the process now...", ".");
                if (kill(pr_no, 0))  // if (kill(pr_no,0) != 0)
                {
                        debug_("errno from kill() function", errno);
                        if (errno == EINVAL)
                        {
                                process_died = false; // unable to execute kill() - wrong input
                                strcpy(print_log, "Error EINVAL: Invalid signal was specified");
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_YES, DATE_YES);
                        }
                        else
                        if (errno == ESRCH )
                        {
                                // ERSRCH means - No process can be found corresponding to pr_no
                                // hence process had died !!
                                process_died = true; // No process can be found matching pr_no
                                sprintf(print_log, 
                                "Error ESRCH: No process or process group can be found for %d", pr_no);
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_YES, DATE_YES);
                        }
                        else
                        if (errno == EPERM)
                        {
                                process_died = false; // unable to execute kill() - wrong input
                                strcpy(print_log, 
                                "Error EPERM: The real or saved user ID does not match the real user ID");
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_YES, DATE_YES);
                        }
                        else
                        {
                                process_died = true; // process died!! restart now
                                debug_("process_die ", "others");
                        }

                        if (process_died == true)
                        {
                                //
                                // char respawn[1024];
                                // strcpy(respawn, cmd_line);
                                //
                                // For "C" program use kill(pid_t process, int signal) function. 
                                // #include <signal.h> // See 'man 2 kill'  
                                // Returns 0 on success and -1 with errno set.
                                //              kill -0 $pid 2>/dev/null || respawn
                                // To get the exit return status do --
                                //              kill -0 $pid 2>/dev/null | echo $?
                                // Return value 0 is success and others mean failure
                                // Sending 0 does not do anything to target process, but it tests
                                // whether the process exists. The kill command will set its exit
                                // status based on this process.
                                //
                                // Alternatively, you can use
                                //              ps -p $pid >/dev/null 2>&1 || respawn
                                // To get the exit return status do --
                                //              ps -p $pid >/dev/null 2>&1 | echo $?
                                // Return value 0 is success and others mean failure
                                //

                                // If the process had died, restart and  re-assign the pid to pr_no
                                // start the process in background ....
                                // Now re-assign new value of process id to pr_no
                                if (pr_no > 0 )
                                        sprintf(print_log, "Fatal Error: Process %s with PID = %d died!!",
                                                pr_name, pr_no);
                                else
                                        sprintf(print_log, "Fatal Error: Process %s is not up!!",
                                                pr_name);
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_YES, DATE_YES);

                                sprintf(print_log, "Starting process %s", pr_name);
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_NO, DATE_NO);

                                //pr_no = start_process(cmd_line, NULL, NULL, proc_pid);  // Using execlp ....
                                pr_no = start_process(cmdargs[0], & cmdargs[0], envp, proc_pid); // Using execve ....

                                debug_("The child pid", pr_no);
                                if (pr_no < 0)
                                {
                                        sprintf(print_log, "Fatal Error: Failed to start the process");
                                        error_msg(print_log, mon_log, LOG_YES, STD_ERR_YES, DATE_YES);
                                        exit(-1);
                                }
                                sleep(WAIT_FOR_SYS); // wait for the process to come up
                                sprintf(print_log, "Process ID of %s is %d", pr_name, pr_no);
                                error_msg(print_log, mon_log, LOG_YES, STD_ERR_NO, DATE_NO);
                        }
                }
                //debug_("Sleeping now ......", ".");
                sleep(sleep_sec);

                // Uncomment these to use micro-seconds
                // For real-time process control use micro-seconds or nana-seconds sleep functions
                // See 'man3 usleep', 'man 2 nanasleep'
                // If you do not have usleep() or nanosleep() on your system, use select() or poll()
                // specifying no file descriptors to test.
                //usleep(sleep_micro);

                // To sleep nano-seconds ...  Uncomment these to use nano-seconds
                //struct timespec *req = new struct timespec;
                //req->tv_sec = 0; // seconds
                //req->tv_nsec = sleep_nano; // nanoseconds
                //nanosleep( (const struct timespec *)req, NULL);
        }
}

inline void error_msg(char *mesg_out, char *lg_file, bool pr_lg, bool std_err, bool pr_dt)
{
        if (pr_lg) // (pr_lg == true) output to log file
        {
                char tmp_msg[BUFF_THOU];
                if (pr_dt == true) // print date and message to log file 'lg_file'
                {
                        sprintf(tmp_msg, "date >> %s; echo '\n%s\n' >> %s\n ", 
                                lg_file, mesg_out, lg_file);
                        system(tmp_msg);
                }
                else
                {
                        sprintf(tmp_msg, "echo '\n%s\n' >> %s\n ", 
                                mesg_out, lg_file);
                        system(tmp_msg);
                }
        }

        if (std_err) // (std_err == true) output to standard error
                fprintf(stderr, "\n%s\n", mesg_out);
        
        debug_("mesg_out", mesg_out);
}

// start a process and returns PID or -ve value if error
// The main() function has envp arg as in - main(int argc, char *argv[], char **envp)
int start_process(char *commandline, char *args[], char **envp, pid_t parent_pid)
{
        int ff;
        unsigned long  tsecs;

        tsecs = time(NULL); // time in secs since Epoch 1 Jan 1970
        debug_("Time tsecs", tsecs); 

        // Use fork2() instead of fork to avoid zombie child processes
        switch (ff = fork2(parent_pid, tsecs))  // fork creates 2 process each executing the following lines
        {
        case -1:
                fprintf(stderr, "\nFatal Error: start_process() - Unable to fork process\n");
                _exit(errno);
                break;
        case 0:  // child process
                debug_("\nStarting the start child process\n", " ");
                // For child process to ignore the interrupts (i.e. to put
                // child process in "background" mode.
                // Signals are sent to all processes started from a 
                // particular terminal. Accordingly, when a program is to be run non-interactively
                // (started by &), the shell arranges that the program will ignore interrupts, so
                // it won't be stopped by interrupts intended for foreground processes.
                // Hence if previous value of signal is not IGN than set it to IGN.

                // Note: Signal handlers cannot be set for SIGKILL, SIGSTOP 
                if (signal(SIGINT, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGINT\n");
                else
                if (signal(SIGINT, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGINT, SIG_IGN);  // ignore interrupts

                if (signal(SIGHUP, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGHUP\n");
                else
                if (signal(SIGHUP, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGHUP, SIG_IGN);  // ignore hangups

                if (signal(SIGQUIT, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGQUIT\n");
                else
                if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGQUIT, SIG_IGN);  // ignore Quit

                if (signal(SIGABRT, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGABRT\n");
                else
                if (signal(SIGABRT, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGABRT, SIG_IGN);  // ignore ABRT

                if (signal(SIGTERM, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGTERM\n");
                else
                if (signal(SIGTERM, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGTERM, SIG_IGN);  // ignore TERM

                // sigtstp - Stop typed at tty. Ignore this so that parent process 
                // be put in background with CTRL+Z or with SIGSTOP
                if (signal(SIGTSTP, SIG_IGN) == SIG_ERR)
                        fprintf(stderr, "\nSignal Error: Not able to set signal to SIGTSTP\n");
                else
                if (signal(SIGTSTP, SIG_IGN) != SIG_IGN) // program already run in background
                        signal(SIGTSTP, SIG_IGN);  // ignore TSTP

                // You can use debug_ generously because they do NOT increase program size!
                debug_("before execve commandline", commandline);
                debug_("before execve args[0]", args[0]);
                debug_("before execve args[1]", args[1]);
                debug_("before execve args[2]", args[2]);
                debug_("before execve args[3]", args[3]);
                debug_("before execve args[4]", args[4]);
                debug_("before execve args[5]", args[5]);
                debug_("before execve args[6]", args[6]);
                debug_("before execve args[7]", args[7]);
                execve(commandline, args, envp);

                // execlp, execvp does not provide expansion of metacharacters
                // like <, >, *, quotes, etc., in argument list. Invoke
                // the shell /bin/sh which then does all the work. Construct
                // a string 'commandline' that contains the complete command
                //execlp("/bin/sh", "sh", "-c", commandline, (char *) 0);  // if success than NEVER returns !!

                // If execlp returns than there is some serious error !! And
                // executes the following lines below...
                fprintf(stderr, "\nFatal Error: Unable to start child process\n");
                ff = -2;
                exit(127);
                break;
        default: // parent process
                // child pid is ff;
                if (ff < 0)
                        fprintf(stderr, "\nFatal Error: Problem while starting child process\n");

                {
                        char    buff[BUFF_HUN];
                        FILE    *fp1;
                        sprintf(buff, "mon/%d%lu.out", (int) parent_pid, tsecs); // tsecs is unsigned long
                        fp1 = fopen(buff, "r");
                        if (fp1 != NULL)
                        {
                                buff[0] = '\0';
                                fgets(buff, BUFF_HUN, fp1);
                                ff = atoi(buff);
                        }
                        fclose(fp1);
                        debug_("start process(): ff - ", ff);
#ifndef DEBUG
                        sprintf(buff, "rm -f mon/%d%lu.out", (int) parent_pid, tsecs);
                        system(buff);
#endif // DEBUG
                }

                // define wait() to put child process in foreground or else put in background
                //waitpid(ff, & status, WNOHANG || WUNTRACED);
                //waitpid(ff, & status, WUNTRACED);
                //wait(& status); 

                break;
        }
        return ff;
}

/* fork2() -- like fork, but the new process is immediately orphaned
 *            (won't leave a zombie when it exits)
 * Returns 1 to the parent, not any meaningful pid.
 * The parent cannot wait() for the new process (it's unrelated).
 */
/* This version assumes that you *haven't* caught or ignored SIGCHLD. */
/* If you have, then you should just be using fork() instead anyway.  */

int fork2(pid_t parent_pid, unsigned long tsecs)
{
    pid_t mainpid, child_pid = -10;
    int status;
        char    buff[BUFF_HUN];

    if (!(mainpid = fork()))
    {
        switch (child_pid = fork())
        {
          case 0:
                        //child_pid = getpid();
                        //debug_("At case 0 fork2 child_pid : ", child_pid);
                        return 0;
          case -1:
                        _exit(errno);    /* assumes all errnos are <256 */
          default: 
                        debug_("fork2 child_pid : ", (int) child_pid);
                        sprintf(buff, "echo %d > mon/%d%lu.out", (int) child_pid, (int) parent_pid, tsecs);
                        system(buff);
                        _exit(0);
        }
    }

        //debug_("fork2 pid : ", pid);
    if (mainpid < 0 || waitpid(mainpid, & status, 0) < 0)
      return -1;

    if (WIFEXITED(status))
      if (WEXITSTATUS(status) == 0)
        return 1;
      else
        errno = WEXITSTATUS(status);
    else
      errno = EINTR;  /* well, sort of :-) */

    return -1;
}


Next Previous Contents


Спонсоры:
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей
Created 1996-2021 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру