/*********************************************************************
   이  름 :   superdaemon - 등록된 프로그램을 실행 및 관리
   버  전 :   1.0.2
                    -  get_execinfo() 함수 추가
                    -  read_task_list() 함수에서 task_t 정보를 모두 구성하도록 수정
              1.0.1
                    -  자시 프로세스에서 프로그램을 식행하기 전에
                       부모 프로세스의 타스크 정보에 생성한 프로세스의 ID를
                       지정하는 시간을 벌어 주기 위해 sleep()함수를 호출
              1.0.0
  *********************************************************************/
  #include  <stdio.h>
  #include  <stdlib.h>
  #include  <signal.h>
  #include  <string.h>
  #include  <sys/types.h>
  #include  <sys/wait.h>
  #include  <unistd.h>
  #include  "main.h"
  #include  "projectinc.h"
  
  #define  PATH_SIZE         255
  #define  TASK_ARRAY_SIZE   20
  
  task_t   ary_task[TASK_ARRAY_SIZE];                                     // 타스크 배열
  int      cnt_task;                                                      // 실행한 타스크의 개수
  
  //--------------------------------------------------------------------
  // desc   차일드 프로세스가 종료되면 발생하는 이벤트 핸들러
  // params sig
  // ref    종료된 차일드 프로세스에 해당하는 ary_task 의 아이템 값을
  //        수정한다.
  //
  //        ary_task 아이템 값을 수정하면, main() 에서 check_task_list()
  //        를 호출함으로써 다시 실행하게 된다.
  //--------------------------------------------------------------------
  void on_check_child( int sig)
  {
     pid_t    pid;
     int      result;
     int      ndx;
  
                                   // 종료된 차일드 프로세스에 해당하는 ary_task 아이템을 찾는다.
                                   // task_t 아이템의 pid 를 0 으로 설정하면 check_task_lisk() 에서
                                   // count_down 값을 감소하고, 0 이되면 다시 실행하게 된다.
  
     while( 0 < ( pid = waitpid( -1, &result, WNOHANG)))
     {                                                                    dp( "killed child pid=%d", pid);
        for ( ndx= 0; ndx < cnt_task; ndx++)
        {                                                                 dp( "checked child pid=%d %s", ary_task[ndx].pid, ary_task[ndx].full_filename);
           if ( pid == ary_task[ndx].pid)
           {
              ary_task[ndx].count_down   = ary_task[ndx].interval;        // 다시 실행하기 까지의 대기 시간(초)
              ary_task[ndx].pid          = 0;                             // check_task_list() 의 대상이 되도록 0 으로 초기화
           }
        }
     }
  }
  
  //--------------------------------------------------------------------
  // desc   _str 에서 첫번째 공백 문자 전까지
  //             또는 공백 문자가 없을 때에는 문자열 끝까지를 _rst
  //             에 복사한다.
  // params _str 원본 문자열을 가지고 있는 변수
  //        _rst 문자열을 복사 받을 변수
  // ret    복사 문자열 다음의 문자 위치의 포인터
  //--------------------------------------------------------------------
  char *str_spc( char *_str, char *_rst)
  {
     char *pos;
  
     *_rst = '\0';                                                        // NULL 을 대입
     pos = index(_str, ' ');
     if ( !pos)                                                           // 공백 구분자가 없다면 다음 루프로
     {
        strcpy(_rst, _str);
     }
     else
     {
        strncpy(_rst, _str, pos-_str);
        _rst[pos-_str]  = '\0';
        while ( ' ' == *pos)                                              // 앞에 있는 공백 삭제
           pos++;
     }
     return( pos);
  }
  
  //--------------------------------------------------------------------
  // desc   _task 의 내용에 따라 새 프로세스를 만들어서 실행한다.
  // params _task : 실행 파일에 대한 정보
  // ref    1.
  //          _task 의 task 로부터 실행파일과 인수를 구한다.
  //          실행이나 인수에서 문제가 있다면 에러를 출력하고,
  //          _task 의 error 에 에러코드를 넣어 다음 호출에도 실행이
  //          되지 않도록 한다.
  //        2.
  //          인수는 20개까지 처리한다.
  //
  //        3.
  //          인수의 개수는 프로그램에 따라 다르므로,
  //          *[] 를 사용하는 execv() 를 사용한다.
  //--------------------------------------------------------------------
  void exec_task( task_t *_task)
  {
     pid_t    pid;
  
     if ( ERR_NONE != _task->error)
     {
        return;
     }
  
     pid = fork();
     if ( 0 == pid)                                                       // 자식 프로세서 라면
     {                                                                    dp( "1 sec wait and exec %s", _task->full_filename);
        sleep( 1);                                                        // 프모  프로세스에서 _task->pid = pid 가 실행이 되도록 sleep
        execv(_task->full_filename, _task->params);                       // 프로그램을 실행한다.
     }
     else if ( 0 < pid)                                                   // fork 실행에 이상이 없었다면
     {                                                                    dp( "********** task= %s New Pid= %d", _task->full_filename, pid);
        _task->pid = pid;
     }
     else                                                                 // 만일 fork() 실행에 실패했다면
     {                                                                    dp( "Reset Counter %d", _task->interval);
        _task->count_down   = _task->interval;
     }
  }
  
  //--------------------------------------------------------------------
  // desc   ary_task 목록을 확인해서 종료된 차일드가 있는지를 확인한다.
  //        종료된 차일드가 있다면 실행여부(에러 상태)를 확인하고,
  //        재 실행 시킨다.
  //--------------------------------------------------------------------
  void check_task_list( void)
  {
     int     ndx;
  
                                      // ary_task 목록에서 pid 가 0 인 항목은
                                      // 종료된 차일드 이다.
                                      //
  
    for ( ndx = 0; ndx < cnt_task; ndx++)
    {
        if ( ( !ary_task[ndx].pid)                                        // 타스크가 실행 전이고
              && ( ERR_NONE == ary_task[ndx].error))                      // 에러가 없다면
        {
           if ( 0 < ary_task[ndx].count_down)                             // 아직 카우트 다운 중이라면
           {                                                              dp( "count down :%d", ary_task[ndx].count_down);
              ary_task[ndx].count_down--;
           }
           else                                                           // 카운트 다운을 완료
           {
              exec_task( &ary_task[ndx]);
           }
        }
    }
    return;
  }
  
  //--------------------------------------------------------------------
  // 파일의 문자열에서 task_t 의 정보중 프로그램 이름과 인수를 구한다.
  //
  // _data : 파일에서 읽어 들인 내용중 디렉토리 위치부터의 문자열
  // _task : 실행 파일에 대한 정보
  //
  // typedef struct
  // {
  //   char *full_filename;     <- 디렉토리 포함 전체 파일 이름을 구한다.
  //   char *params[20];        <- 프로그램 실행을 위한 인수 배열을 구한다.
  //          :
  //   int   error;             <- 내용을 구성 중에 에러가 있다면 에러 정보
  //          :
  // } task_t;
  
  
  
  // ref    1.
  //          _task 의 task 로부터 실행파일과 인수를 구한다.
  //          실행이나 인수에서 문제가 있다면 에러를 출력하고,
  //          _task 의 error 에 에러코드를 넣어 다음 호출에도 실행이
  //          되지 않도록 한다.
  //        2.
  //          인수는 20개까지 처리한다.
  //
  //        3.
  //          인수의 개수는 프로그램에 따라 다르므로,
  //          *[] 를 사용하는 execv() 를 사용한다.
  //--------------------------------------------------------------------
  void get_execinfo( char *_data, task_t *_task)
  {
     char     buf[PACKET_SIZE];
     char     exe_path[PATH_SIZE+5];                                      // 에러 대비 +5
     char     exe_name[PATH_SIZE+5];                                      // 에러 대비 +5
     int      nparam;
     int      sz_str;
     pid_t    pid;
  
                                   // 경로 명을 구한다.
                                   // 경로 명의 끝에 '/' 이 없다면 추가한다.
  
     _data = str_spc(_data, buf);
     if ( PATH_SIZE < strlen( buf))                                       // 경로명의 길이가 너무 길다.
     {
        printf( "%s : path is too long!!
  ", buf);
        _task->error  = ERR_PATH_TOO_LONG;
        return;
     }
     strcpy( exe_path, buf);                                              // exe_path <- 경로명
  
                                   // 경로 명의 끝의 '/' 를 확인한다.
  
     sz_str  = strlen( exe_path);
     if ( '/' != exe_path[sz_str-1])                                      // 끝에 / 를 반드시 포함
     {
        exe_path[sz_str  ]  = '/';
        exe_path[sz_str+1]  = '\0';
     }
  
                                   // 실행 파일의 전체 이름을 구한다.
  
     _data  = str_spc(_data, buf);
     if ( PATH_SIZE < strlen( exe_path)+strlen( buf))                     // 경로와 실행파일의 이름 길이 합이 너무 길다.
     {
        printf( "%s/%s : full name is too long!!
  ", exe_path, buf);
        _task->error  = ERR_PATH_TOO_LONG;
        return;
     }
     strcpy( exe_name, buf);
     strcat( exe_path, exe_name);                                         // exe_path <- 경로/실행파일이름
     _task->full_filename = malloc( strlen( exe_path)+1);
     strcpy( _task->full_filename, exe_path);
  
                                   // 실행 파일의 존재 유무를 확인한다.
  
     if ( 0 != access(_task->full_filename, F_OK))
     {
        printf( "%s is not exists!!
  ",_task->full_filename);
        _task->error  = ERR_PATH_TOO_LONG;
        return;
     }
  
                                   // 실행에 필요한 인수를 배열로 구성한다.
                                   // 첫번째 인수는 실행파일 이름으로 한다.
                                   // 마지막 인수는 NULL 이 되도록 한다.
  
     _task->params[0] = malloc( strlen( exe_name)+1);
     strcpy(_task->params[0], exe_name);
  
                                   // [0] 인수는 실행 파일의 이름이므로,
                                   // [1] 부터 프로그램의 인수를 대입한다.
                                   // params는 *[20]로 선언되어 있으므로
                                   // 인수 개수가 19 개를 넘지 못하게 한다.
  
     nparam    = 1;
     while (_data)
     {
        _data = str_spc(_data, buf);                                      // 다음 인수값을 구한다.
        _task->params[nparam] = malloc( strlen( buf)+1);                  // param[nparam] <- 인수값
        strcpy(_task->params[nparam], buf);
        nparam++;
        if ( 19 == nparam)                                                // 인수가 너무 많다면
        {
           printf( "%s has too many params!!
  ", exe_name);
           _task->error  = ERR_TOO_MANY_PARAMS;
           return;
        }
     }
     _task->params[nparam]   = ( char *)0;                                // 마지막 아이템은 NULL
     _task->error            = ERR_NONE;                                  // 에러 없음
  }
  
  //--------------------------------------------------------------------
  // ini 파일에서 실행할 파일의 정보를 읽어 들이고,
  // ary_task 목록을 작성한다.
  //--------------------------------------------------------------------
  void read_task_list( void)
  {
     FILE  *fp;
     char  *tag;
     char  *pos;
     char   buf[PACKET_SIZE];
     char   item[255];
  
     cnt_task  = 0;                                                       // 실행할 작업 개수 초기화
  
     fp = fopen( "./superdaemon.ini", "r");                               // 환경파일 open;
     if ( NULL == fp)
     {                                                                    // 읽어 들일 타스크가 없음
        return;
     }
     else
     {
        while( NULL != fgets( buf, PACKET_SIZE, fp))
        {
           tag = buf;
           remove_white_char( tag);                                       // 문장에 라인피드와 같은 화이트 문자를 없앤다.
  
                                   // 프로그램 종료 시 다음 시작까지의 시간 간격을 구한다.
  
           while ( ' ' == *tag)                                           // 앞에 있는 공백 삭제
           {
              tag++;
           }
  
           if ( ( ' ' > *tag) ||                                          // 문장의 끝이거나
                ( !strncmp( tag, "//", 2))  )                             // 주석문이라면 다음 행으로
           {
              continue;
           }
                                   // 행의 첫 번째 데이터는 대기 시간 정보이다.
                                   // 첫번째 문자열에서 시간 정보를 구한다.
  
           tag = str_spc( tag, item);
           ary_task[cnt_task].interval  = atoi( item);
  
                                   // 프로그램의 실행 정보를 구한다.
                                   // 실행 정보에는 경로와 프로그램 명이 있어야 하므로
                                   // 최소 공백 문자가 하나 있어야 한다.
                                   // 인수에 공백 문자가 없다면 취소한다.
  
           if ( ( ' ' > *tag) ||                                          // 문장의 끝이거나
                ( !strncmp( tag, "//", 2))  )                             // 주석문이라면 다음 행으로
           {
              continue;
           }
  
           pos = index( tag, ' ');                                        // 공백 문자가 없다면 취소한다.
           if (!pos)
           {
              continue;
           }
  
           get_execinfo( tag, &ary_task[cnt_task]);
  
                                   // task 의 초기값을 초기화 한다.
  
           ary_task[cnt_task].count_down = 0;
           ary_task[cnt_task].pid        = 0;
           cnt_task++;
           if ( TASK_ARRAY_SIZE == cnt_task)
           {
              printf( "***** Task list is over %d. *****
  ", TASK_ARRAY_SIZE);
              break;
           }
        }
     }
     fclose( fp);
  }
  
  //--------------------------------------------------------------------
  // 차일드 프로세서의 죽음을 확인하는 시그널 등록
  //--------------------------------------------------------------------
  void reg_child_signal( void)
  {
     struct  sigaction  sig_child;                                        // 차일드의 죽음을 알기 위한 시그털
  
     sig_child.sa_handler  = on_check_child;
     sigemptyset( &sig_child.sa_mask);
     sig_child.sa_flags    = 0;
     sigaction( SIGCHLD, &sig_child, 0);
  }
  
  //--------------------------------------------------------------------
  // main procedure
  //--------------------------------------------------------------------
  int main( int argc, char **argv)
  {
  #ifdef NDEBUG
  
     pid_t   pid_daemon;                                                  // release 모드일 때만 endif 사이의 내용이 실행된다.
  
     pid_daemon  = fork();
     if ( 0 > pid_daemon)                                                 // fork() 실행에 실패했다면
     {
        printf( "ERR: fork() failed
  ");                                  // 실행 에러를 알린다.
        exit( 1);
     }
     else if( 0 != pid_daemon)                                            // 부모 프로세스 라면
     {
        exit( 0);                                                         // 종료한다.
     }
  
  #endif
  
     reg_child_signal();                                                  // child 시그널 등록
     read_task_list();                                                    // 실행할 정보 목록을 작성한다.
  
     while( 1 )
     {
        check_task_list();                                                // 작업 상태를 확인한다.
        sleep( 1);                                                        // 1 초를 대기
     }
  }