Changeset 488


Ignore:
Timestamp:
Sep 18, 2015, 7:39:03 PM (5 years ago)
Author:
katerina
Message:

Fix for tickets #386 (silent check) and #387 (linux audit support).

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/docs/Changelog

    r487 r488  
    114.1.0:
     2        * fix quirks with Linux audit support
     3        * implement 'silent check' (requested feature)
    24        * fix call of self_check for exit on sigterm
    35        * fix safe_logger() - uses the logger utility with a non-posix option
  • trunk/include/samhain.h

    r481 r488  
    134134#undef  BAD
    135135#define BAD   S_FALSE
     136
     137#define SH_SILENT_FULL 2
     138#define SH_SILENT_STD  1
    136139
    137140
     
    398401extern volatile  int      sig_termfast;           /* SIGTERM */
    399402extern volatile  int      sig_force_check;        /* SIGTTOU */
     403extern volatile  int      sig_force_silent;       /* SIGTSTP */
     404extern volatile  int      sh_global_check_silent;
    400405extern volatile  int      sh_load_delta_flag;
    401406
  • trunk/include/sh_files.h

    r481 r488  
    2424void sh_audit_commit ();
    2525void sh_audit_delete_all ();
    26 char * sh_audit_fetch (char * file, time_t time, char * result, size_t rsize);
     26char * sh_audit_fetch (char * file, time_t mtime, time_t ctime, char * result, size_t rsize);
    2727
    2828struct sh_dirent {
  • trunk/man/samhain.8

    r481 r488  
    231231according to the timing options in the
    232232configuration file.
     233.TP
     234[\-i|\-\-interactive]
     235Run update in interactive mode.
     236.TP
     237[\-\-listfile=PATH]
     238Run the update with a list of 'good' filepaths given in file (one path per line).
     239
    233240
    234241.PP
  • trunk/src/samhain.c

    r487 r488  
    122122volatile  int      sig_termfast;           /* SIGTERM */
    123123volatile  int      sig_force_check;        /* SIGTTOU */
     124volatile  int      sig_force_silent;       /* SIGTSTP */
     125volatile  int      sh_global_check_silent;
    124126volatile  int      sh_load_delta_flag;
    125127long int           eintr__result;
     
    343345  sig_termfast           = 0;           /* SIGTERM */
    344346  sig_force_check        = 0;           /* SIGTTOU */
     347  sig_force_silent       = 0;           /* SIGTSTP */
     348  sh_global_check_silent = 0;
    345349  sh_load_delta_flag     = 0;
    346350  strcpy ( sh_sig_msg, _("None"));
     
    12281232}
    12291233
     1234static int sh_flag_silent = S_FALSE;
     1235
     1236int sh_set_silent_full (const char * str)
     1237{
     1238  int status = sh_util_flagval(str, &sh_flag_silent);
     1239  return status;
     1240}
     1241
    12301242
    12311243void do_reconf()
     
    13781390          }
    13791391     
    1380       if (sig_force_check == 1) /* SIGTTOU */
     1392      if (sig_force_check == 1) /* SIGTTOU / SIGTSTP */
    13811393        {
    13821394          TPT((0, FIL__, __LINE__, _("msg=<Check run triggered.>\n")));
    13831395          *flag_check_1 = 1; *flag_check_2 = 1;
    1384           sig_force_check = 0; --sig_raised;
     1396          sig_force_check = 0; --sig_raised;
     1397          if (sig_force_silent)
     1398            {
     1399              sig_force_silent       = 0;
     1400              sh_global_check_silent = (sh_flag_silent == S_FALSE) ? SH_SILENT_STD : SH_SILENT_FULL;
     1401            }
    13851402          sh_sem_trylock();
    13861403        }
     
    14701487  /* Need to contact the server.
    14711488   */
    1472   sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_2);
     1489  if (sh_global_check_silent < SH_SILENT_FULL)
     1490    sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_2);
    14731491
    14741492  if (sig_raised > 0 && sh_load_delta_flag > 0)  /* DELTA Command */
     
    21192137            (void) sh_files_chk ();
    21202138
    2121           if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
     2139          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); sh_global_check_silent = 0; continue; }
    21222140          /*
    21232141           * check for files not visited
     
    21292147            }
    21302148
    2131           if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
     2149          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); sh_global_check_silent = 0; continue; }
    21322150
    21332151          /* reset
     
    21362154          sh_dirs_reset  ();
    21372155
    2138           if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); continue; }
     2156          if (sig_urgent > 0) { sh_sem_unlock(sh.statistics.files_report); sh_global_check_silent = 0; continue; }
    21392157
    21402158          sh_files_reset ();
     
    21502168          (void) sh_prelink_run (NULL, NULL, 0, 0);
    21512169
    2152           if (sig_urgent > 0) continue;
     2170          if (sig_urgent > 0) { sh_global_check_silent = 0; continue; }
    21532171
    21542172          runtim = time(NULL) - sh.statistics.time_start;
     
    21562174       
    21572175          if ((sh.statistics.dirs_checked == 0) &&
    2158               (sh.statistics.files_checked == 0))
     2176              (sh.statistics.files_checked == 0) &&
     2177              (sh_global_check_silent < SH_SILENT_FULL))
    21592178            sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_0);
    21602179
     
    21742193              sh.statistics.bytes_speed = (unsigned long) st_1;
    21752194
    2176               sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_1,
    2177                                (long) runtim,
    2178                                0.001 * st_1);
     2195              if (sh_global_check_silent < SH_SILENT_FULL)
     2196                sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_1,
     2197                                 (long) runtim,
     2198                                 0.001 * st_1);
    21792199
    21802200              if (sh.flag.checkSum != SH_CHECK_INIT)
    21812201                sh_efile_report();
    21822202            }
    2183           sh.fileCheck.alarm_last = time (NULL);
    2184 
     2203         
     2204          if (0 == sh_global_check_silent)
     2205            sh.fileCheck.alarm_last = time (NULL);
     2206
     2207          sh_global_check_silent = 0;
     2208         
    21852209          if (sig_urgent > 0) continue;
    21862210
  • trunk/src/sh_audit.c

    r434 r488  
    2828#include <errno.h>
    2929#include <unistd.h>
     30#include <fcntl.h>
     31#include <sys/stat.h>
     32
     33#include "samhain.h"
     34#include "sh_error.h"
    3035
    3136#if !defined(SH_COMPILE_STATIC) && defined(__linux__) && defined(HAVE_AUPARSE_H) && defined(HAVE_AUPARSE_LIB)
    3237#include <auparse.h>
    3338
    34 #include "samhain.h"
    35 #include "sh_error.h"
    3639#include "sh_extern.h"
    3740#include "sh_utils.h"
     
    103106}
    104107   
    105 static char * doAuparse (char * file, time_t time, char * result, size_t rsize)
     108static char * doAuparse (const char * file, time_t time, int tol, char * result, size_t rsize, int redo_flag)
    106109{
    107110  struct recordState state;
    108111  struct recordState stateFetched;
    109 
     112  unsigned int       found_flag = 0;
     113 
    110114  auparse_state_t * au = auparse_init(AUSOURCE_LOGS, NULL);
    111115
     
    131135  if (time != 0)
    132136    {
    133       ausearch_add_timestamp_item(au, ">=", time-1, 0, AUSEARCH_RULE_AND);
    134       ausearch_add_timestamp_item(au, "<=", time+1, 0, AUSEARCH_RULE_AND);
     137      ausearch_add_timestamp_item(au, ">=", time-tol, 0, AUSEARCH_RULE_AND);
     138      ausearch_add_timestamp_item(au, "<=", time+tol, 0, AUSEARCH_RULE_AND);
    135139    }
    136140
     
    152156        {
    153157          memcpy(&state, &stateFetched, sizeof(state));
     158          ++found_flag;
    154159        }
    155160      auparse_next_event(au);
    156161    }
    157162
     163  if (found_flag == 0 && redo_flag == S_FALSE)
     164    {
     165      size_t len = strlen(file);
     166      char * path = SH_ALLOC(len + 2);
     167      char * altres;
     168     
     169      sl_strlcpy(path, file, len+2);
     170      path[len] = '/'; path[len+1] = '\0';
     171      auparse_destroy(au);
     172     
     173      altres = doAuparse(path, time, tol, result, rsize, S_TRUE);
     174
     175      SH_FREE(path);
     176      return altres;
     177    }
     178 
    158179  if (0 == strcmp(state.success, "yes"))
    159180    {
     
    189210 * The 'result' array should be sized ~256 char.
    190211 */
    191 char * sh_audit_fetch (char * file, time_t time, char * result, size_t rsize)
     212char * sh_audit_fetch (char * file, time_t mtime, time_t ctime, char * result, size_t rsize)
    192213{
    193214  char * res = NULL;
     
    195216  if (sh_audit_checkdaemon() >= 0)
    196217    {
    197       res = doAuparse (file, time, result, rsize);
     218      time_t new;
     219      char buf[64];
     220     
     221      if (mtime >= ctime) { new = mtime; }
     222      else                { new = ctime; }
     223
     224      res = doAuparse (file, new, 1, result, rsize, S_FALSE);
    198225
    199226      if (!res)
    200227        {
    201           res = doAuparse (file, 0, result, rsize);
     228          res = doAuparse (file, new, 3, result, rsize, S_FALSE);
    202229        }
     230
    203231    }
    204232  return res;
     
    226254}
    227255
     256static int  sh_audit_isdir(const char * file)
     257{
     258  struct stat buf;
     259
     260  if ( (0 == lstat (file, &buf)) && S_ISDIR(buf.st_mode))
     261    return S_TRUE;
     262  return S_FALSE;
     263}
     264
    228265static void sh_audit_mark_int (const char * file)
    229266{
     
    246283      char * safe;
    247284      char   ctl[64];
     285      char   a1[32];
     286      char   a2[32];
     287      char   a3[32];
    248288
    249289      sl_snprintf(command, len, _("%s -w %s -p wa -k samhain"),
     
    256296                       safe,
    257297                       _("sh_audit_mark") );
     298
    258299      SH_FREE(safe);
    259300
     
    261302      sl_strlcpy(command, file, len);
    262303
    263       sh_ext_system(ctl, ctl, "-w", command, "-p", "wa", "-k", _("samhain"), NULL);
    264 
     304      sl_strlcpy(a3, _("samhain"), sizeof(a3));
     305      sh_ext_system(ctl, ctl, "-w", command, "-p", "wa", "-k", a3, NULL);
     306
     307      /* Placing a watch on a directory will not place a watch on the
     308       * directory inode, so we do this explicitely.
     309       */
     310      if (S_TRUE == sh_audit_isdir(file))
     311        {
     312          safe = sh_util_safe_name(file);
     313          sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,
     314                           0, MSG_E_SUBGPATH,
     315                           _("Add path watch for directory"),
     316                           _("sh_audit_mark_int"), safe );
     317          SH_FREE(safe);
     318          sl_strlcpy(command, _("path="), len);
     319          sl_strlcat(command, file, len);
     320          sl_strlcpy(a1, _("always,exit"), sizeof(a1));
     321          sl_strlcpy(a2, _("perm=wa"), sizeof(a2));
     322          sh_ext_system(ctl, ctl, "-a", a1, "-F", command, "-F", a2, "-k", a3, NULL);
     323        }
    265324      SH_FREE(command);
    266325    }
     
    278337{
    279338  struct aud_list * this = SH_ALLOC(sizeof(struct aud_list));
     339  size_t len = strlen(file);
     340
    280341  this->file = sh_util_strdup(file);
     342  if ((len > 1) && (file[len-1] == '/'))
     343    this->file[len-1] = '\0';
     344 
    281345  this->next = mark_these;
    282346  mark_these = this;
     
    284348}
    285349
     350/* Check whether it is already covered by a higher directory
     351 */
    286352static int test_exchange (struct aud_list * this, char * file)
    287353{
     
    312378           if (0 == strncmp(s0, s1, len1 + 1))
    313379             {
     380               size_t len = strlen(file);
    314381               SH_FREE(this->file);
    315382               this->file = sh_util_strdup(file);
     383               if ((len > 1) && (file[len-1] == '/'))
     384                 this->file[len-1] = '\0';
    316385               ret = 0;
    317386             }
     
    324393}
    325394
     395/* Place a path on the list of of paths to be watched
     396 */
    326397void sh_audit_mark (char * file)
    327398{
     
    335406  while (this)
    336407    {
     408      /* Check whether it is already covered by a higher
     409       * directory
     410       */
    337411      if (0 == test_exchange(this, file))
    338412        return;
     
    464538/* HAVE_AUPARSE_H */
    465539#else
    466 char * sh_audit_fetch (char * file, time_t time, char * result, size_t rsize)
     540char * sh_audit_fetch (char * file, time_t mtime, time_t ctime, char * result, size_t rsize)
    467541{
    468542  (void) file;
    469   (void) time;
     543  (void) mtime;
     544  (void) ctime;
    470545  (void) result;
    471546  (void) rsize;
     
    476551{
    477552  (void) file;
     553  sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
     554                  _("Setting audit watch not supported"),
     555                  _("sh_audit_mark"));
    478556  return;
    479557}
  • trunk/src/sh_error.c

    r481 r488  
    11061106      goto exit_here;
    11071107    }
    1108 
     1108 
     1109#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
     1110  if ((sh_global_check_silent > SH_SILENT_STD) &&
     1111      (((1 << FIL) & (1 << class)) != 0))
     1112    {
     1113      goto exit_here;
     1114    }
     1115#endif
    11091116
    11101117  /* Allocate space for the message.
  • trunk/src/sh_fInotify.c

    r481 r488  
    511511
    512512  SH_MUTEX_LOCK(mutex_thread_nolog);
    513   sh_error_handle (level, FIL__, __LINE__, 0, MSG_FI_MISS, tmp);
     513  if (!sh_global_check_silent)
     514    sh_error_handle (level, FIL__, __LINE__, 0, MSG_FI_MISS, tmp);
    514515  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    515516  ++sh.statistics.files_report;
  • trunk/src/sh_files.c

    r481 r488  
    393393                if (tmp == NULL)
    394394                  tmp = sh_util_safe_name (ptr->name);
    395                 sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
    396                                  ShDFLevel[ptr->class] :
    397                                  ShDFLevel[SH_ERR_T_FILE],
    398                                  FIL__, __LINE__, 0, MSG_FI_MISS,
    399                                  tmp);
     395                if (!sh_global_check_silent)
     396                  sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
     397                                   ShDFLevel[ptr->class] :
     398                                   ShDFLevel[SH_ERR_T_FILE],
     399                                   FIL__, __LINE__, 0, MSG_FI_MISS,
     400                                   tmp);
    400401                ++sh.statistics.files_report;
    401402              }
     
    447448                    if (tmp == NULL)
    448449                      tmp = sh_util_safe_name (ptr->name);
    449                     sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE)?
    450                                      ShDFLevel[ptr->class] :
    451                                      ShDFLevel[SH_ERR_T_FILE],
    452                                      FIL__, __LINE__, 0, MSG_FI_MISS,
    453                                      tmp);
     450                    if (!sh_global_check_silent)
     451                      sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE)?
     452                                       ShDFLevel[ptr->class] :
     453                                       ShDFLevel[SH_ERR_T_FILE],
     454                                       FIL__, __LINE__, 0, MSG_FI_MISS,
     455                                       tmp);
    454456                    ++sh.statistics.files_report;
    455457                  }
     
    953955        else if (0 == strcmp(myword, _("TXT")))
    954956          sh_files_set_mask (mask, MODI_TXT, act);
    955 /* get content */
     957/* get audit report */
    956958        else if (0 == strcmp(myword, _("AUDIT")))
    957959          sh_files_set_mask (mask, MODI_AUDIT, act);
     
    11571159      if (MODI_AUDIT_ENABLED(check_flags))
    11581160        {
     1161          sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGPATH,
     1162                          _("Setting audit watch"),
     1163                          _("sh_files_push_file_int"), str_s);
    11591164          sh_audit_mark(str_s);
    11601165        }
     
    15771582                                              ShDFLevel[SH_ERR_T_DIR])) {
    15781583                    tmp = sh_util_safe_name (ptr->name);
    1579                     sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
    1580                                      ShDFLevel[ptr->class] :
    1581                                      ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__,
    1582                                      0, MSG_FI_MISS, tmp);
     1584                    if (!sh_global_check_silent)
     1585                      sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
     1586                                       ShDFLevel[ptr->class] :
     1587                                       ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__,
     1588                                       0, MSG_FI_MISS, tmp);
    15831589                    ++sh.statistics.files_report;
    15841590                    SH_FREE(tmp);
     
    16011607                   */
    16021608                  tmp = sh_util_safe_name (ptr->name);
    1603                   sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
    1604                                    ShDFLevel[ptr->class] :
    1605                                    ShDFLevel[SH_ERR_T_DIR],
    1606                                    FIL__, __LINE__, 0, MSG_FI_ADD,
    1607                                    tmp);
     1609                  if (!sh_global_check_silent)
     1610                    sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
     1611                                     ShDFLevel[ptr->class] :
     1612                                     ShDFLevel[SH_ERR_T_DIR],
     1613                                     FIL__, __LINE__, 0, MSG_FI_ADD,
     1614                                     tmp);
    16081615                  ++sh.statistics.files_report;
    16091616                  SH_FREE(tmp);
     
    17781785      if (MODI_AUDIT_ENABLED(check_flags))
    17791786        {
     1787          sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGPATH,
     1788                          _("Setting audit watch"),
     1789                          _("sh_files_push_file_int"), tail);
    17801790          sh_audit_mark(tail);
    17811791        }
     
    21562166  if (theFile->c_mode[0] != 'd')
    21572167    {
    2158       sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
    2159                        MSG_FI_NODIR,
    2160                        tmpname);
     2168      if (!sh_global_check_silent)
     2169        sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
     2170                         MSG_FI_NODIR,
     2171                         tmpname);
    21612172      ++sh.statistics.files_nodir;
    21622173      if (theFile->attr_string) SH_FREE(theFile->attr_string);
  • trunk/src/sh_hash.c

    r481 r488  
    248248
    249249  SH_MUTEX_LOCK(mutex_thread_nolog);
    250   sh_error_handle (level, FIL__, __LINE__, 0,
    251                    MSG_FI_MISS2, tmp, str);
     250  if (!sh_global_check_silent)
     251    sh_error_handle (level, FIL__, __LINE__, 0,
     252                     MSG_FI_MISS2, tmp, str);
    252253  SH_MUTEX_UNLOCK(mutex_thread_nolog);
    253254  ++sh.statistics.files_report;
     
    363364                  theFile = sh_hash_create_ft (p, fileHash);
    364365                  str = all_items(theFile, fileHash, 0);
    365                   sh_error_handle (level, FIL__, __LINE__, 0,
    366                                    MSG_FI_MISS2, tmp, str);
     366                  if (!sh_global_check_silent)
     367                    sh_error_handle (level, FIL__, __LINE__, 0,
     368                                     MSG_FI_MISS2, tmp, str);
    367369                  ++sh.statistics.files_report;
    368370                  SH_FREE(str);
     
    405407          theFile = sh_hash_create_ft (p, fileHash);
    406408          str = all_items(theFile, fileHash, 0);
    407           sh_error_handle (level, FIL__, __LINE__, 0,
    408                            MSG_FI_MISS2, tmp, str);
     409          if (!sh_global_check_silent)
     410            sh_error_handle (level, FIL__, __LINE__, 0,
     411                             MSG_FI_MISS2, tmp, str);
    409412          ++sh.statistics.files_report;
    410413          SH_FREE(str);
     
    18121815      str = all_items (theFile, fileHash, 1);
    18131816     
    1814       sh_error_handle (log_severity, FIL__, __LINE__, 0,
    1815                        MSG_FI_ADD2,
    1816                        tmp, str);
     1817      if (!sh_global_check_silent)
     1818        sh_error_handle (log_severity, FIL__, __LINE__, 0,
     1819                         MSG_FI_ADD2,
     1820                         tmp, str);
    18171821      ++sh.statistics.files_report;
    18181822      SH_FREE(str);
     
    25402544        {
    25412545          char result[256];
    2542 
    2543           if (NULL != sh_audit_fetch (theFile->fullpath, theFile->mtime, result, sizeof(result)))
     2546         
     2547          sh_error_handle (SH_ERR_INFO, FIL__, __LINE__,
     2548                           0, MSG_E_SUBGPATH,
     2549                           _("Fetching audit record"),
     2550                           _("sh_hash"),  theFile->fullpath );
     2551
     2552          if (NULL != sh_audit_fetch (theFile->fullpath, theFile->mtime, theFile->ctime, result, sizeof(result)))
    25442553            {
    25452554#ifdef SH_USE_XML
     
    25652574       ****************************************************/
    25662575      tmp_path = sh_util_safe_name(theFile->fullpath);
    2567       sh_error_handle(log_severity, FIL__, __LINE__,
    2568                       (long) modi_mask, MSG_FI_CHAN,
    2569                       (policy_override == NULL) ? _(policy[class]):log_policy,
    2570                       change_code, tmp_path, msg);
     2576      if (!sh_global_check_silent)
     2577        sh_error_handle(log_severity, FIL__, __LINE__,
     2578                        (long) modi_mask, MSG_FI_CHAN,
     2579                        (policy_override == NULL) ? _(policy[class]):log_policy,
     2580                        change_code, tmp_path, msg);
    25712581      ++sh.statistics.files_report;
    25722582
  • trunk/src/sh_readconf.c

    r481 r488  
    871871extern int sh_set_schedule_one(const char * str);
    872872extern int sh_set_schedule_two(const char * str);
     873extern int sh_set_silent_full (const char * str);
    873874#endif
    874875#if defined (SH_WITH_SERVER)
     
    11011102  { N_("setprelinkchecksum"),   SH_SECTION_MISC,   SH_SECTION_NONE,
    11021103    sh_prelink_set_hash },
     1104
     1105  { N_("setfullsilent"),        SH_SECTION_MISC,   SH_SECTION_NONE,
     1106    sh_set_silent_full },
    11031107
    11041108  /* client or standalone
  • trunk/src/sh_unix.c

    r487 r488  
    666666    sig_force_check = 1; sh_sem_trylock(); }
    667667#endif
     668#ifdef SIGTSTP
     669  if (mysignal == SIGTSTP) {
     670    sig_force_check = 1; sig_force_silent = 1; sh_sem_trylock(); }
     671#endif
    668672#ifdef SIGTTIN
    669673  if (mysignal == SIGTTIN)
     
    841845  retry_sigaction(FIL__, __LINE__, SIGALRM,   &ignact, &oldact);
    842846#endif
    843 #ifdef SIGTSTP
    844   retry_sigaction(FIL__, __LINE__, SIGTSTP,   &ignact, &oldact);
    845 #endif
    846847
    847848#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
     
    852853    retry_sigaction(FIL__, __LINE__, SIGTTOU,   &ignact, &oldact);
    853854#endif
     855#ifdef SIGTSTP
     856  if (goDaemon == 1)
     857    retry_sigaction(FIL__, __LINE__, SIGTSTP,     &act2, &oldact);
     858  else
     859    retry_sigaction(FIL__, __LINE__, SIGTSTP,   &ignact, &oldact);
     860#endif
    854861#ifdef SIGTTIN
    855862  if (goDaemon == 1)
     
    859866#endif
    860867#else
     868#ifdef SIGTSTP
     869  retry_sigaction(FIL__, __LINE__, SIGTSTP,   &ignact, &oldact);
     870#endif
    861871#ifdef SIGTTOU
    862872  retry_sigaction(FIL__, __LINE__, SIGTTOU,   &ignact, &oldact);
Note: See TracChangeset for help on using the changeset viewer.