Context Navigation

sh_unix.c@ 580

Last change on this file since 580 was 580, checked in by katerina, 11 months ago
Fix for ticket #468 (file attributes). Also add option to switch off check.
File size: 134.2 KB

Rev	Line
[1]	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>
[98]	27	#ifdef HAVE_LINUX_FS_H
	28	#include <linux/fs.h>
	29	#endif
[1]	30
	31	#ifdef HAVE_MEMORY_H
	32	#include <memory.h>
	33	#endif
	34
	35	#ifdef HAVE_UNISTD_H
	36	#include <errno.h>
	37	#include <signal.h>
	38	#include <pwd.h>
	39	#include <grp.h>
	40	#include <sys/types.h>
	41	#include <sys/stat.h>
	42	#include <sys/resource.h>
	43	#include <fcntl.h>
	44	#include <unistd.h>
[169]	45	/* need to undef these, since the #define's may be picked up from
	46	* linux/wait.h, and will clash with a typedef in sys/wait.h
	47	*/
	48	#undef P_ALL
	49	#undef P_PID
	50	#undef P_PGID
[1]	51	#include <sys/wait.h>
	52
	53	/*********************
	54	#ifdef HAVE_SYS_VFS_H
	55	#include <sys/vfs.h>
	56	#endif
	57	**********************/
	58	#endif
	59
	60	#if TIME_WITH_SYS_TIME
	61	#include <sys/time.h>
	62	#include <time.h>
	63	#else
	64	#if HAVE_SYS_TIME_H
	65	#include <sys/time.h>
	66	#else
	67	#include <time.h>
	68	#endif
	69	#endif
	70
	71	#ifdef HAVE_SYS_SELECT_H
	72	#include <sys/select.h>
	73	#endif
	74
	75	#ifndef FD_SET
	76	#define NFDBITS 32
	77	#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] \|= (1 << ((n) % NFDBITS)))
	78	#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
	79	#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
	80	#endif /* !FD_SET */
	81	#ifndef FD_SETSIZE
	82	#define FD_SETSIZE 32
	83	#endif
	84	#ifndef FD_ZERO
[541]	85	#define FD_ZERO(p) memset((char )(p), 0, sizeof((p)))
[1]	86	#endif
	87
	88
	89	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
	90	#include <sys/mman.h>
	91	#endif
	92
	93	#include "samhain.h"
	94	#include "sh_error.h"
	95	#include "sh_unix.h"
	96	#include "sh_utils.h"
	97	#include "sh_mem.h"
	98	#include "sh_hash.h"
	99	#include "sh_tools.h"
[310]	100	#include "sh_restrict.h"
[295]	101	#include "sh_ipvx.h"
[1]	102	#include "sh_tiger.h"
	103	#include "sh_prelink.h"
[137]	104	#include "sh_pthread.h"
[481]	105	#include "sh_sem.h"
[1]	106
	107	/* moved here from far below
	108	*/
	109	#include <netdb.h>
	110
	111	#define SH_NEED_PWD_GRP
	112	#define SH_NEED_GETHOSTBYXXX
	113	#include "sh_static.h"
	114
	115	#ifndef HAVE_LSTAT
	116	#define lstat stat
	117	#endif
	118
	119	#if defined(S_IFLNK) && !defined(S_ISLNK)
	120	#define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
	121	#else
	122	#if !defined(S_ISLNK)
	123	#define S_ISLNK(mode) (0)
	124	#endif
	125	#endif
	126
	127	#if defined(S_IFSOCK) && !defined(S_ISSOCK)
	128	#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
	129	#else
	130	#if !defined(S_ISSOCK)
	131	#define S_ISSOCK(mode) (0)
	132	#endif
	133	#endif
	134
[40]	135	#if defined(S_IFDOOR) && !defined(S_ISDOOR)
	136	#define S_ISDOOR(mode) (((mode) & S_IFMT) == S_IFDOOR)
	137	#else
	138	#if !defined(S_ISDOOR)
	139	#define S_ISDOOR(mode) (0)
	140	#endif
	141	#endif
	142
	143	#if defined(S_IFPORT) && !defined(S_ISPORT)
	144	#define S_ISPORT(mode) (((mode) & S_IFMT) == S_IFPORT)
	145	#else
	146	#if !defined(S_ISPORT)
	147	#define S_ISPORT(mode) (0)
	148	#endif
	149	#endif
	150
[105]	151	#define SH_KEY_NULL _("000000000000000000000000000000000000000000000000")
[40]	152
[1]	153	#undef FIL__
	154	#define FIL__ _("sh_unix.c")
	155
	156	unsigned long mask_PRELINK = MASK_PRELINK_;
	157	unsigned long mask_USER0 = MASK_USER_;
	158	unsigned long mask_USER1 = MASK_USER_;
[27]	159	unsigned long mask_USER2 = MASK_USER_;
	160	unsigned long mask_USER3 = MASK_USER_;
	161	unsigned long mask_USER4 = MASK_USER_;
[1]	162	unsigned long mask_ALLIGNORE = MASK_ALLIGNORE_;
	163	unsigned long mask_ATTRIBUTES = MASK_ATTRIBUTES_;
	164	unsigned long mask_LOGFILES = MASK_LOGFILES_;
	165	unsigned long mask_LOGGROW = MASK_LOGGROW_;
	166	unsigned long mask_READONLY = MASK_READONLY_;
	167	unsigned long mask_NOIGNORE = MASK_NOIGNORE_;
	168
	169
	170	extern char **environ;
	171
	172	int sh_unix_maskreset()
	173	{
	174	mask_PRELINK = MASK_PRELINK_;
	175	mask_USER0 = MASK_USER_;
	176	mask_USER1 = MASK_USER_;
[27]	177	mask_USER2 = MASK_USER_;
	178	mask_USER3 = MASK_USER_;
	179	mask_USER4 = MASK_USER_;
[1]	180	mask_ALLIGNORE = MASK_ALLIGNORE_;
	181	mask_ATTRIBUTES = MASK_ATTRIBUTES_;
	182	mask_LOGFILES = MASK_LOGFILES_;
	183	mask_LOGGROW = MASK_LOGGROW_;
	184	mask_READONLY = MASK_READONLY_;
	185	mask_NOIGNORE = MASK_NOIGNORE_;
	186	return 0;
	187	}
	188
	189
	190	#ifdef SYS_SIGLIST_DECLARED
	191	/* extern const char * const sys_siglist[]; */
	192	#else
	193	char * sh_unix_siglist (int signum)
	194	{
	195	switch (signum)
	196	{
	197	#ifdef SIGHUP
	198	case SIGHUP:
	199	return _("Hangup");
	200	#endif
	201	#ifdef SIGINT
	202	case SIGINT:
	203	return _("Interrupt");
	204	#endif
	205	#ifdef SIGQUIT
	206	case SIGQUIT:
	207	return _("Quit");
	208	#endif
	209	#ifdef SIGILL
	210	case SIGILL:
	211	return _("Illegal instruction");
	212	#endif
	213	#ifdef SIGTRAP
	214	case SIGTRAP:
	215	return _("Trace/breakpoint trap");
	216	#endif
	217	#ifdef SIGABRT
	218	case SIGABRT:
	219	return _("IOT trap/Abort");
	220	#endif
	221	#ifdef SIGBUS
	222	case SIGBUS:
	223	return _("Bus error");
	224	#endif
	225	#ifdef SIGFPE
	226	case SIGFPE:
	227	return _("Floating point exception");
	228	#endif
	229	#ifdef SIGUSR1
	230	case SIGUSR1:
	231	return _("User defined signal 1");
	232	#endif
	233	#ifdef SIGSEGV
	234	case SIGSEGV:
	235	return _("Segmentation fault");
	236	#endif
	237	#ifdef SIGUSR2
	238	case SIGUSR2:
	239	return _("User defined signal 2");
	240	#endif
	241	#ifdef SIGPIPE
	242	case SIGPIPE:
	243	return _("Broken pipe");
	244	#endif
	245	#ifdef SIGALRM
	246	case SIGALRM:
	247	return _("Alarm clock");
	248	#endif
	249	#ifdef SIGTERM
	250	case SIGTERM:
	251	return _("Terminated");
	252	#endif
	253	#ifdef SIGSTKFLT
	254	case SIGSTKFLT:
	255	return _("Stack fault");
	256	#endif
	257	#ifdef SIGCHLD
	258	case SIGCHLD:
	259	return _("Child exited");
	260	#endif
	261	#ifdef SIGCONT
	262	case SIGCONT:
	263	return _("Continued");
	264	#endif
	265	#ifdef SIGSTOP
	266	case SIGSTOP:
	267	return _("Stopped");
	268	#endif
	269	#ifdef SIGTSTP
	270	case SIGTSTP:
	271	return _("Stop typed at tty");
	272	#endif
	273	#ifdef SIGTTIN
	274	case SIGTTIN:
	275	return _("Stopped (tty input)");
	276	#endif
	277	#ifdef SIGTTOU
	278	case SIGTTOU:
	279	return _("Stopped (tty output)");
	280	#endif
	281	#ifdef SIGURG
	282	case SIGURG:
	283	return _("Urgent condition");
	284	#endif
	285	#ifdef SIGXCPU
	286	case SIGXCPU:
	287	return _("CPU time limit exceeded");
	288	#endif
	289	#ifdef SIGXFSZ
	290	case SIGXFSZ:
	291	return _("File size limit exceeded");
	292	#endif
	293	#ifdef SIGVTALRM
	294	case SIGVTALRM:
	295	return _("Virtual time alarm");
	296	#endif
	297	#ifdef SIGPROF
	298	case SIGPROF:
	299	return _("Profile signal");
	300	#endif
	301	#ifdef SIGWINCH
	302	case SIGWINCH:
	303	return _("Window size changed");
	304	#endif
	305	#ifdef SIGIO
	306	case SIGIO:
	307	return _("Possible I/O");
	308	#endif
	309	#ifdef SIGPWR
	310	case SIGPWR:
	311	return _("Power failure");
	312	#endif
	313	#ifdef SIGUNUSED
	314	case SIGUNUSED:
	315	return _("Unused signal");
	316	#endif
	317	}
	318	return _("Unknown");
	319	}
	320	#endif
	321
	322
	323	/* Log from within a signal handler without using any
	324	* functions that are not async signal safe.
	325	*
	326	* This is the safe_itoa helper function.
	327	*/
	328	char * safe_itoa(int i, char * str, int size)
	329	{
	330	unsigned int u;
	331	int iisneg = 0;
	332	char *p = &str[size-1];
	333
	334	*p = '\0';
	335	if (i < 0) {
	336	iisneg = 1;
	337	u = ((unsigned int)(-(1+i))) + 1;
	338	} else {
	339	u = i;
	340	}
	341	do {
	342	--p;
	343	*p = '0' + (u % 10);
	344	u /= 10;
[22]	345	} while (u && (p != str));
	346	if ((iisneg == 1) && (p != str)) {
[1]	347	--p;
	348	*p = '-';
	349	}
	350	return p;
	351	}
	352
	353	/* Log from within a signal handler without using any
	354	* functions that are not async signal safe.
	355	*
	356	* This is the safe_logger function.
	357	* Arguments: signal (signal number), method (0=logger, 1=stderr), thepid (pid)
	358	*/
	359	extern int OnlyStderr;
	360
[170]	361	int safe_logger (int thesignal, int method, char * details)
[1]	362	{
[34]	363	unsigned int i = 0;
[1]	364	int status = -1;
	365	struct stat buf;
	366	pid_t newpid;
	367	char str[128];
	368	char * p;
[22]	369
[1]	370	char l0[64], l1[64], l2[64], l3[64];
[486]	371	char a0[32];
[1]	372	char e0[128];
	373	char msg[128];
[22]	374
[1]	375	char * locations[] = { NULL, NULL, NULL, NULL, NULL };
	376	char * envp[] = { NULL, NULL };
[486]	377	char * argp[] = { NULL, NULL, NULL };
[22]	378
	379	pid_t thepid = getpid();
	380
[1]	381	if ((sh.flag.isdaemon == S_FALSE) \|\| (OnlyStderr == S_TRUE))
	382	method = 1;
[22]	383
[1]	384	/* seems that solaris cc needs this way of initializing ...
	385	*/
	386	locations[0] = l0;
	387	locations[1] = l1;
	388	locations[2] = l2;
	389	locations[3] = l3;
[22]	390
[1]	391	envp[0] = e0;
	392	argp[0] = a0;
[22]	393
[1]	394	sl_strlcpy(msg, _("samhain["), 128);
	395	p = safe_itoa((int) thepid, str, 128);
	396	if (p && *p)
	397	sl_strlcat(msg, p, 128);
[170]	398	if (thesignal == 0)
[1]	399	{
[22]	400	if (details == NULL) {
	401	sl_strlcat(msg, _("]: out of memory"), 128);
	402	} else {
	403	sl_strlcat(msg, _("]: "), 128);
	404	sl_strlcat(msg, details, 128);
	405	}
[1]	406	}
	407	else
	408	{
	409	sl_strlcat(msg, _("]: exit on signal "), 128);
[170]	410	p = safe_itoa(thesignal, str, 128);
[1]	411	if (p && *p)
	412	sl_strlcat(msg, p, 128);
	413	}
	414
	415	if (method == 1) {
	416	#ifndef STDERR_FILENO
	417	#define STDERR_FILENO 2
	418	#endif
[153]	419	int retval = 0;
	420	do {
	421	retval = write(STDERR_FILENO, msg, strlen(msg));
	422	} while (retval < 0 && errno == EINTR);
	423	do {
	424	retval = write(STDERR_FILENO, "\n", 1);
	425	} while (retval < 0 && errno == EINTR);
[1]	426	return 0;
	427	}
[22]	428
	429	sl_strlcpy (l0, _("/usr/bin/logger"), 64);
	430	sl_strlcpy (l1, _("/usr/sbin/logger"), 64);
	431	sl_strlcpy (l2, _("/usr/ucb/logger"), 64);
	432	sl_strlcpy (l3, _("/bin/logger"), 64);
	433
	434	sl_strlcpy (a0, _("logger"), 32);
	435	sl_strlcpy (e0,
	436	_("PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/ucb:/usr/local/bin"),
	437	128);
	438
[1]	439	while (locations[i] != NULL) {
	440	status = stat(locations[i], &buf);
	441	if (status == 0)
	442	break;
	443	++i;
	444	}
	445
	446	if (locations[i] != NULL) {
[486]	447	argp[1] = msg;
[1]	448	newpid = fork();
	449	if (newpid == 0) {
	450	execve(locations[i], argp, envp);
	451	_exit(1);
	452	}
	453	else if (newpid > 0) {
	454	waitpid(newpid, &status, WUNTRACED);
	455	}
	456	}
	457	return 0;
	458	}
	459
[170]	460	void safe_fatal (const char * details,
	461	const char * file, int line)
[22]	462	{
	463	char msg[128];
	464	char str[128];
	465	char * p;
[170]	466	int thesignal = 0;
[34]	467	int method = 0;
	468
[22]	469	p = safe_itoa((int) line, str, 128);
	470	sl_strlcpy(msg, _("FATAL: "), 128);
	471	sl_strlcat(msg, file, 128);
	472	sl_strlcat(msg, ": ", 128);
	473	if (p && (*p)) {
	474	sl_strlcat(msg, p , 128);
	475	sl_strlcat(msg, ": ", 128);
	476	}
	477	sl_strlcat(msg, details, 128);
[170]	478	(void) safe_logger (thesignal, method, msg);
[481]	479
	480	close_ipc ();
[205]	481	raise(SIGKILL);
[22]	482	}
[1]	483
	484	extern char sh_sig_msg[64];
	485
	486	volatile int immediate_exit_normal = 0;
	487
	488	#if defined(SA_SIGACTION_WORKS)
	489	static
	490	void sh_unix_sigexit (int mysignal, siginfo_t * signal_info, void * signal_add)
	491	#else
	492	static
	493	void sh_unix_sigexit (int mysignal)
	494	#endif
	495	{
	496
	497	#if defined(SA_SIGACTION_WORKS)
	498	if (signal_info != NULL && signal_info->si_code == SI_USER &&
	499	mysignal != SIGTERM && mysignal != SIGINT)
	500	{
	501	return;
	502	}
	503
	504	/* avoid compiler warning (unused var)
	505	*/
	506	(void) signal_add;
	507	#endif
	508
	509	/*
	510	* Block re-entry
	511	*/
	512	if (immediate_exit_normal > 0)
	513	{
	514	++immediate_exit_normal;
	515	if ((skey != NULL) && (immediate_exit_normal == 2))
[541]	516	memset (skey, 0, sizeof(sh_key_t));
[1]	517	if (immediate_exit_normal == 2)
	518	{
[153]	519	int val_return;
	520
	521	do {
	522	val_return = chdir ("/");
	523	} while (val_return < 0 && errno == EINTR);
	524
[481]	525	close_ipc ();
[22]	526	safe_logger (mysignal, 0, NULL);
[1]	527	}
[205]	528	raise(SIGKILL);
[1]	529	}
	530	else
	531	{
	532	immediate_exit_normal = 1;
	533	}
	534
	535	#ifdef SYS_SIGLIST_DECLARED
	536	strncpy (sh_sig_msg, sys_siglist[mysignal], 40);
	537	#else
	538	strncpy (sh_sig_msg, sh_unix_siglist(mysignal), 40);
	539	#endif
	540	sh_sig_msg[63] = '\0';
	541
	542	++sig_raised;
	543	++sig_urgent;
	544	sig_termfast = 1;
	545	return;
	546	}
	547
	548	volatile int immediate_exit_fast = 0;
	549
	550	#if defined(SA_SIGACTION_WORKS)
	551	static
	552	void sh_unix_sigexit_fast (int mysignal, siginfo_t * signal_info,
	553	void * signal_add)
	554	#else
	555	static
	556	void sh_unix_sigexit_fast (int mysignal)
	557	#endif
	558	{
[172]	559	#if defined(SL_DEBUG) && (defined(USE_SYSTEM_MALLOC) \|\| !defined(USE_MALLOC_LOCK))
[154]	560	int retval;
	561	#endif
	562
[1]	563	#if defined(SA_SIGACTION_WORKS)
	564	if (signal_info != NULL && signal_info->si_code == SI_USER)
	565	{
	566	return;
	567	}
	568	#endif
	569
	570	/* avoid compiler warning (unused var)
	571	*/
	572	#if defined(SA_SIGACTION_WORKS)
	573	(void) signal_add;
	574	#endif
	575
	576	/* Check whether the heap is ok; otherwise _exit
	577	*/
[172]	578	#if !defined(SL_DEBUG) \|\| (!defined(USE_SYSTEM_MALLOC) && defined(USE_MALLOC_LOCK))
[1]	579	++immediate_exit_fast;
	580	if (skey != NULL && immediate_exit_fast < 2)
[541]	581	memset (skey, 0, sizeof(sh_key_t));
[1]	582	if (immediate_exit_fast < 2)
[22]	583	safe_logger (mysignal, 0, NULL);
[205]	584	raise(SIGKILL);
[1]	585	#else
	586
	587	/* debug code
	588	*/
	589	if (immediate_exit_fast == 1)
	590	{
	591	++immediate_exit_fast;
	592	if (skey != NULL)
[541]	593	memset (skey, 0, sizeof(sh_key_t));
[1]	594	close_ipc ();
[22]	595	safe_logger (mysignal, 0, NULL);
[154]	596	do {
	597	retval = chdir ("/");
	598	} while (retval < 0 && errno == EINTR);
[1]	599	raise(SIGFPE);
	600	}
	601	else if (immediate_exit_fast == 2)
	602	{
[154]	603	do {
	604	retval = chdir ("/");
	605	} while (retval < 0 && errno == EINTR);
[1]	606	raise(SIGFPE);
	607	}
	608	else if (immediate_exit_fast != 0)
	609	{
[205]	610	raise(SIGKILL);
[1]	611	}
	612
	613	++immediate_exit_fast;
	614
	615	/* The FPE\|BUS\|SEGV\|ILL signals leave the system in an undefined
	616	* state, thus it is best to exit immediately.
	617	*/
	618	#ifdef SYS_SIGLIST_DECLARED
	619	strncpy (sh_sig_msg, sys_siglist[mysignal], 40);
	620	#else
	621	strncpy (sh_sig_msg, sh_unix_siglist(mysignal), 40);
	622	#endif
[131]	623	sh_sig_msg[63] = '\0';
[1]	624
	625	sl_stack_print();
	626
	627	/* Try to push out an error message.
	628	*/
	629	sh_error_handle ((-1), FIL__, __LINE__, mysignal, MSG_EXIT_NORMAL,
	630	sh.prg_name, sh_sig_msg);
	631
	632	if (skey != NULL)
[541]	633	memset (skey, 0, sizeof(sh_key_t));
[1]	634	close_ipc ();
	635
[154]	636	do {
	637	retval = chdir ("/");
	638	} while (retval < 0 && errno == EINTR);
	639
[1]	640	raise(SIGFPE);
	641	#endif
	642	}
	643
	644
	645	static
	646	void sh_unix_sigaction (int mysignal)
	647	{
	648	++sig_raised;
	649	#ifdef SIGUSR1
	650	if (mysignal == SIGUSR1)
	651	sig_debug_switch = 1;
	652	#endif
	653	#ifdef SIGUSR2
	654	if (mysignal == SIGUSR2)
	655	{
[19]	656	++sig_suspend_switch;
[1]	657	++sig_urgent;
	658	}
	659	#endif
	660	#ifdef SIGHUP
	661	if (mysignal == SIGHUP)
	662	sig_config_read_again = 1;
	663	#endif
	664	#ifdef SIGTTOU
[481]	665	if (mysignal == SIGTTOU) {
	666	sig_force_check = 1; sh_sem_trylock(); }
[1]	667	#endif
[488]	668	#ifdef SIGTSTP
	669	if (mysignal == SIGTSTP) {
	670	sig_force_check = 1; sig_force_silent = 1; sh_sem_trylock(); }
	671	#endif
[279]	672	#ifdef SIGTTIN
	673	if (mysignal == SIGTTIN)
	674	sig_fresh_trail = 1;
	675	#endif
[1]	676	#ifdef SIGABRT
	677	if (mysignal == SIGABRT)
	678	sig_fresh_trail = 1;
	679	#endif
	680	#ifdef SIGQUIT
	681	if (mysignal == SIGQUIT)
[481]	682	sig_terminate = 1;
[1]	683	#endif
	684	#ifdef SIGTERM
	685	if (mysignal == SIGTERM)
	686	{
	687	strncpy (sh_sig_msg, _("Terminated"), 40);
	688	sig_termfast = 1;
	689	++sig_urgent;
	690	}
	691	#endif
	692
	693	return;
	694	}
	695
[379]	696	void sh_unix_ign_sigpipe()
	697	{
	698	struct sigaction ignact;
	699
	700	ignact.sa_handler = SIG_IGN; /* signal action */
	701	sigemptyset( &ignact.sa_mask ); /* set an empty mask */
	702	ignact.sa_flags = 0; /* init sa_flags */
	703
	704	#ifdef SIGPIPE
	705	retry_sigaction(FIL__, __LINE__, SIGPIPE, &ignact, NULL);
	706	#endif
	707
	708	return;
	709	}
[1]	710	static
	711	void sh_unix_siginstall (int goDaemon)
	712	{
	713	struct sigaction act, act_fast, act2, oldact, ignact;
	714	#if defined (SH_WITH_SERVER)
	715	(void) goDaemon;
	716	#endif
	717
	718	SL_ENTER(_("sh_unix_siginstall"));
	719
	720	ignact.sa_handler = SIG_IGN; /* signal action */
	721	sigemptyset( &ignact.sa_mask ); /* set an empty mask */
	722	ignact.sa_flags = 0; /* init sa_flags */
	723
	724	#if defined(SA_SIGACTION_WORKS)
	725	act.sa_sigaction = &sh_unix_sigexit; /* signal action */
	726	#else
	727	act.sa_handler = &sh_unix_sigexit; /* signal action */
	728	#endif
	729
	730	sigfillset ( &act.sa_mask ); /* set a full mask */
	731
	732
	733	/* Block all but deadly signals.
	734	*/
	735	#ifdef SIGILL
	736	sigdelset ( &act.sa_mask, SIGILL );
	737	#endif
	738	#ifndef SL_DEBUG
	739	#ifdef SIGFPE
	740	sigdelset ( &act.sa_mask, SIGFPE );
	741	#endif
	742	#endif
	743	#ifdef SIGSEGV
	744	sigdelset ( &act.sa_mask, SIGSEGV );
	745	#endif
	746	#ifdef SIGBUS
	747	sigdelset ( &act.sa_mask, SIGBUS );
	748	#endif
	749
	750	#if defined(SA_SIGACTION_WORKS)
	751	act_fast.sa_sigaction = &sh_unix_sigexit_fast; /* signal action */
	752	#else
	753	act_fast.sa_handler = &sh_unix_sigexit_fast; /* signal action */
	754	#endif
	755
	756	sigfillset ( &act_fast.sa_mask ); /* set a full mask */
	757
	758	#ifdef SIGILL
	759	sigdelset ( &act_fast.sa_mask, SIGILL );
	760	#endif
	761	#ifndef SL_DEBUG
	762	#ifdef SIGFPE
	763	sigdelset ( &act_fast.sa_mask, SIGFPE );
	764	#endif
	765	#endif
	766	#ifdef SIGSEGV
	767	sigdelset ( &act_fast.sa_mask, SIGSEGV );
	768	#endif
	769	#ifdef SIGBUS
	770	sigdelset ( &act_fast.sa_mask, SIGBUS );
	771	#endif
	772
	773
	774	/* Use siginfo to verify origin of signal, if possible.
	775	*/
	776	#if defined(SA_SIGACTION_WORKS)
	777	act.sa_flags = SA_SIGINFO;
	778	act_fast.sa_flags = SA_SIGINFO;
	779	#else
	780	act.sa_flags = 0;
	781	act_fast.sa_flags = 0;
	782	#endif
	783
	784	/* Do not block the signal from being received in its handler ...
	785	* (is this a good or a bad idea ??).
	786	*/
	787	#if defined(SA_NOMASK)
	788	act_fast.sa_flags \|= SA_NOMASK;
	789	#elif defined(SA_NODEFER)
	790	act_fast.sa_flags \|= SA_NODEFER;
	791	#endif
	792
	793
	794	act2.sa_handler = &sh_unix_sigaction; /* signal action */
	795	sigemptyset( &act2.sa_mask ); /* set an empty mask */
	796	act2.sa_flags = 0; /* init sa_flags */
	797
	798	/* signals to control the daemon */
	799
	800	#ifdef SIGHUP
	801	retry_sigaction(FIL__, __LINE__, SIGHUP, &act2, &oldact);
	802	#endif
	803	#ifdef SIGABRT
	804	retry_sigaction(FIL__, __LINE__, SIGABRT, &act2, &oldact);
	805	#endif
	806	#ifdef SIGUSR1
	807	retry_sigaction(FIL__, __LINE__, SIGUSR1, &act2, &oldact);
	808	#endif
	809	#ifdef SIGUSR2
	810	retry_sigaction(FIL__, __LINE__, SIGUSR2, &act2, &oldact);
	811	#endif
	812	#ifdef SIGQUIT
	813	retry_sigaction(FIL__, __LINE__, SIGQUIT, &act2, &oldact);
	814	#endif
	815	#ifdef SIGTERM
[131]	816	retry_sigaction(FIL__, __LINE__, SIGTERM, &act, &oldact);
[1]	817	#endif
	818
	819	/* fatal signals that may cause termination */
	820
	821	#ifdef SIGILL
	822	retry_sigaction(FIL__, __LINE__, SIGILL, &act_fast, &oldact);
	823	#endif
	824	#ifndef SL_DEBUG
	825	#ifdef SIGFPE
	826	retry_sigaction(FIL__, __LINE__, SIGFPE, &act_fast, &oldact);
	827	#endif
	828	#endif
	829	#ifdef SIGSEGV
	830	retry_sigaction(FIL__, __LINE__, SIGSEGV, &act_fast, &oldact);
	831	#endif
	832	#ifdef SIGBUS
	833	retry_sigaction(FIL__, __LINE__, SIGBUS, &act_fast, &oldact);
	834	#endif
	835
	836	/* other signals */
	837
	838	#ifdef SIGINT
	839	retry_sigaction(FIL__, __LINE__, SIGINT, &act, &oldact);
	840	#endif
	841	#ifdef SIGPIPE
[132]	842	retry_sigaction(FIL__, __LINE__, SIGPIPE, &ignact, &oldact);
[1]	843	#endif
	844	#ifdef SIGALRM
	845	retry_sigaction(FIL__, __LINE__, SIGALRM, &ignact, &oldact);
	846	#endif
[279]	847
[1]	848	#if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE)
	849	#ifdef SIGTTOU
	850	if (goDaemon == 1)
	851	retry_sigaction(FIL__, __LINE__, SIGTTOU, &act2, &oldact);
	852	else
	853	retry_sigaction(FIL__, __LINE__, SIGTTOU, &ignact, &oldact);
	854	#endif
[488]	855	#ifdef SIGTSTP
	856	if (goDaemon == 1)
	857	retry_sigaction(FIL__, __LINE__, SIGTSTP, &act2, &oldact);
	858	else
	859	retry_sigaction(FIL__, __LINE__, SIGTSTP, &ignact, &oldact);
	860	#endif
[279]	861	#ifdef SIGTTIN
	862	if (goDaemon == 1)
	863	retry_sigaction(FIL__, __LINE__, SIGTTIN, &act2, &oldact);
	864	else
	865	retry_sigaction(FIL__, __LINE__, SIGTTIN, &ignact, &oldact);
	866	#endif
[1]	867	#else
[488]	868	#ifdef SIGTSTP
	869	retry_sigaction(FIL__, __LINE__, SIGTSTP, &ignact, &oldact);
	870	#endif
[1]	871	#ifdef SIGTTOU
	872	retry_sigaction(FIL__, __LINE__, SIGTTOU, &ignact, &oldact);
	873	#endif
[279]	874	#ifdef SIGTTIN
	875	retry_sigaction(FIL__, __LINE__, SIGTTIN, &ignact, &oldact);
[1]	876	#endif
[279]	877	#endif
[1]	878
	879	#ifdef SIGTRAP
	880	#if !defined(SCREW_IT_UP)
	881	retry_sigaction(FIL__, __LINE__, SIGTRAP, &act, &oldact);
	882	#endif
	883	#endif
	884
	885	#ifdef SIGPOLL
	886	retry_sigaction(FIL__, __LINE__, SIGPOLL, &ignact, &oldact);
	887	#endif
	888	#if defined(SIGPROF) && !defined(SH_PROFILE)
	889	retry_sigaction(FIL__, __LINE__, SIGPROF, &ignact, &oldact);
	890	#endif
	891	#ifdef SIGSYS
	892	retry_sigaction(FIL__, __LINE__, SIGSYS, &act, &oldact);
	893	#endif
	894	#ifdef SIGURG
	895	retry_sigaction(FIL__, __LINE__, SIGURG, &ignact, &oldact);
	896	#endif
	897	#if defined(SIGVTALRM) && !defined(SH_PROFILE)
	898	retry_sigaction(FIL__, __LINE__, SIGVTALRM, &ignact, &oldact);
	899	#endif
	900	#ifdef SIGXCPU
	901	retry_sigaction(FIL__, __LINE__, SIGXCPU, &act, &oldact);
	902	#endif
	903	#ifdef SIGXFSZ
	904	retry_sigaction(FIL__, __LINE__, SIGXFSZ, &act, &oldact);
	905	#endif
	906
	907	#ifdef SIGEMT
	908	retry_sigaction(FIL__, __LINE__, SIGEMT, &ignact, &oldact);
	909	#endif
	910	#ifdef SIGSTKFLT
	911	retry_sigaction(FIL__, __LINE__, SIGSTKFLT, &act, &oldact);
	912	#endif
	913	#ifdef SIGIO
	914	retry_sigaction(FIL__, __LINE__, SIGIO, &ignact, &oldact);
	915	#endif
	916	#ifdef SIGPWR
	917	retry_sigaction(FIL__, __LINE__, SIGPWR, &act, &oldact);
	918	#endif
	919
	920	#ifdef SIGLOST
	921	retry_sigaction(FIL__, __LINE__, SIGLOST, &ignact, &oldact);
	922	#endif
	923	#ifdef SIGUNUSED
	924	retry_sigaction(FIL__, __LINE__, SIGUNUSED, &ignact, &oldact);
	925	#endif
	926
	927	SL_RET0(_("sh_unix_siginstall"));
	928	}
	929
	930	/* ---------------------------------------------------------------- */
	931
	932	/* checksum the own binary
	933	*/
[22]	934	int sh_unix_self_hash (const char * c)
[1]	935	{
	936	char message[512];
[133]	937	char hashbuf[KEYBUF_SIZE];
[1]	938
	939	SL_ENTER(_("sh_unix_self_hash"));
	940
	941	if (c == NULL)
	942	{
	943	sh.exec.path[0] = '\0';
	944	SL_RETURN((0), _("sh_unix_self_hash"));
	945	}
	946	sl_strlcpy(sh.exec.path, c, SH_PATHBUF);
	947
	948	sl_strlcpy(sh.exec.hash,
[160]	949	sh_tiger_hash (c, TIGER_FILE, TIGER_NOLIM, hashbuf, sizeof(hashbuf)),
[1]	950	KEY_LEN+1);
	951	sl_snprintf(message, 512, _("%s has checksum: %s"),
	952	sh.exec.path, sh.exec.hash);
	953	message[511] = '\0';
	954	sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	955	message, _("sh_unix_self_hash"));
[93]	956	if (0 == sl_strcmp(sh.exec.hash, SH_KEY_NULL ))
[1]	957	{
	958	dlog(1, FIL__, __LINE__,
	959	_("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"),
	960	sh.exec.path, sl_get_errmsg(), (int) sl_ret_euid());
	961	sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_NOACCESS,
	962	(long) sh.real.uid, c);
	963	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	964	}
	965	SL_RETURN((0), _("sh_unix_self_hash"));
	966	}
	967
	968	int sh_unix_self_check ()
	969	{
	970	char newhash[KEY_LEN+1];
	971	char message[512];
[133]	972	char hashbuf[KEYBUF_SIZE];
[1]	973
	974	SL_ENTER(_("sh_unix_self_check"));
[474]	975	if (sh.exec.path[0] == '\0')
[1]	976	SL_RETURN((0), _("sh_unix_self_check"));
	977
[133]	978	sl_strlcpy(newhash,
[160]	979	sh_tiger_hash (sh.exec.path, TIGER_FILE, TIGER_NOLIM, hashbuf, sizeof(hashbuf)),
[133]	980	KEY_LEN+1);
[487]	981	if (0 == sl_strncmp(sh.exec.hash, newhash, KEY_LEN))
	982	{
	983	sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	984	_("Checksum ok"), _("sh_unix_self_check"));
	985	SL_RETURN((0), _("sh_unix_self_check"));
	986	}
[497]	987
	988	if (0 == sl_strncmp(SH_KEY_NULL, newhash, KEY_LEN))
	989	{
	990	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	991	_("Could not read samhain executable"), _("sh_unix_self_check"));
	992	SL_RETURN((0), _("sh_unix_self_check"));
	993	}
[1]	994
	995	dlog(1, FIL__, __LINE__,
	996	_("The checksum of the executable: %s has changed since startup (%s -> %s).\n"),
	997	sh.exec.path, sh.exec.hash, newhash);
	998
	999	sl_snprintf(message, 512,
	1000	_("The checksum of %s has changed since startup (%s -> %s)"),
	1001	sh.exec.path, sh.exec.hash, newhash);
	1002	message[511] = '\0';
	1003
	1004	sh_error_handle(SH_ERR_INFO, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	1005	message, _("sh_unix_self_check"));
	1006	sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_E_AUTH,
	1007	sh.exec.path);
	1008	SL_RETURN((-1), _("sh_unix_self_check"));
	1009	}
	1010
	1011
	1012	/* ---------------------------------------------------------------- */
	1013
[410]	1014	long sh_group_to_gid (const char * g, int * fail)
	1015	{
	1016	struct group * w;
	1017	gid_t gid = 0;
[428]	1018	int status = 0;
[1]	1019
[410]	1020	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1021	struct group grp;
	1022	char * buffer;
[462]	1023	static size_t gbufsize = SH_GRBUF_SIZE;
[410]	1024	#endif
	1025
	1026	*fail = -1;
	1027
	1028	if (g)
	1029	{
	1030	size_t i;
	1031	size_t len = strlen(g);
	1032
	1033	*fail = 0;
	1034
	1035	for (i = 0; i < len; ++i)
	1036	{
	1037	char c = g[i];
	1038
	1039	if (!isdigit((int) c))
	1040	goto is_a_name;
	1041	}
	1042	return atol(g);
	1043
	1044	is_a_name:
	1045
	1046	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
[462]	1047
	1048	buffer = SH_ALLOC(gbufsize);
	1049	status = sh_getgrnam_r(g, &grp, buffer, gbufsize, &w);
	1050
	1051	if ((status == ERANGE) && (w == NULL))
	1052	{
[481]	1053	if (S_TRUE == sl_ok_adds( gbufsize, SH_GRBUF_SIZE ))
[462]	1054	{
	1055	SH_FREE(buffer);
	1056	gbufsize += SH_GRBUF_SIZE;
	1057	goto is_a_name;
	1058	}
	1059	}
	1060
[410]	1061	#else
[462]	1062
[428]	1063	errno = 0;
[410]	1064	w = sh_getgrnam(g);
[428]	1065	status = errno;
[462]	1066
[410]	1067	#endif
	1068
[428]	1069	if ((status == ERANGE) && (w == NULL))
[410]	1070	{
[428]	1071	static int seen = 0;
	1072
	1073	if (seen == 0)
	1074	{
	1075	char errbuf[SH_ERRBUF_SIZE];
	1076
	1077	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
	1078	sh_error_message(status, errbuf, sizeof(errbuf)),
	1079	_("sh_group_to_gid"), (long) -1, _("line too long in group entry"));
	1080	++seen;
	1081	}
	1082	*fail = -1;
	1083	}
	1084	else if (w == NULL)
	1085	{
[410]	1086	char * tmp = sh_util_strdup(g);
	1087	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1088	_("sh_group_to_gid"), tmp);
	1089	SH_FREE(tmp);
	1090	*fail = -1;
	1091	}
	1092	else
	1093	{
	1094	gid = w->gr_gid;
	1095	}
	1096	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1097	SH_FREE(buffer);
	1098	#endif
	1099	}
	1100
	1101	return gid;
	1102	}
	1103
	1104	/* ---------------------------------------------------------------- */
	1105
	1106
[1]	1107	/* added Tue Feb 22 10:36:44 NFT 2000 Rainer Wichmann */
[22]	1108	static int tf_add_trusted_user_int(const char * c)
[1]	1109	{
[137]	1110	struct passwd * w;
[1]	1111	int count;
	1112	uid_t pwid = (uid_t)-1;
	1113
[131]	1114	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1115	struct passwd pwd;
[227]	1116	char * buffer;
[131]	1117	#endif
	1118
[1]	1119	SL_ENTER(_("tf_add_trusted_user_int"));
	1120
	1121	/* First check for a user name.
	1122	*/
[131]	1123	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
[227]	1124	buffer = SH_ALLOC(SH_PWBUF_SIZE);
	1125	sh_getpwnam_r(c, &pwd, buffer, SH_PWBUF_SIZE, &w);
[131]	1126	#else
	1127	w = sh_getpwnam(c);
	1128	#endif
	1129
	1130	if ((w != NULL) && ((pwid = w->pw_uid) > 0))
[1]	1131	goto succe;
	1132
	1133	/* Failed, so check for a numerical value.
	1134	*/
	1135	pwid = strtol(c, (char **)NULL, 10);
	1136	if (pwid > 0 && pwid < 65535)
	1137	goto succe;
	1138
	1139	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1140	_("add trusted user"), c);
[227]	1141	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1142	SH_FREE(buffer);
	1143	#endif
[1]	1144	SL_RETURN((-1), _("tf_add_trusted_user_int"));
	1145
	1146	succe:
	1147	count = sl_trust_add_user(pwid);
[227]	1148	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1149	SH_FREE(buffer);
	1150	#endif
[1]	1151	SL_RETURN((count), _("tf_add_trusted_user_int"));
	1152	}
	1153
[22]	1154	int tf_add_trusted_user(const char * c)
[1]	1155	{
	1156	int i;
	1157	char * q;
	1158	char * p = sh_util_strdup (c);
[131]	1159	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
	1160	char * saveptr;
	1161	#endif
	1162
[1]	1163	SL_ENTER(_("tf_add_trusted_user"));
	1164
[131]	1165	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
	1166	q = strtok_r(p, ", \t", &saveptr);
	1167	#else
[1]	1168	q = strtok(p, ", \t");
[131]	1169	#endif
[1]	1170	if (!q)
	1171	{
	1172	SH_FREE(p);
	1173	SL_RETURN((-1), _("tf_add_trusted_user"));
	1174	}
	1175	while (q)
	1176	{
	1177	i = tf_add_trusted_user_int(q);
	1178	if (SL_ISERROR(i))
	1179	{
	1180	SH_FREE(p);
	1181	SL_RETURN((i), _("tf_add_trusted_user"));
	1182	}
[131]	1183	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
	1184	q = strtok_r(NULL, ", \t", &saveptr);
	1185	#else
[1]	1186	q = strtok(NULL, ", \t");
[131]	1187	#endif
[1]	1188	}
	1189	SH_FREE(p);
	1190	SL_RETURN((0), _("tf_add_trusted_user"));
	1191	}
	1192
[170]	1193	extern uid_t sl_trust_baduid(void);
	1194	extern gid_t sl_trust_badgid(void);
[1]	1195
	1196	#if defined(HOST_IS_CYGWIN) \|\| defined(__cygwin__) \|\| defined(__CYGWIN32__) \|\| defined(__CYGWIN__)
[183]	1197	int tf_trust_check (const char * file, int mode)
[1]	1198	{
	1199	(void) file;
	1200	(void) mode;
	1201	return 0;
	1202	}
	1203	#else
[183]	1204	int tf_trust_check (const char * file, int mode)
[1]	1205	{
	1206	char * tmp;
	1207	char * tmp2;
	1208	char * p;
	1209	int status;
	1210	int level;
[383]	1211	uid_t ff_euid = (uid_t) -1;
[513]	1212	uid_t baduid;
	1213	gid_t badgid;
[1]	1214
	1215	SL_ENTER(_("tf_trust_check"));
	1216
	1217	if (mode == SL_YESPRIV)
	1218	sl_get_euid(&ff_euid);
	1219	else
	1220	sl_get_ruid(&ff_euid);
	1221
	1222	#if defined(SH_WITH_SERVER)
	1223	if (0 == sl_ret_euid()) /* privileges not dropped yet */
	1224	{
[131]	1225	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1226	struct passwd pwd;
[227]	1227	char * buffer = SH_ALLOC(SH_PWBUF_SIZE);
[131]	1228	struct passwd * tempres;
[227]	1229	sh_getpwnam_r(DEFAULT_IDENT, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
[131]	1230	#else
[1]	1231	struct passwd * tempres = sh_getpwnam(DEFAULT_IDENT);
[131]	1232	#endif
[1]	1233
	1234	if (!tempres)
	1235	{
	1236	dlog(1, FIL__, __LINE__,
	1237	_("User %s does not exist. Please add the user to your system.\n"),
	1238	DEFAULT_IDENT);
	1239	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1240	}
[383]	1241	else
	1242	{
	1243	ff_euid = tempres->pw_uid;
	1244	}
[227]	1245	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWNAM_R)
	1246	SH_FREE(buffer);
	1247	#endif
[1]	1248	}
	1249	#endif
	1250
	1251	status = sl_trustfile_euid(file, ff_euid);
	1252
	1253	if ( SL_ENONE != status)
	1254	{
	1255	if (status == SL_ESTAT)
	1256	level = SH_ERR_ALL;
	1257	else
	1258	level = SH_ERR_ERR;
	1259
[513]	1260	tmp = sh_util_safe_name (file);
	1261	p = sh_util_strdup(sl_trust_errfile());
	1262	baduid = sl_trust_baduid();
	1263	badgid = sl_trust_badgid();
	1264
[1]	1265	if (p && *p != '\0')
	1266	{
[513]	1267	tmp2 = sh_util_safe_name (p);
[1]	1268	sh_error_handle(level, FIL__, __LINE__, status, MSG_E_TRUST2,
	1269	sl_error_string(status), tmp, tmp2);
	1270	SH_FREE(tmp2);
	1271	}
	1272	else
	1273	{
	1274	sh_error_handle(level, FIL__, __LINE__, status, MSG_E_TRUST1,
	1275	sl_error_string(status), tmp);
	1276	}
	1277
	1278	if (status == SL_EBADUID \|\| status == SL_EBADGID \|\|
	1279	status == SL_EBADOTH \|\| status == SL_ETRUNC \|\|
	1280	status == SL_EINTERNAL )
	1281	{
	1282	switch (status) {
	1283	case SL_EINTERNAL:
	1284	dlog(1, FIL__, __LINE__,
	1285	_("An internal error occured in the trustfile function.\n"));
	1286	break;
	1287	case SL_ETRUNC:
	1288	dlog(1, FIL__, __LINE__,
	1289	_("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"),
	1290	tmp);
	1291	break;
	1292	case SL_EBADOTH:
	1293	dlog(1, FIL__, __LINE__,
	1294	_("The path element: %s\nin the filename: %s is world writeable.\n"),
[513]	1295	(p) ? p : _("(null)"), tmp);
[1]	1296	break;
	1297	case SL_EBADUID:
	1298	dlog(1, FIL__, __LINE__,
	1299	_("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"),
[513]	1300	(UID_CAST)baduid, (p) ? p : _("(null)"), tmp);
[1]	1301	break;
	1302	case SL_EBADGID:
	1303	dlog(1, FIL__, __LINE__,
	1304	_("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"),
[513]	1305	(p) ? p : _("(null)"), tmp, (UID_CAST)badgid,
	1306	(UID_CAST)baduid);
[1]	1307	break;
	1308	default:
	1309	break;
	1310	}
[513]	1311	SH_FREE(tmp);
	1312	if (p) SH_FREE(p);
[1]	1313	SL_RETURN((-1), _("tf_trust_check"));
	1314	}
[513]	1315	else {
	1316	SH_FREE(tmp);
	1317	if (p) SH_FREE(p);
	1318	}
[1]	1319	}
	1320
	1321	SL_RETURN((0), _("tf_trust_check"));
	1322	}
	1323	#endif
	1324
	1325	#ifdef HAVE_INITGROUPS
	1326	#ifdef HOST_IS_OSF
	1327	int sh_unix_initgroups ( char * in_user, gid_t in_gid)
	1328	#else
	1329	int sh_unix_initgroups (const char * in_user, gid_t in_gid)
	1330	#endif
	1331	{
	1332	int status = -1;
	1333	status = sh_initgroups (in_user, in_gid);
	1334	if (status < 0)
	1335	{
	1336	if (errno == EPERM)
	1337	return 0;
	1338	if (errno == EINVAL)
	1339	return 0;
	1340	return -1;
	1341	}
	1342	return 0;
	1343	}
	1344	#else
	1345	int sh_unix_initgroups (const char * in_user, gid_t in_gid)
	1346	{
	1347	(void) in_user;
	1348	(void) in_gid;
	1349	return 0;
	1350	}
	1351	#endif
	1352
	1353	#ifdef HAVE_INITGROUPS
[132]	1354	char * sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len);
[1]	1355	int sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
	1356	{
	1357	int status = -1;
[132]	1358	char user[SH_MINIBUF];
[1]	1359
	1360	SL_ENTER(_("sh_unix_initgroups2"));
	1361
[132]	1362	if (NULL == sh_unix_getUIDname (SH_ERR_ERR, in_pid, user, sizeof(user)))
[1]	1363	SL_RETURN((-1), _("sh_unix_initgroups2"));
	1364	status = sh_initgroups (user, in_gid);
	1365	if (status < 0)
	1366	{
	1367	if (errno == EPERM)
	1368	status = 0;
	1369	if (errno == EINVAL)
	1370	status = 0;
	1371	}
	1372	SL_RETURN((status), _("sh_unix_initgroups2"));
	1373	}
	1374	#else
	1375	int sh_unix_initgroups2 (uid_t in_pid, gid_t in_gid)
	1376	{
	1377	(void) in_pid;
	1378	(void) in_gid;
	1379	return 0;
	1380	}
	1381	#endif
	1382
[174]	1383	void sh_unix_closeall (int fd, int except, int inchild)
[1]	1384	{
	1385	int fdx = fd;
	1386	#ifdef _SC_OPEN_MAX
	1387	int fdlimit = sysconf (_SC_OPEN_MAX);
	1388	#else
	1389	#ifdef OPEN_MAX
	1390	int fdlimit = OPEN_MAX;
	1391	#else
	1392	int fdlimit = _POSIX_OPEN_MAX;
	1393	#endif
	1394	#endif
	1395
	1396	SL_ENTER(_("sh_unix_closeall"));
	1397
	1398	/* can't happen - so fix it :-(
	1399	*/
	1400	if (fdlimit < 0)
[84]	1401	fdlimit = 20; /* POSIX lower limit */
[1]	1402
	1403	if (fdlimit > 65536)
	1404	fdlimit = 65536;
	1405
[247]	1406	if (!inchild)
	1407	sl_dropall (fdx, except);
	1408	else
	1409	sl_dropall_dirty (fdx, except);
	1410
[1]	1411	/* Close everything from fd (inclusive) up to fdlimit (exclusive).
	1412	*/
	1413	while (fd < fdlimit)
	1414	{
	1415	if (fd == except)
	1416	fd++;
	1417	else if (slib_do_trace != 0 && fd == slib_trace_fd)
	1418	fd++;
	1419	else
[252]	1420	sl_close_fd(FIL__, __LINE__, fd++);
[1]	1421	}
	1422
	1423	SL_RET0(_("sh_unix_closeall"));
	1424	}
	1425
	1426	static void sh_unix_setlimits(void)
	1427	{
	1428	struct rlimit limits;
	1429
	1430	SL_ENTER(_("sh_unix_setlimits"));
	1431
	1432	limits.rlim_cur = RLIM_INFINITY;
	1433	limits.rlim_max = RLIM_INFINITY;
	1434
	1435	#ifdef RLIMIT_CPU
	1436	setrlimit (RLIMIT_CPU, &limits);
	1437	#endif
	1438	#ifdef RLIMIT_FSIZE
	1439	setrlimit (RLIMIT_FSIZE, &limits);
	1440	#endif
	1441	#ifdef RLIMIT_DATA
	1442	setrlimit (RLIMIT_DATA, &limits);
	1443	#endif
	1444	#ifdef RLIMIT_STACK
	1445	setrlimit (RLIMIT_STACK, &limits);
	1446	#endif
	1447	#ifdef RLIMIT_RSS
	1448	setrlimit (RLIMIT_RSS, &limits);
	1449	#endif
	1450	#ifdef RLIMIT_NPROC
	1451	setrlimit (RLIMIT_NPROC, &limits);
	1452	#endif
	1453	#ifdef RLIMIT_MEMLOCK
	1454	setrlimit (RLIMIT_MEMLOCK, &limits);
	1455	#endif
	1456
	1457	#if !defined(SL_DEBUG)
	1458	/* no core dumps
	1459	*/
	1460	limits.rlim_cur = 0;
	1461	limits.rlim_max = 0;
	1462	#ifdef RLIMIT_CORE
	1463	setrlimit (RLIMIT_CORE, &limits);
	1464	#endif
	1465	#else
	1466	#ifdef RLIMIT_CORE
	1467	setrlimit (RLIMIT_CORE, &limits);
	1468	#endif
	1469	#endif
	1470
[8]	1471	limits.rlim_cur = 1024;
	1472	limits.rlim_max = 1024;
[1]	1473
[8]	1474	#if defined(RLIMIT_NOFILE)
	1475	setrlimit (RLIMIT_NOFILE, &limits);
	1476	#elif defined(RLIMIT_OFILE)
	1477	setrlimit (RLIMIT_OFILE, &limits);
	1478	#endif
	1479
[1]	1480	SL_RET0(_("sh_unix_setlimits"));
	1481	}
	1482
	1483	static void sh_unix_copyenv(void)
	1484	{
	1485	char ** env0 = environ;
	1486	char ** env1;
	1487	int envlen = 0;
[22]	1488	size_t len;
[1]	1489
	1490	SL_ENTER(_("sh_unix_copyenv"));
	1491
	1492	while (env0 != NULL && env0[envlen] != NULL) {
	1493	/* printf("%2d: %s\n", envlen, env0[envlen]); */
	1494	++envlen;
	1495	}
	1496	++envlen;
	1497
	1498	/* printf("-> %2d: slots allocated\n", envlen); */
[454]	1499	env1 = calloc(1,sizeof(char ) envlen); /* only once */
[1]	1500	if (env1 == NULL)
	1501	{
	1502	fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
	1503	SL_RET0(_("sh_unix_copyenv"));
	1504	}
	1505	env0 = environ;
	1506	envlen = 0;
	1507
[22]	1508	while (env0 != NULL && env0[envlen] != NULL) {
	1509	len = strlen(env0[envlen]) + 1;
[454]	1510	env1[envlen] = calloc(1,len); /* only once */
[1]	1511	if (env1[envlen] == NULL)
	1512	{
[473]	1513	int i;
[1]	1514	fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
[473]	1515	for (i = 0; i < envlen; ++i) free(env1[len]);
	1516	free(env1);
[1]	1517	SL_RET0(_("sh_unix_copyenv"));
	1518	}
[22]	1519	sl_strlcpy(env1[envlen], env0[envlen], len);
[1]	1520	++envlen;
	1521	}
	1522	env1[envlen] = NULL;
	1523
	1524	environ = env1;
	1525	SL_RET0(_("sh_unix_copyenv"));
	1526	}
	1527
	1528	/* delete all environment variables
	1529	*/
	1530	static void sh_unix_zeroenv(void)
	1531	{
	1532	char * c;
	1533	char ** env;
	1534
	1535	SL_ENTER(_("sh_unix_zeroenv"));
	1536
	1537	sh_unix_copyenv();
	1538	env = environ;
	1539
	1540	while (env != NULL && *env != NULL) {
	1541	c = strchr ((*env), '=');
	1542	#ifdef WITH_MYSQL
	1543	/*
	1544	* Skip the MYSQL_UNIX_PORT environment variable; MySQL may need it.
	1545	*/
	1546	if (0 == sl_strncmp((*env), _("MYSQL_UNIX_PORT="), 16))
	1547	{
	1548	++(env);
	1549	continue;
	1550	}
[18]	1551	if (0 == sl_strncmp((*env), _("MYSQL_TCP_PORT="), 15))
	1552	{
	1553	++(env);
	1554	continue;
	1555	}
	1556	if (0 == sl_strncmp((*env), _("MYSQL_HOME="), 11))
	1557	{
	1558	++(env);
	1559	continue;
	1560	}
[1]	1561	#endif
	1562	#ifdef WITH_ORACLE
	1563	/*
[415]	1564	* Skip the ORACLE_HOME and TNS_ADMIN environment variables;
	1565	* Oracle may need them.
[1]	1566	*/
	1567	if (0 == sl_strncmp((*env), _("ORACLE_HOME="), 12))
	1568	{
	1569	++(env);
	1570	continue;
	1571	}
[415]	1572	if (0 == sl_strncmp((*env), _("TNS_ADMIN="), 10))
	1573	{
	1574	++(env);
	1575	continue;
	1576	}
[1]	1577	#endif
	1578	/*
	1579	* Skip the TZ environment variable.
	1580	*/
	1581	if (0 == sl_strncmp((*env), _("TZ="), 3))
	1582	{
	1583	++(env);
	1584	continue;
	1585	}
	1586	++(env);
	1587	if (c != NULL)
	1588	{
	1589	++c;
	1590	while ((*c) != '\0') {
	1591	(*c) = '\0';
	1592	++c;
	1593	}
	1594	}
	1595	}
	1596
[205]	1597	#ifdef HAVE_TZSET
	1598	tzset();
	1599	#endif
	1600
[1]	1601	SL_RET0(_("sh_unix_zeroenv"));
	1602	}
	1603
	1604
	1605	static void sh_unix_resettimer(void)
	1606	{
	1607	struct itimerval this_timer;
	1608
	1609	SL_ENTER(_("sh_unix_resettimer"));
	1610
	1611	this_timer.it_value.tv_sec = 0;
	1612	this_timer.it_value.tv_usec = 0;
	1613
	1614	this_timer.it_interval.tv_sec = 0;
	1615	this_timer.it_interval.tv_usec = 0;
	1616
	1617	setitimer(ITIMER_REAL, &this_timer, NULL);
	1618	#if !defined(SH_PROFILE)
	1619	setitimer(ITIMER_VIRTUAL, &this_timer, NULL);
	1620	setitimer(ITIMER_PROF, &this_timer, NULL);
	1621	#endif
	1622
	1623	SL_RET0(_("sh_unix_resettimer"));
	1624	}
	1625
	1626	static void sh_unix_resetsignals(void)
	1627	{
	1628	int sig_num;
	1629	#ifdef NSIG
	1630	int max_sig = NSIG;
	1631	#else
	1632	int max_sig = 255;
	1633	#endif
	1634	int test;
	1635	int status;
[264]	1636	struct sigaction act;
	1637	#if !defined(SH_PROFILE)
	1638	struct sigaction oldact;
	1639	#endif
[1]	1640
	1641	sigset_t set_proc;
	1642
	1643	SL_ENTER(_("sh_unix_resetsignals"));
	1644	/*
	1645	* Reset the current signal mask (inherited from parent process).
	1646	*/
	1647
	1648	sigfillset(&set_proc);
	1649
	1650	do {
	1651	errno = 0;
[315]	1652	test = SH_SETSIGMASK(SIG_UNBLOCK, &set_proc, NULL);
[1]	1653	} while (test < 0 && errno == EINTR);
	1654
	1655	/*
	1656	* Reset signal handling.
	1657	*/
	1658
	1659	act.sa_handler = SIG_DFL; /* signal action */
	1660	sigemptyset( &act.sa_mask ); /* set an empty mask */
	1661	act.sa_flags = 0; /* init sa_flags */
	1662
	1663	for (sig_num = 1; sig_num <= max_sig; ++sig_num)
	1664	{
	1665	#if !defined(SH_PROFILE)
	1666	test = retry_sigaction(FIL__, __LINE__, sig_num, &act, &oldact);
	1667	#else
	1668	test = 0;
	1669	#endif
	1670	if ((test == -1) && (errno != EINVAL))
	1671	{
[132]	1672	char errbuf[SH_ERRBUF_SIZE];
[1]	1673	status = errno;
	1674	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_SIG,
[132]	1675	sh_error_message (status, errbuf, sizeof(errbuf)), sig_num);
[1]	1676	}
	1677	}
	1678
	1679	SL_RET0(_("sh_unix_resetsignals"));
	1680	}
	1681
	1682	/* Get the local hostname (FQDN)
	1683	*/
[293]	1684	static char * sh_tolower (char * s)
	1685	{
	1686	char * ret = s;
	1687	if (s)
	1688	{
	1689	for (; *s; ++s)
	1690	{
	1691	s = tolower((unsigned char) s);
	1692	}
	1693	}
	1694	return ret;
	1695	}
	1696
	1697
[1]	1698	#include <sys/socket.h>
	1699
	1700	/* Required for BSD
	1701	*/
	1702	#ifdef HAVE_NETINET_IN_H
	1703	#include <netinet/in.h>
	1704	#endif
	1705
	1706	#include <arpa/inet.h>
	1707
[263]	1708	const char * sh_unix_h_name (struct hostent * host_entry)
[29]	1709	{
	1710	char ** p;
	1711	if (strchr(host_entry->h_name, '.')) {
	1712	return host_entry->h_name;
	1713	} else {
	1714	for (p = host_entry->h_aliases; *p; ++p) {
	1715	if (strchr(*p, '.'))
	1716	return *p;
	1717	}
	1718	}
	1719	return host_entry->h_name;
	1720	}
	1721
[1]	1722	/* uname() on FreeBSD is broken, because the 'nodename' buf is too small
	1723	* to hold a valid (leftmost) domain label.
	1724	*/
	1725	#if defined(HAVE_UNAME) && !defined(HOST_IS_FREEBSD)
	1726	#include <sys/utsname.h>
	1727	void sh_unix_localhost()
	1728	{
	1729	struct utsname buf;
	1730	int i;
[481]	1731	unsigned int ddot;
[1]	1732	int len;
	1733	char * p;
	1734	char hostname[256];
[295]	1735	char numeric[SH_IP_BUF];
	1736	char * canonical;
[1]	1737
	1738
	1739	SL_ENTER(_("sh_unix_localhost"));
	1740
	1741	(void) uname (&buf);
[22]	1742	/* flawfinder: ignore / / ff bug, ff sees system() */
[1]	1743	sl_strlcpy (sh.host.system, buf.sysname, SH_MINIBUF);
	1744	sl_strlcpy (sh.host.release, buf.release, SH_MINIBUF);
	1745	sl_strlcpy (sh.host.machine, buf.machine, SH_MINIBUF);
	1746
	1747	/* Workaround for cases where nodename could be
	1748	* a truncated FQDN.
	1749	*/
	1750	if (strlen(buf.nodename) == (sizeof(buf.nodename)-1))
	1751	{
	1752	p = strchr(buf.nodename, '.');
	1753	if (NULL != p) {
	1754	*p = '\0';
	1755	sl_strlcpy(hostname, buf.nodename, 256);
	1756	} else {
	1757	#ifdef HAVE_GETHOSTNAME
	1758	if (0 != gethostname(hostname, 256))
	1759	{
	1760	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	1761	_("nodename returned by uname may be truncated"),
	1762	_("sh_unix_localhost"));
	1763	sl_strlcpy (hostname, buf.nodename, 256);
	1764	}
	1765	else
	1766	{
	1767	hostname[255] = '\0';
	1768	}
	1769	#else
	1770	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	1771	_("nodename returned by uname may be truncated"),
	1772	_("sh_unix_localhost"));
	1773	sl_strlcpy(hostname, buf.nodename, 256);
	1774	#endif
	1775	}
	1776	}
	1777	else
	1778	{
	1779	sl_strlcpy(hostname, buf.nodename, 256);
	1780	}
	1781
[295]	1782	canonical = sh_ipvx_canonical(hostname, numeric, sizeof(numeric));
[1]	1783
[295]	1784	if (canonical == NULL)
[134]	1785	{
[295]	1786	sl_strlcpy (sh.host.name, hostname, SH_PATHBUF);
[293]	1787	sh_tolower (sh.host.name);
[134]	1788	}
[295]	1789	else
[1]	1790	{
[295]	1791	sl_strlcpy (sh.host.name, canonical, SH_PATHBUF);
	1792	SH_FREE(canonical);
[1]	1793	}
	1794
	1795	/* check whether it looks like a FQDN
	1796	*/
	1797	len = sl_strlen(sh.host.name);
[170]	1798	ddot = 0;
[1]	1799	for (i = 0; i < len; ++i)
	1800	if (sh.host.name[i] == '.') ++ddot;
	1801
[295]	1802	if (ddot == 0)
[1]	1803	{
	1804	dlog(1, FIL__, __LINE__,
	1805	_("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"),
	1806	hostname, sh.host.name);
[295]	1807	sl_strlcpy (sh.host.name, numeric, SH_PATHBUF);
[1]	1808	SL_RET0(_("sh_unix_localhost"));
	1809	}
	1810
[295]	1811	if (sh_ipvx_is_numeric(sh.host.name))
[1]	1812	{
	1813	dlog(1, FIL__, __LINE__,
	1814	_("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"),
	1815	hostname, sh.host.name);
	1816	}
	1817
	1818	SL_RET0(_("sh_unix_localhost"));
	1819	}
[217]	1820
[1]	1821	#else
[217]	1822
	1823	/*
	1824	* --FreeBSD code
	1825	*/
	1826	#if defined(HAVE_UNAME)
	1827	#include <sys/utsname.h>
	1828	#endif
[1]	1829	void sh_unix_localhost()
	1830	{
[217]	1831	#if defined(HAVE_UNAME)
	1832	struct utsname buf;
	1833	#endif
[1]	1834	int i;
[170]	1835	int ddot;
[1]	1836	int len;
	1837	char hostname[1024];
[295]	1838	char numeric[SH_IP_BUF];
	1839	char * canonical;
[1]	1840
	1841	SL_ENTER(_("sh_unix_localhost"));
	1842
[217]	1843	#if defined(HAVE_UNAME)
	1844	(void) uname (&buf);
	1845	/* flawfinder: ignore / / ff bug, ff sees system() */
	1846	sl_strlcpy (sh.host.system, buf.sysname, SH_MINIBUF);
	1847	sl_strlcpy (sh.host.release, buf.release, SH_MINIBUF);
	1848	sl_strlcpy (sh.host.machine, buf.machine, SH_MINIBUF);
	1849	#endif
	1850
[1]	1851	(void) gethostname (hostname, 1024);
	1852	hostname[1023] = '\0';
[134]	1853
[295]	1854	canonical = sh_ipvx_canonical(hostname, numeric, sizeof(numeric));
[1]	1855
[295]	1856	if (canonical == NULL)
[1]	1857	{
[295]	1858	sl_strlcpy (sh.host.name, hostname, SH_PATHBUF);
[293]	1859	sh_tolower (sh.host.name);
[1]	1860	}
[295]	1861	else
[1]	1862	{
[295]	1863	sl_strlcpy (sh.host.name, canonical, SH_PATHBUF);
	1864	SH_FREE(canonical);
[1]	1865	}
	1866
	1867	/* check whether it looks like a FQDN
	1868	*/
	1869	len = sl_strlen(sh.host.name);
[170]	1870	ddot = 0;
[1]	1871	for (i = 0; i < len; ++i)
	1872	if (sh.host.name[i] == '.') ++ddot;
	1873	if (ddot == 0)
	1874	{
	1875	dlog(1, FIL__, __LINE__,
	1876	_("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"),
	1877	hostname, sh.host.name);
[295]	1878	sl_strlcpy (sh.host.name, numeric, SH_PATHBUF);
[1]	1879	SL_RET0(_("sh_unix_localhost"));
	1880	}
	1881
[295]	1882	if (sh_ipvx_is_numeric(sh.host.name))
[1]	1883	{
	1884	dlog(1, FIL__, __LINE__,
	1885	_("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"),
	1886	hostname, sh.host.name);
	1887	}
	1888
	1889	SL_RET0(_("sh_unix_localhost"));
	1890	}
	1891	#endif
	1892
	1893
	1894	void sh_unix_memlock()
	1895	{
	1896	SL_ENTER(_("sh_unix_memlock"));
	1897
	1898	/* do this before dropping privileges
	1899	*/
	1900	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
[481]	1901	if (skey->mlock_failed == S_FALSE)
[1]	1902	{
[19]	1903	if ( (-1) == sh_unix_mlock( FIL__, __LINE__,
	1904	(char *) skey, sizeof (sh_key_t)) )
[1]	1905	{
[134]	1906	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[481]	1907	skey->mlock_failed = S_TRUE;
[134]	1908	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[1]	1909	}
	1910	}
	1911	#else
[481]	1912	if (skey->mlock_failed == S_FALSE)
[1]	1913	{
[134]	1914	SH_MUTEX_LOCK_UNSAFE(mutex_skey);
[481]	1915	skey->mlock_failed = S_TRUE;
[134]	1916	SH_MUTEX_UNLOCK_UNSAFE(mutex_skey);
[1]	1917	}
	1918	#endif
	1919
	1920	SL_RET0(_("sh_unix_memlock"));
	1921	}
	1922
	1923	#ifdef SH_WITH_SERVER
	1924	char * chroot_dir = NULL;
	1925
[20]	1926	int sh_unix_set_chroot(const char * str)
[1]	1927	{
	1928	size_t len;
	1929	static int block = 0;
	1930
	1931	if (block == 1)
	1932	return 0;
	1933
	1934	if (str && *str == '/')
	1935	{
	1936	len = strlen(str) + 1;
[454]	1937	chroot_dir = calloc(1,strlen(str) + 1); /* only once */
[1]	1938	if (!chroot_dir)
	1939	{
	1940	fprintf(stderr, _("%s: %d: Out of memory\n"), FIL__, __LINE__);
	1941	return 1;
	1942	}
	1943	sl_strlcpy(chroot_dir, str, len);
	1944	block = 1;
	1945	return 0;
	1946	}
	1947	return 1;
	1948	}
	1949
[170]	1950	int sh_unix_chroot(void)
[1]	1951	{
	1952	int status;
	1953
	1954	if (chroot_dir != NULL)
	1955	{
	1956	status = retry_aud_chdir(FIL__, __LINE__, chroot_dir);
	1957	if ( (-1) == status )
	1958	{
[132]	1959	char errbuf[SH_ERRBUF_SIZE];
[1]	1960	status = errno;
	1961	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
[132]	1962	sh_error_message (status, errbuf, sizeof(errbuf)), chroot_dir);
[1]	1963	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1964	}
[22]	1965	/* flawfinder: ignore */
[1]	1966	return (chroot(chroot_dir));
	1967	}
	1968	return 0;
	1969	}
	1970	/* #ifdef SH_WITH_SERVER */
	1971	#else
[170]	1972	int sh_unix_chroot(void) { return 0; }
[1]	1973	#endif
	1974
	1975	/* daemon mode
	1976	*/
	1977	static int block_setdeamon = 0;
	1978
[20]	1979	int sh_unix_setdeamon(const char * dummy)
[1]	1980	{
	1981	int res = 0;
	1982
	1983	SL_ENTER(_("sh_unix_setdeamon"));
	1984
	1985	if (block_setdeamon != 0)
	1986	SL_RETURN((0),_("sh_unix_setdeamon"));
	1987
	1988	if (dummy == NULL)
[481]	1989	sh.flag.isdaemon = S_TRUE;
[1]	1990	else
	1991	res = sh_util_flagval (dummy, &sh.flag.isdaemon);
	1992
	1993	if (sh.flag.opts == S_TRUE)
	1994	block_setdeamon = 1;
	1995
	1996	SL_RETURN(res, _("sh_unix_setdeamon"));
	1997	}
	1998	#if defined(HAVE_LIBPRELUDE)
	1999	#include "sh_prelude.h"
	2000	#endif
	2001
[20]	2002	int sh_unix_setnodeamon(const char * dummy)
[1]	2003	{
	2004	int res = 0;
[132]	2005
[1]	2006	SL_ENTER(_("sh_unix_setnodeamon"));
	2007
	2008	if (block_setdeamon != 0)
	2009	SL_RETURN((0),_("sh_unix_setmodeamon"));
	2010
	2011	if (dummy == NULL)
[481]	2012	sh.flag.isdaemon = S_FALSE;
[1]	2013	else
	2014	res = sh_util_flagval (dummy, &sh.flag.isdaemon);
	2015
	2016	if (sh.flag.opts == S_TRUE)
	2017	block_setdeamon = 1;
	2018
	2019	SL_RETURN(res, _("sh_unix_setnodeamon"));
	2020	}
	2021
	2022	int sh_unix_init(int goDaemon)
	2023	{
	2024	int status;
	2025	uid_t uid;
	2026	pid_t oldpid = getpid();
	2027	#if defined(SH_WITH_SERVER)
[170]	2028	extern int sh_socket_open_int (void);
[1]	2029	#endif
[132]	2030	char errbuf[SH_ERRBUF_SIZE];
[1]	2031
[321]	2032	extern void sh_kill_sub();
	2033
[1]	2034	SL_ENTER(_("sh_unix_init"));
	2035
	2036	/* fork twice, exit the parent process
	2037	*/
	2038	if (goDaemon == 1) {
	2039
	2040	switch (aud_fork(FIL__, __LINE__)) {
	2041	case 0: break; /* child process continues */
	2042	case -1: SL_RETURN((-1),_("sh_unix_init")); /* error */
[321]	2043	default: /* parent process exits */
	2044	sh_kill_sub();
	2045	aud__exit(FIL__, __LINE__, 0);
[1]	2046	}
	2047
	2048	/* Child processes do not inherit page locks across a fork.
	2049	* Error in next fork would return in this (?) thread of execution.
	2050	*/
	2051	sh_unix_memlock();
	2052
	2053	setsid(); /* should not fail */
[162]	2054	sh.pid = (UINT64) getpid();
[1]	2055
	2056	switch (aud_fork(FIL__, __LINE__)) {
	2057	case 0: break; /* child process continues */
	2058	case -1: SL_RETURN((-1),_("sh_unix_init")); /* error */
[321]	2059	default: /* parent process exits */
	2060	sh_kill_sub();
	2061	aud__exit(FIL__, __LINE__, 0);
[1]	2062	}
	2063
	2064	/* Child processes do not inherit page locks across a fork.
	2065	*/
	2066	sh_unix_memlock();
[162]	2067	sh.pid = (UINT64) getpid();
[1]	2068
	2069	} else {
	2070	setsid(); /* should not fail */
	2071	}
	2072
	2073	/* set working directory
	2074	*/
	2075	#ifdef SH_PROFILE
	2076	status = 0;
	2077	#else
	2078	status = retry_aud_chdir(FIL__, __LINE__, "/");
	2079	#endif
	2080	if ( (-1) == status )
	2081	{
	2082	status = errno;
	2083	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_W_CHDIR,
[132]	2084	sh_error_message (status, errbuf, sizeof(errbuf)), "/");
[1]	2085	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2086	}
	2087
	2088	/* reset timers
	2089	*/
	2090	sh_unix_resettimer();
	2091
	2092	/* signal handlers
	2093	*/
	2094	sh_unix_resetsignals();
	2095	#if defined(SCREW_IT_UP)
	2096	sh_sigtrap_prepare();
	2097	#endif
	2098	sh_unix_siginstall (goDaemon);
	2099
	2100	/* set file creation mask
	2101	*/
	2102	(void) umask (0); /* should not fail */
	2103
	2104	/* set resource limits to maximum, and
	2105	* core dump size to zero
	2106	*/
	2107	sh_unix_setlimits();
	2108
	2109	/* zero out the environment (like PATH='\0')
	2110	*/
	2111	sh_unix_zeroenv();
	2112
	2113	if (goDaemon == 1)
	2114	{
[92]	2115	/* Close first tree file descriptors
[84]	2116	*/
[252]	2117	sl_close_fd (FIL__, __LINE__, 0); /* if running as daemon */
	2118	sl_close_fd (FIL__, __LINE__, 1); /* if running as daemon */
	2119	sl_close_fd (FIL__, __LINE__, 2); /* if running as daemon */
[84]	2120
	2121	/* Enable full error logging
	2122	*/
	2123	sh_error_only_stderr (S_FALSE);
	2124
	2125	/* open first three streams to /dev/null
	2126	*/
	2127	status = aud_open(FIL__, __LINE__, SL_NOPRIV, _("/dev/null"), O_RDWR, 0);
	2128	if (status < 0)
	2129	{
	2130	status = errno;
	2131	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
[132]	2132	sh_error_message(status, errbuf, sizeof(errbuf)), _("open"));
[84]	2133	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2134	}
	2135
	2136	status = retry_aud_dup(FIL__, __LINE__, 0);
	2137	if (status >= 0)
	2138	retry_aud_dup(FIL__, __LINE__, 0);
	2139
	2140	if (status < 0)
	2141	{
	2142	status = errno;
	2143	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
[132]	2144	sh_error_message(status, errbuf, sizeof(errbuf)), _("dup"));
[84]	2145	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2146	}
	2147
[86]	2148	sh_error_enable_unsafe (S_TRUE);
[1]	2149	#if defined(HAVE_LIBPRELUDE)
	2150	sh_prelude_reset ();
	2151	#endif
	2152
	2153	/* --- wait until parent has exited ---
	2154	*/
	2155	while (1 == 1)
	2156	{
	2157	errno = 0;
	2158	if (0 > aud_kill (FIL__, __LINE__, oldpid, 0) && errno == ESRCH)
	2159	{
	2160	break;
	2161	}
	2162	retry_msleep(0, 1);
	2163	}
	2164
	2165	/* write PID file
	2166	*/
	2167	status = sh_unix_write_pid_file();
	2168	if (status < 0)
	2169	{
	2170	sl_get_euid(&uid);
	2171	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_PIDFILE,
	2172	(long) uid, sh.srvlog.alt);
	2173	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2174	}
	2175	#if defined(SH_WITH_SERVER)
	2176	sh_socket_open_int ();
	2177	#endif
	2178	}
	2179	else
	2180	{
[86]	2181	sh_error_enable_unsafe (S_TRUE);
[1]	2182	#if defined(HAVE_LIBPRELUDE)
	2183	sh_prelude_reset ();
	2184	#endif
	2185	#if defined(SH_WITH_SERVER)
	2186	sh_socket_open_int ();
	2187	#endif
	2188	}
	2189
	2190	/* chroot (this is a no-op if no chroot dir is specified
	2191	*/
	2192	status = sh_unix_chroot();
	2193	if (status < 0)
	2194	{
	2195	status = errno;
	2196	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
[132]	2197	sh_error_message(status, errbuf, sizeof(errbuf)), _("chroot"));
[1]	2198	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2199	}
	2200
	2201	/* drop capabilities
	2202	*/
	2203	sl_drop_cap();
	2204
	2205	SL_RETURN((0),_("sh_unix_init"));
	2206	}
	2207
[197]	2208	/* --- run a command, securely --- */
	2209
	2210	int sh_unix_run_command (const char * str)
	2211	{
	2212	pid_t pid;
	2213	char * arg[4];
	2214	char * env[5];
	2215	char * path = sh_util_strdup(_("/bin/sh"));
	2216
	2217	int status = -1;
	2218
	2219	arg[0] = sh_util_strdup(_("/bin/sh"));
	2220	arg[1] = sh_util_strdup(_("-c"));
	2221	arg[2] = sh_util_strdup(str);
	2222	arg[3] = NULL;
	2223
	2224	env[0] = sh_util_strdup(_("PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/ucb"));
	2225	env[1] = sh_util_strdup(_("SHELL=/bin/sh"));
	2226	env[2] = sh_util_strdup(_("IFS= \t\n"));
[199]	2227	if (getenv("TZ")) { /* flawfinder: ignore */
	2228	char * tz = sh_util_strdup(getenv("TZ")); /* flawfinder: ignore */
	2229	size_t tzlen = strlen(tz);
[481]	2230	if (S_TRUE == sl_ok_adds (4, tzlen)) {
[199]	2231	env[3] = SH_ALLOC(4+tzlen);
[197]	2232	sl_strlcpy(env[3], "TZ=", 4);
[199]	2233	sl_strlcat(env[3], tz , 4+tzlen);
[197]	2234	} else {
	2235	env[3] = NULL;
	2236	}
	2237	} else {
	2238	env[3] = NULL;
	2239	}
	2240	env[4] = NULL;
	2241
	2242	pid = fork();
	2243
	2244	if (pid == (pid_t)(-1))
	2245	{
	2246	return -1;
	2247	}
	2248
	2249	else if (pid == 0) /* child */
	2250	{
	2251	memset(skey, 0, sizeof(sh_key_t));
	2252	(void) umask(S_IRGRP\|S_IWGRP\|S_IXGRP\|S_IROTH\|S_IWOTH\|S_IXOTH);
[481]	2253	sh_unix_closeall (3, -1, S_TRUE); /* in child process */
[197]	2254	execve(path, arg, env);
	2255	_exit(EXIT_FAILURE);
	2256	}
	2257
	2258	else /* parent */
	2259	{
	2260	int r;
	2261
[203]	2262	while((r = waitpid(pid, &status, WUNTRACED)) != pid && r != -1) ;
[197]	2263
[199]	2264	#if !defined(USE_UNO)
[197]	2265	if (r == -1 \|\| !WIFEXITED(status))
	2266	{
	2267	status = -1;
	2268	}
	2269	else
	2270	{
	2271	status = WEXITSTATUS(status);
	2272	}
[199]	2273	#endif
[197]	2274	}
	2275
	2276	return status;
	2277	}
	2278
[1]	2279	/********************************************************
	2280	*
	2281	* TIME
	2282	*
	2283	********************************************************/
	2284
	2285	/* Figure out the time offset of the current timezone
	2286	* in a portable way.
	2287	*/
	2288	char * t_zone(const time_t * xx)
	2289	{
	2290	struct tm aa;
	2291	struct tm bb;
[362]	2292
[481]	2293	struct tm * aptr;
	2294	struct tm * bptr;
	2295
[1]	2296	int sign = 0;
	2297	int diff = 0;
	2298	int hh, mm;
	2299	static char tz[64];
	2300
	2301	SL_ENTER(_("t_zone"));
	2302
[131]	2303	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
[481]	2304	aptr = gmtime_r (xx, &aa);
[131]	2305	#else
[481]	2306	aptr = gmtime(xx);
	2307	if (aptr)
	2308	memcpy (&aa, aptr, sizeof(struct tm));
[131]	2309	#endif
	2310
	2311	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
[481]	2312	bptr = localtime_r (xx, &bb);
[131]	2313	#else
[481]	2314	bptr = localtime(xx);
	2315	if (bptr)
	2316	memcpy (&bb, bptr, sizeof(struct tm));
[131]	2317	#endif
[1]	2318
[481]	2319	if (bptr && aptr)
	2320	{
	2321	/* Check for datum wrap-around.
	2322	*/
[494]	2323	if ((aa.tm_mday == 1) && (aa.tm_mday < bb.tm_mday) && (aa.tm_hour < bb.tm_hour))
[493]	2324	sign = ( 1);
	2325	else if (aa.tm_year < bb.tm_year)
[481]	2326	sign = (-1);
	2327	else if (aa.tm_mon < bb.tm_mon)
	2328	sign = (-1);
	2329	else if (aa.tm_mday < bb.tm_mday)
	2330	sign = (-1);
	2331	else if (bb.tm_year < aa.tm_year)
	2332	sign = ( 1);
	2333	else if (bb.tm_mon < aa.tm_mon)
	2334	sign = ( 1);
	2335	else if (bb.tm_mday < aa.tm_mday)
	2336	sign = ( 1);
	2337
	2338	diff = aa.tm_hour * 60 + aa.tm_min;
	2339	diff = (bb.tm_hour * 60 + bb.tm_min) - diff;
	2340	diff = diff - (sign * 24 * 60); /* datum wrap-around correction */
	2341	hh = diff / 60;
	2342	mm = diff - (hh * 60);
[539]	2343	sl_snprintf (tz, sizeof(tz), _("%+03d%02d"), hh, mm); /* known to fit */
[481]	2344	}
	2345	else
	2346	{
[539]	2347	sl_snprintf (tz, sizeof(tz), _("%+03d%02d"), 0, 0);
[481]	2348	}
[1]	2349	SL_RETURN(tz, _("t_zone"));
	2350	}
	2351
	2352	unsigned long sh_unix_longtime ()
	2353	{
	2354	return ((unsigned long)time(NULL));
	2355	}
	2356
	2357	#ifdef HAVE_GETTIMEOFDAY
	2358	unsigned long sh_unix_notime ()
	2359	{
	2360	struct timeval tv;
	2361
	2362	gettimeofday (&tv, NULL);
	2363
	2364	return ((unsigned long)(tv.tv_sec + tv.tv_usec * 10835 + getpid() + getppid()));
	2365
	2366	}
	2367	#endif
	2368
	2369	static int count_dev_time = 0;
	2370
	2371	void reset_count_dev_time(void)
	2372	{
	2373	count_dev_time = 0;
	2374	return;
	2375	}
	2376
[22]	2377	int sh_unix_settimeserver (const char * address)
[1]	2378	{
	2379
	2380	SL_ENTER(_("sh_unix_settimeserver"));
	2381
	2382	if (address != NULL && count_dev_time < 2
	2383	&& sl_strlen(address) < SH_PATHBUF)
	2384	{
	2385	if (count_dev_time == 0)
	2386	sl_strlcpy (sh.srvtime.name, address, SH_PATHBUF);
	2387	else
	2388	sl_strlcpy (sh.srvtime.alt, address, SH_PATHBUF);
	2389
	2390	++count_dev_time;
	2391	SL_RETURN((0), _("sh_unix_settimeserver"));
	2392	}
	2393	SL_RETURN((-1), _("sh_unix_settimeserver"));
	2394	}
	2395
	2396
	2397	#ifdef HAVE_NTIME
	2398	#define UNIXEPOCH 2208988800UL /* difference between Unix time and net time
	2399	* The UNIX EPOCH starts in 1970.
	2400	*/
	2401	#include <sys/socket.h>
	2402	#include <netinet/in.h>
	2403	#include <arpa/inet.h>
	2404	#include <netdb.h>
	2405	#include <ctype.h>
	2406	#endif
	2407
	2408	/* Timeserver service. */
	2409	/* define is missing on HP-UX 10.20 */
	2410	#ifndef IPPORT_TIMESERVER
	2411	#define IPPORT_TIMESERVER 37
	2412	#endif
	2413
[132]	2414	char * sh_unix_time (time_t thetime, char * buffer, size_t len)
[1]	2415	{
	2416
	2417	int status;
[132]	2418	char AsciiTime[81]; /* local time */
[1]	2419	time_t time_now;
	2420	struct tm * time_ptr;
[131]	2421	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
	2422	struct tm time_tm;
	2423	#endif
[1]	2424	#ifdef SH_USE_XML
	2425	static char deftime[] = N_("0000-00-00T00:00:00"); /* default time */
	2426	#else
	2427	static char deftime[] = N_("[0000-00-00T00:00:00]"); /* default time */
	2428	#endif
	2429
	2430	#ifdef HAVE_NTIME
	2431	int fd; /* network file descriptor */
	2432	u_char net_time[4]; /* remote time in network format */
	2433	static int failerr = 0; /* no net time */
	2434	int fail = 0; /* no net time */
	2435	int errflag;
	2436	char errmsg[256];
	2437	char error_call[SH_MINIBUF];
	2438	int error_num;
	2439	#endif
	2440
	2441	SL_ENTER(_("sh_unix_time"));
	2442
	2443	#ifdef HAVE_NTIME
	2444	if (thetime == 0)
	2445	{
	2446	if (sh.srvtime.name[0] == '\0')
	2447	{
	2448	fail = 1;
	2449	(void) time (&time_now);
	2450	}
	2451	else /* have a timeserver address */
	2452	{
[343]	2453	/* don't call timeserver more than once per second */
	2454	static time_t time_old = 0;
	2455	time_t time_new;
	2456	static time_t time_saved = 0;
	2457	(void) time (&time_new);
	2458	if ((time_new == time_old) && (time_saved != 0))
	2459	{
	2460	time_now = time_saved;
	2461	goto end;
	2462	}
	2463	time_old = time_new;
	2464
	2465
[1]	2466	fd = connect_port_2 (sh.srvtime.name, sh.srvtime.alt,
	2467	IPPORT_TIMESERVER,
	2468	error_call, &error_num, errmsg, sizeof(errmsg));
	2469	if (fd >= 0)
	2470	{
	2471	if (4 != read_port (fd, (char *) net_time, 4, &errflag, 2))
	2472	{
	2473	fail = 1;
	2474	sh_error_handle ((-1), FIL__, __LINE__, errflag,
	2475	MSG_E_NLOST,
	2476	_("time"), sh.srvtime.name);
	2477	}
[252]	2478	sl_close_fd(FIL__, __LINE__, fd);
[1]	2479	}
	2480	else
	2481	{
	2482	sh_error_handle ((-1), FIL__, __LINE__, error_num,
	2483	MSG_E_NET, errmsg, error_call,
	2484	_("time"), sh.srvtime.name);
[539]	2485	errflag = error_num;
[1]	2486	fail = 1;
	2487	}
	2488
	2489	if (fail == 0)
	2490	{
[230]	2491	unsigned long ltmp;
	2492	UINT32 ttmp;
	2493	memcpy(&ttmp, net_time, sizeof(UINT32)); ltmp = ttmp;
	2494	time_now = ntohl(ltmp) - UNIXEPOCH;
[343]	2495	time_saved = time_now;
	2496
[1]	2497	if (failerr == 1) {
	2498	failerr = 0;
	2499	sh_error_handle ((-1), FIL__, __LINE__, 0,
	2500	MSG_E_NEST,
	2501	_("time"), sh.srvtime.name);
	2502	}
	2503	}
	2504	else
	2505	{
	2506	(void) time (&time_now);
[343]	2507	time_saved = 0;
	2508
[1]	2509	if (failerr == 0)
	2510	{
	2511	failerr = 1;
	2512	sh_error_handle ((-1), FIL__, __LINE__, errflag,
	2513	MSG_SRV_FAIL,
	2514	_("time"), sh.srvtime.name);
	2515	}
	2516	}
[343]	2517	end:
	2518	; /* 'label at end of compound statement' */
[1]	2519	}
	2520	}
	2521	else
	2522	{
	2523	time_now = thetime;
	2524	}
	2525
	2526	/* #ifdef HAVE_NTIME */
	2527	#else
	2528
	2529	if (thetime == 0)
	2530	{
	2531	(void) time (&time_now);
	2532	}
	2533	else
	2534	{
	2535	time_now = thetime;
	2536	}
	2537
	2538	/* #ifdef HAVE_NTIME */
	2539	#endif
	2540
[132]	2541	if (time_now == (-1) )
	2542	{
	2543	sl_strlcpy(buffer, _(deftime), len);
	2544	SL_RETURN(buffer, _("sh_unix_time"));
	2545	}
[1]	2546	else
[131]	2547	{
	2548	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
	2549	time_ptr = localtime_r (&time_now, &time_tm);
	2550	#else
	2551	time_ptr = localtime (&time_now);
	2552	#endif
	2553	}
[1]	2554	if (time_ptr != NULL)
	2555	{
[132]	2556	status = strftime (AsciiTime, sizeof(AsciiTime),
[1]	2557	#ifdef SH_USE_XML
	2558	_("%Y-%m-%dT%H:%M:%S%%s"),
	2559	#else
	2560	_("[%Y-%m-%dT%H:%M:%S%%s]"),
	2561	#endif
	2562	time_ptr);
	2563
[132]	2564	sl_snprintf(buffer, len, AsciiTime, t_zone(&time_now));
[1]	2565
[132]	2566	if ( (status == 0) \|\| (status == sizeof(AsciiTime)) )
	2567	{
	2568	sl_strlcpy(buffer, _(deftime), len);
	2569	SL_RETURN( buffer, _("sh_unix_time"));
	2570	}
[1]	2571	else
[132]	2572	{
	2573	SL_RETURN(buffer, _("sh_unix_time"));
	2574	}
[1]	2575	}
	2576
	2577	/* last resort
	2578	*/
[132]	2579	sl_strlcpy(buffer, _(deftime), len);
	2580	SL_RETURN( buffer, _("sh_unix_time"));
[1]	2581	}
	2582
	2583	static int sh_unix_use_localtime = S_FALSE;
	2584
[481]	2585	/* whether to use localtime for file timestamps in logs
[1]	2586	*/
[22]	2587	int sh_unix_uselocaltime (const char * c)
[1]	2588	{
	2589	int i;
	2590	SL_ENTER(_("sh_unix_uselocaltime"));
	2591	i = sh_util_flagval(c, &(sh_unix_use_localtime));
	2592
	2593	SL_RETURN(i, _("sh_unix_uselocaltime"));
	2594	}
	2595
[132]	2596	char * sh_unix_gmttime (time_t thetime, char * buffer, size_t len)
[1]	2597	{
	2598
	2599	int status;
	2600
	2601	struct tm * time_ptr;
[131]	2602	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS)
	2603	struct tm time_tm;
	2604	#endif
[132]	2605	char AsciiTime[81]; /* GMT time */
[1]	2606	#ifdef SH_USE_XML
	2607	static char deftime[] = N_("0000-00-00T00:00:00"); /* default time */
	2608	#else
	2609	static char deftime[] = N_("[0000-00-00T00:00:00]"); /* default time */
	2610	#endif
	2611
	2612	SL_ENTER(_("sh_unix_gmttime"));
	2613
	2614	if (sh_unix_use_localtime == S_FALSE)
[131]	2615	{
	2616	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
	2617	time_ptr = gmtime_r (&thetime, &time_tm);
	2618	#else
	2619	time_ptr = gmtime (&thetime);
	2620	#endif
	2621	}
[1]	2622	else
[131]	2623	{
	2624	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
	2625	time_ptr = localtime_r (&thetime, &time_tm);
	2626	#else
	2627	time_ptr = localtime (&thetime);
	2628	#endif
	2629	}
[1]	2630	if (time_ptr != NULL)
	2631	{
	2632	status = strftime (AsciiTime, 80,
	2633	#ifdef SH_USE_XML
	2634	_("%Y-%m-%dT%H:%M:%S"),
	2635	#else
	2636	_("[%Y-%m-%dT%H:%M:%S]"),
	2637	#endif
	2638	time_ptr);
	2639
[132]	2640	if ( (status == 0) \|\| (status == 80) )
	2641	sl_strlcpy(buffer, _(deftime), len);
[1]	2642	else
[132]	2643	sl_strlcpy(buffer, AsciiTime, len);
	2644	SL_RETURN( buffer, _("sh_unix_gmttime"));
[1]	2645	}
	2646
	2647	/* last resort
	2648	*/
[132]	2649	sl_strlcpy(buffer, _(deftime), len);
	2650	SL_RETURN( buffer, _("sh_unix_gmttime"));
[1]	2651	}
	2652
	2653
[132]	2654	char * sh_unix_getUIDdir (int level, uid_t uid, char * out, size_t len)
[1]	2655	{
	2656	struct passwd * tempres;
	2657	int status = 0;
[264]	2658
[131]	2659	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
	2660	struct passwd pwd;
[227]	2661	char * buffer;
[131]	2662	#endif
[132]	2663	char errbuf[SH_ERRBUF_SIZE];
[1]	2664
	2665	SL_ENTER(_("sh_unix_getUIDdir"));
	2666
[131]	2667	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
[227]	2668	buffer = SH_ALLOC(SH_PWBUF_SIZE);
	2669	sh_getpwuid_r(uid, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
[131]	2670	#else
[1]	2671	errno = 0;
	2672	tempres = sh_getpwuid(uid);
	2673	status = errno;
[131]	2674	#endif
[1]	2675
	2676	if (tempres == NULL) {
	2677	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
[132]	2678	sh_error_message(status, errbuf, sizeof(errbuf)),
[1]	2679	_("getpwuid"), (long) uid, _("completely missing"));
[227]	2680	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2681	SH_FREE(buffer);
	2682	#endif
[1]	2683	SL_RETURN( NULL, _("sh_unix_getUIDdir"));
	2684	}
	2685
	2686	if (tempres->pw_dir != NULL) {
[132]	2687	sl_strlcpy(out, tempres->pw_dir, len);
[227]	2688	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2689	SH_FREE(buffer);
	2690	#endif
[132]	2691	SL_RETURN( out, _("sh_unix_getUIDdir"));
[1]	2692	} else {
	2693	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
[132]	2694	sh_error_message(status, errbuf, sizeof(errbuf)),
[1]	2695	_("getpwuid"), (long) uid, _("pw_dir"));
[227]	2696	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2697	SH_FREE(buffer);
	2698	#endif
[1]	2699	SL_RETURN( NULL, _("sh_unix_getUIDdir"));
	2700	}
	2701	}
	2702
[264]	2703	/* ------------------- Caching ----------------*/
	2704	#include "zAVLTree.h"
[132]	2705
[264]	2706	#define CACHE_GID 0
	2707	#define CACHE_UID 1
	2708
	2709	struct user_id {
	2710	char * name;
	2711	uid_t id;
	2712	struct user_id * next;
	2713	};
	2714
	2715	static struct user_id * uid_list = NULL;
	2716	static struct user_id * gid_list = NULL;
	2717
	2718	SH_MUTEX_STATIC(mutex_cache, PTHREAD_MUTEX_INITIALIZER);
	2719
	2720	static void sh_userid_free(struct user_id * item)
	2721	{
	2722	while (item)
	2723	{
	2724	struct user_id * user = item;
	2725	item = item->next;
	2726
	2727	SH_FREE(user->name);
	2728	SH_FREE(user);
	2729	}
	2730	return;
	2731	}
	2732
	2733	void sh_userid_destroy ()
	2734	{
	2735	struct user_id * tmp_uid;
	2736	struct user_id * tmp_gid;
	2737
	2738	SH_MUTEX_LOCK_UNSAFE(mutex_cache);
	2739	tmp_gid = gid_list;
	2740	gid_list = NULL;
	2741	tmp_uid = uid_list;
	2742	uid_list = NULL;
	2743	SH_MUTEX_UNLOCK_UNSAFE(mutex_cache);
	2744
	2745	sh_userid_free(tmp_uid);
	2746	sh_userid_free(tmp_gid);
	2747	return;
	2748	}
	2749
	2750	static void sh_userid_additem(struct user_id * list, struct user_id * item)
	2751	{
[383]	2752	if (list)
	2753	{
	2754	while (list && list->next)
	2755	list = list->next;
	2756	list->next = item;
	2757	}
[264]	2758	return;
	2759	}
	2760
	2761	static void sh_userid_add(uid_t id, char * username, int which)
	2762	{
	2763	size_t len;
	2764	struct user_id * user = SH_ALLOC(sizeof(struct user_id));
	2765
	2766	if (username)
	2767	len = strlen(username) + 1;
	2768	else
	2769	len = 1;
	2770
	2771	user->name = SH_ALLOC(len);
	2772	user->id = id;
	2773	if (username)
	2774	sl_strlcpy(user->name, username, len);
	2775	else
	2776	user->name[0] = '\0';
	2777	user->next = NULL;
	2778
	2779	SH_MUTEX_LOCK(mutex_cache);
	2780	if (which == CACHE_UID)
	2781	{
	2782	if (!uid_list)
	2783	uid_list = user;
	2784	else
	2785	sh_userid_additem(uid_list, user);
	2786	}
	2787	else
	2788	{
	2789	if (!gid_list)
	2790	gid_list = user;
	2791	else
	2792	sh_userid_additem(gid_list, user);
	2793	}
	2794	SH_MUTEX_UNLOCK(mutex_cache);
	2795
	2796	return;
	2797	}
	2798
	2799	static char * sh_userid_search(struct user_id * list, uid_t id)
	2800	{
	2801	while (list)
	2802	{
	2803	if (list->id == id)
	2804	return list->name;
	2805	list = list->next;
	2806	}
	2807	return NULL;
	2808	}
	2809
	2810	static char * sh_userid_get (uid_t id, int which, char * out, size_t len)
	2811	{
	2812	char * user = NULL;
	2813
	2814	SH_MUTEX_LOCK_UNSAFE(mutex_cache);
	2815	if (which == CACHE_UID)
	2816	user = sh_userid_search(uid_list, id);
	2817	else
	2818	user = sh_userid_search(gid_list, id);
	2819	if (user)
	2820	{
	2821	sl_strlcpy(out, user, len);
	2822	user = out;
	2823	}
	2824	SH_MUTEX_UNLOCK_UNSAFE(mutex_cache);
	2825
	2826	return user;
	2827	}
	2828
	2829	/* --------- end caching code --------- */
[534]	2830
	2831	#include "sh_subuid.h"
	2832
[132]	2833	char * sh_unix_getUIDname (int level, uid_t uid, char * out, size_t len)
[1]	2834	{
	2835	struct passwd * tempres;
[131]	2836	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
	2837	struct passwd pwd;
[227]	2838	char * buffer;
[131]	2839	#endif
[1]	2840	int status = 0;
[132]	2841	char errbuf[SH_ERRBUF_SIZE];
[264]	2842	char * tmp;
[1]	2843
	2844	SL_ENTER(_("sh_unix_getUIDname"));
	2845
[264]	2846	tmp = sh_userid_get(uid, CACHE_UID, out, len);
	2847
	2848	if (tmp)
	2849	{
	2850	if (tmp[0] != '\0')
	2851	{
	2852	SL_RETURN( out, _("sh_unix_getUIDname"));
	2853	}
	2854	else
	2855	{
	2856	SL_RETURN( NULL, _("sh_unix_getUIDname"));
	2857	}
[132]	2858	}
[1]	2859
[131]	2860	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETPWUID_R)
[227]	2861	buffer = SH_ALLOC(SH_PWBUF_SIZE);
	2862	sh_getpwuid_r(uid, &pwd, buffer, SH_PWBUF_SIZE, &tempres);
[131]	2863	#else
[1]	2864	errno = 0;
	2865	tempres = sh_getpwuid(uid);
	2866	status = errno;
[131]	2867	#endif
[1]	2868
[534]	2869	/* case 1: we have it
	2870	*/
	2871	if (tempres && tempres->pw_name != NULL)
[264]	2872	{
	2873
	2874	sl_strlcpy(out, tempres->pw_name, len);
	2875	sh_userid_add(uid, out, CACHE_UID);
	2876
[227]	2877	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
[264]	2878	SH_FREE(buffer);
[227]	2879	#endif
[264]	2880
	2881	SL_RETURN( out, _("sh_unix_getUIDname"));
[534]	2882	}
	2883
	2884	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2885	SH_FREE(buffer);
	2886	#endif
	2887
	2888	if (tempres == NULL)
[264]	2889	{
[534]	2890	char * pwname = sh_get_subuid ((unsigned long) uid);
	2891
	2892	if (pwname)
	2893	{
	2894	sl_strlcpy(out, pwname, len);
	2895	sh_userid_add(uid, out, CACHE_UID);
	2896	SL_RETURN( out, _("sh_unix_getUIDname"));
	2897	}
	2898
[264]	2899	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
	2900	sh_error_message(status, errbuf, sizeof(errbuf)),
[534]	2901	_("getpwuid"), (long) uid, _("completely missing"));
	2902	sh_userid_add(uid, NULL, CACHE_UID);
[264]	2903	SL_RETURN( NULL, _("sh_unix_getUIDname"));
	2904	}
[534]	2905
	2906
	2907	/* getwpuid returns struct, but no pw_name
	2908	*/
	2909	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_PWNULL,
	2910	sh_error_message(status, errbuf, sizeof(errbuf)),
	2911	_("getpwuid"), (long) uid, _("pw_user"));
	2912	SL_RETURN( NULL, _("sh_unix_getUIDname"));
[1]	2913	}
	2914
[132]	2915	char * sh_unix_getGIDname (int level, gid_t gid, char * out, size_t len)
[1]	2916	{
	2917	struct group * tempres;
	2918	int status = 0;
[264]	2919
[131]	2920	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2921	struct group grp;
[227]	2922	char * buffer;
[131]	2923	#endif
[132]	2924	char errbuf[SH_ERRBUF_SIZE];
[264]	2925	char * tmp;
[131]	2926
[1]	2927	SL_ENTER(_("sh_unix_getGIDname"));
	2928
[264]	2929	tmp = sh_userid_get((uid_t)gid, CACHE_GID, out, len);
	2930
	2931	if (tmp)
	2932	{
	2933	if (tmp[0] != '\0')
	2934	{
	2935	SL_RETURN( out, _("sh_unix_getGIDname"));
	2936	}
	2937	else
	2938	{
	2939	SL_RETURN( NULL, _("sh_unix_getGIDname"));
	2940	}
[132]	2941	}
	2942
[131]	2943	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
[227]	2944	buffer = SH_ALLOC(SH_GRBUF_SIZE);
	2945	status = sh_getgrgid_r(gid, &grp, buffer, SH_GRBUF_SIZE, &tempres);
[131]	2946	#else
[1]	2947	errno = 0;
	2948	tempres = sh_getgrgid(gid);
	2949	status = errno;
[131]	2950	#endif
[1]	2951
[428]	2952	if (status == ERANGE)
	2953	{
	2954	static int seen = 0;
	2955
	2956	if (seen == 0)
	2957	{
	2958	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
	2959	sh_error_message(status, errbuf, sizeof(errbuf)),
	2960	_("getgrgid"), (long) gid, _("line too long in group entry"));
	2961	++seen;
	2962	}
	2963
	2964	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
	2965	SH_FREE(buffer);
	2966	#endif
	2967
	2968	sh_userid_add(gid, NULL, CACHE_GID);
	2969	SL_RETURN( NULL, _("sh_unix_getGIDname"));
	2970	}
	2971
[534]	2972	if (tempres && tempres->gr_name != NULL)
[264]	2973	{
[1]	2974
[264]	2975	sl_strlcpy(out, tempres->gr_name, len);
	2976	sh_userid_add((uid_t)gid, out, CACHE_GID);
	2977
[227]	2978	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
[264]	2979	SH_FREE(buffer);
[227]	2980	#endif
[264]	2981
	2982	SL_RETURN( out, _("sh_unix_getGIDname"));
	2983	}
	2984
[227]	2985	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GETGRGID_R)
[534]	2986	SH_FREE(buffer);
[227]	2987	#endif
[264]	2988
[534]	2989	if (tempres == NULL)
	2990	{
	2991	char * grname = sh_get_subgid ((unsigned long) gid);
	2992
	2993	if (grname)
	2994	{
	2995	sl_strlcpy(out, grname, len);
	2996	sh_userid_add((uid_t)gid, out, CACHE_GID);
	2997	SL_RETURN( out, _("sh_unix_getGIDname"));
	2998	}
	2999
	3000	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
	3001	sh_error_message(status, errbuf, sizeof(errbuf)),
	3002	_("getgrgid"), (long) gid, _("completely missing"));
	3003	sh_userid_add(gid, NULL, CACHE_GID);
[264]	3004	SL_RETURN( NULL, _("sh_unix_getGIDname"));
	3005	}
[534]	3006
	3007	sh_error_handle (level, FIL__, __LINE__, EINVAL, MSG_E_GRNULL,
	3008	sh_error_message(status, errbuf, sizeof(errbuf)),
	3009	_("getgrgid"), (long) gid, _("gr_name"));
	3010	SL_RETURN( NULL, _("sh_unix_getGIDname"));
[1]	3011	}
	3012
	3013	int sh_unix_getUser ()
	3014	{
	3015	char * p;
	3016	uid_t seuid, sruid;
[132]	3017	char user[USER_MAX];
	3018	char dir[SH_PATHBUF];
[1]	3019
	3020	SL_ENTER(_("sh_unix_getUser"));
	3021
	3022	seuid = geteuid();
	3023
	3024	sh.effective.uid = seuid;
	3025
[132]	3026	p = sh_unix_getUIDdir (SH_ERR_ERR, seuid, dir, sizeof(dir));
[1]	3027
	3028	if (p == NULL)
	3029	SL_RETURN((-1), _("sh_unix_getUser"));
	3030	else
	3031	{
	3032	if (sl_strlen(p) >= SH_PATHBUF) {
	3033	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
	3034	_("getpwuid"), (long) seuid, _("pw_home"));
	3035	SL_RETURN((-1), _("sh_unix_getUser"));
	3036	} else {
	3037	sl_strlcpy ( sh.effective.home, p, SH_PATHBUF);
	3038	}
	3039	}
	3040
	3041	sruid = getuid();
	3042
	3043	sh.real.uid = sruid;
	3044
[132]	3045	p = sh_unix_getUIDname (SH_ERR_ERR, sruid, user, sizeof(user));
[1]	3046	if (p == NULL)
	3047	SL_RETURN((-1), _("sh_unix_getUser"));
	3048	else
	3049	{
	3050	if (sl_strlen(p) >= USER_MAX) {
	3051	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
	3052	_("getpwuid"), (long) sruid, _("pw_user"));
	3053	SL_RETURN((-1), _("sh_unix_getUser"));
	3054	} else {
	3055	sl_strlcpy ( sh.real.user, p, USER_MAX);
	3056	}
	3057	}
	3058
[132]	3059	p = sh_unix_getUIDdir (SH_ERR_ERR, sruid, dir, sizeof(dir));
[1]	3060
	3061	if (p == NULL)
	3062	SL_RETURN((-1), _("sh_unix_getUser"));
	3063	else
	3064	{
	3065	if (sl_strlen(p) >= SH_PATHBUF) {
	3066	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, EINVAL, MSG_E_PWLONG,
	3067	_("getpwuid"), (long) sruid, _("pw_home"));
	3068	SL_RETURN((-1), _("sh_unix_getUser"));
	3069	} else {
	3070	sl_strlcpy ( sh.real.home, p, SH_PATHBUF);
	3071	}
	3072	}
	3073
	3074	SL_RETURN((0), _("sh_unix_getUser"));
	3075
	3076	/* notreached */
	3077	}
	3078
[534]	3079	/* return >0 on success, -1 on EOF */
[1]	3080	int sh_unix_getline (SL_TICKET fd, char * line, int sizeofline)
	3081	{
	3082	register int count;
	3083	register int n = 0;
	3084	char c;
	3085
	3086	SL_ENTER(_("sh_unix_getline"));
	3087
	3088	if (sizeofline < 2) {
[34]	3089	line[0] = '\0';
[1]	3090	SL_RETURN((0), _("sh_unix_getline"));
	3091	}
	3092
[34]	3093	--sizeofline;
	3094
[1]	3095	while (n < sizeofline) {
	3096
	3097	count = sl_read (fd, &c, 1);
	3098
	3099	/* end of file
	3100	*/
	3101	if (count < 1) {
	3102	line[n] = '\0';
	3103	n = -1;
	3104	break;
	3105	}
	3106
	3107	if (/* c != '\0' && */ c != '\n') {
	3108	line[n] = c;
	3109	++n;
	3110	} else if (c == '\n') {
	3111	if (n > 0) {
	3112	line[n] = '\0';
	3113	break;
	3114	} else {
	3115	line[n] = '\n'; /* get newline only if only char on line */
	3116	++n;
	3117	line[n] = '\0';
	3118	break;
	3119	}
	3120	} else {
	3121	line[n] = '\0';
	3122	break;
	3123	}
	3124
	3125	}
	3126
	3127
	3128	line[sizeofline] = '\0'; /* make sure line is terminated */
	3129	SL_RETURN((n), _("sh_unix_getline"));
	3130	}
	3131
	3132
	3133	#if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE)
	3134
	3135	/**************************************************************
	3136	*
	3137	* --- FILE INFO ---
	3138	*
	3139	**************************************************************/
	3140
[580]	3141	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	3142
[10]	3143	#if defined(__linux__)
[1]	3144
	3145	/* --- Determine ext2fs file attributes. ---
	3146	*/
	3147	#include <sys/ioctl.h>
	3148	#if defined(HAVE_EXT2FS_EXT2_FS_H)
	3149	#include <ext2fs/ext2_fs.h>
[580]	3150	#elif defined(HAVE_LINUX_EXT2_FS_H)
[1]	3151	#include <linux/ext2_fs.h>
	3152	#endif
	3153
[10]	3154	/* __linux__ includes */
	3155	#endif
	3156
[1]	3157	static
	3158	int sh_unix_getinfo_attr (char * name,
	3159	unsigned long * flags,
	3160	char * c_attr,
[10]	3161	int fd, struct stat * buf)
[1]	3162	{
	3163
	3164	/* TAKEN FROM:
	3165	*
	3166	* lsattr.c - List file attributes on an ext2 file system
	3167	*
	3168	* Copyright (C) 1993, 1994 Remy Card <card@masi.ibp.fr>
	3169	* Laboratoire MASI, Institut Blaise Pascal
	3170	* Universite Pierre et Marie Curie (Paris VI)
	3171	*
	3172	* This file can be redistributed under the terms of the GNU General
	3173	* Public License
	3174	*/
	3175
	3176	#ifdef HAVE_STAT_FLAGS
	3177
	3178	SL_ENTER(_("sh_unix_getinfo_attr"));
	3179
	3180	*flags = 0;
	3181
[10]	3182	/* cast to void to avoid compiler warning about unused parameters */
	3183	(void) fd;
	3184	(void) name;
[1]	3185
[10]	3186	#ifdef UF_NODUMP
	3187	if (buf->st_flags & UF_NODUMP) {
	3188	*flags \|= UF_NODUMP;
	3189	c_attr[0] = 'd';
	3190	}
	3191	#endif
[1]	3192	#ifdef UF_IMMUTABLE
[10]	3193	if (buf->st_flags & UF_IMMUTABLE) {
	3194	*flags \|= UF_IMMUTABLE;
	3195	c_attr[1] = 'i';
	3196	}
[1]	3197	#endif
	3198	#ifdef UF_APPEND
[10]	3199	if (buf->st_flags & UF_APPEND) {
	3200	*flags \|= UF_APPEND;
	3201	c_attr[2] = 'a';
	3202	}
[1]	3203	#endif
[10]	3204	#ifdef UF_NOUNLINK
	3205	if (buf->st_flags & UF_NOUNLINK) {
	3206	*flags \|= UF_NOUNLINK;
	3207	c_attr[3] = 'u';
	3208	}
[1]	3209	#endif
[10]	3210	#ifdef UF_OPAQUE
	3211	if (buf->st_flags & UF_OPAQUE) {
	3212	*flags \|= UF_OPAQUE;
	3213	c_attr[4] = 'o';
	3214	}
	3215	#endif
	3216	#ifdef SF_ARCHIVED
	3217	if (buf->st_flags & SF_ARCHIVED) {
	3218	*flags \|= SF_ARCHIVED;
	3219	c_attr[5] = 'R';
	3220	}
	3221
	3222	#endif
	3223	#ifdef SF_IMMUTABLE
	3224	if (buf->st_flags & SF_IMMUTABLE) {
	3225	*flags \|= SF_IMMUTABLE;
	3226	c_attr[6] = 'I';
	3227	}
	3228	#endif
	3229	#ifdef SF_APPEND
	3230	if (buf->st_flags & SF_APPEND) {
	3231	*flags \|= SF_APPEND;
	3232	c_attr[7] = 'A';
	3233	}
	3234	#endif
	3235	#ifdef SF_NOUNLINK
	3236	if (buf->st_flags & SF_NOUNLINK) {
	3237	*flags \|= SF_NOUNLINK;
	3238	c_attr[8] = 'U';
	3239	}
	3240	#endif
[1]	3241
[10]	3242	/* ! HAVE_STAT_FLAGS */
[1]	3243	#else
	3244
	3245	#ifdef HAVE_EXT2_IOCTLS
	3246	int /* fd, */ r, f;
[580]	3247	unsigned long keep_flags = 0;
[1]	3248
	3249	SL_ENTER(_("sh_unix_getinfo_attr"));
	3250
	3251	*flags = 0;
[580]	3252
[10]	3253	(void) buf;
[1]	3254
	3255	/* open() -> aud_open() R.Wichmann
	3256	fd = aud_open (FIL__, __LINE__, SL_YESPRIV, name, O_RDONLY\|O_NONBLOCK, 0);
	3257	*/
	3258
	3259	if (fd == -1 \|\| name == NULL)
	3260	SL_RETURN(-1, _("sh_unix_getinfo_attr"));
	3261
	3262
[580]	3263	r = ioctl (fd, FS_IOC_GETFLAGS, &f);
[252]	3264	/* sl_close_fd (FIL__, __LINE__, fd); */
[1]	3265
	3266	if (r == -1)
	3267	SL_RETURN(-1, _("sh_unix_getinfo_attr"));
	3268
[10]	3269	if (f == 0)
	3270	SL_RETURN(0, _("sh_unix_getinfo_attr"));
	3271
[1]	3272	*flags = f;
	3273
[580]	3274	/* ! HAVE_FS_IOCTLS */
[1]	3275	#else
	3276
	3277	SL_ENTER(_("sh_unix_getinfo_attr"));
	3278
	3279	flags = 0; / modified by R.Wichmann */
	3280
[580]	3281	/* ! HAVE_FS_IOCTLS */
[1]	3282	#endif
	3283	/*
	3284	* END
	3285	*
	3286	* lsattr.c - List file attributes on an ext2 file system
	3287	*/
	3288
[10]	3289	if (*flags == 0)
	3290	goto theend;
	3291
[580]	3292	#ifdef FS_SECRM_FL
	3293	if ( (*flags & FS_SECRM_FL) != 0 ) { c_attr[0] = 's'; keep_flags \|= FS_SECRM_FL; }
[1]	3294	#endif
[580]	3295	#ifdef FS_UNRM_FL
	3296	if ( (*flags & FS_UNRM_FL) != 0 ) { c_attr[1] = 'u'; keep_flags \|= FS_UNRM_FL; }
[1]	3297	#endif
[580]	3298	#ifdef FS_SYNC_FL
	3299	if ( (*flags & FS_SYNC_FL) != 0 ) { c_attr[2] = 'S'; keep_flags \|= FS_SYNC_FL; }
[1]	3300	#endif
[580]	3301	#ifdef FS_IMMUTABLE_FL
	3302	if ( (*flags & FS_IMMUTABLE_FL) != 0) { c_attr[3] = 'i'; keep_flags \|= FS_IMMUTABLE_FL; }
[1]	3303	#endif
[580]	3304	#ifdef FS_APPEND_FL
	3305	if ( (*flags & FS_APPEND_FL) != 0 ) { c_attr[4] = 'a'; keep_flags \|= FS_APPEND_FL; }
[1]	3306	#endif
[580]	3307	#ifdef FS_NODUMP_FL
	3308	if ( (*flags & FS_NODUMP_FL) != 0 ) { c_attr[5] = 'd'; keep_flags \|= FS_NODUMP_FL; }
[1]	3309	#endif
[580]	3310	#ifdef FS_NOATIME_FL
	3311	if ( (*flags & FS_NOATIME_FL) != 0) { c_attr[6] = 'A'; keep_flags \|= FS_NOATIME_FL; }
[1]	3312	#endif
[580]	3313	#ifdef FS_COMPR_FL
	3314	if ( (*flags & FS_COMPR_FL) != 0 ) { c_attr[7] = 'c'; keep_flags \|= FS_COMPR_FL; }
[1]	3315	#endif
[10]	3316
[580]	3317	#ifdef FS_TOPDIR_FL
	3318	if ( (*flags & FS_TOPDIR_FL) != 0 ) { c_attr[8] = 'T'; keep_flags \|= FS_TOPDIR_FL; }
[1]	3319	#endif
[580]	3320	#ifdef FS_DIRSYNC_FL
	3321	if ( (*flags & FS_DIRSYNC_FL) != 0 ) { c_attr[9] = 'D'; keep_flags \|= FS_DIRSYNC_FL; }
[1]	3322	#endif
[580]	3323	#ifdef FS_NOTAIL_FL
	3324	if ( (*flags & FS_NOTAIL_FL) != 0 ) { c_attr[10] = 't'; keep_flags \|= FS_NOTAIL_FL; }
[1]	3325	#endif
[580]	3326	#ifdef FS_JOURNAL_DATA_FL
	3327	if ( (*flags & FS_JOURNAL_DATA_FL) != 0) { c_attr[11] = 'j'; keep_flags \|= FS_JOURNAL_DATA_FL; }
[1]	3328	#endif
	3329
[580]	3330	*flags = keep_flags;
	3331
[10]	3332	theend:
[580]	3333	/* !HAVE_STAT_FLAGS */
[10]	3334	#endif
	3335
[580]	3336	c_attr[ATTRBUF_USED] = '\0';
[1]	3337
	3338	SL_RETURN(0, _("sh_unix_getinfo_attr"));
	3339	}
	3340
[10]	3341	/* defined(__linux__) \|\| defined(HAVE_STAT_FLAGS) */
[1]	3342	#endif
	3343
	3344	/* determine file type
	3345	*/
	3346	static
	3347	int sh_unix_getinfo_type (struct stat * buf,
	3348	ShFileType * type,
	3349	char * c_mode)
	3350	{
	3351	SL_ENTER(_("sh_unix_getinfo_type"));
	3352
	3353	if ( S_ISREG(buf->st_mode) ) {
	3354	(*type) = SH_FILE_REGULAR;
	3355	c_mode[0] = '-';
	3356	}
	3357	else if ( S_ISLNK(buf->st_mode) ) {
	3358	(*type) = SH_FILE_SYMLINK;
	3359	c_mode[0] = 'l';
	3360	}
	3361	else if ( S_ISDIR(buf->st_mode) ) {
	3362	(*type) = SH_FILE_DIRECTORY;
	3363	c_mode[0] = 'd';
	3364	}
	3365	else if ( S_ISCHR(buf->st_mode) ) {
	3366	(*type) = SH_FILE_CDEV;
	3367	c_mode[0] = 'c';
	3368	}
	3369	else if ( S_ISBLK(buf->st_mode) ) {
	3370	(*type) = SH_FILE_BDEV;
	3371	c_mode[0] = 'b';
	3372	}
	3373	else if ( S_ISFIFO(buf->st_mode) ) {
	3374	(*type) = SH_FILE_FIFO;
	3375	c_mode[0] = '\|';
	3376	}
	3377	else if ( S_ISSOCK(buf->st_mode) ) {
	3378	(*type) = SH_FILE_SOCKET;
	3379	c_mode[0] = 's';
	3380	}
[40]	3381	else if ( S_ISDOOR(buf->st_mode) ) {
	3382	(*type) = SH_FILE_DOOR;
	3383	c_mode[0] = 'D';
	3384	}
	3385	else if ( S_ISPORT(buf->st_mode) ) {
	3386	(*type) = SH_FILE_PORT;
	3387	c_mode[0] = 'P';
	3388	}
[1]	3389	else {
	3390	(*type) = SH_FILE_UNKNOWN;
	3391	c_mode[0] = '?';
	3392	}
	3393
	3394	SL_RETURN(0, _("sh_unix_getinfo_type"));
	3395	}
	3396
	3397	int sh_unix_get_ftype(char * fullpath)
	3398	{
[149]	3399	char c_mode[CMODE_SIZE];
[1]	3400	struct stat buf;
	3401	ShFileType type;
	3402	int res;
	3403
	3404	SL_ENTER(_("sh_unix_get_ftype"));
	3405
	3406	res = retry_lstat(FIL__, __LINE__, fullpath, &buf);
	3407
	3408	if (res < 0)
	3409	SL_RETURN(SH_FILE_UNKNOWN, _("sh_unix_getinfo_type"));
	3410
	3411	sh_unix_getinfo_type (&buf, &type, c_mode);
	3412
	3413	SL_RETURN(type, _("sh_unix_get_ftype"));
	3414	}
	3415
	3416
	3417	static
	3418	int sh_unix_getinfo_mode (struct stat *buf,
	3419	unsigned int * mode,
	3420	char * c_mode)
	3421	{
	3422
	3423	SL_ENTER(_("sh_unix_getinfo_mode"));
	3424
	3425	(*mode) = buf->st_mode;
	3426
	3427	/* make 'ls'-like string */
	3428
	3429	if ( (buf->st_mode & S_IRUSR) != 0 ) c_mode[1] = 'r';
	3430	if ( (buf->st_mode & S_IWUSR) != 0 ) c_mode[2] = 'w';
	3431	if ( (buf->st_mode & S_IXUSR) != 0 ) {
	3432	if ((buf->st_mode & S_ISUID) != 0 ) c_mode[3] = 's';
	3433	else c_mode[3] = 'x';
	3434	} else {
	3435	if ((buf->st_mode & S_ISUID) != 0 ) c_mode[3] = 'S';
	3436	}
	3437
	3438	if ( (buf->st_mode & S_IRGRP) != 0 ) c_mode[4] = 'r';
	3439	if ( (buf->st_mode & S_IWGRP) != 0 ) c_mode[5] = 'w';
	3440	if ( (buf->st_mode & S_IXGRP) != 0 ) {
	3441	if ((buf->st_mode & S_ISGID) != 0 ) c_mode[6] = 's';
	3442	else c_mode[6] = 'x';
	3443	} else {
	3444	if ((buf->st_mode & S_ISGID) != 0 ) c_mode[6] = 'S';
	3445	}
	3446
	3447	if ( (buf->st_mode & S_IROTH) != 0 ) c_mode[7] = 'r';
	3448	if ( (buf->st_mode & S_IWOTH) != 0 ) c_mode[8] = 'w';
	3449	#ifdef S_ISVTX /* not POSIX */
	3450	if ( (buf->st_mode & S_IXOTH) != 0 ) {
	3451	if ((buf->st_mode & S_ISVTX) != 0 ) c_mode[9] = 't';
	3452	else c_mode[9] = 'x';
	3453	} else {
	3454	if ((buf->st_mode & S_ISVTX) != 0 ) c_mode[9] = 'T';
	3455	}
	3456	#else
	3457	if ( (buf->st_mode & S_IXOTH) != 0 ) c_mode[9] = 'x';
	3458	#endif
	3459
	3460	SL_RETURN(0, _("sh_unix_getinfo_mode"));
	3461	}
	3462
	3463
	3464	long IO_Limit = 0;
	3465
	3466	void sh_unix_io_pause ()
	3467	{
	3468	long runtime;
	3469	float someval;
	3470	unsigned long sometime;
	3471
	3472	if (IO_Limit == 0)
	3473	{
	3474	return;
	3475	}
	3476	else
	3477	{
	3478	runtime = (long) (time(NULL) - sh.statistics.time_start);
	3479
	3480	if (runtime > 0 && (long)(sh.statistics.bytes_hashed/runtime) > IO_Limit)
	3481	{
	3482	someval = sh.statistics.bytes_hashed - (IO_Limit * runtime);
	3483	someval /= (float) IO_Limit;
	3484	if (someval < 1.0)
	3485	{
	3486	someval = 1000; / milliseconds in a second */
	3487	sometime = (unsigned long) someval;
	3488	retry_msleep(0, sometime);
	3489	}
	3490	else
	3491	{
	3492	sometime = (unsigned long) someval;
	3493	retry_msleep (sometime, 0);
	3494	}
	3495	}
	3496	}
	3497	return;
	3498	}
	3499
[22]	3500	int sh_unix_set_io_limit (const char * c)
[1]	3501	{
	3502	long val;
	3503
	3504	SL_ENTER(_("sh_unix_set_io_limit"));
	3505
	3506	val = strtol (c, (char **)NULL, 10);
	3507	if (val < 0)
	3508	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	3509	_("set I/O limit"), c);
	3510
	3511	val = (val < 0 ? 0 : val);
	3512
	3513	IO_Limit = val * 1024;
	3514	SL_RETURN( 0, _("sh_unix_set_io_limit"));
	3515	}
	3516
	3517	/* obtain file info
	3518	*/
	3519	extern int flag_err_debug;
	3520
	3521	#include "sh_ignore.h"
	3522
[425]	3523	int sh_unix_checksum_size (char * filename, off_t size, int is_max_size,
[481]	3524	char * fileHash, int alert_timeout, SL_TICKET fd, unsigned long mask)
[19]	3525	{
[227]	3526	file_type * tmpFile;
[19]	3527	int status;
	3528
	3529	SL_ENTER(_("sh_unix_checksum_size"));
	3530
[227]	3531	tmpFile = SH_ALLOC(sizeof(file_type));
	3532	tmpFile->link_path = NULL;
[169]	3533
[59]	3534	if (sh.flag.checkSum != SH_CHECK_INIT)
	3535	{
	3536	/* lookup file in database */
[425]	3537	if (is_max_size == S_TRUE) {
	3538	status = sh_hash_get_it (filename, tmpFile, NULL);
	3539	if ((status != 0) \|\| (tmpFile->size > size)) {
	3540	goto out;
	3541	}
	3542	} else {
	3543	tmpFile->size = size;
[59]	3544	}
	3545	}
	3546	else
	3547	{
[425]	3548	tmpFile->size = size;
[59]	3549	}
[19]	3550
[425]	3551	/* if last <= current get checksum */
	3552	if (tmpFile->size <= size)
[19]	3553	{
[133]	3554	char hashbuf[KEYBUF_SIZE];
[227]	3555	UINT64 local_length = (UINT64) (tmpFile->size < 0 ? 0 : tmpFile->size);
[481]	3556	if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(mask);
[22]	3557	sl_strlcpy(fileHash,
[153]	3558	sh_tiger_generic_hash (filename, fd, &(local_length),
[133]	3559	alert_timeout, hashbuf, sizeof(hashbuf)),
[59]	3560	KEY_LEN+1);
[68]	3561
[107]	3562	/* return */
[227]	3563	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	3564	SH_FREE(tmpFile);
[19]	3565	SL_RETURN( 0, _("sh_unix_checksum_size"));
	3566	}
	3567
	3568	out:
[227]	3569	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	3570	SH_FREE(tmpFile);
[93]	3571	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[19]	3572	SL_RETURN( -1, _("sh_unix_checksum_size"));
	3573	}
	3574
[425]	3575	/********************************************************
	3576	* Search rotated logfile
	3577	*/
	3578	extern char * sh_rotated_log_search(const char * path, struct stat * buf);
	3579
	3580	int sh_check_rotated_log (const char * path,
[481]	3581	UINT64 old_size, UINT64 old_inode, const char * old_hash, unsigned long mask)
[425]	3582	{
	3583	struct stat obuf;
	3584	UINT64 length_nolim = TIGER_NOLIM;
	3585	int retval = S_FALSE;
	3586
	3587	if (old_size != length_nolim)
	3588	{
	3589	char hashbuf[KEYBUF_SIZE];
	3590	char * rotated_file;
	3591
	3592	obuf.st_ino = old_inode;
	3593	rotated_file = sh_rotated_log_search(path, &obuf);
	3594
	3595	if (rotated_file && (0 != strcmp(path, rotated_file)))
	3596	{
	3597	SL_TICKET fd = sl_open_fastread (FIL__, __LINE__, rotated_file, SL_YESPRIV);
	3598	if (!SL_ISERROR(fd))
	3599	{
[481]	3600	sh_unix_checksum_size (rotated_file, old_size, S_FALSE,
	3601	hashbuf, 120 /* alert_timeout */, fd, mask);
[425]	3602
	3603	sl_close(fd);
	3604
	3605	if (strncmp (old_hash, hashbuf, KEY_LEN) == 0) {
	3606	retval = S_TRUE;
	3607	}
	3608	}
	3609	}
[579]	3610	if (rotated_file) {
	3611	SH_FREE(rotated_file);
	3612	}
[425]	3613	}
	3614	return retval;
	3615	}
	3616
	3617
[68]	3618	int sh_unix_check_selinux = S_FALSE;
	3619	int sh_unix_check_acl = S_FALSE;
[580]	3620	int sh_unix_check_attributes = S_TRUE;
[68]	3621
	3622	#ifdef USE_ACL
	3623
	3624	#include <sys/acl.h>
	3625	static char * sh_unix_getinfo_acl (char * path, int fd, struct stat * buf)
	3626	{
	3627	/* system.posix_acl_access, system.posix_acl_default
	3628	*/
	3629	char * out = NULL;
	3630	char * collect = NULL;
	3631	char * tmp;
	3632	char * out_compact;
	3633	ssize_t len;
	3634	acl_t result;
	3635
	3636	SL_ENTER(_("sh_unix_getinfo_acl"));
	3637
	3638	result = (fd == -1) ?
	3639	acl_get_file (path, ACL_TYPE_ACCESS) :
	3640	acl_get_fd (fd);
	3641
	3642	if (result)
	3643	{
	3644	out = acl_to_text (result, &len);
	3645	if (out && (len > 0)) {
	3646	out_compact = sh_util_acl_compact (out, len);
	3647	acl_free(out);
	3648	if (out_compact)
	3649	{
	3650	collect = sh_util_strconcat (_("acl_access:"), out_compact, NULL);
	3651	SH_FREE(out_compact);
	3652	}
	3653	}
	3654	acl_free(result);
	3655	}
	3656
	3657
	3658	if ( S_ISDIR(buf->st_mode) )
	3659	{
	3660	result = acl_get_file (path, ACL_TYPE_DEFAULT);
	3661
	3662	if (result)
	3663	{
	3664	out = acl_to_text (result, &len);
	3665	if (out && (len > 0)) {
	3666	out_compact = sh_util_acl_compact (out, len);
	3667	acl_free(out);
	3668	if (out_compact) {
	3669	if (collect) {
	3670	tmp = sh_util_strconcat (_("acl_default:"),
	3671	out_compact, ":", collect, NULL);
	3672	SH_FREE(collect);
	3673	}
	3674	else {
	3675	tmp = sh_util_strconcat (_("acl_default:"), out_compact, NULL);
	3676	}
	3677	SH_FREE(out_compact);
	3678	collect = tmp;
	3679	}
	3680	}
	3681	acl_free(result);
	3682	}
	3683	}
	3684
	3685	SL_RETURN((collect),_("sh_unix_getinfo_acl"));
	3686	}
	3687	#endif
	3688
	3689	#ifdef USE_XATTR
	3690
	3691	#include <attr/xattr.h>
	3692	static char * sh_unix_getinfo_xattr_int (char * path, int fd, char * name)
	3693	{
	3694	char * out = NULL;
	3695	char * tmp = NULL;
	3696	size_t size = 256;
	3697	ssize_t result;
	3698
	3699	SL_ENTER(_("sh_unix_getinfo_xattr_int"));
	3700
	3701	out = SH_ALLOC(size);
	3702
	3703	result = (fd == -1) ?
	3704	lgetxattr (path, name, out, size-1) :
	3705	fgetxattr (fd, name, out, size-1);
	3706
	3707	if (result == -1 && errno == ERANGE)
	3708	{
	3709	SH_FREE(out);
	3710	result = (fd == -1) ?
	3711	lgetxattr (path, name, NULL, 0) :
	3712	fgetxattr (fd, name, NULL, 0);
	3713	size = result + 1;
	3714	out = SH_ALLOC(size);
	3715	result = (fd == -1) ?
	3716	lgetxattr (path, name, out, size-1) :
	3717	fgetxattr (fd, name, out, size-1);
	3718	}
	3719
	3720	if ((result > 0) && ((size_t)result < size))
	3721	{
	3722	out[size-1] = '\0';
	3723	tmp = out;
	3724	}
	3725	else
	3726	{
	3727	SH_FREE(out);
	3728	}
	3729
	3730	SL_RETURN((tmp),_("sh_unix_getinfo_xattr_int"));
	3731	}
	3732
	3733
	3734	static char * sh_unix_getinfo_xattr (char * path, int fd, struct stat * buf)
	3735	{
	3736	/* system.posix_acl_access, system.posix_acl_default, security.selinux
	3737	*/
	3738	char * tmp;
	3739	char * out = NULL;
	3740	char * collect = NULL;
	3741
	3742	SL_ENTER(_("sh_unix_getinfo_xattr"));
	3743
	3744	#ifdef USE_ACL
	3745	/*
	3746	* we need the acl_get_fd/acl_get_file functions, getxattr will only
	3747	* yield the raw bytes
	3748	*/
	3749	if (sh_unix_check_acl == S_TRUE)
	3750	{
	3751	out = sh_unix_getinfo_acl(path, fd, buf);
	3752
	3753	if (out)
	3754	{
	3755	collect = out;
	3756	}
	3757	}
[290]	3758	#else
	3759	(void) buf;
[68]	3760	#endif
	3761
[105]	3762	if (sh_unix_check_selinux == S_TRUE)
	3763	{
	3764	out = sh_unix_getinfo_xattr_int(path, fd, _("security.selinux"));
[68]	3765
[105]	3766	if (out)
	3767	{
	3768	if (collect) {
	3769	tmp = sh_util_strconcat(_("selinux:"), out, ":", collect, NULL);
	3770	SH_FREE(collect);
	3771	}
	3772	else {
	3773	tmp = sh_util_strconcat(_("selinux:"), out, NULL);
	3774	}
	3775	SH_FREE(out);
	3776	collect = tmp;
	3777	}
[68]	3778	}
	3779
	3780	SL_RETURN((collect),_("sh_unix_getinfo_xattr"));
	3781	}
	3782	#endif
	3783
[580]	3784	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
	3785	int sh_unix_setcheckattributes (const char * c)
	3786	{
	3787	int i;
	3788	SL_ENTER(_("sh_unix_setcheckattributes"));
	3789	i = sh_util_flagval(c, &(sh_unix_check_attributes));
	3790
	3791	SL_RETURN(i, _("sh_unix_setcheckattributes"));
	3792	}
	3793	#endif
	3794
[68]	3795	#ifdef USE_XATTR
	3796	int sh_unix_setcheckselinux (const char * c)
	3797	{
	3798	int i;
	3799	SL_ENTER(_("sh_unix_setcheckselinux"));
	3800	i = sh_util_flagval(c, &(sh_unix_check_selinux));
	3801
	3802	SL_RETURN(i, _("sh_unix_setcheckselinux"));
	3803	}
	3804	#endif
	3805
	3806	#ifdef USE_ACL
	3807	int sh_unix_setcheckacl (const char * c)
	3808	{
	3809	int i;
	3810	SL_ENTER(_("sh_unix_setcheckacl"));
	3811	i = sh_util_flagval(c, &(sh_unix_check_acl));
	3812
	3813	SL_RETURN(i, _("sh_unix_setcheckacl"));
	3814	}
	3815	#endif
	3816
[169]	3817	#ifdef HAVE_LIBZ
	3818	#include <zlib.h>
	3819	#endif
	3820
[367]	3821
	3822	static void * sh_dummy_filename;
[516]	3823	void * sh_dummy_tmp;
	3824	void * sh_dummy_tmp2;
[367]	3825
[373]	3826	int sh_unix_getinfo (int level, const char * filename, file_type * theFile,
[1]	3827	char * fileHash, int policy)
	3828	{
	3829	char timestr[81];
	3830	long runtim;
	3831	struct stat buf;
	3832	struct stat lbuf;
	3833	struct stat fbuf;
[367]	3834	volatile int stat_return;
	3835	volatile int stat_errno = 0;
[8]	3836
[1]	3837	ShFileType type;
	3838	unsigned int mode;
	3839	char * tmp;
	3840	char * tmp2;
[8]	3841
[1]	3842	char * linknamebuf;
[367]	3843	volatile int linksize;
[1]	3844
	3845	extern int get_the_fd (SL_TICKET ticket);
	3846
[367]	3847	volatile SL_TICKET rval_open;
	3848	volatile int err_open = 0;
[192]	3849
[367]	3850	volatile int fd;
	3851	volatile int fstat_return;
	3852	volatile int fstat_errno = 0;
	3853	volatile int try = 0;
[192]	3854
[167]	3855	sh_string * content = NULL;
	3856
[1]	3857	time_t tend;
	3858	time_t tstart;
	3859
	3860
	3861	char * path = NULL;
	3862
[367]	3863	volatile int alert_timeout = 120;
[1]	3864
	3865	path = theFile->fullpath;
	3866
	3867	SL_ENTER(_("sh_unix_getinfo"));
	3868
[481]	3869	if (!MODI_INITIALIZED(theFile->check_flags))
[381]	3870	{
	3871	tmp2 = sh_util_safe_name (theFile->fullpath);
	3872	SH_MUTEX_LOCK(mutex_thread_nolog);
	3873	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_SUBGPATH,
	3874	_("Uninitialized check mask"), _("sh_unix_getinfo"),
	3875	tmp2);
	3876	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	3877	SH_FREE(tmp2);
[481]	3878	SL_RETURN((-1),_("sh_unix_getinfo"));
[381]	3879	}
	3880
[367]	3881	/* Take the address to keep gcc from putting it into a register.
	3882	* Avoids the 'clobbered by longjmp' warning.
	3883	*/
	3884	sh_dummy_filename = (void *) &filename;
	3885	sh_dummy_tmp = (void *) &tmp;
	3886	sh_dummy_tmp2 = (void *) &tmp2;
	3887
[1]	3888	/* --- Stat the file, and get checksum. ---
	3889	*/
	3890	tstart = time(NULL);
[8]	3891
[1]	3892	stat_return = retry_lstat (FIL__, __LINE__,
	3893	path /* theFile->fullpath */, &buf);
	3894
[192]	3895	if (stat_return)
	3896	stat_errno = errno;
	3897
[252]	3898	theFile->link_path = NULL;
	3899
	3900	try_again:
	3901
[8]	3902	fd = -1;
	3903	fstat_return = -1;
	3904	rval_open = -1;
	3905
[1]	3906	if (stat_return == 0 && S_ISREG(buf.st_mode))
	3907	{
[248]	3908	rval_open = sl_open_fastread (FIL__, __LINE__,
	3909	path /* theFile->fullpath */, SL_YESPRIV);
[192]	3910	if (SL_ISERROR(rval_open))
[252]	3911	{
	3912	char * stale = sl_check_stale();
	3913
	3914	if (stale)
	3915	{
[367]	3916	SH_MUTEX_LOCK(mutex_thread_nolog);
[252]	3917	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, err_open, MSG_E_SUBGEN,
	3918	stale, _("sh_unix_getinfo_open"));
[367]	3919	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	3920	}
[1]	3921
[252]	3922	if (errno == EBADF && try == 0) /* obsolete, but we keep this, just in case */
	3923	{
[570]	3924	/* cppcheck-suppress syntaxError */
[252]	3925	++try;
	3926	goto try_again;
	3927	}
	3928	err_open = errno;
	3929	}
[251]	3930
[1]	3931	alert_timeout = 120; /* this is per 8K block now ! */
	3932
[8]	3933	if (path[1] == 'p' && path[5] == '/' && path[2] == 'r' &&
	3934	path[3] == 'o' && path[4] == 'c' && path[0] == '/')
[1]	3935	{
	3936	/* seven is magic */
	3937	alert_timeout = 7;
	3938	}
[8]	3939
	3940	fd = get_the_fd(rval_open);
[1]	3941	}
	3942
	3943	tend = time(NULL);
	3944
	3945	/* An unprivileged user may slow lstat/open to a crawl
	3946	* with clever path/symlink setup
	3947	*/
	3948	if ((tend - tstart) > (time_t) /* 60 */ 6)
	3949	{
	3950	tmp2 = sh_util_safe_name (theFile->fullpath);
[367]	3951	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	3952	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_TOOLATE,
	3953	(long)(tend - tstart), tmp2);
[367]	3954	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	3955	SH_FREE(tmp2);
	3956	}
[8]	3957
[1]	3958	if (fd >= 0)
[192]	3959	{
	3960	fstat_return = retry_fstat (FIL__, __LINE__, fd, &fbuf);
[251]	3961
[192]	3962	if (fstat_return)
[251]	3963	{
	3964	char * stale;
	3965
	3966	fstat_errno = errno;
	3967
	3968	stale = sl_check_stale();
	3969
	3970	if (stale)
	3971	{
[367]	3972	SH_MUTEX_LOCK(mutex_thread_nolog);
[251]	3973	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, fstat_errno,
	3974	MSG_E_SUBGEN,
	3975	stale, _("sh_unix_getinfo_fstat"));
[367]	3976	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[251]	3977	}
[252]	3978
	3979	if (try == 0) /* obsolete, but we keep this, just in case */
	3980	{
	3981	++try;
	3982	sl_close(rval_open);
	3983	goto try_again;
	3984	}
[251]	3985	}
[192]	3986	}
[1]	3987	else
[192]	3988	{
	3989	fd = -1;
	3990	}
[8]	3991
[1]	3992
	3993	/* --- case 1: lstat failed ---
	3994	*/
	3995	if (stat_return != 0)
	3996	{
	3997	stat_return = errno;
	3998	if (!SL_ISERROR(rval_open))
	3999	sl_close(rval_open);
	4000	if (sh.flag.checkSum == SH_CHECK_INIT \|\|
	4001	(sh_hash_have_it (theFile->fullpath) >= 0 &&
[114]	4002	(!SH_FFLAG_REPORTED_SET(theFile->file_reported))))
[1]	4003	{
	4004	if (S_FALSE == sh_ignore_chk_del(theFile->fullpath)) {
[458]	4005	int flags = sh_hash_getflags (theFile->fullpath);
	4006
	4007	if ((flags >= 0) && (flags & SH_FFLAG_ENOENT) == 0) {
	4008	char errbuf[SH_ERRBUF_SIZE];
	4009	uid_t euid;
	4010	(void) sl_get_euid(&euid);
	4011	tmp2 = sh_util_safe_name (theFile->fullpath);
	4012	SH_MUTEX_LOCK(mutex_thread_nolog);
	4013	sh_error_handle (level, FIL__, __LINE__, stat_return, MSG_FI_STAT,
	4014	_("lstat"),
	4015	sh_error_message (stat_errno, errbuf, sizeof(errbuf)),
	4016	(long) euid,
	4017	tmp2);
	4018	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	4019	SH_FREE(tmp2);
	4020	sh_hash_set_flag (theFile->fullpath, SH_FFLAG_ENOENT);
	4021	}
[1]	4022	}
	4023	}
	4024	SL_RETURN((-1),_("sh_unix_getinfo"));
	4025	}
	4026
[8]	4027	/* --- case 2: not a regular file ---
[1]	4028	*/
	4029	else if (! S_ISREG(buf.st_mode))
	4030	{
	4031	if (fileHash != NULL)
[93]	4032	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4033	}
	4034
	4035	/* --- case 3a: a regular file, fstat ok ---
	4036	*/
	4037	else if (fstat_return == 0 &&
	4038	buf.st_mode == fbuf.st_mode &&
	4039	buf.st_ino == fbuf.st_ino &&
	4040	buf.st_uid == fbuf.st_uid &&
	4041	buf.st_gid == fbuf.st_gid &&
	4042	buf.st_dev == fbuf.st_dev )
	4043	{
	4044	if (fileHash != NULL)
	4045	{
[481]	4046	if ((theFile->check_flags & MODI_CHK) == 0 \|\|
[310]	4047	sh_restrict_this(theFile->fullpath, (UINT64) fbuf.st_size,
	4048	(UINT64) fbuf.st_mode, rval_open))
[1]	4049	{
[93]	4050	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4051	}
[481]	4052	else if ((theFile->check_flags & MODI_PREL) != 0 &&
[1]	4053	S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
[102]	4054	alert_timeout, theFile->fullpath))
[1]	4055	{
	4056	if (0 != sh_prelink_run (theFile->fullpath,
[481]	4057	fileHash, alert_timeout, theFile->check_flags))
[93]	4058	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4059	}
	4060	else
	4061	{
[133]	4062	char hashbuf[KEYBUF_SIZE];
[425]	4063	UINT64 length_current = TIGER_NOLIM;
[167]	4064
[481]	4065	if (MODI_TXT_ENABLED(theFile->check_flags) && fbuf.st_size < (10 * SH_TXT_MAX))
[167]	4066	{
	4067	sl_init_content (rval_open, fbuf.st_size);
	4068	}
	4069
[481]	4070	if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(theFile->check_flags);
[22]	4071	sl_strlcpy(fileHash,
	4072	sh_tiger_generic_hash (theFile->fullpath,
[425]	4073	rval_open, &length_current,
[133]	4074	alert_timeout,
	4075	hashbuf, sizeof(hashbuf)),
[22]	4076	KEY_LEN+1);
[167]	4077
	4078	content = sl_get_content(rval_open);
[169]	4079	content = sh_string_copy(content);
[167]	4080
[481]	4081	if ((theFile->check_flags & MODI_SGROW) != 0)
[19]	4082	{
[436]	4083	/* Update size so it matches the one for which the checksum
	4084	has been computed */
	4085	fbuf.st_size = length_current;
[151]	4086	buf.st_size = fbuf.st_size;
[19]	4087	sl_rewind(rval_open);
[425]	4088	sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
[19]	4089	&fileHash[KEY_LEN + 1],
[481]	4090	alert_timeout, rval_open, theFile->check_flags);
[19]	4091	}
[1]	4092	}
	4093	}
	4094	}
	4095
	4096	/* --- case 3b: a regular file, fstat ok, but different ---
	4097	*/
	4098	else if (fstat_return == 0 && S_ISREG(fbuf.st_mode))
	4099	{
	4100	memcpy (&buf, &fbuf, sizeof( struct stat ));
	4101
	4102	if (fileHash != NULL)
	4103	{
[481]	4104	if ((theFile->check_flags & MODI_CHK) == 0 \|\|
[310]	4105	sh_restrict_this(theFile->fullpath, (UINT64) fbuf.st_size,
	4106	(UINT64) fbuf.st_mode, rval_open))
[1]	4107	{
[93]	4108	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4109	}
	4110	else if (policy == SH_LEVEL_PRELINK &&
	4111	S_TRUE == sh_prelink_iself(rval_open, fbuf.st_size,
[102]	4112	alert_timeout, theFile->fullpath))
[1]	4113	{
	4114	if (0 != sh_prelink_run (theFile->fullpath,
[481]	4115	fileHash, alert_timeout, theFile->check_flags))
[93]	4116	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4117	}
	4118	else
	4119	{
[133]	4120	char hashbuf[KEYBUF_SIZE];
[425]	4121	UINT64 length_current = TIGER_NOLIM;
[167]	4122
[481]	4123	if (MODI_TXT_ENABLED(theFile->check_flags) && fbuf.st_size < (10 * SH_TXT_MAX))
[167]	4124	{
	4125	sl_init_content (rval_open, fbuf.st_size);
	4126	}
	4127
[481]	4128	if (sh.flag.opts == S_TRUE) sh_tiger_set_hashtype_mask(theFile->check_flags);
[1]	4129	sl_strlcpy(fileHash,
[133]	4130	sh_tiger_generic_hash (theFile->fullpath, rval_open,
[425]	4131	&length_current,
[133]	4132	alert_timeout,
	4133	hashbuf, sizeof(hashbuf)),
[1]	4134	KEY_LEN + 1);
[167]	4135
	4136	content = sl_get_content(rval_open);
[169]	4137	content = sh_string_copy(content);
[167]	4138
[481]	4139	if ((theFile->check_flags & MODI_SGROW) != 0)
[19]	4140	{
[436]	4141	/* Update size so it matches the one for which the checksum
	4142	has been computed */
	4143	fbuf.st_size = length_current;
[151]	4144	buf.st_size = fbuf.st_size;
[19]	4145	sl_rewind(rval_open);
[425]	4146	sh_unix_checksum_size (theFile->fullpath, length_current, S_TRUE,
[19]	4147	&fileHash[KEY_LEN + 1],
[481]	4148	alert_timeout, rval_open, theFile->check_flags);
[19]	4149	}
[1]	4150	}
	4151	}
	4152	}
	4153
	4154	/* --- case 4: a regular file, fstat failed ---
	4155	*/
	4156
[192]	4157	else /* fstat_return != 0 or !S_ISREG(fbuf.st_mode) or open() failed */
[1]	4158	{
[185]	4159	uid_t euid;
[192]	4160
[1]	4161	if (fileHash != NULL)
[93]	4162	sl_strlcpy(fileHash, SH_KEY_NULL, KEY_LEN+1);
[1]	4163
[481]	4164	if ((theFile->check_flags & MODI_CHK) != 0)
[65]	4165	{
	4166	tmp2 = sh_util_safe_name (theFile->fullpath);
[185]	4167
[200]	4168
	4169	if (fd >= 0 && fstat_return != 0)
[185]	4170	{
[192]	4171	char errbuf[SH_ERRBUF_SIZE];
[185]	4172	(void) sl_get_euid(&euid);
[192]	4173
[367]	4174	SH_MUTEX_LOCK(mutex_thread_nolog);
[192]	4175	sh_error_handle (level, FIL__, __LINE__, stat_return, MSG_FI_STAT,
	4176	_("fstat"),
	4177	sh_error_message (fstat_errno, errbuf, sizeof(errbuf)),
	4178	(long) euid,
	4179	tmp2);
[367]	4180	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[185]	4181	}
[200]	4182	else if (fd >= 0 && !S_ISREG(fbuf.st_mode))
[185]	4183	{
[367]	4184	SH_MUTEX_LOCK(mutex_thread_nolog);
[192]	4185	sh_error_handle (level, FIL__, __LINE__, fstat_errno,
[185]	4186	MSG_E_NOTREG, tmp2);
[367]	4187	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[185]	4188	}
	4189	else
	4190	{
[192]	4191	char errbuf[SH_ERRBUF_SIZE];
	4192	char errbuf2[SH_ERRBUF_SIZE];
	4193	sl_strlcpy(errbuf, sl_error_string(rval_open), sizeof(errbuf));
	4194	sh_error_message(err_open, errbuf2, sizeof(errbuf2));
[367]	4195	SH_MUTEX_LOCK(mutex_thread_nolog);
[192]	4196	sh_error_handle (level, FIL__, __LINE__, err_open,
	4197	MSG_E_READ, errbuf, errbuf2, tmp2);
[367]	4198	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[185]	4199	}
[65]	4200	SH_FREE(tmp2);
	4201	}
[1]	4202	}
	4203
	4204
	4205	/* --- Determine file type. ---
	4206	*/
[149]	4207	memset (theFile->c_mode, '-', CMODE_SIZE-1);
	4208	theFile->c_mode[CMODE_SIZE-1] = '\0';
[8]	4209
[149]	4210	memset (theFile->link_c_mode, '-', CMODE_SIZE-1);
	4211	theFile->link_c_mode[CMODE_SIZE-1] = '\0';
[1]	4212
	4213	sh_unix_getinfo_type (&buf, &type, theFile->c_mode);
	4214	theFile->type = type;
	4215
[10]	4216	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	4217
	4218	/* --- Determine file attributes. ---
	4219	*/
[149]	4220	memset (theFile->c_attributes, '-', ATTRBUF_SIZE);
	4221	theFile->c_attributes[ATTRBUF_USED] = '\0';
[1]	4222	theFile->attributes = 0;
	4223
[580]	4224	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	4225	if (theFile->c_mode[0] != 'c' && theFile->c_mode[0] != 'b' &&
[580]	4226	theFile->c_mode[0] != 'l' ) {
	4227	if (sh_unix_check_attributes == S_TRUE)
	4228	sh_unix_getinfo_attr(theFile->fullpath,
	4229	&theFile->attributes, theFile->c_attributes,
	4230	fd, &buf);
	4231	}
[1]	4232	#endif
[279]	4233	#endif
[1]	4234
[105]	4235	#if defined(USE_XATTR) && defined(USE_ACL)
	4236	if (sh_unix_check_selinux == S_TRUE \|\| sh_unix_check_acl == S_TRUE)
	4237	theFile->attr_string = sh_unix_getinfo_xattr (theFile->fullpath, fd, &buf);
	4238	#elif defined(USE_XATTR)
[68]	4239	if (sh_unix_check_selinux == S_TRUE)
	4240	theFile->attr_string = sh_unix_getinfo_xattr (theFile->fullpath, fd, &buf);
	4241	#elif defined(USE_ACL)
	4242	if (sh_unix_check_acl == S_TRUE)
	4243	theFile->attr_string = sh_unix_getinfo_acl (theFile->fullpath, fd, &buf);
	4244	#else
	4245	theFile->attr_string = NULL;
	4246	#endif
	4247
[1]	4248	if (!SL_ISERROR(rval_open))
	4249	sl_close(rval_open);
	4250
	4251
	4252	/* --- I/O limit. ---
	4253	*/
	4254	if (IO_Limit > 0)
	4255	{
	4256	runtim = (long) (time(NULL) - sh.statistics.time_start);
	4257
	4258	if (runtim > 0 && (long)(sh.statistics.bytes_hashed/runtim) > IO_Limit)
	4259	retry_msleep(1, 0);
	4260	}
	4261
	4262	/* --- Determine permissions. ---
	4263	*/
	4264	sh_unix_getinfo_mode (&buf, &mode, theFile->c_mode);
	4265
	4266	/* --- Trivia. ---
	4267	*/
	4268	theFile->dev = buf.st_dev;
	4269	theFile->ino = buf.st_ino;
	4270	theFile->mode = buf.st_mode;
	4271	theFile->hardlinks = buf.st_nlink;
	4272	theFile->owner = buf.st_uid;
	4273	theFile->group = buf.st_gid;
	4274	theFile->rdev = buf.st_rdev;
	4275	theFile->size = buf.st_size;
	4276	theFile->blksize = (unsigned long) buf.st_blksize;
	4277	theFile->blocks = (unsigned long) buf.st_blocks;
	4278	theFile->atime = buf.st_atime;
	4279	theFile->mtime = buf.st_mtime;
	4280	theFile->ctime = buf.st_ctime;
	4281
	4282
	4283	/* --- Owner and group. ---
	4284	*/
	4285
[132]	4286	if (NULL == sh_unix_getGIDname(SH_ERR_ALL, buf.st_gid, theFile->c_group, GROUP_MAX+1)) {
[1]	4287
	4288	tmp2 = sh_util_safe_name (theFile->fullpath);
	4289
	4290	if (policy == SH_LEVEL_ALLIGNORE)
	4291	{
[367]	4292	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4293	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, ENOENT,
	4294	MSG_FI_NOGRP,
	4295	(long) buf.st_gid, tmp2);
[367]	4296	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4297	}
	4298	else
	4299	{
[367]	4300	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4301	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, ENOENT,
	4302	MSG_FI_NOGRP,
	4303	(long) buf.st_gid, tmp2);
[367]	4304	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4305	}
	4306	SH_FREE(tmp2);
	4307	sl_snprintf(theFile->c_group, GROUP_MAX+1, "%d", (long) buf.st_gid);
	4308	}
	4309
	4310
[137]	4311	if (NULL == sh_unix_getUIDname(SH_ERR_ALL, buf.st_uid, theFile->c_owner, USER_MAX+1)) {
[1]	4312
	4313	tmp2 = sh_util_safe_name (theFile->fullpath);
	4314
	4315	if (policy == SH_LEVEL_ALLIGNORE)
	4316	{
[367]	4317	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4318	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__, ENOENT,
	4319	MSG_FI_NOUSR,
	4320	(long) buf.st_uid, tmp2);
[367]	4321	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4322	}
	4323	else
	4324	{
[367]	4325	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4326	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, ENOENT,
	4327	MSG_FI_NOUSR,
	4328	(long) buf.st_uid, tmp2);
[367]	4329	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4330	}
	4331	SH_FREE(tmp2);
	4332	sl_snprintf(theFile->c_owner, USER_MAX+1, "%d", (long) buf.st_uid);
	4333	}
	4334
	4335	/* --- Output the file. ---
	4336	*/
[481]	4337	if (flag_err_debug == S_TRUE)
[1]	4338	{
	4339	tmp2 = sh_util_safe_name ((filename == NULL) ?
	4340	theFile->fullpath : filename);
[137]	4341	(void) sh_unix_time(theFile->mtime, timestr, sizeof(timestr));
[367]	4342	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4343	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LIST,
	4344	theFile->c_mode,
	4345	theFile->hardlinks,
	4346	theFile->c_owner,
	4347	theFile->c_group,
	4348	(unsigned long) theFile->size,
	4349	timestr,
	4350	tmp2);
[367]	4351	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4352	SH_FREE(tmp2);
	4353	}
	4354
	4355	/* --- Check for links. ---
	4356	*/
	4357	if (theFile->c_mode[0] == 'l')
	4358	{
	4359	linknamebuf = SH_ALLOC(PATH_MAX);
	4360
[22]	4361	/* flawfinder: ignore */
[1]	4362	linksize = readlink (theFile->fullpath, linknamebuf, PATH_MAX-1);
	4363
	4364	if (linksize < (PATH_MAX-1) && linksize >= 0)
	4365	linknamebuf[linksize] = '\0';
	4366	else
	4367	linknamebuf[PATH_MAX-1] = '\0';
	4368
	4369	if (linksize < 0)
	4370	{
[132]	4371	char errbuf[SH_ERRBUF_SIZE];
[1]	4372	linksize = errno;
	4373	tmp2 = sh_util_safe_name (theFile->fullpath);
[367]	4374	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	4375	sh_error_handle (level, FIL__, __LINE__, linksize, MSG_FI_RDLNK,
[132]	4376	sh_error_message (linksize, errbuf, sizeof(errbuf)), tmp2);
[367]	4377	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	4378	SH_FREE(tmp2);
	4379	SH_FREE(linknamebuf);
[167]	4380	theFile->link_path = sh_util_strdup("-");
[1]	4381	SL_RETURN((-1),_("sh_unix_getinfo"));
	4382	}
[138]	4383
[167]	4384	if (linknamebuf[0] == '/')
	4385	{
	4386	theFile->link_path = sh_util_strdup (linknamebuf);
	4387	}
	4388	else
	4389	{
	4390	tmp = sh_util_dirname(theFile->fullpath);
	4391	if (tmp) {
	4392	theFile->link_path = SH_ALLOC(PATH_MAX);
	4393	sl_strlcpy (theFile->link_path, tmp, PATH_MAX);
	4394	SH_FREE(tmp);
	4395	} else {
	4396	theFile->link_path = SH_ALLOC(PATH_MAX);
	4397	theFile->link_path[0] = '\0';
	4398	}
	4399	/*
	4400	* Only attach '/' if not root directory. Handle "//", which
	4401	* according to POSIX is implementation-defined, and may be
	4402	* different from "/" (however, three or more '/' will collapse
	4403	* to one).
	4404	*/
	4405	tmp = theFile->link_path; while (*tmp == '/') ++tmp;
	4406	if (*tmp != '\0')
	4407	{
	4408	sl_strlcat (theFile->link_path, "/", PATH_MAX);
	4409	}
	4410	sl_strlcat (theFile->link_path, linknamebuf, PATH_MAX);
	4411	}
	4412
	4413	/* stat the link
	4414	*/
	4415	stat_return = retry_lstat (FIL__, __LINE__, theFile->link_path, &lbuf);
	4416
	4417	/* check for error
	4418	*/
	4419	if (stat_return != 0)
	4420	{
	4421	stat_return = errno;
	4422	tmp = sh_util_safe_name (theFile->fullpath);
	4423	tmp2 = sh_util_safe_name (theFile->link_path);
	4424	if (stat_return != ENOENT)
	4425	{
[192]	4426	uid_t euid;
[167]	4427	char errbuf[SH_ERRBUF_SIZE];
[192]	4428
	4429	(void) sl_get_euid(&euid);
[367]	4430	SH_MUTEX_LOCK(mutex_thread_nolog);
[167]	4431	sh_error_handle (level, FIL__, __LINE__, stat_return,
[192]	4432	MSG_FI_STAT,
[454]	4433	_("lstat (link target)"),
[167]	4434	sh_error_message (stat_return,errbuf, sizeof(errbuf)),
[192]	4435	(long) euid,
[167]	4436	tmp2);
[367]	4437	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[167]	4438	}
	4439	else
	4440	{
	4441	/* a dangling link -- everybody seems to have plenty of them
	4442	*/
[367]	4443	SH_MUTEX_LOCK(mutex_thread_nolog);
[167]	4444	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DLNK,
	4445	tmp, tmp2);
[367]	4446	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[167]	4447	}
	4448	theFile->linkisok = BAD;
[93]	4449	SH_FREE(tmp);
[167]	4450	SH_FREE(tmp2);
	4451	SH_FREE(linknamebuf);
	4452	/*
	4453	* changed Tue Feb 10 16:16:13 CET 2004:
	4454	* add dangling symlinks into database
	4455	* SL_RETURN((-1),_("sh_unix_getinfo"));
	4456	*/
	4457	theFile->linkmode = 0;
	4458	SL_RETURN((0),_("sh_unix_getinfo"));
[93]	4459	}
[1]	4460
[167]	4461	theFile->linkisok = GOOD;
	4462
	4463
	4464	/* --- Determine file type. ---
	4465	*/
	4466	sh_unix_getinfo_type (&lbuf, &type, theFile->link_c_mode);
	4467	theFile->type = type;
	4468
	4469	/* --- Determine permissions. ---
	4470	*/
	4471	sh_unix_getinfo_mode (&lbuf, &mode, theFile->link_c_mode);
	4472	theFile->linkmode = lbuf.st_mode;
	4473
	4474	/* --- Output the link. ---
	4475	*/
	4476	if (theFile->linkisok == GOOD)
	4477	{
	4478	tmp2 = sh_util_safe_name (linknamebuf);
[367]	4479	SH_MUTEX_LOCK(mutex_thread_nolog);
[167]	4480	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_LLNK,
	4481	theFile->link_c_mode, tmp2);
[367]	4482	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[167]	4483	SH_FREE(tmp2);
	4484	}
	4485	SH_FREE(linknamebuf);
	4486	}
[402]	4487	else /* not a link, theFile->c_mode[0] != 'l' */
[167]	4488	{
	4489	if (content)
	4490	{
[169]	4491	#ifdef HAVE_LIBZ
[171]	4492	unsigned long clen;
	4493	unsigned char * compressed;
	4494	#ifdef HAVE_COMPRESSBOUND
	4495	clen = compressBound(sh_string_len(content));
	4496	#else
	4497	if (sh_string_len(content) > 10*SH_TXT_MAX)
	4498	clen = SH_TXT_MAX;
	4499	else
	4500	clen = 13 + (int)(1.0001*sh_string_len(content));
	4501	#endif
	4502	compressed = SH_ALLOC(clen);
[169]	4503	if (Z_OK == compress(compressed, &clen,
	4504	(unsigned char *) sh_string_str(content),
	4505	sh_string_len(content)))
	4506	{
	4507	if (clen < SH_TXT_MAX)
	4508	{
	4509	sh_util_base64_enc_alloc (&(theFile->link_path),
	4510	(char *) compressed, clen);
	4511	}
	4512	else
	4513	{
	4514	char tmsg[128];
	4515	char * tpath = sh_util_safe_name (theFile->fullpath);
	4516	sl_snprintf(tmsg, sizeof(tmsg),
	4517	_("compressed file too large (%lu bytes)"),
	4518	clen);
[367]	4519	SH_MUTEX_LOCK(mutex_thread_nolog);
[169]	4520	sh_error_handle (SH_ERR_WARN, FIL__, __LINE__, -1,
	4521	MSG_E_SUBGPATH, tmsg,
	4522	_("sh_unix_getinfo"), tpath);
[367]	4523	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[169]	4524	SH_FREE(tpath);
	4525	}
	4526	}
	4527	SH_FREE(compressed);
	4528	#endif
	4529	sh_string_destroy(&content);
[167]	4530	}
	4531	}
[1]	4532	SL_RETURN((0),_("sh_unix_getinfo"));
	4533	}
	4534
	4535	/* #if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE) */
	4536	#endif
	4537
[169]	4538	int sh_unix_unlock(char * lockfile, char * flag)
	4539	{
	4540	int error = 0;
	4541
	4542	SL_ENTER(_("sh_unix_unlock"));
[1]	4543
[169]	4544	if (sh.flag.isdaemon == S_FALSE && flag == NULL)
	4545	SL_RETURN((0),_("sh_unix_unlock"));
	4546
	4547	/* --- Logfile is not locked to us. ---
	4548	*/
	4549	if (sh.flag.islocked == BAD && flag != NULL)
	4550	SL_RETURN((-1),_("sh_unix_unlock"));
	4551
	4552	/* --- Check whether the directory is secure. ---
	4553	*/
	4554	if (0 != tf_trust_check (lockfile, SL_YESPRIV))
	4555	SL_RETURN((-1),_("sh_unix_unlock"));
	4556
	4557	/* --- Delete the lock file. ---
	4558	*/
	4559	error = retry_aud_unlink (FIL__, __LINE__, lockfile);
	4560
	4561	if (error == 0)
	4562	{
	4563	if (flag != NULL)
	4564	sh.flag.islocked = BAD; /* not locked anymore */
	4565	}
	4566	else if (flag != NULL)
	4567	{
	4568	char errbuf[SH_ERRBUF_SIZE];
	4569	error = errno;
	4570	sh_error_handle ((-1), FIL__, __LINE__, error, MSG_E_UNLNK,
	4571	sh_error_message(error, errbuf, sizeof(errbuf)),
	4572	lockfile);
	4573	SL_RETURN((-1),_("sh_unix_unlock"));
	4574	}
	4575	SL_RETURN((0),_("sh_unix_unlock"));
	4576	}
	4577
[265]	4578	int sh_unix_check_piddir (char * pidpath)
[246]	4579	{
	4580	static struct stat buf;
	4581	int status = 0;
	4582	char * pid_dir;
	4583
	4584	SL_ENTER(_("sh_unix_check_piddir"));
	4585
[265]	4586	pid_dir = sh_util_dirname (pidpath);
[246]	4587
	4588	status = retry_lstat (FIL__, __LINE__, pid_dir, &buf);
	4589
	4590	if (status < 0 && errno == ENOENT)
	4591	{
	4592	status = mkdir (pid_dir, 0777);
	4593	if (status < 0)
	4594	{
	4595	sh_error_handle ((-1), FIL__, __LINE__, status,
	4596	MSG_E_SUBGEN,
	4597	_("Cannot create PID directory"),
	4598	_("sh_unix_check_piddir"));
	4599	SH_FREE(pid_dir);
	4600	SL_RETURN((-1),_("sh_unix_check_piddir"));
	4601	}
	4602	}
	4603	else if (!S_ISDIR(buf.st_mode))
	4604	{
	4605	sh_error_handle ((-1), FIL__, __LINE__, status,
	4606	MSG_E_SUBGEN,
	4607	_("Path of PID directory refers to a non-directory object"),
	4608	_("sh_unix_check_piddir"));
	4609	SH_FREE(pid_dir);
	4610	SL_RETURN((-1),_("sh_unix_check_piddir"));
	4611	}
	4612	SH_FREE(pid_dir);
	4613	SL_RETURN((0),_("sh_unix_check_piddir"));
	4614	}
	4615
[169]	4616	int sh_unix_lock (char * lockfile, char * flag)
	4617	{
	4618	int filed;
	4619	int errnum;
	4620	char myPid[64];
	4621	SL_TICKET fd;
	4622	extern int get_the_fd (SL_TICKET ticket);
	4623
	4624	SL_ENTER(_("sh_unix_lock"));
	4625
[539]	4626	sl_snprintf (myPid, sizeof(myPid), "%ld\n", (long) sh.pid); /* known to fit */
[169]	4627
[246]	4628	if (flag == NULL) /* PID file, check for directory */
	4629	{
	4630	if (0 != sh_unix_check_piddir (lockfile))
	4631	{
	4632	SL_RETURN((-1),_("sh_unix_lock"));
	4633	}
	4634	}
	4635
[248]	4636	fd = sl_open_safe_rdwr (FIL__, __LINE__,
	4637	lockfile, SL_YESPRIV); /* fails if file exists */
[169]	4638
	4639	if (!SL_ISERROR(fd))
	4640	{
	4641	errnum = sl_write (fd, myPid, sl_strlen(myPid));
	4642	filed = get_the_fd(fd);
	4643	fchmod (filed, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IROTH);
	4644	sl_close (fd);
	4645
	4646	if (!SL_ISERROR(errnum))
	4647	{
	4648	if (flag != NULL)
	4649	sh.flag.islocked = GOOD;
	4650	SL_RETURN((0),_("sh_unix_lock"));
	4651	}
	4652	}
	4653
	4654	TPT((0, FIL__, __LINE__, _("msg=<open pid file failed>\n")));
	4655	if (flag != NULL)
	4656	sh.flag.islocked = BAD;
	4657	SL_RETURN((-1),_("sh_unix_lock"));
	4658
	4659	/* notreached */
	4660	}
	4661
	4662
[1]	4663	/* check whether file is locked
	4664	*/
	4665	int sh_unix_test_and_lock (char * filename, char * lockfile)
	4666	{
	4667	static struct stat buf;
	4668	int status = 0;
	4669
	4670
	4671	SL_TICKET fd;
	4672	char line_in[128];
	4673
	4674	SL_ENTER(_("sh_unix_test_and_lock"));
	4675
	4676	status = retry_lstat (FIL__, __LINE__, lockfile, &buf);
	4677
	4678	/* --- No lock file found, try to lock. ---
	4679	*/
	4680
	4681	if (status < 0 && errno == ENOENT)
	4682	{
	4683	if (0 == sh_unix_lock (lockfile, filename))
	4684	{
	4685	if (filename != NULL)
	4686	sh.flag.islocked = GOOD;
	4687	SL_RETURN((0),_("sh_unix_test_and_lock"));
	4688	}
[76]	4689	else
	4690	{
	4691	sh_error_handle ((-1), FIL__, __LINE__, status,
	4692	MSG_E_SUBGEN,
[246]	4693	(filename == NULL) ? _("Cannot create PID file (1)") : _("Cannot create lock file (1)"),
[76]	4694	_("sh_unix_test_and_lock"));
	4695	SL_RETURN((-1),_("sh_unix_test_and_lock"));
	4696	}
[1]	4697	}
	4698	else if (status == 0 && buf.st_size == 0)
	4699	{
	4700	if (filename != NULL)
	4701	sh.flag.islocked = GOOD;
	4702	sh_unix_unlock (lockfile, filename);
	4703	if (filename != NULL)
	4704	sh.flag.islocked = BAD;
	4705	if (0 == sh_unix_lock (lockfile, filename))
	4706	{
	4707	if (filename != NULL)
	4708	sh.flag.islocked = GOOD;
	4709	SL_RETURN((0),_("sh_unix_test_and_lock"));
	4710	}
	4711	else
	4712	{
[76]	4713	sh_error_handle ((-1), FIL__, __LINE__, status,
	4714	MSG_E_SUBGEN,
[246]	4715	(filename == NULL) ? _("Cannot create PID file (2)") : _("Cannot create lock file (2)"),
[76]	4716	_("sh_unix_test_and_lock"));
[1]	4717	SL_RETURN((-1),_("sh_unix_test_and_lock"));
	4718	}
	4719	}
	4720
	4721	/* --- Check on lock. ---
	4722	*/
	4723
	4724	if (status >= 0)
	4725	{
[248]	4726	fd = sl_open_read (FIL__, __LINE__, lockfile, SL_YESPRIV);
[1]	4727	if (SL_ISERROR(fd))
	4728	sh_error_handle ((-1), FIL__, __LINE__, fd,
	4729	MSG_E_SUBGEN,
	4730	(filename == NULL) ? _("Cannot open PID file for read") : _("Cannot open lock file for read"),
	4731	_("sh_unix_test_and_lock"));
	4732	}
	4733	else
	4734	fd = -1;
	4735
	4736	if (!SL_ISERROR(fd))
	4737	{
	4738	/* read the PID in the lock file
	4739	*/
[76]	4740	status = sl_read (fd, line_in, sizeof(line_in));
	4741	line_in[sizeof(line_in)-1] = '\0';
[1]	4742
	4743	/* convert to numeric
	4744	*/
	4745	if (status > 0)
	4746	{
	4747	errno = 0;
	4748	status = strtol(line_in, (char **)NULL, 10);
	4749	if (errno == ERANGE \|\| status <= 0)
	4750	{
	4751	sh_error_handle ((-1), FIL__, __LINE__, status,
	4752	MSG_E_SUBGEN,
	4753	(filename == NULL) ? _("Bad PID in PID file") : _("Bad PID in lock file"),
	4754	_("sh_unix_test_and_lock"));
	4755
	4756	status = -1;
	4757	}
	4758	}
	4759	else
	4760	{
	4761	sh_error_handle ((-1), FIL__, __LINE__, status,
	4762	MSG_E_SUBGEN,
	4763	(filename == NULL) ? _("Cannot read PID file") : _("Cannot read lock file"),
	4764	_("sh_unix_test_and_lock"));
	4765	}
	4766	sl_close(fd);
	4767
[162]	4768	if (status > 0 && (unsigned int) status == sh.pid)
[1]	4769	{
	4770	if (filename != NULL)
	4771	sh.flag.islocked = GOOD;
	4772	SL_RETURN((0),_("sh_unix_test_and_lock"));
	4773	}
	4774
	4775
	4776	/* --- Check whether the process exists. ---
	4777	*/
	4778	if (status > 0)
	4779	{
	4780	errno = 0;
	4781	status = aud_kill (FIL__, __LINE__, status, 0);
	4782
	4783	/* Does not exist, so remove the stale lock
	4784	* and create a new one.
	4785	*/
	4786	if (status < 0 && errno == ESRCH)
	4787	{
	4788	if (filename != NULL)
	4789	sh.flag.islocked = GOOD;
	4790	if (0 != sh_unix_unlock(lockfile, filename) && (filename !=NULL))
	4791	sh.flag.islocked = BAD;
	4792	else
	4793	{
	4794	if (0 == sh_unix_lock (lockfile, filename))
	4795	{
	4796	if (filename != NULL)
	4797	sh.flag.islocked = GOOD;
	4798	SL_RETURN((0),_("sh_unix_test_and_lock"));
	4799	}
	4800	else
	4801	{
	4802	sh_error_handle ((-1), FIL__, __LINE__, status,
	4803	MSG_E_SUBGEN,
[246]	4804	(filename == NULL) ? _("Cannot create PID file (3)") : _("Cannot create lock file (3)"),
[1]	4805	_("sh_unix_test_and_lock"));
	4806	}
	4807	if (filename != NULL)
	4808	sh.flag.islocked = BAD;
	4809	}
	4810	}
	4811	else
	4812	{
	4813	sh_error_handle ((-1), FIL__, __LINE__, status,
	4814	MSG_E_SUBGEN,
	4815	(filename == NULL) ? _("Cannot remove stale PID file, PID may be a running process") : _("Cannot remove stale lock file, PID may be a running process"),
	4816	_("sh_unix_test_and_lock"));
	4817	if (filename != NULL)
	4818	sh.flag.islocked = BAD;
	4819	}
	4820	}
	4821	}
	4822	SL_RETURN((-1),_("sh_unix_testlock"));
	4823	}
	4824
	4825	/* write the PID file
	4826	*/
	4827	int sh_unix_write_pid_file()
	4828	{
	4829	return sh_unix_test_and_lock(NULL, sh.srvlog.alt);
	4830	}
	4831
	4832	/* write lock for filename
	4833	*/
	4834	int sh_unix_write_lock_file(char * filename)
	4835	{
[34]	4836	size_t len;
	4837	int res;
[1]	4838	char * lockfile;
	4839
	4840	if (filename == NULL)
	4841	return (-1);
	4842
[34]	4843	len = sl_strlen(filename);
	4844	if (sl_ok_adds(len, 6))
	4845	len += 6;
	4846	lockfile = SH_ALLOC(len);
	4847	sl_strlcpy(lockfile, filename, len);
	4848	sl_strlcat(lockfile, _(".lock"), len);
	4849	res = sh_unix_test_and_lock(filename, lockfile);
[1]	4850	SH_FREE(lockfile);
[34]	4851	return res;
[1]	4852	}
	4853
	4854	/* rm lock for filename
	4855	*/
	4856	int sh_unix_rm_lock_file(char * filename)
	4857	{
[34]	4858	size_t len;
	4859	int res;
[1]	4860	char * lockfile;
	4861
	4862	if (filename == NULL)
	4863	return (-1);
	4864
[34]	4865	len = sl_strlen(filename);
	4866	if (sl_ok_adds(len, 6))
	4867	len += 6;
	4868	lockfile = SH_ALLOC(len);
	4869	sl_strlcpy(lockfile, filename, len);
	4870	sl_strlcat(lockfile, _(".lock"), len);
	4871
	4872	res = sh_unix_unlock(lockfile, filename);
[1]	4873	SH_FREE(lockfile);
[34]	4874	return res;
[1]	4875	}
	4876
	4877	/* rm lock for filename
	4878	*/
	4879	int sh_unix_rm_pid_file()
	4880	{
	4881	return sh_unix_unlock(sh.srvlog.alt, NULL);
	4882	}
	4883
	4884	/* Test whether file exists
	4885	*/
[78]	4886	int sh_unix_file_exists(char * path)
[1]	4887	{
	4888	struct stat buf;
	4889
[78]	4890	SL_ENTER(_("sh_unix_file_exists"));
[1]	4891
[221]	4892	if (0 == retry_lstat(FIL__, __LINE__, path, &buf))
	4893	SL_RETURN( S_TRUE, _("sh_unix_file_exists"));
[579]	4894
	4895	SL_RETURN( S_FALSE, _("sh_unix_file_exists"));
[1]	4896	}
	4897
	4898
[78]	4899	/* Test whether file exists, is a character device, and allows read
	4900	* access.
[1]	4901	*/
[78]	4902	int sh_unix_device_readable(int fd)
[1]	4903	{
	4904	struct stat buf;
	4905
[78]	4906	SL_ENTER(_("sh_unix_device_readable"));
[1]	4907
	4908	if (retry_fstat(FIL__, __LINE__, fd, &buf) == -1)
[78]	4909	SL_RETURN( (-1), _("sh_unix_device_readable"));
[579]	4910	if ( S_ISCHR(buf.st_mode) && 0 != (S_IROTH & buf.st_mode) )
[78]	4911	SL_RETURN( (0), _("sh_unix_device_readable"));
[579]	4912
	4913	SL_RETURN( (-1), _("sh_unix_device_readable"));
[1]	4914	}
	4915
	4916	static char preq[16];
	4917
	4918	/* return true if database is remote
	4919	*/
	4920	int file_is_remote ()
	4921	{
	4922	static int init = 0;
[42]	4923	struct stat buf;
[1]	4924
	4925	SL_ENTER(_("file_is_remote"));
	4926
	4927	if (init == 0)
	4928	{
	4929	sl_strlcpy(preq, _("REQ_FROM_SERVER"), 16);
	4930	++init;
	4931	}
	4932	if (0 == sl_strncmp (sh.data.path, preq, 15))
	4933	{
[42]	4934	if (sh.data.path[15] != '\0') /* should be start of path */
	4935	{
	4936	if (0 == stat(&(sh.data.path[15]), &buf))
	4937	{
	4938	SL_RETURN( S_FALSE, _("file_is_remote"));
	4939	}
[460]	4940	else
	4941	{
	4942	char * tmp = sh_util_safe_name (&(sh.data.path[15]));
	4943	sh_error_handle((-1), FIL__, __LINE__, S_FALSE, MSG_E_SUBGPATH,
	4944	_("No local baseline database at expected path"),
	4945	_("file_is_remote"),
	4946	tmp);
	4947	SH_FREE(tmp);
	4948	}
[42]	4949	}
[460]	4950	else
	4951	{
	4952	sh_error_handle((-1), FIL__, __LINE__, S_FALSE, MSG_E_SUBGEN,
	4953	_("No local baseline database path known"),
	4954	_("file_is_remote"));
	4955	}
[1]	4956	SL_RETURN( S_TRUE, _("file_is_remote"));
	4957	}
	4958	SL_RETURN( S_FALSE, _("file_is_remote"));
	4959	}
	4960
	4961	/* Return the path to the configuration/database file.
	4962	*/
	4963	char * file_path(char what, char flag)
	4964	{
	4965	static int init = 0;
	4966
	4967	SL_ENTER(_("file_path"));
	4968
	4969	if (init == 0)
	4970	{
	4971	sl_strlcpy(preq, _("REQ_FROM_SERVER"), 16);
	4972	++init;
	4973	}
	4974
	4975	switch (what)
	4976	{
	4977
	4978	case 'C':
	4979	if (0 == sl_strncmp (sh.conf.path, preq, 15))
	4980	{
	4981	#if defined(SH_WITH_SERVER)
	4982	if (sh.flag.isserver == S_TRUE && sl_strlen(sh.conf.path) == 15)
	4983	SL_RETURN( NULL, _("file_path"));
	4984	if (sh.flag.isserver == S_TRUE)
	4985	SL_RETURN( &(sh.conf.path[15]), _("file_path"));
	4986	#endif
	4987	if (flag == 'R')
	4988	SL_RETURN( preq, _("file_path"));
	4989	if (flag == 'I')
	4990	{
	4991	if (sl_strlen(sh.conf.path) == 15)
	4992	SL_RETURN( NULL, _("file_path"));
	4993	else
	4994	SL_RETURN( &(sh.conf.path[15]), _("file_path"));
	4995	}
	4996	SL_RETURN ( preq, _("file_path"));
	4997	}
	4998	else
	4999	SL_RETURN( sh.conf.path, _("file_path"));
	5000	/* break; // unreachable */
	5001
	5002	case 'D':
	5003	if (0 == sl_strncmp (sh.data.path, preq, 15))
	5004	{
	5005	if (flag == 'R')
	5006	SL_RETURN( preq, _("file_path"));
	5007	if (flag == 'W' && sl_strlen(sh.data.path) == 15)
	5008	SL_RETURN (NULL, _("file_path"));
	5009	if (flag == 'W')
	5010	SL_RETURN( &(sh.data.path[15]), _("file_path"));
	5011	}
	5012	else
	5013	SL_RETURN( sh.data.path, _("file_path"));
	5014	break;
	5015
	5016	default:
	5017	SL_RETURN( NULL, _("file_path"));
	5018	}
	5019
	5020	return NULL; /* notreached */
	5021	}
	5022	/************************************************/
	5023	/** Mlock Utilities **/
	5024	/************************************************/
	5025
	5026	#include <limits.h>
	5027
	5028	int sh_unix_pagesize()
	5029	{
	5030	int pagesize = 4096;
	5031	#if defined(_SC_PAGESIZE)
	5032	pagesize = sysconf(_SC_PAGESIZE);
	5033	#elif defined(_SC_PAGE_SIZE)
	5034	pagesize = sysconf(_SC_PAGE_SIZE);
	5035	#elif defined(HAVE_GETPAGESIZE)
	5036	pagesize = getpagesize();
	5037	#elif defined(PAGESIZE)
	5038	pagesize = PAGESIZE;
	5039	#endif
	5040
	5041	return ((pagesize > 0) ? pagesize : 4096);
	5042	}
	5043
	5044	typedef struct sh_page_lt {
	5045	unsigned long page_start;
	5046	int page_refcount;
[19]	5047	char file[64];
	5048	int line;
[1]	5049	struct sh_page_lt * next;
	5050	} sh_page_l;
	5051
	5052	sh_page_l * sh_page_locked = NULL;
	5053	volatile int page_locking = 0;
	5054
	5055	unsigned long sh_unix_lookup_page (void * in_addr, size_t len, int * num_pages)
	5056	{
	5057	int pagesize = sh_unix_pagesize();
	5058	unsigned long addr = (unsigned long) in_addr;
	5059
	5060	unsigned long pagebase;
	5061	unsigned long pagediff;
	5062	unsigned long pagenum = addr / pagesize;
	5063
	5064	SL_ENTER(_("sh_unix_lookup_page"));
	5065	#if 0
	5066	fprintf(stderr, "mlock: --> base %ld, pagenum: %ld\n",
	5067	addr, pagenum);
	5068	#endif
	5069
	5070	/* address of first page
	5071	*/
	5072	pagebase = pagenum * pagesize;
	5073
	5074	/* number of pages
	5075	*/
	5076	pagediff = (addr + len) - pagebase;
	5077	pagenum = pagediff / pagesize;
	5078	if (pagenum * pagesize < pagediff)
	5079	++pagenum;
	5080
	5081	#if 0
	5082	fprintf(stderr, "mlock: --> pagebase %ld, pagediff %ld, (addr + len) %ld\n",
	5083	pagebase, pagediff, (addr + len));
	5084	#endif
	5085
	5086	*num_pages = pagenum;
	5087	SL_RETURN((pagebase), _("sh_unix_lookup_page"));
	5088	}
	5089
	5090
	5091	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
[134]	5092
	5093	SH_MUTEX_STATIC(mutex_mlock,PTHREAD_MUTEX_INITIALIZER);
	5094
[170]	5095	int sh_unix_mlock (const char * file, int line, void * in_addr, size_t len)
[1]	5096	{
	5097	int num_pages;
	5098	int status = 0;
	5099	int pagesize;
[253]	5100	sh_page_l * page_list;
[1]	5101	unsigned long addr;
	5102	#ifdef TEST_MLOCK
	5103	int i = 0;
	5104	#endif
	5105
	5106	SL_ENTER(_("sh_unix_mlock"));
	5107
[134]	5108	/* There's no cancellation point here, except if tracing is on
	5109	*/
	5110	SH_MUTEX_LOCK_UNSAFE(mutex_mlock);
	5111
[253]	5112	page_list = sh_page_locked;
	5113
[1]	5114	if (0 != page_locking)
	5115	{
[143]	5116	status = -1;
	5117	goto exit_mlock;
[1]	5118	}
[134]	5119
[1]	5120	page_locking = 1;
	5121
	5122	pagesize = sh_unix_pagesize();
	5123	addr = sh_unix_lookup_page (in_addr, len, &num_pages);
	5124
	5125	#ifdef TEST_MLOCK
	5126	fprintf(stderr, "mlock: addr %ld, base %ld, pages: %d, length %d\n",
	5127	(unsigned long) in_addr, addr, num_pages, len);
	5128	#endif
	5129
	5130	/* increase refcount of locked pages
	5131	* addr is first page; num_pages is #(consecutive pages) to lock
	5132	*/
[134]	5133
[1]	5134	while ((page_list != NULL) && (num_pages > 0))
	5135	{
	5136	#ifdef TEST_MLOCK
	5137	fprintf(stderr, "mlock: check page %d: %ld [%d]\n",
	5138	i, page_list->page_start, page_list->page_refcount);
	5139	#endif
	5140	if (page_list->page_start == addr)
	5141	{
	5142	page_list->page_refcount += 1;
	5143	num_pages -= 1;
	5144	addr += pagesize;
	5145	#ifdef TEST_MLOCK
	5146	fprintf(stderr, "mlock: found page %d: %ld [%d], next page %ld\n",
	5147	i, page_list->page_start, page_list->page_refcount, addr);
	5148	#endif
	5149	}
	5150	#ifdef TEST_MLOCK
	5151	++i;
	5152	#endif
	5153	page_list = page_list->next;
	5154	}
	5155
	5156	/* mlock some more pages, if needed
	5157	*/
	5158	while (num_pages > 0)
	5159	{
	5160	#ifdef TEST_MLOCK
	5161	fprintf(stderr, "mlock: lock page %d: mlock %ld [num_pages %d]\n",
	5162	i, addr, num_pages);
	5163	++i;
	5164	#endif
	5165	page_list = SH_ALLOC(sizeof(sh_page_l));
	5166	page_list->page_start = addr;
	5167	page_list->page_refcount = 1;
[19]	5168	sl_strlcpy(page_list->file, file, 64);
	5169	page_list->line = line;
[1]	5170	status = mlock( (void *) addr, pagesize);
	5171	if (status != 0)
	5172	{
	5173	#ifdef TEST_MLOCK
[132]	5174	char errbuf[SH_ERRBUF_SIZE];
	5175	fprintf(stderr, "mlock: error: %s\n",
	5176	sh_error_message(errno, errbuf, sizeof(errbuf)));
[1]	5177	#endif
	5178	SH_FREE(page_list);
	5179	page_locking = 0;
[143]	5180	goto exit_mlock;
[1]	5181	}
	5182	page_list->next = sh_page_locked;
	5183	sh_page_locked = page_list;
	5184	num_pages -= 1;
	5185	addr += pagesize;
	5186	}
[134]	5187	page_locking = 0;
[143]	5188
	5189	exit_mlock:
[134]	5190	SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
[1]	5191
	5192	SL_RETURN((status), _("sh_unix_mlock"));
	5193	}
	5194	#else
[175]	5195	int sh_unix_mlock (const char * file, int line, void * in_addr, size_t len)
[1]	5196	{
[49]	5197	(void) file; (void) line;
[1]	5198	(void) in_addr; (void) len;
	5199	return -1;
	5200	}
	5201	#endif
	5202
	5203	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
	5204	int sh_unix_munlock (void * in_addr, size_t len)
	5205	{
	5206	int num_pages;
[253]	5207	int unlocked;
	5208	int status;
[1]	5209	int pagesize;
[253]	5210	sh_page_l * page_list;
[1]	5211	sh_page_l * page_last;
	5212	unsigned long addr;
	5213
	5214	int test_count;
	5215	int test_status;
	5216	int test_pages;
	5217
	5218	#ifdef TEST_MLOCK
	5219	int i = 0;
	5220	#endif
	5221
	5222	SL_ENTER(_("sh_unix_munlock"));
	5223
[134]	5224	/* There's no cancellation point here, except if tracing is on
	5225	*/
	5226	SH_MUTEX_LOCK_UNSAFE(mutex_mlock);
	5227
[253]	5228	unlocked = 0;
	5229	status = 0;
	5230	page_list = sh_page_locked;
	5231
[1]	5232	if (0 != page_locking)
	5233	{
[143]	5234	status = -1;
	5235	goto exit_munlock;
[1]	5236	}
	5237	page_locking = 1;
	5238
	5239	pagesize = sh_unix_pagesize();
	5240	addr = sh_unix_lookup_page (in_addr, len, &num_pages);
	5241
	5242	#ifdef TEST_MLOCK
	5243	fprintf(stderr, "munlock: in_addr %ld, addr %ld, pages: %d, length %d\n",
	5244	(unsigned long) in_addr, addr, num_pages, len);
	5245	#endif
	5246
	5247	test_pages = num_pages;
	5248
	5249	/* reduce refcount of locked pages
	5250	* addr is first page; num_pages is #(consecutive pages) to lock
	5251	*/
	5252	while ((page_list != NULL) && (num_pages > 0))
	5253	{
	5254	#ifdef TEST_MLOCK
	5255	fprintf(stderr, "munlock: page %d: %ld [%d]\n",
	5256	i, page_list->page_start, page_list->page_refcount);
	5257	#endif
	5258
	5259	test_status = 0;
	5260	for (test_count = 0; test_count < test_pages; ++test_count)
	5261	{
	5262	if (page_list->page_start == (addr + (test_count * pagesize)))
	5263	{
	5264	test_status = 1;
	5265	break;
	5266	}
	5267	}
	5268
	5269	if (test_status == 1)
	5270	{
	5271	page_list->page_refcount -= 1;
	5272	if (page_list->page_refcount == 0)
	5273	{
	5274	status = munlock ( (void *) addr, pagesize);
	5275	++unlocked;
	5276	}
	5277	num_pages -= 1;
	5278	#ifdef TEST_MLOCK
	5279	fprintf(stderr,
	5280	"munlock: page %d: %ld [refcount %d], refcount reduced\n",
	5281	i, page_list->page_start, page_list->page_refcount);
	5282	#endif
	5283	}
	5284	#ifdef TEST_MLOCK
	5285	++i;
	5286	#endif
	5287	page_list = page_list->next;
	5288	}
	5289
	5290	#ifdef TEST_MLOCK
	5291	i = 0;
	5292	#endif
	5293
	5294	if (unlocked > 0)
	5295	{
	5296	page_list = sh_page_locked;
	5297	page_last = sh_page_locked;
	5298
	5299	while ((page_list != NULL) && (unlocked > 0))
	5300	{
	5301	if (page_list->page_refcount == 0)
	5302	{
	5303	#ifdef TEST_MLOCK
	5304	fprintf(stderr, "munlock: remove page %d: %ld [refcount %d]\n",
	5305	i, page_list->page_start, page_list->page_refcount);
	5306	#endif
	5307	if (page_last != page_list)
	5308	{
	5309	page_last->next = page_list->next;
	5310	SH_FREE(page_list);
	5311	page_list = page_last->next;
	5312	}
	5313	else
	5314	{
	5315	page_last = page_list->next;
	5316	if (page_list == sh_page_locked)
	5317	sh_page_locked = page_list->next;
	5318	SH_FREE(page_list);
	5319	page_list = page_last;
	5320	}
	5321	--unlocked;
	5322	}
	5323	else
	5324	{
	5325	#ifdef TEST_MLOCK
	5326	fprintf(stderr, "munlock: skip page %d: %ld [refcount %d]\n",
	5327	i, page_list->page_start, page_list->page_refcount);
	5328	#endif
	5329
	5330	page_last = page_list;
	5331	page_list = page_list->next;
	5332	}
	5333	#ifdef TEST_MLOCK
	5334	++i;
	5335	#endif
	5336	}
	5337	}
	5338
	5339	page_locking = 0;
[143]	5340
	5341	exit_munlock:
[134]	5342	SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
[1]	5343	SL_RETURN((status), _("sh_unix_munlock"));
	5344	}
	5345	#else
	5346	int sh_unix_munlock (void * in_addr, size_t len)
	5347	{
	5348	(void) in_addr; (void) len;
	5349	return -1;
	5350	}
	5351	#endif
	5352
	5353	int sh_unix_count_mlock()
	5354	{
[481]	5355	unsigned int i = 0;
[253]	5356	char str[32][64];
	5357	sh_page_l * page_list;
[1]	5358
	5359	SL_ENTER(_("sh_unix_count_mlock"));
[253]	5360
[263]	5361	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
[253]	5362	/* There's no cancellation point here, except if tracing is on
	5363	*/
	5364	SH_MUTEX_LOCK_UNSAFE(mutex_mlock);
[263]	5365	#endif
[253]	5366
	5367	page_list = sh_page_locked;
	5368
[1]	5369	while (page_list != NULL)
	5370	{
[19]	5371	#ifdef WITH_TPT
[253]	5372	if (i < 32)
	5373	sl_snprintf(str[i], 64, _("file: %s line: %d page: %d"),
	5374	page_list->file, page_list->line, i+1);
[19]	5375	#endif
[1]	5376	page_list = page_list->next;
	5377	++i;
	5378	}
[253]	5379
[263]	5380	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
[253]	5381	SH_MUTEX_UNLOCK_UNSAFE(mutex_mlock);
[263]	5382	#endif
[253]	5383
	5384	#ifdef WITH_TPT
	5385	{
[481]	5386	unsigned int j = 0;
[253]	5387	while (j < i && j < 32)
	5388	{
[481]	5389	sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, j, MSG_E_SUBGEN,
[253]	5390	str[j], _("sh_unix_count_mlock"));
	5391	++j;
	5392	}
	5393	}
	5394	#endif
	5395
	5396	sl_snprintf(str[0], 64, _("%d pages locked"), i);
[481]	5397	sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, i, MSG_E_SUBGEN,
[253]	5398	str[0], _("sh_unix_count_mlock"));
[1]	5399	SL_RETURN((i), _("sh_unix_count_mlock"));
	5400	}
	5401
	5402	/************************************************/
	5403	/************************************************/
	5404	/** Stealth Utilities **/
	5405	/************************************************/
	5406	/************************************************/
	5407	#ifdef SH_STEALTH
	5408
	5409	void sh_unix_xor_code (char * str, int len)
	5410	{
	5411	register int i;
	5412
	5413	for (i = 0; i < len; ++i) str[i] ^= (char) XOR_CODE;
	5414	return;
	5415	}
	5416
	5417	#if !defined(SH_STEALTH_MICRO)
	5418
	5419
[89]	5420	int hideout_hex_block(SL_TICKET fd, unsigned char * str, int len,
	5421	unsigned long * bytes_read);
[1]	5422	unsigned long first_hex_block(SL_TICKET fd, unsigned long * max);
	5423
	5424	/*
	5425	* --- Get hidden data from a block of hex data. ---
	5426	*/
	5427	int sh_unix_getline_stealth (SL_TICKET fd, char * str, int len)
	5428	{
[89]	5429	int add_off = 0, llen;
[550]	5430	unsigned long bread;
[89]	5431	static unsigned long off_data = 0;
	5432	static unsigned long max_data = 0;
	5433	static unsigned long bytes_read = 0;
[52]	5434	static int stealth_init = BAD;
[1]	5435
	5436	SL_ENTER(_("sh_unix_getline_stealth"));
	5437
[194]	5438	if (str == NULL)
	5439	{
	5440	off_data = 0;
	5441	max_data = 0;
	5442	bytes_read = 0;
	5443	stealth_init = BAD;
	5444	SL_RETURN(0, _("sh_unix_getline_stealth"));
	5445	}
[34]	5446
[1]	5447	/* --- Initialize. ---
	5448	*/
	5449	if (stealth_init == BAD)
	5450	{
	5451	off_data = first_hex_block(fd, &max_data);
	5452	if (off_data == 0)
	5453	{
	5454	dlog(1, FIL__, __LINE__,
	5455	_("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"));
	5456	sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_P_NODATA,
	5457	_("Stealth config file."));
	5458	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	5459	}
	5460	stealth_init = GOOD;
[52]	5461	max_data += off_data;
[1]	5462	}
	5463
	5464	/* --- Seek to proper position. ---
	5465	*/
[89]	5466	if (bytes_read >= max_data \|\| add_off < 0)
[52]	5467	{
	5468	dlog(1, FIL__, __LINE__,
	5469	_("The capacity of the container image file for the stealth config file seems to be too small. Your config file is likely truncated.\n"));
	5470	sh_error_handle ((-1), FIL__, __LINE__, EIO, MSG_P_NODATA,
	5471	_("Stealth config file."));
	5472	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	5473	}
[1]	5474	sl_seek(fd, off_data);
	5475
	5476	/* --- Read one line. ---
	5477	*/
[550]	5478	add_off = hideout_hex_block(fd, (unsigned char *) str, len, &bread);
	5479	if (add_off > 0)
	5480	off_data += add_off;
	5481	bytes_read += bread;
[1]	5482
[550]	5483	if (bread == 0 \|\| add_off <= 0) /* EOF */
	5484	str[0] = '\0';
	5485
[1]	5486	llen = sl_strlen(str);
	5487	SL_RETURN(llen, _("sh_unix_getline_stealth"));
	5488	}
	5489
[89]	5490	int hideout_hex_block(SL_TICKET fd, unsigned char * str, int len,
	5491	unsigned long * bytes_read)
[1]	5492	{
	5493
	5494	register int i, j, k;
	5495	unsigned char c, e;
	5496	register int num;
	5497	unsigned char mask[9] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
	5498	unsigned long here = 0;
	5499	unsigned long retval = 0;
[89]	5500	unsigned long bread = 0;
[1]	5501
	5502	SL_ENTER(_("hideout_hex_block"));
	5503
[34]	5504	ASSERT_RET((len > 1), _("len > 1"), (0));
	5505
[550]	5506	str[0] = '\0';
	5507	*bytes_read = 0;
[34]	5508	--len;
	5509
[1]	5510	i = 0;
	5511	while (i < len)
	5512	{
	5513	for (j = 0; j < 8; ++j)
	5514	{
	5515
	5516	/* --- Get a low byte, modify, read back. ---
	5517	*/
	5518	for (k = 0; k < 2; ++k)
	5519	{
	5520	/* -- Skip whitespace. ---
	5521	*/
	5522	c = ' ';
	5523	do {
	5524	do {
[550]	5525	errno = 0;
[1]	5526	num = sl_read (fd, &c, 1);
	5527	} while (num == 0 && errno == EINTR);
[89]	5528	if (num > 0)
	5529	++here;
[550]	5530	else if (num == 0) {
[89]	5531	SL_RETURN((-1), _("hideout_hex_block"));
[550]	5532	}
	5533	else {
	5534	SL_RETURN((-1), _("hideout_hex_block"));
	5535	}
[1]	5536	} while (c == '\n' \|\| c == '\t' \|\| c == '\r' \|\|
	5537	c == ' ');
	5538	}
	5539
	5540
	5541	/* --- e is the value of the low byte. ---
	5542	*/
	5543	e = (unsigned char) sh_util_hexchar( c );
	5544	if ((e & mask[7]) != 0) /* bit is set */
	5545	str[i] \|= mask[j];
	5546	else /* bit is not set */
	5547	str[i] &= ~mask[j];
	5548
[89]	5549	bread += 1;
[1]	5550	}
	5551	if (str[i] == '\n') break;
	5552	++i;
	5553	}
	5554
	5555	if (i != 0)
	5556	str[i] = '\0';
[550]	5557	else if (str[0] == '\n')
	5558	str[i+1] = '\0'; /* keep newline and terminate */
[1]	5559	else
[550]	5560	str[0] = '\0';
[1]	5561	retval += here;
[89]	5562	*bytes_read += (bread/8);
[1]	5563
	5564	SL_RETURN(retval, _("hideout_hex_block"));
	5565	}
	5566
	5567	/* --- Get offset of first data block. ---
	5568	*/
	5569	unsigned long first_hex_block(SL_TICKET fd, unsigned long * max)
	5570	{
[34]	5571	unsigned int i;
	5572	long num = 1;
	5573	unsigned long lnum;
[1]	5574	char c;
	5575	int nothex = 0;
	5576	unsigned long retval = 0;
[34]	5577	unsigned int this_line = 0;
[1]	5578	char theline[SH_BUFSIZE];
	5579
	5580	SL_ENTER(_("first_hex_block"));
	5581
	5582	*max = 0;
	5583
	5584	while (1)
	5585	{
	5586	theline[0] = '\0';
	5587	this_line = 0;
	5588	c = '\0';
[481]	5589	while (c != '\n' && this_line < (sizeof(theline)-1))
[1]	5590	{
	5591	do {
	5592	num = sl_read (fd, &c, 1);
	5593	} while (num == 0 && errno == EINTR);
	5594	if (num > 0)
	5595	theline[this_line] = c;
	5596	else
	5597	SL_RETURN((0), _("first_hex_block"));
[34]	5598	++this_line;
[1]	5599	}
	5600	theline[this_line] = '\0';
	5601
	5602	/* not only 'newline' */
	5603	if (this_line > 60)
	5604	{
	5605	nothex = 0;
	5606	i = 0;
	5607	while (nothex == 0 && i < (this_line-1))
	5608	{
	5609	if (! isxdigit((int)theline[i])) nothex = 1;
	5610	++i;
	5611	}
	5612	if (nothex == 1) retval += this_line;
	5613	}
	5614	else
	5615	{
	5616	nothex = 1;
	5617	retval += this_line;
	5618	}
	5619
	5620	if (nothex == 0)
	5621	{
	5622	*max = 0;
	5623	do {
	5624	do {
	5625	num = sl_read (fd, theline, SH_BUFSIZE);
	5626	} while (num == 0 && errno == EINTR);
[34]	5627	if (num > 0)
	5628	{
	5629	lnum = (unsigned long) num;
	5630	for (i = 0; i < lnum; ++i)
	5631	{
	5632	c = theline[i];
	5633	if (c == '\n' \|\| c == '\t' \|\| c == '\r' \|\| c == ' ')
	5634	;
	5635	else if (!isxdigit((int)c))
	5636	break;
	5637	else
	5638	*max += 1;
	5639	}
[1]	5640	}
	5641	} while (num > 0);
	5642
	5643	*max /= 16;
	5644	SL_RETURN((retval), _("first_hex_block"));
	5645	}
	5646
	5647	}
	5648	/* SL_RETURN((0), _("first_hex_block")); // unreachable */
	5649	}
	5650
	5651	/* if !defined(SH_STEALTH_MICRO) */
	5652	#endif
	5653
	5654	/* ifdef SH_STEALTH */
	5655	#endif
	5656
	5657	/*
	5658	* anti-debugger code
	5659	*/
	5660	#if defined(SCREW_IT_UP)
[408]	5661
	5662	#if defined(HAVE_PTHREAD)
	5663
[411]	5664	static pthread_key_t gSigtrapVariables_key;
	5665	static pthread_once_t gSigtrapVariables_key_once = PTHREAD_ONCE_INIT;
[408]	5666
[411]	5667	static inline void make_gSigtrapVariables_key()
[408]	5668	{
[411]	5669	(void) pthread_key_create(&gSigtrapVariables_key, free);
[408]	5670	}
	5671
[411]	5672	struct sh_sigtrap_variables * sh_sigtrap_variables_get()
[408]	5673	{
	5674	void * ptr;
	5675
[411]	5676	(void) pthread_once(&gSigtrapVariables_key_once, make_gSigtrapVariables_key);
[408]	5677
[411]	5678	ptr = pthread_getspecific(gSigtrapVariables_key);
	5679	if (ptr == NULL) {
[454]	5680	ptr = calloc(1,sizeof(struct sh_sigtrap_variables));
[411]	5681	if (ptr == NULL) {
	5682	return NULL;
[408]	5683	}
[411]	5684	(void) pthread_setspecific(gSigtrapVariables_key, ptr);
	5685	}
[408]	5686
[411]	5687	return (struct sh_sigtrap_variables *) ptr;
[408]	5688	}
	5689
	5690	/* !defined(HAVE_PTHREAD) */
	5691	#else
	5692
[411]	5693	static struct sh_sigtrap_variables global_sigtrap_variables;
	5694	struct sh_sigtrap_variables * sh_sigtrap_variables_get()
[408]	5695	{
[411]	5696	return &global_sigtrap_variables;
[408]	5697	}
[411]	5698
[1]	5699	#endif
	5700
[411]	5701	int sh_sigtrap_max_duration_set (const char * str)
[409]	5702	{
[411]	5703	/* For security (prevent reloading with larger value)
	5704	* this value can only be set once.
	5705	*/
	5706	static int once = 0;
	5707	int i;
[409]	5708
[411]	5709	SL_ENTER(_("sh_sigtrap_max_duration_set"));
[408]	5710
[411]	5711	i = atoi (str);
[409]	5712
[411]	5713	if (i >= 0 && once == 0)
	5714	{
	5715	sh.sigtrap_max_duration = i;
	5716	once = 1;
	5717	}
	5718	else
	5719	{
	5720	SL_RETURN ((-1), _("sh_sigtrap_max_duration_set"));
	5721	}
	5722	SL_RETURN( (0), _("sh_sigtrap_max_duration_set"));
	5723	}
	5724
[1]	5725	void sh_sigtrap_handler (int signum)
	5726	{
[411]	5727	struct sh_sigtrap_variables * sigtrap_variables;
	5728	sigtrap_variables = sh_sigtrap_variables_get();
	5729	if (sigtrap_variables == NULL) {
	5730	/* Perhaps, it's better to not die, and to continue using Samhain,
	5731	even if this part does not work. */
	5732	return;
	5733	}
	5734
[1]	5735	#ifdef HAVE_GETTIMEOFDAY
[411]	5736	{
	5737	struct timeval tv;
	5738	long difftv;
	5739
	5740	gettimeofday(&tv, NULL);
	5741	difftv = (tv.tv_sec - sigtrap_variables->save_tv.tv_sec) * 1000000 +
	5742	(tv.tv_usec - sigtrap_variables->save_tv.tv_usec);
	5743	if (difftv > sh.sigtrap_max_duration)
	5744	raise(SIGKILL);
	5745	}
	5746	#endif
[408]	5747
[411]	5748	sigtrap_variables->not_traced = signum;
[473]	5749	/* cppcheck-suppress memleak */
[1]	5750	return;
	5751	}
	5752	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/sh_unix.c@ 580

Download in other formats: