Context Navigation

source: trunk/src/sh_suidchk.c@ 165

Last change on this file since 165 was 165, checked in by katerina, 17 years ago
Fix for ticket #92 (compile failure).
File size: 51.6 KB

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

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

Download in other formats: