Context Navigation

source: trunk/src/sh_suidchk.c@ 494

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

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

Download in other formats: