Context Navigation

source: trunk/src/sh_files.c@ 134

Last change on this file since 134 was 132, checked in by rainer, 17 years ago
Make utility functions thread-safe.
File size: 54.5 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 1999 Rainer Wichmann */
	3	/* */
	4	/* This program is free software; you can redistribute it */
	5	/* and/or modify */
	6	/* it under the terms of the GNU General Public License as */
	7	/* published by */
	8	/* the Free Software Foundation; either version 2 of the License, or */
	9	/* (at your option) any later version. */
	10	/* */
	11	/* This program is distributed in the hope that it will be useful, */
	12	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
	13	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
	14	/* GNU General Public License for more details. */
	15	/* */
	16	/* You should have received a copy of the GNU General Public License */
	17	/* along with this program; if not, write to the Free Software */
	18	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "config_xor.h"
	21
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <limits.h>
	26
	27	#include <errno.h>
	28
	29	/* Must be before <utime.h> on FreeBSD
	30	*/
	31	#include <sys/types.h>
	32	#include <unistd.h>
	33
	34	#include <utime.h>
	35
	36
	37	#ifdef HAVE_DIRENT_H
	38	#include <dirent.h>
	39	#define NAMLEN(dirent) sl_strlen((dirent)->d_name)
	40	#else
	41	#define dirent direct
	42	#define NAMLEN(dirent) (dirent)->d_namlen
	43	#ifdef HAVE_SYS_NDIR_H
	44	#include <sys/ndir.h>
	45	#endif
	46	#ifdef HAVE_SYS_DIR_H
	47	#include <sys/dir.h>
	48	#endif
	49	#ifdef HAVE_NDIR_H
	50	#include <ndir.h>
	51	#endif
	52	#endif
	53
	54	#ifdef HAVE_GLOB_H
	55	#include <glob.h>
	56	#endif
	57
	58	#include "samhain.h"
	59
	60	#if (defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE))
	61
[131]	62	#include "sh_pthread.h"
[1]	63	#include "sh_error.h"
	64	#include "sh_utils.h"
	65	#include "sh_unix.h"
	66	#include "sh_files.h"
	67	#include "sh_tiger.h"
	68	#include "sh_hash.h"
	69	#include "sh_ignore.h"
	70	#include "zAVLTree.h"
	71
	72	#undef FIL__
	73	#define FIL__ _("sh_files.c")
	74
	75	extern int flag_err_debug;
	76	extern int flag_err_info;
	77
[22]	78	int sh_files_reportonce(const char * c)
[1]	79	{
	80	int i;
	81	SL_ENTER(_("sh_files_reportonce"));
	82	i = sh_util_flagval(c, &(sh.flag.reportonce));
	83
	84	SL_RETURN(i, _("sh_files_reportonce"));
	85	}
	86
[22]	87	int sh_files_fulldetail(const char * c)
[1]	88	{
	89	int i;
	90	SL_ENTER(_("sh_files_fulldetail"));
	91	i = sh_util_flagval(c, &(sh.flag.fulldetail));
	92
	93	SL_RETURN((i), _("sh_files_fulldetail"));
	94	}
	95
	96
	97	typedef struct dir_struct {
	98	long NumRegular;
	99	long NumDirs;
	100	long NumSymlinks;
	101	long NumFifos;
	102	long NumSockets;
	103	long NumCDev;
	104	long NumBDev;
[40]	105	long NumDoor;
	106	long NumPort;
[1]	107	long NumAll;
	108	long TotalBytes;
	109	char DirPath[PATH_MAX];
	110	} dir_type;
	111
	112	typedef struct dirstack_entry {
	113	char * name;
	114	int class;
	115	unsigned long check_mask;
	116	int rdepth;
	117	short checked;
	118	short childs_checked;
[114]	119	short is_reported;
[1]	120	/* struct dirstack_entry * next; */
	121	} dirstack_t;
	122
	123
	124	/* the destructor
	125	*/
	126	void free_dirstack (void * inptr)
	127	{
	128	dirstack_t * here;
	129
	130	SL_ENTER(_("free_dirstack"));
	131	if (inptr == NULL)
	132	SL_RET0(_("free_dirstack"));
	133	else
	134	here = (dirstack_t *) inptr;
	135
	136	if (here->name != NULL)
	137	SH_FREE(here->name);
	138	SH_FREE(here);
	139	SL_RET0(_("free_dirstack"));
	140	}
	141
	142	/* Function to return the key for indexing
	143	* the argument
	144	*/
	145	zAVLKey zdirstack_key (void const * arg)
	146	{
	147	const dirstack_t * sa = (const dirstack_t *) arg;
	148	return (zAVLKey) sa->name;
	149	}
	150
	151
	152	static zAVLTree * zdirListOne = NULL;
	153	static zAVLTree * zdirListTwo = NULL;
	154	static zAVLTree * zfileList = NULL;
	155
	156
	157	static int sh_files_fullpath (char * testdir, char * d_name,
	158	char * statpath);
[22]	159	static int sh_files_pushdir (int class, const char * str_s);
	160	static int sh_files_pushfile (int class, const char * str_s);
[1]	161	static int sh_files_checkdir (int class, int rdepth, char * dirName,
	162	char * relativeName);
	163	static ShFileType sh_files_filecheck (int class, char * dirName,
	164	char * fileName, int * reported,
	165	int rsrcflag);
	166
	167	static long MaxRecursionLevel = 0;
	168
	169	/* set default recursion level
	170	*/
[20]	171	int sh_files_setrecursion (const char * flag_s)
[1]	172	{
	173	long flag = 0;
	174	static int reject = 0;
	175
	176	SL_ENTER( _("sh_files_setrecursion"));
	177
	178	if (reject == 1)
	179	SL_RETURN((-1), _("sh_files_setrecursion"));
	180
	181	if (sh.flag.opts == 1)
	182	reject = 1;
	183
	184	if (flag_s != NULL)
	185	flag = (int)(atof(flag_s));
	186
	187	if (flag >= 0 && flag <= 99)
	188	MaxRecursionLevel = flag;
	189	else
	190	SL_RETURN((-1), _("sh_files_setrecursion"));
	191
	192	SL_RETURN((0), _("sh_files_setrecursion"));
	193	}
	194
	195	unsigned long sh_files_chk ()
	196	{
	197	zAVLCursor cursor;
	198	ShFileType status;
	199	unsigned long fcount = 0;
	200
	201	char * tmp = NULL;
	202
	203	dirstack_t * ptr;
[34]	204	char * dir;
[1]	205	char * file;
[46]	206	int tmp_reported;
[1]	207
	208	SL_ENTER(_("sh_files_chk"));
	209
	210	for (ptr = (dirstack_t *) zAVLFirst(&cursor, zfileList); ptr;
	211	ptr = (dirstack_t *) zAVLNext(&cursor))
	212	{
	213
	214	if (sig_urgent > 0) {
	215	SL_RETURN(fcount, _("sh_files_chk"));
	216	}
	217
	218	if (ptr->checked == S_FALSE)
	219	{
[34]	220	dir = sh_util_dirname (ptr->name);
	221	file = sh_util_basename (ptr->name);
[1]	222	#if defined(WITH_TPT)
	223	tmp = sh_util_safe_name (ptr->name);
	224	#endif
	225
	226
	227	if (flag_err_info == SL_TRUE)
	228	{
	229	#if !defined(WITH_TPT)
	230	tmp = sh_util_safe_name (ptr->name);
	231	#endif
[8]	232	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CHK, tmp);
[1]	233	}
	234
	235	BREAKEXIT(sh_files_filecheck);
[114]	236	tmp_reported = ptr->is_reported; /* fix aliasing warning */
[34]	237	status = sh_files_filecheck (ptr->class, dir, file,
[46]	238	&tmp_reported, 0);
[114]	239	ptr->is_reported = tmp_reported;
[1]	240
	241	TPT(( 0, FIL__, __LINE__,
	242	_("msg=<filecheck complete: %s> status=<%d> reported=<%d>\n"),
[114]	243	tmp, status, ptr->is_reported));
[1]	244
[114]	245	if (status == SH_FILE_UNKNOWN && (!SH_FFLAG_REPORTED_SET(ptr->is_reported)))
[1]	246	{
	247	TPT(( 0, FIL__, __LINE__, _("msg=<file: %s> status=<%d>\n"),
	248	tmp, status));
	249
	250	if ( sh.flag.checkSum == SH_CHECK_INIT \|\|
	251	sh_hash_have_it (ptr->name) >= 0)
	252	{
	253	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	254	{
	255	if (0 != hashreport_missing(ptr->name,
	256	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	257	ShDFLevel[ptr->class] :
	258	ShDFLevel[SH_ERR_T_FILE])) {
	259	if (tmp == NULL)
	260	tmp = sh_util_safe_name (ptr->name);
	261	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	262	ShDFLevel[ptr->class] :
	263	ShDFLevel[SH_ERR_T_FILE],
	264	FIL__, __LINE__, 0, MSG_FI_MISS,
	265	tmp);
	266	}
	267	}
	268	}
	269	else /* not there at init, and still missing */
	270	{
	271	if (tmp == NULL)
	272	tmp = sh_util_safe_name (ptr->name);
	273	sh_error_handle (SH_ERR_NOTICE,
	274	FIL__, __LINE__, 0,
	275	MSG_FI_FAIL,
	276	tmp);
	277	}
	278	#ifndef REPLACE_OLD
	279	/* this will tell that we have seen the file, and thus prevent
	280	* deletion from the database, resulting in an incomplete
	281	* message when the file reappears
	282	*/
	283	if (sh.flag.checkSum != SH_CHECK_INIT)
	284	sh_hash_set_visited_true(ptr->name);
	285	#else
	286	if (sh.flag.checkSum != SH_CHECK_INIT)
	287	sh_hash_set_missing(ptr->name);
	288	#endif
	289	if (sh.flag.reportonce == S_TRUE)
[114]	290	SET_SH_FFLAG_REPORTED(ptr->is_reported);
[1]	291	}
	292	else
	293	{
	294	/* exists (status >= 0), but was missing (reported == TRUE)
	295	*/
[114]	296	if (status != SH_FILE_UNKNOWN && SH_FFLAG_REPORTED_SET(ptr->is_reported))
[1]	297	{
[114]	298	CLEAR_SH_FFLAG_REPORTED(ptr->is_reported);
[1]	299	}
	300	/* Catchall
	301	*/
	302	else if (status == SH_FILE_UNKNOWN)
	303	{
	304	/* Thu Mar 7 15:09:40 CET 2002 Make sure missing file
	305	* is reported if ptr->reported == S_TRUE because the
	306	* file has been added.
	307	*/
	308	if (sh_hash_have_it (ptr->name) >= 0)
	309	{
	310	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	311	{
	312	if (0 != hashreport_missing(ptr->name,
	313	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	314	ShDFLevel[ptr->class] :
	315	ShDFLevel[SH_ERR_T_FILE])) {
	316	if (tmp == NULL)
	317	tmp = sh_util_safe_name (ptr->name);
	318	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE)?
	319	ShDFLevel[ptr->class] :
	320	ShDFLevel[SH_ERR_T_FILE],
	321	FIL__, __LINE__, 0, MSG_FI_MISS,
	322	tmp);
	323	}
	324	}
	325	#ifndef REPLACE_OLD
	326	if (sh.flag.checkSum != SH_CHECK_INIT)
	327	sh_hash_set_visited_true(ptr->name);
	328	#else
	329	/* delete from database
	330	*/
	331	if (sh.flag.checkSum != SH_CHECK_INIT)
	332	sh_hash_set_missing(ptr->name);
	333	#endif
	334	}
	335	else
	336	{
	337	if (tmp == NULL)
	338	tmp = sh_util_safe_name (ptr->name);
	339	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, 0,
	340	MSG_FI_FAIL,
	341	tmp);
	342	if (sh.flag.checkSum != SH_CHECK_INIT)
	343	sh_hash_set_visited_true(ptr->name);
	344	}
	345	}
	346	++fcount;
	347	}
	348
	349	if (tmp != NULL)
	350	{
	351	SH_FREE(tmp);
	352	tmp = NULL;
	353	}
[94]	354	if (file)
	355	SH_FREE(file);
	356	if (dir)
	357	SH_FREE(dir);
[1]	358
	359	ptr->checked = S_TRUE;
	360	}
	361	}
	362
	363	SL_RETURN(fcount, _("sh_files_chk"));
	364	}
	365
	366	int sh_files_delfilestack ()
	367	{
	368	SL_ENTER(_("sh_files_delfilestack"));
	369
	370	zAVLFreeTree (zfileList, free_dirstack);
	371	zfileList = NULL;
	372
	373	SL_RETURN(0, _("sh_files_delfilestack"));
	374	}
	375
	376	int sh_files_setrec_int (zAVLTree * tree)
	377	{
	378	dirstack_t * ptr;
	379	zAVLCursor avlcursor;
	380
	381	SL_ENTER(_("sh_files_setrec"));
	382	if (tree != NULL) {
	383	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, tree); ptr;
	384	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	385	{
	386	if (ptr->rdepth < (-1) \|\| ptr->rdepth > 99)
	387	{
	388	ptr->rdepth = MaxRecursionLevel;
	389	}
	390	if (ptr->rdepth == (-1) && sh.flag.checkSum != SH_CHECK_INIT)
	391	hash_remove_tree (ptr->name);
	392	}
	393	}
	394	SL_RETURN(0, _("sh_files_setrec"));
	395	}
	396
	397	int sh_files_setrec ()
	398	{
	399	sh_files_setrec_int(zdirListOne);
	400	return sh_files_setrec_int(zdirListTwo);
	401	}
	402
	403	zAVLTree * sh_files_deldirstack_int (zAVLTree * ptr)
	404	{
	405	SL_ENTER(_("sh_files_deldirstack"));
	406
	407	zAVLFreeTree (ptr, free_dirstack);
	408
	409	SL_RETURN(NULL, _("sh_files_deldirstack"));
	410	}
	411
	412	int sh_files_deldirstack ()
	413	{
	414	zdirListOne = sh_files_deldirstack_int(zdirListOne);
	415	zdirListTwo = sh_files_deldirstack_int(zdirListTwo);
	416	return 0;
	417	}
	418
	419	void sh_files_reset()
	420	{
	421	dirstack_t * ptr;
	422	zAVLCursor avlcursor;
	423
	424	SL_ENTER(_("sh_files_reset"));
	425
	426	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, zfileList); ptr;
	427	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	428	ptr->checked = 0;
	429
	430	SL_RET0(_("sh_files_reset"));
	431	}
	432
	433	void sh_dirs_reset()
	434	{
	435	dirstack_t * ptr;
	436	zAVLCursor avlcursor1;
	437	zAVLCursor avlcursor2;
	438
	439	SL_ENTER(_("sh_dirs_reset"));
	440
	441	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor1, zdirListOne); ptr;
	442	ptr = (dirstack_t *) zAVLNext(&avlcursor1))
	443	ptr->checked = 0;
	444
	445	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor2, zdirListTwo); ptr;
	446	ptr = (dirstack_t *) zAVLNext(&avlcursor2))
	447	ptr->checked = 0;
	448
	449	SL_RET0(_("sh_dirs_reset"));
	450	}
	451
	452
[22]	453	int sh_files_pushfile_prelink (const char * str_s)
[1]	454	{
	455	return (sh_files_pushfile (SH_LEVEL_PRELINK, str_s));
	456	}
	457
[22]	458	int sh_files_pushfile_user0 (const char * str_s)
[1]	459	{
	460	return (sh_files_pushfile (SH_LEVEL_USER0, str_s));
	461	}
	462
[22]	463	int sh_files_pushfile_user1 (const char * str_s)
[1]	464	{
	465	return (sh_files_pushfile (SH_LEVEL_USER1, str_s));
	466	}
	467
[27]	468	int sh_files_pushfile_user2 (const char * str_s)
	469	{
	470	return (sh_files_pushfile (SH_LEVEL_USER2, str_s));
	471	}
[1]	472
[27]	473	int sh_files_pushfile_user3 (const char * str_s)
	474	{
	475	return (sh_files_pushfile (SH_LEVEL_USER3, str_s));
	476	}
	477
	478	int sh_files_pushfile_user4 (const char * str_s)
	479	{
	480	return (sh_files_pushfile (SH_LEVEL_USER4, str_s));
	481	}
	482
	483
[22]	484	int sh_files_pushfile_ro (const char * str_s)
[1]	485	{
	486	return (sh_files_pushfile (SH_LEVEL_READONLY, str_s));
	487	}
	488
[22]	489	int sh_files_pushfile_attr (const char * str_s)
[1]	490	{
	491	return (sh_files_pushfile (SH_LEVEL_ATTRIBUTES, str_s));
	492	}
	493
[22]	494	int sh_files_pushfile_log (const char * str_s)
[1]	495	{
	496	return (sh_files_pushfile (SH_LEVEL_LOGFILES, str_s));
	497	}
	498
[22]	499	int sh_files_pushfile_glog (const char * str_s)
[1]	500	{
	501	return (sh_files_pushfile (SH_LEVEL_LOGGROW, str_s));
	502	}
	503
[22]	504	int sh_files_pushfile_noig (const char * str_s)
[1]	505	{
	506	return (sh_files_pushfile (SH_LEVEL_NOIGNORE, str_s));
	507	}
	508
[22]	509	int sh_files_pushfile_allig (const char * str_s)
[1]	510	{
	511	return (sh_files_pushfile (SH_LEVEL_ALLIGNORE, str_s));
	512	}
	513
	514
	515	static void sh_files_set_mask (unsigned long * mask,
	516	unsigned long val, int act)
	517	{
	518	SL_ENTER(_("sh_files_set_mask"));
	519
	520	if (act == 0)
	521	(*mask) = val;
	522	else if (act > 0)
	523	(*mask) \|= val;
	524	else
	525	(*mask) &= ~val;
	526
	527	SL_RET0(_("sh_files_set_mask"));
	528	}
	529
	530	/* set mask(class)
	531	*/
[22]	532	static int sh_files_parse_mask (unsigned long * mask, const char * str)
[1]	533	{
	534	int l, i = 0, act = 0, k = 0;
	535	char myword[64];
	536
	537	SL_ENTER(_("sh_files_parse_mask"));
	538
	539	if (str == NULL)
	540	{
	541	SL_RETURN ( (-1), _("sh_files_parse_mask"));
	542	}
	543	else
	544	l = sl_strlen(str);
	545
	546	while (i < l) {
	547	if (str[i] == '\0')
	548	break;
	549	if (str[i] == ' ' \|\| str[i] == '\t' \|\| str[i] == ',')
	550	{
	551	++i;
	552	continue;
	553	}
	554
	555	if (str[i] == '+')
	556	{
	557	act = +1; ++i;
	558	continue;
	559	}
	560	else if (str[i] == '-')
	561	{
	562	act = -1; ++i;
	563	continue;
	564	}
	565	else /* a word */
	566	{
	567	k = 0;
	568	while (k < 63 && str[i] != ' ' && str[i] != '\t' && str[i] != ','
	569	&& str[i] != '+' && str[i] != '-' && str[i] != '\0') {
	570	myword[k] = str[i];
	571	++i; ++k;
	572	}
	573	myword[k] = '\0';
	574
	575	/* checksum */
	576	if (0 == strncmp(myword, _("CHK"), 3))
	577	sh_files_set_mask (mask, MODI_CHK, act);
	578	/* link */
	579	if (0 == strncmp(myword, _("LNK"), 3))
	580	sh_files_set_mask (mask, MODI_LNK, act);
	581	/* inode */
	582	if (0 == strncmp(myword, _("RDEV"), 3))
	583	sh_files_set_mask (mask, MODI_RDEV, act);
	584	/* inode */
	585	if (0 == strncmp(myword, _("INO"), 3))
	586	sh_files_set_mask (mask, MODI_INO, act);
	587	/* user */
	588	if (0 == strncmp(myword, _("USR"), 3))
	589	sh_files_set_mask (mask, MODI_USR, act);
	590	/* group */
	591	if (0 == strncmp(myword, _("GRP"), 3))
	592	sh_files_set_mask (mask, MODI_GRP, act);
	593	/* mtime */
	594	if (0 == strncmp(myword, _("MTM"), 3))
	595	sh_files_set_mask (mask, MODI_MTM, act);
	596	/* ctime */
	597	if (0 == strncmp(myword, _("CTM"), 3))
	598	sh_files_set_mask (mask, MODI_CTM, act);
	599	/* atime */
	600	if (0 == strncmp(myword, _("ATM"), 3))
	601	sh_files_set_mask (mask, MODI_ATM, act);
	602	/* size */
	603	if (0 == strncmp(myword, _("SIZ"), 3))
	604	sh_files_set_mask (mask, MODI_SIZ, act);
	605	/* file mode */
	606	if (0 == strncmp(myword, _("MOD"), 3))
	607	sh_files_set_mask (mask, MODI_MOD, act);
	608	/* hardlinks */
	609	if (0 == strncmp(myword, _("HLN"), 3))
	610	sh_files_set_mask (mask, MODI_HLN, act);
[19]	611	/* size may grow */
	612	if (0 == strncmp(myword, _("GROW"), 3))
	613	sh_files_set_mask (mask, MODI_SGROW, act);
	614	/* use prelink */
	615	if (0 == strncmp(myword, _("PRE"), 3))
	616	sh_files_set_mask (mask, MODI_PREL, act);
[1]	617
	618	}
	619	}
	620	SL_RETURN ( (0), _("sh_files_parse_mask"));
	621	}
	622
[22]	623	int sh_files_redef_prelink(const char * str)
[1]	624	{
	625	return (sh_files_parse_mask(&mask_PRELINK, str));
	626	}
[22]	627	int sh_files_redef_user0(const char * str)
[1]	628	{
	629	return (sh_files_parse_mask(&mask_USER0, str));
	630	}
[22]	631	int sh_files_redef_user1(const char * str)
[1]	632	{
	633	return (sh_files_parse_mask(&mask_USER1, str));
	634	}
[27]	635	int sh_files_redef_user2(const char * str)
	636	{
	637	return (sh_files_parse_mask(&mask_USER2, str));
	638	}
	639	int sh_files_redef_user3(const char * str)
	640	{
	641	return (sh_files_parse_mask(&mask_USER3, str));
	642	}
	643	int sh_files_redef_user4(const char * str)
	644	{
	645	return (sh_files_parse_mask(&mask_USER4, str));
	646	}
[22]	647	int sh_files_redef_readonly(const char * str)
[1]	648	{
	649	return (sh_files_parse_mask(&mask_READONLY, str));
	650	}
[22]	651	int sh_files_redef_loggrow(const char * str)
[1]	652	{
	653	return (sh_files_parse_mask(&mask_LOGGROW, str));
	654	}
[22]	655	int sh_files_redef_logfiles(const char * str)
[1]	656	{
	657	return (sh_files_parse_mask(&mask_LOGFILES, str));
	658	}
[22]	659	int sh_files_redef_attributes(const char * str)
[1]	660	{
	661	return (sh_files_parse_mask(&mask_ATTRIBUTES, str));
	662	}
[22]	663	int sh_files_redef_noignore(const char * str)
[1]	664	{
	665	return (sh_files_parse_mask(&mask_NOIGNORE, str));
	666	}
[22]	667	int sh_files_redef_allignore(const char * str)
[1]	668	{
	669	return (sh_files_parse_mask(&mask_ALLIGNORE, str));
	670	}
	671
	672	unsigned long sh_files_maskof (int class)
	673	{
	674	switch (class)
	675	{
	676	case SH_LEVEL_READONLY:
	677	return (unsigned long) mask_READONLY;
	678	case SH_LEVEL_ATTRIBUTES:
	679	return (unsigned long) mask_ATTRIBUTES;
	680	case SH_LEVEL_LOGFILES:
	681	return (unsigned long) mask_LOGFILES;
	682	case SH_LEVEL_LOGGROW:
	683	return (unsigned long) mask_LOGGROW;
	684	case SH_LEVEL_ALLIGNORE:
	685	return (unsigned long) mask_ALLIGNORE;
	686	case SH_LEVEL_NOIGNORE:
	687	return (unsigned long) mask_NOIGNORE;
	688	case SH_LEVEL_USER0:
	689	return (unsigned long) mask_USER0;
	690	case SH_LEVEL_USER1:
	691	return (unsigned long) mask_USER1;
[27]	692	case SH_LEVEL_USER2:
	693	return (unsigned long) mask_USER2;
	694	case SH_LEVEL_USER3:
	695	return (unsigned long) mask_USER3;
	696	case SH_LEVEL_USER4:
	697	return (unsigned long) mask_USER4;
[1]	698	case SH_LEVEL_PRELINK:
	699	return (unsigned long) mask_PRELINK;
	700	default:
	701	return (unsigned long) 0;
	702	}
	703	}
	704
	705	#ifdef HAVE_GLOB_H
	706	int sh_files_has_metachar (const char * str)
	707	{
	708	SL_ENTER(_("sh_files_has_metachar"));
	709	if (NULL != strchr(str, '*'))
	710	SL_RETURN(1, _("sh_files_has_metachar"));
	711	else if (NULL != strchr(str, '?'))
	712	SL_RETURN(1, _("sh_files_has_metachar"));
	713	else if (NULL != (strchr(str, '[')))
	714	SL_RETURN(1, _("sh_files_has_metachar"));
	715	else
	716	SL_RETURN(0, _("sh_files_has_metachar"));
	717	}
	718
	719
	720	int sh_files_globerr (const char * epath, int errnum)
	721	{
	722	char * p;
[132]	723	char errbuf[SH_ERRBUF_SIZE];
[1]	724
	725	SL_ENTER(_("sh_files_globerr"));
	726
[61]	727	if (errnum == ENOTDIR \|\| errnum == ENOENT)
	728	{
	729	SL_RETURN(0, _("sh_files_globerr"));
	730	}
	731
[1]	732	p = sh_util_safe_name (epath);
	733	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, errnum, MSG_FI_GLOB,
[132]	734	sh_error_message (errnum, errbuf, sizeof(errbuf)), p);
[1]	735	SH_FREE(p);
	736
	737	SL_RETURN(0, _("sh_files_globerr"));
	738	}
	739
	740	/* #ifdef HAVE_GLOB_H
	741	*/
	742	#endif
	743
[34]	744	int sh_files_push_file_int (int class, const char * str_s, size_t len)
[1]	745	{
	746	dirstack_t * new_item_ptr;
	747	char * fileName;
	748	int ret;
	749
	750	SL_ENTER(_("sh_files_push_file_int"));
	751
	752	fileName = SH_ALLOC(len+1);
	753	sl_strlcpy(fileName, str_s, len+1);
	754
	755	new_item_ptr = (dirstack_t *) SH_ALLOC (sizeof(dirstack_t));
	756
	757	new_item_ptr->name = fileName;
	758	new_item_ptr->class = class;
	759	new_item_ptr->check_mask = sh_files_maskof(class);
	760	new_item_ptr->rdepth = 0;
	761	new_item_ptr->checked = S_FALSE;
[114]	762	new_item_ptr->is_reported = 0;
[1]	763	new_item_ptr->childs_checked = S_FALSE;
	764
	765	if (zfileList == NULL)
	766	{
	767	zfileList = zAVLAllocTree (zdirstack_key);
	768	if (zfileList == NULL)
	769	{
[22]	770	(void) safe_logger (0, 0, NULL);
[1]	771	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	772	}
	773	}
	774
	775	ret = zAVLInsert (zfileList, new_item_ptr);
	776
	777	if (-1 == ret)
	778	{
[22]	779	(void) safe_logger (0, 0, NULL);
[1]	780	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	781	}
	782	if (3 == ret)
	783	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	784	fileName);
	785
	786	SL_RETURN(0, _("sh_files_push_file_int"));
	787	}
	788
	789
[22]	790	static int sh_files_pushfile (int class, const char * str_s)
[1]	791	{
[34]	792	size_t len;
[1]	793	char * tmp;
[22]	794	char * p;
[1]	795	#ifdef HAVE_GLOB_H
	796	int globstatus = -1;
	797	unsigned int gloop;
[22]	798	glob_t pglob;
[1]	799	#endif
	800
	801	static int reject = 0;
	802
	803	SL_ENTER(_("sh_files_pushfile"));
	804
	805	if (reject == 1)
	806	SL_RETURN((-1),_("sh_files_pushfile"));
	807
	808	/* if we push a filename from the command line, make sure it
	809	* is the only one -- and will stay the only one
	810	*/
	811	if (sh.flag.opts == 1)
	812	{
	813	sh_files_delfilestack ();
	814	sh_files_deldirstack ();
	815	reject = 1;
	816	}
	817
	818	if (str_s == NULL)
	819	SL_RETURN((-1),_("sh_files_pushfile"));
	820
	821	len = sl_strlen(str_s);
	822
	823	if (len >= PATH_MAX)
	824	{
	825	/* Name too long
	826	*/
	827	tmp = sh_util_safe_name (str_s);
	828	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_2LONG,
	829	tmp);
	830	SH_FREE(tmp);
	831	SL_RETURN((-1),_("sh_files_pushfile"));
	832	}
	833	else if (len < 1)
	834	{
	835	/* Should not happen (str_s == NULL caught further above)
	836	*/
	837	SL_RETURN((-1),_("sh_files_pushfile"));
	838	}
	839	else if (str_s[0] != '/')
	840	{
	841	/* Not an absolute path
	842	*/
	843	tmp = sh_util_safe_name (str_s);
	844	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NOPATH,
	845	tmp);
	846	SH_FREE(tmp);
	847	SL_RETURN((-1),_("sh_files_pushfile"));
	848	}
	849	else
	850	{
	851	/* remove a terminating '/', take care of the
	852	* special case of the root directory.
	853	*/
[22]	854	p = sh_util_strdup (str_s);
	855	if (p[len-1] == '/' && len > 1)
[1]	856	{
[22]	857	p[len-1] = '\0';
[1]	858	--len;
	859	}
	860
	861	}
	862
	863	#ifdef HAVE_GLOB_H
[22]	864	if (0 == sh_files_has_metachar(p))
[1]	865	{
[22]	866	sh_files_push_file_int (class, p, len);
[1]	867	}
	868	else
	869	{
	870	pglob.gl_offs = 0;
[22]	871	globstatus = glob (p, 0, sh_files_globerr, &pglob);
[1]	872
	873	if (globstatus == 0 && pglob.gl_pathc > 0)
	874	{
	875	for (gloop = 0; gloop < (unsigned int) pglob.gl_pathc; ++gloop)
	876	sh_files_push_file_int (class, pglob.gl_pathv[gloop],
	877	sl_strlen(pglob.gl_pathv[gloop]));
	878	}
	879	else
	880	{
[22]	881	tmp = sh_util_safe_name (p);
[1]	882
	883	if (pglob.gl_pathc == 0
	884	#ifdef GLOB_NOMATCH
	885	\|\| globstatus == GLOB_NOMATCH
	886	#endif
	887	)
	888	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	889	globstatus, MSG_FI_GLOB,
	890	_("No matches found"), tmp);
	891	#ifdef GLOB_NOSPACE
	892	else if (globstatus == GLOB_NOSPACE)
	893	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	894	globstatus, MSG_FI_GLOB,
	895	_("Out of memory"), tmp);
	896	#endif
	897	#ifdef GLOB_ABORTED
	898	else if (globstatus == GLOB_ABORTED)
	899	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	900	globstatus, MSG_FI_GLOB,
	901	_("Read error"), tmp);
	902	#endif
	903	else
	904	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	905	globstatus, MSG_FI_GLOB,
	906	_("Unknown error"), tmp);
	907
	908	SH_FREE(tmp);
	909
	910	}
	911
	912	globfree(&pglob);
	913	}
	914
	915	#else
[22]	916	sh_files_push_file_int (class, p, len);
[1]	917	#endif
	918
[22]	919	SH_FREE(p);
[1]	920	SL_RETURN((0),_("sh_files_pushfile"));
	921	}
	922
	923
	924	/* ------ directories ----- */
	925
	926	int sh_files_is_allignore_int (char * str, zAVLTree * tree)
	927	{
	928	dirstack_t * ptr;
	929
	930	SL_ENTER(_("sh_files_is_allignore"));
	931
	932	if (tree)
	933	{
	934	ptr = zAVLSearch(tree, str);
	935	if (ptr)
	936	{
	937	if (ptr->class == SH_LEVEL_ALLIGNORE)
	938	SL_RETURN( 1, _("sh_files_is_allignore"));
	939	else
	940	SL_RETURN( 0, _("sh_files_is_allignore"));
	941	}
	942	}
	943	SL_RETURN( 0, _("sh_files_is_allignore"));
	944	}
	945
	946	int sh_files_is_allignore (char * str)
	947	{
	948	if (1 == sh_files_is_allignore_int(str, zdirListOne))
	949	return 1;
	950	if (NULL == zdirListTwo)
	951	return 0;
	952	return sh_files_is_allignore_int(str, zdirListTwo);
	953	}
	954
	955	unsigned long sh_dirs_chk (int which)
	956	{
	957	zAVLTree * tree;
	958	zAVLCursor cursor;
	959	dirstack_t * ptr;
	960	dirstack_t * dst_ptr;
	961	int status;
	962	unsigned long dcount = 0;
	963	char * tmp;
	964
	965	SL_ENTER(_("sh_dirs_chk"));
	966
	967	if (which == 1)
	968	tree = zdirListOne;
	969	else
	970	tree = zdirListTwo;
	971
	972	for (ptr = (dirstack_t *) zAVLFirst(&cursor, tree); ptr;
	973	ptr = (dirstack_t *) zAVLNext(&cursor))
	974	{
	975	if (sig_urgent > 0) {
	976	SL_RETURN(dcount, _("sh_dirs_chk"));
	977	}
	978
	979	if (ptr->checked == S_FALSE)
	980	{
	981	/* 28 Aug 2001 check the top level directory
	982	*/
	983	status = S_FALSE;
	984	dst_ptr = zAVLSearch(zfileList, ptr->name);
	985	if (dst_ptr)
	986	{
	987	if (dst_ptr->checked == S_FALSE)
	988	{
	989	BREAKEXIT(sh_files_filecheck);
	990	sh_files_filecheck (dst_ptr->class, ptr->name,
	991	NULL, &status, 0);
	992	dst_ptr->checked = S_TRUE;
	993	status = S_TRUE;
	994	}
	995	else
	996	{
	997	status = S_TRUE;
	998	}
	999	}
	1000
	1001	if (status == S_FALSE)
	1002	sh_files_filecheck (ptr->class, ptr->name, NULL, &status, 0);
	1003
	1004	BREAKEXIT(sh_files_checkdir);
	1005	status = sh_files_checkdir (ptr->class, ptr->rdepth, ptr->name,
	1006	ptr->name);
	1007
[114]	1008	if (status < 0 && (!SH_FFLAG_REPORTED_SET(ptr->is_reported)))
[1]	1009	{
	1010	/* directory is missing
	1011	*/
	1012	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	1013	{
	1014	if (0 != hashreport_missing(ptr->name,
	1015	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	1016	ShDFLevel[ptr->class] :
	1017	ShDFLevel[SH_ERR_T_DIR])) {
	1018	tmp = sh_util_safe_name (ptr->name);
	1019	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	1020	ShDFLevel[ptr->class] :
	1021	ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__,
	1022	0, MSG_FI_MISS, tmp);
	1023	SH_FREE(tmp);
	1024	}
	1025	}
	1026	if (sh.flag.reportonce == S_TRUE)
[114]	1027	SET_SH_FFLAG_REPORTED(ptr->is_reported);
[1]	1028	}
	1029	else
	1030	{
	1031	/* exists (status >= 0), but was missing (reported == TRUE)
	1032	*/
[114]	1033	if (status >= 0 && SH_FFLAG_REPORTED_SET(ptr->is_reported))
[1]	1034	{
[114]	1035	CLEAR_SH_FFLAG_REPORTED(ptr->is_reported);
[1]	1036	#if 0
	1037	/* obsoleted (really?) by the mandatory sh_files_filecheck()
	1038	* above, which will catch missing directories anyway
	1039	*/
	1040	tmp = sh_util_safe_name (ptr->name);
	1041	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	1042	ShDFLevel[ptr->class] :
	1043	ShDFLevel[SH_ERR_T_DIR],
	1044	FIL__, __LINE__, 0, MSG_FI_ADD,
	1045	tmp);
	1046	SH_FREE(tmp);
	1047	#endif
	1048	}
	1049	else if (status == SH_FILE_UNKNOWN)
	1050	{
	1051	/* catchall
	1052	*/
	1053	tmp = sh_util_safe_name (ptr->name);
	1054	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, 0,
	1055	MSG_FI_FAIL,
	1056	tmp);
	1057	SH_FREE(tmp);
	1058	if (sh.flag.checkSum != SH_CHECK_INIT)
	1059	sh_hash_set_visited_true(ptr->name);
	1060	}
	1061
	1062	++dcount;
	1063	}
[19]	1064	ptr->checked = S_TRUE;
	1065	ptr->childs_checked = S_TRUE;
[1]	1066	}
	1067
	1068	if (sig_urgent > 0) {
	1069	SL_RETURN(dcount, _("sh_dirs_chk"));
	1070	}
	1071
	1072	}
	1073	SL_RETURN(dcount, _("sh_dirs_chk"));
	1074	}
	1075
[22]	1076	int sh_files_pushdir_prelink (const char * str_s)
[1]	1077	{
	1078	return (sh_files_pushdir (SH_LEVEL_PRELINK, str_s));
	1079	}
	1080
[22]	1081	int sh_files_pushdir_user0 (const char * str_s)
[1]	1082	{
	1083	return (sh_files_pushdir (SH_LEVEL_USER0, str_s));
	1084	}
	1085
[22]	1086	int sh_files_pushdir_user1 (const char * str_s)
[1]	1087	{
	1088	return (sh_files_pushdir (SH_LEVEL_USER1, str_s));
	1089	}
	1090
[27]	1091	int sh_files_pushdir_user2 (const char * str_s)
	1092	{
	1093	return (sh_files_pushdir (SH_LEVEL_USER2, str_s));
	1094	}
	1095
	1096	int sh_files_pushdir_user3 (const char * str_s)
	1097	{
	1098	return (sh_files_pushdir (SH_LEVEL_USER3, str_s));
	1099	}
	1100
	1101	int sh_files_pushdir_user4 (const char * str_s)
	1102	{
	1103	return (sh_files_pushdir (SH_LEVEL_USER4, str_s));
	1104	}
	1105
[22]	1106	int sh_files_pushdir_attr (const char * str_s)
[1]	1107	{
	1108	return (sh_files_pushdir (SH_LEVEL_ATTRIBUTES, str_s));
	1109	}
	1110
[22]	1111	int sh_files_pushdir_ro (const char * str_s)
[1]	1112	{
	1113	return (sh_files_pushdir (SH_LEVEL_READONLY, str_s));
	1114	}
	1115
[22]	1116	int sh_files_pushdir_log (const char * str_s)
[1]	1117	{
	1118	return (sh_files_pushdir (SH_LEVEL_LOGFILES, str_s));
	1119	}
	1120
[22]	1121	int sh_files_pushdir_glog (const char * str_s)
[1]	1122	{
	1123	return (sh_files_pushdir (SH_LEVEL_LOGGROW, str_s));
	1124	}
	1125
[22]	1126	int sh_files_pushdir_noig (const char * str_s)
[1]	1127	{
	1128	return (sh_files_pushdir (SH_LEVEL_NOIGNORE, str_s));
	1129	}
	1130
[22]	1131	int sh_files_pushdir_allig (const char * str_s)
[1]	1132	{
	1133	return (sh_files_pushdir (SH_LEVEL_ALLIGNORE, str_s));
	1134	}
	1135
	1136	static int which_dirList = 1;
	1137
	1138	int set_dirList (int which)
	1139	{
	1140	if (which == 2)
	1141	which_dirList = 2;
	1142	else
	1143	which_dirList = 1;
	1144	return 0;
	1145	}
	1146
[34]	1147	int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth)
[1]	1148	{
	1149	zAVLTree * tree;
	1150	dirstack_t * new_item_ptr;
	1151	char * dirName;
	1152	int ret;
	1153
	1154	SL_ENTER(_("sh_files_push_dir_int"));
	1155
	1156	dirName = SH_ALLOC(len+1);
	1157	sl_strlcpy(dirName, tail, len+1);
	1158
	1159	new_item_ptr = (dirstack_t * ) SH_ALLOC (sizeof(dirstack_t));
	1160
	1161	new_item_ptr->name = dirName;
	1162	new_item_ptr->class = class;
	1163	new_item_ptr->check_mask = sh_files_maskof(class);
	1164	new_item_ptr->rdepth = rdepth;
	1165	new_item_ptr->checked = S_FALSE;
[114]	1166	new_item_ptr->is_reported = 0;
[1]	1167	new_item_ptr->childs_checked = S_FALSE;
	1168
	1169	if (which_dirList == 1)
	1170	{
	1171	tree = zdirListOne;
	1172	}
	1173	else
	1174	{
	1175	tree = zdirListTwo;
	1176	}
	1177
	1178	if (tree == NULL)
	1179	{
	1180	tree = zAVLAllocTree (zdirstack_key);
	1181	if (tree == NULL)
	1182	{
[22]	1183	(void) safe_logger (0, 0, NULL);
[1]	1184	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1185	}
	1186	if (which_dirList == 1)
	1187	zdirListOne = tree;
	1188	else
	1189	zdirListTwo = tree;
	1190	}
	1191
	1192	ret = zAVLInsert (tree, new_item_ptr);
	1193
	1194	if (-1 == ret)
	1195	{
[22]	1196	(void) safe_logger (0, 0, NULL);
[1]	1197	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1198	}
	1199	if (3 == ret)
	1200	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	1201	dirName);
	1202
	1203	SL_RETURN(0, _("sh_files_push_dir_int"));
	1204	}
	1205
[22]	1206	static int sh_files_pushdir (int class, const char * str_s)
[1]	1207	{
	1208	char * tmp;
[34]	1209	size_t len;
[1]	1210	int rdepth = 0;
	1211	char * tail = NULL;
[22]	1212	char * p;
[1]	1213
	1214	#ifdef HAVE_GLOB_H
	1215	glob_t pglob;
	1216	int globstatus = -1;
	1217	unsigned int gloop;
	1218	#endif
	1219
	1220	SL_ENTER(_("sh_files_pushdir"));
	1221
	1222	if (sh.flag.opts == 1) {
	1223	sh_files_delfilestack ();
	1224	sh_files_deldirstack ();
	1225	}
	1226
	1227	if (str_s == NULL)
	1228	SL_RETURN((-1), _("sh_files_pushdir"));
	1229
[22]	1230	p = sh_util_strdup (str_s);
[1]	1231
[22]	1232	if (p[0] != '/')
[1]	1233	{
[22]	1234	rdepth = strtol(p, &tail, 10);
	1235	if (tail == p)
	1236	{
	1237	SH_FREE(p);
	1238	SL_RETURN((-1), _("sh_files_pushdir"));
	1239	}
[1]	1240	}
	1241	else
[22]	1242	tail = p;
[1]	1243
	1244
[22]	1245	if (rdepth < (-1) \|\| tail == p \|\| rdepth > 99)
[1]	1246	rdepth = (-2);
	1247
	1248	len = sl_strlen(tail);
	1249
	1250	if (len >= PATH_MAX)
	1251	{
	1252	tmp = sh_util_safe_name (tail);
	1253	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_2LONG,
	1254	tmp);
	1255	SH_FREE(tmp);
[22]	1256	SH_FREE(p);
[1]	1257	SL_RETURN((-1), _("sh_files_pushdir"));
	1258	}
	1259	else if (len < 1)
	1260	{
[22]	1261	SH_FREE(p);
[1]	1262	SL_RETURN((-1), _("sh_files_pushdir"));
	1263	}
	1264	else if (tail[0] != '/')
	1265	{
	1266	tmp = sh_util_safe_name (tail);
	1267	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NOPATH,
	1268	tmp);
	1269	SH_FREE(tmp);
[22]	1270	SH_FREE(p);
[1]	1271	SL_RETURN((-1), _("sh_files_pushdir"));
	1272	}
	1273	else
	1274	{
	1275
	1276	if (tail[len-1] == '/' && len > 1)
	1277	{
	1278	tail[len-1] = '\0';
	1279	--len;
	1280	}
	1281
	1282	}
	1283
	1284	#ifdef HAVE_GLOB_H
	1285	if (0 == sh_files_has_metachar(tail))
	1286	{
	1287	sh_files_push_dir_int (class, tail, len, rdepth);
	1288	}
	1289	else
	1290	{
	1291	pglob.gl_offs = 0;
	1292	globstatus = glob (tail, 0, sh_files_globerr, &pglob);
	1293
	1294	if (globstatus == 0 && pglob.gl_pathc > 0)
	1295	{
	1296	for (gloop = 0; gloop < (unsigned int) pglob.gl_pathc; ++gloop)
	1297	sh_files_push_dir_int (class,
	1298	pglob.gl_pathv[gloop],
	1299	sl_strlen(pglob.gl_pathv[gloop]),
	1300	rdepth);
	1301	}
	1302	else
	1303	{
	1304	tmp = sh_util_safe_name (tail);
	1305
	1306	if (pglob.gl_pathc == 0
	1307	#ifdef GLOB_NOMATCH
	1308	\|\| globstatus == GLOB_NOMATCH
	1309	#endif
	1310	)
	1311	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1312	globstatus, MSG_FI_GLOB,
	1313	_("No matches found"), tmp);
	1314	#ifdef GLOB_NOSPACE
	1315	else if (globstatus == GLOB_NOSPACE)
	1316	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1317	globstatus, MSG_FI_GLOB,
	1318	_("Out of memory"), tmp);
	1319	#endif
	1320	#ifdef GLOB_ABORTED
	1321	else if (globstatus == GLOB_ABORTED)
	1322	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1323	globstatus, MSG_FI_GLOB,
	1324	_("Read error"), tmp);
	1325	#endif
	1326	else
	1327	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1328	globstatus, MSG_FI_GLOB,
	1329	_("Unknown error"), tmp);
	1330	SH_FREE(tmp);
	1331	}
	1332
	1333	globfree(&pglob);
	1334	}
	1335	#else
	1336	sh_files_push_dir_int (class, tail, len, rdepth);
	1337	#endif
	1338
[22]	1339	SH_FREE(p);
[1]	1340	SL_RETURN((0), _("sh_files_pushdir"));
[34]	1341	}
[1]	1342
[131]	1343	/**
[1]	1344	struct sh_dirent {
	1345	char * sh_d_name;
	1346	struct sh_dirent * next;
	1347	};
[131]	1348	**/
[1]	1349
[131]	1350	void kill_sh_dirlist (struct sh_dirent * dirlist)
[1]	1351	{
	1352	struct sh_dirent * this;
	1353
	1354	while (dirlist)
	1355	{
	1356	this = dirlist->next;
	1357	SH_FREE(dirlist->sh_d_name);
	1358	SH_FREE(dirlist);
	1359	dirlist = this;
	1360	}
	1361	return;
	1362	}
	1363
	1364	/* -- add an entry to a directory listing
	1365	*/
[131]	1366	struct sh_dirent * addto_sh_dirlist (struct dirent * thisEntry,
	1367	struct sh_dirent * dirlist)
[1]	1368	{
	1369	struct sh_dirent * this;
[34]	1370	size_t len;
[1]	1371
	1372	if (thisEntry == NULL)
	1373	return dirlist;
	1374
[34]	1375	len = sl_strlen(thisEntry->d_name);
	1376	if (len == 0)
[1]	1377	return dirlist;
[34]	1378	++len;
[1]	1379
	1380	this = SH_ALLOC(sizeof(struct sh_dirent));
	1381	if (!this)
	1382	return dirlist;
	1383
[34]	1384	this->sh_d_name = SH_ALLOC(len);
	1385	sl_strlcpy(this->sh_d_name, thisEntry->d_name, len);
[1]	1386
	1387	this->next = dirlist;
	1388	return this;
	1389	}
	1390
	1391	static int sh_check_hardlinks = S_TRUE;
	1392
	1393	/* Simply sets our boolean as to whether this check is active
	1394	*/
[22]	1395	int sh_files_check_hardlinks (const char * opt)
[1]	1396	{
	1397	int i;
	1398	SL_ENTER(_("sh_files_check_hardlinks"));
	1399	i = sh_util_flagval(opt, &sh_check_hardlinks);
	1400	SL_RETURN(i, _("sh_files_check_hardlinks"));
	1401	}
	1402
	1403	struct sh_hle_struct {
	1404	long offset;
	1405	char * path;
	1406	struct sh_hle_struct * next;
	1407	};
	1408
	1409	static struct sh_hle_struct * sh_hl_exc = NULL;
	1410
[22]	1411	int sh_files_hle_reg (const char * str)
[1]	1412	{
	1413	long offset;
	1414	size_t len;
	1415	char * path;
	1416
	1417	struct sh_hle_struct * tmp = sh_hl_exc;
	1418
	1419	SL_ENTER(_("sh_files_hle_reg"));
	1420
	1421	/* Free the linked list if called with NULL argument
	1422	*/
	1423	if (str == NULL)
	1424	{
	1425	while (tmp)
	1426	{
	1427	sh_hl_exc = tmp->next;
	1428	SH_FREE(tmp->path);
	1429	SH_FREE(tmp);
	1430	tmp = sh_hl_exc;
	1431	}
	1432	sh_hl_exc = NULL;
	1433	SL_RETURN(0, _("sh_files_hle_reg"));
	1434	}
	1435
	1436	/* We expect 'offset:/path'
	1437	*/
	1438	offset = strtol(str, &path, 0);
	1439	if ((path == NULL) \|\| (path == '\0') \|\| (path != ':') \|\| (path[1] != '/'))
	1440	{
	1441	SL_RETURN(-1, _("sh_files_hle_reg"));
	1442	}
	1443	++path;
	1444	len = 1 + sl_strlen(path);
	1445
	1446	tmp = SH_ALLOC(sizeof(struct sh_hle_struct));
	1447	tmp->path = SH_ALLOC(len);
	1448	sl_strlcpy (tmp->path, path, len);
	1449	tmp->offset = offset;
	1450	tmp->next = sh_hl_exc;
	1451	sh_hl_exc = tmp;
	1452
	1453	SL_RETURN(0, _("sh_files_hle_reg"));
	1454	}
	1455
	1456	#if !defined(HOST_IS_DARWIN)
	1457	static int sh_files_hle_test (int offset, char * path)
	1458	{
	1459	struct sh_hle_struct * tmp = sh_hl_exc;
	1460
	1461	SL_ENTER(_("sh_files_hle_reg"));
	1462
	1463	while(tmp)
	1464	{
	1465	if ((offset == tmp->offset) && (0 == strcmp(path, tmp->path)))
	1466	{
	1467	SL_RETURN(0, _("sh_files_hle_test"));
	1468	}
	1469	tmp = tmp->next;
	1470	}
	1471	SL_RETURN(-1, _("sh_files_hle_test"));
	1472	}
	1473	#endif
	1474
	1475	/* -- check a single directory and its content
	1476	*/
	1477	static int sh_files_checkdir (int iclass, int idepth, char * iname,
	1478	char * relativeName)
	1479	{
	1480	struct sh_dirent * dirlist = NULL;
	1481	struct sh_dirent * dirlist_orig = NULL;
	1482
	1483	DIR * thisDir = NULL;
	1484	struct dirent * thisEntry;
	1485	int status;
	1486	int dummy = S_FALSE;
	1487	dir_type theDir;
	1488	ShFileType checkit;
[131]	1489	static unsigned int state = 1;
[1]	1490
	1491	file_type theFile;
	1492	char * tmpname;
	1493	char * tmpcat;
[132]	1494	char errbuf[SH_ERRBUF_SIZE];
[1]	1495
	1496	int rdepth = 0;
	1497	int class = 0;
	1498	int rdepth_next;
	1499	int class_next;
	1500	int file_class_next;
	1501
	1502	int checked_flag = S_FALSE;
	1503	int cchecked_flag = S_FALSE;
	1504
	1505	dirstack_t * dst_ptr;
[19]	1506	dirstack_t * tmp_ptr;
[1]	1507
	1508	int hardlink_num = 0;
[34]	1509	#if !defined(HOST_IS_DARWIN)
	1510	size_t len;
	1511	#endif
[1]	1512
	1513	SL_ENTER(_("sh_files_checkdir"));
	1514
	1515	if (sig_urgent > 0) {
	1516	SL_RETURN((0), _("sh_files_checkdir"));
	1517	}
	1518
	1519	if (iname == NULL \|\| idepth < (-1))
	1520	SL_RETURN((-1), _("sh_files_checkdir"));
	1521
	1522	if (idepth < 0)
	1523	{
	1524	/* hash_remove_tree (iname); */
	1525	SL_RETURN((0), _("sh_files_checkdir"));
	1526	}
	1527
	1528	rdepth = idepth;
	1529	class = iclass;
	1530
	1531	tmpname = sh_util_safe_name (iname);
	1532
	1533	/* ---- check for obscure name ----
	1534	*/
	1535	if (iclass != SH_LEVEL_ALLIGNORE)
	1536	{
	1537	sh_util_obscurename (ShDFLevel[SH_ERR_T_NAME], iname, S_TRUE);
	1538	}
	1539
[8]	1540	if (flag_err_info == SL_TRUE)
	1541	{
	1542	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CHK, tmpname);
	1543	}
	1544
[1]	1545	/* ---- check input ----
	1546	*/
	1547	if ( sl_strlen(iname) >= PATH_MAX)
	1548	{
	1549	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	1550	MSG_FI_2LONG,
	1551	tmpname);
	1552	SH_FREE(tmpname);
	1553	SL_RETURN((-1), _("sh_files_checkdir"));
	1554	}
	1555
	1556	/* ---- check for absolute path ---- */
	1557	if ( iname[0] != '/')
	1558	{
	1559	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	1560	MSG_FI_NOPATH,
	1561	tmpname);
	1562	SH_FREE(tmpname);
	1563	SL_RETURN((-1), _("sh_files_checkdir"));
	1564	}
	1565
	1566
	1567	/* ---- stat the directory ----
	1568	*/
	1569	sl_strlcpy (theFile.fullpath, iname, PATH_MAX);
[68]	1570	theFile.attr_string = NULL;
[1]	1571
	1572	(void) relativeName;
	1573	status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_DIR],
	1574	iname,
	1575	&theFile, NULL, iclass);
	1576
	1577	if ((sig_termfast == 1) \|\| (sig_terminate == 1))
	1578	{
[68]	1579	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1580	SL_RETURN((0), _("sh_files_checkdir"));
	1581	}
	1582
	1583	if (status == -1)
	1584	{
	1585	SH_FREE(tmpname);
[68]	1586	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1587	SL_RETURN((-1), _("sh_files_checkdir"));
	1588	}
	1589
	1590	if (theFile.c_mode[0] != 'd')
	1591	{
	1592	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	1593	MSG_FI_NODIR,
	1594	tmpname);
	1595	SH_FREE(tmpname);
[68]	1596	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1597	SL_RETURN((-1), _("sh_files_checkdir"));
	1598	}
	1599
	1600	hardlink_num = theFile.hardlinks;
	1601
	1602
	1603	/* ---- open directory for reading ----
	1604	*
	1605	* opendir() will fail with ENOTDIR if the path has been changed
	1606	* to a non-directory in between lstat() and opendir().
	1607	*/
	1608	thisDir = opendir (iname);
	1609
	1610	if (thisDir == NULL)
	1611	{
	1612	status = errno;
	1613	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	1614	MSG_E_OPENDIR,
[132]	1615	sh_error_message (status, errbuf, sizeof(errbuf)), tmpname);
[1]	1616	SH_FREE(tmpname);
	1617
[68]	1618	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1619	SL_RETURN((-1), _("sh_files_checkdir"));
	1620	}
	1621
	1622	theDir.NumRegular = 0;
	1623	theDir.NumDirs = 0;
	1624	theDir.NumSymlinks = 0;
	1625	theDir.NumFifos = 0;
	1626	theDir.NumSockets = 0;
	1627	theDir.NumCDev = 0;
	1628	theDir.NumBDev = 0;
[40]	1629	theDir.NumDoor = 0;
	1630	theDir.NumPort = 0;
[1]	1631	theDir.NumAll = 0;
	1632	theDir.TotalBytes = 0;
	1633	sl_strlcpy (theDir.DirPath, iname, PATH_MAX);
	1634
	1635
	1636	/* ---- read ----
	1637	*/
[131]	1638	SH_MUTEX_LOCK(readdir_lock);
	1639
[1]	1640	do {
	1641	thisEntry = readdir (thisDir);
	1642	if (thisEntry != NULL)
	1643	{
	1644	++theDir.NumAll;
	1645	if (sl_strcmp (thisEntry->d_name, ".") == 0)
	1646	{
	1647	++theDir.NumDirs;
	1648	continue;
	1649	}
	1650	if (sl_strcmp (thisEntry->d_name, "..") == 0)
	1651	{
	1652	++theDir.NumDirs;
	1653	continue;
	1654	}
	1655	dirlist = addto_sh_dirlist (thisEntry, dirlist);
	1656	}
	1657	} while (thisEntry != NULL);
	1658
[131]	1659	SH_MUTEX_UNLOCK(readdir_lock);
	1660
[1]	1661	closedir (thisDir);
	1662
	1663	++sh.statistics.dirs_checked;
	1664
	1665	dirlist_orig = dirlist;
	1666
	1667	do {
	1668
	1669	/* If the directory is empty, dirlist = NULL
	1670	*/
	1671	if (!dirlist)
	1672	break;
	1673
	1674	if (sig_termfast == 1)
	1675	{
[68]	1676	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1677	SL_RETURN((0), _("sh_files_checkdir"));
	1678	}
	1679
	1680	BREAKEXIT(sh_derr);
[131]	1681
	1682	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R)
	1683	if (0 == (rand_r(&state) % 5)) (void) sh_derr();
	1684	#else
	1685	if (0 == state * (rand() % 5)) (void) sh_derr();
	1686	#endif
[1]	1687
	1688	/* ---- Check the file. ----
	1689	*/
	1690	tmpcat = SH_ALLOC(PATH_MAX);
	1691	sl_strlcpy(tmpcat, iname, PATH_MAX);
	1692	if (sl_strlen(tmpcat) > 1 \|\| tmpcat[0] != '/')
	1693	sl_strlcat(tmpcat, "/", PATH_MAX);
	1694	sl_strlcat(tmpcat, dirlist->sh_d_name, PATH_MAX);
	1695
	1696	rdepth_next = rdepth - 1;
	1697	class_next = class;
	1698	file_class_next = class;
	1699	checked_flag = -1;
	1700	cchecked_flag = -1;
	1701
	1702	/* Wed Aug 24 2005 compare against dirListOne, dirListTwo
	1703	* this fixes the problem that the directory special file
	1704	* is checked with the policy of the parent directory
	1705	*/
	1706	dst_ptr = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
	1707
	1708	if (dst_ptr)
	1709	{
	1710	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	1711	* this fixes the problem that a policy for the directory
	1712	* inode erroneously becomes a policy for the directory itself.
	1713	*/
	1714	file_class_next = dst_ptr->class;
	1715	checked_flag = dst_ptr->checked;
	1716	cchecked_flag = dst_ptr->childs_checked;
	1717	}
	1718
	1719	if (checked_flag == -1)
	1720	{
	1721	dst_ptr = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
	1722
	1723	if (dst_ptr)
	1724	{
	1725	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	1726	* this fixes the problem that a policy for the directory
	1727	* inode erroneously becomes a policy for the directory itself.
	1728	*/
	1729	file_class_next = dst_ptr->class;
	1730	checked_flag = dst_ptr->checked;
	1731	cchecked_flag = dst_ptr->childs_checked;
	1732	}
	1733	}
	1734
	1735	dst_ptr = (dirstack_t *) zAVLSearch(zfileList, tmpcat);
	1736
	1737	if (dst_ptr)
	1738	{
	1739	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	1740	* this fixes the problem that a policy for the directory
	1741	* inode erroneously becomes a policy for the directory itself.
	1742	*/
	1743	file_class_next = dst_ptr->class;
	1744	checked_flag = dst_ptr->checked;
[19]	1745	/* not set, hence always FALSE */
	1746	/* cchecked_flag = dst_ptr->childs_checked; */
[1]	1747	}
	1748
	1749	/* ---- Has been checked already. ----
	1750	*/
	1751	if (checked_flag == S_TRUE && cchecked_flag == S_TRUE)
	1752	{
	1753	/* Mar 11 2004 get ftype for complete directory count
	1754	*/
	1755	checkit = sh_unix_get_ftype(tmpcat);
	1756	if (checkit == SH_FILE_DIRECTORY)
	1757	{
	1758	++theDir.NumDirs;
	1759	}
	1760	SH_FREE(tmpcat);
	1761	dirlist = dirlist->next;
	1762	continue;
	1763	}
	1764
	1765	/* --- May be true, false, or not found. ---
	1766	*/
	1767	if (checked_flag == S_TRUE)
	1768	{
	1769	/* -- need only the file type --
	1770	*/
	1771	checkit = sh_unix_get_ftype(tmpcat);
	1772	}
	1773	else
	1774	{
	1775	/* -- need to check the file itself --
	1776	*/
	1777	if (dst_ptr && sh.flag.reportonce == S_TRUE)
[114]	1778	dummy = dst_ptr->is_reported;
[1]	1779
	1780	checkit = sh_files_filecheck (file_class_next,
	1781	iname,
	1782	dirlist->sh_d_name,
	1783	&dummy, 0);
	1784
	1785	if (dst_ptr && checked_flag == S_FALSE)
	1786	dst_ptr->checked = S_TRUE;
	1787	/* Thu Mar 7 15:09:40 CET 2002 Propagate the 'reported' flag
	1788	*/
	1789	if (dst_ptr && sh.flag.reportonce == S_TRUE)
[114]	1790	dst_ptr->is_reported = dummy;
[1]	1791	}
	1792
	1793	if (checkit == SH_FILE_REGULAR)
	1794	++theDir.NumRegular;
	1795
	1796	else if (checkit == SH_FILE_DIRECTORY)
	1797	{
	1798	++theDir.NumDirs;
	1799	if (rdepth_next >= 0 && cchecked_flag != S_TRUE)
	1800	{
	1801	rdepth_next = rdepth - 1;
	1802
	1803	/* check whether the new directory is in the
	1804	* list with a recursion depth already defined
	1805	*/
	1806	checked_flag = -1;
	1807	cchecked_flag = -1;
	1808
[19]	1809	tmp_ptr = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
[1]	1810
[19]	1811	if (tmp_ptr)
[1]	1812	{
	1813	TPT((0, FIL__, __LINE__,
	1814	_("msg=<%s -> recursion depth %d\n>"),
[19]	1815	tmp_ptr->name, tmp_ptr->rdepth));
	1816	rdepth_next = tmp_ptr->rdepth;
	1817	class_next = tmp_ptr->class;
[1]	1818	/* 28. Aug 2001 reversed
	1819	*/
[19]	1820	cchecked_flag = tmp_ptr->childs_checked;
	1821	checked_flag = tmp_ptr->checked;
[1]	1822	}
	1823
	1824	if (checked_flag == -1)
	1825	{
[19]	1826	tmp_ptr = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
[1]	1827
[19]	1828	if (tmp_ptr)
[1]	1829	{
	1830	TPT((0, FIL__, __LINE__,
	1831	_("msg=<%s -> recursion depth %d\n>"),
[19]	1832	tmp_ptr->name, tmp_ptr->rdepth));
	1833	rdepth_next = tmp_ptr->rdepth;
	1834	class_next = tmp_ptr->class;
[1]	1835	/* 28. Aug 2001 reversed
	1836	*/
[19]	1837	cchecked_flag = tmp_ptr->childs_checked;
	1838	checked_flag = tmp_ptr->checked;
[1]	1839	}
	1840	}
	1841
	1842	if (cchecked_flag == S_FALSE)
	1843	{
	1844	sh_files_checkdir (class_next, rdepth_next, tmpcat,
	1845	dirlist->sh_d_name);
[19]	1846	tmp_ptr->childs_checked = S_TRUE;
	1847	/*
	1848	* 04. Feb 2006 avoid double checking
	1849	*/
	1850	tmp_ptr->checked = S_TRUE;
[1]	1851	}
	1852	else if (checked_flag == -1)
	1853	sh_files_checkdir (class_next, rdepth_next, tmpcat,
	1854	dirlist->sh_d_name);
	1855
	1856	}
	1857	}
	1858
	1859	else if (checkit == SH_FILE_SYMLINK) ++theDir.NumSymlinks;
	1860	else if (checkit == SH_FILE_FIFO) ++theDir.NumFifos;
	1861	else if (checkit == SH_FILE_SOCKET) ++theDir.NumSockets;
	1862	else if (checkit == SH_FILE_CDEV) ++theDir.NumCDev;
	1863	else if (checkit == SH_FILE_BDEV) ++theDir.NumBDev;
[40]	1864	else if (checkit == SH_FILE_DOOR) ++theDir.NumDoor;
	1865	else if (checkit == SH_FILE_PORT) ++theDir.NumPort;
[1]	1866
	1867	SH_FREE(tmpcat);
	1868
	1869	if ((sig_termfast == 1) \|\| (sig_terminate == 1))
	1870	{
[68]	1871	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1872	SL_RETURN((0), _("sh_files_checkdir"));
	1873	}
	1874
	1875	dirlist = dirlist->next;
[19]	1876
	1877	if (dst_ptr)
	1878	dst_ptr->childs_checked = S_TRUE;
[1]	1879
	1880	} while (dirlist != NULL);
	1881
	1882	if (flag_err_info == SL_TRUE)
	1883	{
	1884	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DSUM,
	1885	theDir.NumDirs,
	1886	theDir.NumRegular,
	1887	theDir.NumSymlinks,
	1888	theDir.NumFifos,
	1889	theDir.NumSockets,
	1890	theDir.NumCDev,
	1891	theDir.NumBDev);
	1892	}
	1893
	1894	kill_sh_dirlist (dirlist_orig);
	1895
	1896	#if !defined(HOST_IS_DARWIN)
	1897	/*
	1898	* Hardlink check; not done on MacOS X because of resource forks
	1899	*/
	1900	if ((sh_check_hardlinks == S_TRUE) && (hardlink_num != theDir.NumDirs))
	1901	{
	1902	if (0 != sh_files_hle_test(hardlink_num-theDir.NumDirs, iname))
	1903	{
[34]	1904	len = strlen(tmpname);
	1905	if (sl_ok_adds(len, 256))
	1906	len += 256;
	1907	tmpcat = SH_ALLOC(len);
	1908	sl_snprintf(tmpcat, len,
[1]	1909	_("%s: subdirectory count (%d) != hardlinks (%d)"),
	1910	tmpname, theDir.NumDirs, hardlink_num);
	1911	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	1912	MSG_E_SUBGEN, tmpcat, _("sh_files_checkdir"));
	1913	SH_FREE(tmpcat);
	1914	}
	1915	}
	1916	#endif
	1917
[68]	1918	if (theFile.attr_string) SH_FREE(theFile.attr_string);
[1]	1919	SH_FREE(tmpname);
	1920
	1921	SL_RETURN((0), _("sh_files_checkdir"));
	1922	}
	1923
	1924	int get_the_fd (SL_TICKET ticket);
	1925
	1926
	1927	static ShFileType sh_files_filecheck (int class, char * dirName,
[34]	1928	char * infileName,
[1]	1929	int * reported,
	1930	int rsrcflag)
	1931	{
	1932	/* 28 Aug 2001 allow NULL fileName
	1933	*/
	1934	char fullpath[PATH_MAX];
[19]	1935	char fileHash[2*(KEY_LEN + 1)];
[1]	1936	int status;
	1937	file_type theFile;
	1938	char * tmpdir;
	1939	char * tmpname;
[34]	1940	char * fileName;
[1]	1941	struct utimbuf utime_buf;
[131]	1942	static unsigned int state = 1;
[1]	1943
	1944	SL_ENTER(_("sh_files_filecheck"));
	1945
	1946	BREAKEXIT(sh_derr);
	1947
[131]	1948	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R)
	1949	if (0 == (rand_r(&state) % 2)) (void) sh_derr();
	1950	#else
	1951	if (0 == state * (rand() % 2)) (void) sh_derr();
	1952	#endif
	1953
[34]	1954	if (dirName && infileName && (dirName[0] == '/') && (dirName[1] == '\0')
	1955	&& (infileName[0] == '/') && (infileName[1] == '\0'))
	1956	{
	1957	fileName = NULL;
	1958	}
	1959	else
	1960	{
	1961	fileName = infileName;
	1962	}
	1963
[1]	1964	/* fileName may be NULL if this is a directory
	1965	*/
	1966	if (dirName == NULL /* \|\| fileName == NULL */)
	1967	{
	1968	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NULL);
	1969	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	1970	}
	1971
	1972	if ((fileName != NULL) && (class != SH_LEVEL_ALLIGNORE) &&
	1973	(0 != sh_util_obscurename (ShDFLevel[SH_ERR_T_NAME],
	1974	fileName, S_FALSE)))
	1975	{
	1976	if ((dirName != NULL) && (dirName[0] == '/') && (dirName[1] == '\0'))
	1977	{
	1978	tmpname = sh_util_safe_name (fileName);
	1979	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, 0,
	1980	MSG_FI_OBSC2,
	1981	"", tmpname);
	1982	SH_FREE(tmpname);
	1983	}
	1984	else
	1985	{
	1986	tmpdir = sh_util_safe_name (dirName);
	1987	tmpname = sh_util_safe_name (fileName);
	1988	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, 0,
	1989	MSG_FI_OBSC2,
	1990	tmpdir, tmpname);
	1991	SH_FREE(tmpname);
	1992	SH_FREE(tmpdir);
	1993	}
	1994	}
	1995
	1996	/* sh_files_fullpath accepts NULL fileName
	1997	*/
	1998	if (0 != sh_files_fullpath (dirName, fileName, fullpath))
	1999	{
	2000	tmpdir = sh_util_safe_name (dirName);
	2001	tmpname = sh_util_safe_name (fileName);
	2002	sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, 0,
	2003	MSG_FI_2LONG2,
	2004	tmpdir, tmpname);
	2005	SH_FREE(tmpname);
	2006	SH_FREE(tmpdir);
	2007	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2008	}
	2009
	2010
	2011	/* stat the file and determine checksum (if a regular file)
	2012	*/
	2013	sl_strlcpy (theFile.fullpath, fullpath, PATH_MAX);
[114]	2014	theFile.check_mask = sh_files_maskof(class);
	2015	theFile.file_reported = (*reported);
	2016	theFile.attr_string = NULL;
[1]	2017
	2018	TPT(( 0, FIL__, __LINE__, _("msg=<checking file: %s>\n"), fullpath));
	2019
	2020	status = sh_unix_getinfo ( (class == SH_LEVEL_ALLIGNORE) ?
	2021	ShDFLevel[class] : ShDFLevel[SH_ERR_T_FILE],
	2022	fileName,
	2023	&theFile, fileHash, class);
	2024
	2025	if (status != 0)
	2026	{
	2027	TPT(( 0, FIL__, __LINE__, _("msg=<file: %s> status=<%d>\n"),
	2028	fullpath, status));
	2029	if (class == SH_LEVEL_ALLIGNORE && sh.flag.checkSum != SH_CHECK_INIT)
[68]	2030	sh_hash_set_visited_true (fullpath);
	2031	if (theFile.attr_string)
	2032	SH_FREE(theFile.attr_string);
[1]	2033	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2034	}
	2035
	2036	if (sig_termfast == 1) {
	2037	goto ret_point;
	2038	}
	2039
	2040	/* report
	2041	*/
	2042	if ((flag_err_debug == SL_TRUE) && (theFile.c_mode[0] == '-'))
	2043	{
	2044	tmpname = sh_util_safe_name (fullpath); /* fixed in 1.5.4 */
	2045	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CSUM,
	2046	fileHash, tmpname);
	2047	SH_FREE(tmpname);
	2048	}
	2049	++sh.statistics.files_checked;
	2050
[77]	2051	if ( sh.flag.checkSum == SH_CHECK_INIT /* && sh.flag.update == S_FALSE */)
[1]	2052	{
	2053	sh_hash_pushdata (&theFile, fileHash);
	2054	}
	2055	else if (sh.flag.checkSum == SH_CHECK_CHECK
	2056	/* && theFile.c_mode[0] == '-' */
	2057	/* && class != SH_LEVEL_ALLIGNORE */
	2058	)
	2059	{
	2060	sh_hash_compdata (class, &theFile, fileHash, NULL, -1);
	2061	}
	2062
[114]	2063	(*reported) = theFile.file_reported;
[1]	2064
	2065	/* reset the access time
	2066	*/
	2067	if (class == SH_LEVEL_NOIGNORE && (theFile.check_mask & MODI_ATM) != 0)
	2068	{
	2069	utime_buf.actime = (time_t) theFile.atime;
	2070	utime_buf.modtime = (time_t) theFile.mtime;
	2071	#if !defined(O_NOATIME)
	2072	retry_aud_utime (FIL__, __LINE__, fullpath, &utime_buf);
	2073	#endif
	2074	}
	2075
	2076	#ifdef HOST_IS_DARWIN
	2077	/*
	2078	* Check for resource fork
	2079	*/
	2080	if ( (theFile.c_mode[0] != 'd') && (rsrcflag == 0) )
	2081	{
	2082	int dummy;
	2083	static int rsrc_init = 0;
	2084	static char rsrc[17];
	2085	char testpath[PATH_MAX];
	2086
	2087	if (rsrc_init == 0) {
	2088	sl_strlcpy(rsrc, _("..namedfork/rsrc"), 17);
	2089	rsrc_init = 1;
	2090	}
	2091	sl_strlcpy (testpath, fullpath, PATH_MAX);
	2092	sl_strlcat (testpath, "/", PATH_MAX);
	2093	sl_strlcat (testpath, rsrc, PATH_MAX);
	2094
	2095	if (sl_strlen(testpath) == (17 + sl_strlen(fullpath)))
	2096	{
[78]	2097	if (S_TRUE == sh_unix_file_exists (testpath))
[1]	2098	{
	2099	sh_files_filecheck (class, fullpath, rsrc, &dummy, 1);
	2100	}
	2101	}
	2102	}
	2103	#else
[68]	2104	(void) rsrcflag; /* avoid compiler warning */
[1]	2105	#endif
	2106
	2107	ret_point:
	2108
[68]	2109	if (theFile.attr_string) SH_FREE(theFile.attr_string);
	2110
[1]	2111	switch (theFile.c_mode[0])
	2112	{
	2113	case '-': SL_RETURN(SH_FILE_REGULAR, _("sh_files_filecheck"));
	2114	case 'l': SL_RETURN(SH_FILE_SYMLINK, _("sh_files_filecheck"));
	2115	case 'd': SL_RETURN(SH_FILE_DIRECTORY, _("sh_files_filecheck"));
	2116	case 'c': SL_RETURN(SH_FILE_CDEV, _("sh_files_filecheck"));
	2117	case 'b': SL_RETURN(SH_FILE_BDEV, _("sh_files_filecheck"));
	2118	case '\|': SL_RETURN(SH_FILE_FIFO, _("sh_files_filecheck"));
[40]	2119	case 'D': SL_RETURN(SH_FILE_DOOR, _("sh_files_filecheck"));
	2120	case 'P': SL_RETURN(SH_FILE_PORT, _("sh_files_filecheck"));
[1]	2121	case 's': SL_RETURN(SH_FILE_SOCKET, _("sh_files_filecheck"));
	2122	default: SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2123	}
	2124
	2125	/* notreached */
	2126	}
	2127
	2128	/* concatenate statpath = testdir"/"d_name
	2129	*/
	2130	static int sh_files_fullpath (char * testdir, char * d_name, char * statpath)
	2131	{
	2132	int llen = 0;
	2133
	2134	SL_ENTER(_("sh_files_fullpath"));
	2135
	2136	if (testdir != NULL)
	2137	{
	2138	if ( (llen = sl_strlen(testdir)) > (PATH_MAX-2) )
	2139	SL_RETURN((-1),_("sh_files_fullpath"));
	2140	sl_strlcpy(statpath, testdir, PATH_MAX - 1);
	2141	}
	2142	if (d_name != NULL)
	2143	{
	2144	if (llen > 1 \|\| statpath[0] != '/')
	2145	sl_strlcat(statpath, "/", PATH_MAX);
	2146	if ((sl_strlen(d_name) + sl_strlen(statpath)) >= PATH_MAX)
	2147	SL_RETURN((-1),_("sh_files_fullpath"));
	2148	sl_strlcat(statpath, d_name, PATH_MAX);
	2149	}
	2150	if (statpath == NULL)
	2151	SL_RETURN((-1),_("sh_files_fullpath"));
	2152	SL_RETURN((0),_("sh_files_fullpath"));
	2153	}
	2154
	2155
	2156	/* -----------------------------------
	2157	*
	2158	* The following two routines serve to
	2159	* verify that the user has selected
	2160	* a proper setup for file policies.
	2161	*
	2162	* -----------------------------------
	2163	*/
	2164	static int check_file(char * name)
	2165	{
	2166	dirstack_t * pfilL;
	2167	zAVLCursor cursor;
	2168
	2169	SL_ENTER(_("check_file"));
	2170
	2171	if (SH_FILE_DIRECTORY == sh_unix_get_ftype(name))
	2172	SL_RETURN(0, _("check_file"));
	2173
	2174	for (pfilL = (dirstack_t *) zAVLFirst (&cursor, zfileList); pfilL;
	2175	pfilL = (dirstack_t *) zAVLNext (&cursor))
	2176	{
	2177	if (0 == strcmp(name, pfilL->name) &&
	2178	(pfilL->check_mask & MODI_ATM) == 0 &&
	2179	(pfilL->check_mask & MODI_CTM) == 0 &&
	2180	(pfilL->check_mask & MODI_MTM) == 0)
	2181	SL_RETURN(0, _("check_file"));
	2182	}
	2183	SL_RETURN((-1), _("check_file"));
	2184	}
	2185
	2186	int sh_files_test_setup_int (zAVLTree * tree)
	2187	{
	2188	int dlen, flen;
	2189	zAVLCursor cursor1;
	2190	zAVLCursor cursor2;
	2191
	2192	dirstack_t * pdirL;
	2193	dirstack_t * pfilL;
	2194
	2195	SL_ENTER(_("sh_files_test_setup"));
	2196
	2197	for (pdirL = (dirstack_t *) zAVLFirst (&cursor1, tree); pdirL;
	2198	pdirL = (dirstack_t *) zAVLNext (&cursor1))
	2199	{
	2200	dlen = strlen(pdirL->name);
	2201
	2202	for (pfilL = (dirstack_t *) zAVLFirst (&cursor2, zfileList); pfilL;
	2203	pfilL = (dirstack_t *) zAVLNext (&cursor2))
	2204	{
	2205	flen = strlen(pfilL->name);
	2206
	2207	/* check whether file is in tree of dir
	2208	*/
	2209	if ((pfilL->class == SH_LEVEL_READONLY) \|\|
	2210	(pfilL->class == SH_LEVEL_NOIGNORE))
	2211	{
	2212	; /* do nothing */
	2213	}
	2214	else
	2215	{
	2216	if ((flen > (dlen+1)) &&
	2217	(pfilL->name[dlen] == '/') &&
	2218	(NULL == strchr(&(pfilL->name[dlen+1]), '/')) && /30-5-01/
	2219	(0 == strncmp(pfilL->name, pdirL->name, dlen)))
	2220	{
	2221	if ((pdirL->check_mask & MODI_ATM) != 0 \|\|
	2222	(pdirL->check_mask & MODI_MTM) != 0 \|\|
	2223	(pdirL->check_mask & MODI_CTM) != 0)
	2224	{
	2225	if (check_file (pdirL->name) != 0)
	2226	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_COLL,
	2227	pdirL->name, pfilL->name);
	2228	}
	2229	}
	2230	}
	2231	}
	2232	}
	2233
	2234	SL_RETURN((0), _("sh_files_test_setup"));
	2235	}
	2236
	2237	int sh_files_test_double (zAVLTree * firstList, zAVLTree * secondList)
	2238	{
	2239	int count;
	2240	int retval = 0;
	2241
	2242	zAVLCursor cursor;
	2243
	2244	dirstack_t * first;
	2245
	2246	for (first = (dirstack_t *) zAVLFirst (&cursor, firstList); first;
	2247	first = (dirstack_t *) zAVLNext (&cursor))
	2248	{
	2249
	2250	if (NULL != zAVLSearch(secondList, first->name))
	2251	{
	2252	++count;
	2253	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	2254	first->name);
	2255	retval = 1;
	2256	}
	2257	}
	2258	return retval;
	2259	}
	2260
	2261	extern void aud_exit (char * file, int line, int fd);
	2262
	2263	int sh_files_test_setup ()
	2264	{
	2265	int retval = 0;
	2266
	2267	/* Test for modifications allowed in ReadOnly directory
	2268	*/
	2269	sh_files_test_setup_int (zdirListOne);
	2270	sh_files_test_setup_int (zdirListTwo);
	2271
	2272	/* Test for files/dirz defined twice
	2273	*/
	2274	retval = sh_files_test_double (zdirListOne, zdirListTwo);
	2275	if (retval != 0)
	2276	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2277
	2278	retval = sh_files_test_double (zdirListTwo, zdirListOne);
	2279	if (retval != 0)
	2280	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2281
[5]	2282
[1]	2283	/*
	2284	retval = sh_files_test_double (zfileList, NULL);
	2285	if (retval != 0)
	2286	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	2287	*/
	2288	return 0;
	2289	}
	2290
	2291	#endif

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

Download in other formats: