source: trunk/src/samhain.c @ 473

Last change on this file since 473 was 473, checked in by katerina, 7 years ago

Fix for ticket #371 (use cppcheck instead of uno for static checking).

File size: 52.2 KB
Line 
1/* SAMHAIN file system integrity testing                                   */
2/* Copyright (C) 1999, 2000 Rainer Wichmann                                */
3/*                                                                         */
4/*  This program is free software; you can redistribute it                 */
5/*  and/or modify                                                          */
6/*  it under the terms of the GNU General Public License as                */
7/*  published by                                                           */
8/*  the Free Software Foundation; either version 2 of the License, or      */
9/*  (at your option) any later version.                                    */
10/*                                                                         */
11/*  This program is distributed in the hope that it will be useful,        */
12/*  but WITHOUT ANY WARRANTY; without even the implied warranty of         */
13/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
14/*  GNU General Public License for more details.                           */
15/*                                                                         */
16/*  You should have received a copy of the GNU General Public License      */
17/*  along with this program; if not, write to the Free Software            */
18/*  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
19
20#include "config_xor.h"
21
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27#include <fcntl.h>
28
29/* samhainctl */
30#include <sys/types.h>
31#include <sys/stat.h>
32#include <sys/wait.h>
33#include <signal.h>
34#include <errno.h>
35
36
37#if TIME_WITH_SYS_TIME
38#include <sys/time.h>
39#include <time.h>
40#else
41#if HAVE_SYS_TIME_H
42#include <sys/time.h>
43#else
44#include <time.h>
45#endif
46#endif
47
48#ifdef HAVE_MEMORY_H
49#include <memory.h>
50#endif
51
52#ifdef HAVE_SETPRIORITY
53#include <sys/resource.h>
54#endif
55
56#ifndef HAVE_LSTAT
57#define lstat stat
58#endif
59
60/* for FLT_EPSILON
61 */
62#include <float.h>
63
64#include "samhain.h"
65#include "sh_pthread.h"
66#include "sh_utils.h"
67#include "sh_error.h"
68#include "sh_unix.h"
69#include "sh_files.h"
70#include "sh_getopt.h"
71#include "sh_readconf.h"
72#include "sh_hash.h"
73#include "sh_restrict.h"
74
75#include "sh_nmail.h"
76
77#include "sh_tiger.h"
78#include "sh_gpg.h"
79#include "sh_mem.h"
80#include "sh_forward.h"
81#include "sh_tools.h"
82#include "sh_hash.h"
83#if defined(WITH_EXTERNAL)
84#include "sh_extern.h"
85#endif
86#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
87#include "sh_modules.h"
88#include "sh_ignore.h"
89#include "sh_prelink.h"
90#endif
91
92#undef  FIL__
93#define FIL__  _("samhain.c")
94
95
96/**************************************************
97 *
98 * Needed to compile the key into the code.
99 *
100 **************************************************/
101
102extern UINT32  ErrFlag[2];
103#include "sh_MK.h"
104
105/**************************************************
106 *
107 * Variables for signal handling.
108 *
109 **************************************************/
110
111volatile  int      sig_raised;
112volatile  int      sig_urgent;
113volatile  int      sig_debug_switch;       /* SIGUSR1 */
114volatile  int      sig_suspend_switch;     /* SIGUSR2 */
115volatile  int      sh_global_suspend_flag;
116volatile  int      sig_fresh_trail;        /* SIGIOT  */
117volatile  int      sh_thread_pause_flag = S_FALSE;
118volatile  int      sig_config_read_again;  /* SIGHUP  */
119volatile  int      sig_terminate;          /* SIGQUIT */
120volatile  int      sig_termfast;           /* SIGTERM */
121volatile  int      sig_force_check;        /* SIGTTOU */
122long int           eintr__result;
123char               sh_sig_msg[SH_MINIBUF];
124
125
126#ifdef SH_STEALTH
127/**************************************************
128 *
129 * The following set of functions is required for
130 * the 'stealth' mode.
131 *
132 **************************************************/
133
134#ifndef SH_MAX_GLOBS
135#define SH_MAX_GLOBS 16
136#endif
137
138#ifndef GLOB_LEN
139#define GLOB_LEN 511
140#endif
141
142#ifdef HAVE_PTHREAD
143struct gt {
144  size_t g_count;
145  char * g_glob;
146};
147
148pthread_key_t g_key;
149
150int sh_g_thread()
151{
152  struct gt * ptr = calloc(1,sizeof(struct gt));
153  if (!ptr)
154    return -1;
155  ptr->g_count    = 0;
156  ptr->g_glob     = calloc(1, SH_MAX_GLOBS * (GLOB_LEN+1));
157  if (!(ptr->g_glob))
158    {
159      free(ptr);
160      return -1;
161    }
162  return pthread_setspecific(g_key, ptr);
163}
164
165void sh_g_destroy(void * data)
166{
167  struct gt * ptr = (struct gt *) data;
168  free(ptr->g_glob);
169  free(ptr);
170  return;
171}
172
173void sh_g_init(void)
174{
175#if !defined(USE_SYSTEM_MALLOC) && defined(USE_MALLOC_LOCK)
176  extern int dnmalloc_pthread_init(void);
177  dnmalloc_pthread_init();
178#endif
179
180  if (0 != pthread_key_create(&g_key, sh_g_destroy))
181    {
182      perror("1");
183      exit(EXIT_FAILURE);
184    }
185
186  if (0 != sh_g_thread())
187    {
188      perror("2");
189      exit(EXIT_FAILURE);
190    }
191  return;
192}
193#define SH_G_INIT sh_g_init()
194#else
195#define SH_G_INIT ((void)0)
196#endif
197
198char * globber(const char * str)
199{
200  size_t i;
201  size_t j;
202
203#ifndef HAVE_PTHREAD
204  static   size_t  count = 0;
205  static   char glob[SH_MAX_GLOBS * (GLOB_LEN+1)];
206#else
207  struct gt * ptr = pthread_getspecific(g_key);
208  size_t count;
209  char *  glob;
210
211  if (ptr) {
212    count = ptr->g_count;
213    glob  = ptr->g_glob;
214  } else {
215    return NULL;
216  }
217#endif
218
219  if (str != NULL)
220    j = strlen(str);
221  else
222    return NULL;
223
224  ASSERT((j <= GLOB_LEN), _("j <= GLOB_LEN"))
225
226  if (j > GLOB_LEN) 
227    j = GLOB_LEN;
228
229  /* Overwrap the buffer.
230   */
231  if ( (count + j) >= (SH_MAX_GLOBS * (GLOB_LEN+1)))
232    {
233      count = 0;
234    }
235
236  for (i = 0; i < j; ++i)
237    {
238      if (str[i] != '\n' && str[i] != '\t' && str[i] != '\r' && str[i] != '"')
239        glob[count + i] = str[i] ^ XOR_CODE;
240      else
241        glob[count + i] = str[i];
242    }
243  glob[count + j] = '\0';
244
245  i     = count;
246#ifdef HAVE_PTHREAD
247  ptr->g_count = count + j + 1;
248#else
249  count = count + j + 1;
250#endif
251  return &glob[i];
252}
253
254void sh_do_encode (char * str, int len)
255{
256  register          int i;
257
258  /* this is a symmetric operation
259   */
260  for (i = 0; i < len; ++i)
261    {
262      str[i] = str[i] ^ XOR_CODE;
263    }
264  return;
265}
266
267#else
268/* not stealth */
269#define SH_G_INIT ((void)0)
270#endif
271
272/**************************************************
273 *
274 * Global variables.
275 *
276 **************************************************/
277
278sh_struct   sh;
279/*@null@*/ sh_key_t  * skey = NULL;
280
281extern unsigned char TcpFlag[8][PW_LEN+1];
282
283/**************************************************
284 *
285 * Initializing.
286 *
287 **************************************************/
288
289static int is_samhainctl_init = S_FALSE;
290
291static
292void sh_init (void)
293{
294  unsigned char * dez = NULL;
295  int             i;
296#if defined(SH_WITH_MAIL)
297  char          * p;
298  char            q[SH_PATHBUF];
299#endif
300
301  SL_ENTER(_("sh_init"));
302
303#ifdef MKA_09
304  ErrFlag[0] |= (1 << 8);
305#endif
306#ifdef MKA_10
307  ErrFlag[0] |= (1 << 9);
308#endif
309#ifdef MKA_11
310  ErrFlag[0] |= (1 << 10);
311#endif
312#ifdef MKA_12
313  ErrFlag[0] |= (1 << 11);
314#endif
315#ifdef MKA_13
316  ErrFlag[0] |= (1 << 12);
317#endif
318#ifdef MKA_14
319  ErrFlag[0] |= (1 << 13);
320#endif
321#ifdef MKA_15
322  ErrFlag[0] |= (1 << 14);
323#endif
324#ifdef MKA_16
325  ErrFlag[0] |= (1 << 15);
326#endif
327
328  /* Signal handling.
329   */
330  sig_raised             = 0;
331  sig_config_read_again  = 0;           /* SIGHUP  */
332  sig_debug_switch       = 0;           /* SIGUSR1 */
333  sig_suspend_switch     = 0;           /* SIGUSR2 */
334  sh_global_suspend_flag = 0;           /* SIGUSR2 */
335  sig_fresh_trail        = 0;           /* SIGIOT  */
336  sig_terminate          = 0;           /* SIGQUIT */
337  sig_termfast           = 0;           /* SIGTERM */
338  sig_force_check        = 0;           /* SIGTTOU */
339  strcpy ( sh_sig_msg, _("None"));
340
341#ifdef MKB_01
342  ErrFlag[1] |= (1 << 0);
343#endif
344#ifdef MKB_02
345  ErrFlag[1] |= (1 << 1);
346#endif
347#ifdef MKB_03
348  ErrFlag[1] |= (1 << 2);
349#endif
350#ifdef MKB_04
351  ErrFlag[1] |= (1 << 3);
352#endif
353#ifdef MKB_05
354  ErrFlag[1] |= (1 << 4);
355#endif
356#ifdef MKB_06
357  ErrFlag[1] |= (1 << 5);
358#endif
359#ifdef MKB_07
360  ErrFlag[1] |= (1 << 6);
361#endif
362#ifdef MKB_08
363  ErrFlag[1] |= (1 << 7);
364#endif
365
366#if defined(SH_WITH_SERVER) && !defined(SH_WITH_CLIENT)
367  strncpy(sh.prg_name, _("Yule"), 8);
368  sh.prg_name[4] = '\0';
369#else
370  strncpy(sh.prg_name, _("Samhain"), 8);
371  sh.prg_name[7] = '\0';
372#endif
373
374  sh.pid = (UINT64) getpid();
375
376  /* The flags.
377   */
378  if (is_samhainctl_init == S_FALSE)
379    sh.flag.checkSum        = SH_CHECK_NONE;
380  sh.flag.update          = S_FALSE;
381  sh.flag.opts            = S_FALSE;
382  sh.flag.started         = S_FALSE;
383  if (is_samhainctl_init == S_FALSE)
384    sh.flag.isdaemon        = S_FALSE;
385  sh.flag.isserver        = S_FALSE;
386  sh.flag.islocked        = S_FALSE;
387  sh.flag.smsg            = S_FALSE;
388  sh.flag.log_start       = S_TRUE;
389  sh.flag.reportonce      = S_TRUE;
390  sh.flag.fulldetail      = S_FALSE;
391  sh.flag.audit           = S_FALSE;
392  sh.flag.nice            = 0;
393  sh.flag.aud_mask        = 0xFFFFFFFFUL;
394  sh.flag.client_severity = S_FALSE;
395  sh.flag.client_class    = S_FALSE;
396  sh.flag.hidefile        = S_FALSE;
397  sh.flag.loop            = S_FALSE;
398  sh.flag.inotify         = 0;
399
400#ifdef MKB_09
401  ErrFlag[1] |= (1 << 8);
402#endif
403#ifdef MKB_10
404  ErrFlag[1] |= (1 << 9);
405#endif
406#ifdef MKB_11
407  ErrFlag[1] |= (1 << 10);
408#endif
409#ifdef MKB_12
410  ErrFlag[1] |= (1 << 11);
411#endif
412#ifdef MKB_13
413  ErrFlag[1] |= (1 << 12);
414#endif
415#ifdef MKB_14
416  ErrFlag[1] |= (1 << 13);
417#endif
418#ifdef MKB_15
419  ErrFlag[1] |= (1 << 14);
420#endif
421#ifdef MKB_16
422  ErrFlag[1] |= (1 << 15);
423#endif
424
425  /* The stats.
426   */
427  sh.statistics.bytes_speed   = 0;
428  sh.statistics.bytes_hashed  = 0;
429  sh.statistics.files_report  = 0;
430  sh.statistics.files_error   = 0;
431  sh.statistics.files_nodir   = 0;
432
433  sh.statistics.mail_success = 0;
434  sh.statistics.mail_failed  = 0;
435  sh.statistics.time_start   = time(NULL);
436  sh.statistics.time_check   = (time_t) 0;
437
438#ifdef MKC_01
439  ErrFlag[0] |= (1 << 16);
440#endif
441#ifdef MKC_02
442  ErrFlag[0] |= (1 << 17);
443#endif
444#ifdef MKC_03
445  ErrFlag[0] |= (1 << 18);
446#endif
447#ifdef MKC_04
448  ErrFlag[0] |= (1 << 19);
449#endif
450#ifdef MKC_05
451  ErrFlag[0] |= (1 << 20);
452#endif
453#ifdef MKC_06
454  ErrFlag[0] |= (1 << 21);
455#endif
456#ifdef MKC_07
457  ErrFlag[0] |= (1 << 22);
458#endif
459#ifdef MKC_08
460  ErrFlag[0] |= (1 << 23);
461#endif
462
463
464  /* The local host.
465   */
466  (void) sl_strlcpy (sh.host.name,  _("localhost"),  SH_MINIBUF);
467  sh.host.system[0]     = '\0'; /* flawfinder: ignore *//* ff bug */
468  sh.host.release[0]    = '\0';
469  sh.host.machine[0]    = '\0';
470
471#ifdef MKC_09
472  ErrFlag[0] |= (1 << 24);
473#endif
474#ifdef MKC_10
475  ErrFlag[0] |= (1 << 25);
476#endif
477#ifdef MKC_11
478  ErrFlag[0] |= (1 << 26);
479#endif
480#ifdef MKC_12
481  ErrFlag[0] |= (1 << 27);
482#endif
483#ifdef MKC_13
484  ErrFlag[0] |= (1 << 28);
485#endif
486#ifdef MKC_14
487  ErrFlag[0] |= (1 << 29);
488#endif
489#ifdef MKC_15
490  ErrFlag[0] |= (1 << 30);
491#endif
492#ifdef MKC_16
493  ErrFlag[0] |= (1UL << 31);
494#endif
495
496  /* The paths.
497   */
498  (void) sl_strlcpy (sh.conf.path,  DEFAULT_CONFIGFILE,    SH_PATHBUF);
499  sh.conf.hash[0] = '\0';
500  (void) sl_strlcpy (sh.data.path,  DEFAULT_DATA_FILE,     SH_PATHBUF);
501  sh.data.hash[0] = '\0';
502  sh.exec.path[0] = '\0';
503  sh.exec.hash[0] = '\0';
504
505#ifdef MKD_01
506  ErrFlag[1] |= (1 << 16);
507#endif
508#ifdef MKD_02
509  ErrFlag[1] |= (1 << 17);
510#endif
511#ifdef MKD_03
512  ErrFlag[1] |= (1 << 18);
513#endif
514#ifdef MKD_04
515  ErrFlag[1] |= (1 << 19);
516#endif
517#ifdef MKD_05
518  ErrFlag[1] |= (1 << 20);
519#endif
520#ifdef MKD_06
521  ErrFlag[1] |= (1 << 21);
522#endif
523#ifdef MKD_07
524  ErrFlag[1] |= (1 << 22);
525#endif
526#ifdef MKD_08
527  ErrFlag[1] |= (1 << 23);
528#endif
529
530  /* The addresses.
531   */
532#if defined(SH_WITH_MAIL)
533  if (0 != strcmp (DEFAULT_MAILADDRESS, _("NULL")))
534    {
535#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
536      char * saveptr;
537      (void) sl_strncpy(q, DEFAULT_MAILADDRESS, SH_PATHBUF);
538      p = strtok_r (q, ", \t", &saveptr);
539      if (p)
540        {
541          (void) sh_nmail_add_compiled_recipient (p);
542          while (NULL != (p = strtok_r (NULL, ", \t", &saveptr)))
543            (void) sh_nmail_add_compiled_recipient (p);
544        }
545#else
546      (void) sl_strncpy(q, DEFAULT_MAILADDRESS, SH_PATHBUF);
547      p = strtok (q, ", \t");
548      if (p)
549        {
550          (void) sh_nmail_add_compiled_recipient (p);
551          while (NULL != (p = strtok (NULL, ", \t")))
552            (void) sh_nmail_add_compiled_recipient (p);
553        }
554#endif
555    }
556#endif
557
558  if (0 == strcmp (ALT_TIMESERVER, _("NULL")))
559    sh.srvtime.alt[0] = '\0';
560  else
561    (void) sl_strlcpy (sh.srvtime.alt, ALT_TIMESERVER,        SH_PATHBUF);
562  if (0 == strcmp (DEFAULT_TIMESERVER, _("NULL")))
563    sh.srvtime.name[0] = '\0';
564  else
565    (void) sl_strlcpy (sh.srvtime.name, DEFAULT_TIMESERVER,   SH_PATHBUF);
566
567
568  if (0 == strcmp (ALT_LOGSERVER, _("NULL")))
569    sh.srvexport.alt[0] = '\0';
570  else
571    (void) sl_strlcpy (sh.srvexport.alt,  ALT_LOGSERVER,  SH_PATHBUF);
572  if (0 == strcmp (DEFAULT_LOGSERVER, _("NULL")))
573    sh.srvexport.name[0] = '\0';
574  else
575    (void) sl_strlcpy (sh.srvexport.name,  DEFAULT_LOGSERVER, SH_PATHBUF);
576
577
578  if (0 == strcmp (DEFAULT_ERRLOCK, _("NULL")))
579    sh.srvlog.alt[0] = '\0';
580  else
581    (void) sl_strlcpy (sh.srvlog.alt,  DEFAULT_ERRLOCK,       SH_PATHBUF);
582  if (0 == strcmp (DEFAULT_ERRFILE, _("NULL")))
583    sh.srvlog.name[0] = '\0';
584  else
585    (void) sl_strlcpy (sh.srvlog.name,  DEFAULT_ERRFILE,      SH_PATHBUF);
586
587  if (0 == strcmp (ALT_CONSOLE, _("NULL")))
588    sh.srvcons.alt[0] = '\0';
589  else
590    (void) sl_strlcpy (sh.srvcons.alt,  ALT_CONSOLE,          SH_PATHBUF);
591#ifndef DEFAULT_CONSOLE
592  (void) sl_strlcpy (sh.srvcons.name, _("/dev/console"),    SH_PATHBUF);
593#else
594  if (0 == strcmp (DEFAULT_CONSOLE, _("NULL")))
595    (void) sl_strlcpy (sh.srvcons.name, _("/dev/console"),    SH_PATHBUF);
596  else
597    (void) sl_strlcpy (sh.srvcons.name,  DEFAULT_CONSOLE,     SH_PATHBUF);
598#endif
599
600#ifdef MKD_09
601  ErrFlag[1] |= (1 << 24);
602#endif
603#ifdef MKD_10
604  ErrFlag[1] |= (1 << 25);
605#endif
606#ifdef MKD_11
607  ErrFlag[1] |= (1 << 26);
608#endif
609#ifdef MKD_12
610  ErrFlag[1] |= (1 << 27);
611#endif
612#ifdef MKD_13
613  ErrFlag[1] |= (1 << 28);
614#endif
615#ifdef MKD_14
616  ErrFlag[1] |= (1 << 29);
617#endif
618#ifdef MKD_15
619  ErrFlag[1] |= (1 << 30);
620#endif
621#ifdef MKD_16
622  ErrFlag[1] |= (1UL << 31);
623#endif
624
625
626  /* The timers.
627   */
628  sh.fileCheck.alarm_last     = 0;
629  sh.fileCheck.alarm_interval = 600; /* ten minutes */
630
631  sh.mailTime.alarm_last     = 0;
632  sh.mailTime.alarm_interval = 86400;
633
634  sh.mailNum.alarm_last      = 0;
635  sh.mailNum.alarm_interval  = 10;
636
637  sh.looptime     = 60;
638
639#ifdef SCREW_IT_UP
640  sh.sigtrap_max_duration = 500000; /* 500ms */
641#endif
642
643  /* The struct to hold privileged information.
644   */
645  skey = calloc(1,sizeof(sh_key_t));
646  if (skey != NULL)
647    {
648
649      skey->mlock_failed = SL_FALSE;
650      skey->rngI         = BAD;
651      /* properly initialized later
652       */
653      skey->rng0[0] = 0x03; skey->rng0[1] = 0x09; skey->rng0[2] = 0x17;
654      skey->rng1[0] = 0x03; skey->rng1[1] = 0x09; skey->rng1[2] = 0x17;
655      skey->rng2[0] = 0x03; skey->rng2[1] = 0x09; skey->rng2[2] = 0x17;
656     
657      for (i = 0; i < KEY_BYT; ++i)
658        skey->poolv[i] = '\0';
659     
660      skey->poolc        = 0;
661     
662      skey->ErrFlag[0]   = ErrFlag[0];
663      ErrFlag[0]         = 0;
664      skey->ErrFlag[1]   = ErrFlag[1];
665      ErrFlag[1]         = 0;
666     
667      dez = &(TcpFlag[POS_TF-1][0]);
668      for (i = 0; i < PW_LEN; ++i)
669        { 
670          skey->pw[i] = (char) (*dez); 
671          (*dez)      = '\0';
672          ++dez; 
673        }
674     
675      skey->sh_sockpass[0]  = '\0';
676      skey->sigkey_old[0]   = '\0';
677      skey->sigkey_new[0]   = '\0';
678      skey->mailkey_old[0]  = '\0';
679      skey->mailkey_new[0]  = '\0';
680      skey->crypt[0]        = '\0'; /* flawfinder: ignore *//* ff bug */
681      skey->session[0]      = '\0';
682      skey->vernam[0]       = '\0';
683    }
684  else
685    {
686      perror(_("sh_init"));
687      _exit (EXIT_FAILURE);
688    }
689
690  sh_unix_memlock();
691  SL_RET0(_("sh_init"));
692}
693
694
695#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
696#include <sys/mman.h>
697#endif
698
699#if defined(SH_USE_XML)
700extern int    sh_log_file    (char * message, char * inet_peer);
701#endif
702
703/*******************************************************
704 *
705 * Exit Handler
706 *
707 *******************************************************/
708static void exit_handler(void)
709{
710  /* --- Clean up modules, if any. ---
711   */
712#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
713  int modnum;
714#endif
715#if defined(SH_WITH_SERVER)
716  extern int sh_socket_remove (void);
717  extern int sh_html_zero();
718#endif
719
720  SL_ENTER(_("exit_handler"));
721
722#if defined(SH_WITH_SERVER)
723  sh_socket_remove ();
724#endif
725
726#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
727  for (modnum = 0; modList[modnum].name != NULL; ++modnum) 
728    {
729      if (modList[modnum].initval == SH_MOD_ACTIVE)
730        (void) modList[modnum].mod_cleanup();
731    }
732#ifdef HAVE_PTHREAD
733  sh_pthread_cancel_all();
734#endif
735#endif
736
737  /* --- Push out all pending messages. ---
738   */
739#if defined(SH_WITH_MAIL)
740  if (sh.mailNum.alarm_last > 0) 
741    {
742      (void) sh_nmail_flush ();
743    }
744#endif
745
746  /* --- Write the server stat. ---
747   */
748#if defined(SH_WITH_SERVER)
749  /* zero out the status file at exit, such that the status
750   * of client becomes unknown in the beltane interface
751   */
752  sh_html_zero();
753  /* sh_forward_html_write(); */
754#endif
755
756  /* --- Clean up memory to check for problems. ---
757   */
758#ifdef MEM_DEBUG
759#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
760  sh_files_deldirstack ();
761  sh_files_delfilestack ();
762  sh_files_delglobstack ();
763  sh_hash_hashdelete();
764  sh_files_hle_reg (NULL);
765  /*
766   * Only flush on exit if running as deamon.
767   * Otherwise we couldn't run another instance
768   * while the deamon is running (would leave the
769   * deamon with flushed ruleset).
770   */
771  if (sh.flag.isdaemon == S_TRUE)
772    {
773      sh_audit_delete_all ();
774    }
775#endif
776#if defined(SH_WITH_SERVER)
777  sh_forward_free_all ();
778#endif
779#if defined(SH_WITH_MAIL)
780  sh_nmail_free();
781#endif
782  delete_cache();
783  sh_userid_destroy ();
784  sh_mem_stat();
785#endif
786
787#ifdef MEM_DEBUG
788  sh_unix_count_mlock();
789#endif
790
791  /* --- Checksum of executable. ---
792   */
793  (void) sh_unix_self_check();
794
795
796  /* --- Exit Message. ---
797   */
798  sh_error_handle ((-1), FIL__, __LINE__, sh.flag.exit, MSG_EXIT_NORMAL, 
799                   sh.prg_name, sh_sig_msg);
800#ifdef SH_USE_XML
801  (void) sh_log_file (NULL, NULL);
802#endif
803
804
805  /* --- Restrict error logging to stderr. ---
806   */
807#ifdef WITH_MESSAGE_QUEUE
808  close_ipc ();
809#endif
810  sh_error_only_stderr (S_TRUE);
811
812
813  /* --- Remove lock, delete critical information. ---
814   */
815  (void) sh_unix_rm_lock_file (sh.srvlog.name);
816  if (sh.flag.isdaemon == S_TRUE)
817    (void) sh_unix_rm_pid_file ();
818  if (skey != NULL)
819    memset (skey, (int) '\0', sizeof(sh_key_t));
820 
821  /* --- Exit. ---
822   */
823  SL_RET0(_("exit_handler"));
824}
825
826/***********************************************************
827 *
828 */
829#ifndef SIGHUP
830#define SIGHUP   1
831#endif
832#ifndef SIGTERM
833#define SIGTERM 15
834#endif
835#ifndef SIGKILL
836#define SIGKILL  9
837#endif
838
839#if defined(__linux__) || defined(sun) || defined(__sun) || defined(__sun__)
840#include <dirent.h>
841static pid_t * procdirSamhain (void)
842{
843  pid_t        * pidlist;
844  struct dirent * d;
845  DIR *        dp;
846  long         ino;
847  struct stat  buf;
848  int          i;
849  pid_t        pid, mypid = getpid();
850  char       * tail;
851  char         exef[128];
852
853  if (0 != stat(SH_INSTALL_PATH, &buf))
854    {
855      return NULL;
856    }
857
858  ino = (long) buf.st_ino;
859   
860  if (NULL == (dp = opendir(_("/proc"))))
861    {
862      return NULL;
863    }
864
865  SH_MUTEX_LOCK(mutex_readdir);
866
867  pidlist =  calloc(1, sizeof(pid_t) * 65535);
868  if (!pidlist)
869    goto unlock_and_out;
870
871  for (i = 0; i < 65535; ++i) pidlist[i] = 0;
872
873  i = 0;
874  while (NULL != (d = readdir(dp)) && i < 65535)
875    {
876      if (0 != strcmp(d->d_name, ".") && 0 != strcmp(d->d_name, ".."))
877        {
878          errno = 0;
879          pid = (pid_t) strtol (d->d_name, &tail, 0);
880          if (*tail != '\0' || errno != 0)
881            continue;
882          if (pid == mypid)
883            continue;
884#if defined(__linux__)
885          sprintf(exef, _("/proc/%d/exe"), (int) pid); /* known to fit  */
886#else
887          sprintf(exef, _("/proc/%d/object/a.out"),    /* known to fit  */
888                  (int) pid);
889#endif
890          if (0 == stat(exef, &buf) && ino == (long) buf.st_ino)
891            { pidlist[i] = (pid_t) pid; ++i; }
892        }
893    }
894
895 unlock_and_out:
896  ;
897  SH_MUTEX_UNLOCK(mutex_readdir);
898
899  closedir(dp);
900  return pidlist;
901}
902#else
903static pid_t * procdirSamhain (void)
904{
905  return NULL;
906}
907#endif
908
909static int killprocSamhain (pid_t pid)
910{
911  int i;
912
913  /* fprintf(stderr, "Killing %d\n", pid); */
914  if (pid > 0 && 0 == kill (pid, SIGTERM))
915    {
916      for (i = 0; i < 16; ++i)
917        {
918          (void) retry_msleep(1, 0);
919          if (0 != kill (pid, 0) && errno == ESRCH)
920            return (0);
921        }
922     
923      (void) kill (pid, SIGKILL);
924      return (0);
925    }
926  if (pid > 0)
927    {
928      if (errno == ESRCH)
929        return 7;
930      if (errno == EPERM)
931        return 4;
932      return 1;
933    }
934  else
935    return (7);
936}
937
938static pid_t pidofSamhain (int flag)
939{
940  FILE      * fp;
941  char        line[256];
942  char      * tail;
943  char      * p;
944  pid_t       pid;
945  long        inpid;
946  struct stat buf;
947 
948  fp = fopen (DEFAULT_ERRLOCK, "r");
949
950  if (!fp)
951    { if (errno != ENOENT) perror(_("fopen")); return 0; }
952  if (NULL == fgets(line, sizeof(line), fp))
953    { perror(_("fgets")); (void) sl_fclose(FIL__, __LINE__, fp); return 0; }
954  (void) sl_fclose(FIL__, __LINE__, fp); 
955  p = line; 
956  while (*p == ' '  || *p == '\f' || *p == '\n' || 
957         *p == '\r' || *p == '\t' || *p == '\v')
958    ++p;
959  errno = 0;
960  inpid = strtol (p, &tail, 0);
961  if (p == tail || errno != 0)
962    { perror(_("strtol")); return 0; }
963
964  pid = (pid_t) inpid;
965  if (inpid != (long) pid)
966    { perror(_("strtol")); return 0; }
967
968  /* remove stale pid file
969   */
970  if (flag == 1 && pid > 0 && 0 != kill(pid, 0) && errno == ESRCH)
971    {
972      if /*@-unrecog@*/ (0 == lstat (DEFAULT_ERRLOCK, &buf))/*@+unrecog@*/
973        {
974          if /*@-usedef@*/(S_ISREG(buf.st_mode))/*@+usedef@*/ 
975            {
976              (void) unlink(DEFAULT_ERRLOCK);
977            }
978        }
979      else 
980        {
981          perror(_("lstat")); return 0;
982        }
983      pid = 0;
984    }
985  return pid;
986}
987
988/* 1: start 2:stop 3:reload 4:status
989 */
990/*@-exitarg@*/
991static int samhainctl(int ctl, int * argc, char * argv[])
992{
993  char * fullpath;
994  pid_t  pid;
995  int    status;
996  int    res;
997  pid_t  respid;
998  int    times;
999  char * argp[32];
1000  pid_t       * pidlist;
1001  int         i;
1002#ifdef WCONTINUED
1003      int wflags = WNOHANG|WUNTRACED|WCONTINUED;
1004#else
1005      int wflags = WNOHANG|WUNTRACED;
1006#endif
1007
1008  fullpath = strdup (SH_INSTALL_PATH);
1009  if (fullpath == NULL)
1010    { perror(_("strdup")); exit (1); }
1011
1012  argp[0]  = strdup (SH_INSTALL_PATH);
1013  if (argp[0] == NULL)
1014    { perror(_("strdup")); exit (1); }
1015
1016  for (times = 1; times < 32; ++times)  argp[times] = NULL;
1017
1018  res = (*argc > 32) ? 32 : *argc;
1019
1020  for (times = 2; times < res; ++times) 
1021    {
1022      argp[times-1] = strdup (argv[times]);
1023      if (argp[times-1] == NULL)
1024        { perror(_("strdup")); exit (1); }
1025    }
1026
1027  if (ctl == 1)
1028    {
1029      pid = pidofSamhain(1);
1030
1031      if (pid != 0 && 0 == kill (pid, 0)) /* already started */
1032        exit (0);
1033
1034      pid = fork();
1035      switch (pid) {
1036      case ((pid_t) -1):
1037        perror(_("fork"));
1038        exit (1);
1039      case  0:
1040        if (0 != sl_close_fd (FIL__, __LINE__, 0))
1041          {
1042            _exit(4);
1043          }
1044        (void) execv(fullpath, argp); /* flawfinder: ignore *//* wtf? */
1045        if (errno == EPERM)
1046          _exit(4);
1047        else if (errno == ENOENT)
1048          _exit(5);
1049        _exit (1);
1050      default:
1051        times = 0;
1052        while (times < 300) {
1053          respid = waitpid(pid, &status, wflags);
1054          if ((pid_t)-1 == respid)
1055            {
1056              perror(_("waitpid"));
1057              exit (1);
1058            }
1059          else if (pid == respid)
1060            {
1061#ifndef USE_UNO
1062              if (0 != WIFEXITED(status))
1063                {
1064                  res = WEXITSTATUS(status);
1065                  exit (res == 0 ? 0 : res );
1066                }
1067              else
1068                exit (1);
1069#else
1070              exit (1);
1071#endif
1072            }
1073          ++times;
1074          (void) retry_msleep(1, 0);
1075        }
1076        exit (0); /* assume that it runs ok */
1077      }
1078    }
1079
1080  pid = pidofSamhain(0);
1081
1082  if (ctl == 2)  /* stop */
1083    {
1084      pidlist = procdirSamhain ();
1085      if (pid == 0 && NULL == pidlist) /* pid file not found */ 
1086        {
1087          free(fullpath);
1088          return (0);
1089        }
1090         
1091      status = 0;
1092      if (pid != 0)
1093         status = killprocSamhain(pid);
1094      if (pidlist != NULL)
1095        {
1096          i = 0; 
1097          while (i < 65535 && pidlist[i] != 0)
1098            { 
1099              if (pidlist[i] != pid) 
1100                status = killprocSamhain(pidlist[i]);
1101              ++i;
1102            }
1103        }
1104      free(fullpath);
1105      if (status == 7)
1106        return 0;
1107      else
1108        return status;
1109    }
1110       
1111  if (ctl == 3)  /* reload */
1112    {
1113      if (pid == 0)
1114        exit (7);
1115      if (0 == kill (pid, SIGHUP))
1116        exit (0);
1117      else
1118        {
1119          if (errno == EPERM)
1120            exit (4);
1121          if (errno == ESRCH)
1122            exit (7);
1123          exit (1);
1124        }
1125    }
1126
1127  if (ctl == 4)  /* status */
1128    {
1129      if (pid == 0)
1130        exit (3);
1131      if (0 == kill (pid, 0))
1132        exit (0);
1133      else
1134        {
1135          if (errno == EPERM)
1136            exit (4);
1137          if (errno == ESRCH)
1138            exit (1);
1139        }
1140    }
1141  free(fullpath); /* silence smatch false positive */
1142  exit (1); /* no exit handler installed yet */
1143  /*@notreached@*/
1144  return (0);
1145}
1146/*@+exitarg@*/
1147
1148#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1149#include "sh_schedule.h"
1150static sh_schedule_t * FileSchedOne = NULL;
1151static sh_schedule_t * FileSchedTwo = NULL;
1152
1153/* free a linked list of schedules
1154 */
1155static sh_schedule_t *  free_sched (sh_schedule_t * isched)
1156{
1157  sh_schedule_t * current = isched;
1158  sh_schedule_t * next    = NULL;
1159
1160  while (current != NULL)
1161    {
1162      next = current->next;
1163      SH_FREE(current);
1164      current = next;
1165    }
1166  return NULL;
1167}
1168
1169/* Add a new schedule to the linked list of schedules
1170 */
1171static sh_schedule_t * sh_set_schedule_int (const char * str, 
1172                                            sh_schedule_t * FileSchedIn, 
1173                                            /*@out@*/ int * status)
1174{
1175  sh_schedule_t * FileSched;
1176
1177  SL_ENTER(_("sh_set_schedule_int"));
1178
1179  if (0 == sl_strncmp(str, _("NULL"), 4))
1180    {
1181      (void) free_sched(FileSchedIn);
1182      FileSchedIn = NULL;
1183      *status = 0;
1184      return NULL;
1185    }
1186
1187  FileSched = SH_ALLOC(sizeof(sh_schedule_t));
1188  *status = create_sched(str, FileSched);
1189  if (*status != 0)
1190    {
1191      SH_FREE(FileSched);
1192      FileSched = NULL;
1193      SL_RETURN(FileSchedIn , _("sh_set_schedule_int"));
1194    }
1195  FileSched->next = FileSchedIn;
1196  SL_RETURN(FileSched , _("sh_set_schedule_int"));
1197}
1198
1199/* Add a new schedule to the linked list FileSchedOne
1200 */
1201int sh_set_schedule_one (const char * str)
1202{
1203  int status;
1204  FileSchedOne = sh_set_schedule_int (str, FileSchedOne, &status);
1205  return status;
1206}
1207
1208/* Add a new schedule to the linked list FileSchedTwo
1209 */
1210int sh_set_schedule_two (const char * str)
1211{
1212  int status;
1213  FileSchedTwo = sh_set_schedule_int (str, FileSchedTwo, &status);
1214  return status;
1215}
1216
1217#endif
1218
1219/*******************************************************
1220 *
1221 * Main program
1222 *
1223 *******************************************************/
1224#if !defined(SH_CUTEST)
1225int main(int argc, char * argv[])
1226#else
1227int undef_main(int argc, char * argv[])
1228#endif
1229{
1230#if defined(INET_SYSLOG)
1231  extern int    create_syslog_socket (int flag);
1232#endif
1233#if defined(SH_WITH_SERVER)
1234  extern int    sh_create_tcp_socket(void);
1235#endif
1236
1237#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1238  int           modnum;
1239  time_t        runtim;
1240  float         st_1, st_2;
1241  int           status;
1242  volatile long          cct = 0; /* main loop iterations */
1243
1244  volatile int           flag_check_1 = 0;
1245  volatile int           flag_check_2 = 0;
1246
1247  int           check_done   = 0;
1248#endif
1249
1250  volatile time_t        told;
1251  volatile time_t        tcurrent;
1252  size_t        tzlen;
1253  char *        tzptr;
1254  int           res;
1255
1256#if defined (SH_STEALTH_NOCL)
1257  char    command_line[256];
1258  int     my_argc = 0;
1259  char  * my_argv[32];
1260#endif
1261
1262#if !defined(USE_SYSTEM_MALLOC)
1263  typedef void assert_handler_tp(const char * error, const char *file, int line);
1264  extern assert_handler_tp *dnmalloc_set_handler(assert_handler_tp *new);
1265  (void) dnmalloc_set_handler(safe_fatal);
1266#endif
1267
1268  SH_G_INIT; /* Must precede any use of _() */
1269
1270  SL_ENTER(_("main"));
1271
1272  /* --- Close all but first three file descriptors. ---
1273   */
1274  sh_unix_closeall(3, -1, SL_FALSE); /* at program start */
1275
1276
1277  if (argc >= 2 && 0 != getuid() &&
1278      (0 == strcmp(argv[1], _("start")) ||
1279       0 == strcmp(argv[1], _("stop")) ||
1280       0 == strcmp(argv[1], _("reload")) ||
1281       0 == strcmp(argv[1], _("force-reload")) ||
1282       0 == strcmp(argv[1], _("status")) ||
1283       0 == strcmp(argv[1], _("restart"))))
1284    {
1285      return 4;
1286    }
1287       
1288  if (argc >= 2 && 0 == getuid())
1289    {
1290      /* return codes:
1291       * 0    Success
1292       * 1    Can not send signal / start program
1293       * 2    Pid file does not exist
1294       */
1295      if      (0 == strcmp(argv[1], _("start")))
1296        {
1297          (void) samhainctl (1, &argc, argv); /* does not return */
1298        }
1299      else if (0 == strcmp(argv[1], _("stop")))
1300        return (samhainctl (2, &argc, argv));
1301      else if (0 == strcmp(argv[1], _("reload")))
1302        (void) samhainctl (3, &argc, argv);   /* does not return */
1303      else if (0 == strcmp(argv[1], _("force-reload")))
1304        (void) samhainctl (3, &argc, argv);   /* does not return */
1305      else if (0 == strcmp(argv[1], _("status")))
1306        (void) samhainctl (4, &argc, argv);   /* does not return */
1307      else if (0 == strcmp(argv[1], _("restart")))
1308        {
1309          res = samhainctl (2, &argc, argv);
1310          if (res == 0 || res == 7)
1311            {
1312              (void) samhainctl (1, &argc, argv); /* does not return */
1313            }
1314          else
1315            return (res);
1316        }
1317    }
1318 
1319  /* if fd 0 is closed, presume that we want to be daemon and
1320   * run in check mode
1321   */
1322  if ((-1) == retry_fcntl(FIL__, __LINE__, 0, F_GETFL, 0) && 
1323           errno == EBADF)
1324    {
1325      sh.flag.opts = S_TRUE;
1326      (void) sh_unix_setdeamon(NULL);
1327#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1328      sh.flag.checkSum = SH_CHECK_CHECK;
1329      /* (void) sh_util_setchecksum(_("check")); */
1330#endif
1331      is_samhainctl_init = S_TRUE;
1332      sh.flag.opts = S_FALSE;
1333    }
1334
1335
1336  /* --- Install the exit handler. ---
1337   */
1338  (void) atexit(exit_handler);
1339
1340  /* --- Zero the mailer key, and fill it. ---
1341   */
1342  memset (ErrFlag, 0, 2*sizeof(UINT32));
1343
1344#ifdef MKA_01
1345  ErrFlag[0] |= (1 << 0);
1346#endif
1347#ifdef MKA_02
1348  ErrFlag[0] |= (1 << 1);
1349#endif
1350#ifdef MKA_03
1351  ErrFlag[0] |= (1 << 2);
1352#endif
1353#ifdef MKA_04
1354  ErrFlag[0] |= (1 << 3);
1355#endif
1356#ifdef MKA_05
1357  ErrFlag[0] |= (1 << 4);
1358#endif
1359#ifdef MKA_06
1360  ErrFlag[0] |= (1 << 5);
1361#endif
1362#ifdef MKA_07
1363  ErrFlag[0] |= (1 << 6);
1364#endif
1365#ifdef MKA_08
1366  ErrFlag[0] |= (1 << 7);
1367#endif
1368
1369#if defined(SCREW_IT_UP)
1370  BREAKEXIT(sh_sigtrap_prepare);
1371  (void) sh_sigtrap_prepare();
1372#endif
1373
1374  /* Save the timezone.
1375   */
1376  if (NULL != (tzptr = getenv("TZ"))) /* flawfinder: ignore */
1377    {
1378      tzlen       = strlen(tzptr);
1379      if (tzlen < 1024)
1380        {
1381          sh.timezone = calloc(1, tzlen + 1);
1382          if (sh.timezone != NULL)
1383            (void) sl_strlcpy (sh.timezone, tzptr, tzlen + 1);
1384        }
1385      else
1386        sh.timezone = NULL;
1387    }
1388  else
1389     sh.timezone = NULL;
1390
1391
1392  /* --------  INIT  --------   
1393   */
1394  sh_unix_ign_sigpipe();
1395
1396  /* Restrict error logging to stderr.
1397   */
1398  sh_error_only_stderr (S_TRUE);
1399
1400  /* Check that first three descriptors are open.
1401   */
1402  if ( retry_fcntl(FIL__, __LINE__, 0, F_GETFL, 0) == (-1))
1403    (void) aud_open(FIL__, __LINE__, SL_NOPRIV, _("/dev/null"), O_RDWR, 0);
1404  if ( retry_fcntl(FIL__, __LINE__, 1, F_GETFL, 0) == (-1))
1405    (void) aud_open(FIL__, __LINE__, SL_NOPRIV, _("/dev/null"), O_RDWR, 1);
1406  if ( retry_fcntl(FIL__, __LINE__, 2, F_GETFL, 0) == (-1))
1407    (void) aud_open(FIL__, __LINE__, SL_NOPRIV, _("/dev/null"), O_RDWR, 2);
1408
1409  /* --- Set default values. ---
1410   */
1411  BREAKEXIT(sh_init);
1412  sh_init ();    /* we are still privileged here, so we can mlock skey */
1413#if (defined (SH_WITH_SERVER) && !defined (SH_WITH_CLIENT))
1414  sh.flag.isserver = S_TRUE;
1415#endif
1416
1417  /* --- First check for an attached debugger (after setting
1418         sh.sigtrap_max_duration which has to be done before). ---
1419   */
1420  BREAKEXIT(sh_derr);
1421  (void) sh_derr();
1422
1423  /* --- Get local hostname. ---
1424   */
1425  BREAKEXIT(sh_unix_localhost);
1426  sh_unix_localhost();
1427
1428  /* --- Read the command line. ---
1429   */
1430  sh.flag.opts = S_TRUE;
1431
1432#if !defined(SH_STEALTH_NOCL)
1433  sh_argc_store = argc;
1434  sh_argv_store = argv;
1435  (void) sh_getopt_get (argc, argv);
1436#else
1437  if (argc > 1 && argv[1] != NULL && 
1438      strlen(argv[1]) > 0 && strlen(NOCL_CODE) > 0)
1439    {
1440      if ( 0 == strcmp(argv[1], NOCL_CODE) )
1441        {
1442#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
1443          char * saveptr;
1444#endif
1445          my_argv[0] = argv[0]; ++my_argc; 
1446          command_line[0] = '\0';
1447          if (NULL != fgets (command_line, sizeof(command_line), stdin))
1448            command_line[sizeof(command_line)-1] = '\0';
1449
1450          do {
1451#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
1452            my_argv[my_argc] = 
1453              strtok_r( (my_argc == 1) ? command_line : NULL, " \n", &saveptr);
1454#else
1455            my_argv[my_argc] = 
1456              strtok( (my_argc == 1) ? command_line : NULL, " \n");
1457#endif
1458            if (my_argv[my_argc] != NULL) {
1459              ++my_argc;
1460            } else {
1461              break;
1462            }
1463          } while (my_argc < 32);
1464
1465          sh_argc_store = my_argc;
1466          sh_argv_store = my_argv;
1467
1468          (void) sh_getopt_get (my_argc, my_argv);
1469        }
1470      else
1471        {
1472          /* discard command line */
1473          /* _exit(EXIT_FAILURE)  */  ; 
1474        }
1475    }
1476#endif
1477  sh.flag.opts = S_FALSE;
1478 
1479
1480  /* --- Get user info. ---
1481   */
1482  TPT((0, FIL__, __LINE__, _("msg=<Get user name.>\n")))
1483  if (0 != sh_unix_getUser ())
1484    {
1485      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1,
1486                       sh.prg_name);
1487      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1488    }
1489
1490
1491  /* *****************************
1492   *
1493   *  Read the configuration file.
1494   *
1495   * *****************************/
1496
1497  TPT((0, FIL__, __LINE__, _("msg=<Read the configuration file.>\n")))
1498  BREAKEXIT(sh_readconf_read);
1499  (void) sh_readconf_read ();
1500
1501  sh_calls_enable_sub();
1502
1503#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1504  if (sh.flag.checkSum == SH_CHECK_NONE)
1505    {
1506      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
1507                       _("No action specified: init, update, or check"), 
1508                       _("main"));
1509      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1,
1510                       sh.prg_name);
1511      aud_exit (FIL__, __LINE__, EXIT_FAILURE);
1512    }
1513#endif
1514
1515  /* do not append to database if run SUID
1516   */
1517  if ((sh.flag.checkSum == SH_CHECK_INIT) && (0 != sl_is_suid())) 
1518    {
1519      (void) dlog(1, FIL__, __LINE__, 
1520           _("Cannot initialize database when running with SUID credentials.\nYou need to run this with the user ID %d.\nYour current user ID is %d."), 
1521           (int) geteuid(), (int) sh.real.uid);
1522      sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_ACCESS,
1523                       (long) sh.real.uid, sh.data.path);
1524      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1525    }
1526
1527  /* avoid daemon mode for initialization
1528   */
1529  if (sh.flag.checkSum == SH_CHECK_INIT)
1530    {
1531      sh.flag.isdaemon = S_FALSE;
1532      sh.flag.loop     = S_FALSE;
1533    }
1534
1535  /* --- load database; checksum of database
1536   */
1537#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1538  TPT((0, FIL__, __LINE__, _("msg=<Get checksum of the database.>\n")))
1539  if (sh.flag.checkSum == SH_CHECK_CHECK) 
1540    {
1541      if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
1542        {
1543          char hashbuf[KEYBUF_SIZE];
1544          (void) sl_strlcpy(sh.data.hash,
1545                            sh_tiger_hash (file_path('D', 'R'), 
1546                                           TIGER_FILE, TIGER_NOLIM, 
1547                                           hashbuf, sizeof(hashbuf)), 
1548                            KEY_LEN+1);
1549        }
1550
1551      /* this eventually fetches the file from server to get checksum
1552       */
1553      sh_hash_init ();
1554    }
1555#endif
1556
1557  /* --- initialize signal handling etc.; fork daemon
1558   */
1559  if (sh_unix_init(sh.flag.isdaemon) == -1) 
1560    {
1561      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1,
1562                       sh.prg_name);
1563      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1564    }
1565
1566  /* --- drop privileges eventually ---
1567   */
1568#if defined(SH_WITH_SERVER)
1569  sh_create_tcp_socket ();
1570#if defined(INET_SYSLOG)
1571  create_syslog_socket (S_TRUE);
1572#endif
1573  SL_REQUIRE(sl_policy_get_real(DEFAULT_IDENT) == SL_ENONE, 
1574             _("sl_policy_get_real(DEFAULT_IDENT) == SL_ENONE"));
1575#else
1576  SL_REQUIRE(sl_policy_get_user(DEFAULT_IDENT) == SL_ENONE, 
1577             _("sl_policy_get_user(DEFAULT_IDENT) == SL_ENONE"));
1578#endif
1579
1580  /* --- Get user info (again). ---
1581   */
1582  TPT((0, FIL__, __LINE__, _("msg=<Get user name.>\n")))
1583  if (0 != sh_unix_getUser ())
1584    {
1585      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1,
1586                       sh.prg_name);
1587      aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1588    }
1589
1590  /* --- now check whether we really wanted it; if not, close ---
1591   */
1592#if defined(INET_SYSLOG) && defined(SH_WITH_SERVER)
1593  create_syslog_socket (S_FALSE);
1594#endif
1595
1596
1597  /* --- Enable full error logging ---
1598   */
1599  sh_error_only_stderr (S_FALSE);
1600
1601  sh.flag.started = S_TRUE;
1602
1603  /****************************************************
1604   *
1605   *   SERVER
1606   *
1607   ****************************************************/
1608
1609#if defined(SH_WITH_SERVER) && !defined(SH_WITH_CLIENT)
1610
1611#if (defined(WITH_GPG) || defined(WITH_PGP))
1612  /* log startup */
1613  sh_gpg_log_startup ();
1614#else
1615  sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_1H,
1616                   sh.prg_name, (long) sh.real.uid, 
1617                   (sh.flag.hidefile == S_TRUE) ? 
1618                   _("(hidden)") : file_path('C','R'), 
1619                   sh.conf.hash);
1620#endif
1621
1622#else
1623
1624  /****************************************************
1625   *
1626   *   CLIENT/STANDALONE
1627   *
1628   ****************************************************/
1629
1630  BREAKEXIT(sh_error_handle);
1631
1632  if (sh.flag.checkSum == SH_CHECK_CHECK) 
1633    {
1634#if (defined(WITH_GPG) || defined(WITH_PGP))
1635      /* log startup */
1636      sh_gpg_log_startup ();
1637#else
1638      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_2H,
1639                       sh.prg_name, (long) sh.real.uid,
1640                       (sh.flag.hidefile == S_TRUE) ? _("(hidden)") : file_path('C', 'R'), sh.conf.hash,
1641                       (sh.flag.hidefile == S_TRUE) ? _("(hidden)") : file_path('D', 'R'), sh.data.hash);
1642#endif
1643    }
1644  else
1645    {
1646#if (defined(WITH_GPG) || defined(WITH_PGP))
1647      /* log startup */
1648      sh_gpg_log_startup ();
1649#else
1650      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_START_1H,
1651                       sh.prg_name, (long) sh.real.uid,
1652                       (sh.flag.hidefile == S_TRUE) ? _("(hidden)") : file_path('C', 'R'), sh.conf.hash);
1653#endif
1654    }
1655#endif
1656
1657 
1658  if ((skey == NULL) || (skey->mlock_failed == SL_TRUE))
1659    sh_error_handle ((-1), FIL__, __LINE__, EPERM, MSG_MLOCK);
1660
1661  /* timer
1662   */
1663  tcurrent                   = time (NULL);
1664  told                       = tcurrent;
1665  sh.mailTime.alarm_last     = told;
1666
1667
1668  /****************************************************
1669   *
1670   *   SERVER
1671   *
1672   ****************************************************/
1673
1674#if defined(SH_WITH_SERVER)
1675  TPT((0, FIL__, __LINE__, _("msg=<Start server.>\n")))
1676
1677#if defined (SH_WITH_CLIENT)
1678  if (sh.flag.isserver == S_TRUE)
1679    { 
1680      sh_receive();
1681      TPT((0, FIL__, __LINE__, _("msg=<End server.>\n")))
1682      aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
1683    }
1684#else
1685  sh_receive();
1686  TPT((0, FIL__, __LINE__, _("msg=<End server.>\n")))
1687  aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
1688#endif
1689
1690#endif
1691
1692  /****************************************************
1693   *
1694   *   CLIENT/STANDALONE
1695   *
1696   ****************************************************/
1697#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1698
1699
1700  /* --- Initialize modules. ---
1701   */
1702  TPT((0, FIL__, __LINE__, _("msg=<Initialize modules.>\n")))
1703  for (modnum = 0; modList[modnum].name != NULL; ++modnum) 
1704    {
1705      status = modList[modnum].mod_init(&(modList[modnum]));
1706      if ( status < 0 )
1707        {
1708          if (status == (-1)) {
1709            sh_error_handle (SH_ERR_NOTICE, FIL__, __LINE__, status, 
1710                             MSG_MOD_FAIL,
1711                             _(modList[modnum].name),
1712                             status+SH_MOD_OFFSET);
1713          } else {
1714            sh_error_handle ((-1), FIL__, __LINE__, status, MSG_MOD_FAIL,
1715                             _(modList[modnum].name),
1716                             status+SH_MOD_OFFSET);
1717          }
1718          modList[modnum].initval = SH_MOD_FAILED;
1719        }
1720      else
1721        {
1722          sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MOD_OK,
1723                           _(modList[modnum].name));
1724          modList[modnum].initval = status;
1725        }
1726    }
1727   
1728  /*  --------  TEST SETUP  ---------
1729   */
1730  (void) sh_files_setrec();
1731  (void) sh_files_test_setup();
1732  sh_audit_commit ();
1733
1734  /* --------  NICE LEVEL   ---------
1735   */
1736  if (0 != sh.flag.nice)
1737    {
1738#ifdef HAVE_SETPRIORITY
1739      /*@-unrecog@*/
1740      (void) setpriority(PRIO_PROCESS, 0, sh.flag.nice);
1741      /*@+unrecog@*/
1742#else
1743      (void) nice(sh.flag.nice);
1744#endif
1745    }
1746
1747  /*  --------  MAIN LOOP  ---------
1748   */
1749  sh.statistics.bytes_speed   = 0;
1750  sh.statistics.bytes_hashed  = 0;
1751  sh.statistics.files_report  = 0;
1752  sh.statistics.files_error   = 0;
1753  sh.statistics.files_nodir   = 0;
1754
1755  while (1 == 1) 
1756    {
1757      ++cct;
1758
1759      BREAKEXIT(sh_error_handle);
1760
1761      TPT((0, FIL__, __LINE__, _("msg=<Start main loop.>, iter=<%ld>\n"), cct))
1762
1763      tcurrent = time (NULL);
1764
1765      if (sig_raised > 0) 
1766        {
1767
1768          TPT((0, FIL__, __LINE__, _("msg=<Process a signal.>\n")))
1769
1770          if (sig_termfast == 1)  /* SIGTERM */
1771            {
1772              TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
1773              /* strncpy (sh_sig_msg, _("SIGTERM"), 20); */
1774              --sig_raised; --sig_urgent;
1775              aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
1776            }
1777
1778          if (sig_force_check == 1) /* SIGTTOU */
1779            {
1780              TPT((0, FIL__, __LINE__, _("msg=<Check run triggered.>\n")));
1781              flag_check_1 = 1;
1782              flag_check_2 = 1;
1783              sig_force_check = 0;
1784              --sig_raised; 
1785            }
1786         
1787          if (sig_config_read_again == 1 && /* SIGHUP */
1788              sh_global_suspend_flag == 0)
1789            {
1790              TPT((0, FIL__, __LINE__, _("msg=<Re-read configuration.>\n")))
1791              sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_RECONF);
1792
1793              sh_thread_pause_flag = S_TRUE;
1794
1795#if defined(WITH_EXTERNAL)
1796              /* delete list of external tasks
1797               */
1798              (void) sh_ext_cleanup();
1799#endif
1800#if defined(SH_WITH_MAIL)
1801              sh_nmail_free();
1802#endif
1803
1804              /* delete the file list, make all database
1805               * entries visible (allignore = FALSE)
1806               */
1807              (void) sh_files_deldirstack ();
1808              (void) sh_files_delfilestack ();
1809              (void) sh_files_delglobstack ();
1810              (void) sh_ignore_clean ();
1811              (void) hash_full_tree ();
1812              sh_audit_delete_all ();
1813
1814
1815#if defined(SH_WITH_CLIENT)
1816              reset_count_dev_server();
1817#endif
1818#if defined(SH_WITH_CLIENT) || defined(SH_STANDALONE)
1819              sh_restrict_purge ();
1820
1821
1822              FileSchedOne = free_sched(FileSchedOne);
1823              FileSchedTwo = free_sched(FileSchedTwo);
1824
1825              for (modnum = 0; modList[modnum].name != NULL; ++modnum) 
1826                {
1827                  /* sh_thread_pause_flag is true, and we block in lock
1828                   * until check has returned, so we are sure check will
1829                   * not run until sh_thread_pause_flag is set to false
1830                   */
1831                  /* if (modList[modnum].initval >= SH_MOD_ACTIVE) */
1832                  (void) modList[modnum].mod_reconf();
1833                }
1834#endif
1835
1836              reset_count_dev_console();
1837              reset_count_dev_time();
1838
1839              (void) sh_unix_maskreset();
1840 
1841              /* Should this be included ???
1842               * (i.e. should we reload the database ?)
1843               */
1844#ifdef RELOAD_DATABASE
1845              sh_hash_hashdelete();
1846
1847              if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
1848                {
1849                  char hashbuf[KEYBUF_SIZE];
1850                  (void) sl_strlcpy(sh.data.hash,
1851                                    sh_tiger_hash (file_path('D', 'R'), 
1852                                                   TIGER_FILE, TIGER_NOLIM, 
1853                                                   hashbuf, sizeof(hashbuf)), 
1854                                    KEY_LEN+1);
1855                }
1856#endif
1857              (void) sl_trust_purge_user();
1858              (void) sh_files_hle_reg (NULL);
1859              (void) sh_prelink_run (NULL, NULL, 0);
1860
1861              /* --------------------------
1862               * --- READ CONFIGURATION ---
1863               * --------------------------
1864               */
1865              (void) sh_readconf_read ();
1866              sig_config_read_again = 0;
1867              (void) sh_files_setrec();
1868              (void) sh_files_test_setup();
1869              sh_audit_commit ();
1870
1871              if (0 != sh.flag.nice)
1872                {
1873#ifdef HAVE_SETPRIORITY
1874                  setpriority(PRIO_PROCESS, 0, sh.flag.nice);
1875#else
1876                  nice(sh.flag.nice);
1877#endif
1878                }
1879
1880              if (sh.flag.checkSum == SH_CHECK_INIT)
1881                {
1882                  sh.flag.isdaemon = S_FALSE;
1883                  sh.flag.loop     = S_FALSE;
1884                }
1885
1886
1887              /* --- Initialize modules. ---
1888               */
1889              TPT((0, FIL__, __LINE__, _("msg=<Initialize modules.>\n")));
1890              for (modnum = 0; modList[modnum].name != NULL; ++modnum) 
1891                {
1892                  status = modList[modnum].mod_init(&(modList[modnum]));
1893
1894                  if (status < 0)
1895                    {
1896                      if (status == (-1)) {
1897                        sh_error_handle (SH_ERR_NOTICE, FIL__, __LINE__, 
1898                                         status, MSG_MOD_FAIL,
1899                                         _(modList[modnum].name),
1900                                         status+SH_MOD_OFFSET);
1901                      } else {
1902                        sh_error_handle ((-1), FIL__, __LINE__, 
1903                                         status, MSG_MOD_FAIL,
1904                                         _(modList[modnum].name),
1905                                         status+SH_MOD_OFFSET);
1906                      }
1907                      modList[modnum].initval = SH_MOD_FAILED;
1908                    }
1909                  else
1910                    {
1911                      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_MOD_OK,
1912                                       _(modList[modnum].name));
1913                      modList[modnum].initval = status;
1914                    }
1915                }
1916
1917              /* module is properly set up now
1918               */
1919              sh_thread_pause_flag = S_FALSE;
1920             
1921              --sig_raised;
1922            }
1923         
1924          if (sig_fresh_trail == 1) /* SIGIOT */
1925            {
1926              if (sh_global_suspend_flag == 0)
1927                {
1928                  SH_MUTEX_LOCK(mutex_thread_nolog);
1929
1930                  /* Logfile access
1931                   */
1932#ifdef SH_USE_XML
1933                  (void) sh_log_file (NULL, NULL);
1934#endif
1935                  TPT((0, FIL__, __LINE__, _("msg=<Logfile stop/restart.>\n")));
1936                  sh_error_only_stderr (S_TRUE);
1937                  (void) sh_unix_rm_lock_file(sh.srvlog.name);
1938                  (void) retry_msleep(3, 0);
1939                  sh.flag.log_start = S_TRUE;
1940                  sh_error_only_stderr (S_FALSE);
1941                  sh_thread_pause_flag = S_FALSE;
1942                  sig_fresh_trail       = 0;
1943                  --sig_raised;
1944                  SH_MUTEX_UNLOCK(mutex_thread_nolog);
1945                }
1946            }
1947         
1948          if (sig_terminate == 1)  /* SIGQUIT */
1949            {
1950              TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
1951              strncpy (sh_sig_msg, _("Quit"), 20);
1952              --sig_raised; --sig_urgent;
1953              aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
1954            }
1955         
1956          if (sig_debug_switch == 1)  /* SIGUSR1 */
1957            {
1958              TPT((0, FIL__, __LINE__, _("msg=<Debug switch.>\n")));
1959              sh_error_dbg_switch();
1960              sig_debug_switch = 0;
1961              --sig_raised;
1962            }
1963         
1964          if (sig_suspend_switch > 0)  /* SIGUSR2 */
1965            {
1966              TPT((0, FIL__, __LINE__, _("msg=<Suspend switch.>\n")));
1967              if (sh_global_suspend_flag != 1) {
1968                SH_MUTEX_LOCK_UNSAFE(mutex_thread_nolog);
1969                sh_global_suspend_flag = 1;
1970                sh_error_handle((-1), FIL__, __LINE__, 0, MSG_SUSPEND, 
1971                                sh.prg_name);
1972              } else {
1973                sh_global_suspend_flag = 0;
1974                SH_MUTEX_UNLOCK_UNSAFE(mutex_thread_nolog);
1975              }
1976              --sig_suspend_switch;
1977              --sig_raised; --sig_urgent;
1978            }
1979          sig_raised = (sig_raised < 0) ? 0 : sig_raised;
1980          sig_urgent = (sig_urgent < 0) ? 0 : sig_urgent;
1981          TPT((0, FIL__, __LINE__, _("msg=<End signal processing.>\n")));
1982        }
1983     
1984      if (sh_global_suspend_flag == 1)
1985        {
1986          (void) retry_msleep (1, 0);
1987          continue;
1988        }
1989     
1990      /* see whether its time to check files
1991       */
1992      if      (sh.flag.checkSum == SH_CHECK_INIT ||
1993               (sh.flag.inotify & SH_INOTIFY_DOSCAN) != 0 ||
1994               (sh.flag.checkSum == SH_CHECK_CHECK &&
1995                (sh.flag.isdaemon == S_FALSE && sh.flag.loop == S_FALSE)))
1996        {
1997          flag_check_1 = 1;
1998          if (FileSchedTwo != NULL) 
1999            flag_check_2 = 1;
2000        }
2001      else if (sh.flag.checkSum == SH_CHECK_CHECK || 
2002               (sh.flag.update == S_TRUE && 
2003                (sh.flag.isdaemon == S_TRUE || sh.flag.loop == S_TRUE)))
2004        {
2005          if (FileSchedOne == NULL)
2006            {
2007              /* use interval if we have no schedule
2008               */
2009              if (tcurrent - sh.fileCheck.alarm_last >= 
2010                  sh.fileCheck.alarm_interval)
2011                flag_check_1 = 1;
2012            }
2013          else
2014            {
2015              flag_check_1 = test_sched(FileSchedOne);
2016              if (FileSchedTwo != NULL) 
2017                flag_check_2 = test_sched(FileSchedTwo);
2018              if (flag_check_2 == 1) 
2019                flag_check_1 = 1;
2020            }
2021        }
2022
2023      check_done = 0;
2024
2025      if (sh.flag.checkSum != SH_CHECK_NONE &&
2026          (flag_check_1 == 1 || flag_check_2 == 1))
2027        {
2028          SH_INOTIFY_IFUSED( sh.flag.inotify |= SH_INOTIFY_INSCAN; );
2029          /* Refresh list files matching glob patterns.
2030           */
2031          if (sh.flag.checkSum != SH_CHECK_INIT)
2032            sh_files_check_globPatterns();
2033
2034          /*
2035           * check directories and files
2036           * ORDER IS IMPORTANT -- DIRZ FIRST
2037           */
2038          sh.statistics.bytes_hashed   = 0;
2039          sh.statistics.time_start     = time (NULL);
2040          sh.statistics.dirs_checked   = 0;
2041          sh.statistics.files_checked  = 0;
2042          sh.statistics.files_report   = 0;
2043          sh.statistics.files_error    = 0;
2044          sh.statistics.files_nodir    = 0;
2045
2046          TPT((0, FIL__, __LINE__, _("msg=<Check directories.>\n")))
2047          BREAKEXIT(sh_dirs_chk);
2048          if (flag_check_1 == 1)
2049            {
2050              (void) sh_dirs_chk  (1);
2051#ifndef SH_PROFILE
2052              (void) retry_aud_chdir (FIL__, __LINE__, "/");
2053#endif
2054            }
2055          if (flag_check_2 == 1)
2056            {
2057              (void) sh_dirs_chk  (2); 
2058#ifndef SH_PROFILE
2059              (void) retry_aud_chdir (FIL__, __LINE__, "/");
2060#endif
2061            }
2062          TPT((0, FIL__, __LINE__, _("msg=<Check files.>\n")))
2063          BREAKEXIT(sh_files_chk);
2064          if (flag_check_1 == 1)
2065            (void) sh_files_chk ();
2066
2067          if (sig_urgent > 0)
2068            continue;
2069
2070          /*
2071           * check for files not visited
2072           */
2073          if (flag_check_2 == 1 || FileSchedTwo == NULL)
2074            {
2075              TPT((0, FIL__, __LINE__, _("msg=<Check for missing files.>\n")))
2076              sh_hash_unvisited (ShDFLevel[SH_ERR_T_FILE]);
2077            }
2078
2079          if (sig_urgent > 0)
2080            continue;
2081
2082          /* reset
2083           */
2084          TPT((0, FIL__, __LINE__, _("msg=<Reset status.>\n")))
2085          sh_dirs_reset  ();
2086          if (sig_urgent > 0)
2087            continue;
2088
2089          sh_files_reset ();
2090          flag_check_1 = 0;
2091          flag_check_2 = 0;
2092          check_done   = 1;
2093          SH_INOTIFY_IFUSED( sh.flag.inotify &= ~SH_INOTIFY_INSCAN; );
2094          SH_INOTIFY_IFUSED( sh.flag.inotify &= ~SH_INOTIFY_DOSCAN; );
2095
2096          (void) sh_prelink_run (NULL, NULL, 0);
2097
2098          if (sig_urgent > 0)
2099            continue;
2100
2101          runtim = time(NULL) - sh.statistics.time_start;
2102          sh.statistics.time_check = runtim;
2103       
2104          if ((sh.statistics.dirs_checked == 0) && 
2105              (sh.statistics.files_checked == 0))
2106            sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_0);
2107
2108          else
2109            {
2110              st_1 = (float) sh.statistics.bytes_hashed;
2111              st_2 = (float) runtim;
2112
2113
2114              if (st_1 > FLT_EPSILON && st_2 > FLT_EPSILON) 
2115                st_1 = st_1/st_2;
2116              else if (st_1 > FLT_EPSILON)
2117                st_1 = (float) (st_1 * 1.0);
2118              else
2119                st_1 = 0.0;
2120
2121              sh.statistics.bytes_speed = (unsigned long) st_1;
2122
2123              sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_CHECK_1,
2124                               (long) runtim, 
2125                               0.001 * st_1);
2126
2127              if (sh.flag.checkSum != SH_CHECK_INIT)
2128                sh_efile_report();
2129            }
2130          sh.fileCheck.alarm_last = time (NULL);
2131
2132          if (sig_urgent > 0)
2133            continue;
2134
2135          /*
2136           * flush mail queue
2137           */
2138#if defined(SH_WITH_MAIL)
2139          TPT((0, FIL__, __LINE__, _("msg=<Flush mail queue.>\n")))
2140          (void) sh_nmail_flush ();
2141#endif
2142        }
2143     
2144      if (sig_urgent > 0)
2145        continue;
2146     
2147      /* execute modules
2148       */
2149      TPT((0, FIL__, __LINE__, _("msg=<Execute modules.>\n")))
2150      for (modnum = 0; modList[modnum].name != NULL; ++modnum) 
2151        {
2152          if (modList[modnum].initval == SH_MOD_ACTIVE &&
2153              0 != modList[modnum].mod_timer(tcurrent))
2154            if (0 != (status = modList[modnum].mod_check()))
2155              sh_error_handle ((-1), FIL__, __LINE__, status, MSG_MOD_EXEC,
2156                               _(modList[modnum].name), (long) (status+SH_MOD_OFFSET));
2157        }
2158     
2159      /* 27.05.2002 avoid empty database
2160       * 22.10.2002 moved here b/o suid check initialization
2161       */ 
2162      if      (sh.flag.checkSum == SH_CHECK_INIT)
2163        sh_hash_pushdata (NULL, NULL);
2164
2165      /* write out database
2166       */
2167      if (sh.flag.checkSum == SH_CHECK_CHECK && 
2168          sh.flag.update == S_TRUE && 
2169          check_done == 1)
2170        sh_hash_writeout ();
2171
2172      /* no-op unless MEM_LOG is defined in sh_mem.c
2173       */
2174#ifdef MEM_DEBUG
2175      sh_mem_dump ();
2176#endif
2177
2178      {
2179        char * stale;
2180
2181        stale = sl_check_stale();
2182        if (stale)
2183          {
2184            sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
2185                            stale, _("sl_check_stale"));
2186          }
2187
2188        stale = sl_check_badfd();
2189        if (stale)
2190          {
2191            sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
2192                            stale, _("sl_check_stale"));
2193          }
2194      }
2195
2196      /* no loop if not daemon
2197       */
2198      if (sh.flag.isdaemon != S_TRUE && sh.flag.loop == S_FALSE)
2199        break; 
2200      if (sig_urgent > 0)
2201        continue;
2202
2203      /* see whether its time to send mail
2204       */
2205#if defined(SH_WITH_MAIL)
2206      if (tcurrent - sh.mailTime.alarm_last >= sh.mailTime.alarm_interval) 
2207        {
2208          TPT((0, FIL__, __LINE__, _("msg=<Flush mail queue.>\n")))
2209          (void) sh_nmail_flush ();
2210          sh.mailTime.alarm_last = time (NULL);
2211        }
2212#endif
2213      if (sig_urgent > 0)
2214        continue;
2215           
2216      /* log the timestamp
2217       */
2218      if ((int)(tcurrent - told) >= sh.looptime )
2219        {
2220          TPT((0, FIL__, __LINE__, _("msg=<Log the timestamp.>\n")))
2221          told = tcurrent;
2222#ifdef MEM_DEBUG
2223          sh_mem_check();
2224          sh_unix_count_mlock();
2225#else
2226          sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_STAMP);
2227#endif
2228        }
2229   
2230      /* seed / re-seed the PRNG if required
2231       */
2232      (void) taus_seed();
2233     
2234      if (sig_urgent > 0)
2235        continue;
2236     
2237      /* reset cache
2238       */
2239      sh_userid_destroy();
2240
2241      /* go to sleep
2242       */
2243      (void) retry_msleep (1, 0);
2244
2245      BREAKEXIT(sh_derr);
2246      (void) sh_derr();
2247    }
2248 
2249  /*   ------  END  -----------
2250   */
2251
2252
2253
2254  /*
2255   * cleanup
2256   */
2257  TPT((0, FIL__, __LINE__, _("msg=<Cleanup.>\n")));
2258  sh_hash_hashdelete(); 
2259
2260#if defined(SH_WITH_MAIL)
2261  if (sh.mailNum.alarm_last > 0) 
2262    (void)sh_nmail_flush ();
2263#endif
2264
2265  /* #if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE) */
2266#endif
2267
2268#if 0
2269  {
2270    char command[128];
2271    sprintf(command, "/bin/cat /proc/%d/status", (int) getpid());
2272    system(command); /* flawfinder: ignore *//* debug code */
2273    malloc_stats();
2274  }
2275#endif
2276
2277  aud_exit (FIL__, __LINE__, EXIT_SUCCESS);
2278  SL_RETURN(0, _("main"));
2279}
Note: See TracBrowser for help on using the repository browser.