Context Navigation

source: trunk/src/sh_suidchk.c@ 457

Last change on this file since 457 was 453, checked in by katerina, 10 years ago
Fix for a compile error introduced in changeset [452].
File size: 63.6 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 2001 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 <sys/types.h>
	27	#include <sys/stat.h>
	28	#include <fcntl.h>
	29	#include <unistd.h>
	30	#include <errno.h>
	31	#include <limits.h>
[94]	32
[1]	33	#ifdef HAVE_SCHED_H
	34	#include <sched.h>
	35	#endif
	36
	37	#ifdef SH_USE_SUIDCHK
	38
	39	#undef FIL__
	40	#define FIL__ _("sh_suidchk.c")
	41
	42	#if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE)
	43
	44	#if TIME_WITH_SYS_TIME
	45	#include <sys/time.h>
	46	#include <time.h>
	47	#else
	48	#if HAVE_SYS_TIME_H
	49	#include <sys/time.h>
	50	#else
	51	#include <time.h>
	52	#endif
	53	#endif
	54
	55	#ifdef HAVE_DIRENT_H
	56	#include <dirent.h>
	57	#define NAMLEN(dirent) sl_strlen((dirent)->d_name)
	58	#else
	59	#define dirent direct
	60	#define NAMLEN(dirent) (dirent)->d_namlen
	61	#ifdef HAVE_SYS_NDIR_H
	62	#include <sys/ndir.h>
	63	#endif
	64	#ifdef HAVE_SYS_DIR_H
	65	#include <sys/dir.h>
	66	#endif
	67	#ifdef HAVE_NDIR_H
	68	#include <ndir.h>
	69	#endif
	70	#endif
[137]	71	#define NEED_ADD_DIRENT
[1]	72
	73	#include "samhain.h"
[131]	74	#include "sh_pthread.h"
[1]	75	#include "sh_utils.h"
	76	#include "sh_error.h"
	77	#include "sh_modules.h"
	78	#include "sh_suidchk.h"
	79	#include "sh_hash.h"
	80	#include "sh_unix.h"
	81	#include "sh_files.h"
	82	#include "sh_schedule.h"
	83	#include "sh_calls.h"
[452]	84	#include "zAVLTree.h"
[1]	85
	86
	87	sh_rconf sh_suidchk_table[] = {
	88	{
	89	N_("severitysuidcheck"),
	90	sh_suidchk_set_severity
	91	},
	92	{
	93	N_("suidcheckactive"),
	94	sh_suidchk_set_activate
	95	},
	96	{
	97	N_("suidcheckinterval"),
	98	sh_suidchk_set_timer
	99	},
	100	{
	101	N_("suidcheckschedule"),
	102	sh_suidchk_set_schedule
	103	},
	104	{
	105	N_("suidcheckexclude"),
	106	sh_suidchk_set_exclude
	107	},
	108	{
	109	N_("suidcheckfps"),
	110	sh_suidchk_set_fps
	111	},
	112	{
	113	N_("suidcheckyield"),
	114	sh_suidchk_set_yield
	115	},
	116	{
[119]	117	N_("suidchecknosuid"),
	118	sh_suidchk_set_nosuid
	119	},
	120	{
[1]	121	N_("suidcheckquarantinefiles"),
	122	sh_suidchk_set_quarantine
	123	},
	124	{
	125	N_("suidcheckquarantinemethod"),
	126	sh_suidchk_set_qmethod
	127	},
	128	{
	129	N_("suidcheckquarantinedelete"),
	130	sh_suidchk_set_qdelete
	131	},
	132	{
	133	NULL,
	134	NULL
	135	},
	136	};
	137
	138
	139	static time_t lastcheck = (time_t) 0;
	140	static int ShSuidchkActive = S_TRUE;
	141	static time_t ShSuidchkInterval = 7200;
	142	static long ShSuidchkFps = 0;
[119]	143	static int ShSuidchkNosuid = S_FALSE;
[1]	144	static int ShSuidchkYield = S_FALSE;
	145	static int ShSuidchkQEnable = S_FALSE;
	146	static int ShSuidchkQMethod = SH_Q_CHANGEPERM;
	147	static int ShSuidchkQDelete = S_FALSE;
	148	static int ShSuidchkSeverity = SH_ERR_SEVERE;
	149
	150	static time_t FileLimNow = 0;
	151	static time_t FileLimStart = 0;
	152	static long FileLimNum = 0;
	153	static long FileLimTotal = 0;
	154
	155	static sh_schedule_t * ShSuidchkSched = NULL;
	156
[452]	157
	158	static zAVLTree * ShSuidchkExclude = NULL;
	159	static void sh_suid_exclude_free()
	160	{
	161	zAVL_string_reset(ShSuidchkExclude);
	162	ShSuidchkExclude = NULL;
	163	return;
	164	}
	165	static int sh_suid_exclude_add(const char * str)
	166	{
	167	size_t len;
	168	int ret;
	169	char * key = sh_util_strdup(str);
	170
	171	len = sl_strlen (key);
	172	if (len && key[len-1] == '/')
	173	{
	174	key[len-1] = '\0';
	175	}
	176	ret = zAVL_string_set(&ShSuidchkExclude, key);
	177	SH_FREE(key);
	178	return ret;
	179	}
	180
	181
[1]	182	static char *
	183	filesystem_type (char * path, char * relpath, struct stat * statp);
	184
	185	#ifndef PATH_MAX
	186	#define PATH_MAX 1024
	187	#endif
	188
[253]	189	SH_MUTEX_STATIC(mutex_suid_check, PTHREAD_MUTEX_INITIALIZER);
	190
[1]	191	extern unsigned long sh_files_maskof (int class);
	192
[149]	193	static void set_defaults (void)
	194	{
	195	ShSuidchkActive = S_TRUE;
	196	ShSuidchkInterval = 7200;
	197	ShSuidchkFps = 0;
	198	ShSuidchkNosuid = S_FALSE;
	199	ShSuidchkYield = S_FALSE;
	200	ShSuidchkQEnable = S_FALSE;
	201	ShSuidchkQMethod = SH_Q_CHANGEPERM;
	202	ShSuidchkQDelete = S_FALSE;
	203	ShSuidchkSeverity = SH_ERR_SEVERE;
	204	if (ShSuidchkExclude != NULL)
[452]	205	sh_suid_exclude_free(ShSuidchkExclude);
[149]	206
	207	FileLimNow = 0;
	208	FileLimStart = 0;
	209	FileLimNum = 0;
	210	FileLimTotal = 0;
	211
	212	return;
	213	}
	214
[1]	215	/* Recursively descend into the directory to make sure that
	216	* there is no symlink in the path.
[317]	217	*
	218	* Use retry_lstat_ns() here because we cannot chdir the subprocess
	219	* that does the lstat().
[1]	220	*/
	221	static int do_truncate_int (char * path, int depth)
	222	{
	223	char * q;
	224	struct stat one;
	225	struct stat two;
	226	int fd;
[132]	227	char errbuf[SH_ERRBUF_SIZE];
[1]	228
	229	if (depth > 99)
	230	{
[253]	231	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	232	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	233	MSG_SUID_ERROR,
	234	_("do_truncate: max depth 99 exceeded"));
[253]	235	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	236	return -1;
	237	}
	238	++depth;
	239	if (path[0] != '/')
	240	{
[253]	241	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	242	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	243	MSG_SUID_ERROR,
	244	_("do_truncate: not an absolute path"));
[253]	245	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	246	return -1;
	247	}
	248	++path;
	249	q = strchr(path, '/');
	250	if (q)
	251	{
	252	*q = '\0';
[317]	253	if (0 != retry_lstat_ns(FIL__, __LINE__, path, &one))
[1]	254	{
[253]	255	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	256	sh_error_handle ((-1), FIL__, __LINE__, errno,
	257	MSG_SUID_ERROR,
[132]	258	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	259	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	260	*q = '/';
	261	return -1;
	262	}
	263	if (/@-usedef@/!S_ISDIR(one.st_mode)/@+usedef@/)
	264
	265	{
[253]	266	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	267	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	268	MSG_SUID_ERROR,
	269	_("Possible race: not a directory"));
[253]	270	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	271	*q = '/';
	272	return -1;
	273	}
	274
	275
	276	if (0 != chdir(path))
	277	{
[253]	278	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	279	sh_error_handle ((-1), FIL__, __LINE__, errno,
	280	MSG_SUID_ERROR,
[132]	281	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	282	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	283	*q = '/';
	284	return -1;
	285	}
	286	*q = '/';
[317]	287	if (0 != retry_lstat_ns(FIL__, __LINE__, ".", &two))
[1]	288	{
[405]	289	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	290	sh_error_handle ((-1), FIL__, __LINE__, errno,
	291	MSG_SUID_ERROR,
[132]	292	sh_error_message(errno, errbuf, sizeof(errbuf)));
[405]	293	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	294	return -1;
	295	}
	296	if (/@-usedef@/(one.st_dev != two.st_dev) \|\|
	297	(one.st_ino != two.st_ino) \|\|
	298	(!S_ISDIR(two.st_mode))/@+usedef@/)
	299	{
[253]	300	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	301	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	302	MSG_SUID_ERROR,
	303	_("Possible race: lstat(dir) != lstat(.)"));
[253]	304	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	305	return -1;
	306	}
	307
	308
	309	return (do_truncate_int(q, depth));
	310	}
	311	else
	312	{
	313	/* no more '/', so this is the file
	314	*/
	315	if (*path == '\0')
	316	return -1;
[317]	317	if (0 != retry_lstat_ns(FIL__, __LINE__, path, &one))
[1]	318	{
[253]	319	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	320	sh_error_handle ((-1), FIL__, __LINE__, errno,
	321	MSG_SUID_ERROR,
[132]	322	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	323	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	324	return -1;
	325	}
	326	fd = open(path, O_RDWR);
	327	if (-1 == fd)
	328	{
[253]	329	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	330	sh_error_handle ((-1), FIL__, __LINE__, errno,
	331	MSG_SUID_ERROR,
[132]	332	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	333	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	334	return -1;
	335	}
	336	if (0 != retry_fstat(FIL__, __LINE__, fd, &two))
	337	{
[253]	338	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	339	sh_error_handle ((-1), FIL__, __LINE__, errno,
	340	MSG_SUID_ERROR,
[132]	341	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	342	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	343	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	344	return -1;
	345	}
	346	if (/@-usedef@/(one.st_dev != two.st_dev) \|\|
	347	(one.st_ino != two.st_ino)/@+usedef@/)
	348	{
[253]	349	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	350	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	351	MSG_SUID_ERROR,
	352	_("Possible race: lstat != fstat"));
[253]	353	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	354	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	355	return -1;
	356	}
	357	if (!S_ISREG(two.st_mode))
	358	{
[253]	359	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	360	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	361	MSG_SUID_ERROR,
	362	_("Possible race: not a regular file"));
[253]	363	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	364	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	365	return -1;
	366	}
	367	if ((0 == (two.st_mode & S_ISUID)) && (0 == (two.st_mode & S_ISGID)))
	368	{
[253]	369	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	370	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	371	MSG_SUID_ERROR,
	372	_("Possible race: not a suid/sgid file"));
[253]	373	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	374	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	375	return -1;
	376	}
	377	if (ShSuidchkQDelete == S_FALSE)
	378	{
	379	if ((two.st_mode & S_ISUID) > 0)
	380	two.st_mode -= S_ISUID;
	381	if ((two.st_mode & S_ISGID) > 0)
	382	two.st_mode -= S_ISGID;
	383	#ifdef HAVE_FCHMOD
	384	if (-1 == /@-unrecog@/fchmod(fd, two.st_mode)/@+unrecog@/)
	385	{
[253]	386	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	387	sh_error_handle ((-1), FIL__, __LINE__, errno,
	388	MSG_SUID_ERROR,
[132]	389	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	390	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	391	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	392	return -1;
	393	}
	394	#else
[253]	395	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	396	sh_error_handle ((-1), FIL__, __LINE__, errno,
	397	MSG_SUID_ERROR,
	398	_("The fchmod() function is not available"));
[253]	399	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	400	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	401	return -1;
	402	#endif
	403	if (two.st_nlink > 1)
	404	{
[253]	405	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	406	sh_error_handle ((-1), FIL__, __LINE__, 0,
	407	MSG_SUID_ERROR,
	408	_("Not truncated because hardlink count gt 1"));
[253]	409	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	410	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	411	return -1;
	412	}
	413	/* The man page says: 'POSIX has ftruncate'
	414	*/
	415	if (-1 == /@-unrecog@/ftruncate(fd, 0)/@+unrecog@/)
	416	{
[253]	417	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	418	sh_error_handle ((-1), FIL__, __LINE__, errno,
	419	MSG_SUID_ERROR,
[132]	420	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	421	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	422	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	423	return -1;
	424	}
	425	}
	426	else
	427	{
	428	if (-1 == retry_aud_unlink(FIL__, __LINE__, path))
	429	{
[253]	430	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	431	sh_error_handle ((-1), FIL__, __LINE__, errno,
	432	MSG_SUID_ERROR,
[132]	433	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	434	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[252]	435	(void) sl_close_fd(FIL__, __LINE__, fd);
[1]	436	return -1;
	437	}
	438	}
[252]	439	(void) sl_close_fd (FIL__, __LINE__, fd);
[1]	440	return (0);
	441	}
	442	}
	443
[94]	444	static int do_truncate (const char * path_in)
[1]	445	{
[253]	446	volatile int caperr;
[94]	447	int result;
	448	char * path;
[132]	449	char errbuf[SH_ERRBUF_SIZE];
[1]	450
	451	if (0 != chdir("/"))
	452	{
[253]	453	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	454	sh_error_handle ((-1), FIL__, __LINE__, errno,
	455	MSG_SUID_ERROR,
[132]	456	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	457	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	458	}
	459
	460	if (0 != (caperr = sl_get_cap_qdel()))
	461	{
[253]	462	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	463	sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
[132]	464	sh_error_message (caperr, errbuf, sizeof(errbuf)),
[1]	465	_("sl_get_cap_qdel"));
[253]	466	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	467	}
	468
[94]	469	path = sh_util_strdup (path_in);
[1]	470	result = do_truncate_int (path, 0);
[94]	471	SH_FREE(path);
[1]	472
	473	if (0 != (caperr = sl_drop_cap_qdel()))
	474	{
[253]	475	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	476	sh_error_handle((-1), FIL__, __LINE__, caperr, MSG_E_SUBGEN,
[132]	477	sh_error_message (caperr, errbuf, sizeof(errbuf)),
[1]	478	_("sl_drop_cap_qdel"));
[253]	479	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	480	}
	481
	482	if (0 != chdir("/"))
	483	{
[253]	484	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	485	sh_error_handle ((-1), FIL__, __LINE__, errno,
	486	MSG_SUID_ERROR,
[132]	487	sh_error_message(errno, errbuf, sizeof(errbuf)));
[253]	488	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	489	}
	490	return result;
	491	}
	492
[253]	493	/* This variable is not used anywhere. It only exists
	494	* to assign &dirlist to it, which keeps gcc from
	495	* putting it into a register, and avoids the 'clobbered
	496	* by longjmp' warning. And no, 'volatile' proved insufficient.
	497	*/
	498	static void * sh_dummy_tmp = NULL;
	499
[94]	500	static void sh_q_delete(const char * fullpath)
	501	{
	502	int status;
	503	char * msg;
	504	char * tmp;
	505
[253]	506	/* Take the address to keep gcc from putting it into a register.
	507	* Avoids the 'clobbered by longjmp' warning.
	508	*/
	509	sh_dummy_tmp = (void*) &tmp;
	510
[94]	511	if (do_truncate (fullpath) == -1)
	512	{
	513	status = errno;
	514	msg = SH_ALLOC(SH_BUFSIZE);
	515	tmp = sh_util_safe_name(fullpath);
	516
	517	(void) sl_snprintf(msg, SH_BUFSIZE,
	518	_("Problem quarantining file. File NOT quarantined. errno = %ld"),
	519	status);
[253]	520	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	521	sh_error_handle (ShSuidchkSeverity,
	522	FIL__, __LINE__,
	523	status,
	524	MSG_SUID_QREPORT, msg,
	525	tmp );
[253]	526	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	527	SH_FREE(tmp);
	528	SH_FREE(msg);
	529	}
	530	else
	531	{
	532	tmp = sh_util_safe_name(fullpath);
[253]	533	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	534	sh_error_handle (ShSuidchkSeverity,
	535	FIL__, __LINE__, 0,
	536	MSG_SUID_QREPORT,
	537	_("Quarantine method applied"),
	538	tmp );
[253]	539	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	540	SH_FREE(tmp);
	541	}
	542	return;
	543	}
	544
[253]	545	/* This variable is not used anywhere. It only exists
	546	* to assign &dirlist to it, which keeps gcc from
	547	* putting it into a register, and avoids the 'clobbered
	548	* by longjmp' warning. And no, 'volatile' proved insufficient.
	549	*/
	550	static void * sh_dummy_mtmp = NULL;
	551	static void * sh_dummy_mmsg = NULL;
	552
[94]	553	static void sh_q_move(const char * fullpath, file_type * theFile,
	554	const char * timestrc, const char * timestra,
	555	const char * timestrm)
	556	{
[253]	557	volatile int status;
[94]	558	int readFile = -1;
[253]	559	volatile int writeFile = -1;
[94]	560	struct stat fileInfo;
	561	ssize_t count;
	562	char * msg;
	563	char * tmp;
	564	char * basetmp;
	565	char * filetmp;
	566	char buffer[1024];
	567	char * dir = SH_ALLOC(PATH_MAX+1);
	568	mode_t umask_old;
	569	FILE * filePtr = NULL;
	570
[253]	571	/* Take the address to keep gcc from putting it into a register.
	572	* Avoids the 'clobbered by longjmp' warning.
	573	*/
	574	sh_dummy_mtmp = (void*) &tmp;
	575	sh_dummy_mmsg = (void*) &msg;
	576
[94]	577	(void) sl_strlcpy (dir, DEFAULT_QDIR, PATH_MAX+1);
	578
	579	if (retry_stat (FIL__, __LINE__, dir, &fileInfo) != 0)
	580	{
	581	/* Quarantine directory does not exist,
	582	*/
	583	status = errno;
	584	msg = SH_ALLOC(SH_BUFSIZE);
	585	tmp = sh_util_safe_name(fullpath);
	586
	587	(void) sl_snprintf(msg, SH_BUFSIZE,
	588	_("Problem quarantining file. File NOT quarantined. errno = %ld (stat)"),
	589	status);
[253]	590	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	591	sh_error_handle (ShSuidchkSeverity,
	592	FIL__, __LINE__,
	593	status,
	594	MSG_SUID_QREPORT, msg,
	595	tmp );
[253]	596	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	597	SH_FREE(tmp);
	598	SH_FREE(msg);
	599	}
	600	else
	601	{
	602	if (retry_lstat (FIL__, __LINE__,
	603	fullpath, &fileInfo) == -1)
	604	{
	605	status = errno;
	606	msg = SH_ALLOC(SH_BUFSIZE);
	607	tmp = sh_util_safe_name(fullpath);
	608
	609	(void) sl_snprintf(msg, SH_BUFSIZE, _("I/O error. errno = %ld(stat)"), status);
[253]	610	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	611	sh_error_handle (ShSuidchkSeverity,
	612	FIL__, __LINE__,
	613	status,
	614	MSG_SUID_QREPORT,
	615	msg, tmp );
[253]	616	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	617	SH_FREE(tmp);
	618	SH_FREE(msg);
	619	}
	620	else
	621	{
	622	basetmp = sh_util_strdup(fullpath);
	623	filetmp = SH_ALLOC(PATH_MAX+1);
	624	tmp = sh_util_basename(basetmp);
	625
	626	(void) sl_snprintf(filetmp, PATH_MAX+1, "%s/%s",
	627	DEFAULT_QDIR, tmp);
	628	SH_FREE(tmp);
	629	SH_FREE(basetmp);
	630
	631	readFile = open (fullpath, O_RDONLY);
	632	if (readFile != -1)
[166]	633	writeFile = open (filetmp, O_WRONLY\|O_CREAT, S_IRUSR\|S_IWUSR\|S_IXUSR);
[94]	634
	635	if ((readFile == -1) \|\| (writeFile == -1))
	636	{
	637	status = errno;
	638	msg = SH_ALLOC(SH_BUFSIZE);
	639	tmp = sh_util_safe_name(fullpath);
	640
	641	(void) sl_snprintf(msg, SH_BUFSIZE, _("Problem quarantining file. File NOT quarantined. errno = %ld (open)"), status);
[253]	642	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	643	sh_error_handle (ShSuidchkSeverity,
	644	FIL__, __LINE__, status,
	645	MSG_SUID_QREPORT,
	646	msg, tmp );
[253]	647	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	648	SH_FREE(tmp);
	649	SH_FREE(msg);
	650	}
	651	else
	652	{
	653	/* sizeof(buffer) is 1024
	654	*/
	655	while ((count = (int) read (readFile, buffer, sizeof (buffer))) > 0)
	656	{
	657	if ((int) write (writeFile, buffer, (size_t) count) != count)
	658	{
	659	status = errno;
	660	msg = SH_ALLOC(SH_BUFSIZE);
	661	tmp = sh_util_safe_name(fullpath);
	662
	663	(void) sl_snprintf(msg, SH_BUFSIZE,
	664	_("I/O error. errno = %ld (write)"), status);
[253]	665	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	666	sh_error_handle (ShSuidchkSeverity,
	667	FIL__,
	668	__LINE__,
	669	status,
	670	MSG_SUID_QREPORT,
	671	msg, tmp );
[253]	672	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	673	SH_FREE(tmp);
	674	SH_FREE(msg);
	675	}
	676	}
	677	}
	678
[252]	679	(void) sl_close_fd (FIL__, __LINE__, readFile);
[94]	680	(void) fchmod(writeFile, S_IRUSR \| S_IWUSR \| S_IXUSR);
[252]	681	(void) sl_close_fd (FIL__, __LINE__, writeFile);
[94]	682
	683	if (do_truncate (fullpath) == -1)
	684	{
	685	status = errno;
	686	msg = SH_ALLOC(SH_BUFSIZE);
	687	tmp = sh_util_safe_name(fullpath);
	688
	689	(void) sl_snprintf(msg, SH_BUFSIZE,
	690	_("Problem quarantining file. File NOT quarantined. errno = %ld"),
	691	status);
[253]	692	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	693	sh_error_handle (ShSuidchkSeverity,
	694	FIL__, __LINE__, status,
	695	MSG_SUID_QREPORT,
	696	msg, tmp );
[253]	697	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	698	SH_FREE(tmp);
	699	SH_FREE(msg);
	700	}
	701	else
	702	{
	703	tmp = sh_util_basename(fullpath);
	704
	705	(void) sl_snprintf(filetmp, PATH_MAX+1, "%s/%s.info",
	706	DEFAULT_QDIR,
	707	tmp);
	708
	709	SH_FREE(tmp);
	710	/*
	711	* avoid chmod by setting umask
	712	*/
	713	umask_old = umask (0077);
	714	filePtr = fopen (filetmp, "w+");
	715
	716	/@-usedef@/
	717	if (filePtr)
	718	{
	719	fprintf(filePtr,
	720	_("File Info:\n filename=%s\n size=%lu\n owner=%s(%d)\n group=%s(%d)\n ctime=%s\n atime=%s\n mtime=%s\n"),
	721	fullpath,
	722	(unsigned long) theFile->size,
	723	theFile->c_owner, (int) theFile->owner,
	724	theFile->c_group, (int) theFile->group,
	725	timestrc, timestra, timestrm);
[252]	726	(void) sl_fclose (FIL__, __LINE__, filePtr);
[94]	727	}
	728	/@+usedef@/
	729	umask (umask_old);
	730
	731	tmp = sh_util_safe_name(fullpath);
[253]	732	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	733	sh_error_handle (ShSuidchkSeverity,
	734	FIL__,__LINE__,
	735	0, MSG_SUID_QREPORT,
	736	_("Quarantine method applied"),
	737	tmp );
[253]	738	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	739	SH_FREE(tmp);
	740	}
	741	SH_FREE(filetmp);
	742	}
	743	}
	744	SH_FREE(dir);
	745	return;
	746	}
	747
[253]	748	/* This variable is not used anywhere. It only exists
	749	* to assign &dirlist to it, which keeps gcc from
	750	* putting it into a register, and avoids the 'clobbered
	751	* by longjmp' warning. And no, 'volatile' proved insufficient.
	752	*/
	753	static void * sh_dummy_ctmp = NULL;
	754	static void * sh_dummy_cmsg = NULL;
	755
[94]	756	static void sh_q_changeperm(const char * fullpath)
	757	{
[253]	758	volatile int caperr;
	759	volatile int status;
[94]	760	char * msg;
	761	char * tmp;
	762	struct stat fileInfo;
	763	struct stat fileInfo_F;
	764	int cperm_status = 0;
[253]	765	volatile int file_d = -1;
[132]	766	char errbuf[SH_ERRBUF_SIZE];
[94]	767
[253]	768	/* Take the address to keep gcc from putting it into a register.
	769	* Avoids the 'clobbered by longjmp' warning.
	770	*/
	771	sh_dummy_ctmp = (void*) &tmp;
	772	sh_dummy_cmsg = (void*) &msg;
	773
[94]	774	if (retry_lstat(FIL__, __LINE__, fullpath, &fileInfo) == -1)
	775	{
	776	status = errno;
	777	msg = SH_ALLOC(SH_BUFSIZE);
	778	tmp = sh_util_safe_name(fullpath);
	779
	780	(void) sl_snprintf(msg, SH_BUFSIZE, _("I/O error. errno = %ld"), status);
[253]	781	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	782	sh_error_handle (ShSuidchkSeverity,
	783	FIL__, __LINE__,
	784	status,
	785	MSG_SUID_QREPORT, msg,
	786	tmp );
[253]	787	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	788	SH_FREE(tmp);
	789	SH_FREE(msg);
	790	cperm_status = -1;
	791	}
	792
	793	if (cperm_status == 0)
	794	{
	795	if (0 != (caperr = sl_get_cap_qdel()))
	796	{
[253]	797	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	798	sh_error_handle((-1), FIL__, __LINE__,
	799	caperr, MSG_E_SUBGEN,
[132]	800	sh_error_message (caperr, errbuf, sizeof(errbuf)),
[94]	801	_("sl_get_cap_qdel"));
[253]	802	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	803	cperm_status = -1;
	804	}
	805	}
	806
	807	if (cperm_status == 0)
	808	{
	809	file_d = aud_open (FIL__, __LINE__, SL_YESPRIV,
	810	fullpath, O_RDONLY, 0);
	811	if (-1 == file_d)
	812	{
	813	status = errno;
	814	msg = SH_ALLOC(SH_BUFSIZE);
	815	tmp = sh_util_safe_name(fullpath);
	816
	817	(void) sl_snprintf(msg, SH_BUFSIZE, _("I/O error. errno = %ld"), status);
[253]	818	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	819	sh_error_handle (ShSuidchkSeverity,
	820	FIL__, __LINE__,
	821	status,
	822	MSG_SUID_QREPORT, msg,
	823	tmp );
[253]	824	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	825	SH_FREE(tmp);
	826	SH_FREE(msg);
	827	cperm_status = -1;
	828	}
	829	}
	830
	831	if (cperm_status == 0)
	832	{
	833	if (retry_fstat(FIL__, __LINE__, file_d, &fileInfo_F) == -1)
	834	{
	835	status = errno;
	836	msg = SH_ALLOC(SH_BUFSIZE);
	837	tmp = sh_util_safe_name(fullpath);
	838
	839	(void) sl_snprintf(msg, SH_BUFSIZE,
	840	_("I/O error. errno = %ld"), status);
[253]	841	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	842	sh_error_handle (ShSuidchkSeverity,
	843	FIL__, __LINE__,
	844	status,
	845	MSG_SUID_QREPORT, msg,
	846	tmp );
[253]	847	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	848	SH_FREE(tmp);
	849	SH_FREE(msg);
	850	cperm_status = -1;
	851	}
	852	}
	853
	854	if (cperm_status == 0)
	855	{
	856	if (fileInfo_F.st_ino != fileInfo.st_ino \|\|
	857	fileInfo_F.st_dev != fileInfo.st_dev \|\|
	858	fileInfo_F.st_mode != fileInfo.st_mode)
	859	{
	860	status = errno;
	861	msg = SH_ALLOC(SH_BUFSIZE);
	862	tmp = sh_util_safe_name(fullpath);
	863
	864	(void) sl_snprintf(msg, SH_BUFSIZE,
	865	_("Race detected. errno = %ld"), status);
[253]	866	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	867	sh_error_handle (ShSuidchkSeverity,
	868	FIL__, __LINE__,
	869	status,
	870	MSG_SUID_QREPORT, msg,
	871	tmp );
[253]	872	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	873	SH_FREE(tmp);
	874	SH_FREE(msg);
	875	cperm_status = -1;
	876	}
	877	}
	878
	879	if ((fileInfo.st_mode & S_ISUID) > 0)
	880	fileInfo.st_mode -= S_ISUID;
	881	if ((fileInfo.st_mode & S_ISGID) > 0)
	882	fileInfo.st_mode -= S_ISGID;
	883
	884	if (cperm_status == 0)
	885	{
	886	if (fchmod(file_d, fileInfo.st_mode) == -1)
	887	{
	888	status = errno;
	889	msg = SH_ALLOC(SH_BUFSIZE);
	890	tmp = sh_util_safe_name(fullpath);
	891
	892	(void) sl_snprintf(msg, SH_BUFSIZE,
	893	_("Problem quarantining file. File NOT quarantined. errno = %ld"),
	894	status);
[253]	895	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	896	sh_error_handle (ShSuidchkSeverity,
	897	FIL__, __LINE__,
	898	status,
	899	MSG_SUID_QREPORT,
	900	msg, tmp );
[253]	901	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	902	SH_FREE(tmp);
	903	SH_FREE(msg);
	904	}
	905	else
	906	{
	907	tmp = sh_util_safe_name(fullpath);
[253]	908	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	909	sh_error_handle (ShSuidchkSeverity,
	910	FIL__, __LINE__,
	911	0,
	912	MSG_SUID_QREPORT,
	913	_("Quarantine method applied"),
	914	tmp );
[253]	915	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	916	SH_FREE(tmp);
	917	}
	918	}
	919
	920	if (0 != (caperr = sl_drop_cap_qdel()))
	921	{
[253]	922	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	923	sh_error_handle((-1), FIL__, __LINE__,
	924	caperr, MSG_E_SUBGEN,
[132]	925	sh_error_message (caperr, errbuf, sizeof(errbuf)),
[94]	926	_("sl_drop_cap_qdel"));
[253]	927	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	928	}
	929
	930	if (file_d != -1)
	931	{
	932	do {
[252]	933	status = sl_close_fd (FIL__, __LINE__, file_d);
[94]	934	} while (status == -1 && errno == EINTR);
	935
	936	if (-1 == status)
	937	{
	938	status = errno;
	939	msg = SH_ALLOC(SH_BUFSIZE);
	940	tmp = sh_util_safe_name(fullpath);
	941
	942	(void) sl_snprintf(msg, SH_BUFSIZE,
	943	_("I/O error. errno = %ld"), status);
[253]	944	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	945	sh_error_handle (ShSuidchkSeverity,
	946	FIL__, __LINE__,
	947	status,
	948	MSG_SUID_QREPORT, msg,
	949	tmp );
[253]	950	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	951	SH_FREE(tmp);
	952	SH_FREE(msg);
	953	}
	954	}
	955	return;
	956	}
	957
	958	static void report_file (const char * tmpcat, file_type * theFile,
	959	char * timestrc, char * timestra, char * timestrm)
	960	{
	961	char * msg = SH_ALLOC(SH_BUFSIZE);
	962	char * tmp = sh_util_safe_name(tmpcat);
	963
	964	msg[0] = '\0';
	965	/@-usedef@/
[132]	966
[94]	967	#ifdef SH_USE_XML
	968	(void) sl_snprintf(msg, SH_BUFSIZE, _("owner_new=\"%s\" iowner_new=\"%ld\" group_new=\"%s\" igroup_new=\"%ld\" size_new=\"%lu\" ctime_new=\"%s\" atime_new=\"%s\" mtime_new=\"%s\""),
	969	theFile->c_owner, theFile->owner,
	970	theFile->c_group, theFile->group,
	971	(unsigned long) theFile->size,
	972	timestrc, timestra, timestrm);
	973	#else
	974	(void) sl_snprintf(msg, SH_BUFSIZE, _("owner_new=<%s>, iowner_new=<%ld>, group_new=<%s>, igroup_new=<%ld>, filesize=<%lu>, ctime=<%s>, atime=<%s>, mtime=<%s>"),
	975	theFile->c_owner, theFile->owner,
	976	theFile->c_group, theFile->group,
	977	(unsigned long) theFile->size,
	978	timestrc, timestra, timestrm);
	979	#endif
	980	/@+usedef@/
	981
[253]	982	SH_MUTEX_LOCK(mutex_thread_nolog);
[94]	983	sh_error_handle (ShSuidchkSeverity, FIL__, __LINE__,
	984	0, MSG_SUID_POLICY,
	985	_("suid/sgid file not in database"),
	986	tmp, msg );
[253]	987	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[94]	988	SH_FREE(tmp);
	989	SH_FREE(msg);
	990	return;
	991	}
	992
[253]	993	/* This variable is not used anywhere. It only exists
	994	* to assign &dirlist to it, which keeps gcc from
	995	* putting it into a register, and avoids the 'clobbered
	996	* by longjmp' warning. And no, 'volatile' proved insufficient.
	997	*/
	998	static void * sh_dummy_dirlist = NULL;
	999	static void * sh_dummy_itmp = NULL;
	1000
	1001
[1]	1002	static
	1003	int sh_suidchk_check_internal (char * iname)
	1004	{
	1005	DIR * thisDir = NULL;
	1006	struct dirent * thisEntry;
	1007	char * tmpcat;
	1008	char * tmp;
	1009	char timestrc[32];
	1010	char timestra[32];
	1011	char timestrm[32];
	1012	struct stat buf;
[253]	1013	volatile int status;
[115]	1014	int fflags;
[1]	1015	char * fs;
[253]	1016	volatile long sl_status;
[227]	1017	file_type * theFile = NULL;
[19]	1018	char fileHash[2*(KEY_LEN + 1)];
[1]	1019
[170]	1020	struct sh_dirent * dirlist;
	1021	struct sh_dirent * dirlist_orig;
[132]	1022	char errbuf[SH_ERRBUF_SIZE];
[22]	1023
[1]	1024	SL_ENTER(_("sh_suidchk_check_internal"));
	1025
[253]	1026	/* Take the address to keep gcc from putting it into a register.
	1027	* Avoids the 'clobbered by longjmp' warning.
	1028	*/
	1029	sh_dummy_dirlist = (void*) &dirlist;
	1030	sh_dummy_itmp = (void*) &tmp;
	1031
[1]	1032	if (iname == NULL)
	1033	{
	1034	TPT((0, FIL__, __LINE__ , _("msg=<directory name is NULL>\n")));
	1035	SL_RETURN( (-1), _("sh_suidchk_check_internal"));
	1036	}
	1037
	1038	if (sig_urgent > 0) {
	1039	SL_RETURN( (0), _("sh_suidchk_check_internal"));
	1040	}
	1041
	1042	thisDir = opendir (iname);
	1043
	1044	if (thisDir == NULL)
	1045	{
	1046	status = errno;
	1047	tmp = sh_util_safe_name(iname);
[253]	1048	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1049	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, status,
	1050	MSG_E_OPENDIR,
[132]	1051	sh_error_message (status, errbuf, sizeof(errbuf)), tmp);
[253]	1052	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1053	SH_FREE(tmp);
	1054	SL_RETURN( (-1), _("sh_suidchk_check_internal"));
	1055	}
	1056
[94]	1057	/* Loop over directory entries
	1058	*/
[137]	1059	SH_MUTEX_LOCK(mutex_readdir);
[131]	1060
[170]	1061	dirlist = NULL;
	1062	dirlist_orig = NULL;
	1063
[1]	1064	do {
	1065
	1066	thisEntry = readdir (thisDir);
	1067
	1068	if (thisEntry != NULL) {
	1069
	1070	if (sl_strcmp (thisEntry->d_name, ".") == 0)
	1071	continue;
	1072
	1073	if (sl_strcmp (thisEntry->d_name, "..") == 0)
	1074	continue;
	1075
[131]	1076	dirlist = addto_sh_dirlist (thisEntry, dirlist);
	1077	}
[1]	1078
[131]	1079	} while (thisEntry != NULL);
[94]	1080
[137]	1081	SH_MUTEX_UNLOCK(mutex_readdir);
[94]	1082
[131]	1083	closedir(thisDir);
[1]	1084
[131]	1085	dirlist_orig = dirlist;
[1]	1086
[170]	1087	sl_status = SL_ENONE;
	1088
[131]	1089	do {
	1090
	1091	/* If the directory is empty, dirlist = NULL
	1092	*/
	1093	if (!dirlist)
	1094	break;
	1095
[143]	1096	if (sig_urgent > 0) {
	1097	SL_RETURN( (0), _("sh_suidchk_check_internal"));
	1098	}
	1099
[131]	1100	tmpcat = SH_ALLOC(PATH_MAX);
	1101	(void) sl_strlcpy(tmpcat, iname, PATH_MAX);
	1102
	1103	if ((sl_strlen(tmpcat) != sl_strlen(iname)) \|\| (tmpcat[0] == '\0'))
	1104	{
	1105	sl_status = SL_ETRUNC;
	1106	}
	1107	else
	1108	{
	1109	if (tmpcat[1] != '\0')
	1110	sl_status = sl_strlcat(tmpcat, "/", PATH_MAX);
	1111	}
	1112
	1113	if (! SL_ISERROR(sl_status))
	1114	sl_status = sl_strlcat(tmpcat, dirlist->sh_d_name, PATH_MAX);
	1115
	1116	if (SL_ISERROR(sl_status))
	1117	{
	1118	tmp = sh_util_safe_name(tmpcat);
[253]	1119	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1120	sh_error_handle ((-1), FIL__, __LINE__, (int) sl_status,
	1121	MSG_E_SUBGPATH,
	1122	_("path too long"),
	1123	_("sh_suidchk_check_internal"), tmp );
[253]	1124	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1125	SH_FREE(tmp);
[227]	1126	SH_FREE(tmpcat);
[131]	1127	dirlist = dirlist->next;
	1128	continue;
	1129	}
	1130
	1131	++FileLimNum;
	1132	++FileLimTotal;
	1133
	1134	/* Rate limit (Fps == Files per second)
	1135	*/
	1136	if ((ShSuidchkFps > 0 && FileLimNum > ShSuidchkFps && FileLimTotal > 0)&&
	1137	(ShSuidchkYield == S_FALSE))
	1138	{
	1139	FileLimNum = 0;
	1140	FileLimNow = time(NULL);
	1141
	1142	if ( (FileLimNow - FileLimStart) > 0 &&
	1143	FileLimTotal/(FileLimNow - FileLimStart) > ShSuidchkFps )
	1144	(void) retry_msleep((int)((FileLimTotal/(FileLimNow-FileLimStart))/
	1145	ShSuidchkFps) , 0);
	1146	}
[1]	1147
[131]	1148	status = (int) retry_lstat(FIL__, __LINE__, tmpcat, &buf);
[1]	1149
[131]	1150	if (status != 0)
	1151	{
[253]	1152	volatile int elevel = SH_ERR_ERR;
[252]	1153	size_t tlen;
	1154
[131]	1155	status = errno;
	1156	tmp = sh_util_safe_name(tmpcat);
[252]	1157	tlen = strlen(tmp);
	1158	if (tlen >= 6 && 0 == strcmp(&tmp[tlen-6], _("/.gvfs")))
	1159	elevel = SH_ERR_NOTICE;
[453]	1160	else if (tlen >= 5 && 0 == strcmp(&tmp[tlen-5], _("/gvfs")))
[452]	1161	elevel = SH_ERR_NOTICE;
[406]	1162
	1163	/* If we are scanning a temporary directory where dirs and files
	1164	* can be created/deleted, an lstat() error is something which
	1165	* may occur frequently. As a missing dir/file is not an important
	1166	* problem for the suidcheck, the error level is only SH_ERR_NOTICE.
	1167	*/
	1168	if (status == ENOENT)
	1169	elevel = SH_ERR_NOTICE;
	1170
[253]	1171	SH_MUTEX_LOCK(mutex_thread_nolog);
[252]	1172	sh_error_handle (elevel, FIL__, __LINE__, status, MSG_ERR_LSTAT,
[132]	1173	sh_error_message(status, errbuf, sizeof(errbuf)),
[252]	1174	tmp );
[253]	1175	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1176	SH_FREE(tmp);
	1177	}
	1178	else
	1179	{
	1180	if (/@-usedef@/S_ISDIR(buf.st_mode)/@+usedef@/ &&
	1181	(ShSuidchkExclude == NULL \|\|
[452]	1182	NULL == zAVL_string_get(ShSuidchkExclude, tmpcat)))
[131]	1183	{
	1184	/* fs is a STATIC string or NULL
	1185	*/
	1186	fs = filesystem_type (tmpcat, tmpcat, &buf);
	1187	if (fs != NULL
[30]	1188	#ifndef SH_SUIDTESTDIR
[131]	1189	&&
	1190	0 != strncmp (_("afs"), fs, 3) &&
	1191	0 != strncmp (_("devfs"), fs, 5) &&
[231]	1192	0 != strncmp (_("fdesc"), fs, 5) &&
[131]	1193	0 != strncmp (_("iso9660"), fs, 7) &&
[231]	1194	0 != strncmp (_("cd9660"), fs, 6) &&
[131]	1195	0 != strncmp (_("lustre"), fs, 6) &&
	1196	0 != strncmp (_("mmfs"), fs, 4) &&
	1197	0 != strncmp (_("msdos"), fs, 5) &&
	1198	0 != strncmp (_("nfs"), fs, 3) &&
	1199	0 != strncmp (_("proc"), fs, 4) &&
[231]	1200	0 != strncmp (_("sysfs"), fs, 5) &&
[131]	1201	0 != strncmp (_("vfat"), fs, 4)
[30]	1202	#endif
[131]	1203	)
	1204	{
	1205	if ((ShSuidchkNosuid == S_TRUE) \|\|
	1206	(0 != strncmp (_("nosuid"), fs, 6)))
	1207	/* fprintf(stderr, "%s: %s\n", fs, tmpcat); */
	1208	(void) sh_suidchk_check_internal(tmpcat);
	1209	}
	1210	}
	1211	else if (S_ISREG(buf.st_mode) &&
	1212	(0 !=(S_ISUID & buf.st_mode) \|\|
[1]	1213	#if defined(HOST_IS_LINUX)
[131]	1214	(0 !=(S_ISGID & buf.st_mode) &&
	1215	0 !=(S_IXGRP & buf.st_mode))
[1]	1216	#else
[131]	1217	0 !=(S_ISGID & buf.st_mode)
[1]	1218	#endif
[131]	1219	)
	1220	)
	1221	{
[370]	1222	int dummy;
	1223	int class;
[381]	1224	unsigned long check_mask = 0;
[370]	1225
[227]	1226	theFile = SH_ALLOC(sizeof(file_type));
	1227
	1228	(void) sl_strlcpy (theFile->fullpath, tmpcat, PATH_MAX);
	1229	theFile->check_mask = sh_files_maskof(SH_LEVEL_READONLY);
	1230	CLEAR_SH_FFLAG_REPORTED(theFile->file_reported);
	1231	theFile->attr_string = NULL;
	1232	theFile->link_path = NULL;
[131]	1233
[370]	1234	sh_files_search_file(tmpcat, &class, &check_mask, &dummy);
	1235	if ((check_mask & MODI_PREL) != 0)
	1236	{
	1237	theFile->check_mask \|= MODI_PREL;
	1238	}
	1239
[131]	1240	status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_RO],
[138]	1241	dirlist->sh_d_name,
[227]	1242	theFile, fileHash, 0);
[131]	1243
	1244	tmp = sh_util_safe_name(tmpcat);
	1245
	1246	if (status != 0)
	1247	{
[253]	1248	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1249	sh_error_handle (ShSuidchkSeverity, FIL__, __LINE__,
	1250	0, MSG_E_SUBGPATH,
	1251	_("Could not check suid/sgid file"),
	1252	_("sh_suidchk_check_internal"),
	1253	tmp);
[253]	1254	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1255	}
	1256	else
	1257	{
	1258
	1259	if ( sh.flag.update == S_TRUE &&
	1260	(sh.flag.checkSum == SH_CHECK_INIT \|\|
	1261	sh.flag.checkSum == SH_CHECK_CHECK))
	1262	{
[253]	1263	int compret;
	1264
[131]	1265	/* Updating database. Report new files that
	1266	* are not in database already. Then compare
	1267	* to database and report changes.
	1268	*/
	1269	if (-1 == sh_hash_have_it (tmpcat))
	1270	{
[253]	1271	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1272	sh_error_handle ((-1), FIL__, __LINE__,
	1273	0, MSG_SUID_FOUND, tmp );
[253]	1274	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1275	}
	1276	else
	1277	{
[253]	1278	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1279	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,
	1280	0, MSG_SUID_FOUND, tmp );
[253]	1281	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1282	}
	1283
[253]	1284	SH_MUTEX_LOCK(mutex_thread_nolog);
	1285	compret = sh_hash_compdata (SH_LEVEL_READONLY,
	1286	theFile, fileHash,
	1287	_("[SuidCheck]"),
	1288	ShSuidchkSeverity);
	1289	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	1290
	1291	if (compret == 0)
[131]	1292	{
[253]	1293	sh_hash_pushdata_memory (theFile, fileHash); /* no call to sh_error_handle */
[131]	1294	}
	1295
[253]	1296	sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); /* no call to sh_error_handle */
[131]	1297
	1298	}
	1299
	1300	else if (sh.flag.checkSum == SH_CHECK_INIT &&
	1301	sh.flag.update == S_FALSE )
	1302	{
	1303	/* Running init. Report on files detected.
	1304	*/
[253]	1305	sh_hash_pushdata (theFile, fileHash); /* no call to sh_error_handle */
	1306	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1307	sh_error_handle ((-1), FIL__, __LINE__,
	1308	0, MSG_SUID_FOUND, tmp );
[253]	1309	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1310	}
	1311
	1312	else if (sh.flag.checkSum == SH_CHECK_CHECK )
	1313	{
	1314	/* Running file check. Report on new files
	1315	* detected, and quarantine them.
	1316	*/
[253]	1317	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1318	sh_error_handle (SH_ERR_ALL, FIL__, __LINE__,
	1319	0, MSG_SUID_FOUND, tmp );
[253]	1320	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1321
[253]	1322	fflags = sh_hash_getflags(tmpcat); /* no call to sh_error_handle */
[131]	1323
	1324	if ( (-1 == fflags) \|\| (!SH_FFLAG_SUIDCHK_SET(fflags)))
	1325	{
	1326	if (-1 == fflags)
[132]	1327	{
[227]	1328	(void) sh_unix_gmttime (theFile->ctime, timestrc, sizeof(timestrc));
	1329	(void) sh_unix_gmttime (theFile->atime, timestra, sizeof(timestra));
	1330	(void) sh_unix_gmttime (theFile->mtime, timestrm, sizeof(timestrm));
[132]	1331
[227]	1332	report_file(tmpcat, theFile, timestrc, timestra, timestrm);
[132]	1333	}
[131]	1334	/* Quarantine file according to configured method
	1335	*/
	1336	if (ShSuidchkQEnable == S_TRUE)
	1337	{
	1338	switch (ShSuidchkQMethod)
	1339	{
	1340	case SH_Q_DELETE:
[227]	1341	sh_q_delete(theFile->fullpath);
[131]	1342	break;
	1343	case SH_Q_CHANGEPERM:
[227]	1344	sh_q_changeperm(theFile->fullpath);
[131]	1345	break;
	1346	case SH_Q_MOVE:
[227]	1347	sh_q_move(theFile->fullpath, theFile, timestrc, timestra, timestrm);
[131]	1348	break;
	1349	default:
[253]	1350	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1351	sh_error_handle (ShSuidchkSeverity, FIL__,
	1352	__LINE__, 0, MSG_SUID_QREPORT,
	1353	_("Bad quarantine method"), tmp);
[253]	1354	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1355	break;
	1356	}
	1357	}
	1358	else
	1359	{
	1360	/* 1.8.1 push file to in-memory database
	1361	*/
[253]	1362	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1363	(void) sh_hash_compdata (SH_LEVEL_READONLY,
[227]	1364	theFile, fileHash,
[131]	1365	_("[SuidCheck]"),
	1366	ShSuidchkSeverity);
[253]	1367	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[131]	1368
[253]	1369	sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); /* no call to sh_error_handle */
[131]	1370
	1371	}
	1372	}
	1373	else
	1374	{
	1375	/* File exists. Check for modifications.
	1376	*/
[253]	1377	SH_MUTEX_LOCK(mutex_thread_nolog);
[131]	1378	(void) sh_hash_compdata (SH_LEVEL_READONLY,
[227]	1379	theFile, fileHash,
[131]	1380	_("[SuidCheck]"),
	1381	ShSuidchkSeverity);
[253]	1382	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	1383	sh_hash_addflag(tmpcat, SH_FFLAG_SUIDCHK); /* no call to sh_error_handle */
[131]	1384
	1385	}
	1386	}
	1387	}
	1388	SH_FREE(tmp);
[227]	1389	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	1390	if (theFile->link_path) SH_FREE(theFile->link_path);
	1391	SH_FREE(theFile);
[131]	1392	}
	1393	}
	1394	SH_FREE(tmpcat);
[115]	1395
[131]	1396
[1]	1397	#ifdef HAVE_SCHED_YIELD
	1398	if (ShSuidchkYield == S_TRUE)
	1399	{
	1400	if (sched_yield() == -1)
	1401	{
	1402	status = errno;
[253]	1403	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1404	sh_error_handle ((-1), FIL__, __LINE__, status, MSG_E_SUBGEN,
[131]	1405	_("Failed to release time slice"),
[1]	1406	_("sh_suidchk_check_internal") );
[253]	1407	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1408	}
	1409	}
	1410	#endif
[131]	1411
	1412	dirlist = dirlist->next;
[68]	1413
[131]	1414	} while (dirlist != NULL);
[1]	1415
[131]	1416
	1417	kill_sh_dirlist (dirlist_orig);
	1418
[1]	1419	SL_RETURN( (0), _("sh_suidchk_check_internal"));
	1420	}
	1421
	1422	/*************
	1423	*
	1424	* module init
	1425	*
	1426	*************/
[140]	1427	int sh_suidchk_init (struct mod_type * arg)
[1]	1428	{
[253]	1429	#ifndef HAVE_PTHREAD
[140]	1430	(void) arg;
[253]	1431	#endif
	1432
[1]	1433	if (ShSuidchkActive == S_FALSE)
[253]	1434	return SH_MOD_FAILED;
[1]	1435
[253]	1436	#ifdef HAVE_PTHREAD
	1437	if (arg != NULL && arg->initval < 0 &&
	1438	(sh.flag.isdaemon == S_TRUE \|\| sh.flag.loop == S_TRUE))
	1439	{
	1440	if (0 == sh_pthread_create(sh_threaded_module_run, (void *)arg))
	1441	return SH_MOD_THREAD;
	1442	else
	1443	return SH_MOD_FAILED;
	1444	}
[335]	1445	else if (arg != NULL && arg->initval == SH_MOD_THREAD &&
	1446	(sh.flag.isdaemon == S_TRUE \|\| sh.flag.loop == S_TRUE))
	1447	{
	1448	return SH_MOD_THREAD;
	1449	}
[253]	1450	#endif
	1451
[1]	1452	return (0);
	1453	}
	1454
	1455
	1456	/*************
	1457	*
	1458	* module cleanup
	1459	*
	1460	*************/
	1461	int sh_suidchk_end ()
	1462	{
	1463	return (0);
	1464	}
	1465
	1466
	1467	/*************
	1468	*
	1469	* module timer
	1470	*
	1471	*************/
	1472	int sh_suidchk_timer (time_t tcurrent)
	1473	{
	1474	if (sh.flag.checkSum == SH_CHECK_INIT)
	1475	return -1;
	1476
	1477	/* One-shot (not daemon and not loop forever)
	1478	*/
	1479	if (sh.flag.isdaemon != S_TRUE && sh.flag.loop == S_FALSE)
	1480	return -1;
	1481
	1482	if (ShSuidchkSched != NULL)
	1483	{
	1484	return test_sched(ShSuidchkSched);
	1485	}
	1486	if ((time_t) (tcurrent - lastcheck) >= ShSuidchkInterval)
	1487	{
	1488	lastcheck = tcurrent;
	1489	return (-1);
	1490	}
	1491	return 0;
	1492	}
	1493
	1494	/*************
	1495	*
	1496	* module check
	1497	*
	1498	*************/
	1499
	1500	int sh_suidchk_check ()
	1501	{
[253]	1502	volatile int status;
[1]	1503
	1504	SL_ENTER(_("sh_suidchk_check"));
	1505
[253]	1506	if (ShSuidchkActive == S_FALSE)
	1507	SL_RETURN(-1, _("sh_suidchk_check"));
	1508
	1509	SH_MUTEX_LOCK(mutex_thread_nolog);
[257]	1510	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, EINVAL, MSG_E_SUBGEN,
[1]	1511	_("Checking for SUID programs"),
[257]	1512	_("sh_suidchk_check") );
[253]	1513	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1514
	1515	FileLimNow = time(NULL);
	1516	FileLimStart = FileLimNow;
	1517	FileLimNum = 0;
	1518	FileLimTotal = 0;
	1519
[22]	1520	#ifdef SH_SUIDTESTDIR
	1521	status = sh_suidchk_check_internal (SH_SUIDTESTDIR);
	1522	#else
[1]	1523	status = sh_suidchk_check_internal ("/");
[22]	1524	#endif
[1]	1525
[253]	1526	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1527	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_SUID_SUMMARY,
	1528	FileLimTotal,
	1529	(long) (time(NULL) - FileLimStart) );
[253]	1530	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1531
	1532	SL_RETURN(status, _("sh_suidchk_check"));
	1533	}
	1534
	1535	/*************
	1536	*
	1537	* module setup
	1538	*
	1539	*************/
	1540
[68]	1541	int sh_suidchk_set_severity (const char * c)
[1]	1542	{
	1543	int retval;
	1544	char tmp[32];
	1545
	1546	SL_ENTER(_("sh_suidchk_set_severity"));
	1547	tmp[0] = '='; tmp[1] = '\0';
	1548	(void) sl_strlcat (tmp, c, 32);
	1549	retval = sh_error_set_level (tmp, &ShSuidchkSeverity);
	1550	SL_RETURN(retval, _("sh_suidchk_set_severity"));
	1551	}
	1552
[68]	1553	int sh_suidchk_set_exclude (const char * c)
[1]	1554	{
[452]	1555	int ret = 0;
[1]	1556	SL_ENTER(_("sh_suidchk_set_exclude"));
[68]	1557
[1]	1558	if (c == NULL \|\| c[0] == '\0')
	1559	{
	1560	SL_RETURN(-1, _("sh_suidchk_set_exclude"));
	1561	}
	1562
	1563	if (0 == sl_strncmp(c, _("NULL"), 4))
	1564	{
	1565	if (ShSuidchkExclude != NULL)
[452]	1566	sh_suid_exclude_free();
[1]	1567	SL_RETURN(0, _("sh_suidchk_set_exclude"));
	1568	}
	1569
[452]	1570	ret = sh_suid_exclude_add(c);
[1]	1571
[452]	1572	SL_RETURN(ret, _("sh_suidchk_set_exclude"));
[1]	1573	}
	1574
[68]	1575	int sh_suidchk_set_timer (const char * c)
[1]	1576	{
[253]	1577	volatile long val;
[1]	1578
	1579	SL_ENTER(_("sh_suidchk_set_timer"));
	1580
	1581	val = strtol (c, (char **)NULL, 10);
	1582	if (val <= 0)
[253]	1583	{
	1584	SH_MUTEX_LOCK(mutex_thread_nolog);
	1585	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1586	_("suidchk timer"), c);
	1587	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	1588	}
[1]	1589	val = (val <= 0 ? 7200 : val);
	1590
	1591	ShSuidchkInterval = (time_t) val;
	1592	SL_RETURN( 0, _("sh_suidchk_set_timer"));
	1593	}
	1594
	1595
[170]	1596	static void sh_suidchk_free_schedule (void)
[1]	1597	{
	1598	sh_schedule_t * current = ShSuidchkSched;
	1599	sh_schedule_t * next = NULL;
	1600
	1601	while (current != NULL)
	1602	{
	1603	next = current->next;
	1604	SH_FREE(current);
	1605	current = next;
	1606	}
	1607	ShSuidchkSched = NULL;
[149]	1608	return;
[1]	1609	}
	1610
[149]	1611	int sh_suidchk_reconf ()
	1612	{
[253]	1613	SH_MUTEX_LOCK(mutex_suid_check);
[149]	1614	sh_suidchk_free_schedule();
	1615	set_defaults();
[253]	1616	SH_MUTEX_UNLOCK(mutex_suid_check);
[150]	1617	return 0;
[149]	1618	}
	1619
[68]	1620	int sh_suidchk_set_schedule (const char * str)
[1]	1621	{
	1622	int status;
	1623	sh_schedule_t * newSched = NULL;
	1624
	1625	SL_ENTER(_("sh_suidchk_set_schedule"));
	1626
	1627	/*
	1628	if (ShSuidchkSched != NULL)
	1629	{
	1630	SH_FREE(ShSuidchkSched);
	1631	ShSuidchkSched = NULL;
	1632	}
	1633	*/
	1634
	1635	if (0 == sl_strncmp(str, _("NULL"), 4))
	1636	{
	1637	(void) sh_suidchk_free_schedule ();
	1638	return 0;
	1639	}
	1640
	1641	newSched = SH_ALLOC(sizeof(sh_schedule_t));
	1642	status = create_sched(str, newSched);
	1643	if (status != 0)
	1644	{
	1645	SH_FREE(newSched);
	1646	newSched = NULL;
	1647	}
	1648	else
	1649	{
	1650	newSched->next = ShSuidchkSched;
	1651	ShSuidchkSched = newSched;
	1652	}
	1653	SL_RETURN( status, _("sh_suidchk_set_schedule"));
	1654	}
	1655
	1656
	1657
[68]	1658	int sh_suidchk_set_fps (const char * c)
[1]	1659	{
[253]	1660	volatile long val;
[1]	1661
	1662	SL_ENTER(_("sh_suidchk_set_fps"));
	1663
	1664	val = strtol (c, (char **)NULL, 10);
	1665	if (val < 0)
[253]	1666	{
	1667	SH_MUTEX_LOCK(mutex_thread_nolog);
	1668	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1669	_("suidchk fps"), c);
	1670	SH_MUTEX_UNLOCK(mutex_thread_nolog);
	1671	}
[1]	1672	val = (val < 0 ? 0 : val);
	1673
	1674	ShSuidchkFps = val;
	1675	SL_RETURN( 0, _("sh_suidchk_set_fps"));
	1676	}
	1677
[68]	1678	int sh_suidchk_set_yield (const char * c)
[1]	1679	{
	1680	int i;
	1681	SL_ENTER(_("sh_suidchk_set_yield"));
	1682	#ifdef HAVE_SCHED_YIELD
	1683	i = sh_util_flagval(c, &ShSuidchkYield);
	1684	#else
	1685	(void) c; /* cast to void to avoid compiler warning */
	1686	i = -1;
	1687	#endif
	1688	SL_RETURN(i, _("sh_suidchk_set_yield"));
	1689	}
	1690
[68]	1691	int sh_suidchk_set_activate (const char * c)
[1]	1692	{
	1693	int i;
	1694	SL_ENTER(_("sh_suidchk_set_activate"));
	1695	i = sh_util_flagval(c, &ShSuidchkActive);
	1696	SL_RETURN(i, _("sh_suidchk_set_activate"));
	1697	}
	1698
[119]	1699	int sh_suidchk_set_nosuid (const char * c)
	1700	{
	1701	int i;
	1702	SL_ENTER(_("sh_suidchk_set_nosuid"));
	1703	i = sh_util_flagval(c, &ShSuidchkNosuid);
	1704	SL_RETURN(i, _("sh_suidchk_set_nosuid"));
	1705	}
	1706
[68]	1707	int sh_suidchk_set_quarantine (const char * c)
[1]	1708	{
	1709	int i;
	1710	SL_ENTER(_("sh_suidchk_set_quarantine"));
	1711	i = sh_util_flagval(c, &ShSuidchkQEnable);
	1712	SL_RETURN(i, _("sh_suidchk_set_quarantine"));
	1713	}
	1714
[68]	1715	int sh_suidchk_set_qdelete (const char * c)
[1]	1716	{
	1717	int i;
	1718	SL_ENTER(_("sh_suidchk_set_qdelete"));
	1719	i = sh_util_flagval(c, &ShSuidchkQDelete);
	1720	SL_RETURN(i, _("sh_suidchk_set_qdelete"));
	1721	}
	1722
[68]	1723	int sh_suidchk_set_qmethod (const char * c)
[1]	1724	{
[253]	1725	volatile long val;
	1726	volatile int ret = 0;
[22]	1727	struct stat buf;
[1]	1728
	1729	SL_ENTER(_("sh_suidchk_set_qmethod"));
	1730
	1731	val = strtol (c, (char **)NULL, 10);
	1732	if (val < 0)
	1733	{
[253]	1734	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1735	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1736	_("suidchk qmethod"), c);
[253]	1737	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1738	ret = -1;
	1739	}
	1740	else
	1741	{
	1742	switch (val)
	1743	{
	1744	case SH_Q_DELETE:
	1745	ShSuidchkQMethod = SH_Q_DELETE;
	1746	break;
	1747	case SH_Q_CHANGEPERM:
	1748	ShSuidchkQMethod = SH_Q_CHANGEPERM;
	1749	break;
	1750	case SH_Q_MOVE:
[22]	1751	if (retry_stat (FIL__, __LINE__, DEFAULT_QDIR, &buf) != 0)
[1]	1752	{
	1753	if (mkdir (DEFAULT_QDIR, 0750) == -1)
	1754	{
[253]	1755	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1756	sh_error_handle ((-1), FIL__, __LINE__, EINVAL,
	1757	MSG_SUID_ERROR,
	1758	_("Unable to create quarantine directory"));
[253]	1759	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1760	}
	1761	}
	1762	ShSuidchkQMethod = SH_Q_MOVE;
	1763	break;
	1764	default:
[253]	1765	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	1766	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
	1767	_("suidchk qmethod"), c);
[253]	1768	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	1769	ShSuidchkQMethod = -1;
	1770	ret = -1;
	1771	break;
	1772	}
	1773	}
	1774
	1775	SL_RETURN( ret, _("sh_suidchk_set_qmethod"));
	1776	}
	1777
	1778	#if defined(FSTYPE_STATFS) \|\| defined(FSTYPE_AIX_STATFS)
	1779	/* dirname.c -- return all but the last element in a path
	1780	Copyright (C) 1990 Free Software Foundation, Inc.
	1781
	1782	This program is free software; you can redistribute it and/or modify
	1783	it under the terms of the GNU General Public License as published by
	1784	the Free Software Foundation; either version 2, or (at your option)
	1785	any later version.
	1786
	1787	This program is distributed in the hope that it will be useful,
	1788	but WITHOUT ANY WARRANTY; without even the implied warranty of
	1789	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	1790	GNU General Public License for more details.
	1791
	1792	You should have received a copy of the GNU General Public License
	1793	along with this program; if not, write to the Free Software Foundation,
	1794	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	1795
	1796	/* Return the leading directories part of PATH,
	1797	allocated with malloc. If out of memory, return 0.
	1798	Assumes that trailing slashes have already been
	1799	removed. */
	1800
	1801	char * sh_dirname (const char * path)
	1802	{
	1803	char *newpath;
	1804	char *slash;
	1805	int length; /* Length of result, not including NUL. */
	1806
	1807	slash = strrchr (path, '/');
	1808	if (slash == NULL)
	1809	{
	1810	/* File is in the current directory. */
	1811	path = ".";
	1812	length = 1;
	1813	}
	1814	else
	1815	{
	1816	/* Remove any trailing slashes from the result. */
	1817	while (slash > path && *slash == '/')
	1818	--slash;
	1819
	1820	length = slash - path + 1;
	1821	}
	1822	newpath = (char *) SH_ALLOC (length + 1);
	1823	if (newpath == NULL)
	1824	return NULL;
	1825	strncpy (newpath, path, length);
	1826	newpath[length] = '\0';
	1827	return newpath;
	1828	}
	1829	/* #ifdef FSTYPE_STATFS */
	1830	#endif
	1831
	1832	/* fstype.c -- determine type of filesystems that files are on
	1833	Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
	1834
	1835	This program is free software; you can redistribute it and/or modify
	1836	it under the terms of the GNU General Public License as published by
	1837	the Free Software Foundation; either version 2, or (at your option)
	1838	any later version.
	1839
	1840	This program is distributed in the hope that it will be useful,
	1841	but WITHOUT ANY WARRANTY; without even the implied warranty of
	1842	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	1843	GNU General Public License for more details.
	1844
	1845	You should have received a copy of the GNU General Public License
	1846	along with this program; if not, write to the Free Software
	1847	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	1848
	1849	/* Written by David MacKenzie <djm@gnu.ai.mit.edu>. */
	1850
	1851	/* Modified by R. Wichmann:
	1852	- replaced error() by sh_error_handle()
	1853	- replaced xstrdup() by sl_strdup()
	1854	- replaced strstr() by sl_strstr()
	1855	- some additions to recognize nosuid fs
	1856	*/
	1857
	1858	/* modetype.h -- file type bits definitions for POSIX systems
	1859	Requires sys/types.h sys/stat.h.
	1860	Copyright (C) 1990 Free Software Foundation, Inc.
	1861
	1862	This program is free software; you can redistribute it and/or modify
	1863	it under the terms of the GNU General Public License as published by
	1864	the Free Software Foundation; either version 2, or (at your option)
	1865	any later version.
	1866
	1867	This program is distributed in the hope that it will be useful,
	1868	but WITHOUT ANY WARRANTY; without even the implied warranty of
	1869	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	1870	GNU General Public License for more details.
	1871
	1872	You should have received a copy of the GNU General Public License
	1873	along with this program; if not, write to the Free Software
	1874	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	1875
	1876	/* POSIX.1 doesn't mention the S_IFMT bits; instead, it uses S_IStype
	1877	test macros. To make storing file types more convenient, define
	1878	them; the values don't need to correspond to what the kernel uses,
	1879	because of the way we use them. */
	1880	#ifndef S_IFMT /* Doesn't have traditional Unix macros. */
	1881	#define S_IFBLK 1
	1882	#define S_IFCHR 2
	1883	#define S_IFDIR 4
	1884	#define S_IFREG 8
	1885	#ifdef S_ISLNK
	1886	#define S_IFLNK 16
	1887	#endif
	1888	#ifdef S_ISFIFO
	1889	#define S_IFIFO 32
	1890	#endif
	1891	#ifdef S_ISSOCK
	1892	#define S_IFSOCK 64
	1893	#endif
	1894	#endif /* !S_IFMT */
	1895
	1896	#ifdef STAT_MACROS_BROKEN
	1897	#undef S_ISBLK
	1898	#undef S_ISCHR
	1899	#undef S_ISDIR
	1900	#undef S_ISREG
	1901	#undef S_ISFIFO
	1902	#undef S_ISLNK
	1903	#undef S_ISSOCK
	1904	#undef S_ISMPB
	1905	#undef S_ISMPC
	1906	#undef S_ISNWK
	1907	#endif
	1908
	1909	/* Do the reverse: define the POSIX.1 macros for traditional Unix systems
	1910	that don't have them. */
	1911	#if !defined(S_ISBLK) && defined(S_IFBLK)
	1912	#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)
	1913	#endif
	1914	#if !defined(S_ISCHR) && defined(S_IFCHR)
	1915	#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)
	1916	#endif
	1917	#if !defined(S_ISDIR) && defined(S_IFDIR)
	1918	#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
	1919	#endif
	1920	#if !defined(S_ISREG) && defined(S_IFREG)
	1921	#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
	1922	#endif
	1923	#if !defined(S_ISFIFO) && defined(S_IFIFO)
	1924	#define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)
	1925	#endif
	1926	#if !defined(S_ISLNK) && defined(S_IFLNK)
	1927	#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
	1928	#endif
	1929	#if !defined(S_ISSOCK) && defined(S_IFSOCK)
	1930	#define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
	1931	#endif
	1932	#if !defined(S_ISMPB) && defined(S_IFMPB) /* V7 */
	1933	#define S_ISMPB(m) (((m) & S_IFMT) == S_IFMPB)
	1934	#define S_ISMPC(m) (((m) & S_IFMT) == S_IFMPC)
	1935	#endif
	1936	#if !defined(S_ISNWK) && defined(S_IFNWK) /* HP/UX */
	1937	#define S_ISNWK(m) (((m) & S_IFMT) == S_IFNWK)
	1938	#endif
	1939
	1940
	1941	static char filesystem_type_uncached (char path, char *relpath,
	1942	struct stat *statp);
	1943
	1944	#ifdef FSTYPE_MNTENT /* 4.3BSD etc. */
[199]	1945	static int xatoi (const char *cp);
[1]	1946	#endif
	1947
	1948	#ifdef FSTYPE_MNTENT /* 4.3BSD, SunOS, HP-UX, Dynix, Irix. */
	1949	#include <mntent.h>
	1950	#if !defined(MOUNTED)
	1951	# if defined(MNT_MNTTAB) /* HP-UX. */
	1952	# define MOUNTED MNT_MNTTAB
	1953	# endif
	1954	# if defined(MNTTABNAME) /* Dynix. */
	1955	# define MOUNTED MNTTABNAME
	1956	# endif
	1957	#endif
	1958	#endif
	1959
	1960	#ifdef FSTYPE_GETMNT /* Ultrix. */
	1961	#include <sys/param.h>
	1962	#include <sys/mount.h>
	1963	#include <sys/fs_types.h>
	1964	#endif
	1965
	1966	#ifdef FSTYPE_USG_STATFS /* SVR3. */
	1967	#include <sys/statfs.h>
	1968	#include <sys/fstyp.h>
	1969	#endif
	1970
	1971	#ifdef FSTYPE_STATVFS /* SVR4. */
	1972	#include <sys/statvfs.h>
	1973	#include <sys/fstyp.h>
	1974	#endif
	1975
	1976	#ifdef FSTYPE_STATFS /* 4.4BSD. */
	1977	#include <sys/param.h> /* NetBSD needs this. */
	1978	#include <sys/mount.h>
	1979
	1980	#ifndef MFSNAMELEN /* NetBSD defines this. */
	1981	static char *
	1982	fstype_to_string (t)
	1983	short t;
	1984	{
	1985	#ifdef INITMOUNTNAMES /* Defined in 4.4BSD, not in NET/2. */
	1986	static char *mn[] = INITMOUNTNAMES;
	1987	if (t >= 0 && t <= MOUNT_MAXTYPE)
	1988	return mn[t];
	1989	else
	1990	return "?";
	1991	#else /* !INITMOUNTNAMES */
	1992	switch (t)
	1993	{
[231]	1994	#ifdef MOUNT_UFS
[1]	1995	case MOUNT_UFS:
	1996	return _("ufs");
[231]	1997	#endif
	1998	#ifdef MOUNT_ISO9660
	1999	case MOUNT_ISO9660:
	2000	return _("iso9660fs");
	2001	#endif
	2002	#ifdef MOUNT_CD9660
	2003	case MOUNT_CD9660:
	2004	return _("cd9660");
	2005	#endif
	2006	#ifdef MOUNT_NFS
[1]	2007	case MOUNT_NFS:
	2008	return _("nfs");
[231]	2009	#endif
[1]	2010	#ifdef MOUNT_PC
	2011	case MOUNT_PC:
	2012	return _("pc");
	2013	#endif
	2014	#ifdef MOUNT_MFS
	2015	case MOUNT_MFS:
	2016	return _("mfs");
	2017	#endif
	2018	#ifdef MOUNT_LO
	2019	case MOUNT_LO:
	2020	return _("lofs");
	2021	#endif
	2022	#ifdef MOUNT_TFS
	2023	case MOUNT_TFS:
	2024	return _("tfs");
	2025	#endif
	2026	#ifdef MOUNT_TMP
	2027	case MOUNT_TMP:
	2028	return _("tmp");
	2029	#endif
	2030	#ifdef MOUNT_MSDOS
	2031	case MOUNT_MSDOS:
	2032	return _("msdos");
	2033	#endif
[231]	2034	#ifdef MOUNT_LFS
	2035	case MOUNT_LFS:
	2036	return _("lfs");
[1]	2037	#endif
[231]	2038	#ifdef MOUNT_LOFS
	2039	case MOUNT_LOFS:
	2040	return _("lofs");
	2041	#endif
	2042	#ifdef MOUNT_FDESC
	2043	case MOUNT_FDESC:
	2044	return _("fdesc");
	2045	#endif
	2046	#ifdef MOUNT_PORTAL
	2047	case MOUNT_PORTAL:
	2048	return _("portal");
	2049	#endif
	2050	#ifdef MOUNT_NULL
	2051	case MOUNT_NULL:
	2052	return _("null");
	2053	#endif
	2054	#ifdef MOUNT_UMAP
	2055	case MOUNT_UMAP:
	2056	return _("umap");
	2057	#endif
	2058	#ifdef MOUNT_KERNFS
	2059	case MOUNT_KERNFS:
	2060	return _("kernfs");
	2061	#endif
	2062	#ifdef MOUNT_PROCFS
	2063	case MOUNT_PROCFS:
	2064	return _("procfs");
	2065	#endif
	2066	#ifdef MOUNT_DEVFS
	2067	case MOUNT_DEVFS:
	2068	return _("devfs");
	2069	#endif
	2070	#ifdef MOUNT_EXT2FS
	2071	case MOUNT_EXT2FS:
	2072	return _("ext2fs");
	2073	#endif
	2074	#ifdef MOUNT_UNION
	2075	case MOUNT_UNION:
	2076	return _("union");
	2077	#endif
[1]	2078	default:
	2079	return "?";
	2080	}
	2081	#endif /* !INITMOUNTNAMES */
	2082	}
	2083	#endif /* !MFSNAMELEN */
	2084	#endif /* FSTYPE_STATFS */
	2085
	2086	#ifdef FSTYPE_AIX_STATFS /* AIX. */
	2087	#include <sys/vmount.h>
	2088	#include <sys/statfs.h>
	2089
	2090	#define FSTYPE_STATFS /* Otherwise like 4.4BSD. */
	2091	#define f_type f_vfstype
	2092
	2093	static char *
	2094	fstype_to_string (t)
	2095	short t;
	2096	{
	2097	switch (t)
	2098	{
	2099	case MNT_AIX:
	2100	return _("aix"); /* AIX 4.3: NFS filesystems are actually MNT_AIX. */
	2101	#ifdef MNT_NAMEFS
	2102	case MNT_NAMEFS:
	2103	return _("namefs");
	2104	#endif
	2105	case MNT_NFS:
	2106	return _("nfs");
	2107	case MNT_JFS:
	2108	return _("jfs");
	2109	case MNT_CDROM:
	2110	return _("cdrom");
	2111	#ifdef MNT_PROCFS
	2112	case MNT_PROCFS:
	2113	return _("procfs");
	2114	#endif
	2115	#ifdef MNT_SFS
	2116	case MNT_SFS:
	2117	return _("sfs");
	2118	#endif
	2119	#ifdef MNT_CACHEFS
	2120	case MNT_CACHEFS:
	2121	return _("cachefs");
	2122	#endif
	2123	#ifdef MNT_NFS3
	2124	case MNT_NFS3:
	2125	return _("nfs3");
	2126	#endif
	2127	#ifdef MNT_AUTOFS
	2128	case MNT_AUTOFS:
	2129	return _("autofs");
	2130	#endif
	2131	#ifdef MNT_VXFS
	2132	case MNT_VXFS:
	2133	return _("vxfs");
	2134	#endif
	2135	#ifdef MNT_VXODM
	2136	case MNT_VXODM:
	2137	return _("veritasfs");
	2138	#endif
	2139	#ifdef MNT_UDF
	2140	case MNT_UDF:
	2141	return _("udfs");
	2142	#endif
	2143	#ifdef MNT_NFS4
	2144	case MNT_NFS4:
	2145	return _("nfs4");
	2146	#endif
	2147	#ifdef MNT_RFS4
	2148	case MNT_RFS4:
	2149	return _("nfs4");
	2150	#endif
	2151	#ifdef MNT_CIFS
	2152	case MNT_CIFS:
	2153	return _("cifs");
	2154	#endif
	2155	default:
	2156	return "?";
	2157	}
	2158	}
	2159	#endif /* FSTYPE_AIX_STATFS */
	2160
	2161	#ifdef AFS
	2162	#include <netinet/in.h>
	2163	#include <afs/venus.h>
	2164	#if __STDC__
	2165	/* On SunOS 4, afs/vice.h defines this to rely on a pre-ANSI cpp. */
	2166	#undef _VICEIOCTL
	2167	#define _VICEIOCTL(id) ((unsigned int ) _IOW('V', id, struct ViceIoctl))
	2168	#endif
	2169	#ifndef _IOW
	2170	/* AFS on Solaris 2.3 doesn't get this definition. */
	2171	#include <sys/ioccom.h>
	2172	#endif
	2173
	2174	static int
	2175	in_afs (path)
	2176	char *path;
	2177	{
	2178	static char space[2048];
	2179	struct ViceIoctl vi;
	2180
	2181	vi.in_size = 0;
	2182	vi.out_size = sizeof (space);
	2183	vi.out = space;
	2184
	2185	if (pioctl (path, VIOC_FILE_CELL_NAME, &vi, 1)
	2186	&& (errno == EINVAL \|\| errno == ENOENT))
	2187	return 0;
	2188	return 1;
	2189	}
	2190	#endif /* AFS */
	2191
	2192	/* Nonzero if the current filesystem's type is known. */
	2193	static int fstype_known = 0;
	2194
	2195	/* Return a static string naming the type of filesystem that the file PATH,
	2196	described by STATP, is on.
	2197	RELPATH is the file name relative to the current directory.
	2198	Return "unknown" if its filesystem type is unknown. */
	2199
	2200	static char *
	2201	filesystem_type (char * path, char * relpath, struct stat * statp)
	2202	{
	2203	static char *current_fstype = NULL;
	2204	static dev_t current_dev;
	2205
	2206	if (current_fstype != NULL)
	2207	{
	2208	if ((0 != fstype_known) && statp->st_dev == current_dev)
	2209	return current_fstype; /* Cached value. */
	2210	SH_FREE (current_fstype);
	2211	}
	2212	current_dev = statp->st_dev;
	2213	current_fstype = filesystem_type_uncached (path, relpath, statp);
	2214	return current_fstype;
	2215	}
	2216
[253]	2217	/* This variable is not used anywhere. It only exists
	2218	* to assign &dirlist to it, which keeps gcc from
	2219	* putting it into a register, and avoids the 'clobbered
	2220	* by longjmp' warning. And no, 'volatile' proved insufficient.
	2221	*/
	2222	static void * sh_dummy_type = NULL;
	2223
	2224
[1]	2225	/* Return a newly allocated string naming the type of filesystem that the
	2226	file PATH, described by STATP, is on.
	2227	RELPATH is the file name relative to the current directory.
	2228	Return "unknown" if its filesystem type is unknown. */
	2229
	2230	static char *
	2231	filesystem_type_uncached (path, relpath, statp)
	2232	char *path;
	2233	char *relpath;
	2234	struct stat *statp;
	2235	{
	2236	char * type = NULL;
	2237	#ifdef MFSNAMELEN /* NetBSD. */
	2238	static char my_tmp_type[64];
	2239	#endif
	2240
	2241	#ifdef FSTYPE_MNTENT /* 4.3BSD, SunOS, HP-UX, Dynix, Irix. */
	2242	char *table = MOUNTED;
	2243	FILE *mfp;
	2244	struct mntent *mnt;
	2245
	2246	if (path == NULL \|\| relpath == NULL)
	2247	return NULL;
	2248
	2249	mfp = setmntent (table, "r");
	2250	if (mfp == NULL)
	2251	{
[253]	2252	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2253	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
	2254	_("setmntent() failed"),
	2255	_("filesystem_type_uncached") );
[253]	2256	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2257	return NULL;
	2258	}
	2259
[253]	2260	/* Take the address to keep gcc from putting it into a register.
	2261	* Avoids the 'clobbered by longjmp' warning.
	2262	*/
	2263	sh_dummy_type = (void*) &type;
	2264
[1]	2265	/* Find the entry with the same device number as STATP, and return
	2266	that entry's fstype. */
	2267	while (type == NULL && (mnt = getmntent (mfp)) != NULL)
	2268	{
[199]	2269	const char *devopt;
[1]	2270	dev_t dev;
	2271	struct stat disk_stats;
	2272
	2273	#ifdef MNTTYPE_IGNORE
	2274	if (0 == strcmp (mnt->mnt_type, MNTTYPE_IGNORE))
	2275	continue;
	2276	#endif
	2277
	2278	/* Newer systems like SunOS 4.1 keep the dev number in the mtab,
	2279	in the options string. For older systems, we need to stat the
	2280	directory that the filesystem is mounted on to get it.
	2281
	2282	Unfortunately, the HPUX 9.x mnttab entries created by automountq
	2283	contain a dev= option but the option value does not match the
	2284	st_dev value of the file (maybe the lower 16 bits match?). */
	2285
	2286	#if !defined(hpux) && !defined(__hpux__)
	2287	devopt = sl_strstr (mnt->mnt_opts, "dev=");
	2288	if (devopt)
	2289	{
	2290	if (devopt[4] == '0' && (devopt[5] == 'x' \|\| devopt[5] == 'X'))
	2291	dev = (dev_t) xatoi (devopt + 6);
	2292	else
	2293	dev = (dev_t) xatoi (devopt + 4);
	2294	}
	2295	else
	2296	#endif /* not hpux */
	2297	{
	2298	if (stat (mnt->mnt_dir, &disk_stats) == -1)
	2299	{
[252]	2300	char errmsg[256];
[253]	2301	volatile int elevel = SH_ERR_ERR;
[252]	2302	size_t tlen = strlen(mnt->mnt_dir);
[440]	2303
[252]	2304	if (tlen >= 6 && 0 == strcmp(&((mnt->mnt_dir)[tlen-6]), _("/.gvfs")))
	2305	elevel = SH_ERR_NOTICE;
[440]	2306	else if (tlen >= 5 && 0 == strcmp(&((mnt->mnt_dir)[tlen-5]), _("/gvfs")))
	2307	elevel = SH_ERR_NOTICE;
	2308
[252]	2309	sl_snprintf(errmsg, sizeof(errmsg), _("stat(%s) failed"),
	2310	mnt->mnt_dir);
[253]	2311	SH_MUTEX_LOCK(mutex_thread_nolog);
[252]	2312	sh_error_handle (elevel, FIL__, __LINE__, 0, MSG_E_SUBGEN,
	2313	errmsg,
[1]	2314	_("filesystem_type_uncached") );
[253]	2315	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2316	return NULL;
	2317	}
	2318	dev = disk_stats.st_dev;
	2319	}
	2320
	2321	if (dev == statp->st_dev)
	2322	{
	2323	/* check for the "nosuid" option
	2324	*/
[61]	2325	#ifdef HAVE_HASMNTOPT
[119]	2326	if (NULL == hasmntopt(mnt, "nosuid") \|\| (ShSuidchkNosuid == S_TRUE))
[1]	2327	type = mnt->mnt_type;
	2328	else
[61]	2329	type = _("nosuid"); /* hasmntopt (nosuid) */
	2330	#else
	2331	type = mnt->mnt_type;
	2332	#endif
[1]	2333	}
	2334	}
	2335
	2336	if (endmntent (mfp) == 0)
	2337	{
[253]	2338	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2339	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
	2340	_("endmntent() failed"),
	2341	_("filesystem_type_uncached") );
[253]	2342	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2343	}
	2344	#endif
	2345
	2346	#ifdef FSTYPE_GETMNT /* Ultrix. */
	2347	int offset = 0;
	2348	struct fs_data fsd;
	2349
	2350	if (path == NULL \|\| relpath == NULL)
	2351	return NULL;
	2352
[253]	2353	/* Take the address to keep gcc from putting it into a register.
	2354	* Avoids the 'clobbered by longjmp' warning.
	2355	*/
	2356	sh_dummy_type = (void*) &type;
	2357
[1]	2358	while (type == NULL
	2359	&& getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY, 0) > 0)
	2360	{
	2361	if (fsd.fd_req.dev == statp->st_dev)
	2362	type = gt_names[fsd.fd_req.fstype];
	2363	}
	2364	#endif
	2365
	2366	#ifdef FSTYPE_USG_STATFS /* SVR3. */
	2367	struct statfs fss;
	2368	char typebuf[FSTYPSZ];
	2369
	2370	if (path == NULL \|\| relpath == NULL)
	2371	return NULL;
	2372
[253]	2373	/* Take the address to keep gcc from putting it into a register.
	2374	* Avoids the 'clobbered by longjmp' warning.
	2375	*/
	2376	sh_dummy_type = (void*) &type;
	2377
[1]	2378	if (statfs (relpath, &fss, sizeof (struct statfs), 0) == -1)
	2379	{
	2380	/* Don't die if a file was just removed. */
	2381	if (errno != ENOENT)
	2382	{
[253]	2383	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2384	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
	2385	_("statfs() failed"),
	2386	_("filesystem_type_uncached") );
[253]	2387	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2388	return NULL;
	2389	}
	2390	}
	2391	else if (!sysfs (GETFSTYP, fss.f_fstyp, typebuf))
	2392	type = typebuf;
	2393	#endif
	2394
	2395	#ifdef FSTYPE_STATVFS /* SVR4. */
	2396	struct statvfs fss;
	2397
	2398	if (path == NULL \|\| relpath == NULL)
	2399	return NULL;
	2400
[253]	2401	/* Take the address to keep gcc from putting it into a register.
	2402	* Avoids the 'clobbered by longjmp' warning.
	2403	*/
	2404	sh_dummy_type = (void*) &type;
	2405
[1]	2406	if (statvfs (relpath, &fss) == -1)
	2407	{
	2408	/* Don't die if a file was just removed. */
	2409	if (errno != ENOENT)
	2410	{
[253]	2411	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2412	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
	2413	_("statvfs() failed"),
	2414	_("filesystem_type_uncached") );
[253]	2415	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2416	return NULL;
	2417	}
	2418	}
	2419	else
	2420	{
	2421	type = fss.f_basetype;
	2422
	2423	/* patch by Konstantin Khrooschev <nathoo@co.ru>
	2424	*/
[119]	2425	if( (fss.f_flag & ST_NOSUID) && (ShSuidchkNosuid == S_FALSE))
[1]	2426	type = _("nosuid");
	2427	}
	2428	(void) statp; /* fix compiler warning */
	2429	#endif
	2430
	2431	#ifdef FSTYPE_STATFS /* 4.4BSD. */
	2432	struct statfs fss;
	2433	char *p;
	2434	#if defined(MNT_VISFLAGMASK) && defined(HAVE_STRUCT_STATFS_F_FLAGS)
	2435	int flags;
	2436	#endif
	2437	/* char * sh_dirname(const char path); /
	2438
	2439	if (path == NULL \|\| relpath == NULL)
	2440	return NULL;
	2441
[253]	2442	/* Take the address to keep gcc from putting it into a register.
	2443	* Avoids the 'clobbered by longjmp' warning.
	2444	*/
	2445	sh_dummy_type = (void*) &type;
	2446
[1]	2447	if (S_ISLNK (statp->st_mode))
	2448	p = sh_dirname (relpath);
	2449	else
	2450	p = relpath;
	2451
	2452	if (statfs (p, &fss) == -1)
	2453	{
	2454	/* Don't die if symlink to nonexisting file, or a file that was
	2455	just removed. */
	2456	if (errno != ENOENT)
	2457	{
[253]	2458	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2459	sh_error_handle ((-1), FIL__, __LINE__, errno, MSG_E_SUBGEN,
	2460	_("statfs() failed"),
	2461	_("filesystem_type_uncached") );
[253]	2462	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2463	return NULL;
	2464	}
	2465	}
	2466	else
	2467	{
	2468
	2469	#ifdef MFSNAMELEN /* NetBSD. */
	2470	/* MEMORY LEAK !!!
	2471	* type = sh_util_strdup (fss.f_fstypename);
	2472	*/
	2473	sl_strlcpy (my_tmp_type, fss.f_fstypename, 64);
	2474	type = my_tmp_type;
	2475	#else
	2476	type = fstype_to_string (fss.f_type);
	2477	#endif
	2478
	2479	#ifdef HAVE_STRUCT_STATFS_F_FLAGS
	2480	#ifdef MNT_VISFLAGMASK
	2481	flags = fss.f_flags & MNT_VISFLAGMASK;
[119]	2482	if ((flags & MNT_NOSUID) && (ShSuidchkNosuid == S_FALSE))
[1]	2483	#else
[119]	2484	if ((fss.f_flags & MNT_NOSUID) && (ShSuidchkNosuid == S_FALSE))
[1]	2485	#endif
	2486	type = _("nosuid");
	2487	#endif
	2488	}
	2489	if (p != relpath)
	2490	SH_FREE (p);
	2491	#endif
	2492
	2493	#ifdef AFS
	2494	if ((!type \|\| !strcmp (type, "xx")) && in_afs (relpath))
	2495	type = "afs";
	2496	#endif
	2497
	2498	/* An unknown value can be caused by an ENOENT error condition.
	2499	Don't cache those values. */
	2500	fstype_known = (int)(type != NULL);
	2501
	2502	return sh_util_strdup (type ? type : "unknown");
	2503	}
	2504
	2505	#ifdef FSTYPE_MNTENT /* 4.3BSD etc. */
	2506	/* Return the value of the hexadecimal number represented by CP.
	2507	No prefix (like '0x') or suffix (like 'h') is expected to be
	2508	part of CP. */
	2509
	2510	static int
	2511	xatoi (cp)
[199]	2512	const char *cp;
[1]	2513	{
	2514	int val;
	2515
	2516	val = 0;
	2517	while (*cp != '\0')
	2518	{
	2519	/@+charint@/
	2520	if (cp >= 'a' && cp <= 'f')
	2521	val = val * 16 + *cp - 'a' + 10;
	2522	else if (cp >= 'A' && cp <= 'F')
	2523	val = val * 16 + *cp - 'A' + 10;
	2524	else if (cp >= '0' && cp <= '9')
	2525	val = val * 16 + *cp - '0';
	2526	else
	2527	break;
	2528	/@-charint@/
	2529	cp++;
	2530	}
	2531	return val;
	2532	}
	2533	#endif
	2534
	2535
	2536
	2537	#endif
	2538
	2539
	2540	/* #ifdef SH_USE_UTMP */
	2541	#endif
	2542
	2543
	2544

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

Download in other formats: