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