source: trunk/src/sh_unix.c@ 85

Last change on this file since 85 was 84, checked in by rainer, 18 years ago

Fix fo ticket #47 (yule TCP socket accidentally closed).
File size: 103.5 KB
Line 
1/* SAMHAIN file system integrity testing */
2/* Copyright (C) 1999 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 <ctype.h>
27
28
29#ifdef HAVE_MEMORY_H
30#include <memory.h>
31#endif
32
33#ifdef HAVE_UNISTD_H
34#include <errno.h>
35#include <signal.h>
36#include <pwd.h>
37#include <grp.h>
38#include <sys/types.h>
39#include <sys/stat.h>
40#include <sys/resource.h>
41#include <fcntl.h>
42#include <unistd.h>
43#include <sys/wait.h>
44
45/*********************
46#ifdef HAVE_SYS_VFS_H
47#include <sys/vfs.h>
48#endif
49**********************/
50#endif
51
52#if TIME_WITH_SYS_TIME
53#include <sys/time.h>
54#include <time.h>
55#else
56#if HAVE_SYS_TIME_H
57#include <sys/time.h>
58#else
59#include <time.h>
60#endif
61#endif
62
63#ifdef HAVE_SYS_SELECT_H
64#include <sys/select.h>
65#endif
66
67#ifndef FD_SET
68#define NFDBITS 32
69#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
70#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
71#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
72#endif /* !FD_SET */
73#ifndef FD_SETSIZE
74#define FD_SETSIZE 32
75#endif
76#ifndef FD_ZERO
77#define FD_ZERO(p) memset((char *)(p), '\0', sizeof(*(p)))
78#endif
79
80
81#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
82#include <sys/mman.h>
83#endif
84
85#include "samhain.h"
86#include "sh_error.h"
87#include "sh_unix.h"
88#include "sh_utils.h"
89#include "sh_mem.h"
90#include "sh_hash.h"
91#include "sh_tools.h"
92#include "sh_tiger.h"
93#include "sh_prelink.h"
94
95/* moved here from far below
96 */
97#include <netdb.h>
98
99#define SH_NEED_PWD_GRP
100#define SH_NEED_GETHOSTBYXXX
101#include "sh_static.h"
102
103#ifndef HAVE_LSTAT
104#define lstat stat
105#endif
106
107#if defined(S_IFLNK) && !defined(S_ISLNK)
108#define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
109#else
110#if !defined(S_ISLNK)
111#define S_ISLNK(mode) (0)
112#endif
113#endif
114
115#if defined(S_IFSOCK) && !defined(S_ISSOCK)
116#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
117#else
118#if !defined(S_ISSOCK)
119#define S_ISSOCK(mode) (0)
120#endif
121#endif
122
123#if defined(S_IFDOOR) && !defined(S_ISDOOR)
124#define S_ISDOOR(mode) (((mode) & S_IFMT) == S_IFDOOR)
125#else
126#if !defined(S_ISDOOR)
127#define S_ISDOOR(mode) (0)
128#endif
129#endif
130
131#if defined(S_IFPORT) && !defined(S_ISPORT)
132#define S_ISPORT(mode) (((mode) & S_IFMT) == S_IFPORT)
133#else
134#if !defined(S_ISPORT)
135#define S_ISPORT(mode) (0)
136#endif
137#endif
138
139
140#undef FIL__
141#define FIL__ _("sh_unix.c")
142
143unsigned long mask_PRELINK = MASK_PRELINK_;
144unsigned long mask_USER0 = MASK_USER_;
145unsigned long mask_USER1 = MASK_USER_;
146unsigned long mask_USER2 = MASK_USER_;
147unsigned long mask_USER3 = MASK_USER_;
148unsigned long mask_USER4 = MASK_USER_;
149unsigned long mask_ALLIGNORE = MASK_ALLIGNORE_;
150unsigned long mask_ATTRIBUTES = MASK_ATTRIBUTES_;
151unsigned long mask_LOGFILES = MASK_LOGFILES_;
152unsigned long mask_LOGGROW = MASK_LOGGROW_;
153unsigned long mask_READONLY = MASK_READONLY_;
154unsigned long mask_NOIGNORE = MASK_NOIGNORE_;
155
156
157extern char **environ;
158
159int sh_unix_maskreset()
160{
161 mask_PRELINK = MASK_PRELINK_;
162 mask_USER0 = MASK_USER_;
163 mask_USER1 = MASK_USER_;
164 mask_USER2 = MASK_USER_;
165 mask_USER3 = MASK_USER_;
166 mask_USER4 = MASK_USER_;
167 mask_ALLIGNORE = MASK_ALLIGNORE_;
168 mask_ATTRIBUTES = MASK_ATTRIBUTES_;
169 mask_LOGFILES = MASK_LOGFILES_;
170 mask_LOGGROW = MASK_LOGGROW_;
171 mask_READONLY = MASK_READONLY_;
172 mask_NOIGNORE = MASK_NOIGNORE_;
173 return 0;
174}
175
176
177#ifdef SYS_SIGLIST_DECLARED
178/* extern const char * const sys_siglist[]; */
179#else
180char * sh_unix_siglist (int signum)
181{
182 switch (signum)
183 {
184#ifdef SIGHUP
185 case SIGHUP:
186 return _("Hangup");
187#endif
188#ifdef SIGINT
189 case SIGINT:
190 return _("Interrupt");
191#endif
192#ifdef SIGQUIT
193 case SIGQUIT:
194 return _("Quit");
195#endif
196#ifdef SIGILL
197 case SIGILL:
198 return _("Illegal instruction");
199#endif
200#ifdef SIGTRAP
201 case SIGTRAP:
202 return _("Trace/breakpoint trap");
203#endif
204#ifdef SIGABRT
205 case SIGABRT:
206 return _("IOT trap/Abort");
207#endif
208#ifdef SIGBUS
209 case SIGBUS:
210 return _("Bus error");
211#endif
212#ifdef SIGFPE
213 case SIGFPE:
214 return _("Floating point exception");
215#endif
216#ifdef SIGUSR1
217 case SIGUSR1:
218 return _("User defined signal 1");
219#endif
220#ifdef SIGSEGV
221 case SIGSEGV:
222 return _("Segmentation fault");
223#endif
224#ifdef SIGUSR2
225 case SIGUSR2:
226 return _("User defined signal 2");
227#endif
228#ifdef SIGPIPE
229 case SIGPIPE:
230 return _("Broken pipe");
231#endif
232#ifdef SIGALRM
233 case SIGALRM:
234 return _("Alarm clock");
235#endif
236#ifdef SIGTERM
237 case SIGTERM:
238 return _("Terminated");
239#endif
240#ifdef SIGSTKFLT
241 case SIGSTKFLT:
242 return _("Stack fault");
243#endif
244#ifdef SIGCHLD
245 case SIGCHLD:
246 return _("Child exited");
247#endif
248#ifdef SIGCONT
249 case SIGCONT:
250 return _("Continued");
251#endif
252#ifdef SIGSTOP
253 case SIGSTOP:
254 return _("Stopped");
255#endif
256#ifdef SIGTSTP
257 case SIGTSTP:
258 return _("Stop typed at tty");
259#endif
260#ifdef SIGTTIN
261 case SIGTTIN:
262 return _("Stopped (tty input)");
263#endif
264#ifdef SIGTTOU
265 case SIGTTOU:
266 return _("Stopped (tty output)");
267#endif
268#ifdef SIGURG
269 case SIGURG:
270 return _("Urgent condition");
271#endif
272#ifdef SIGXCPU
273 case SIGXCPU:
274 return _("CPU time limit exceeded");
275#endif
276#ifdef SIGXFSZ
277 case SIGXFSZ:
278 return _("File size limit exceeded");
279#endif
280#ifdef SIGVTALRM
281 case SIGVTALRM:
282 return _("Virtual time alarm");
283#endif
284#ifdef SIGPROF
285 case SIGPROF:
286 return _("Profile signal");
287#endif
288#ifdef SIGWINCH
289 case SIGWINCH:
290 return _("Window size changed");
291#endif
292#ifdef SIGIO
293 case SIGIO:
294 return _("Possible I/O");
295#endif
296#ifdef SIGPWR
297 case SIGPWR:
298 return _("Power failure");
299#endif
300#ifdef SIGUNUSED
301 case SIGUNUSED:
302 return _("Unused signal");
303#endif
304 }
305 return _("Unknown");
306}
307#endif
308
309
310/* Log from within a signal handler without using any
311 * functions that are not async signal safe.
312 *
313 * This is the safe_itoa helper function.
314 */
315char * safe_itoa(int i, char * str, int size)
316{
317 unsigned int u;
318 int iisneg = 0;
319 char *p = &str[size-1];
320
321 *p = '\0';
322 if (i < 0) {
323 iisneg = 1;
324 u = ((unsigned int)(-(1+i))) + 1;
325 } else {
326 u = i;
327 }
328 do {
329 --p;
330 *p = '0' + (u % 10);
331 u /= 10;
332 } while (u && (p != str));
333 if ((iisneg == 1) && (p != str)) {
334 --p;
335 *p = '-';
336 }
337 return p;
338}
339
340/* Log from within a signal handler without using any
341 * functions that are not async signal safe.
342 *
343 * This is the safe_logger function.
344 * Arguments: signal (signal number), method (0=logger, 1=stderr), thepid (pid)
345 */
346extern int OnlyStderr;
347
348int safe_logger (int signal, int method, char * details)
349{
350 unsigned int i = 0;
351 int status = -1;
352 struct stat buf;
353 pid_t newpid;
354 char str[128];
355 char * p;
356
357 char l0[64], l1[64], l2[64], l3[64];
358 char a0[32], a1[32], a2[32];
359 char e0[128];
360 char msg[128];
361
362 char * locations[] = { NULL, NULL, NULL, NULL, NULL };
363 char * envp[] = { NULL, NULL };
364 char * argp[] = { NULL, NULL, NULL, NULL, NULL };
365
366 pid_t thepid = getpid();
367
368 if ((sh.flag.isdaemon == S_FALSE) || (OnlyStderr == S_TRUE))
369 method = 1;
370
371 /* seems that solaris cc needs this way of initializing ...
372 */
373 locations[0] = l0;
374 locations[1] = l1;
375 locations[2] = l2;
376 locations[3] = l3;
377
378 envp[0] = e0;
379
380 argp[0] = a0;
381 argp[1] = a1;
382 argp[2] = a2;
383
384 sl_strlcpy(msg, _("samhain["), 128);
385 p = safe_itoa((int) thepid, str, 128);
386 if (p && *p)
387 sl_strlcat(msg, p, 128);
388 if (signal == 0)
389 {
390 if (details == NULL) {
391 sl_strlcat(msg, _("]: out of memory"), 128);
392 } else {
393 sl_strlcat(msg, _("]: "), 128);
394 sl_strlcat(msg, details, 128);
395 }
396 }
397 else
398 {
399 sl_strlcat(msg, _("]: exit on signal "), 128);
400 p = safe_itoa(signal, str, 128);
401 if (p && *p)
402 sl_strlcat(msg, p, 128);
403 }
404
405 if (method == 1) {
406#ifndef STDERR_FILENO
407#define STDERR_FILENO 2
408#endif
409 write(STDERR_FILENO, msg, strlen(msg));
410 write(STDERR_FILENO, "\n", 1);
411 return 0;
412 }
413
414 sl_strlcpy (l0, _("/usr/bin/logger"), 64);
415 sl_strlcpy (l1, _("/usr/sbin/logger"), 64);
416 sl_strlcpy (l2, _("/usr/ucb/logger"), 64);
417 sl_strlcpy (l3, _("/bin/logger"), 64);
418
419 sl_strlcpy (a0, _("logger"), 32);
420 sl_strlcpy (a1, _("-p"), 32);
421 sl_strlcpy (a2, _("daemon.alert"), 32);
422
423 sl_strlcpy (e0,
424 _("PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/ucb:/usr/local/bin"),
425 128);
426
427 while (locations[i] != NULL) {
428 status = stat(locations[i], &buf);
429 if (status == 0)
430 break;
431 ++i;
432 }
433
434 if (locations[i] != NULL) {
435 argp[3] = msg;
436 newpid = fork();
437 if (newpid == 0) {
438 execve(locations[i], argp, envp);
439 _exit(1);
440 }
441 else if (newpid > 0) {
442 waitpid(newpid, &status, WUNTRACED);
443 }
444 }
445 return 0;
446}
447
448void safe_fatal (char * details,
449 char * file, int line)
450{
451 char msg[128];
452 char str[128];
453 char * p;
454 int signal = 0;
455 int method = 0;
456
457 p = safe_itoa((int) line, str, 128);
458 sl_strlcpy(msg, _("FATAL: "), 128);
459 sl_strlcat(msg, file, 128);
460 sl_strlcat(msg, ": ", 128);
461 if (p && (*p)) {
462 sl_strlcat(msg, p , 128);
463 sl_strlcat(msg, ": ", 128);
464 }
465 sl_strlcat(msg, details, 128);
466 safe_logger (signal, method, msg);
467 _exit(EXIT_FAILURE);
468}
469
470extern char sh_sig_msg[64];
471
472volatile int immediate_exit_normal = 0;
473
474#if defined(SA_SIGACTION_WORKS)
475static
476void sh_unix_sigexit (int mysignal, siginfo_t * signal_info, void * signal_add)
477#else
478static
479void sh_unix_sigexit (int mysignal)
480#endif
481{
482
483#if defined(SA_SIGACTION_WORKS)
484 if (signal_info != NULL && signal_info->si_code == SI_USER &&
485 mysignal != SIGTERM && mysignal != SIGINT)
486 {
487 return;
488 }
489
490 /* avoid compiler warning (unused var)
491 */
492 (void) signal_add;
493#endif
494
495 /*
496 * Block re-entry
497 */
498 if (immediate_exit_normal > 0)
499 {
500 ++immediate_exit_normal;
501 if ((skey != NULL) && (immediate_exit_normal == 2))
502 memset (skey, '\0', sizeof(sh_key_t));
503 if (immediate_exit_normal == 2)
504 {
505 chdir ("/");
506 safe_logger (mysignal, 0, NULL);
507 }
508 _exit(mysignal);
509 }
510 else
511 {
512 immediate_exit_normal = 1;
513 }
514
515#ifdef SYS_SIGLIST_DECLARED
516 strncpy (sh_sig_msg, sys_siglist[mysignal], 40);
517#else
518 strncpy (sh_sig_msg, sh_unix_siglist(mysignal), 40);
519#endif
520 sh_sig_msg[63] = '\0';
521
522 ++sig_raised;
523 ++sig_urgent;
524 sig_termfast = 1;
525 return;
526}
527
528volatile int immediate_exit_fast = 0;
529
530#if defined(SA_SIGACTION_WORKS)
531static
532void sh_unix_sigexit_fast (int mysignal, siginfo_t * signal_info,
533 void * signal_add)
534#else
535static
536void sh_unix_sigexit_fast (int mysignal)
537#endif
538{
539#if defined(SA_SIGACTION_WORKS)
540 if (signal_info != NULL && signal_info->si_code == SI_USER)
541 {
542 return;
543 }
544#endif
545
546 /* avoid compiler warning (unused var)
547 */
548#if defined(SA_SIGACTION_WORKS)
549 (void) signal_add;
550#endif
551
552 /* Check whether the heap is ok; otherwise _exit
553 */
554#if !defined(SL_DEBUG)
555 ++immediate_exit_fast;
556 if (skey != NULL && immediate_exit_fast < 2)
557 memset (skey, '\0', sizeof(sh_key_t));
558 if (immediate_exit_fast < 2)
559 safe_logger (mysignal, 0, NULL);
560 _exit(mysignal);
561#else
562
563 /* debug code
564 */
565 if (immediate_exit_fast == 1)
566 {
567 ++immediate_exit_fast;
568 if (skey != NULL)
569 memset (skey, '\0', sizeof(sh_key_t));
570#ifdef WITH_MESSAGE_QUEUE
571 close_ipc ();
572#endif
573 safe_logger (mysignal, 0, NULL);
574 chdir ("/");
575 raise(SIGFPE);
576 }
577 else if (immediate_exit_fast == 2)
578 {
579 chdir ("/");
580 raise(SIGFPE);
581 }
582 else if (immediate_exit_fast != 0)
583 {
584 _exit(mysignal);
585 }
586
587 ++immediate_exit_fast;
588
589 /* The FPE|BUS|SEGV|ILL signals leave the system in an undefined
590 * state, thus it is best to exit immediately.
591 */
592#ifdef SYS_SIGLIST_DECLARED
593 strncpy (sh_sig_msg, sys_siglist[mysignal], 40);
594#else
595 strncpy (sh_sig_msg, sh_unix_siglist(mysignal), 40);
596#endif
597
598 sl_stack_print();
599
600 /* Try to push out an error message.
601 */
602 sh_error_handle ((-1), FIL__, __LINE__, mysignal, MSG_EXIT_NORMAL,
603 sh.prg_name, sh_sig_msg);
604
605 if (skey != NULL)
606 memset (skey, '\0', sizeof(sh_key_t));
607#ifdef WITH_MESSAGE_QUEUE
608 close_ipc ();
609#endif
610
611 chdir ("/");
612 raise(SIGFPE);
613#endif
614}
615
616
617static
618void sh_unix_sigaction (int mysignal)
619{
620 ++sig_raised;
621#ifdef SIGUSR1
622 if (mysignal == SIGUSR1)
623 sig_debug_switch = 1;
624#endif
625#ifdef SIGUSR2
626 if (mysignal == SIGUSR2)
627 {
628 ++sig_suspend_switch;
629 ++sig_urgent;
630 }
631#endif
632#ifdef SIGHUP
633 if (mysignal == SIGHUP)
634 sig_config_read_again = 1;
635#endif
636#ifdef SIGTTOU
637 if (mysignal == SIGTTOU)
638 sig_force_check = 1;
639#endif
640#ifdef SIGABRT
641 if (mysignal == SIGABRT)
642 sig_fresh_trail = 1;
643#endif
644#ifdef SIGQUIT
645 if (mysignal == SIGQUIT)
646 {
647 sig_terminate = 1;
648 ++sig_urgent;
649 }
650#endif
651#ifdef SIGTERM
652 if (mysignal == SIGTERM)
653 {
654 strncpy (sh_sig_msg, _("Terminated"), 40);
655 sig_termfast = 1;
656 ++sig_urgent;
657 }
658#endif
659
660 return;
661}
662
663static
664void sh_unix_siginstall (int goDaemon)
665{
666 struct sigaction act, act_fast, act2, oldact, ignact;
667#if defined (SH_WITH_SERVER)
668 (void) goDaemon;
669#endif
670
671 SL_ENTER(_("sh_unix_siginstall"));
672
673 ignact.sa_handler = SIG_IGN; /* signal action */
674 sigemptyset( &ignact.sa_mask ); /* set an empty mask */
675 ignact.sa_flags = 0; /* init sa_flags */
676
677#if defined(SA_SIGACTION_WORKS)
678 act.sa_sigaction = &sh_unix_sigexit; /* signal action */
679#else
680 act.sa_handler = &sh_unix_sigexit; /* signal action */
681#endif
682
683 sigfillset ( &act.sa_mask ); /* set a full mask */
684
685
686 /* Block all but deadly signals.
687 */
688#ifdef SIGILL
689 sigdelset ( &act.sa_mask, SIGILL );
690#endif
691#ifndef SL_DEBUG
692#ifdef SIGFPE
693 sigdelset ( &act.sa_mask, SIGFPE );
694#endif
695#endif
696#ifdef SIGSEGV
697 sigdelset ( &act.sa_mask, SIGSEGV );
698#endif
699#ifdef SIGBUS
700 sigdelset ( &act.sa_mask, SIGBUS );
701#endif
702
703#if defined(SA_SIGACTION_WORKS)
704 act_fast.sa_sigaction = &sh_unix_sigexit_fast; /* signal action */
705#else
706 act_fast.sa_handler = &sh_unix_sigexit_fast; /* signal action */
707#endif
708
709 sigfillset ( &act_fast.sa_mask ); /* set a full mask */
710
711#ifdef SIGILL
712 sigdelset ( &act_fast.sa_mask, SIGILL );
713#endif
714#ifndef SL_DEBUG
715#ifdef SIGFPE
716 sigdelset ( &act_fast.sa_mask, SIGFPE );
717#endif
718#endif
719#ifdef SIGSEGV
720 sigdelset ( &act_fast.sa_mask, SIGSEGV );
721#endif
722#ifdef SIGBUS
723 sigdelset ( &act_fast.sa_mask, SIGBUS );
724#endif
725
726
727 /* Use siginfo to verify origin of signal, if possible.
728 */
729#if defined(SA_SIGACTION_WORKS)
730 act.sa_flags = SA_SIGINFO;
731 act_fast.sa_flags = SA_SIGINFO;
732#else
733 act.sa_flags = 0;
734 act_fast.sa_flags = 0;
735#endif
736
737 /* Do not block the signal from being received in its handler ...
738 * (is this a good or a bad idea ??).
739 */
740#if defined(SA_NOMASK)
741 act_fast.sa_flags |= SA_NOMASK;
742#elif defined(SA_NODEFER)
743 act_fast.sa_flags |= SA_NODEFER;
744#endif
745
746
747 act2.sa_handler = &sh_unix_sigaction; /* signal action */
748 sigemptyset( &act2.sa_mask ); /* set an empty mask */
749 act2.sa_flags = 0; /* init sa_flags */
750
751 /* signals to control the daemon */
752
753#ifdef SIGHUP
754 retry_sigaction(FIL__, __LINE__, SIGHUP, &act2, &oldact);
755#endif
756#ifdef SIGABRT
757 retry_sigaction(FIL__, __LINE__, SIGABRT, &act2, &oldact);
758#endif
759#ifdef SIGUSR1
760 retry_sigaction(FIL__, __LINE__, SIGUSR1, &act2, &oldact);
761#endif
762#ifdef SIGUSR2
763 retry_sigaction(FIL__, __LINE__, SIGUSR2, &act2, &oldact);
764#endif
765#ifdef SIGQUIT
766 retry_sigaction(FIL__, __LINE__, SIGQUIT, &act2, &oldact);
767#endif
768#ifdef SIGTERM
769 retry_sigaction(FIL__, __LINE__, SIGTERM, &act, &oldact);
770#endif
771
772 /* fatal signals that may cause termination */
773
774#ifdef SIGILL
775 retry_sigaction(FIL__, __LINE__, SIGILL, &act_fast, &oldact);
776#endif
777#ifndef SL_DEBUG
778#ifdef SIGFPE
779 retry_sigaction(FIL__, __LINE__, SIGFPE, &act_fast, &oldact);
780#endif
781#endif
782#ifdef SIGSEGV
783 retry_sigaction(FIL__, __LINE__, SIGSEGV, &act_fast, &oldact);
784#endif
785#ifdef SIGBUS
786 retry_sigaction(FIL__, __LINE__, SIGBUS, &act_fast, &oldact);
787#endif
788
789 /* other signals */
790
791#ifdef SIGINT
792 retry_sigaction(FIL__, __LINE__, SIGINT, &act, &oldact);
793#endif
794#ifdef SIGPIPE
795 retry_sigaction(FIL__, __LINE__, SIGPIPE, &act, &oldact);
796#endif
797#ifdef SIGALRM
798 retry_sigaction(FIL__, __LINE__, SIGALRM, &ignact, &oldact);
799#endif
800#ifdef SIGTSTP
801 retry_sigaction(FIL__, __LINE__, SIGTSTP, &ignact, &oldact);
802#endif
803#ifdef SIGTTIN
804 retry_sigaction(FIL__, __LINE__, SIGTTIN, &ignact, &oldact);
805#endif
806#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
807#ifdef SIGTTOU
808 if (goDaemon == 1)
809 retry_sigaction(FIL__, __LINE__, SIGTTOU, &act2, &oldact);
810 else
811 retry_sigaction(FIL__, __LINE__, SIGTTOU, &ignact, &oldact);
812#endif
813#else
814#ifdef SIGTTOU
815 retry_sigaction(FIL__, __LINE__, SIGTTOU, &ignact, &oldact);
816#endif
817#endif
818
819#ifdef SIGTRAP
820#if !defined(SCREW_IT_UP)
821 retry_sigaction(FIL__, __LINE__, SIGTRAP, &act, &oldact);
822#endif
823#endif
824
825#ifdef SIGPOLL
826 retry_sigaction(FIL__, __LINE__, SIGPOLL, &ignact, &oldact);
827#endif
828#if defined(SIGPROF) && !defined(SH_PROFILE)
829 retry_sigaction(FIL__, __LINE__, SIGPROF, &ignact, &oldact);
830#endif
831#ifdef SIGSYS
832 retry_sigaction(FIL__, __LINE__, SIGSYS, &act, &oldact);
833#endif
834#ifdef SIGURG
835 retry_sigaction(FIL__, __LINE__, SIGURG, &ignact, &oldact);
836#endif
837#if defined(SIGVTALRM) && !defined(SH_PROFILE)
838 retry_sigaction(FIL__, __LINE__, SIGVTALRM, &ignact, &oldact);
839#endif
840#ifdef SIGXCPU
841 retry_sigaction(FIL__, __LINE__, SIGXCPU, &act, &oldact);
842#endif
843#ifdef SIGXFSZ
844 retry_sigaction(FIL__, __LINE__, SIGXFSZ, &act, &oldact);
845#endif
846
847#ifdef SIGEMT
848 retry_sigaction(FIL__, __LINE__, SIGEMT, &ignact, &oldact);
849#endif
850#ifdef SIGSTKFLT
851 retry_sigaction(FIL__, __LINE__, SIGSTKFLT, &act, &oldact);
852#endif
853#ifdef SIGIO
854 retry_sigaction(FIL__, __LINE__, SIGIO, &ignact, &oldact);
855#endif
856#ifdef SIGPWR
857 retry_sigaction(FIL__, __LINE__, SIGPWR, &act, &oldact);
858#endif
859
860#ifdef SIGLOST
861 retry_sigaction(FIL__, __LINE__, SIGLOST, &ignact, &oldact);
862#endif
863#ifdef SIGUNUSED
864 retry_sigaction(FIL__, __LINE__, SIGUNUSED, &ignact, &oldact);
865#endif
866
867 SL_RET0(_("sh_unix_siginstall"));
868}
869
870/* ---------------------------------------------------------------- */
871
872/* checksum the own binary
873 */
874int sh_unix_self_hash (const char * c)
875{
876 char message[512];
877
878 SL_ENTER(_("sh_unix_self_hash"));
879
880 if (c == NULL)
881 {
882 sh.exec.path[0] = '\0';
883 SL_RETURN((0), _("sh_unix_self_hash"));
884 }
885 sl_strlcpy(sh.exec.path, c, SH_PATHBUF);
886
887 sl_strlcpy(sh.exec.hash,
888 sh_tiger_hash (c, TIGER_FILE, 0),
889 KEY_LEN+1);
890 sl_snprintf(message, 512, _("%s has checksum: %s"),
891 sh.exec.path, sh.exec.hash);
892 message[511] = '\0';
893 sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
894 message, _("sh_unix_self_hash"));
895 if (0 == sl_strcmp(sh.exec.hash,
896 _("000000000000000000000000000000000000000000000000")
897 ))
898 {
899 dlog(1, FIL__, __LINE__,
900 _("Could not checksum my own executable because of the\nfollowing error: %s: %s\n\nPossible reasons include:\n Wrong path in configure file option SamhainPath=/path/to/executable\n No read permission for the effective UID: %d\n"),
901 sh.exec.path, sl_get_errmsg(), (int) sl_ret_euid());
902 sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_NOACCESS,
903 (long) sh.real.uid, c);
904 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
905 }
906 SL_RETURN((0), _("sh_unix_self_hash"));
907}
908
909int sh_unix_self_check ()
910{
911 char newhash[KEY_LEN+1];
912 char message[512];
913
914 SL_ENTER(_("sh_unix_self_check"));
915 if (sh.exec.path == NULL || sh.exec.path[0] == '\0')
916 SL_RETURN((0), _("sh_unix_self_check"));
917
918 sl_strlcpy(newhash, sh_tiger_hash (sh.exec.path, TIGER_FILE, 0), KEY_LEN+1);
919 if (0 == sl_strncmp(sh.exec.hash,
920 newhash,
921 KEY_LEN))
922 SL_RETURN((0), _("sh_unix_self_check"));
923
924
925 dlog(1, FIL__, __LINE__,
926 _("The checksum of the executable: %s has changed since startup (%s -> %s).\n"),
927 sh.exec.path, sh.exec.hash, newhash);
928
929 sl_snprintf(message, 512,
930 _("The checksum of %s has changed since startup (%s -> %s)"),
931 sh.exec.path, sh.exec.hash, newhash);
932 message[511] = '\0';
933
934 sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
935 message, _("sh_unix_self_check"));
936 sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_E_AUTH,
937 sh.exec.path);
938 SL_RETURN((-1), _("sh_unix_self_check"));
939}
940
941
942/* ---------------------------------------------------------------- */
943
944
945/* added Tue Feb 22 10:36:44 NFT 2000 Rainer Wichmann */
946static int tf_add_trusted_user_int(const char * c)
947{
948 register struct passwd * w;
949 int count;
950 uid_t pwid = (uid_t)-1;
951
952 SL_ENTER(_("tf_add_trusted_user_int"));
953
954 /* First check for a user name.
955 */
956 if ((w = sh_getpwnam(c)) != NULL && ((pwid = w->pw_uid) > 0))
957 goto succe;
958
959 /* Failed, so check for a numerical value.
960 */
961 pwid = strtol(c, (char **)NULL, 10);
962 if (pwid > 0 && pwid < 65535)
963 goto succe;
964
965 sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
966 _("add trusted user"), c);
967 SL_RETURN((-1), _("tf_add_trusted_user_int"));
968
969 succe:
970 count = sl_trust_add_user(pwid);
971 SL_RETURN((count), _("tf_add_trusted_user_int"));
972}
973
974int tf_add_trusted_user(const char * c)
975{
976 int i;
977 char * q;
978 char * p = sh_util_strdup (c);
979
980 SL_ENTER(_("tf_add_trusted_user"));
981
982 q = strtok(p, ", \t");
983 if (!q)
984 {
985 SH_FREE(p);
986 SL_RETURN((-1), _("tf_add_trusted_user"));
987 }
988 while (q)
989 {
990 i = tf_add_trusted_user_int(q);
991 if (SL_ISERROR(i))
992 {
993 SH_FREE(p);
994 SL_RETURN((i), _("tf_add_trusted_user"));
995 }
996 q = strtok(NULL, ", \t");
997 }
998 SH_FREE(p);
999 SL_RETURN((0), _("tf_add_trusted_user"));
1000}
1001
1002extern uid_t sl_trust_baduid();
1003extern gid_t sl_trust_badgid();
1004
1005#if defined(HOST_IS_CYGWIN) || defined(__cygwin__) || defined(__CYGWIN32__) || defined(__CYGWIN__)
1006int tf_trust_check (char * file, int mode)
1007{
1008 (void) file;
1009 (void) mode;
1010 return 0;
1011}
1012#else
1013int tf_trust_check (char * file, int mode)
1014{
1015 char * tmp;
1016 char * tmp2;
1017 char * p;
1018 int status;
1019 int level;
1020 uid_t ff_euid;
1021
1022 SL_ENTER(_("tf_trust_check"));
1023
1024 if (mode == SL_YESPRIV)
1025 sl_get_euid(&ff_euid);
1026 else
1027 sl_get_ruid(&ff_euid);
1028
1029#if defined(SH_WITH_SERVER)
1030 if (0 == sl_ret_euid()) /* privileges not dropped yet */
1031 {
1032 struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT);
1033
1034 if (!tempres)
1035 {
1036 dlog(1, FIL__, __LINE__,
1037 _("User %s does not exist. Please add the user to your system.\n"),
1038 DEFAULT_IDENT);
1039 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
1040 }
1041 ff_euid = tempres->pw_uid;
1042 }
1043#endif
1044
1045 status = sl_trustfile_euid(file, ff_euid);
1046
1047 if ( SL_ENONE != status)
1048 {
1049 if (status == SL_ESTAT)
1050 level = SH_ERR_ALL;
1051 else
1052 level = SH_ERR_ERR;
1053
1054 tmp = sh_util_safe_name (file);
1055 p = sl_trust_errfile();
1056 if (p && *p != '\0')
1057 {
1058 tmp2 = sh_util_safe_name (sl_trust_errfile());
1059 sh_error_handle(level, FIL__, __LINE__, status, MSG_E_TRUST2,
1060 sl_error_string(status), tmp, tmp2);
1061 SH_FREE(tmp2);
1062 }
1063 else
1064 {
1065 sh_error_handle(level, FIL__, __LINE__, status, MSG_E_TRUST1,
1066 sl_error_string(status), tmp);
1067 }
1068 SH_FREE(tmp);
1069
1070 if (status == SL_EBADUID || status == SL_EBADGID ||
1071 status == SL_EBADOTH || status == SL_ETRUNC ||
1072 status == SL_EINTERNAL )
1073 {
1074 switch (status) {
1075 case SL_EINTERNAL:
1076 dlog(1, FIL__, __LINE__,
1077 _("An internal error occured in the trustfile function.\n"));
1078 break;
1079 case SL_ETRUNC:
1080 tmp = sh_util_safe_name (file);
1081 dlog(1, FIL__, __LINE__,
1082 _("A filename truncation occured in the trustfile function.\nProbably the normalized filename for %s\nis too long. This may be due e.g. to deep or circular softlinks.\n"),
1083 tmp);
1084 SH_FREE(tmp);
1085 break;
1086 case SL_EBADOTH:
1087 tmp = sh_util_safe_name (file);
1088 p = sl_trust_errfile();
1089 dlog(1, FIL__, __LINE__,
1090 _("The path element: %s\nin the filename: %s is world writeable.\n"),
1091 p, tmp);
1092 SH_FREE(tmp);
1093 break;
1094 case SL_EBADUID:
1095 tmp = sh_util_safe_name (file);
1096 p = sl_trust_errfile();
1097 dlog(1, FIL__, __LINE__,
1098 _("The owner (UID = %ld) of the path element: %s\nin the filename: %s\nis not in the list of trusted users.\nTo fix the problem, you can:\n - run ./configure again with the option --with-trusted=0,...,UID\n where UID is the UID of the untrusted user, or\n - use the option TrustedUser=UID in the configuration file.\n"),
1099 (UID_CAST)sl_trust_baduid(), p, tmp);
1100 SH_FREE(tmp);
1101 break;
1102 case SL_EBADGID:
1103 tmp = sh_util_safe_name (file);
1104 p = sl_trust_errfile();
1105 dlog(1, FIL__, __LINE__,
1106 _("The path element: %s\nin the filename: %s\nis group writeable (GID = %ld), and at least one of the group\nmembers (UID = %ld) is not in the list of trusted users.\nTo fix the problem, you can:\n - run ./configure again with the option --with-trusted=0,...,UID\n where UID is the UID of the untrusted user, or\n - use the option TrustedUser=UID in the configuration file.\n"),
1107 p, tmp, (UID_CAST)sl_trust_badgid(),
1108 (UID_CAST)sl_trust_baduid());
1109 SH_FREE(tmp);
1110 break;
1111 default:
1112 break;
1113 }
1114
1115 SL_RETURN((-1), _("tf_trust_check"));
1116 }
1117 }
1118
1119 SL_RETURN((0), _("tf_trust_check"));
1120}
1121#endif
1122
1123#ifdef HAVE_INITGROUPS
1124#ifdef HOST_IS_OSF
1125int sh_unix_initgroups ( char * in_user, gid_t in_gid)
1126#else
1127int sh_unix_initgroups (const char * in_user, gid_t in_gid)
1128#endif
1129{
1130 int status = -1;
1131 status = sh_initgroups (in_user, in_gid);
1132 if (status < 0)
1133 {
1134 if (errno == EPERM)
1135 return 0;
1136 if (errno == EINVAL)
1137 return 0;
1138 return -1;
1139 }
1140 return 0;
1141}
1142#else
1143int sh_unix_initgroups (const char * in_user, gid_t in_gid)
1144{
1145 (void) in_user;
1146 (void) in_gid;
1147 return 0;
1148}
1149#endif
1150
1151#ifdef HAVE_INITGROUPS
1152char * sh_unix_getUIDname (int level, uid_t uid);
1153int sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
1154{
1155 int status = -1;
1156 char * user = NULL;
1157
1158 SL_ENTER(_("sh_unix_initgroups2"));
1159
1160 user = sh_unix_getUIDname (SH_ERR_ERR, in_pid);
1161 if (user == NULL)
1162 SL_RETURN((-1), _("sh_unix_initgroups2"));
1163 status = sh_initgroups (user, in_gid);
1164 if (status < 0)
1165 {
1166 if (errno == EPERM)
1167 status = 0;
1168 if (errno == EINVAL)
1169 status = 0;
1170 }
1171 SL_RETURN((status), _("sh_unix_initgroups2"));
1172}
1173#else
1174int sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
1175{
1176 (void) in_pid;
1177 (void) in_gid;
1178 return 0;
1179}
1180#endif
1181
1182void sh_unix_closeall (int fd, int except)
1183{
1184 int fdx = fd;
1185#ifdef _SC_OPEN_MAX
1186 int fdlimit = sysconf (_SC_OPEN_MAX);
1187#else
1188#ifdef OPEN_MAX
1189 int fdlimit = OPEN_MAX;
1190#else
1191 int fdlimit = _POSIX_OPEN_MAX;
1192#endif
1193#endif
1194
1195 SL_ENTER(_("sh_unix_closeall"));
1196
1197 /* can't happen - so fix it :-(
1198 */
1199 if (fdlimit < 0)
1200 fdlimit = 20; /* POSIX lower limit */
1201
1202 if (fdlimit > 65536)
1203 fdlimit = 65536;
1204
1205 /* Close everything from fd (inclusive) up to fdlimit (exclusive).
1206 */
1207 while (fd < fdlimit)
1208 {
1209 if (fd == except)
1210 fd++;
1211 else if (slib_do_trace != 0 && fd == slib_trace_fd)
1212 fd++;
1213 else
1214 close(fd++);
1215 }
1216
1217 sl_dropall (fdx, except);
1218
1219 SL_RET0(_("sh_unix_closeall"));
1220}
1221
1222static void sh_unix_setlimits(void)
1223{
1224 struct rlimit limits;
1225
1226 SL_ENTER(_("sh_unix_setlimits"));
1227
1228 limits.rlim_cur = RLIM_INFINITY;
1229 limits.rlim_max = RLIM_INFINITY;
1230
1231#ifdef RLIMIT_CPU
1232 setrlimit (RLIMIT_CPU, &limits);
1233#endif
1234#ifdef RLIMIT_FSIZE
1235 setrlimit (RLIMIT_FSIZE, &limits);
1236#endif
1237#ifdef RLIMIT_DATA
1238 setrlimit (RLIMIT_DATA, &limits);
1239#endif
1240#ifdef RLIMIT_STACK
1241 setrlimit (RLIMIT_STACK, &limits);
1242#endif
1243#ifdef RLIMIT_RSS
1244 setrlimit (RLIMIT_RSS, &limits);
1245#endif
1246#ifdef RLIMIT_NPROC
1247 setrlimit (RLIMIT_NPROC, &limits);
1248#endif
1249#ifdef RLIMIT_MEMLOCK
1250 setrlimit (RLIMIT_MEMLOCK, &limits);
1251#endif
1252
1253#if !defined(SL_DEBUG)
1254 /* no core dumps
1255 */
1256 limits.rlim_cur = 0;
1257 limits.rlim_max = 0;
1258#ifdef RLIMIT_CORE
1259 setrlimit (RLIMIT_CORE, &limits);
1260#endif
1261#else
1262#ifdef RLIMIT_CORE
1263 setrlimit (RLIMIT_CORE, &limits);
1264#endif
1265#endif
1266
1267 limits.rlim_cur = 1024;
1268 limits.rlim_max = 1024;
1269
1270#if defined(RLIMIT_NOFILE)
1271 setrlimit (RLIMIT_NOFILE, &limits);
1272#elif defined(RLIMIT_OFILE)
1273 setrlimit (RLIMIT_OFILE, &limits);
1274#endif
1275
1276 SL_RET0(_("sh_unix_setlimits"));
1277}
1278
1279static void sh_unix_copyenv(void)
1280{
1281 char ** env0 = environ;
1282 char ** env1;
1283 int envlen = 0;
1284 size_t len;
1285
1286 SL_ENTER(_("sh_unix_copyenv"));
1287
1288 while (env0 != NULL && env0[envlen] != NULL) {
1289 /* printf("%2d: %s\n", envlen, env0[envlen]); */
1290 ++envlen;
1291 }
1292 ++envlen;
1293
1294 /* printf("-> %2d: slots allocated\n", envlen); */
1295 env1 = malloc (sizeof(char *) * envlen); /* only once */
1296 if (env1 == NULL)
1297 {
1298 fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
1299 SL_RET0(_("sh_unix_copyenv"));
1300 }
1301 env0 = environ;
1302 envlen = 0;
1303
1304 while (env0 != NULL && env0[envlen] != NULL) {
1305 len = strlen(env0[envlen]) + 1;
1306 env1[envlen] = malloc (len); /* only once */
1307 if (env1[envlen] == NULL)
1308 {
1309 fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
1310 SL_RET0(_("sh_unix_copyenv"));
1311 }
1312 sl_strlcpy(env1[envlen], env0[envlen], len);
1313 ++envlen;
1314 }
1315 env1[envlen] = NULL;
1316
1317 environ = env1;
1318 SL_RET0(_("sh_unix_copyenv"));
1319}
1320
1321/* delete all environment variables
1322 */
1323static void sh_unix_zeroenv(void)
1324{
1325 char * c;
1326 char ** env;
1327
1328 SL_ENTER(_("sh_unix_zeroenv"));
1329
1330 sh_unix_copyenv();
1331 env = environ;
1332
1333 while (env != NULL && *env != NULL) {
1334 c = strchr ((*env), '=');
1335#ifdef WITH_MYSQL
1336 /*
1337 * Skip the MYSQL_UNIX_PORT environment variable; MySQL may need it.
1338 */
1339 if (0 == sl_strncmp((*env), _("MYSQL_UNIX_PORT="), 16))
1340 {
1341 ++(env);
1342 continue;
1343 }
1344 if (0 == sl_strncmp((*env), _("MYSQL_TCP_PORT="), 15))
1345 {
1346 ++(env);
1347 continue;
1348 }
1349 if (0 == sl_strncmp((*env), _("MYSQL_HOME="), 11))
1350 {
1351 ++(env);
1352 continue;
1353 }
1354#endif
1355#ifdef WITH_ORACLE
1356 /*
1357 * Skip the ORACLE_HOME environment variable; Oracle may need it.
1358 */
1359 if (0 == sl_strncmp((*env), _("ORACLE_HOME="), 12))
1360 {
1361 ++(env);
1362 continue;
1363 }
1364#endif
1365 /*
1366 * Skip the TZ environment variable.
1367 */
1368 if (0 == sl_strncmp((*env), _("TZ="), 3))
1369 {
1370 ++(env);
1371 continue;
1372 }
1373 ++(env);
1374 if (c != NULL)
1375 {
1376 ++c;
1377 while ((*c) != '\0') {
1378 (*c) = '\0';
1379 ++c;
1380 }
1381 }
1382 }
1383
1384 SL_RET0(_("sh_unix_zeroenv"));
1385}
1386
1387
1388static void sh_unix_resettimer(void)
1389{
1390 struct itimerval this_timer;
1391
1392 SL_ENTER(_("sh_unix_resettimer"));
1393
1394 this_timer.it_value.tv_sec = 0;
1395 this_timer.it_value.tv_usec = 0;
1396
1397 this_timer.it_interval.tv_sec = 0;
1398 this_timer.it_interval.tv_usec = 0;
1399
1400 setitimer(ITIMER_REAL, &this_timer, NULL);
1401#if !defined(SH_PROFILE)
1402 setitimer(ITIMER_VIRTUAL, &this_timer, NULL);
1403 setitimer(ITIMER_PROF, &this_timer, NULL);
1404#endif
1405
1406 SL_RET0(_("sh_unix_resettimer"));
1407}
1408
1409static void sh_unix_resetsignals(void)
1410{
1411 int sig_num;
1412#ifdef NSIG
1413 int max_sig = NSIG;
1414#else
1415 int max_sig = 255;
1416#endif
1417 int test;
1418 struct sigaction act, oldact;
1419 int status;
1420
1421 sigset_t set_proc;
1422
1423 SL_ENTER(_("sh_unix_resetsignals"));
1424 /*
1425 * Reset the current signal mask (inherited from parent process).
1426 */
1427
1428 sigfillset(&set_proc);
1429
1430 do {
1431 errno = 0;
1432 test = sigprocmask(SIG_UNBLOCK, &set_proc, NULL);
1433 } while (test < 0 && errno == EINTR);
1434
1435 /*
1436 * Reset signal handling.
1437 */
1438
1439 act.sa_handler = SIG_DFL; /* signal action */
1440 sigemptyset( &act.sa_mask ); /* set an empty mask */
1441 act.sa_flags = 0; /* init sa_flags */
1442
1443 for (sig_num = 1; sig_num <= max_sig; ++sig_num)
1444 {
1445#if !defined(SH_PROFILE)
1446 test = retry_sigaction(FIL__, __LINE__, sig_num, &act, &oldact);
1447#else
1448 test = 0;
1449#endif
1450 if ((test == -1) && (errno != EINVAL))
1451 {
1452 status = errno;
1453 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_SIG,
1454 sh_error_message (status), sig_num);
1455 }
1456 }
1457
1458 SL_RET0(_("sh_unix_resetsignals"));
1459}
1460
1461/* Get the local hostname (FQDN)
1462 */
1463#include <sys/socket.h>
1464
1465/* Required for BSD
1466 */
1467#ifdef HAVE_NETINET_IN_H
1468#include <netinet/in.h>
1469#endif
1470
1471#include <arpa/inet.h>
1472
1473char * sh_unix_h_name (struct hostent * host_entry)
1474{
1475 char ** p;
1476 if (strchr(host_entry->h_name, '.')) {
1477 return host_entry->h_name;
1478 } else {
1479 for (p = host_entry->h_aliases; *p; ++p) {
1480 if (strchr(*p, '.'))
1481 return *p;
1482 }
1483 }
1484 return host_entry->h_name;
1485}
1486
1487/* uname() on FreeBSD is broken, because the 'nodename' buf is too small
1488 * to hold a valid (leftmost) domain label.
1489 */
1490#if defined(HAVE_UNAME) && !defined(HOST_IS_FREEBSD)
1491#include <sys/utsname.h>
1492void sh_unix_localhost()
1493{
1494 struct utsname buf;
1495 struct hostent * he1;
1496 int i;
1497 int ddot = 0;
1498 int len;
1499 char * p;
1500 char hostname[256];
1501
1502
1503 SL_ENTER(_("sh_unix_localhost"));
1504
1505 (void) uname (&buf);
1506 /* flawfinder: ignore */ /* ff bug, ff sees system() */
1507 sl_strlcpy (sh.host.system, buf.sysname, SH_MINIBUF);
1508 sl_strlcpy (sh.host.release, buf.release, SH_MINIBUF);
1509 sl_strlcpy (sh.host.machine, buf.machine, SH_MINIBUF);
1510
1511 /* Workaround for cases where nodename could be
1512 * a truncated FQDN.
1513 */
1514 if (strlen(buf.nodename) == (sizeof(buf.nodename)-1))
1515 {
1516 p = strchr(buf.nodename, '.');
1517 if (NULL != p) {
1518 *p = '\0';
1519 sl_strlcpy(hostname, buf.nodename, 256);
1520 } else {
1521#ifdef HAVE_GETHOSTNAME
1522 if (0 != gethostname(hostname, 256))
1523 {
1524 sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
1525 _("nodename returned by uname may be truncated"),
1526 _("sh_unix_localhost"));
1527 sl_strlcpy (hostname, buf.nodename, 256);
1528 }
1529 else
1530 {
1531 hostname[255] = '\0';
1532 }
1533#else
1534 sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
1535 _("nodename returned by uname may be truncated"),
1536 _("sh_unix_localhost"));
1537 sl_strlcpy(hostname, buf.nodename, 256);
1538#endif
1539 }
1540 }
1541 else
1542 {
1543 sl_strlcpy(hostname, buf.nodename, 256);
1544 }
1545
1546 he1 = sh_gethostbyname(hostname);
1547
1548 if (he1 == NULL)
1549 {
1550 dlog(1, FIL__, __LINE__,
1551 _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN. For more information, see the entry about self-resolving under 'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1552 hostname);
1553 sl_strlcpy (sh.host.name, hostname, SH_PATHBUF);
1554 }
1555 else
1556 {
1557 sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
1558 }
1559
1560
1561 /* check whether it looks like a FQDN
1562 */
1563 len = sl_strlen(sh.host.name);
1564 for (i = 0; i < len; ++i)
1565 if (sh.host.name[i] == '.') ++ddot;
1566
1567 if (ddot == 0 && he1 != NULL)
1568 {
1569 dlog(1, FIL__, __LINE__,
1570 _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1571 hostname, sh.host.name);
1572 sl_strlcpy (sh.host.name,
1573 inet_ntoa (*(struct in_addr *) he1->h_addr),
1574 SH_PATHBUF);
1575 SL_RET0(_("sh_unix_localhost"));
1576 }
1577
1578 if (is_numeric(sh.host.name))
1579 {
1580 dlog(1, FIL__, __LINE__,
1581 _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1582 hostname, sh.host.name);
1583 }
1584
1585 SL_RET0(_("sh_unix_localhost"));
1586}
1587#else
1588void sh_unix_localhost()
1589{
1590 struct hostent * he1;
1591 int i;
1592 int ddot = 0;
1593 int len;
1594 char hostname[1024];
1595
1596
1597 SL_ENTER(_("sh_unix_localhost"));
1598
1599 (void) gethostname (hostname, 1024);
1600 hostname[1023] = '\0';
1601 he1 = sh_gethostbyname(hostname);
1602
1603 if (he1 != NULL)
1604 {
1605 sl_strlcpy (sh.host.name, sh_unix_h_name(he1), SH_PATHBUF);
1606 }
1607 else
1608 {
1609 dlog(1, FIL__, __LINE__,
1610 _("According to gethostname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1611 hostname);
1612 sl_strlcpy (sh.host.name, _("localhost"), SH_PATHBUF);
1613 SL_RET0(_("sh_unix_localhost"));
1614 }
1615
1616 /* check whether it looks like a FQDN
1617 */
1618 len = sl_strlen(sh.host.name);
1619 for (i = 0; i < len; ++i)
1620 if (sh.host.name[i] == '.') ++ddot;
1621 if (ddot == 0)
1622 {
1623 dlog(1, FIL__, __LINE__,
1624 _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1625 hostname, sh.host.name);
1626 sl_strlcpy (sh.host.name,
1627 inet_ntoa (*(struct in_addr *) he1->h_addr),
1628 SH_PATHBUF);
1629 SL_RET0(_("sh_unix_localhost"));
1630 }
1631
1632 if (is_numeric(sh.host.name))
1633 {
1634 dlog(1, FIL__, __LINE__,
1635 _("According to uname, your nodename is %s, but your resolver\nlibrary cannot resolve this nodename to a FQDN.\nRather, it resolves this to %s.\nFor more information, see the entry about self-resolving under\n'Most frequently' in the FAQ that you will find in the docs/ subdirectory.\n"),
1636 hostname, sh.host.name);
1637 }
1638
1639 SL_RET0(_("sh_unix_localhost"));
1640}
1641#endif
1642
1643
1644void sh_unix_memlock()
1645{
1646 SL_ENTER(_("sh_unix_memlock"));
1647
1648 /* do this before dropping privileges
1649 */
1650#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
1651 if (skey->mlock_failed == SL_FALSE)
1652 {
1653 if ( (-1) == sh_unix_mlock( FIL__, __LINE__,
1654 (char *) skey, sizeof (sh_key_t)) )
1655 {
1656 skey->mlock_failed = SL_TRUE;
1657 }
1658 }
1659#else
1660 if (skey->mlock_failed == SL_FALSE)
1661 {
1662 skey->mlock_failed = SL_TRUE;
1663 }
1664#endif
1665
1666 SL_RET0(_("sh_unix_memlock"));
1667}
1668
1669#ifdef SH_WITH_SERVER
1670char * chroot_dir = NULL;
1671
1672int sh_unix_set_chroot(const char * str)
1673{
1674 size_t len;
1675 static int block = 0;
1676
1677 if (block == 1)
1678 return 0;
1679
1680 if (str && *str == '/')
1681 {
1682 len = strlen(str) + 1;
1683 chroot_dir = malloc(strlen(str) + 1); /* only once */
1684 if (!chroot_dir)
1685 {
1686 fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
1687 return 1;
1688 }
1689 sl_strlcpy(chroot_dir, str, len);
1690 block = 1;
1691 return 0;
1692 }
1693 return 1;
1694}
1695
1696int sh_unix_chroot()
1697{
1698 int status;
1699
1700 if (chroot_dir != NULL)
1701 {
1702 status = retry_aud_chdir(FIL__, __LINE__, chroot_dir);
1703 if ( (-1) == status )
1704 {
1705 status = errno;
1706 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
1707 sh_error_message (status), chroot_dir);
1708 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1709 }
1710 /* flawfinder: ignore */
1711 return (chroot(chroot_dir));
1712 }
1713 return 0;
1714}
1715/* #ifdef SH_WITH_SERVER */
1716#else
1717int sh_unix_chroot() { return 0; }
1718#endif
1719
1720/* daemon mode
1721 */
1722static int block_setdeamon = 0;
1723
1724int sh_unix_setdeamon(const char * dummy)
1725{
1726 int res = 0;
1727
1728 SL_ENTER(_("sh_unix_setdeamon"));
1729
1730 if (block_setdeamon != 0)
1731 SL_RETURN((0),_("sh_unix_setdeamon"));
1732
1733 if (dummy == NULL)
1734 sh.flag.isdaemon = ON;
1735 else
1736 res = sh_util_flagval (dummy, &sh.flag.isdaemon);
1737
1738 if (sh.flag.opts == S_TRUE)
1739 block_setdeamon = 1;
1740
1741 SL_RETURN(res, _("sh_unix_setdeamon"));
1742}
1743#if defined(HAVE_LIBPRELUDE)
1744#include "sh_prelude.h"
1745#endif
1746
1747int sh_unix_setnodeamon(const char * dummy)
1748{
1749 int res = 0;
1750
1751 SL_ENTER(_("sh_unix_setnodeamon"));
1752
1753 if (block_setdeamon != 0)
1754 SL_RETURN((0),_("sh_unix_setmodeamon"));
1755
1756 if (dummy == NULL)
1757 sh.flag.isdaemon = OFF;
1758 else
1759 res = sh_util_flagval (dummy, &sh.flag.isdaemon);
1760
1761 if (sh.flag.opts == S_TRUE)
1762 block_setdeamon = 1;
1763
1764 SL_RETURN(res, _("sh_unix_setnodeamon"));
1765}
1766
1767int sh_unix_init(int goDaemon)
1768{
1769 int status;
1770 uid_t uid;
1771 pid_t oldpid = getpid();
1772#if defined(SH_WITH_SERVER)
1773 extern int sh_socket_open_int ();
1774#endif
1775
1776 SL_ENTER(_("sh_unix_init"));
1777
1778 /* fork twice, exit the parent process
1779 */
1780 if (goDaemon == 1) {
1781
1782 switch (aud_fork(FIL__, __LINE__)) {
1783 case 0: break; /* child process continues */
1784 case -1: SL_RETURN((-1),_("sh_unix_init")); /* error */
1785 default: aud__exit(FIL__, __LINE__, 0); /* parent process exits */
1786 }
1787
1788 /* Child processes do not inherit page locks across a fork.
1789 * Error in next fork would return in this (?) thread of execution.
1790 */
1791 sh_unix_memlock();
1792
1793 setsid(); /* should not fail */
1794
1795 switch (aud_fork(FIL__, __LINE__)) {
1796 case 0: break; /* child process continues */
1797 case -1: SL_RETURN((-1),_("sh_unix_init")); /* error */
1798 default: aud__exit(FIL__, __LINE__, 0); /* parent process exits */
1799 }
1800
1801 /* Child processes do not inherit page locks across a fork.
1802 */
1803 sh_unix_memlock();
1804
1805 } else {
1806 setsid(); /* should not fail */
1807 }
1808
1809 /* set working directory
1810 */
1811#ifdef SH_PROFILE
1812 status = 0;
1813#else
1814 status = retry_aud_chdir(FIL__, __LINE__, "/");
1815#endif
1816 if ( (-1) == status )
1817 {
1818 status = errno;
1819 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
1820 sh_error_message (status), "/");
1821 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1822 }
1823
1824 /* reset timers
1825 */
1826 sh_unix_resettimer();
1827
1828 /* signal handlers
1829 */
1830 sh_unix_resetsignals();
1831#if defined(SCREW_IT_UP)
1832 sh_sigtrap_prepare();
1833#endif
1834 sh_unix_siginstall (goDaemon);
1835
1836 /* set file creation mask
1837 */
1838 (void) umask (0); /* should not fail */
1839
1840 /* set resource limits to maximum, and
1841 * core dump size to zero
1842 */
1843 sh_unix_setlimits();
1844
1845 /* zero out the environment (like PATH='\0')
1846 */
1847 sh_unix_zeroenv();
1848
1849 if (goDaemon == 1)
1850 {
1851 /* close all file descriptors
1852 */
1853 sh_unix_closeall (0, -1); /* if running as daemon */
1854
1855 /* Enable full error logging
1856 */
1857 sh_error_only_stderr (S_FALSE);
1858
1859 /* open first three streams to /dev/null
1860 */
1861 status = aud_open(FIL__, __LINE__, SL_NOPRIV, _("/dev/null"), O_RDWR, 0);
1862 if (status < 0)
1863 {
1864 status = errno;
1865 sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
1866 sh_error_message(status), _("open"));
1867 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1868 }
1869
1870 status = retry_aud_dup(FIL__, __LINE__, 0);
1871 if (status >= 0)
1872 retry_aud_dup(FIL__, __LINE__, 0);
1873
1874 if (status < 0)
1875 {
1876 status = errno;
1877 sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
1878 sh_error_message(status), _("dup"));
1879 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1880 }
1881
1882#if defined(HAVE_LIBPRELUDE)
1883 sh_prelude_reset ();
1884#endif
1885
1886 /* --- wait until parent has exited ---
1887 */
1888 while (1 == 1)
1889 {
1890 errno = 0;
1891 if (0 > aud_kill (FIL__, __LINE__, oldpid, 0) && errno == ESRCH)
1892 {
1893 break;
1894 }
1895 retry_msleep(0, 1);
1896 }
1897
1898 /* write PID file
1899 */
1900 status = sh_unix_write_pid_file();
1901 if (status < 0)
1902 {
1903 sl_get_euid(&uid);
1904 sh_error_handle ((-1), FIL__, __LINE__, status, MSG_PIDFILE,
1905 (long) uid, sh.srvlog.alt);
1906 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1907 }
1908#if defined(SH_WITH_SERVER)
1909 sh_socket_open_int ();
1910#endif
1911 }
1912 else
1913 {
1914 sh_unix_closeall(3, -1); /* if not daemon */
1915#if defined(HAVE_LIBPRELUDE)
1916 sh_prelude_reset ();
1917#endif
1918#if defined(SH_WITH_SERVER)
1919 sh_socket_open_int ();
1920#endif
1921 }
1922
1923 /* chroot (this is a no-op if no chroot dir is specified
1924 */
1925 status = sh_unix_chroot();
1926 if (status < 0)
1927 {
1928 status = errno;
1929 sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
1930 sh_error_message(status), _("chroot"));
1931 aud_exit(FIL__, __LINE__, EXIT_FAILURE);
1932 }
1933
1934 /* drop capabilities
1935 */
1936 sl_drop_cap();
1937
1938 SL_RETURN((0),_("sh_unix_init"));
1939}
1940
1941/********************************************************
1942 *
1943 * TIME
1944 *
1945 ********************************************************/
1946
1947/* Figure out the time offset of the current timezone
1948 * in a portable way.
1949 */
1950char * t_zone(const time_t * xx)
1951{
1952 struct tm aa;
1953 struct tm bb;
1954 struct tm * cc;
1955 int sign = 0;
1956 int diff = 0;
1957 int hh, mm;
1958 static char tz[64];
1959
1960 SL_ENTER(_("t_zone"));
1961
1962
1963 cc = gmtime (xx);
1964 memcpy (&aa, cc, sizeof(struct tm));
1965 cc = localtime (xx);
1966 memcpy (&bb, cc, sizeof(struct tm));
1967
1968 /* Check for datum wrap-around.
1969 */
1970 if (aa.tm_year < bb.tm_year)
1971 sign = (-1);
1972 else if (aa.tm_mon < bb.tm_mon)
1973 sign = (-1);
1974 else if (aa.tm_mday < bb.tm_mday)
1975 sign = (-1);
1976 else if (bb.tm_year < aa.tm_year)
1977 sign = ( 1);
1978 else if (bb.tm_mon < aa.tm_mon)
1979 sign = ( 1);
1980 else if (bb.tm_mday < aa.tm_mday)
1981 sign = ( 1);
1982
1983 diff = aa.tm_hour * 60 + aa.tm_min;
1984 diff = (bb.tm_hour * 60 + bb.tm_min) - diff;
1985 diff = diff - (sign * 24 * 60); /* datum wrap-around correction */
1986 hh = diff / 60;
1987 mm = diff - (hh * 60);
1988 sprintf (tz, _("%+03d%02d"), hh, mm); /* known to fit */
1989
1990 SL_RETURN(tz, _("t_zone"));
1991}
1992
1993unsigned long sh_unix_longtime ()
1994{
1995 return ((unsigned long)time(NULL));
1996}
1997
1998#ifdef HAVE_GETTIMEOFDAY
1999unsigned long sh_unix_notime ()
2000{
2001 struct timeval tv;
2002
2003 gettimeofday (&tv, NULL);
2004
2005 return ((unsigned long)(tv.tv_sec + tv.tv_usec * 10835 + getpid() + getppid()));
2006
2007}
2008#endif
2009
2010static int count_dev_time = 0;
2011
2012void reset_count_dev_time(void)
2013{
2014 count_dev_time = 0;
2015 return;
2016}
2017
2018int sh_unix_settimeserver (const char * address)
2019{
2020
2021 SL_ENTER(_("sh_unix_settimeserver"));
2022
2023 if (address != NULL && count_dev_time < 2
2024 && sl_strlen(address) < SH_PATHBUF)
2025 {
2026 if (count_dev_time == 0)
2027 sl_strlcpy (sh.srvtime.name, address, SH_PATHBUF);
2028 else
2029 sl_strlcpy (sh.srvtime.alt, address, SH_PATHBUF);
2030
2031 ++count_dev_time;
2032 SL_RETURN((0), _("sh_unix_settimeserver"));
2033 }
2034 SL_RETURN((-1), _("sh_unix_settimeserver"));
2035}
2036
2037
2038#ifdef HAVE_NTIME
2039#define UNIXEPOCH 2208988800UL /* difference between Unix time and net time
2040 * The UNIX EPOCH starts in 1970.
2041 */
2042#include <sys/socket.h>
2043#include <netinet/in.h>
2044#include <arpa/inet.h>
2045#include <netdb.h>
2046#include <ctype.h>
2047#endif
2048
2049/* Timeserver service. */
2050/* define is missing on HP-UX 10.20 */
2051#ifndef IPPORT_TIMESERVER
2052#define IPPORT_TIMESERVER 37
2053#endif
2054
2055char * sh_unix_time (time_t thetime)
2056{
2057
2058 int status;
2059
2060 time_t time_now;
2061 struct tm * time_ptr;
2062 static char AsciiTime[81]; /* local time */
2063 static char RetTime[81]; /* local time */
2064#ifdef SH_USE_XML
2065 static char deftime[] = N_("0000-00-00T00:00:00"); /* default time */
2066#else
2067 static char deftime[] = N_("[0000-00-00T00:00:00]"); /* default time */
2068#endif
2069
2070#ifdef HAVE_NTIME
2071 int fd; /* network file descriptor */
2072 u_char net_time[4]; /* remote time in network format */
2073 static int failerr = 0; /* no net time */
2074 int fail = 0; /* no net time */
2075 int errflag;
2076 char errmsg[256];
2077 char error_call[SH_MINIBUF];
2078 int error_num;
2079#endif
2080
2081 SL_ENTER(_("sh_unix_time"));
2082
2083#ifdef HAVE_NTIME
2084 if (thetime == 0)
2085 {
2086 if (sh.srvtime.name[0] == '\0')
2087 {
2088 fail = 1;
2089 (void) time (&time_now);
2090 }
2091 else /* have a timeserver address */
2092 {
2093 fd = connect_port_2 (sh.srvtime.name, sh.srvtime.alt,
2094 IPPORT_TIMESERVER,
2095 error_call, &error_num, errmsg, sizeof(errmsg));
2096 if (fd >= 0)
2097 {
2098 if (4 != read_port (fd, (char *) net_time, 4, &errflag, 2))
2099 {
2100 fail = 1;
2101 sh_error_handle ((-1), FIL__, __LINE__, errflag,
2102 MSG_E_NLOST,
2103 _("time"), sh.srvtime.name);
2104 }
2105 close(fd);
2106 }
2107 else
2108 {
2109 sh_error_handle ((-1), FIL__, __LINE__, error_num,
2110 MSG_E_NET, errmsg, error_call,
2111 _("time"), sh.srvtime.name);
2112 fail = 1;
2113 }
2114
2115 if (fail == 0)
2116 {
2117 time_now = ntohl(* (long *) net_time) - UNIXEPOCH;
2118 /* fprintf(stderr, "TIME IS %ld\n", time_now); */
2119 if (failerr == 1) {
2120 failerr = 0;
2121 sh_error_handle ((-1), FIL__, __LINE__, 0,
2122 MSG_E_NEST,
2123 _("time"), sh.srvtime.name);
2124 }
2125 }
2126 else
2127 {
2128 (void) time (&time_now);
2129 if (failerr == 0)
2130 {
2131 failerr = 1;
2132 sh_error_handle ((-1), FIL__, __LINE__, errflag,
2133 MSG_SRV_FAIL,
2134 _("time"), sh.srvtime.name);
2135 }
2136 }
2137 }
2138 }
2139 else
2140 {
2141 time_now = thetime;
2142 }
2143
2144 /* #ifdef HAVE_NTIME */
2145#else
2146
2147 if (thetime == 0)
2148 {
2149 (void) time (&time_now);
2150 }
2151 else
2152 {
2153 time_now = thetime;
2154 }
2155
2156 /* #ifdef HAVE_NTIME */
2157#endif
2158
2159 if (time_now == (-1) )
2160 SL_RETURN( _(deftime), _("sh_unix_time"));
2161 else
2162 time_ptr = localtime (&time_now);
2163
2164 if (time_ptr != NULL)
2165 {
2166 status = strftime (AsciiTime, 80,
2167#ifdef SH_USE_XML
2168 _("%Y-%m-%dT%H:%M:%S%%s"),
2169#else
2170 _("[%Y-%m-%dT%H:%M:%S%%s]"),
2171#endif
2172 time_ptr);
2173
2174 sl_snprintf(RetTime, 80, AsciiTime, t_zone(&time_now));
2175
2176 if ( (status == 0) || (status == 80) )
2177 SL_RETURN( _(deftime), _("sh_unix_time"));
2178 else
2179 SL_RETURN( &RetTime[0], _("sh_unix_time"));
2180 }
2181
2182 /* last resort
2183 */
2184 SL_RETURN( _(deftime), _("sh_unix_time"));
2185}
2186
2187static int sh_unix_use_localtime = S_FALSE;
2188
2189/* whether to use localtime for file timesatams in logs
2190 */
2191int sh_unix_uselocaltime (const char * c)
2192{
2193 int i;
2194 SL_ENTER(_("sh_unix_uselocaltime"));
2195 i = sh_util_flagval(c, &(sh_unix_use_localtime));
2196
2197 SL_RETURN(i, _("sh_unix_uselocaltime"));
2198}
2199
2200char * sh_unix_gmttime (time_t thetime)
2201{
2202
2203 int status;
2204
2205 struct tm * time_ptr;
2206 static char AsciiTime[81]; /* GMT time */
2207#ifdef SH_USE_XML
2208 static char deftime[] = N_("0000-00-00T00:00:00"); /* default time */
2209#else
2210 static char deftime[] = N_("[0000-00-00T00:00:00]"); /* default time */
2211#endif
2212
2213 SL_ENTER(_("sh_unix_gmttime"));
2214
2215 if (sh_unix_use_localtime == S_FALSE)
2216 time_ptr = gmtime (&thetime);
2217 else
2218 time_ptr = localtime (&thetime);
2219
2220 if (time_ptr != NULL)
2221 {
2222 status = strftime (AsciiTime, 80,
2223#ifdef SH_USE_XML
2224 _("%Y-%m-%dT%H:%M:%S"),
2225#else
2226 _("[%Y-%m-%dT%H:%M:%S]"),
2227#endif
2228 time_ptr);
2229
2230 if ( (status == 0) || (status == 80) )
2231 SL_RETURN( _(deftime), _("sh_unix_gmttime"));
2232 else
2233 SL_RETURN( &AsciiTime[0], _("sh_unix_gmttime"));
2234 }
2235
2236 /* last resort
2237 */
2238 SL_RETURN( _(deftime), _("sh_unix_gmttime"));
2239}
2240
2241
2242
2243char * sh_unix_getUIDdir (int level, uid_t uid)
2244{
2245 struct passwd * tempres;
2246 int status = 0;
2247
2248 SL_ENTER(_("sh_unix_getUIDdir"));
2249
2250 errno = 0;
2251 tempres = sh_getpwuid(uid);
2252 status = errno;
2253
2254 if (tempres == NULL) {
2255 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
2256 sh_error_message(status),
2257 _("getpwuid"), (long) uid, _("completely missing"));
2258 SL_RETURN( NULL, _("sh_unix_getUIDdir"));
2259 }
2260
2261 if (tempres->pw_dir != NULL) {
2262 SL_RETURN( tempres->pw_dir, _("sh_unix_getUIDdir"));
2263 } else {
2264 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
2265 sh_error_message(status),
2266 _("getpwuid"), (long) uid, _("pw_dir"));
2267 SL_RETURN( NULL, _("sh_unix_getUIDdir"));
2268 }
2269}
2270
2271char * sh_unix_getUIDname (int level, uid_t uid)
2272{
2273 struct passwd * tempres;
2274 int status = 0;
2275 static uid_t old_uid;
2276 static char name[32] = { '\0' };
2277
2278 SL_ENTER(_("sh_unix_getUIDname"));
2279
2280 if ((uid == old_uid) && (name[0] != '\0')) {
2281 SL_RETURN( name, _("sh_unix_getUIDname"));
2282 }
2283
2284 errno = 0;
2285 tempres = sh_getpwuid(uid);
2286 status = errno;
2287
2288 if (tempres == NULL) {
2289 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
2290 sh_error_message(status),
2291 _("getpwuid"), (long) uid, _("completely missing"));
2292 SL_RETURN( NULL, _("sh_unix_getUIDname"));
2293 }
2294
2295
2296 if (tempres->pw_name != NULL) {
2297 sl_strlcpy(name, tempres->pw_name, sizeof(name));
2298 old_uid = uid;
2299 SL_RETURN( name, _("sh_unix_getUIDname"));
2300 } else {
2301 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
2302 sh_error_message(status),
2303 _("getpwuid"), (long) uid, _("pw_user"));
2304 SL_RETURN( NULL, _("sh_unix_getUIDname"));
2305 }
2306}
2307
2308char * sh_unix_getGIDname (int level, gid_t gid)
2309{
2310 struct group * tempres;
2311 int status = 0;
2312 static gid_t old_gid;
2313 static char name[32] = { '\0' };
2314
2315 SL_ENTER(_("sh_unix_getGIDname"));
2316
2317 if ((gid == old_gid) && (name[0] != '\0')) {
2318 SL_RETURN( name, _("sh_unix_getUIDname"));
2319 }
2320
2321 errno = 0;
2322 tempres = sh_getgrgid(gid);
2323 status = errno;
2324
2325 if (tempres == NULL) {
2326 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
2327 sh_error_message(status),
2328 _("getgrgid"), (long) gid, _("completely missing"));
2329
2330 SL_RETURN( NULL, _("sh_unix_getGIDname"));
2331 }
2332
2333 if (tempres->gr_name != NULL) {
2334 sl_strlcpy(name, tempres->gr_name, sizeof(name));
2335 old_gid = gid;
2336 SL_RETURN( name, _("sh_unix_getGIDname"));
2337 } else {
2338 sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
2339 sh_error_message(status),
2340 _("getgrgid"), (long) gid, _("gr_name"));
2341 SL_RETURN( NULL, _("sh_unix_getGIDname"));
2342 }
2343}
2344
2345int sh_unix_getUser ()
2346{
2347 char * p;
2348 uid_t seuid, sruid;
2349
2350 SL_ENTER(_("sh_unix_getUser"));
2351
2352 seuid = geteuid();
2353
2354 sh.effective.uid = seuid;
2355
2356 p = sh_unix_getUIDdir (SH_ERR_ERR, seuid);
2357
2358 if (p == NULL)
2359 SL_RETURN((-1), _("sh_unix_getUser"));
2360 else
2361 {
2362 if (sl_strlen(p) >= SH_PATHBUF) {
2363 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
2364 _("getpwuid"), (long) seuid, _("pw_home"));
2365 SL_RETURN((-1), _("sh_unix_getUser"));
2366 } else {
2367 sl_strlcpy ( sh.effective.home, p, SH_PATHBUF);
2368 }
2369 }
2370
2371 sruid = getuid();
2372
2373 sh.real.uid = sruid;
2374
2375 p = sh_unix_getUIDname (SH_ERR_ERR, sruid);
2376 if (p == NULL)
2377 SL_RETURN((-1), _("sh_unix_getUser"));
2378 else
2379 {
2380 if (sl_strlen(p) >= USER_MAX) {
2381 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
2382 _("getpwuid"), (long) sruid, _("pw_user"));
2383 SL_RETURN((-1), _("sh_unix_getUser"));
2384 } else {
2385 sl_strlcpy ( sh.real.user, p, USER_MAX);
2386 }
2387 }
2388
2389 p = sh_unix_getUIDdir (SH_ERR_ERR, sruid);
2390
2391 if (p == NULL)
2392 SL_RETURN((-1), _("sh_unix_getUser"));
2393 else
2394 {
2395 if (sl_strlen(p) >= SH_PATHBUF) {
2396 sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
2397 _("getpwuid"), (long) sruid, _("pw_home"));
2398 SL_RETURN((-1), _("sh_unix_getUser"));
2399 } else {
2400 sl_strlcpy ( sh.real.home, p, SH_PATHBUF);
2401 }
2402 }
2403
2404 SL_RETURN((0), _("sh_unix_getUser"));
2405
2406 /* notreached */
2407}
2408
2409
2410int sh_unix_getline (SL_TICKET fd, char * line, int sizeofline)
2411{
2412 register int count;
2413 register int n = 0;
2414 char c;
2415
2416 SL_ENTER(_("sh_unix_getline"));
2417
2418 if (sizeofline < 2) {
2419 line[0] = '\0';
2420 SL_RETURN((0), _("sh_unix_getline"));
2421 }
2422
2423 --sizeofline;
2424
2425 while (n < sizeofline) {
2426
2427 count = sl_read (fd, &c, 1);
2428
2429 /* end of file
2430 */
2431 if (count < 1) {
2432 line[n] = '\0';
2433 n = -1;
2434 break;
2435 }
2436
2437 if (/* c != '\0' && */ c != '\n') {
2438 line[n] = c;
2439 ++n;
2440 } else if (c == '\n') {
2441 if (n > 0) {
2442 line[n] = '\0';
2443 break;
2444 } else {
2445 line[n] = '\n'; /* get newline only if only char on line */
2446 ++n;
2447 line[n] = '\0';
2448 break;
2449 }
2450 } else {
2451 line[n] = '\0';
2452 break;
2453 }
2454
2455 }
2456
2457
2458 line[sizeofline] = '\0'; /* make sure line is terminated */
2459 SL_RETURN((n), _("sh_unix_getline"));
2460}
2461
2462
2463#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
2464
2465/**************************************************************
2466 *
2467 * --- FILE INFO ---
2468 *
2469 **************************************************************/
2470
2471#if (defined(__linux__) && (defined(HAVE_LINUX_EXT2_FS_H) || defined(HAVE_EXT2FS_EXT2_FS_H))) || defined(HAVE_STAT_FLAGS)
2472
2473#if defined(__linux__)
2474
2475/* --- Determine ext2fs file attributes. ---
2476 */
2477#include <sys/ioctl.h>
2478#if defined(HAVE_EXT2FS_EXT2_FS_H)
2479#include <ext2fs/ext2_fs.h>
2480#else
2481#include <linux/ext2_fs.h>
2482#endif
2483
2484/* __linux__ includes */
2485#endif
2486
2487static
2488int sh_unix_getinfo_attr (char * name,
2489 unsigned long * flags,
2490 char * c_attr,
2491 int fd, struct stat * buf)
2492{
2493
2494/* TAKEN FROM:
2495 *
2496 * lsattr.c - List file attributes on an ext2 file system
2497 *
2498 * Copyright (C) 1993, 1994 Remy Card <card@masi.ibp.fr>
2499 * Laboratoire MASI, Institut Blaise Pascal
2500 * Universite Pierre et Marie Curie (Paris VI)
2501 *
2502 * This file can be redistributed under the terms of the GNU General
2503 * Public License
2504 */
2505
2506#ifdef HAVE_STAT_FLAGS
2507
2508 SL_ENTER(_("sh_unix_getinfo_attr"));
2509
2510 *flags = 0;
2511
2512 /* cast to void to avoid compiler warning about unused parameters */
2513 (void) fd;
2514 (void) name;
2515
2516#ifdef UF_NODUMP
2517 if (buf->st_flags & UF_NODUMP) {
2518 *flags |= UF_NODUMP;
2519 c_attr[0] = 'd';
2520 }
2521#endif
2522#ifdef UF_IMMUTABLE
2523 if (buf->st_flags & UF_IMMUTABLE) {
2524 *flags |= UF_IMMUTABLE;
2525 c_attr[1] = 'i';
2526 }
2527#endif
2528#ifdef UF_APPEND
2529 if (buf->st_flags & UF_APPEND) {
2530 *flags |= UF_APPEND;
2531 c_attr[2] = 'a';
2532 }
2533#endif
2534#ifdef UF_NOUNLINK
2535 if (buf->st_flags & UF_NOUNLINK) {
2536 *flags |= UF_NOUNLINK;
2537 c_attr[3] = 'u';
2538 }
2539#endif
2540#ifdef UF_OPAQUE
2541 if (buf->st_flags & UF_OPAQUE) {
2542 *flags |= UF_OPAQUE;
2543 c_attr[4] = 'o';
2544 }
2545#endif
2546#ifdef SF_ARCHIVED
2547 if (buf->st_flags & SF_ARCHIVED) {
2548 *flags |= SF_ARCHIVED;
2549 c_attr[5] = 'R';
2550 }
2551
2552#endif
2553#ifdef SF_IMMUTABLE
2554 if (buf->st_flags & SF_IMMUTABLE) {
2555 *flags |= SF_IMMUTABLE;
2556 c_attr[6] = 'I';
2557 }
2558#endif
2559#ifdef SF_APPEND
2560 if (buf->st_flags & SF_APPEND) {
2561 *flags |= SF_APPEND;
2562 c_attr[7] = 'A';
2563 }
2564#endif
2565#ifdef SF_NOUNLINK
2566 if (buf->st_flags & SF_NOUNLINK) {
2567 *flags |= SF_NOUNLINK;
2568 c_attr[8] = 'U';
2569 }
2570#endif
2571
2572 /* ! HAVE_STAT_FLAGS */
2573#else
2574
2575#ifdef HAVE_EXT2_IOCTLS
2576 int /* fd, */ r, f;
2577
2578 SL_ENTER(_("sh_unix_getinfo_attr"));
2579
2580 *flags = 0;
2581 (void) buf;
2582
2583 /* open() -> aud_open() R.Wichmann
2584 fd = aud_open (FIL__, __LINE__, SL_YESPRIV, name, O_RDONLY|O_NONBLOCK, 0);
2585 */
2586
2587 if (fd == -1 || name == NULL)
2588 SL_RETURN(-1, _("sh_unix_getinfo_attr"));
2589
2590
2591 r = ioctl (fd, EXT2_IOC_GETFLAGS, &f);
2592 /* close (fd); */
2593
2594 if (r == -1)
2595 SL_RETURN(-1, _("sh_unix_getinfo_attr"));
2596
2597 if (f == 0)
2598 SL_RETURN(0, _("sh_unix_getinfo_attr"));
2599
2600 *flags = f;
2601
2602/* ! HAVE_EXT2_IOCTLS */
2603#else
2604
2605 SL_ENTER(_("sh_unix_getinfo_attr"));
2606
2607 *flags = 0; /* modified by R.Wichmann */
2608
2609/* ! HAVE_EXT2_IOCTLS */
2610#endif
2611/*
2612 * END
2613 *
2614 * lsattr.c - List file attributes on an ext2 file system
2615 */
2616
2617 if (*flags == 0)
2618 goto theend;
2619
2620#ifdef EXT2_SECRM_FL
2621 if ( (*flags & EXT2_SECRM_FL) != 0 ) c_attr[0] = 's';
2622#endif
2623#ifdef EXT2_UNRM_FL
2624 if ( (*flags & EXT2_UNRM_FL) != 0 ) c_attr[1] = 'u';
2625#endif
2626#ifdef EXT2_SYNC_FL
2627 if ( (*flags & EXT2_SYNC_FL) != 0 ) c_attr[2] = 'S';
2628#endif
2629#ifdef EXT2_IMMUTABLE_FL
2630 if ( (*flags & EXT2_IMMUTABLE_FL) != 0) c_attr[3] = 'i';
2631#endif
2632#ifdef EXT2_APPEND_FL
2633 if ( (*flags & EXT2_APPEND_FL) != 0 ) c_attr[4] = 'a';
2634#endif
2635#ifdef EXT2_NODUMP_FL
2636 if ( (*flags & EXT2_NODUMP_FL) != 0 ) c_attr[5] = 'd';
2637#endif
2638#ifdef EXT2_NOATIME_FL
2639 if ( (*flags & EXT2_NOATIME_FL) != 0) c_attr[6] = 'A';
2640#endif
2641#ifdef EXT2_COMPR_FL
2642 if ( (*flags & EXT2_COMPR_FL) != 0 ) c_attr[7] = 'c';
2643#endif
2644
2645#ifdef EXT2_TOPDIR_FL
2646 if ( (*flags & EXT2_TOPDIR_FL) != 0 ) c_attr[8] = 'T';
2647#endif
2648#ifdef EXT2_DIRSYNC_FL
2649 if ( (*flags & EXT2_DIRSYNC_FL) != 0 ) c_attr[9] = 'D';
2650#endif
2651#ifdef EXT2_NOTAIL_FL
2652 if ( (*flags & EXT2_NOTAIL_FL) != 0 ) c_attr[10] = 't';
2653#endif
2654#ifdef EXT2_JOURNAL_DATA_FL
2655 if ( (*flags & EXT2_JOURNAL_DATA_FL) != 0) c_attr[11] = 'j';
2656#endif
2657
2658 theend:
2659 /* ext2 */
2660#endif
2661
2662 c_attr[12] = '\0';
2663
2664 SL_RETURN(0, _("sh_unix_getinfo_attr"));
2665}
2666#else
2667static
2668int sh_unix_getinfo_attr (char * name,
2669 unsigned long * flags,
2670 char * c_attr,
2671 int fd, struct stat * buf)
2672{
2673 return 0;
2674}
2675
2676/* defined(__linux__) || defined(HAVE_STAT_FLAGS) */
2677#endif
2678
2679/* determine file type
2680 */
2681static
2682int sh_unix_getinfo_type (struct stat * buf,
2683 ShFileType * type,
2684 char * c_mode)
2685{
2686 SL_ENTER(_("sh_unix_getinfo_type"));
2687
2688 if ( S_ISREG(buf->st_mode) ) {
2689 (*type) = SH_FILE_REGULAR;
2690 c_mode[0] = '-';
2691 }
2692 else if ( S_ISLNK(buf->st_mode) ) {
2693 (*type) = SH_FILE_SYMLINK;
2694 c_mode[0] = 'l';
2695 }
2696 else if ( S_ISDIR(buf->st_mode) ) {
2697 (*type) = SH_FILE_DIRECTORY;
2698 c_mode[0] = 'd';
2699 }
2700 else if ( S_ISCHR(buf->st_mode) ) {
2701 (*type) = SH_FILE_CDEV;
2702 c_mode[0] = 'c';
2703 }
2704 else if ( S_ISBLK(buf->st_mode) ) {
2705 (*type) = SH_FILE_BDEV;
2706 c_mode[0] = 'b';
2707 }
2708 else if ( S_ISFIFO(buf->st_mode) ) {
2709 (*type) = SH_FILE_FIFO;
2710 c_mode[0] = '|';
2711 }
2712 else if ( S_ISSOCK(buf->st_mode) ) {
2713 (*type) = SH_FILE_SOCKET;
2714 c_mode[0] = 's';
2715 }
2716 else if ( S_ISDOOR(buf->st_mode) ) {
2717 (*type) = SH_FILE_DOOR;
2718 c_mode[0] = 'D';
2719 }
2720 else if ( S_ISPORT(buf->st_mode) ) {
2721 (*type) = SH_FILE_PORT;
2722 c_mode[0] = 'P';
2723 }
2724 else {
2725 (*type) = SH_FILE_UNKNOWN;
2726 c_mode[0] = '?';
2727 }
2728
2729 SL_RETURN(0, _("sh_unix_getinfo_type"));
2730}
2731
2732int sh_unix_get_ftype(char * fullpath)
2733{
2734 char c_mode[16];
2735 struct stat buf;
2736 ShFileType type;
2737 int res;
2738
2739 SL_ENTER(_("sh_unix_get_ftype"));
2740
2741 res = retry_lstat(FIL__, __LINE__, fullpath, &buf);
2742
2743 if (res < 0)
2744 SL_RETURN(SH_FILE_UNKNOWN, _("sh_unix_getinfo_type"));
2745
2746 sh_unix_getinfo_type (&buf, &type, c_mode);
2747
2748 SL_RETURN(type, _("sh_unix_get_ftype"));
2749}
2750
2751
2752static
2753int sh_unix_getinfo_mode (struct stat *buf,
2754 unsigned int * mode,
2755 char * c_mode)
2756{
2757
2758 SL_ENTER(_("sh_unix_getinfo_mode"));
2759
2760 (*mode) = buf->st_mode;
2761
2762 /* make 'ls'-like string */
2763
2764 if ( (buf->st_mode & S_IRUSR) != 0 ) c_mode[1] = 'r';
2765 if ( (buf->st_mode & S_IWUSR) != 0 ) c_mode[2] = 'w';
2766 if ( (buf->st_mode & S_IXUSR) != 0 ) {
2767 if ((buf->st_mode & S_ISUID) != 0 ) c_mode[3] = 's';
2768 else c_mode[3] = 'x';
2769 } else {
2770 if ((buf->st_mode & S_ISUID) != 0 ) c_mode[3] = 'S';
2771 }
2772
2773 if ( (buf->st_mode & S_IRGRP) != 0 ) c_mode[4] = 'r';
2774 if ( (buf->st_mode & S_IWGRP) != 0 ) c_mode[5] = 'w';
2775 if ( (buf->st_mode & S_IXGRP) != 0 ) {
2776 if ((buf->st_mode & S_ISGID) != 0 ) c_mode[6] = 's';
2777 else c_mode[6] = 'x';
2778 } else {
2779 if ((buf->st_mode & S_ISGID) != 0 ) c_mode[6] = 'S';
2780 }
2781
2782 if ( (buf->st_mode & S_IROTH) != 0 ) c_mode[7] = 'r';
2783 if ( (buf->st_mode & S_IWOTH) != 0 ) c_mode[8] = 'w';
2784#ifdef S_ISVTX /* not POSIX */
2785 if ( (buf->st_mode & S_IXOTH) != 0 ) {
2786 if ((buf->st_mode & S_ISVTX) != 0 ) c_mode[9] = 't';
2787 else c_mode[9] = 'x';
2788 } else {
2789 if ((buf->st_mode & S_ISVTX) != 0 ) c_mode[9] = 'T';
2790 }
2791#else
2792 if ( (buf->st_mode & S_IXOTH) != 0 ) c_mode[9] = 'x';
2793#endif
2794
2795 SL_RETURN(0, _("sh_unix_getinfo_mode"));
2796}
2797
2798
2799long IO_Limit = 0;
2800
2801void sh_unix_io_pause ()
2802{
2803 long runtime;
2804 float someval;
2805 unsigned long sometime;
2806
2807 if (IO_Limit == 0)
2808 {
2809 return;
2810 }
2811 else
2812 {
2813 runtime = (long) (time(NULL) - sh.statistics.time_start);
2814
2815 if (runtime > 0 && (long)(sh.statistics.bytes_hashed/runtime) > IO_Limit)
2816 {
2817 someval = sh.statistics.bytes_hashed - (IO_Limit * runtime);
2818 someval /= (float) IO_Limit;
2819 if (someval < 1.0)
2820 {
2821 someval *= 1000; /* milliseconds in a second */
2822 sometime = (unsigned long) someval;
2823 /* fprintf(stderr, "FIXME PAUSE %ld\n", sometime); */
2824 retry_msleep(0, sometime);
2825 }
2826 else
2827 {
2828 sometime = (unsigned long) someval;
2829 /* fprintf(stderr, "FIXME PAUSE %ld sec\n", sometime); */
2830 retry_msleep (sometime, 0);
2831 }
2832 }
2833 }
2834 return;
2835}
2836
2837int sh_unix_set_io_limit (const char * c)
2838{
2839 long val;
2840
2841 SL_ENTER(_("sh_unix_set_io_limit"));
2842
2843 val = strtol (c, (char **)NULL, 10);
2844 if (val < 0)
2845 sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
2846 _("set I/O limit"), c);
2847
2848 val = (val < 0 ? 0 : val);
2849
2850 IO_Limit = val * 1024;
2851 SL_RETURN( 0, _("sh_unix_set_io_limit"));
2852}
2853
2854/* obtain file info
2855 */
2856extern int flag_err_debug;
2857
2858#include "sh_ignore.h"
2859
2860int sh_unix_checksum_size (char * filename, struct stat * fbuf,
2861 char * fileHash, int alert_timeout)
2862{
2863 file_type tmpFile;
2864 int status;
2865
2866 SL_ENTER(_("sh_unix_checksum_size"));
2867
2868 if (sh.flag.checkSum != SH_CHECK_INIT)
2869 {
2870 /* lookup file in database */
2871 status = sh_hash_get_it (filename, &tmpFile);
2872 if (status != 0) {
2873 goto out;
2874 }
2875 }
2876 else
2877 {
2878 tmpFile.size = fbuf->st_size;
2879 }
2880
2881 /* if last < current get checksum */
2882 if (tmpFile.size < fbuf->st_size)
2883 {
2884 sl_strlcpy(fileHash,
2885 sh_tiger_generic_hash (filename, TIGER_FD, tmpFile.size,
2886 alert_timeout),
2887 KEY_LEN+1);
2888
2889 /* return */
2890 SL_RETURN( 0, _("sh_unix_checksum_size"));
2891 }
2892
2893 out:
2894 sl_strlcpy(fileHash,
2895 _("000000000000000000000000000000000000000000000000"),
2896 KEY_LEN+1);
2897 SL_RETURN( -1, _("sh_unix_checksum_size"));
2898}
2899
2900int sh_unix_check_selinux = S_FALSE;
2901int sh_unix_check_acl = S_FALSE;
2902
2903#ifdef USE_ACL
2904
2905#include <sys/acl.h>
2906static char * sh_unix_getinfo_acl (char * path, int fd, struct stat * buf)
2907{
2908 /* system.posix_acl_access, system.posix_acl_default
2909 */
2910 char * out = NULL;
2911 char * collect = NULL;
2912 char * tmp;
2913 char * out_compact;
2914 ssize_t len;
2915 acl_t result;
2916
2917 SL_ENTER(_("sh_unix_getinfo_acl"));
2918
2919 result = (fd == -1) ?
2920 acl_get_file (path, ACL_TYPE_ACCESS) :
2921 acl_get_fd (fd);
2922
2923 if (result)
2924 {
2925 out = acl_to_text (result, &len);
2926 if (out && (len > 0)) {
2927 out_compact = sh_util_acl_compact (out, len);
2928 acl_free(out);
2929 if (out_compact)
2930 {
2931 collect = sh_util_strconcat (_("acl_access:"), out_compact, NULL);
2932 SH_FREE(out_compact);
2933 }
2934 }
2935 acl_free(result);
2936 }
2937
2938
2939 if ( S_ISDIR(buf->st_mode) )
2940 {
2941 result = acl_get_file (path, ACL_TYPE_DEFAULT);
2942
2943 if (result)
2944 {
2945 out = acl_to_text (result, &len);
2946 if (out && (len > 0)) {
2947 out_compact = sh_util_acl_compact (out, len);
2948 acl_free(out);
2949 if (out_compact) {
2950 if (collect) {
2951 tmp = sh_util_strconcat (_("acl_default:"),
2952 out_compact, ":", collect, NULL);
2953 SH_FREE(collect);
2954 }
2955 else {
2956 tmp = sh_util_strconcat (_("acl_default:"), out_compact, NULL);
2957 }
2958 SH_FREE(out_compact);
2959 collect = tmp;
2960 }
2961 }
2962 acl_free(result);
2963 }
2964 }
2965
2966 SL_RETURN((collect),_("sh_unix_getinfo_acl"));
2967}
2968#endif
2969
2970#ifdef USE_XATTR
2971
2972#include <attr/xattr.h>
2973static char * sh_unix_getinfo_xattr_int (char * path, int fd, char * name)
2974{
2975 char * out = NULL;
2976 char * tmp = NULL;
2977 size_t size = 256;
2978 ssize_t result;
2979
2980 SL_ENTER(_("sh_unix_getinfo_xattr_int"));
2981
2982 out = SH_ALLOC(size);
2983
2984 result = (fd == -1) ?
2985 lgetxattr (path, name, out, size-1) :
2986 fgetxattr (fd, name, out, size-1);
2987
2988 if (result == -1 && errno == ERANGE)
2989 {
2990 SH_FREE(out);
2991 result = (fd == -1) ?
2992 lgetxattr (path, name, NULL, 0) :
2993 fgetxattr (fd, name, NULL, 0);
2994 size = result + 1;
2995 out = SH_ALLOC(size);
2996 result = (fd == -1) ?
2997 lgetxattr (path, name, out, size-1) :
2998 fgetxattr (fd, name, out, size-1);
2999 }
3000
3001 if ((result > 0) && ((size_t)result < size))
3002 {
3003 out[size-1] = '\0';
3004 tmp = out;
3005 }
3006 else
3007 {
3008 SH_FREE(out);
3009 }
3010
3011 SL_RETURN((tmp),_("sh_unix_getinfo_xattr_int"));
3012}
3013
3014
3015static char * sh_unix_getinfo_xattr (char * path, int fd, struct stat * buf)
3016{
3017 /* system.posix_acl_access, system.posix_acl_default, security.selinux
3018 */
3019 char * tmp;
3020 char * out = NULL;
3021 char * collect = NULL;
3022
3023 SL_ENTER(_("sh_unix_getinfo_xattr"));
3024
3025#ifdef USE_ACL
3026 /*
3027 * we need the acl_get_fd/acl_get_file functions, getxattr will only
3028 * yield the raw bytes
3029 */
3030 if (sh_unix_check_acl == S_TRUE)
3031 {
3032 out = sh_unix_getinfo_acl(path, fd, buf);
3033
3034 if (out)
3035 {
3036 collect = out;
3037 }
3038 }
3039#endif
3040
3041 out = sh_unix_getinfo_xattr_int(path, fd, _("security.selinux"));
3042
3043 if (out)
3044 {
3045 if (collect) {
3046 tmp = sh_util_strconcat(_("selinux:"), out, ":", collect, NULL);
3047 SH_FREE(collect);
3048 }
3049 else {
3050 tmp = sh_util_strconcat(_("selinux:"), out, NULL);
3051 }
3052 SH_FREE(out);
3053 collect = tmp;
3054 }
3055
3056 SL_RETURN((collect),_("sh_unix_getinfo_xattr"));
3057}
3058#endif
3059
3060#ifdef USE_XATTR
3061int sh_unix_setcheckselinux (const char * c)
3062{
3063 int i;
3064 SL_ENTER(_("sh_unix_setcheckselinux"));
3065 i = sh_util_flagval(c, &(sh_unix_check_selinux));
3066
3067 SL_RETURN(i, _("sh_unix_setcheckselinux"));
3068}
3069#endif
3070
3071#ifdef USE_ACL
3072int sh_unix_setcheckacl (const char * c)
3073{
3074 int i;
3075 SL_ENTER(_("sh_unix_setcheckacl"));
3076 i = sh_util_flagval(c, &(sh_unix_check_acl));
3077
3078 SL_RETURN(i, _("sh_unix_setcheckacl"));
3079}
3080#endif
3081
3082
3083int sh_unix_getinfo (int level, char * filename, file_type * theFile,
3084 char * fileHash, int policy)
3085{
3086 char timestr[81];
3087 long runtim;
3088 struct stat buf;
3089 struct stat lbuf;
3090 struct stat fbuf;
3091 int stat_return;
3092
3093 ShFileType type;
3094 unsigned int mode;
3095 char * name;
3096 char * tmp;
3097 char * tmp2;
3098
3099 char * linknamebuf;
3100 int linksize;
3101
3102 extern int get_the_fd (SL_TICKET ticket);
3103
3104 SL_TICKET rval_open;
3105 int fd;
3106 int fstat_return;
3107
3108 time_t tend;
3109 time_t tstart;
3110
3111
3112 char * path = NULL;
3113
3114 int alert_timeout = 120;
3115
3116 path = theFile->fullpath;
3117
3118 SL_ENTER(_("sh_unix_getinfo"));
3119
3120 /* --- Stat the file, and get checksum. ---
3121 */
3122 tstart = time(NULL);
3123
3124 stat_return = retry_lstat (FIL__, __LINE__,
3125 path /* theFile->fullpath */, &buf);
3126
3127 fd = -1;
3128 fstat_return = -1;
3129 rval_open = -1;
3130
3131 if (stat_return == 0 && S_ISREG(buf.st_mode))
3132 {
3133 rval_open = sl_open_fastread (path /* theFile->fullpath */, SL_YESPRIV);
3134
3135 alert_timeout = 120; /* this is per 8K block now ! */
3136
3137 if (path[1] == 'p' && path[5] == '/' && path[2] == 'r' &&
3138 path[3] == 'o' && path[4] == 'c' && path[0] == '/')
3139 {
3140 /* seven is magic */
3141 alert_timeout = 7;
3142 }
3143
3144 fd = get_the_fd(rval_open);
3145 }
3146
3147 tend = time(NULL);
3148
3149 /* An unprivileged user may slow lstat/open to a crawl
3150 * with clever path/symlink setup
3151 */
3152 if ((tend - tstart) > (time_t) /* 60 */ 6)
3153 {
3154 tmp2 = sh_util_safe_name (theFile->fullpath);
3155 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_TOOLATE,
3156 (long)(tend - tstart), tmp2);
3157 SH_FREE(tmp2);
3158 }
3159
3160 if (fd >= 0)
3161 fstat_return = retry_fstat (FIL__, __LINE__, fd, &fbuf);
3162 else
3163 fd = -1;
3164
3165
3166 /* --- case 1: lstat failed ---
3167 */
3168 if (stat_return != 0)
3169 {
3170 stat_return = errno;
3171 if (!SL_ISERROR(rval_open))
3172 sl_close(rval_open);
3173 if (sh.flag.checkSum == SH_CHECK_INIT ||
3174 (sh_hash_have_it (theFile->fullpath) >= 0 &&
3175 theFile->reported == S_FALSE))
3176 {
3177 if (S_FALSE == sh_ignore_chk_del(theFile->fullpath)) {
3178 tmp2 = sh_util_safe_name (theFile->fullpath);
3179 sh_error_handle (level, FIL__, __LINE__, stat_return, MSG_FI_LSTAT,
3180 sh_error_message (stat_return), tmp2);
3181 SH_FREE(tmp2);
3182 }
3183 }
3184 SL_RETURN((-1),_("sh_unix_getinfo"));
3185 }
3186
3187 /* --- case 2: not a regular file ---
3188 */
3189 else if (! S_ISREG(buf.st_mode))
3190 {
3191 if (fileHash != NULL)
3192 sl_strlcpy(fileHash,
3193 _("000000000000000000000000000000000000000000000000"),
3194 KEY_LEN+1);
3195 }
3196
3197 /* --- case 3a: a regular file, fstat ok ---
3198 */
3199 else if (fstat_return == 0 &&
3200 buf.st_mode == fbuf.st_mode &&
3201 buf.st_ino == fbuf.st_ino &&
3202 buf.st_uid == fbuf.st_uid &&
3203 buf.st_gid == fbuf.st_gid &&
3204 buf.st_dev == fbuf.st_dev )
3205 {
3206 if (fileHash != NULL)
3207 {
3208 if ((theFile->check_mask & MODI_CHK) == 0)
3209 {
3210 sl_strlcpy(fileHash,
3211 _("000000000000000000000000000000000000000000000000"),
3212 KEY_LEN+1);
3213 }
3214 else if ((theFile->check_mask & MODI_PREL) != 0 &&
3215 S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
3216 alert_timeout))
3217 {
3218 if (0 != sh_prelink_run (theFile->fullpath,
3219 fileHash, alert_timeout))
3220 sl_strlcpy(fileHash,
3221 _("000000000000000000000000000000000000000000000000"),
3222 KEY_LEN+1);
3223 }
3224 else
3225 {
3226 tiger_fd = rval_open;
3227 sl_strlcpy(fileHash,
3228 sh_tiger_generic_hash (theFile->fullpath,
3229 TIGER_FD, 0,
3230 alert_timeout),
3231 KEY_LEN+1);
3232 if ((theFile->check_mask & MODI_SGROW) != 0)
3233 {
3234 sl_rewind(rval_open);
3235 tiger_fd = rval_open;
3236 sh_unix_checksum_size (theFile->fullpath, &fbuf,
3237 &fileHash[KEY_LEN + 1],
3238 alert_timeout);
3239 }
3240 }
3241 }
3242 }
3243
3244 /* --- case 3b: a regular file, fstat ok, but different ---
3245 */
3246 else if (fstat_return == 0 && S_ISREG(fbuf.st_mode))
3247 {
3248 memcpy (&buf, &fbuf, sizeof( struct stat ));
3249
3250 if (fileHash != NULL)
3251 {
3252 if ((theFile->check_mask & MODI_CHK) == 0)
3253 {
3254 sl_strlcpy(fileHash,
3255 _("000000000000000000000000000000000000000000000000"),
3256 KEY_LEN+1);
3257 }
3258 else if (policy == SH_LEVEL_PRELINK &&
3259 S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
3260 alert_timeout))
3261 {
3262 if (0 != sh_prelink_run (theFile->fullpath,
3263 fileHash, alert_timeout))
3264 sl_strlcpy(fileHash,
3265 _("000000000000000000000000000000000000000000000000"),
3266 KEY_LEN+1);
3267 }
3268 else
3269 {
3270 tiger_fd = rval_open;
3271 sl_strlcpy(fileHash,
3272 sh_tiger_generic_hash (theFile->fullpath, TIGER_FD, 0,
3273 alert_timeout),
3274 KEY_LEN + 1);
3275 if ((theFile->check_mask & MODI_SGROW) != 0)
3276 {
3277 sl_rewind(rval_open);
3278 tiger_fd = rval_open;
3279 sh_unix_checksum_size (theFile->fullpath, &fbuf,
3280 &fileHash[KEY_LEN + 1],
3281 alert_timeout);
3282 }
3283 }
3284 }
3285 }
3286
3287 /* --- case 4: a regular file, fstat failed ---
3288 */
3289
3290 else /* fstat_return != 0 or !S_ISREG(fbuf->st_mode) */
3291 {
3292 fstat_return = errno;
3293 if (fileHash != NULL)
3294 sl_strlcpy(fileHash,
3295 _("000000000000000000000000000000000000000000000000"),
3296 KEY_LEN + 1);
3297
3298 if ((theFile->check_mask & MODI_CHK) != 0)
3299 {
3300 tmp2 = sh_util_safe_name (theFile->fullpath);
3301 sh_error_handle (level, FIL__, __LINE__, fstat_return, MSG_E_READ,
3302 tmp2);
3303 SH_FREE(tmp2);
3304 }
3305 }
3306
3307
3308 /* --- Determine file type. ---
3309 */
3310 memset (theFile->c_mode, '-', 10);
3311 theFile->c_mode[10] = '\0';
3312
3313 memset (theFile->link_c_mode, '-', 10);
3314 theFile->link_c_mode[10] = '\0';
3315
3316 sh_unix_getinfo_type (&buf, &type, theFile->c_mode);
3317 theFile->type = type;
3318
3319#if defined(__linux__) || defined(HAVE_STAT_FLAGS)
3320
3321 /* --- Determine file attributes. ---
3322 */
3323 memset (theFile->c_attributes, '-', 12);
3324 theFile->c_attributes[12] = '\0';
3325 theFile->attributes = 0;
3326
3327 if (theFile->c_mode[0] != 'c' && theFile->c_mode[0] != 'b' &&
3328 theFile->c_mode[0] != 'l' )
3329 sh_unix_getinfo_attr(theFile->fullpath,
3330 &theFile->attributes, theFile->c_attributes,
3331 fd, &buf);
3332#endif
3333
3334#if defined(USE_XATTR)
3335 if (sh_unix_check_selinux == S_TRUE)
3336 theFile->attr_string = sh_unix_getinfo_xattr (theFile->fullpath, fd, &buf);
3337#elif defined(USE_ACL)
3338 if (sh_unix_check_acl == S_TRUE)
3339 theFile->attr_string = sh_unix_getinfo_acl (theFile->fullpath, fd, &buf);
3340#else
3341 theFile->attr_string = NULL;
3342#endif
3343
3344 if (!SL_ISERROR(rval_open))
3345 sl_close(rval_open);
3346
3347
3348 /* --- I/O limit. ---
3349 */
3350 if (IO_Limit > 0)
3351 {
3352 runtim = (long) (time(NULL) - sh.statistics.time_start);
3353
3354 if (runtim > 0 && (long)(sh.statistics.bytes_hashed/runtim) > IO_Limit)
3355 retry_msleep(1, 0);
3356 }
3357
3358 /* --- Determine permissions. ---
3359 */
3360 sh_unix_getinfo_mode (&buf, &mode, theFile->c_mode);
3361
3362 /* --- Trivia. ---
3363 */
3364 theFile->dev = buf.st_dev;
3365 theFile->ino = buf.st_ino;
3366 theFile->mode = buf.st_mode;
3367 theFile->hardlinks = buf.st_nlink;
3368 theFile->owner = buf.st_uid;
3369 theFile->group = buf.st_gid;
3370 theFile->rdev = buf.st_rdev;
3371 theFile->size = buf.st_size;
3372 theFile->blksize = (unsigned long) buf.st_blksize;
3373 theFile->blocks = (unsigned long) buf.st_blocks;
3374 theFile->atime = buf.st_atime;
3375 theFile->mtime = buf.st_mtime;
3376 theFile->ctime = buf.st_ctime;
3377
3378
3379 /* --- Owner and group. ---
3380 */
3381
3382 if ( (name = sh_unix_getGIDname(SH_ERR_ALL,
3383 buf.st_gid)) != NULL) {
3384 sl_strlcpy (theFile->c_group, name, GROUP_MAX+1);
3385 } else {
3386
3387 tmp2 = sh_util_safe_name (theFile->fullpath);
3388
3389 if (policy == SH_LEVEL_ALLIGNORE)
3390 {
3391 sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, ENOENT,
3392 MSG_FI_NOGRP,
3393 (long) buf.st_gid, tmp2);
3394 }
3395 else
3396 {
3397 sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, ENOENT,
3398 MSG_FI_NOGRP,
3399 (long) buf.st_gid, tmp2);
3400 }
3401 SH_FREE(tmp2);
3402 sl_snprintf(theFile->c_group, GROUP_MAX+1, "%d", (long) buf.st_gid);
3403 }
3404
3405
3406 if ( (name = sh_unix_getUIDname(SH_ERR_ALL,
3407 buf.st_uid)) != NULL) {
3408 sl_strlcpy (theFile->c_owner, name, USER_MAX+1);
3409 } else {
3410
3411 tmp2 = sh_util_safe_name (theFile->fullpath);
3412
3413 if (policy == SH_LEVEL_ALLIGNORE)
3414 {
3415 sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, ENOENT,
3416 MSG_FI_NOUSR,
3417 (long) buf.st_uid, tmp2);
3418 }
3419 else
3420 {
3421 sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, ENOENT,
3422 MSG_FI_NOUSR,
3423 (long) buf.st_uid, tmp2);
3424 }
3425 SH_FREE(tmp2);
3426 sl_snprintf(theFile->c_owner, USER_MAX+1, "%d", (long) buf.st_uid);
3427 }
3428
3429 /* --- Output the file. ---
3430 */
3431 if (flag_err_debug == SL_TRUE)
3432 {
3433 tmp2 = sh_util_safe_name ((filename == NULL) ?
3434 theFile->fullpath : filename);
3435 sl_strlcpy(timestr, sh_unix_time(theFile->mtime), 81);
3436 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LIST,
3437 theFile->c_mode,
3438 theFile->hardlinks,
3439 theFile->c_owner,
3440 theFile->c_group,
3441 (unsigned long) theFile->size,
3442 timestr,
3443 tmp2);
3444 SH_FREE(tmp2);
3445 }
3446
3447 /* --- Check for links. ---
3448 */
3449 if (theFile->c_mode[0] == 'l')
3450 {
3451
3452 linknamebuf = SH_ALLOC(PATH_MAX);
3453
3454 /* flawfinder: ignore */
3455 linksize = readlink (theFile->fullpath, linknamebuf, PATH_MAX-1);
3456
3457 if (linksize < (PATH_MAX-1) && linksize >= 0)
3458 linknamebuf[linksize] = '\0';
3459 else
3460 linknamebuf[PATH_MAX-1] = '\0';
3461
3462 if (linksize < 0)
3463 {
3464 linksize = errno;
3465 tmp2 = sh_util_safe_name (theFile->fullpath);
3466 sh_error_handle (level, FIL__, __LINE__, linksize, MSG_FI_RDLNK,
3467 sh_error_message (linksize), tmp2);
3468 SH_FREE(tmp2);
3469 SH_FREE(linknamebuf);
3470 theFile->linkpath[0] = '-';
3471 theFile->linkpath[1] = '\0';
3472 SL_RETURN((-1),_("sh_unix_getinfo"));
3473 }
3474
3475 if (linknamebuf[0] == '/')
3476 {
3477 sl_strlcpy (theFile->linkpath, linknamebuf, PATH_MAX);
3478 }
3479 else
3480 {
3481 tmp = sh_util_dirname(theFile->fullpath);
3482 sl_strlcpy (theFile->linkpath,
3483 tmp,
3484 PATH_MAX);
3485 SH_FREE(tmp);
3486 sl_strlcat (theFile->linkpath,
3487 "/", PATH_MAX);
3488 sl_strlcat (theFile->linkpath,
3489 linknamebuf,
3490 PATH_MAX);
3491 }
3492
3493 /* stat the link
3494 */
3495 stat_return = retry_lstat (FIL__, __LINE__, theFile->linkpath, &lbuf);
3496
3497 /* check for error
3498 */
3499 if (stat_return != 0)
3500 {
3501 stat_return = errno;
3502 tmp = sh_util_safe_name (theFile->fullpath);
3503 tmp2 = sh_util_safe_name (theFile->linkpath);
3504 if (stat_return != ENOENT)
3505 {
3506 sh_error_handle (level, FIL__, __LINE__, stat_return,
3507 MSG_FI_LSTAT,
3508 sh_error_message (stat_return), tmp2);
3509 }
3510 else
3511 {
3512 /* a dangling link -- everybody seems to have plenty of them
3513 */
3514 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DLNK,
3515 tmp, tmp2);
3516 }
3517 theFile->linkisok = BAD;
3518 SH_FREE(tmp);
3519 SH_FREE(tmp2);
3520 SH_FREE(linknamebuf);
3521 /*
3522 * changed Tue Feb 10 16:16:13 CET 2004:
3523 * add dangling symlinks into database
3524 * SL_RETURN((-1),_("sh_unix_getinfo"));
3525 */
3526 theFile->linkmode = 0;
3527 SL_RETURN((0),_("sh_unix_getinfo"));
3528 }
3529
3530 theFile->linkisok = GOOD;
3531
3532
3533 /* --- Determine file type. ---
3534 */
3535 sh_unix_getinfo_type (&lbuf, &type, theFile->link_c_mode);
3536 theFile->type = type;
3537
3538 /* --- Determine permissions. ---
3539 */
3540 sh_unix_getinfo_mode (&lbuf, &mode, theFile->link_c_mode);
3541 theFile->linkmode = lbuf.st_mode;
3542
3543 /* --- Output the link. ---
3544 */
3545 if (theFile->linkisok == GOOD)
3546 {
3547 tmp2 = sh_util_safe_name (linknamebuf);
3548 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LLNK,
3549 theFile->link_c_mode, tmp2);
3550 SH_FREE(tmp2);
3551 }
3552 SH_FREE(linknamebuf);
3553 }
3554 SL_RETURN((0),_("sh_unix_getinfo"));
3555}
3556
3557/* #if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE) */
3558#endif
3559
3560int sh_unix_unlock (char * lockfile, char * flag);
3561int sh_unix_lock (char * lockfile, char * flag);
3562
3563/* check whether file is locked
3564 */
3565int sh_unix_test_and_lock (char * filename, char * lockfile)
3566{
3567 static struct stat buf;
3568 int status = 0;
3569
3570
3571 SL_TICKET fd;
3572 char line_in[128];
3573
3574 SL_ENTER(_("sh_unix_test_and_lock"));
3575
3576 status = retry_lstat (FIL__, __LINE__, lockfile, &buf);
3577
3578 /* --- No lock file found, try to lock. ---
3579 */
3580
3581 if (status < 0 && errno == ENOENT)
3582 {
3583 if (0 == sh_unix_lock (lockfile, filename))
3584 {
3585 if (filename != NULL)
3586 sh.flag.islocked = GOOD;
3587 SL_RETURN((0),_("sh_unix_test_and_lock"));
3588 }
3589 else
3590 {
3591 sh_error_handle ((-1), FIL__, __LINE__, status,
3592 MSG_E_SUBGEN,
3593 (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
3594 _("sh_unix_test_and_lock"));
3595 SL_RETURN((-1),_("sh_unix_test_and_lock"));
3596 }
3597 }
3598 else if (status == 0 && buf.st_size == 0)
3599 {
3600 if (filename != NULL)
3601 sh.flag.islocked = GOOD;
3602 sh_unix_unlock (lockfile, filename);
3603 if (filename != NULL)
3604 sh.flag.islocked = BAD;
3605 if (0 == sh_unix_lock (lockfile, filename))
3606 {
3607 if (filename != NULL)
3608 sh.flag.islocked = GOOD;
3609 SL_RETURN((0),_("sh_unix_test_and_lock"));
3610 }
3611 else
3612 {
3613 sh_error_handle ((-1), FIL__, __LINE__, status,
3614 MSG_E_SUBGEN,
3615 (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
3616 _("sh_unix_test_and_lock"));
3617 SL_RETURN((-1),_("sh_unix_test_and_lock"));
3618 }
3619 }
3620
3621 /* --- Check on lock. ---
3622 */
3623
3624 if (status >= 0)
3625 {
3626 fd = sl_open_read (lockfile, SL_YESPRIV);
3627 if (SL_ISERROR(fd))
3628 sh_error_handle ((-1), FIL__, __LINE__, fd,
3629 MSG_E_SUBGEN,
3630 (filename == NULL) ? _("Cannot open PID file for read") : _("Cannot open lock file for read"),
3631 _("sh_unix_test_and_lock"));
3632 }
3633 else
3634 fd = -1;
3635
3636 if (!SL_ISERROR(fd))
3637 {
3638 /* read the PID in the lock file
3639 */
3640 status = sl_read (fd, line_in, sizeof(line_in));
3641 line_in[sizeof(line_in)-1] = '\0';
3642
3643 /* convert to numeric
3644 */
3645 if (status > 0)
3646 {
3647 errno = 0;
3648 status = strtol(line_in, (char **)NULL, 10);
3649 if (errno == ERANGE || status <= 0)
3650 {
3651 sh_error_handle ((-1), FIL__, __LINE__, status,
3652 MSG_E_SUBGEN,
3653 (filename == NULL) ? _("Bad PID in PID file") : _("Bad PID in lock file"),
3654 _("sh_unix_test_and_lock"));
3655
3656 status = -1;
3657 }
3658 }
3659 else
3660 {
3661 sh_error_handle ((-1), FIL__, __LINE__, status,
3662 MSG_E_SUBGEN,
3663 (filename == NULL) ? _("Cannot read PID file") : _("Cannot read lock file"),
3664 _("sh_unix_test_and_lock"));
3665 }
3666 sl_close(fd);
3667
3668 if (status == (int) getpid())
3669 {
3670 if (filename != NULL)
3671 sh.flag.islocked = GOOD;
3672 SL_RETURN((0),_("sh_unix_test_and_lock"));
3673 }
3674
3675
3676 /* --- Check whether the process exists. ---
3677 */
3678 if (status > 0)
3679 {
3680 errno = 0;
3681 status = aud_kill (FIL__, __LINE__, status, 0);
3682
3683 /* Does not exist, so remove the stale lock
3684 * and create a new one.
3685 */
3686 if (status < 0 && errno == ESRCH)
3687 {
3688 if (filename != NULL)
3689 sh.flag.islocked = GOOD;
3690 if (0 != sh_unix_unlock(lockfile, filename) && (filename !=NULL))
3691 sh.flag.islocked = BAD;
3692 else
3693 {
3694 if (0 == sh_unix_lock (lockfile, filename))
3695 {
3696 if (filename != NULL)
3697 sh.flag.islocked = GOOD;
3698 SL_RETURN((0),_("sh_unix_test_and_lock"));
3699 }
3700 else
3701 {
3702 sh_error_handle ((-1), FIL__, __LINE__, status,
3703 MSG_E_SUBGEN,
3704 (filename == NULL) ? _("Cannot create PID file") : _("Cannot create lock file"),
3705 _("sh_unix_test_and_lock"));
3706 }
3707 if (filename != NULL)
3708 sh.flag.islocked = BAD;
3709 }
3710 }
3711 else
3712 {
3713 sh_error_handle ((-1), FIL__, __LINE__, status,
3714 MSG_E_SUBGEN,
3715 (filename == NULL) ? _("Cannot remove stale PID file, PID may be a running process") : _("Cannot remove stale lock file, PID may be a running process"),
3716 _("sh_unix_test_and_lock"));
3717 if (filename != NULL)
3718 sh.flag.islocked = BAD;
3719 }
3720 }
3721 }
3722 SL_RETURN((-1),_("sh_unix_testlock"));
3723}
3724
3725/* write the PID file
3726 */
3727int sh_unix_write_pid_file()
3728{
3729 return sh_unix_test_and_lock(NULL, sh.srvlog.alt);
3730}
3731
3732/* write lock for filename
3733 */
3734int sh_unix_write_lock_file(char * filename)
3735{
3736 size_t len;
3737 int res;
3738 char * lockfile;
3739
3740 if (filename == NULL)
3741 return (-1);
3742
3743 len = sl_strlen(filename);
3744 if (sl_ok_adds(len, 6))
3745 len += 6;
3746 lockfile = SH_ALLOC(len);
3747 sl_strlcpy(lockfile, filename, len);
3748 sl_strlcat(lockfile, _(".lock"), len);
3749 res = sh_unix_test_and_lock(filename, lockfile);
3750 SH_FREE(lockfile);
3751 return res;
3752}
3753
3754int sh_unix_unlock(char * lockfile, char * flag)
3755{
3756 int error = 0;
3757
3758 SL_ENTER(_("sh_unix_unlock"));
3759
3760 /* --- Logfile is not locked to us. ---
3761 */
3762 if (sh.flag.islocked == BAD && flag != NULL)
3763 SL_RETURN((-1),_("sh_unix_unlock"));
3764
3765 /* --- Check whether the directory is secure. ---
3766 */
3767 if (0 != tf_trust_check (lockfile, SL_YESPRIV))
3768 SL_RETURN((-1),_("sh_unix_unlock"));
3769
3770 /* --- Delete the lock file. ---
3771 */
3772 error = retry_aud_unlink (FIL__, __LINE__, lockfile);
3773
3774 if (error == 0)
3775 {
3776 if (flag != NULL)
3777 sh.flag.islocked = BAD; /* not locked anymore */
3778 }
3779 else if (flag != NULL)
3780 {
3781 error = errno;
3782 sh_error_handle ((-1), FIL__, __LINE__, error, MSG_E_UNLNK,
3783 sh_error_message(error), lockfile);
3784 SL_RETURN((-1),_("sh_unix_unlock"));
3785 }
3786 SL_RETURN((0),_("sh_unix_unlock"));
3787}
3788
3789/* rm lock for filename
3790 */
3791int sh_unix_rm_lock_file(char * filename)
3792{
3793 size_t len;
3794 int res;
3795 char * lockfile;
3796
3797 if (filename == NULL)
3798 return (-1);
3799
3800 len = sl_strlen(filename);
3801 if (sl_ok_adds(len, 6))
3802 len += 6;
3803 lockfile = SH_ALLOC(len);
3804 sl_strlcpy(lockfile, filename, len);
3805 sl_strlcat(lockfile, _(".lock"), len);
3806
3807 res = sh_unix_unlock(lockfile, filename);
3808 SH_FREE(lockfile);
3809 return res;
3810}
3811
3812/* rm lock for filename
3813 */
3814int sh_unix_rm_pid_file()
3815{
3816 return sh_unix_unlock(sh.srvlog.alt, NULL);
3817}
3818
3819int sh_unix_lock (char * lockfile, char * flag)
3820{
3821 int filed;
3822 int errnum;
3823 char myPid[64];
3824 SL_TICKET fd;
3825 extern int get_the_fd (SL_TICKET ticket);
3826
3827 SL_ENTER(_("sh_unix_lock"));
3828
3829 sprintf (myPid, "%ld\n", (long) getpid()); /* known to fit */
3830
3831 fd = sl_open_safe_rdwr (lockfile, SL_YESPRIV); /* fails if file exists */
3832
3833 if (!SL_ISERROR(fd))
3834 {
3835 errnum = sl_write (fd, myPid, sl_strlen(myPid));
3836 filed = get_the_fd(fd);
3837 fchmod (filed, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
3838 sl_close (fd);
3839
3840 if (!SL_ISERROR(errnum))
3841 {
3842 if (flag != NULL)
3843 sh.flag.islocked = GOOD;
3844 SL_RETURN((0),_("sh_unix_lock"));
3845 }
3846 }
3847
3848 TPT((0, FIL__, __LINE__, _("msg=<open pid file failed>\n")));
3849 if (flag != NULL)
3850 sh.flag.islocked = BAD;
3851 SL_RETURN((-1),_("sh_unix_lock"));
3852
3853 /* notreached */
3854}
3855
3856/* Test whether file exists
3857 */
3858int sh_unix_file_exists(char * path)
3859{
3860 struct stat buf;
3861
3862 SL_ENTER(_("sh_unix_file_exists"));
3863
3864 if (-1 == retry_stat(FIL__, __LINE__, path, &buf))
3865 SL_RETURN( S_FALSE, _("sh_unix_file_exists"));
3866 else
3867 SL_RETURN( S_TRUE, _("sh_unix_file_exists"));
3868}
3869
3870
3871/* Test whether file exists, is a character device, and allows read
3872 * access.
3873 */
3874int sh_unix_device_readable(int fd)
3875{
3876 struct stat buf;
3877
3878 SL_ENTER(_("sh_unix_device_readable"));
3879
3880 if (retry_fstat(FIL__, __LINE__, fd, &buf) == -1)
3881 SL_RETURN( (-1), _("sh_unix_device_readable"));
3882 else if ( S_ISCHR(buf.st_mode) && 0 != (S_IROTH & buf.st_mode) )
3883 SL_RETURN( (0), _("sh_unix_device_readable"));
3884 else
3885 SL_RETURN( (-1), _("sh_unix_device_readable"));
3886}
3887
3888static char preq[16];
3889
3890/* return true if database is remote
3891 */
3892int file_is_remote ()
3893{
3894 static int init = 0;
3895 struct stat buf;
3896
3897 SL_ENTER(_("file_is_remote"));
3898
3899 if (init == 0)
3900 {
3901 sl_strlcpy(preq, _("REQ_FROM_SERVER"), 16);
3902 ++init;
3903 }
3904 if (0 == sl_strncmp (sh.data.path, preq, 15))
3905 {
3906 if (sh.data.path[15] != '\0') /* should be start of path */
3907 {
3908 if (0 == stat(&(sh.data.path[15]), &buf))
3909 {
3910 SL_RETURN( S_FALSE, _("file_is_remote"));
3911 }
3912 }
3913 SL_RETURN( S_TRUE, _("file_is_remote"));
3914 }
3915 SL_RETURN( S_FALSE, _("file_is_remote"));
3916}
3917
3918/* Return the path to the configuration/database file.
3919 */
3920char * file_path(char what, char flag)
3921{
3922 static int init = 0;
3923
3924 SL_ENTER(_("file_path"));
3925
3926 if (init == 0)
3927 {
3928 sl_strlcpy(preq, _("REQ_FROM_SERVER"), 16);
3929 ++init;
3930 }
3931
3932 switch (what)
3933 {
3934
3935 case 'C':
3936 if (0 == sl_strncmp (sh.conf.path, preq, 15))
3937 {
3938#if defined(SH_WITH_SERVER)
3939 if (sh.flag.isserver == S_TRUE && sl_strlen(sh.conf.path) == 15)
3940 SL_RETURN( NULL, _("file_path"));
3941 if (sh.flag.isserver == S_TRUE)
3942 SL_RETURN( &(sh.conf.path[15]), _("file_path"));
3943#endif
3944 if (flag == 'R')
3945 SL_RETURN( preq, _("file_path"));
3946 if (flag == 'I')
3947 {
3948 if (sl_strlen(sh.conf.path) == 15)
3949 SL_RETURN( NULL, _("file_path"));
3950 else
3951 SL_RETURN( &(sh.conf.path[15]), _("file_path"));
3952 }
3953 SL_RETURN ( preq, _("file_path"));
3954 }
3955 else
3956 SL_RETURN( sh.conf.path, _("file_path"));
3957 /* break; *//* unreachable */
3958
3959 case 'D':
3960 if (0 == sl_strncmp (sh.data.path, preq, 15))
3961 {
3962 if (flag == 'R')
3963 SL_RETURN( preq, _("file_path"));
3964 if (flag == 'W' && sl_strlen(sh.data.path) == 15)
3965 SL_RETURN (NULL, _("file_path"));
3966 if (flag == 'W')
3967 SL_RETURN( &(sh.data.path[15]), _("file_path"));
3968 }
3969 else
3970 SL_RETURN( sh.data.path, _("file_path"));
3971 break;
3972
3973 default:
3974 SL_RETURN( NULL, _("file_path"));
3975 }
3976
3977 return NULL; /* notreached */
3978}
3979/************************************************/
3980/**** Mlock Utilities ****/
3981/************************************************/
3982
3983#include <limits.h>
3984
3985int sh_unix_pagesize()
3986{
3987 int pagesize = 4096;
3988#if defined(_SC_PAGESIZE)
3989 pagesize = sysconf(_SC_PAGESIZE);
3990#elif defined(_SC_PAGE_SIZE)
3991 pagesize = sysconf(_SC_PAGE_SIZE);
3992#elif defined(HAVE_GETPAGESIZE)
3993 pagesize = getpagesize();
3994#elif defined(PAGESIZE)
3995 pagesize = PAGESIZE;
3996#endif
3997
3998 return ((pagesize > 0) ? pagesize : 4096);
3999}
4000
4001typedef struct sh_page_lt {
4002 unsigned long page_start;
4003 int page_refcount;
4004 char file[64];
4005 int line;
4006 struct sh_page_lt * next;
4007} sh_page_l;
4008
4009sh_page_l * sh_page_locked = NULL;
4010volatile int page_locking = 0;
4011
4012unsigned long sh_unix_lookup_page (void * in_addr, size_t len, int * num_pages)
4013{
4014 int pagesize = sh_unix_pagesize();
4015 unsigned long addr = (unsigned long) in_addr;
4016
4017 unsigned long pagebase;
4018 unsigned long pagediff;
4019 unsigned long pagenum = addr / pagesize;
4020
4021 SL_ENTER(_("sh_unix_lookup_page"));
4022#if 0
4023 fprintf(stderr, "mlock: --> base %ld, pagenum: %ld\n",
4024 addr, pagenum);
4025#endif
4026
4027 /* address of first page
4028 */
4029 pagebase = pagenum * pagesize;
4030
4031 /* number of pages
4032 */
4033 pagediff = (addr + len) - pagebase;
4034 pagenum = pagediff / pagesize;
4035 if (pagenum * pagesize < pagediff)
4036 ++pagenum;
4037
4038#if 0
4039 fprintf(stderr, "mlock: --> pagebase %ld, pagediff %ld, (addr + len) %ld\n",
4040 pagebase, pagediff, (addr + len));
4041#endif
4042
4043 *num_pages = pagenum;
4044 SL_RETURN((pagebase), _("sh_unix_lookup_page"));
4045}
4046
4047
4048#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
4049int sh_unix_mlock (char * file, int line, void * in_addr, size_t len)
4050{
4051 int num_pages;
4052 int status = 0;
4053 int pagesize;
4054 sh_page_l * page_list = sh_page_locked;
4055 unsigned long addr;
4056#ifdef TEST_MLOCK
4057 int i = 0;
4058#endif
4059
4060 SL_ENTER(_("sh_unix_mlock"));
4061
4062 if (0 != page_locking)
4063 {
4064 SL_RETURN((-1), _("sh_unix_mlock"));
4065 }
4066 page_locking = 1;
4067
4068 pagesize = sh_unix_pagesize();
4069 addr = sh_unix_lookup_page (in_addr, len, &num_pages);
4070
4071#ifdef TEST_MLOCK
4072 fprintf(stderr, "mlock: addr %ld, base %ld, pages: %d, length %d\n",
4073 (unsigned long) in_addr, addr, num_pages, len);
4074#endif
4075
4076 /* increase refcount of locked pages
4077 * addr is first page; num_pages is #(consecutive pages) to lock
4078 */
4079 while ((page_list != NULL) && (num_pages > 0))
4080 {
4081#ifdef TEST_MLOCK
4082 fprintf(stderr, "mlock: check page %d: %ld [%d]\n",
4083 i, page_list->page_start, page_list->page_refcount);
4084#endif
4085 if (page_list->page_start == addr)
4086 {
4087 page_list->page_refcount += 1;
4088 num_pages -= 1;
4089 addr += pagesize;
4090#ifdef TEST_MLOCK
4091 fprintf(stderr, "mlock: found page %d: %ld [%d], next page %ld\n",
4092 i, page_list->page_start, page_list->page_refcount, addr);
4093#endif
4094 }
4095#ifdef TEST_MLOCK
4096 ++i;
4097#endif
4098 page_list = page_list->next;
4099 }
4100
4101 /* mlock some more pages, if needed
4102 */
4103 while (num_pages > 0)
4104 {
4105#ifdef TEST_MLOCK
4106 fprintf(stderr, "mlock: lock page %d: mlock %ld [num_pages %d]\n",
4107 i, addr, num_pages);
4108 ++i;
4109#endif
4110 page_list = SH_ALLOC(sizeof(sh_page_l));
4111 page_list->page_start = addr;
4112 page_list->page_refcount = 1;
4113 sl_strlcpy(page_list->file, file, 64);
4114 page_list->line = line;
4115 status = mlock( (void *) addr, pagesize);
4116 if (status != 0)
4117 {
4118#ifdef TEST_MLOCK
4119 fprintf(stderr, "mlock: error: %s\n", sh_error_message(errno));
4120#endif
4121 SH_FREE(page_list);
4122 page_locking = 0;
4123 SL_RETURN((status), _("sh_unix_mlock"));
4124 }
4125 page_list->next = sh_page_locked;
4126 sh_page_locked = page_list;
4127 num_pages -= 1;
4128 addr += pagesize;
4129 }
4130
4131 page_locking = 0;
4132 SL_RETURN((status), _("sh_unix_mlock"));
4133}
4134#else
4135int sh_unix_mlock (char * file, int line, void * in_addr, size_t len)
4136{
4137 (void) file; (void) line;
4138 (void) in_addr; (void) len;
4139 return -1;
4140}
4141#endif
4142
4143#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
4144int sh_unix_munlock (void * in_addr, size_t len)
4145{
4146 int num_pages;
4147 int unlocked = 0;
4148 int status = 0;
4149 int pagesize;
4150 sh_page_l * page_list = sh_page_locked;
4151 sh_page_l * page_last;
4152 unsigned long addr;
4153
4154 int test_count;
4155 int test_status;
4156 int test_pages;
4157
4158#ifdef TEST_MLOCK
4159 int i = 0;
4160#endif
4161
4162 SL_ENTER(_("sh_unix_munlock"));
4163
4164 if (0 != page_locking)
4165 {
4166 SL_RETURN((-1), _("sh_unix_munlock"));
4167 }
4168 page_locking = 1;
4169
4170 pagesize = sh_unix_pagesize();
4171 addr = sh_unix_lookup_page (in_addr, len, &num_pages);
4172
4173#ifdef TEST_MLOCK
4174 fprintf(stderr, "munlock: in_addr %ld, addr %ld, pages: %d, length %d\n",
4175 (unsigned long) in_addr, addr, num_pages, len);
4176#endif
4177
4178 test_pages = num_pages;
4179
4180 /* reduce refcount of locked pages
4181 * addr is first page; num_pages is #(consecutive pages) to lock
4182 */
4183 while ((page_list != NULL) && (num_pages > 0))
4184 {
4185#ifdef TEST_MLOCK
4186 fprintf(stderr, "munlock: page %d: %ld [%d]\n",
4187 i, page_list->page_start, page_list->page_refcount);
4188#endif
4189
4190 test_status = 0;
4191 for (test_count = 0; test_count < test_pages; ++test_count)
4192 {
4193 if (page_list->page_start == (addr + (test_count * pagesize)))
4194 {
4195 test_status = 1;
4196 break;
4197 }
4198 }
4199
4200 if (test_status == 1)
4201 {
4202 page_list->page_refcount -= 1;
4203 if (page_list->page_refcount == 0)
4204 {
4205 status = munlock ( (void *) addr, pagesize);
4206 ++unlocked;
4207 }
4208 num_pages -= 1;
4209#ifdef TEST_MLOCK
4210 fprintf(stderr,
4211 "munlock: page %d: %ld [refcount %d], refcount reduced\n",
4212 i, page_list->page_start, page_list->page_refcount);
4213#endif
4214 }
4215#ifdef TEST_MLOCK
4216 ++i;
4217#endif
4218 page_list = page_list->next;
4219 }
4220
4221#ifdef TEST_MLOCK
4222 i = 0;
4223#endif
4224
4225 if (unlocked > 0)
4226 {
4227 page_list = sh_page_locked;
4228 page_last = sh_page_locked;
4229
4230 while ((page_list != NULL) && (unlocked > 0))
4231 {
4232 if (page_list->page_refcount == 0)
4233 {
4234#ifdef TEST_MLOCK
4235 fprintf(stderr, "munlock: remove page %d: %ld [refcount %d]\n",
4236 i, page_list->page_start, page_list->page_refcount);
4237#endif
4238 if (page_last != page_list)
4239 {
4240 page_last->next = page_list->next;
4241 SH_FREE(page_list);
4242 page_list = page_last->next;
4243 }
4244 else
4245 {
4246 page_last = page_list->next;
4247 if (page_list == sh_page_locked)
4248 sh_page_locked = page_list->next;
4249 SH_FREE(page_list);
4250 page_list = page_last;
4251 }
4252 --unlocked;
4253 }
4254 else
4255 {
4256#ifdef TEST_MLOCK
4257 fprintf(stderr, "munlock: skip page %d: %ld [refcount %d]\n",
4258 i, page_list->page_start, page_list->page_refcount);
4259#endif
4260
4261 page_last = page_list;
4262 page_list = page_list->next;
4263 }
4264#ifdef TEST_MLOCK
4265 ++i;
4266#endif
4267 }
4268 }
4269
4270 page_locking = 0;
4271 SL_RETURN((status), _("sh_unix_munlock"));
4272}
4273#else
4274int sh_unix_munlock (void * in_addr, size_t len)
4275{
4276 (void) in_addr; (void) len;
4277 return -1;
4278}
4279#endif
4280
4281int sh_unix_count_mlock()
4282{
4283 int i = 0;
4284 char str[128];
4285 sh_page_l * page_list = sh_page_locked;
4286
4287 SL_ENTER(_("sh_unix_count_mlock"));
4288 while (page_list != NULL)
4289 {
4290#ifdef WITH_TPT
4291 sl_snprintf(str, sizeof(str), _("file: %s line: %d page: %d"),
4292 page_list->file, page_list->line, i+1);
4293 sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, i, MSG_E_SUBGEN,
4294 str, _("sh_unix_count_mlock"));
4295#endif
4296 page_list = page_list->next;
4297 ++i;
4298 }
4299 sl_snprintf(str, sizeof(str), _("%d pages locked"), i);
4300 sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, i, MSG_E_SUBGEN,
4301 str, _("sh_unix_count_mlock"));
4302 SL_RETURN((i), _("sh_unix_count_mlock"));
4303}
4304
4305/************************************************/
4306/************************************************/
4307/**** Stealth Utilities ****/
4308/************************************************/
4309/************************************************/
4310#ifdef SH_STEALTH
4311
4312void sh_unix_xor_code (char * str, int len)
4313{
4314 register int i;
4315
4316 for (i = 0; i < len; ++i) str[i] ^= (char) XOR_CODE;
4317 return;
4318}
4319
4320#if !defined(SH_STEALTH_MICRO)
4321
4322
4323int hideout_hex_block(SL_TICKET fd, unsigned char * str, int len);
4324unsigned long first_hex_block(SL_TICKET fd, unsigned long * max);
4325
4326/*
4327 * --- Get hidden data from a block of hex data. ---
4328 */
4329int sh_unix_getline_stealth (SL_TICKET fd, char * str, int len)
4330{
4331 int add_off, llen;
4332 static unsigned long off_data = 0;
4333 static unsigned long max_data = 0;
4334 static int stealth_init = BAD;
4335
4336 SL_ENTER(_("sh_unix_getline_stealth"));
4337
4338
4339 /* --- Initialize. ---
4340 */
4341 if (stealth_init == BAD)
4342 {
4343 off_data = first_hex_block(fd, &max_data);
4344 if (off_data == 0)
4345 {
4346 dlog(1, FIL__, __LINE__,
4347 _("The stealth config file does not contain any steganographically\nhidden data. This file must be an image file in _uncompressed_\npostscript format.\nTo hide data in it, use:\n samhain_stealth -s postscript_file orig_config_file\n mv postscript_file /path/to/config/file\n"));
4348 sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_P_NODATA,
4349 _("Stealth config file."));
4350 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
4351 }
4352 stealth_init = GOOD;
4353 max_data += off_data;
4354 }
4355
4356 /* --- Seek to proper position. ---
4357 */
4358 if (off_data >= max_data)
4359 {
4360 dlog(1, FIL__, __LINE__,
4361 _("The capacity of the container image file for the stealth config file seems to be too small. Your config file is likely truncated.\n"));
4362 sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_P_NODATA,
4363 _("Stealth config file."));
4364 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
4365 }
4366 sl_seek(fd, off_data);
4367
4368 /* --- Read one line. ---
4369 */
4370 add_off = hideout_hex_block(fd, (unsigned char *) str, len);
4371 off_data += add_off;
4372
4373 llen = sl_strlen(str);
4374 SL_RETURN(llen, _("sh_unix_getline_stealth"));
4375}
4376
4377int hideout_hex_block(SL_TICKET fd, unsigned char * str, int len)
4378{
4379
4380 register int i, j, k;
4381 unsigned char c, e;
4382 register int num;
4383 unsigned char mask[9] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
4384 unsigned long here = 0;
4385 unsigned long retval = 0;
4386
4387 SL_ENTER(_("hideout_hex_block"));
4388
4389 ASSERT_RET((len > 1), _("len > 1"), (0));
4390
4391 --len;
4392
4393 i = 0;
4394 while (i < len)
4395 {
4396 for (j = 0; j < 8; ++j)
4397 {
4398
4399 /* --- Get a low byte, modify, read back. ---
4400 */
4401 for (k = 0; k < 2; ++k)
4402 {
4403 /* -- Skip whitespace. ---
4404 */
4405 c = ' ';
4406 do {
4407 do {
4408 num = sl_read (fd, &c, 1);
4409 } while (num == 0 && errno == EINTR);
4410 if (num == 0)
4411 SL_RETURN((0), _("hideout_hex_block"));
4412 ++here;
4413 } while (c == '\n' || c == '\t' || c == '\r' ||
4414 c == ' ');
4415 }
4416
4417
4418 /* --- e is the value of the low byte. ---
4419 */
4420 e = (unsigned char) sh_util_hexchar( c );
4421 if ((e & mask[7]) != 0) /* bit is set */
4422 str[i] |= mask[j];
4423 else /* bit is not set */
4424 str[i] &= ~mask[j];
4425
4426 }
4427 if (str[i] == '\n') break;
4428 ++i;
4429 }
4430
4431 if (i != 0)
4432 str[i] = '\0';
4433 else
4434 str[i+1] = '\0'; /* keep newline and terminate */
4435 retval += here;
4436
4437 SL_RETURN(retval, _("hideout_hex_block"));
4438}
4439
4440/* --- Get offset of first data block. ---
4441 */
4442unsigned long first_hex_block(SL_TICKET fd, unsigned long * max)
4443{
4444 unsigned int i;
4445 long num = 1;
4446 unsigned long lnum;
4447 char c;
4448 int nothex = 0;
4449 unsigned long retval = 0;
4450 unsigned int this_line = 0;
4451 char theline[SH_BUFSIZE];
4452
4453 SL_ENTER(_("first_hex_block"));
4454
4455 *max = 0;
4456
4457 while (1)
4458 {
4459 theline[0] = '\0';
4460 this_line = 0;
4461 c = '\0';
4462 while (c != '\n' && num > 0 && this_line < (sizeof(theline)-1))
4463 {
4464 do {
4465 num = sl_read (fd, &c, 1);
4466 } while (num == 0 && errno == EINTR);
4467 if (num > 0)
4468 theline[this_line] = c;
4469 else
4470 SL_RETURN((0), _("first_hex_block"));
4471 ++this_line;
4472 }
4473 theline[this_line] = '\0';
4474
4475 /* not only 'newline' */
4476 if (this_line > 60)
4477 {
4478 nothex = 0;
4479 i = 0;
4480 while (nothex == 0 && i < (this_line-1))
4481 {
4482 if (! isxdigit((int)theline[i])) nothex = 1;
4483 ++i;
4484 }
4485 if (nothex == 1) retval += this_line;
4486 }
4487 else
4488 {
4489 nothex = 1;
4490 retval += this_line;
4491 }
4492
4493 if (nothex == 0)
4494 {
4495 *max = 0;
4496 do {
4497 do {
4498 num = sl_read (fd, theline, SH_BUFSIZE);
4499 } while (num == 0 && errno == EINTR);
4500 if (num > 0)
4501 {
4502 lnum = (unsigned long) num;
4503 for (i = 0; i < lnum; ++i)
4504 {
4505 c = theline[i];
4506 if (c == '\n' || c == '\t' || c == '\r' || c == ' ')
4507 ;
4508 else if (!isxdigit((int)c))
4509 break;
4510 else
4511 *max += 1;
4512 }
4513 }
4514 } while (num > 0);
4515
4516 *max /= 16;
4517 SL_RETURN((retval), _("first_hex_block"));
4518 }
4519
4520 }
4521 /* SL_RETURN((0), _("first_hex_block")); *//* unreachable */
4522}
4523
4524 /* if !defined(SH_STEALTH_MICRO) */
4525#endif
4526
4527 /* ifdef SH_STEALTH */
4528#endif
4529
4530/*
4531 * anti-debugger code
4532 */
4533#if defined(SCREW_IT_UP)
4534volatile int sh_not_traced = 0;
4535
4536#ifdef HAVE_GETTIMEOFDAY
4537struct timeval save_tv;
4538#endif
4539
4540void sh_sigtrap_handler (int signum)
4541{
4542#ifdef HAVE_GETTIMEOFDAY
4543 struct timeval tv;
4544 long difftv;
4545
4546 gettimeofday(&tv, NULL);
4547 difftv = (tv.tv_sec - save_tv.tv_sec) * 1000000 +
4548 (tv.tv_usec - save_tv.tv_usec);
4549 if (difftv > 500000)
4550 _exit(6);
4551#endif
4552 sh_not_traced += signum;
4553 return;
4554}
4555#endif
Note: See TracBrowser for help on using the repository browser.