Context Navigation

source: trunk/src/sh_suidchk.c@ 371

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

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

Download in other formats: