Context Navigation

source: trunk/src/sh_files.c@ 487

Last change on this file since 487 was 481, checked in by katerina, 9 years ago
Enhancements and fixes for tickets #374, #375, #376, #377, #378, and #379.
File size: 81.1 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
[377]	22	#if defined(HAVE_PTHREAD_MUTEX_RECURSIVE)
	23	#define _XOPEN_SOURCE 500
	24	#endif
	25
[1]	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include <string.h>
[286]	29	#include <ctype.h>
[1]	30	#include <limits.h>
	31
	32	#include <errno.h>
	33
	34	/* Must be before <utime.h> on FreeBSD
	35	*/
	36	#include <sys/types.h>
	37	#include <unistd.h>
[386]	38	#include <sys/types.h>
	39	#include <sys/stat.h>
	40	#include <fcntl.h>
[1]	41
[386]	42	#if !defined(O_NOATIME)
[395]	43	#if defined(__linux__) && (defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__PPC__))
[386]	44	#define O_NOATIME 01000000
	45	#endif
	46	#endif
	47
[1]	48	#include <utime.h>
	49
	50	#ifdef HAVE_DIRENT_H
	51	#include <dirent.h>
	52	#define NAMLEN(dirent) sl_strlen((dirent)->d_name)
	53	#else
	54	#define dirent direct
	55	#define NAMLEN(dirent) (dirent)->d_namlen
	56	#ifdef HAVE_SYS_NDIR_H
	57	#include <sys/ndir.h>
	58	#endif
	59	#ifdef HAVE_SYS_DIR_H
	60	#include <sys/dir.h>
	61	#endif
	62	#ifdef HAVE_NDIR_H
	63	#include <ndir.h>
	64	#endif
	65	#endif
[137]	66	#define NEED_ADD_DIRENT
[1]	67
	68	#ifdef HAVE_GLOB_H
	69	#include <glob.h>
	70	#endif
[371]	71	#ifdef HAVE_FNMATCH_H
	72	#include <fnmatch.h>
	73	#endif
[1]	74
[371]	75
[1]	76	#include "samhain.h"
	77
	78	#if (defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE))
	79
[131]	80	#include "sh_pthread.h"
[1]	81	#include "sh_error.h"
	82	#include "sh_utils.h"
	83	#include "sh_unix.h"
	84	#include "sh_files.h"
	85	#include "sh_tiger.h"
	86	#include "sh_hash.h"
	87	#include "sh_ignore.h"
[367]	88	#include "sh_inotify.h"
[1]	89	#include "zAVLTree.h"
[481]	90	#include "sh_dbIO.h"
[1]	91
	92	#undef FIL__
	93	#define FIL__ _("sh_files.c")
	94
[367]	95	extern sh_watches sh_file_watches;
	96
[286]	97	static char * sh_files_C_dequote (char * s, size_t * length)
	98	{
[362]	99	size_t i, len = *length;
[286]	100	int flag = 0;
	101	char p, q, po, pend;
	102
	103	/* search for backslash
	104	*/
	105	for (i = 0; i < len; ++i)
	106	{
	107	if (s[i] == '\\')
	108	{
	109	flag = 1;
	110	break;
	111	}
	112	}
	113
	114	if (flag == 0 \|\| *s == '\0')
	115	return s;
	116
	117	po = SH_ALLOC(len+1); *po = '\0'; p = po; pend = &po[len];
	118
[383]	119	q = s;
[286]	120
	121	do
	122	{
	123	if (*q == '\\')
	124	{
	125	++q;
	126
	127	if (*q == '\0')
	128	{ p = q; flag = 0; break; }
	129	else if (*q == 'a')
	130	{ *p = '\a'; ++p; ++q; }
	131	else if (*q == 'b')
	132	{ *p = '\b'; ++p; ++q; }
	133	else if (*q == 'f')
	134	{ *p = '\f'; ++p; ++q; }
	135	else if (*q == 'n')
	136	{ *p = '\n'; ++p; ++q; }
	137	else if (*q == 'r')
	138	{ *p = '\r'; ++p; ++q; }
	139	else if (*q == 't')
	140	{ *p = '\t'; ++p; ++q; }
	141	else if (*q == 'v')
	142	{ *p = '\v'; ++p; ++q; }
	143	else if (*q == '\\')
	144	{ *p = '\\'; ++p; ++q; }
	145	else if (*q == '\'')
	146	{ *p = '\''; ++p; ++q; }
	147	else if (*q == '"')
	148	{ *p = '"'; ++p; ++q; }
	149	else if (*q == 'x')
	150	{
	151	if (isxdigit((int) q[1]) && isxdigit((int) q[2]))
	152	{
	153	/* hexadecimal value following */
	154	unsigned char cc = (16 * sh_util_hexchar(q[1]))
	155	+ sh_util_hexchar(q[2]);
	156	*p = (char) cc;
	157	++p; q += 3;
	158	}
	159	else
	160	{
	161	*p = '\0'; flag = 0; break;
	162	}
	163	}
	164	else if (isdigit((int)*q))
	165	{
	166	if (isdigit((int) q[1]) && q[1] < '8' &&
	167	isdigit((int) q[2]) && q[2] < '8')
	168	{
	169	/* octal value following */
	170	char tmp[4]; unsigned char cc;
	171	tmp[0] = q; ++q; tmp[1] = q; ++q; tmp[2] = *q; ++q;
	172	tmp[3] = '\0';
	173	cc = strtol(tmp, NULL, 8);
	174	*p = (char) cc; ++p;
	175	}
	176	else
	177	{
	178	*p = '\0'; flag = 0; break;
	179	}
	180	}
	181	else
	182	{
	183	/* invalid escape sequence */
	184	*p = '\0'; flag = 0; break;
	185	}
	186	}
	187	else
	188	{
	189	p = q;
	190	++p; ++q;
	191	}
	192	} while (*q && p <= pend);
	193
	194	SL_REQUIRE (p <= pend, _("p <= pend"));
	195
	196	if (flag)
	197	{
	198	*p = '\0';
	199	*length = strlen(po);
	200	}
	201	else
	202	{
	203	SH_FREE(po);
	204	po = NULL;
	205	*length = 0;
	206	}
	207
	208	SL_REQUIRE (length <= len, _("length <= len"));
	209
	210	SH_FREE(s);
	211	return po;
	212	}
	213
[481]	214	char * sh_files_parse_input(const char * str_s, size_t * len)
	215	{
	216	char * p;
	217
	218	if (!str_s \|\| *str_s == '\0')
	219	return NULL;
	220
	221	*len = sl_strlen(str_s);
	222
	223	if ( (str_s[0] == '"' && str_s[*len-1] == '"' ) \|\|
	224	(str_s[0] == '\'' && str_s[*len-1] == '\'') )
	225	{
	226	if (*len < 3)
	227	return NULL;
	228	--(*len);
	229	p = sh_util_strdup_l(&str_s[1], *len);
	230	p[*len-1] = '\0';
	231	--(*len);
	232	}
	233	else
	234	{
	235	p = sh_util_strdup_l(str_s, *len);
	236	}
	237
	238	p = sh_files_C_dequote(p, len);
	239
	240	return p;
	241	}
	242
	243
[1]	244	extern int flag_err_debug;
	245	extern int flag_err_info;
	246
[22]	247	int sh_files_reportonce(const char * c)
[1]	248	{
	249	int i;
	250	SL_ENTER(_("sh_files_reportonce"));
	251	i = sh_util_flagval(c, &(sh.flag.reportonce));
	252
	253	SL_RETURN(i, _("sh_files_reportonce"));
	254	}
	255
[22]	256	int sh_files_fulldetail(const char * c)
[1]	257	{
	258	int i;
	259	SL_ENTER(_("sh_files_fulldetail"));
	260	i = sh_util_flagval(c, &(sh.flag.fulldetail));
	261
	262	SL_RETURN((i), _("sh_files_fulldetail"));
	263	}
	264
	265
	266	typedef struct dir_struct {
	267	long NumRegular;
	268	long NumDirs;
	269	long NumSymlinks;
	270	long NumFifos;
	271	long NumSockets;
	272	long NumCDev;
	273	long NumBDev;
[40]	274	long NumDoor;
	275	long NumPort;
[1]	276	long NumAll;
	277	long TotalBytes;
	278	char DirPath[PATH_MAX];
	279	} dir_type;
	280
	281	typedef struct dirstack_entry {
	282	char * name;
	283	int class;
[481]	284	unsigned long check_flags;
[1]	285	int rdepth;
	286	short checked;
	287	short childs_checked;
[114]	288	short is_reported;
[1]	289	/* struct dirstack_entry * next; */
	290	} dirstack_t;
	291
	292
	293	/* the destructor
	294	*/
	295	void free_dirstack (void * inptr)
	296	{
	297	dirstack_t * here;
	298
	299	SL_ENTER(_("free_dirstack"));
	300	if (inptr == NULL)
	301	SL_RET0(_("free_dirstack"));
	302	else
	303	here = (dirstack_t *) inptr;
	304
	305	if (here->name != NULL)
	306	SH_FREE(here->name);
	307	SH_FREE(here);
	308	SL_RET0(_("free_dirstack"));
	309	}
	310
	311	/* Function to return the key for indexing
	312	* the argument
	313	*/
	314	zAVLKey zdirstack_key (void const * arg)
	315	{
	316	const dirstack_t * sa = (const dirstack_t *) arg;
	317	return (zAVLKey) sa->name;
	318	}
	319
[256]	320	#define SH_LIST_FILE 0
	321	#define SH_LIST_DIR1 1
	322	#define SH_LIST_DIR2 2
[1]	323
[256]	324
	325	static int which_dirList = SH_LIST_DIR1;
	326
[1]	327	static zAVLTree * zdirListOne = NULL;
	328	static zAVLTree * zdirListTwo = NULL;
	329	static zAVLTree * zfileList = NULL;
	330
[371]	331	SH_MUTEX_STATIC(mutex_zfiles, PTHREAD_MUTEX_INITIALIZER);
	332	SH_MUTEX_STATIC(mutex_zglob, PTHREAD_MUTEX_INITIALIZER);
[373]	333	SH_MUTEX_RECURSIVE(mutex_zdirs);
[1]	334
[373]	335	static int sh_files_fullpath (const char * testdir,
	336	const char * d_name,
[1]	337	char * statpath);
[22]	338	static int sh_files_pushdir (int class, const char * str_s);
	339	static int sh_files_pushfile (int class, const char * str_s);
[1]	340
	341	static long MaxRecursionLevel = 0;
	342
	343	/* set default recursion level
	344	*/
[20]	345	int sh_files_setrecursion (const char * flag_s)
[1]	346	{
	347	long flag = 0;
	348	static int reject = 0;
	349
	350	SL_ENTER( _("sh_files_setrecursion"));
	351
	352	if (reject == 1)
	353	SL_RETURN((-1), _("sh_files_setrecursion"));
	354
[481]	355	if (sh.flag.opts == S_TRUE)
[1]	356	reject = 1;
	357
	358	if (flag_s != NULL)
	359	flag = (int)(atof(flag_s));
	360
	361	if (flag >= 0 && flag <= 99)
	362	MaxRecursionLevel = flag;
	363	else
	364	SL_RETURN((-1), _("sh_files_setrecursion"));
	365
	366	SL_RETURN((0), _("sh_files_setrecursion"));
	367	}
	368
[458]	369	static int handle_filecheck_ret(dirstack_t * ptr, char * tmp_in, int status)
	370	{
	371	int fcount = 0;
	372	char * tmp;
	373
	374	if (!tmp_in)
	375	tmp = sh_util_safe_name (ptr->name);
	376	else
	377	tmp = tmp_in;
	378
	379	if (status == SH_FILE_UNKNOWN && (!SH_FFLAG_REPORTED_SET(ptr->is_reported)))
	380	{
	381	TPT(( 0, FIL__, __LINE__, _("msg=<file: %s> status=<%d>\n"),
	382	tmp, status));
	383
	384	if ( sh.flag.checkSum == SH_CHECK_INIT \|\|
	385	sh_hash_have_it (ptr->name) >= 0)
	386	{
	387	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	388	{
	389	if (0 != hashreport_missing(ptr->name,
	390	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	391	ShDFLevel[ptr->class] :
	392	ShDFLevel[SH_ERR_T_FILE])) {
	393	if (tmp == NULL)
	394	tmp = sh_util_safe_name (ptr->name);
	395	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	396	ShDFLevel[ptr->class] :
	397	ShDFLevel[SH_ERR_T_FILE],
	398	FIL__, __LINE__, 0, MSG_FI_MISS,
	399	tmp);
	400	++sh.statistics.files_report;
	401	}
	402	}
	403	}
	404	else /* not there at init, and still missing */
	405	{
	406	if (tmp == NULL)
	407	tmp = sh_util_safe_name (ptr->name);
	408	sh_error_handle (SH_ERR_NOTICE,
	409	FIL__, __LINE__, 0,
	410	MSG_FI_FAIL,
	411	tmp);
	412	}
[481]	413
[458]	414	if (sh.flag.checkSum != SH_CHECK_INIT)
	415	sh_hash_set_missing(ptr->name);
[481]	416
[458]	417	if (sh.flag.reportonce == S_TRUE)
	418	SET_SH_FFLAG_REPORTED(ptr->is_reported);
	419	}
	420	else
	421	{
	422	/* exists (status >= 0), but was missing (reported == TRUE)
	423	*/
	424	if (status != SH_FILE_UNKNOWN && SH_FFLAG_REPORTED_SET(ptr->is_reported))
	425	{
	426	CLEAR_SH_FFLAG_REPORTED(ptr->is_reported);
	427	sh_hash_clear_flag(ptr->name, SH_FFLAG_ENOENT);
	428	}
	429
	430	/* Catchall
	431	*/
	432	else if (status == SH_FILE_UNKNOWN)
	433	{
	434	/* Thu Mar 7 15:09:40 CET 2002 Make sure missing file
	435	* is reported if ptr->reported == S_TRUE because the
	436	* file has been added.
	437	*/
	438	if (sh_hash_have_it (ptr->name) >= 0 &&
	439	!SH_FFLAG_REPORTED_SET(ptr->is_reported))
	440	{
	441	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	442	{
	443	if (0 != hashreport_missing(ptr->name,
	444	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	445	ShDFLevel[ptr->class] :
	446	ShDFLevel[SH_ERR_T_FILE])) {
	447	if (tmp == NULL)
	448	tmp = sh_util_safe_name (ptr->name);
	449	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE)?
	450	ShDFLevel[ptr->class] :
	451	ShDFLevel[SH_ERR_T_FILE],
	452	FIL__, __LINE__, 0, MSG_FI_MISS,
	453	tmp);
	454	++sh.statistics.files_report;
	455	}
	456	}
[481]	457
[458]	458	/* delete from database
	459	*/
	460	if (sh.flag.checkSum != SH_CHECK_INIT)
	461	sh_hash_set_missing(ptr->name);
	462	}
	463	else
	464	{
	465	if (tmp == NULL)
	466	tmp = sh_util_safe_name (ptr->name);
	467	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, 0,
	468	MSG_FI_FAIL,
	469	tmp);
	470	if (sh.flag.checkSum != SH_CHECK_INIT)
	471	sh_hash_set_visited_true(ptr->name);
	472	}
	473	}
	474
	475	++fcount;
	476	}
	477	if (!tmp_in)
	478	SH_FREE(tmp);
	479
	480	return fcount;
	481	}
	482
	483
[1]	484	unsigned long sh_files_chk ()
	485	{
	486	zAVLCursor cursor;
	487	ShFileType status;
	488	unsigned long fcount = 0;
	489
	490	char * tmp = NULL;
	491
	492	dirstack_t * ptr;
[34]	493	char * dir;
[1]	494	char * file;
[46]	495	int tmp_reported;
[1]	496
	497	SL_ENTER(_("sh_files_chk"));
	498
	499	for (ptr = (dirstack_t *) zAVLFirst(&cursor, zfileList); ptr;
	500	ptr = (dirstack_t *) zAVLNext(&cursor))
	501	{
	502
	503	if (sig_urgent > 0) {
	504	SL_RETURN(fcount, _("sh_files_chk"));
	505	}
	506
	507	if (ptr->checked == S_FALSE)
	508	{
[34]	509	dir = sh_util_dirname (ptr->name);
	510	file = sh_util_basename (ptr->name);
[1]	511	#if defined(WITH_TPT)
	512	tmp = sh_util_safe_name (ptr->name);
	513	#endif
	514
	515
[481]	516	if (flag_err_info == S_TRUE)
[1]	517	{
[356]	518	char pstr[32];
[1]	519	#if !defined(WITH_TPT)
	520	tmp = sh_util_safe_name (ptr->name);
	521	#endif
[356]	522	sl_strlcpy(pstr, sh_hash_getpolicy(ptr->class), sizeof(pstr));
[365]	523	sh_error_handle ((-1), FIL__, __LINE__, 0,
	524	MSG_FI_CHK, pstr, tmp);
[1]	525	}
	526
[373]	527	if ((sh.flag.inotify & SH_INOTIFY_INSCAN) != 0)
[367]	528	{
	529	sh_inotify_add_watch_later(ptr->name, &sh_file_watches, NULL,
[481]	530	ptr->class, ptr->check_flags,
[373]	531	SH_INOTIFY_FILE, 0);
[367]	532	}
	533
[1]	534	BREAKEXIT(sh_files_filecheck);
[114]	535	tmp_reported = ptr->is_reported; /* fix aliasing warning */
[481]	536	status = sh_files_filecheck (ptr->class, ptr->check_flags, dir, file,
[46]	537	&tmp_reported, 0);
[114]	538	ptr->is_reported = tmp_reported;
[1]	539
	540	TPT(( 0, FIL__, __LINE__,
	541	_("msg=<filecheck complete: %s> status=<%d> reported=<%d>\n"),
[114]	542	tmp, status, ptr->is_reported));
[1]	543
[458]	544	fcount += handle_filecheck_ret(ptr, tmp, status);
[1]	545
	546	if (tmp != NULL)
	547	{
	548	SH_FREE(tmp);
	549	tmp = NULL;
	550	}
[94]	551	if (file)
	552	SH_FREE(file);
	553	if (dir)
	554	SH_FREE(dir);
[1]	555
	556	ptr->checked = S_TRUE;
	557	}
	558	}
	559
	560	SL_RETURN(fcount, _("sh_files_chk"));
	561	}
	562
[457]	563	static zAVLTree * fileTree = NULL;
	564	static zAVLTree * dirTree = NULL;
	565
	566	static void clear_lists()
	567	{
	568	if (fileTree) {
	569	zAVL_string_reset(fileTree);
	570	fileTree = NULL;
	571	}
	572	if (dirTree) {
	573	zAVL_string_reset(dirTree);
	574	dirTree = NULL;
	575	}
	576	return;
	577	}
	578
	579	static void add_to_filelist(zAVLTree * tree)
	580	{
	581	dirstack_t * ptr;
	582	zAVLCursor avlcursor;
	583
	584	SL_ENTER(_("add_to_filelist"));
	585
	586	SH_MUTEX_LOCK(mutex_zfiles);
	587	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, tree); ptr;
	588	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	589	zAVL_string_set (&fileTree, ptr->name);
	590	SH_MUTEX_UNLOCK(mutex_zfiles);
	591	SL_RET0(_("add_to_filelist"));
	592	}
	593	static void add_to_dirlist(zAVLTree * tree)
	594	{
	595	dirstack_t * ptr;
	596	zAVLCursor avlcursor;
	597
	598	SL_ENTER(_("add_to_dirlist"));
	599
	600	SH_MUTEX_LOCK(mutex_zfiles);
	601	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, tree); ptr;
	602	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	603	zAVL_string_set (&dirTree, ptr->name);
	604	SH_MUTEX_UNLOCK(mutex_zfiles);
	605	SL_RET0(_("add_to_dirlist"));
	606	}
	607	char * sh_files_findfile(const char * path)
	608	{
	609	return zAVL_string_get (fileTree, path);
	610	}
[465]	611
[481]	612	void * sh_dummy_621_candidate;
[465]	613
[457]	614	static char * intern_find_morespecific_dir(zAVLTree * tree,
	615	const char * path, size_t * len)
	616	{
	617	dirstack_t * ptr;
	618	zAVLCursor avlcursor;
	619	size_t l_path = strlen(path);
	620	size_t l_name;
	621	char * candidate = NULL;
	622	size_t l_candidate = 0;
	623
	624	if (NULL == tree)
	625	return NULL;
	626
[481]	627	sh_dummy_621_candidate = (void *) &candidate;
[465]	628
[457]	629	SH_MUTEX_LOCK(mutex_zfiles);
	630	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, tree); ptr;
	631	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	632	{
	633	l_name = strlen(ptr->name);
	634	if (l_name <= l_path)
	635	{
	636	if (0 == strncmp(ptr->name, path, l_name))
	637	{
	638	if ((l_name == l_path) \|\| (path[l_name] == '/'))
	639	{
	640	if (!candidate \|\| (l_candidate < l_name))
	641	{
	642	candidate = ptr->name;
	643	l_candidate = l_name;
	644	*len = l_candidate;
	645	}
	646	}
	647	}
	648	}
	649	}
	650	SH_MUTEX_UNLOCK(mutex_zfiles);
	651	return candidate;
	652	}
	653	char * sh_files_find_mostspecific_dir(const char * path)
	654	{
	655	size_t l_one = 0;
	656	size_t l_two = 0;
	657	char * one;
	658	char * two;
	659
	660	one = intern_find_morespecific_dir(zdirListOne, path, &l_one);
	661	two = intern_find_morespecific_dir(zdirListTwo, path, &l_two);
	662
	663	if (l_one > l_two) return one;
	664	else return two;
	665	}
	666
[1]	667	int sh_files_delfilestack ()
	668	{
	669	SL_ENTER(_("sh_files_delfilestack"));
	670
[371]	671	SH_MUTEX_LOCK(mutex_zfiles);
[1]	672	zAVLFreeTree (zfileList, free_dirstack);
	673	zfileList = NULL;
[371]	674	SH_MUTEX_UNLOCK(mutex_zfiles);
[1]	675
	676	SL_RETURN(0, _("sh_files_delfilestack"));
	677	}
	678
	679	int sh_files_setrec_int (zAVLTree * tree)
	680	{
	681	dirstack_t * ptr;
	682	zAVLCursor avlcursor;
	683
	684	SL_ENTER(_("sh_files_setrec"));
	685	if (tree != NULL) {
	686	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, tree); ptr;
	687	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	688	{
	689	if (ptr->rdepth < (-1) \|\| ptr->rdepth > 99)
	690	{
	691	ptr->rdepth = MaxRecursionLevel;
	692	}
[457]	693
	694	if ( (ptr->rdepth == (-1)) &&
	695	(ptr->class == SH_LEVEL_ALLIGNORE) &&
	696	(sh.flag.checkSum != SH_CHECK_INIT))
[1]	697	hash_remove_tree (ptr->name);
	698	}
	699	}
	700	SL_RETURN(0, _("sh_files_setrec"));
	701	}
	702
	703	int sh_files_setrec ()
	704	{
[373]	705	volatile int ret;
	706	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	707	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[457]	708	clear_lists();
	709	add_to_dirlist(zdirListOne);
	710	add_to_dirlist(zdirListTwo);
	711	add_to_filelist(zfileList);
[1]	712	sh_files_setrec_int(zdirListOne);
[373]	713	ret = sh_files_setrec_int(zdirListTwo);
	714	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
	715
	716	return ret;
[1]	717	}
	718
	719	zAVLTree * sh_files_deldirstack_int (zAVLTree * ptr)
	720	{
	721	SL_ENTER(_("sh_files_deldirstack"));
	722
	723	zAVLFreeTree (ptr, free_dirstack);
	724
	725	SL_RETURN(NULL, _("sh_files_deldirstack"));
	726	}
	727
	728	int sh_files_deldirstack ()
	729	{
[373]	730	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	731	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[1]	732	zdirListOne = sh_files_deldirstack_int(zdirListOne);
	733	zdirListTwo = sh_files_deldirstack_int(zdirListTwo);
[373]	734	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
[1]	735	return 0;
	736	}
	737
	738	void sh_files_reset()
	739	{
	740	dirstack_t * ptr;
	741	zAVLCursor avlcursor;
	742
	743	SL_ENTER(_("sh_files_reset"));
	744
[371]	745	SH_MUTEX_LOCK(mutex_zfiles);
[1]	746	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor, zfileList); ptr;
	747	ptr = (dirstack_t *) zAVLNext(&avlcursor))
	748	ptr->checked = 0;
[371]	749	SH_MUTEX_UNLOCK(mutex_zfiles);
[1]	750	SL_RET0(_("sh_files_reset"));
	751	}
	752
	753	void sh_dirs_reset()
	754	{
	755	dirstack_t * ptr;
	756	zAVLCursor avlcursor1;
	757	zAVLCursor avlcursor2;
	758
	759	SL_ENTER(_("sh_dirs_reset"));
	760
[373]	761	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	762	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[1]	763	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor1, zdirListOne); ptr;
	764	ptr = (dirstack_t *) zAVLNext(&avlcursor1))
	765	ptr->checked = 0;
	766
	767	for (ptr = (dirstack_t *) zAVLFirst(&avlcursor2, zdirListTwo); ptr;
	768	ptr = (dirstack_t *) zAVLNext(&avlcursor2))
	769	ptr->checked = 0;
[373]	770	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
[1]	771
	772	SL_RET0(_("sh_dirs_reset"));
	773	}
	774
	775
[22]	776	int sh_files_pushfile_prelink (const char * str_s)
[1]	777	{
	778	return (sh_files_pushfile (SH_LEVEL_PRELINK, str_s));
	779	}
	780
[22]	781	int sh_files_pushfile_user0 (const char * str_s)
[1]	782	{
	783	return (sh_files_pushfile (SH_LEVEL_USER0, str_s));
	784	}
	785
[22]	786	int sh_files_pushfile_user1 (const char * str_s)
[1]	787	{
	788	return (sh_files_pushfile (SH_LEVEL_USER1, str_s));
	789	}
	790
[27]	791	int sh_files_pushfile_user2 (const char * str_s)
	792	{
	793	return (sh_files_pushfile (SH_LEVEL_USER2, str_s));
	794	}
[1]	795
[27]	796	int sh_files_pushfile_user3 (const char * str_s)
	797	{
	798	return (sh_files_pushfile (SH_LEVEL_USER3, str_s));
	799	}
	800
	801	int sh_files_pushfile_user4 (const char * str_s)
	802	{
	803	return (sh_files_pushfile (SH_LEVEL_USER4, str_s));
	804	}
	805
	806
[22]	807	int sh_files_pushfile_ro (const char * str_s)
[1]	808	{
	809	return (sh_files_pushfile (SH_LEVEL_READONLY, str_s));
	810	}
	811
[22]	812	int sh_files_pushfile_attr (const char * str_s)
[1]	813	{
	814	return (sh_files_pushfile (SH_LEVEL_ATTRIBUTES, str_s));
	815	}
	816
[22]	817	int sh_files_pushfile_log (const char * str_s)
[1]	818	{
	819	return (sh_files_pushfile (SH_LEVEL_LOGFILES, str_s));
	820	}
	821
[22]	822	int sh_files_pushfile_glog (const char * str_s)
[1]	823	{
	824	return (sh_files_pushfile (SH_LEVEL_LOGGROW, str_s));
	825	}
	826
[22]	827	int sh_files_pushfile_noig (const char * str_s)
[1]	828	{
	829	return (sh_files_pushfile (SH_LEVEL_NOIGNORE, str_s));
	830	}
	831
[22]	832	int sh_files_pushfile_allig (const char * str_s)
[1]	833	{
	834	return (sh_files_pushfile (SH_LEVEL_ALLIGNORE, str_s));
	835	}
	836
	837
	838	static void sh_files_set_mask (unsigned long * mask,
	839	unsigned long val, int act)
	840	{
	841	SL_ENTER(_("sh_files_set_mask"));
	842
	843	if (act == 0)
	844	(*mask) = val;
	845	else if (act > 0)
	846	(*mask) \|= val;
	847	else
	848	(*mask) &= ~val;
	849
	850	SL_RET0(_("sh_files_set_mask"));
	851	}
	852
	853	/* set mask(class)
	854	*/
[22]	855	static int sh_files_parse_mask (unsigned long * mask, const char * str)
[1]	856	{
	857	int l, i = 0, act = 0, k = 0;
	858	char myword[64];
	859
	860	SL_ENTER(_("sh_files_parse_mask"));
	861
[381]	862	myword[0] = '\0';
	863
[1]	864	if (str == NULL)
	865	{
	866	SL_RETURN ( (-1), _("sh_files_parse_mask"));
	867	}
	868	else
	869	l = sl_strlen(str);
	870
	871	while (i < l) {
[381]	872
[1]	873	if (str[i] == '\0')
	874	break;
[381]	875
[1]	876	if (str[i] == ' ' \|\| str[i] == '\t' \|\| str[i] == ',')
	877	{
	878	++i;
	879	continue;
	880	}
	881
	882	if (str[i] == '+')
	883	{
	884	act = +1; ++i;
[381]	885	myword[0] = '\0';
	886	goto getword;
[1]	887	}
	888	else if (str[i] == '-')
	889	{
	890	act = -1; ++i;
[381]	891	myword[0] = '\0';
	892	goto getword;
[1]	893	}
	894	else /* a word */
	895	{
[381]	896	getword:
[1]	897	k = 0;
	898	while (k < 63 && str[i] != ' ' && str[i] != '\t' && str[i] != ','
	899	&& str[i] != '+' && str[i] != '-' && str[i] != '\0') {
	900	myword[k] = str[i];
	901	++i; ++k;
	902	}
	903	myword[k] = '\0';
	904
[381]	905	if (sl_strlen(myword) == 0)
	906	{
	907	SL_RETURN ( (-1), _("sh_files_parse_mask"));
	908	}
	909
[1]	910	/* checksum */
[381]	911	if (0 == strcmp(myword, _("CHK")))
[1]	912	sh_files_set_mask (mask, MODI_CHK, act);
	913	/* link */
[381]	914	else if (0 == strcmp(myword, _("LNK")))
[1]	915	sh_files_set_mask (mask, MODI_LNK, act);
	916	/* inode */
[381]	917	else if (0 == strcmp(myword, _("RDEV")))
[1]	918	sh_files_set_mask (mask, MODI_RDEV, act);
	919	/* inode */
[381]	920	else if (0 == strcmp(myword, _("INO")))
[1]	921	sh_files_set_mask (mask, MODI_INO, act);
	922	/* user */
[381]	923	else if (0 == strcmp(myword, _("USR")))
[1]	924	sh_files_set_mask (mask, MODI_USR, act);
	925	/* group */
[381]	926	else if (0 == strcmp(myword, _("GRP")))
[1]	927	sh_files_set_mask (mask, MODI_GRP, act);
	928	/* mtime */
[381]	929	else if (0 == strcmp(myword, _("MTM")))
[1]	930	sh_files_set_mask (mask, MODI_MTM, act);
	931	/* ctime */
[381]	932	else if (0 == strcmp(myword, _("CTM")))
[1]	933	sh_files_set_mask (mask, MODI_CTM, act);
	934	/* atime */
[381]	935	else if (0 == strcmp(myword, _("ATM")))
[1]	936	sh_files_set_mask (mask, MODI_ATM, act);
	937	/* size */
[381]	938	else if (0 == strcmp(myword, _("SIZ")))
[1]	939	sh_files_set_mask (mask, MODI_SIZ, act);
	940	/* file mode */
[381]	941	else if (0 == strcmp(myword, _("MOD")))
[1]	942	sh_files_set_mask (mask, MODI_MOD, act);
	943	/* hardlinks */
[381]	944	else if (0 == strcmp(myword, _("HLN")))
[1]	945	sh_files_set_mask (mask, MODI_HLN, act);
[19]	946	/* size may grow */
[381]	947	else if (0 == strcmp(myword, _("SGROW")))
[19]	948	sh_files_set_mask (mask, MODI_SGROW, act);
	949	/* use prelink */
[381]	950	else if (0 == strcmp(myword, _("PRE")))
[19]	951	sh_files_set_mask (mask, MODI_PREL, act);
[167]	952	/* get content */
[381]	953	else if (0 == strcmp(myword, _("TXT")))
[167]	954	sh_files_set_mask (mask, MODI_TXT, act);
[294]	955	/* get content */
[381]	956	else if (0 == strcmp(myword, _("AUDIT")))
[294]	957	sh_files_set_mask (mask, MODI_AUDIT, act);
[381]	958	else
	959	{
	960	SL_RETURN ( (-1), _("sh_files_parse_mask"));
	961	}
	962	act = 0;
	963	myword[0] = '\0';
[1]	964	}
	965	}
	966	SL_RETURN ( (0), _("sh_files_parse_mask"));
	967	}
	968
[22]	969	int sh_files_redef_prelink(const char * str)
[1]	970	{
	971	return (sh_files_parse_mask(&mask_PRELINK, str));
	972	}
[22]	973	int sh_files_redef_user0(const char * str)
[1]	974	{
	975	return (sh_files_parse_mask(&mask_USER0, str));
	976	}
[22]	977	int sh_files_redef_user1(const char * str)
[1]	978	{
	979	return (sh_files_parse_mask(&mask_USER1, str));
	980	}
[27]	981	int sh_files_redef_user2(const char * str)
	982	{
	983	return (sh_files_parse_mask(&mask_USER2, str));
	984	}
	985	int sh_files_redef_user3(const char * str)
	986	{
	987	return (sh_files_parse_mask(&mask_USER3, str));
	988	}
	989	int sh_files_redef_user4(const char * str)
	990	{
	991	return (sh_files_parse_mask(&mask_USER4, str));
	992	}
[22]	993	int sh_files_redef_readonly(const char * str)
[1]	994	{
	995	return (sh_files_parse_mask(&mask_READONLY, str));
	996	}
[22]	997	int sh_files_redef_loggrow(const char * str)
[1]	998	{
	999	return (sh_files_parse_mask(&mask_LOGGROW, str));
	1000	}
[22]	1001	int sh_files_redef_logfiles(const char * str)
[1]	1002	{
	1003	return (sh_files_parse_mask(&mask_LOGFILES, str));
	1004	}
[22]	1005	int sh_files_redef_attributes(const char * str)
[1]	1006	{
	1007	return (sh_files_parse_mask(&mask_ATTRIBUTES, str));
	1008	}
[22]	1009	int sh_files_redef_noignore(const char * str)
[1]	1010	{
	1011	return (sh_files_parse_mask(&mask_NOIGNORE, str));
	1012	}
[22]	1013	int sh_files_redef_allignore(const char * str)
[1]	1014	{
	1015	return (sh_files_parse_mask(&mask_ALLIGNORE, str));
	1016	}
	1017
	1018	unsigned long sh_files_maskof (int class)
	1019	{
	1020	switch (class)
	1021	{
	1022	case SH_LEVEL_READONLY:
[381]	1023	return (unsigned long) (mask_READONLY \| MODI_INIT);
[1]	1024	case SH_LEVEL_ATTRIBUTES:
[381]	1025	return (unsigned long) (mask_ATTRIBUTES \| MODI_INIT);
[1]	1026	case SH_LEVEL_LOGFILES:
[381]	1027	return (unsigned long) (mask_LOGFILES \| MODI_INIT);
[1]	1028	case SH_LEVEL_LOGGROW:
[381]	1029	return (unsigned long) (mask_LOGGROW \| MODI_INIT);
[1]	1030	case SH_LEVEL_ALLIGNORE:
[381]	1031	return (unsigned long) (mask_ALLIGNORE \| MODI_INIT);
[1]	1032	case SH_LEVEL_NOIGNORE:
[381]	1033	return (unsigned long) (mask_NOIGNORE \| MODI_INIT);
[1]	1034	case SH_LEVEL_USER0:
[381]	1035	return (unsigned long) (mask_USER0 \| MODI_INIT);
[1]	1036	case SH_LEVEL_USER1:
[381]	1037	return (unsigned long) (mask_USER1 \| MODI_INIT);
[27]	1038	case SH_LEVEL_USER2:
[381]	1039	return (unsigned long) (mask_USER2 \| MODI_INIT);
[27]	1040	case SH_LEVEL_USER3:
[381]	1041	return (unsigned long) (mask_USER3 \| MODI_INIT);
[27]	1042	case SH_LEVEL_USER4:
[381]	1043	return (unsigned long) (mask_USER4 \| MODI_INIT);
[1]	1044	case SH_LEVEL_PRELINK:
[381]	1045	return (unsigned long) (mask_PRELINK \| MODI_INIT);
[1]	1046	default:
	1047	return (unsigned long) 0;
	1048	}
	1049	}
	1050
	1051	#ifdef HAVE_GLOB_H
	1052	int sh_files_has_metachar (const char * str)
	1053	{
	1054	SL_ENTER(_("sh_files_has_metachar"));
	1055	if (NULL != strchr(str, '*'))
	1056	SL_RETURN(1, _("sh_files_has_metachar"));
	1057	else if (NULL != strchr(str, '?'))
	1058	SL_RETURN(1, _("sh_files_has_metachar"));
	1059	else if (NULL != (strchr(str, '[')))
	1060	SL_RETURN(1, _("sh_files_has_metachar"));
	1061	else
	1062	SL_RETURN(0, _("sh_files_has_metachar"));
	1063	}
	1064
	1065
	1066	int sh_files_globerr (const char * epath, int errnum)
	1067	{
	1068	char * p;
[132]	1069	char errbuf[SH_ERRBUF_SIZE];
[1]	1070
	1071	SL_ENTER(_("sh_files_globerr"));
	1072
[61]	1073	if (errnum == ENOTDIR \|\| errnum == ENOENT)
	1074	{
	1075	SL_RETURN(0, _("sh_files_globerr"));
	1076	}
	1077
[1]	1078	p = sh_util_safe_name (epath);
	1079	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__, errnum, MSG_FI_GLOB,
[132]	1080	sh_error_message (errnum, errbuf, sizeof(errbuf)), p);
[1]	1081	SH_FREE(p);
	1082
	1083	SL_RETURN(0, _("sh_files_globerr"));
	1084	}
	1085
	1086	/* #ifdef HAVE_GLOB_H
	1087	*/
	1088	#endif
	1089
[383]	1090	int sh_files_push_file_int (int class, const char * str_s, size_t len,
[481]	1091	unsigned long check_flags)
[1]	1092	{
	1093	dirstack_t * new_item_ptr;
	1094	char * fileName;
	1095	int ret;
[383]	1096	volatile int count = 0;
[1]	1097
	1098	SL_ENTER(_("sh_files_push_file_int"));
	1099
	1100	fileName = SH_ALLOC(len+1);
	1101	sl_strlcpy(fileName, str_s, len+1);
	1102
	1103	new_item_ptr = (dirstack_t *) SH_ALLOC (sizeof(dirstack_t));
	1104
	1105	new_item_ptr->name = fileName;
	1106	new_item_ptr->class = class;
[481]	1107	new_item_ptr->check_flags = check_flags;
[1]	1108	new_item_ptr->rdepth = 0;
	1109	new_item_ptr->checked = S_FALSE;
[114]	1110	new_item_ptr->is_reported = 0;
[1]	1111	new_item_ptr->childs_checked = S_FALSE;
	1112
[371]	1113	SH_MUTEX_LOCK(mutex_zfiles);
[1]	1114	if (zfileList == NULL)
	1115	{
[363]	1116	zfileList = zAVLAllocTree (zdirstack_key, zAVL_KEY_STRING);
[1]	1117	if (zfileList == NULL)
	1118	{
[22]	1119	(void) safe_logger (0, 0, NULL);
[1]	1120	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1121	}
	1122	}
	1123
	1124	ret = zAVLInsert (zfileList, new_item_ptr);
[371]	1125	SH_MUTEX_UNLOCK(mutex_zfiles);
[1]	1126
	1127	if (-1 == ret)
	1128	{
[22]	1129	(void) safe_logger (0, 0, NULL);
[1]	1130	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1131	}
[371]	1132	else if (3 == ret)
[256]	1133	{
	1134	if (sh.flag.started != S_TRUE)
	1135	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	1136	fileName);
	1137	SH_FREE(fileName);
	1138	SH_FREE(new_item_ptr);
[294]	1139	new_item_ptr = NULL;
[256]	1140	}
[371]	1141	else
[294]	1142	{
[373]	1143	int reported;
[481]	1144	unsigned long check_flags = sh_files_maskof(class);
[373]	1145
	1146	if ((sh.flag.inotify & SH_INOTIFY_INSCAN) != 0)
[371]	1147	{
[481]	1148	sh_files_filecheck (class, check_flags, str_s, NULL,
[373]	1149	&reported, 0);
	1150	if (SH_FFLAG_REPORTED_SET(reported))
	1151	sh_files_set_file_reported(str_s);
	1152	sh_inotify_add_watch_later(str_s, &sh_file_watches, NULL,
[481]	1153	class, check_flags,
[373]	1154	SH_INOTIFY_FILE, 0);
[371]	1155	}
[373]	1156
[481]	1157	if (MODI_AUDIT_ENABLED(check_flags))
[373]	1158	{
	1159	sh_audit_mark(str_s);
	1160	}
	1161	++count;
[294]	1162	}
[373]	1163	SL_RETURN(count, _("sh_files_push_file_int"));
[1]	1164	}
	1165
[481]	1166	int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags);
[1]	1167
[256]	1168	#ifdef HAVE_GLOB_H
	1169
	1170	typedef struct globstack_entry {
	1171	char * name;
	1172	int class;
[481]	1173	unsigned long check_flags;
[256]	1174	int rdepth;
	1175	short type;
	1176	/* struct dirstack_entry * next; */
	1177	} sh_globstack_t;
	1178
	1179	static zAVLTree * zglobList = NULL;
	1180
[373]	1181	static int sh_files_pushglob (int class, int type, const char * p, int rdepth,
[481]	1182	unsigned long check_flags_in, int flag)
[1]	1183	{
	1184	int globstatus = -1;
	1185	unsigned int gloop;
[22]	1186	glob_t pglob;
[371]	1187
[383]	1188	volatile int count = 0;
[481]	1189	volatile unsigned long check_flags = (flag == 0) ? sh_files_maskof(class) : check_flags_in;
[256]	1190
	1191	SL_ENTER(_("sh_files_pushglob"));
	1192
	1193	pglob.gl_offs = 0;
	1194	globstatus = glob (p, 0, sh_files_globerr, &pglob);
	1195
	1196	if (globstatus == 0 && pglob.gl_pathc > 0)
	1197	{
	1198
	1199	if (sh.flag.checkSum != SH_CHECK_INIT)
	1200	{
	1201	sh_globstack_t * new_item_ptr;
	1202	char * fileName;
	1203	int ret;
	1204
[371]	1205	SH_MUTEX_TRYLOCK(mutex_zfiles);
[256]	1206	fileName = sh_util_strdup (p);
	1207
	1208	new_item_ptr = (sh_globstack_t *) SH_ALLOC (sizeof(sh_globstack_t));
	1209
	1210	new_item_ptr->name = fileName;
	1211	new_item_ptr->class = class;
[481]	1212	new_item_ptr->check_flags = check_flags;
[256]	1213	new_item_ptr->rdepth = rdepth;
	1214	new_item_ptr->type = type;
	1215
	1216	if (zglobList == NULL)
	1217	{
[363]	1218	zglobList = zAVLAllocTree (zdirstack_key, zAVL_KEY_STRING);
[256]	1219	if (zglobList == NULL)
	1220	{
	1221	(void) safe_logger (0, 0, NULL);
	1222	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1223	}
	1224	}
	1225
	1226	ret = zAVLInsert (zglobList, new_item_ptr);
	1227
	1228	if (ret != 0) /* already in list */
	1229	{
	1230	SH_FREE(fileName);
	1231	SH_FREE(new_item_ptr);
	1232	}
[371]	1233	SH_MUTEX_TRYLOCK_UNLOCK(mutex_zfiles);
[256]	1234	}
	1235
	1236	for (gloop = 0; gloop < (unsigned int) pglob.gl_pathc; ++gloop)
	1237	{
	1238	if (type == SH_LIST_FILE)
	1239	{
[373]	1240	count += sh_files_push_file_int (class, pglob.gl_pathv[gloop],
[481]	1241	sl_strlen(pglob.gl_pathv[gloop]), check_flags);
[256]	1242	}
	1243	else
	1244	{
	1245	which_dirList = type;
	1246
[373]	1247	count += sh_files_push_dir_int (class, pglob.gl_pathv[gloop],
[481]	1248	sl_strlen(pglob.gl_pathv[gloop]), rdepth, check_flags);
[256]	1249	}
	1250	}
	1251	}
	1252	else
	1253	{
	1254	char * tmp = sh_util_safe_name (p);
	1255
	1256	if (pglob.gl_pathc == 0
	1257	#ifdef GLOB_NOMATCH
	1258	\|\| globstatus == GLOB_NOMATCH
[1]	1259	#endif
[256]	1260	)
	1261	sh_error_handle ((sh.flag.started != S_TRUE) ? SH_ERR_ERR : SH_ERR_NOTICE,
	1262	FIL__, __LINE__,
	1263	globstatus, MSG_FI_GLOB,
	1264	_("No matches found"), tmp);
	1265	#ifdef GLOB_NOSPACE
	1266	else if (globstatus == GLOB_NOSPACE)
	1267	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1268	globstatus, MSG_FI_GLOB,
	1269	_("Out of memory"), tmp);
	1270	#endif
	1271	#ifdef GLOB_ABORTED
	1272	else if (globstatus == GLOB_ABORTED)
	1273	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1274	globstatus, MSG_FI_GLOB,
	1275	_("Read error"), tmp);
	1276	#endif
	1277	else
	1278	sh_error_handle (SH_ERR_ERR, FIL__, __LINE__,
	1279	globstatus, MSG_FI_GLOB,
	1280	_("Unknown error"), tmp);
	1281
	1282	SH_FREE(tmp);
	1283
	1284	}
	1285
	1286	globfree(&pglob);
[373]	1287	SL_RETURN(count, _("sh_files_pushglob"));
	1288	return count;
[256]	1289	}
[1]	1290
[371]	1291	void sh_files_check_globFilePatterns()
	1292	{
	1293	sh_globstack_t * testPattern;
	1294	zAVLCursor cursor;
	1295
	1296	SL_ENTER(_("sh_files_check_globPatterns"));
	1297
	1298	SH_MUTEX_LOCK(mutex_zglob);
	1299	for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
	1300	testPattern;
	1301	testPattern = (sh_globstack_t *) zAVLNext (&cursor))
	1302	{
	1303	if (testPattern->type == SH_LIST_FILE)
	1304	{
	1305	sh_files_pushglob(testPattern->class, testPattern->type,
	1306	testPattern->name, testPattern->rdepth,
[481]	1307	testPattern->check_flags, 1);
[371]	1308	}
	1309	}
	1310	SH_MUTEX_UNLOCK(mutex_zglob);
	1311	SL_RET0(_("sh_files_check_globPatterns"));
	1312	}
	1313
[256]	1314	void sh_files_check_globPatterns()
	1315	{
	1316	sh_globstack_t * testPattern;
	1317	zAVLCursor cursor;
	1318
	1319	SL_ENTER(_("sh_files_check_globPatterns"));
	1320
[371]	1321	SH_MUTEX_LOCK(mutex_zglob);
	1322	for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
	1323	testPattern;
[256]	1324	testPattern = (sh_globstack_t *) zAVLNext (&cursor))
	1325	{
	1326	sh_files_pushglob(testPattern->class, testPattern->type,
[365]	1327	testPattern->name, testPattern->rdepth,
[481]	1328	testPattern->check_flags, 1);
[256]	1329	}
[371]	1330	SH_MUTEX_UNLOCK(mutex_zglob);
[256]	1331	SL_RET0(_("sh_files_check_globPatterns"));
	1332	}
	1333
	1334	/* the destructor
	1335	*/
	1336	void free_globstack (void * inptr)
	1337	{
	1338	sh_globstack_t * here;
	1339
	1340	SL_ENTER(_("free_globstack"));
	1341	if (inptr == NULL)
	1342	SL_RET0(_("free_globstack"));
	1343	else
	1344	here = (sh_globstack_t *) inptr;
	1345
	1346	if (here->name != NULL)
	1347	SH_FREE(here->name);
	1348	SH_FREE(here);
	1349	SL_RET0(_("free_globstack"));
	1350	}
	1351
	1352	int sh_files_delglobstack ()
	1353	{
[365]	1354	SL_ENTER(_("sh_files_delglobstack"));
[256]	1355
[371]	1356	SH_MUTEX_LOCK(mutex_zglob);
[256]	1357	zAVLFreeTree (zglobList, free_globstack);
	1358	zglobList = NULL;
[371]	1359	SH_MUTEX_UNLOCK(mutex_zglob);
[256]	1360
[365]	1361	SL_RETURN(0, _("sh_files_delglobstack"));
[256]	1362	}
	1363
	1364
	1365	#else
	1366	void sh_files_check_globPatterns()
	1367	{
	1368	return;
	1369	}
	1370	int sh_files_delglobstack ()
	1371	{
	1372	return 0;
	1373	}
	1374	#endif
	1375
	1376	static int sh_files_pushfile (int class, const char * str_s)
	1377	{
	1378	size_t len;
	1379	char * tmp;
	1380	char * p;
	1381
[1]	1382	static int reject = 0;
	1383
	1384	SL_ENTER(_("sh_files_pushfile"));
	1385
	1386	if (reject == 1)
	1387	SL_RETURN((-1),_("sh_files_pushfile"));
	1388
	1389	/* if we push a filename from the command line, make sure it
	1390	* is the only one -- and will stay the only one
	1391	*/
[481]	1392	if (sh.flag.opts == S_TRUE)
[1]	1393	{
	1394	sh_files_delfilestack ();
	1395	sh_files_deldirstack ();
[256]	1396	sh_files_delglobstack ();
[1]	1397	reject = 1;
	1398	}
	1399
[481]	1400	p = sh_files_parse_input(str_s, &len);
[286]	1401	if (!p \|\| len == 0)
[310]	1402	SL_RETURN((-1), _("sh_files_pushfile"));
[286]	1403
[1]	1404	if (len >= PATH_MAX)
	1405	{
	1406	/* Name too long
	1407	*/
[286]	1408	tmp = sh_util_safe_name (p);
[1]	1409	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_2LONG,
	1410	tmp);
	1411	SH_FREE(tmp);
	1412	SL_RETURN((-1),_("sh_files_pushfile"));
	1413	}
[286]	1414	else if (p[0] != '/')
[1]	1415	{
	1416	/* Not an absolute path
	1417	*/
[286]	1418	tmp = sh_util_safe_name (p);
[1]	1419	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NOPATH,
	1420	tmp);
	1421	SH_FREE(tmp);
	1422	SL_RETURN((-1),_("sh_files_pushfile"));
	1423	}
	1424	else
	1425	{
	1426	/* remove a terminating '/', take care of the
	1427	* special case of the root directory.
	1428	*/
[22]	1429	if (p[len-1] == '/' && len > 1)
[1]	1430	{
[22]	1431	p[len-1] = '\0';
[1]	1432	--len;
	1433	}
	1434	}
	1435
	1436	#ifdef HAVE_GLOB_H
[22]	1437	if (0 == sh_files_has_metachar(p))
[1]	1438	{
[381]	1439	sh_files_push_file_int (class, p, len, sh_files_maskof(class));
[1]	1440	}
	1441	else
	1442	{
[365]	1443	sh_files_pushglob (class, SH_LIST_FILE, p, 0, 0, 0);
[1]	1444	}
	1445
	1446	#else
[381]	1447	sh_files_push_file_int (class, p, len, sh_files_maskof(class));
[1]	1448	#endif
	1449
[22]	1450	SH_FREE(p);
[1]	1451	SL_RETURN((0),_("sh_files_pushfile"));
	1452	}
	1453
	1454
	1455	/* ------ directories ----- */
	1456
	1457	int sh_files_is_allignore_int (char * str, zAVLTree * tree)
	1458	{
	1459	dirstack_t * ptr;
	1460
	1461	SL_ENTER(_("sh_files_is_allignore"));
	1462
	1463	if (tree)
	1464	{
	1465	ptr = zAVLSearch(tree, str);
	1466	if (ptr)
	1467	{
	1468	if (ptr->class == SH_LEVEL_ALLIGNORE)
	1469	SL_RETURN( 1, _("sh_files_is_allignore"));
	1470	else
	1471	SL_RETURN( 0, _("sh_files_is_allignore"));
	1472	}
	1473	}
	1474	SL_RETURN( 0, _("sh_files_is_allignore"));
	1475	}
	1476
	1477	int sh_files_is_allignore (char * str)
	1478	{
[373]	1479	int retval = 0;
	1480
	1481	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	1482	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
	1483	retval = sh_files_is_allignore_int(str, zdirListOne);
	1484
	1485	if (NULL != zdirListTwo && retval == 0)
	1486	{
	1487	retval = sh_files_is_allignore_int(str, zdirListTwo);
	1488	}
	1489	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
	1490	return retval;
[1]	1491	}
	1492
[481]	1493	void * sh_dummy_1493_ptr;
[371]	1494
[1]	1495	unsigned long sh_dirs_chk (int which)
	1496	{
	1497	zAVLTree * tree;
	1498	zAVLCursor cursor;
	1499	dirstack_t * ptr;
	1500	dirstack_t * dst_ptr;
	1501	int status;
[458]	1502	int tmp_reported;
	1503	volatile int filetype = SH_FILE_UNKNOWN;
[371]	1504	volatile unsigned long dcount = 0;
[1]	1505	char * tmp;
	1506
	1507	SL_ENTER(_("sh_dirs_chk"));
	1508
[481]	1509	sh_dummy_1493_ptr = (void *) &ptr;
[371]	1510
[373]	1511	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	1512	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[1]	1513	if (which == 1)
	1514	tree = zdirListOne;
	1515	else
	1516	tree = zdirListTwo;
	1517
	1518	for (ptr = (dirstack_t *) zAVLFirst(&cursor, tree); ptr;
	1519	ptr = (dirstack_t *) zAVLNext(&cursor))
	1520	{
	1521	if (sig_urgent > 0) {
[373]	1522	goto out;
[1]	1523	}
	1524
	1525	if (ptr->checked == S_FALSE)
	1526	{
[371]	1527	SH_MUTEX_LOCK(mutex_zfiles);
[1]	1528	/* 28 Aug 2001 check the top level directory
	1529	*/
	1530	status = S_FALSE;
	1531	dst_ptr = zAVLSearch(zfileList, ptr->name);
	1532	if (dst_ptr)
	1533	{
	1534	if (dst_ptr->checked == S_FALSE)
	1535	{
	1536	BREAKEXIT(sh_files_filecheck);
[458]	1537	tmp_reported = dst_ptr->is_reported;
[481]	1538	filetype = sh_files_filecheck (dst_ptr->class, dst_ptr->check_flags,
[458]	1539	ptr->name,
	1540	NULL, &tmp_reported, 0);
	1541	dst_ptr->is_reported = tmp_reported;
	1542	(void) handle_filecheck_ret(dst_ptr, NULL, filetype);
	1543
[1]	1544	dst_ptr->checked = S_TRUE;
	1545	status = S_TRUE;
	1546	}
	1547	else
	1548	{
	1549	status = S_TRUE;
	1550	}
	1551	}
[371]	1552	SH_MUTEX_UNLOCK(mutex_zfiles);
[1]	1553
	1554	if (status == S_FALSE)
[458]	1555	{
	1556	tmp_reported = ptr->is_reported;
[481]	1557	filetype = sh_files_filecheck (ptr->class, ptr->check_flags,
[458]	1558	ptr->name, NULL, &tmp_reported, 0);
	1559	ptr->is_reported = tmp_reported;
	1560	(void) handle_filecheck_ret(ptr, NULL, filetype);
	1561	}
[1]	1562
	1563	BREAKEXIT(sh_files_checkdir);
[481]	1564	status = sh_files_checkdir (ptr->class, ptr->check_flags,
[373]	1565	ptr->rdepth, ptr->name,
[1]	1566	ptr->name);
	1567
[114]	1568	if (status < 0 && (!SH_FFLAG_REPORTED_SET(ptr->is_reported)))
[1]	1569	{
	1570	/* directory is missing
	1571	*/
	1572	if (S_FALSE == sh_ignore_chk_del(ptr->name))
	1573	{
	1574	if (0 != hashreport_missing(ptr->name,
	1575	(ptr->class == SH_LEVEL_ALLIGNORE) ?
	1576	ShDFLevel[ptr->class] :
	1577	ShDFLevel[SH_ERR_T_DIR])) {
	1578	tmp = sh_util_safe_name (ptr->name);
	1579	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	1580	ShDFLevel[ptr->class] :
	1581	ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__,
	1582	0, MSG_FI_MISS, tmp);
[405]	1583	++sh.statistics.files_report;
[1]	1584	SH_FREE(tmp);
	1585	}
	1586	}
	1587	if (sh.flag.reportonce == S_TRUE)
[114]	1588	SET_SH_FFLAG_REPORTED(ptr->is_reported);
[1]	1589	}
	1590	else
	1591	{
	1592	/* exists (status >= 0), but was missing (reported == TRUE)
	1593	*/
[114]	1594	if (status >= 0 && SH_FFLAG_REPORTED_SET(ptr->is_reported))
[1]	1595	{
[114]	1596	CLEAR_SH_FFLAG_REPORTED(ptr->is_reported);
[458]	1597	sh_hash_clear_flag(ptr->name, SH_FFLAG_ENOENT);
[1]	1598	#if 0
	1599	/* obsoleted (really?) by the mandatory sh_files_filecheck()
	1600	* above, which will catch missing directories anyway
	1601	*/
	1602	tmp = sh_util_safe_name (ptr->name);
	1603	sh_error_handle ((ptr->class == SH_LEVEL_ALLIGNORE) ?
	1604	ShDFLevel[ptr->class] :
	1605	ShDFLevel[SH_ERR_T_DIR],
	1606	FIL__, __LINE__, 0, MSG_FI_ADD,
	1607	tmp);
[405]	1608	++sh.statistics.files_report;
[1]	1609	SH_FREE(tmp);
	1610	#endif
	1611	}
	1612	else if (status == SH_FILE_UNKNOWN)
	1613	{
	1614	/* catchall
	1615	*/
	1616	tmp = sh_util_safe_name (ptr->name);
	1617	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, 0,
	1618	MSG_FI_FAIL,
	1619	tmp);
	1620	SH_FREE(tmp);
	1621	if (sh.flag.checkSum != SH_CHECK_INIT)
	1622	sh_hash_set_visited_true(ptr->name);
	1623	}
	1624
	1625	++dcount;
	1626	}
[19]	1627	ptr->checked = S_TRUE;
	1628	ptr->childs_checked = S_TRUE;
[1]	1629	}
	1630
	1631	if (sig_urgent > 0) {
[373]	1632	goto out;
[1]	1633	}
	1634
	1635	}
[373]	1636	out:
[377]	1637	; /* 'label at end of compound statement' */
[373]	1638	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
	1639
[1]	1640	SL_RETURN(dcount, _("sh_dirs_chk"));
	1641	}
	1642
[22]	1643	int sh_files_pushdir_prelink (const char * str_s)
[1]	1644	{
	1645	return (sh_files_pushdir (SH_LEVEL_PRELINK, str_s));
	1646	}
	1647
[22]	1648	int sh_files_pushdir_user0 (const char * str_s)
[1]	1649	{
	1650	return (sh_files_pushdir (SH_LEVEL_USER0, str_s));
	1651	}
	1652
[22]	1653	int sh_files_pushdir_user1 (const char * str_s)
[1]	1654	{
	1655	return (sh_files_pushdir (SH_LEVEL_USER1, str_s));
	1656	}
	1657
[27]	1658	int sh_files_pushdir_user2 (const char * str_s)
	1659	{
	1660	return (sh_files_pushdir (SH_LEVEL_USER2, str_s));
	1661	}
	1662
	1663	int sh_files_pushdir_user3 (const char * str_s)
	1664	{
	1665	return (sh_files_pushdir (SH_LEVEL_USER3, str_s));
	1666	}
	1667
	1668	int sh_files_pushdir_user4 (const char * str_s)
	1669	{
	1670	return (sh_files_pushdir (SH_LEVEL_USER4, str_s));
	1671	}
	1672
[22]	1673	int sh_files_pushdir_attr (const char * str_s)
[1]	1674	{
	1675	return (sh_files_pushdir (SH_LEVEL_ATTRIBUTES, str_s));
	1676	}
	1677
[22]	1678	int sh_files_pushdir_ro (const char * str_s)
[1]	1679	{
	1680	return (sh_files_pushdir (SH_LEVEL_READONLY, str_s));
	1681	}
	1682
[22]	1683	int sh_files_pushdir_log (const char * str_s)
[1]	1684	{
	1685	return (sh_files_pushdir (SH_LEVEL_LOGFILES, str_s));
	1686	}
	1687
[22]	1688	int sh_files_pushdir_glog (const char * str_s)
[1]	1689	{
	1690	return (sh_files_pushdir (SH_LEVEL_LOGGROW, str_s));
	1691	}
	1692
[22]	1693	int sh_files_pushdir_noig (const char * str_s)
[1]	1694	{
	1695	return (sh_files_pushdir (SH_LEVEL_NOIGNORE, str_s));
	1696	}
	1697
[22]	1698	int sh_files_pushdir_allig (const char * str_s)
[1]	1699	{
	1700	return (sh_files_pushdir (SH_LEVEL_ALLIGNORE, str_s));
	1701	}
	1702
	1703	int set_dirList (int which)
	1704	{
	1705	if (which == 2)
[256]	1706	which_dirList = SH_LIST_DIR2;
[1]	1707	else
[256]	1708	which_dirList = SH_LIST_DIR1;
[1]	1709	return 0;
	1710	}
	1711
[481]	1712	int sh_files_push_dir_int (int class, char * tail, size_t len, int rdepth, unsigned long check_flags)
[1]	1713	{
	1714	zAVLTree * tree;
	1715	dirstack_t * new_item_ptr;
	1716	char * dirName;
	1717	int ret;
	1718
	1719	SL_ENTER(_("sh_files_push_dir_int"));
	1720
	1721	dirName = SH_ALLOC(len+1);
	1722	sl_strlcpy(dirName, tail, len+1);
	1723
	1724	new_item_ptr = (dirstack_t * ) SH_ALLOC (sizeof(dirstack_t));
	1725
	1726	new_item_ptr->name = dirName;
	1727	new_item_ptr->class = class;
[481]	1728	new_item_ptr->check_flags = check_flags;
[1]	1729	new_item_ptr->rdepth = rdepth;
	1730	new_item_ptr->checked = S_FALSE;
[114]	1731	new_item_ptr->is_reported = 0;
[1]	1732	new_item_ptr->childs_checked = S_FALSE;
	1733
[373]	1734	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	1735	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[256]	1736	if (which_dirList == SH_LIST_DIR1)
[1]	1737	{
	1738	tree = zdirListOne;
	1739	}
	1740	else
	1741	{
	1742	tree = zdirListTwo;
	1743	}
	1744
	1745	if (tree == NULL)
	1746	{
[363]	1747	tree = zAVLAllocTree (zdirstack_key, zAVL_KEY_STRING);
[1]	1748	if (tree == NULL)
	1749	{
[22]	1750	(void) safe_logger (0, 0, NULL);
[1]	1751	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1752	}
[256]	1753	if (which_dirList == SH_LIST_DIR1)
[1]	1754	zdirListOne = tree;
	1755	else
	1756	zdirListTwo = tree;
	1757	}
	1758
	1759	ret = zAVLInsert (tree, new_item_ptr);
[373]	1760	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
[1]	1761
	1762	if (-1 == ret)
	1763	{
[22]	1764	(void) safe_logger (0, 0, NULL);
[1]	1765	aud__exit(FIL__, __LINE__, EXIT_FAILURE);
	1766	}
	1767	if (3 == ret)
[256]	1768	{
	1769	if (sh.flag.started != S_TRUE)
	1770	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	1771	dirName);
	1772	SH_FREE(dirName);
	1773	SH_FREE(new_item_ptr);
[294]	1774	new_item_ptr = NULL;
[256]	1775	}
[373]	1776	else
[294]	1777	{
[481]	1778	if (MODI_AUDIT_ENABLED(check_flags))
[373]	1779	{
	1780	sh_audit_mark(tail);
	1781	}
[294]	1782	}
[1]	1783	SL_RETURN(0, _("sh_files_push_dir_int"));
	1784	}
	1785
[22]	1786	static int sh_files_pushdir (int class, const char * str_s)
[1]	1787	{
	1788	char * tmp;
[34]	1789	size_t len;
[1]	1790	int rdepth = 0;
	1791	char * tail = NULL;
[22]	1792	char * p;
[1]	1793
	1794	SL_ENTER(_("sh_files_pushdir"));
	1795
[481]	1796	if (sh.flag.opts == S_TRUE) {
[1]	1797	sh_files_delfilestack ();
	1798	sh_files_deldirstack ();
[256]	1799	sh_files_delglobstack ();
[1]	1800	}
	1801
[481]	1802	p = sh_files_parse_input(str_s, &len);
	1803	if (!p \|\| len == 0)
[286]	1804	SL_RETURN((-1),_("sh_files_pushdir"));
	1805
[22]	1806	if (p[0] != '/')
[1]	1807	{
[22]	1808	rdepth = strtol(p, &tail, 10);
	1809	if (tail == p)
	1810	{
	1811	SH_FREE(p);
	1812	SL_RETURN((-1), _("sh_files_pushdir"));
	1813	}
[1]	1814	}
	1815	else
[22]	1816	tail = p;
[1]	1817
	1818
[310]	1819	if (tail == p)
	1820	{
	1821	/* Setting to an invalid number will force MaxRecursionLevel,
	1822	* see sh_files_setrec_int()
	1823	*/
	1824	rdepth = (-2);
	1825	}
	1826	else if ( (rdepth < (-1) \|\| rdepth > 99) \|\|
	1827	((rdepth == (-1)) && (class != SH_LEVEL_ALLIGNORE)) )
	1828	{
	1829	SH_FREE(p);
	1830	SL_RETURN((-1), _("sh_files_pushdir"));
	1831	}
[1]	1832
	1833	len = sl_strlen(tail);
	1834
	1835	if (len >= PATH_MAX)
	1836	{
	1837	tmp = sh_util_safe_name (tail);
	1838	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_2LONG,
	1839	tmp);
	1840	SH_FREE(tmp);
[22]	1841	SH_FREE(p);
[1]	1842	SL_RETURN((-1), _("sh_files_pushdir"));
	1843	}
	1844	else if (len < 1)
	1845	{
[22]	1846	SH_FREE(p);
[1]	1847	SL_RETURN((-1), _("sh_files_pushdir"));
	1848	}
	1849	else if (tail[0] != '/')
	1850	{
	1851	tmp = sh_util_safe_name (tail);
	1852	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NOPATH,
	1853	tmp);
	1854	SH_FREE(tmp);
[22]	1855	SH_FREE(p);
[1]	1856	SL_RETURN((-1), _("sh_files_pushdir"));
	1857	}
	1858	else
	1859	{
	1860	if (tail[len-1] == '/' && len > 1)
	1861	{
	1862	tail[len-1] = '\0';
	1863	--len;
	1864	}
	1865	}
	1866
	1867	#ifdef HAVE_GLOB_H
	1868	if (0 == sh_files_has_metachar(tail))
	1869	{
[381]	1870	sh_files_push_dir_int (class, tail, len, rdepth, sh_files_maskof(class));
[1]	1871	}
	1872	else
	1873	{
[365]	1874	sh_files_pushglob (class, which_dirList, tail, rdepth, 0, 0);
[1]	1875	}
	1876	#else
[381]	1877	sh_files_push_dir_int (class, tail, len, rdepth, sh_files_maskof(class));
[1]	1878	#endif
	1879
[22]	1880	SH_FREE(p);
[1]	1881	SL_RETURN((0), _("sh_files_pushdir"));
[34]	1882	}
[1]	1883
[131]	1884	/**
[1]	1885	struct sh_dirent {
	1886	char * sh_d_name;
	1887	struct sh_dirent * next;
	1888	};
[131]	1889	**/
[1]	1890
[131]	1891	void kill_sh_dirlist (struct sh_dirent * dirlist)
[1]	1892	{
	1893	struct sh_dirent * this;
	1894
	1895	while (dirlist)
	1896	{
	1897	this = dirlist->next;
	1898	SH_FREE(dirlist->sh_d_name);
	1899	SH_FREE(dirlist);
	1900	dirlist = this;
	1901	}
	1902	return;
	1903	}
	1904
	1905	/* -- add an entry to a directory listing
	1906	*/
[131]	1907	struct sh_dirent * addto_sh_dirlist (struct dirent * thisEntry,
	1908	struct sh_dirent * dirlist)
[1]	1909	{
	1910	struct sh_dirent * this;
[34]	1911	size_t len;
[1]	1912
	1913	if (thisEntry == NULL)
	1914	return dirlist;
	1915
[34]	1916	len = sl_strlen(thisEntry->d_name);
	1917	if (len == 0)
[1]	1918	return dirlist;
[34]	1919	++len;
[1]	1920
	1921	this = SH_ALLOC(sizeof(struct sh_dirent));
	1922	if (!this)
	1923	return dirlist;
	1924
[34]	1925	this->sh_d_name = SH_ALLOC(len);
	1926	sl_strlcpy(this->sh_d_name, thisEntry->d_name, len);
[1]	1927
	1928	this->next = dirlist;
	1929	return this;
	1930	}
	1931
	1932	static int sh_check_hardlinks = S_TRUE;
	1933
	1934	/* Simply sets our boolean as to whether this check is active
	1935	*/
[22]	1936	int sh_files_check_hardlinks (const char * opt)
[1]	1937	{
	1938	int i;
	1939	SL_ENTER(_("sh_files_check_hardlinks"));
	1940	i = sh_util_flagval(opt, &sh_check_hardlinks);
	1941	SL_RETURN(i, _("sh_files_check_hardlinks"));
	1942	}
	1943
	1944	struct sh_hle_struct {
	1945	long offset;
	1946	char * path;
	1947	struct sh_hle_struct * next;
	1948	};
	1949
	1950	static struct sh_hle_struct * sh_hl_exc = NULL;
	1951
[22]	1952	int sh_files_hle_reg (const char * str)
[1]	1953	{
	1954	long offset;
	1955	size_t len;
	1956	char * path;
	1957
	1958	struct sh_hle_struct * tmp = sh_hl_exc;
	1959
	1960	SL_ENTER(_("sh_files_hle_reg"));
	1961
	1962	/* Free the linked list if called with NULL argument
	1963	*/
	1964	if (str == NULL)
	1965	{
	1966	while (tmp)
	1967	{
	1968	sh_hl_exc = tmp->next;
	1969	SH_FREE(tmp->path);
	1970	SH_FREE(tmp);
	1971	tmp = sh_hl_exc;
	1972	}
	1973	sh_hl_exc = NULL;
	1974	SL_RETURN(0, _("sh_files_hle_reg"));
	1975	}
	1976
	1977	/* We expect 'offset:/path'
	1978	*/
	1979	offset = strtol(str, &path, 0);
	1980	if ((path == NULL) \|\| (path == '\0') \|\| (path != ':') \|\| (path[1] != '/'))
	1981	{
	1982	SL_RETURN(-1, _("sh_files_hle_reg"));
	1983	}
	1984	++path;
	1985	len = 1 + sl_strlen(path);
	1986
	1987	tmp = SH_ALLOC(sizeof(struct sh_hle_struct));
	1988	tmp->path = SH_ALLOC(len);
	1989	sl_strlcpy (tmp->path, path, len);
	1990	tmp->offset = offset;
	1991	tmp->next = sh_hl_exc;
	1992	sh_hl_exc = tmp;
	1993
	1994	SL_RETURN(0, _("sh_files_hle_reg"));
	1995	}
	1996
	1997	#if !defined(HOST_IS_DARWIN)
	1998	static int sh_files_hle_test (int offset, char * path)
	1999	{
	2000	struct sh_hle_struct * tmp = sh_hl_exc;
	2001
	2002	SL_ENTER(_("sh_files_hle_reg"));
	2003
	2004	while(tmp)
	2005	{
	2006	if ((offset == tmp->offset) && (0 == strcmp(path, tmp->path)))
	2007	{
	2008	SL_RETURN(0, _("sh_files_hle_test"));
	2009	}
	2010	tmp = tmp->next;
	2011	}
[440]	2012	#ifdef HAVE_FNMATCH_H
	2013	if ( (offset == 1) && (0 == fnmatch(_("/run/user/*"), path, FNM_PATHNAME)) )
	2014	{
	2015	/* gvfs directory in /run/user/username/ */
	2016	SL_RETURN(0, _("sh_files_hle_test"));
	2017	}
	2018	#endif
	2019
[1]	2020	SL_RETURN(-1, _("sh_files_hle_test"));
	2021	}
	2022	#endif
	2023
[371]	2024	static void * sh_dummy_dirlist;
[383]	2025	static void * sh_dummy_tmpcat;
[371]	2026
[373]	2027	/* -- Check a single directory and its content. Does not
	2028	* check the directory inode itself.
[1]	2029	*/
[481]	2030	int sh_files_checkdir (int iclass, unsigned long check_flags,
[373]	2031	int idepth, char * iname,
	2032	char * relativeName)
[1]	2033	{
[170]	2034	struct sh_dirent * dirlist;
	2035	struct sh_dirent * dirlist_orig;
[1]	2036
	2037	DIR * thisDir = NULL;
	2038	struct dirent * thisEntry;
	2039	int status;
	2040	int dummy = S_FALSE;
[227]	2041	dir_type * theDir;
[1]	2042	ShFileType checkit;
[131]	2043	static unsigned int state = 1;
[1]	2044
[227]	2045	file_type * theFile;
[1]	2046	char * tmpname;
	2047	char * tmpcat;
[132]	2048	char errbuf[SH_ERRBUF_SIZE];
[1]	2049
	2050	int rdepth = 0;
	2051	int class = 0;
[377]	2052	volatile int rdepth_next;
[383]	2053	volatile int class_next;
[371]	2054	volatile int file_class_next;
[481]	2055	volatile unsigned long check_flags_next;
	2056	volatile unsigned long file_check_flags_next;
[1]	2057
[371]	2058	volatile int checked_flag = S_FALSE;
	2059	volatile int cchecked_flag = S_FALSE;
[1]	2060
	2061	dirstack_t * dst_ptr;
[19]	2062	dirstack_t * tmp_ptr;
[1]	2063
	2064	int hardlink_num = 0;
[34]	2065	#if !defined(HOST_IS_DARWIN)
	2066	size_t len;
	2067	#endif
[1]	2068
	2069	SL_ENTER(_("sh_files_checkdir"));
	2070
	2071	if (sig_urgent > 0) {
	2072	SL_RETURN((0), _("sh_files_checkdir"));
	2073	}
	2074
	2075	if (iname == NULL \|\| idepth < (-1))
	2076	SL_RETURN((-1), _("sh_files_checkdir"));
	2077
	2078	if (idepth < 0)
	2079	{
	2080	/* hash_remove_tree (iname); */
	2081	SL_RETURN((0), _("sh_files_checkdir"));
	2082	}
	2083
	2084	rdepth = idepth;
	2085	class = iclass;
	2086
	2087	tmpname = sh_util_safe_name (iname);
	2088
	2089	/* ---- check for obscure name ----
	2090	*/
	2091	if (iclass != SH_LEVEL_ALLIGNORE)
	2092	{
	2093	sh_util_obscurename (ShDFLevel[SH_ERR_T_NAME], iname, S_TRUE);
	2094	}
	2095
[481]	2096	if (flag_err_info == S_TRUE)
[8]	2097	{
[356]	2098	char pstr[32];
	2099
	2100	sl_strlcpy(pstr, sh_hash_getpolicy(iclass), sizeof(pstr));
	2101	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CHK, pstr, tmpname);
[8]	2102	}
	2103
[1]	2104	/* ---- check input ----
	2105	*/
	2106	if ( sl_strlen(iname) >= PATH_MAX)
	2107	{
	2108	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	2109	MSG_FI_2LONG,
	2110	tmpname);
	2111	SH_FREE(tmpname);
	2112	SL_RETURN((-1), _("sh_files_checkdir"));
	2113	}
	2114
	2115	/* ---- check for absolute path ---- */
	2116	if ( iname[0] != '/')
	2117	{
	2118	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	2119	MSG_FI_NOPATH,
	2120	tmpname);
	2121	SH_FREE(tmpname);
	2122	SL_RETURN((-1), _("sh_files_checkdir"));
	2123	}
[365]	2124
[1]	2125	/* ---- stat the directory ----
	2126	*/
[227]	2127	theFile = SH_ALLOC(sizeof(file_type));
	2128	sl_strlcpy (theFile->fullpath, iname, PATH_MAX);
	2129	theFile->attr_string = NULL;
	2130	theFile->link_path = NULL;
[481]	2131	theFile->check_flags = check_flags;
[1]	2132
	2133	(void) relativeName;
	2134	status = sh_unix_getinfo (ShDFLevel[SH_ERR_T_DIR],
	2135	iname,
[227]	2136	theFile, NULL, iclass);
[1]	2137
	2138	if ((sig_termfast == 1) \|\| (sig_terminate == 1))
	2139	{
[227]	2140	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2141	if (theFile->link_path) SH_FREE(theFile->link_path);
	2142	SH_FREE(theFile);
[433]	2143	SH_FREE(tmpname);
[1]	2144	SL_RETURN((0), _("sh_files_checkdir"));
	2145	}
	2146
	2147	if (status == -1)
	2148	{
[227]	2149	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2150	if (theFile->link_path) SH_FREE(theFile->link_path);
	2151	SH_FREE(theFile);
[433]	2152	SH_FREE(tmpname);
[227]	2153	SL_RETURN((-1), _("sh_files_checkdir"));
[1]	2154	}
	2155
[227]	2156	if (theFile->c_mode[0] != 'd')
[1]	2157	{
	2158	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	2159	MSG_FI_NODIR,
	2160	tmpname);
[405]	2161	++sh.statistics.files_nodir;
[227]	2162	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2163	if (theFile->link_path) SH_FREE(theFile->link_path);
	2164	SH_FREE(theFile);
[433]	2165	SH_FREE(tmpname);
[1]	2166	SL_RETURN((-1), _("sh_files_checkdir"));
	2167	}
	2168
[373]	2169	if ((sh.flag.inotify & SH_INOTIFY_INSCAN) != 0)
[372]	2170	{
	2171	sh_inotify_add_watch_later(iname, &sh_file_watches, &status,
[481]	2172	iclass, check_flags, SH_INOTIFY_DIR, idepth);
[372]	2173	}
	2174
[227]	2175	hardlink_num = theFile->hardlinks;
[1]	2176
[227]	2177	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2178	if (theFile->link_path) SH_FREE(theFile->link_path);
	2179	SH_FREE(theFile);
[1]	2180
	2181	/* ---- open directory for reading ----
	2182	*
	2183	* opendir() will fail with ENOTDIR if the path has been changed
	2184	* to a non-directory in between lstat() and opendir().
	2185	*/
	2186	thisDir = opendir (iname);
	2187
	2188	if (thisDir == NULL)
	2189	{
	2190	status = errno;
	2191	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	2192	MSG_E_OPENDIR,
[132]	2193	sh_error_message (status, errbuf, sizeof(errbuf)), tmpname);
[1]	2194	SH_FREE(tmpname);
	2195	SL_RETURN((-1), _("sh_files_checkdir"));
	2196	}
	2197
[227]	2198	theDir = SH_ALLOC(sizeof(dir_type));
[1]	2199
[227]	2200	theDir->NumRegular = 0;
	2201	theDir->NumDirs = 0;
	2202	theDir->NumSymlinks = 0;
	2203	theDir->NumFifos = 0;
	2204	theDir->NumSockets = 0;
	2205	theDir->NumCDev = 0;
	2206	theDir->NumBDev = 0;
	2207	theDir->NumDoor = 0;
	2208	theDir->NumPort = 0;
	2209	theDir->NumAll = 0;
	2210	theDir->TotalBytes = 0;
	2211	sl_strlcpy (theDir->DirPath, iname, PATH_MAX);
[1]	2212
[227]	2213
[383]	2214	sh_dummy_dirlist = (void *) &dirlist;
	2215	sh_dummy_tmpcat = (void *) &tmpcat;
	2216
[1]	2217	/* ---- read ----
	2218	*/
[137]	2219	SH_MUTEX_LOCK(mutex_readdir);
[131]	2220
[170]	2221	dirlist = NULL;
	2222	dirlist_orig = NULL;
	2223
[1]	2224	do {
	2225	thisEntry = readdir (thisDir);
	2226	if (thisEntry != NULL)
	2227	{
[227]	2228	++theDir->NumAll;
[1]	2229	if (sl_strcmp (thisEntry->d_name, ".") == 0)
	2230	{
[227]	2231	++theDir->NumDirs;
[1]	2232	continue;
	2233	}
	2234	if (sl_strcmp (thisEntry->d_name, "..") == 0)
	2235	{
[227]	2236	++theDir->NumDirs;
[1]	2237	continue;
	2238	}
	2239	dirlist = addto_sh_dirlist (thisEntry, dirlist);
	2240	}
	2241	} while (thisEntry != NULL);
	2242
[137]	2243	SH_MUTEX_UNLOCK(mutex_readdir);
[131]	2244
[1]	2245	closedir (thisDir);
	2246
	2247	++sh.statistics.dirs_checked;
	2248
	2249	dirlist_orig = dirlist;
	2250
	2251	do {
	2252
	2253	/* If the directory is empty, dirlist = NULL
	2254	*/
	2255	if (!dirlist)
	2256	break;
	2257
	2258	if (sig_termfast == 1)
	2259	{
[227]	2260	SH_FREE(theDir);
[433]	2261	SH_FREE(tmpname);
[1]	2262	SL_RETURN((0), _("sh_files_checkdir"));
	2263	}
	2264
	2265	BREAKEXIT(sh_derr);
[131]	2266
	2267	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R)
	2268	if (0 == (rand_r(&state) % 5)) (void) sh_derr();
	2269	#else
	2270	if (0 == state * (rand() % 5)) (void) sh_derr();
	2271	#endif
[1]	2272
	2273	/* ---- Check the file. ----
	2274	*/
	2275	tmpcat = SH_ALLOC(PATH_MAX);
	2276	sl_strlcpy(tmpcat, iname, PATH_MAX);
	2277	if (sl_strlen(tmpcat) > 1 \|\| tmpcat[0] != '/')
	2278	sl_strlcat(tmpcat, "/", PATH_MAX);
	2279	sl_strlcat(tmpcat, dirlist->sh_d_name, PATH_MAX);
	2280
	2281	rdepth_next = rdepth - 1;
	2282	class_next = class;
[481]	2283	check_flags_next = check_flags;
[1]	2284	file_class_next = class;
[481]	2285	file_check_flags_next = check_flags;
[1]	2286	checked_flag = -1;
	2287	cchecked_flag = -1;
	2288
	2289	/* Wed Aug 24 2005 compare against dirListOne, dirListTwo
	2290	* this fixes the problem that the directory special file
	2291	* is checked with the policy of the parent directory
	2292	*/
[373]	2293	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	2294	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[1]	2295	dst_ptr = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
	2296
	2297	if (dst_ptr)
	2298	{
	2299	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	2300	* this fixes the problem that a policy for the directory
	2301	* inode erroneously becomes a policy for the directory itself.
	2302	*/
	2303	file_class_next = dst_ptr->class;
[481]	2304	file_check_flags_next = dst_ptr->check_flags;
[1]	2305	checked_flag = dst_ptr->checked;
	2306	cchecked_flag = dst_ptr->childs_checked;
	2307	}
	2308
	2309	if (checked_flag == -1)
	2310	{
	2311	dst_ptr = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
	2312
	2313	if (dst_ptr)
	2314	{
	2315	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	2316	* this fixes the problem that a policy for the directory
	2317	* inode erroneously becomes a policy for the directory itself.
	2318	*/
	2319	file_class_next = dst_ptr->class;
[481]	2320	file_check_flags_next = dst_ptr->check_flags;
[1]	2321	checked_flag = dst_ptr->checked;
	2322	cchecked_flag = dst_ptr->childs_checked;
	2323	}
	2324	}
[373]	2325	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
[1]	2326
[373]	2327	SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
[1]	2328	dst_ptr = (dirstack_t *) zAVLSearch(zfileList, tmpcat);
	2329
	2330	if (dst_ptr)
	2331	{
	2332	/* Tue Aug 6 22:13:27 CEST 2002 introduce file_class_next
	2333	* this fixes the problem that a policy for the directory
	2334	* inode erroneously becomes a policy for the directory itself.
	2335	*/
	2336	file_class_next = dst_ptr->class;
[481]	2337	file_check_flags_next = dst_ptr->check_flags;
[1]	2338	checked_flag = dst_ptr->checked;
[19]	2339	/* not set, hence always FALSE */
	2340	/* cchecked_flag = dst_ptr->childs_checked; */
[373]	2341
	2342	if (checked_flag != S_TRUE)
	2343	{
	2344	/* -- need to check the file itself --
	2345	*/
	2346	if (sh.flag.reportonce == S_TRUE)
	2347	dummy = dst_ptr->is_reported;
	2348	}
[1]	2349	}
[373]	2350	SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
[1]	2351
	2352	/* ---- Has been checked already. ----
	2353	*/
	2354	if (checked_flag == S_TRUE && cchecked_flag == S_TRUE)
	2355	{
	2356	/* Mar 11 2004 get ftype for complete directory count
	2357	*/
	2358	checkit = sh_unix_get_ftype(tmpcat);
	2359	if (checkit == SH_FILE_DIRECTORY)
	2360	{
[227]	2361	++theDir->NumDirs;
[1]	2362	}
	2363	SH_FREE(tmpcat);
	2364	dirlist = dirlist->next;
	2365	continue;
	2366	}
	2367
	2368	/* --- May be true, false, or not found. ---
	2369	*/
	2370	if (checked_flag == S_TRUE)
	2371	{
	2372	/* -- need only the file type --
	2373	*/
	2374	checkit = sh_unix_get_ftype(tmpcat);
	2375	}
	2376	else
	2377	{
	2378	/* -- need to check the file itself --
	2379	*/
[373]	2380	/* -- moved up --
	2381	* if (dst_ptr && sh.flag.reportonce == S_TRUE)
	2382	* dummy = dst_ptr->is_reported;
	2383	*/
[1]	2384
[481]	2385	checkit = sh_files_filecheck (file_class_next, file_check_flags_next,
[1]	2386	iname,
	2387	dirlist->sh_d_name,
	2388	&dummy, 0);
	2389
[373]	2390
	2391	SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
	2392	dst_ptr = (dirstack_t *) zAVLSearch(zfileList, tmpcat);
	2393
[1]	2394	if (dst_ptr && checked_flag == S_FALSE)
	2395	dst_ptr->checked = S_TRUE;
[373]	2396
[1]	2397	/* Thu Mar 7 15:09:40 CET 2002 Propagate the 'reported' flag
	2398	*/
	2399	if (dst_ptr && sh.flag.reportonce == S_TRUE)
[114]	2400	dst_ptr->is_reported = dummy;
[373]	2401
	2402	if (dst_ptr)
	2403	dst_ptr->childs_checked = S_TRUE;
	2404	SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
[1]	2405	}
	2406
	2407	if (checkit == SH_FILE_REGULAR)
[227]	2408	++theDir->NumRegular;
[1]	2409
	2410	else if (checkit == SH_FILE_DIRECTORY)
	2411	{
[227]	2412	++theDir->NumDirs;
[365]	2413
[1]	2414	if (rdepth_next >= 0 && cchecked_flag != S_TRUE)
	2415	{
	2416	rdepth_next = rdepth - 1;
	2417
	2418	/* check whether the new directory is in the
	2419	* list with a recursion depth already defined
	2420	*/
	2421	checked_flag = -1;
	2422	cchecked_flag = -1;
	2423
[373]	2424	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	2425	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[19]	2426	tmp_ptr = (dirstack_t *) zAVLSearch(zdirListOne, tmpcat);
[1]	2427
[19]	2428	if (tmp_ptr)
[1]	2429	{
	2430	TPT((0, FIL__, __LINE__,
	2431	_("msg=<%s -> recursion depth %d\n>"),
[19]	2432	tmp_ptr->name, tmp_ptr->rdepth));
	2433	rdepth_next = tmp_ptr->rdepth;
	2434	class_next = tmp_ptr->class;
[481]	2435	check_flags_next = tmp_ptr->check_flags;
[1]	2436	/* 28. Aug 2001 reversed
	2437	*/
[19]	2438	cchecked_flag = tmp_ptr->childs_checked;
	2439	checked_flag = tmp_ptr->checked;
[1]	2440	}
	2441
	2442	if (checked_flag == -1)
	2443	{
[19]	2444	tmp_ptr = (dirstack_t *) zAVLSearch(zdirListTwo, tmpcat);
[1]	2445
[19]	2446	if (tmp_ptr)
[1]	2447	{
	2448	TPT((0, FIL__, __LINE__,
	2449	_("msg=<%s -> recursion depth %d\n>"),
[19]	2450	tmp_ptr->name, tmp_ptr->rdepth));
	2451	rdepth_next = tmp_ptr->rdepth;
	2452	class_next = tmp_ptr->class;
[481]	2453	check_flags_next = tmp_ptr->check_flags;
[1]	2454	/* 28. Aug 2001 reversed
	2455	*/
[19]	2456	cchecked_flag = tmp_ptr->childs_checked;
	2457	checked_flag = tmp_ptr->checked;
[1]	2458	}
	2459	}
[373]	2460
	2461	if (tmp_ptr && cchecked_flag == S_FALSE)
[1]	2462	{
[19]	2463	tmp_ptr->childs_checked = S_TRUE;
	2464	/*
	2465	* 04. Feb 2006 avoid double checking
	2466	*/
	2467	tmp_ptr->checked = S_TRUE;
[1]	2468	}
[373]	2469	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
	2470
	2471	if (cchecked_flag == S_FALSE)
	2472	{
[481]	2473	sh_files_checkdir (class_next, check_flags_next, rdepth_next,
[373]	2474	tmpcat, dirlist->sh_d_name);
	2475	/*
	2476	tmp_ptr->childs_checked = S_TRUE;
	2477	tmp_ptr->checked = S_TRUE;
	2478	*/
	2479	}
[1]	2480	else if (checked_flag == -1)
[481]	2481	sh_files_checkdir (class_next, check_flags_next, rdepth_next,
[373]	2482	tmpcat, dirlist->sh_d_name);
[1]	2483
	2484	}
	2485	}
	2486
[227]	2487	else if (checkit == SH_FILE_SYMLINK) ++theDir->NumSymlinks;
	2488	else if (checkit == SH_FILE_FIFO) ++theDir->NumFifos;
	2489	else if (checkit == SH_FILE_SOCKET) ++theDir->NumSockets;
	2490	else if (checkit == SH_FILE_CDEV) ++theDir->NumCDev;
	2491	else if (checkit == SH_FILE_BDEV) ++theDir->NumBDev;
	2492	else if (checkit == SH_FILE_DOOR) ++theDir->NumDoor;
	2493	else if (checkit == SH_FILE_PORT) ++theDir->NumPort;
[1]	2494
	2495	SH_FREE(tmpcat);
	2496
	2497	if ((sig_termfast == 1) \|\| (sig_terminate == 1))
	2498	{
[227]	2499	SH_FREE(theDir);
[383]	2500	sh_dummy_dirlist = NULL;
[433]	2501	SH_FREE(tmpname);
[1]	2502	SL_RETURN((0), _("sh_files_checkdir"));
	2503	}
	2504
	2505	dirlist = dirlist->next;
[19]	2506
[373]	2507	/* -- moved up, only affects zfileList anyway
	2508	* if (dst_ptr)
	2509	* dst_ptr->childs_checked = S_TRUE;
	2510	*/
	2511
[1]	2512	} while (dirlist != NULL);
	2513
[481]	2514	if (flag_err_info == S_TRUE)
[1]	2515	{
	2516	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DSUM,
[227]	2517	theDir->NumDirs,
	2518	theDir->NumRegular,
	2519	theDir->NumSymlinks,
	2520	theDir->NumFifos,
	2521	theDir->NumSockets,
	2522	theDir->NumCDev,
	2523	theDir->NumBDev);
[1]	2524	}
	2525
	2526	kill_sh_dirlist (dirlist_orig);
	2527
	2528	#if !defined(HOST_IS_DARWIN)
	2529	/*
	2530	* Hardlink check; not done on MacOS X because of resource forks
	2531	*/
[227]	2532	if ((sh_check_hardlinks == S_TRUE) && (hardlink_num != theDir->NumDirs))
[1]	2533	{
[227]	2534	if (0 != sh_files_hle_test(hardlink_num-theDir->NumDirs, iname))
[1]	2535	{
[34]	2536	len = strlen(tmpname);
	2537	if (sl_ok_adds(len, 256))
	2538	len += 256;
	2539	tmpcat = SH_ALLOC(len);
	2540	sl_snprintf(tmpcat, len,
[1]	2541	_("%s: subdirectory count (%d) != hardlinks (%d)"),
[227]	2542	tmpname, theDir->NumDirs, hardlink_num);
[1]	2543	sh_error_handle (ShDFLevel[SH_ERR_T_DIR], FIL__, __LINE__, 0,
	2544	MSG_E_SUBGEN, tmpcat, _("sh_files_checkdir"));
	2545	SH_FREE(tmpcat);
	2546	}
	2547	}
	2548	#endif
	2549
	2550	SH_FREE(tmpname);
[227]	2551	SH_FREE(theDir);
[1]	2552
[383]	2553	sh_dummy_dirlist = NULL;
	2554
[1]	2555	SL_RETURN((0), _("sh_files_checkdir"));
	2556	}
	2557
[481]	2558	void sh_files_fixup_mask (int class, unsigned long * check_flags)
	2559	{
	2560	if (class == SH_LEVEL_ALLIGNORE)
	2561	MODI_SET((*check_flags), MODI_ALLIGNORE);
	2562	sh_tiger_get_mask_hashtype(check_flags);
	2563	return;
	2564	}
	2565
[1]	2566	int get_the_fd (SL_TICKET ticket);
	2567
[254]	2568	static int sh_use_rsrc = S_FALSE;
[1]	2569
[254]	2570	int sh_files_use_rsrc(const char * str)
	2571	{
	2572	return sh_util_flagval(str, &sh_use_rsrc);
	2573	}
	2574
[365]	2575	static void * sh_dummy_fileName;
	2576	static void * sh_dummy_tmpname;
	2577	static void * sh_dummy_tmpdir;
	2578
[481]	2579	ShFileType sh_files_filecheck (int class, unsigned long check_flags,
[373]	2580	const char * dirName,
	2581	const char * infileName,
[365]	2582	int * reported,
	2583	int rsrcflag)
[1]	2584	{
	2585	/* 28 Aug 2001 allow NULL fileName
	2586	*/
[227]	2587	char * fullpath;
[19]	2588	char fileHash[2*(KEY_LEN + 1)];
[1]	2589	int status;
[227]	2590	file_type * theFile;
[1]	2591	char * tmpdir;
	2592	char * tmpname;
[373]	2593	const char * fileName;
[425]	2594	#if !defined(O_NOATIME)
[1]	2595	struct utimbuf utime_buf;
[425]	2596	#endif
[131]	2597	static unsigned int state = 1;
[227]	2598	char sc;
[1]	2599
	2600	SL_ENTER(_("sh_files_filecheck"));
	2601
[227]	2602	fullpath = SH_ALLOC(PATH_MAX);
	2603	theFile = SH_ALLOC(sizeof(file_type));
	2604
[365]	2605	/* Take the address to keep gcc from putting it into a register.
	2606	* Avoids the 'clobbered by longjmp' warning.
	2607	*/
	2608	sh_dummy_fileName = (void *) &fileName;
	2609	sh_dummy_tmpname = (void *) &tmpname;
	2610	sh_dummy_tmpdir = (void *) &tmpdir;
	2611
[1]	2612	BREAKEXIT(sh_derr);
	2613
[131]	2614	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_RAND_R)
	2615	if (0 == (rand_r(&state) % 2)) (void) sh_derr();
	2616	#else
	2617	if (0 == state * (rand() % 2)) (void) sh_derr();
	2618	#endif
	2619
[34]	2620	if (dirName && infileName && (dirName[0] == '/') && (dirName[1] == '\0')
	2621	&& (infileName[0] == '/') && (infileName[1] == '\0'))
	2622	{
	2623	fileName = NULL;
	2624	}
	2625	else
	2626	{
	2627	fileName = infileName;
	2628	}
	2629
[1]	2630	/* fileName may be NULL if this is a directory
	2631	*/
	2632	if (dirName == NULL /* \|\| fileName == NULL */)
	2633	{
[365]	2634	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2635	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_NULL);
[365]	2636	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[227]	2637	SH_FREE(fullpath);
	2638	SH_FREE(theFile);
[1]	2639	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2640	}
	2641
	2642	if ((fileName != NULL) && (class != SH_LEVEL_ALLIGNORE) &&
	2643	(0 != sh_util_obscurename (ShDFLevel[SH_ERR_T_NAME],
	2644	fileName, S_FALSE)))
	2645	{
	2646	if ((dirName != NULL) && (dirName[0] == '/') && (dirName[1] == '\0'))
	2647	{
	2648	tmpname = sh_util_safe_name (fileName);
[365]	2649	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2650	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, 0,
	2651	MSG_FI_OBSC2,
	2652	"", tmpname);
[365]	2653	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2654	SH_FREE(tmpname);
	2655	}
	2656	else
	2657	{
	2658	tmpdir = sh_util_safe_name (dirName);
	2659	tmpname = sh_util_safe_name (fileName);
[365]	2660	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2661	sh_error_handle (ShDFLevel[SH_ERR_T_NAME], FIL__, __LINE__, 0,
	2662	MSG_FI_OBSC2,
	2663	tmpdir, tmpname);
[365]	2664	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2665	SH_FREE(tmpname);
	2666	SH_FREE(tmpdir);
	2667	}
	2668	}
	2669
	2670	/* sh_files_fullpath accepts NULL fileName
	2671	*/
	2672	if (0 != sh_files_fullpath (dirName, fileName, fullpath))
	2673	{
	2674	tmpdir = sh_util_safe_name (dirName);
	2675	tmpname = sh_util_safe_name (fileName);
[365]	2676	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2677	sh_error_handle (ShDFLevel[SH_ERR_T_FILE], FIL__, __LINE__, 0,
	2678	MSG_FI_2LONG2,
	2679	tmpdir, tmpname);
[365]	2680	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2681	SH_FREE(tmpname);
	2682	SH_FREE(tmpdir);
[227]	2683	SH_FREE(fullpath);
	2684	SH_FREE(theFile);
[1]	2685	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2686	}
	2687
	2688	/* stat the file and determine checksum (if a regular file)
	2689	*/
[227]	2690	sl_strlcpy (theFile->fullpath, fullpath, PATH_MAX);
[481]	2691	theFile->check_flags = check_flags /* sh_files_maskof(class) */;
[227]	2692	theFile->file_reported = (*reported);
	2693	theFile->attr_string = NULL;
	2694	theFile->link_path = NULL;
[1]	2695
	2696	TPT(( 0, FIL__, __LINE__, _("msg=<checking file: %s>\n"), fullpath));
	2697
	2698	status = sh_unix_getinfo ( (class == SH_LEVEL_ALLIGNORE) ?
	2699	ShDFLevel[class] : ShDFLevel[SH_ERR_T_FILE],
	2700	fileName,
[227]	2701	theFile, fileHash, class);
[481]	2702
[1]	2703	if (status != 0)
	2704	{
	2705	TPT(( 0, FIL__, __LINE__, _("msg=<file: %s> status=<%d>\n"),
	2706	fullpath, status));
	2707	if (class == SH_LEVEL_ALLIGNORE && sh.flag.checkSum != SH_CHECK_INIT)
[68]	2708	sh_hash_set_visited_true (fullpath);
[227]	2709	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2710	if (theFile->link_path) SH_FREE(theFile->link_path);
	2711	SH_FREE(fullpath);
	2712	SH_FREE(theFile);
[1]	2713	SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2714	}
	2715
	2716	if (sig_termfast == 1) {
	2717	goto ret_point;
	2718	}
	2719
	2720	/* report
	2721	*/
[481]	2722	if ((flag_err_debug == S_TRUE) && (theFile->c_mode[0] == '-'))
[1]	2723	{
	2724	tmpname = sh_util_safe_name (fullpath); /* fixed in 1.5.4 */
[365]	2725	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	2726	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CSUM,
	2727	fileHash, tmpname);
[365]	2728	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[1]	2729	SH_FREE(tmpname);
	2730	}
	2731	++sh.statistics.files_checked;
	2732
[481]	2733	if ( sh.flag.checkSum == SH_CHECK_INIT)
[1]	2734	{
[481]	2735	if (class == SH_LEVEL_ALLIGNORE)
	2736	MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
	2737	if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
	2738	MODI_SET(theFile->check_flags, MODI_NOCHECK);
	2739	sh_tiger_get_mask_hashtype(&(theFile->check_flags));
	2740	sh_dbIO_data_write (theFile, fileHash);
[1]	2741	}
	2742	else if (sh.flag.checkSum == SH_CHECK_CHECK
	2743	/* && theFile.c_mode[0] == '-' */
	2744	/* && class != SH_LEVEL_ALLIGNORE */
	2745	)
	2746	{
[481]	2747	if (sh.flag.update == S_TRUE)
	2748	{
	2749	if (class == SH_LEVEL_ALLIGNORE)
	2750	MODI_SET(theFile->check_flags, MODI_ALLIGNORE);
	2751	if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
	2752	MODI_SET(theFile->check_flags, MODI_NOCHECK);
	2753	sh_tiger_get_mask_hashtype(&(theFile->check_flags));
	2754	}
[227]	2755	sh_hash_compdata (class, theFile, fileHash, NULL, -1);
[1]	2756	}
	2757
[227]	2758	(*reported) = theFile->file_reported;
[1]	2759
	2760	/* reset the access time
	2761	*/
[425]	2762	#if !defined(O_NOATIME)
[481]	2763	if (class == SH_LEVEL_NOIGNORE && (theFile->check_flags & MODI_ATM) != 0)
[1]	2764	{
[227]	2765	utime_buf.actime = (time_t) theFile->atime;
	2766	utime_buf.modtime = (time_t) theFile->mtime;
[425]	2767
[1]	2768	retry_aud_utime (FIL__, __LINE__, fullpath, &utime_buf);
[425]	2769	}
[1]	2770	#endif
	2771
[254]	2772	#if defined(HOST_IS_DARWIN)
[1]	2773	/*
	2774	* Check for resource fork
	2775	*/
[254]	2776	if ( (sh_use_rsrc == S_TRUE) && (theFile->c_mode[0] != 'd') && (rsrcflag == 0) )
[1]	2777	{
	2778	int dummy;
	2779	static int rsrc_init = 0;
	2780	static char rsrc[17];
[242]	2781	char * testpath = SH_ALLOC(PATH_MAX);
[1]	2782
	2783	if (rsrc_init == 0) {
	2784	sl_strlcpy(rsrc, _("..namedfork/rsrc"), 17);
	2785	rsrc_init = 1;
	2786	}
	2787	sl_strlcpy (testpath, fullpath, PATH_MAX);
	2788	sl_strlcat (testpath, "/", PATH_MAX);
	2789	sl_strlcat (testpath, rsrc, PATH_MAX);
	2790
	2791	if (sl_strlen(testpath) == (17 + sl_strlen(fullpath)))
	2792	{
[78]	2793	if (S_TRUE == sh_unix_file_exists (testpath))
[1]	2794	{
[481]	2795	sh_files_filecheck (class, check_flags, fullpath, rsrc, &dummy, 1);
[1]	2796	}
	2797	}
[227]	2798	SH_FREE(testpath);
[1]	2799	}
	2800	#else
[68]	2801	(void) rsrcflag; /* avoid compiler warning */
[1]	2802	#endif
	2803
	2804	ret_point:
	2805
[227]	2806	sc = theFile->c_mode[0];
[68]	2807
[227]	2808	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	2809	if (theFile->link_path) SH_FREE(theFile->link_path);
	2810	SH_FREE(fullpath);
	2811	SH_FREE(theFile);
	2812
	2813	switch (sc)
[1]	2814	{
	2815	case '-': SL_RETURN(SH_FILE_REGULAR, _("sh_files_filecheck"));
	2816	case 'l': SL_RETURN(SH_FILE_SYMLINK, _("sh_files_filecheck"));
	2817	case 'd': SL_RETURN(SH_FILE_DIRECTORY, _("sh_files_filecheck"));
	2818	case 'c': SL_RETURN(SH_FILE_CDEV, _("sh_files_filecheck"));
	2819	case 'b': SL_RETURN(SH_FILE_BDEV, _("sh_files_filecheck"));
	2820	case '\|': SL_RETURN(SH_FILE_FIFO, _("sh_files_filecheck"));
[40]	2821	case 'D': SL_RETURN(SH_FILE_DOOR, _("sh_files_filecheck"));
	2822	case 'P': SL_RETURN(SH_FILE_PORT, _("sh_files_filecheck"));
[1]	2823	case 's': SL_RETURN(SH_FILE_SOCKET, _("sh_files_filecheck"));
	2824	default: SL_RETURN(SH_FILE_UNKNOWN, _("sh_files_filecheck"));
	2825	}
	2826
	2827	/* notreached */
	2828	}
	2829
	2830	/* concatenate statpath = testdir"/"d_name
	2831	*/
[373]	2832	static int sh_files_fullpath (const char * testdir, const char * d_name,
	2833	char * statpath)
[1]	2834	{
	2835	int llen = 0;
	2836
	2837	SL_ENTER(_("sh_files_fullpath"));
	2838
	2839	if (testdir != NULL)
	2840	{
	2841	if ( (llen = sl_strlen(testdir)) > (PATH_MAX-2) )
	2842	SL_RETURN((-1),_("sh_files_fullpath"));
	2843	sl_strlcpy(statpath, testdir, PATH_MAX - 1);
	2844	}
	2845	if (d_name != NULL)
	2846	{
	2847	if (llen > 1 \|\| statpath[0] != '/')
	2848	sl_strlcat(statpath, "/", PATH_MAX);
	2849	if ((sl_strlen(d_name) + sl_strlen(statpath)) >= PATH_MAX)
	2850	SL_RETURN((-1),_("sh_files_fullpath"));
	2851	sl_strlcat(statpath, d_name, PATH_MAX);
	2852	}
	2853	if (statpath == NULL)
	2854	SL_RETURN((-1),_("sh_files_fullpath"));
	2855	SL_RETURN((0),_("sh_files_fullpath"));
	2856	}
	2857
	2858	/* -----------------------------------
[367]	2859	* Routines required for inotify
	2860	* -----------------------------------
	2861	*/
[373]	2862	int sh_files_search_dir(char * name, int * class,
[481]	2863	unsigned long check_flags, int reported,
[373]	2864	int * rdepth)
	2865	{
[383]	2866	volatile int retval = 0;
[373]	2867	#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
	2868	sh_globstack_t * testPattern;
	2869	zAVLCursor cursor;
	2870	#endif
	2871	dirstack_t * item;
	2872
	2873	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	2874	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
	2875
	2876	item = zAVLSearch(zdirListOne, name);
	2877
	2878	if (item)
	2879	{
[481]	2880	*check_flags = item->check_flags;
[373]	2881	*class = item->class;
	2882	*reported = item->is_reported;
	2883	*rdepth = item->rdepth;
	2884	item->checked = S_FALSE;
	2885	item->childs_checked = S_FALSE;
	2886	item->is_reported = S_FALSE;
	2887	retval = 1;
	2888	goto out;
	2889	}
	2890
	2891	item = zAVLSearch(zdirListTwo, name);
	2892
	2893	if (item)
	2894	{
[481]	2895	*check_flags = item->check_flags;
[373]	2896	*class = item->class;
	2897	*reported = item->is_reported;
	2898	*rdepth = item->rdepth;
	2899	item->checked = S_FALSE;
	2900	item->childs_checked = S_FALSE;
	2901	item->is_reported = S_FALSE;
	2902	retval = 1;
	2903	goto out;
	2904	}
	2905
	2906	#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
	2907	SH_MUTEX_LOCK(mutex_zglob);
	2908	for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
	2909	testPattern;
	2910	testPattern = (sh_globstack_t *) zAVLNext (&cursor))
	2911	{
	2912	if (testPattern->type == SH_LIST_DIR1 \|\|
	2913	testPattern->type == SH_LIST_DIR2)
	2914	{
	2915	if (0 == fnmatch(testPattern->name, name, FNM_PATHNAME\|FNM_PERIOD))
	2916	{
[481]	2917	*check_flags = testPattern->check_flags;
[373]	2918	*class = testPattern->class;
	2919	*rdepth = testPattern->rdepth;
	2920	retval = 1;
	2921	break;
	2922	}
	2923
	2924	}
	2925	}
	2926	SH_MUTEX_UNLOCK(mutex_zglob);
	2927	#endif
	2928	out:
[377]	2929	; /* 'label at end of compound statement' */
[373]	2930	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
	2931	return retval;
	2932	}
	2933
[371]	2934	int sh_files_search_file(char * name, int * class,
[481]	2935	unsigned long check_flags, int reported)
[367]	2936	{
[383]	2937	volatile int retval = 0;
[371]	2938	#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
	2939	sh_globstack_t * testPattern;
	2940	zAVLCursor cursor;
	2941	#endif
	2942	dirstack_t * item;
[367]	2943
[371]	2944	SH_MUTEX_LOCK(mutex_zfiles);
	2945	item = zAVLSearch(zfileList, name);
	2946
[367]	2947	if (item)
	2948	{
[481]	2949	*check_flags = item->check_flags;
[367]	2950	*class = item->class;
	2951	*reported = item->is_reported;
[371]	2952	retval = 1;
[367]	2953	}
[397]	2954	SH_MUTEX_UNLOCK(mutex_zfiles);
[371]	2955
	2956	#if defined(HAVE_GLOB_H) && defined(HAVE_FNMATCH_H)
[397]	2957	if (retval == 0)
[371]	2958	{
[397]	2959	SH_MUTEX_LOCK(mutex_zglob);
	2960	for (testPattern = (sh_globstack_t *) zAVLFirst (&cursor, zglobList);
	2961	testPattern;
	2962	testPattern = (sh_globstack_t *) zAVLNext (&cursor))
[371]	2963	{
[397]	2964	if (testPattern->type == SH_LIST_FILE)
[371]	2965	{
[397]	2966	if (0 == fnmatch(testPattern->name, name,
	2967	FNM_PATHNAME\|FNM_PERIOD))
	2968	{
[481]	2969	*check_flags = testPattern->check_flags;
[397]	2970	*class = testPattern->class;
	2971	retval = 1;
	2972	break;
	2973	}
	2974
[371]	2975	}
	2976	}
[397]	2977	SH_MUTEX_UNLOCK(mutex_zglob);
[371]	2978	}
	2979	#endif
[397]	2980
[371]	2981	return retval;
[367]	2982	}
	2983
[373]	2984	void sh_files_set_file_reported(const char * name)
[367]	2985	{
[371]	2986	dirstack_t * item;
[367]	2987
[371]	2988	SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
	2989	item = zAVLSearch(zfileList, name);
	2990
[367]	2991	if (item)
	2992	{
	2993	if (sh.flag.reportonce == S_TRUE)
	2994	SET_SH_FFLAG_REPORTED(item->is_reported);
	2995	}
[371]	2996	SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
[367]	2997	return;
	2998	}
	2999
[373]	3000	void sh_files_clear_file_reported(const char * name)
[367]	3001	{
[371]	3002	dirstack_t * item;
[367]	3003
[371]	3004	SH_MUTEX_LOCK_UNSAFE(mutex_zfiles);
	3005	item = zAVLSearch(zfileList, name);
	3006
[367]	3007	if (item)
	3008	{
	3009	CLEAR_SH_FFLAG_REPORTED(item->is_reported);
	3010	}
[371]	3011	SH_MUTEX_UNLOCK_UNSAFE(mutex_zfiles);
[367]	3012	return;
	3013	}
	3014
	3015	/* -----------------------------------
[1]	3016	*
	3017	* The following two routines serve to
	3018	* verify that the user has selected
	3019	* a proper setup for file policies.
	3020	*
	3021	* -----------------------------------
	3022	*/
	3023	static int check_file(char * name)
	3024	{
	3025	dirstack_t * pfilL;
	3026	zAVLCursor cursor;
[371]	3027	volatile int retval = -1;
[1]	3028
	3029	SL_ENTER(_("check_file"));
	3030
	3031	if (SH_FILE_DIRECTORY == sh_unix_get_ftype(name))
	3032	SL_RETURN(0, _("check_file"));
	3033
	3034	for (pfilL = (dirstack_t *) zAVLFirst (&cursor, zfileList); pfilL;
	3035	pfilL = (dirstack_t *) zAVLNext (&cursor))
	3036	{
	3037	if (0 == strcmp(name, pfilL->name) &&
[481]	3038	(pfilL->check_flags & MODI_ATM) == 0 &&
	3039	(pfilL->check_flags & MODI_CTM) == 0 &&
	3040	(pfilL->check_flags & MODI_MTM) == 0)
[371]	3041	{
	3042	retval = 0;
	3043	break;
	3044	}
[1]	3045	}
[371]	3046
	3047	SL_RETURN(retval, _("check_file"));
[1]	3048	}
[371]	3049
	3050	static void * sh_dummy_pdirL;
	3051
[1]	3052	int sh_files_test_setup_int (zAVLTree * tree)
	3053	{
	3054	int dlen, flen;
	3055	zAVLCursor cursor1;
	3056	zAVLCursor cursor2;
	3057
	3058	dirstack_t * pdirL;
	3059	dirstack_t * pfilL;
	3060
	3061	SL_ENTER(_("sh_files_test_setup"));
	3062
[371]	3063	sh_dummy_pdirL = (void *) &pdirL;
	3064
[1]	3065	for (pdirL = (dirstack_t *) zAVLFirst (&cursor1, tree); pdirL;
	3066	pdirL = (dirstack_t *) zAVLNext (&cursor1))
	3067	{
	3068	dlen = strlen(pdirL->name);
	3069
[371]	3070	SH_MUTEX_LOCK(mutex_zfiles);
[1]	3071	for (pfilL = (dirstack_t *) zAVLFirst (&cursor2, zfileList); pfilL;
	3072	pfilL = (dirstack_t *) zAVLNext (&cursor2))
	3073	{
	3074	flen = strlen(pfilL->name);
	3075
	3076	/* check whether file is in tree of dir
	3077	*/
	3078	if ((pfilL->class == SH_LEVEL_READONLY) \|\|
	3079	(pfilL->class == SH_LEVEL_NOIGNORE))
	3080	{
	3081	; /* do nothing */
	3082	}
	3083	else
	3084	{
	3085	if ((flen > (dlen+1)) &&
	3086	(pfilL->name[dlen] == '/') &&
	3087	(NULL == strchr(&(pfilL->name[dlen+1]), '/')) && /30-5-01/
	3088	(0 == strncmp(pfilL->name, pdirL->name, dlen)))
	3089	{
[481]	3090	if ((pdirL->check_flags & MODI_ATM) != 0 \|\|
	3091	(pdirL->check_flags & MODI_MTM) != 0 \|\|
	3092	(pdirL->check_flags & MODI_CTM) != 0)
[1]	3093	{
	3094	if (check_file (pdirL->name) != 0)
	3095	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_COLL,
	3096	pdirL->name, pfilL->name);
	3097	}
	3098	}
	3099	}
	3100	}
[371]	3101	SH_MUTEX_UNLOCK(mutex_zfiles);
[1]	3102	}
	3103
	3104	SL_RETURN((0), _("sh_files_test_setup"));
	3105	}
	3106
	3107	int sh_files_test_double (zAVLTree * firstList, zAVLTree * secondList)
	3108	{
	3109	int retval = 0;
	3110	zAVLCursor cursor;
	3111	dirstack_t * first;
	3112
	3113	for (first = (dirstack_t *) zAVLFirst (&cursor, firstList); first;
	3114	first = (dirstack_t *) zAVLNext (&cursor))
	3115	{
	3116
	3117	if (NULL != zAVLSearch(secondList, first->name))
	3118	{
	3119	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_DOUBLE,
	3120	first->name);
	3121	retval = 1;
	3122	}
	3123	}
	3124	return retval;
	3125	}
	3126
[170]	3127	extern void aud_exit (const char * file, int line, int fd);
[1]	3128
	3129	int sh_files_test_setup ()
	3130	{
[373]	3131	int retval;
[1]	3132
[373]	3133	SH_MUTEX_RECURSIVE_INIT(mutex_zdirs);
	3134	SH_MUTEX_RECURSIVE_LOCK(mutex_zdirs);
[1]	3135	/* Test for modifications allowed in ReadOnly directory
	3136	*/
	3137	sh_files_test_setup_int (zdirListOne);
	3138	sh_files_test_setup_int (zdirListTwo);
	3139
	3140	/* Test for files/dirz defined twice
	3141	*/
	3142	retval = sh_files_test_double (zdirListOne, zdirListTwo);
	3143	if (retval != 0)
	3144	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	3145
	3146	retval = sh_files_test_double (zdirListTwo, zdirListOne);
	3147	if (retval != 0)
	3148	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
[373]	3149	SH_MUTEX_RECURSIVE_UNLOCK(mutex_zdirs);
[1]	3150
	3151	return 0;
	3152	}
	3153
	3154	#endif
[286]	3155
	3156	#ifdef SH_CUTEST
	3157	#include "CuTest.h"
	3158
[457]	3159	void Test_file_lists (CuTest *tc)
	3160	{
	3161	#if (defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE))
	3162
	3163	extern int hash_remove_tree_test(char * s, char * fullpath, size_t len_s);
	3164
	3165	char * test;
	3166	int ret;
	3167
	3168	sh_files_pushfile_ro("/usr/test");
	3169	sh_files_pushfile_ro("/usr/bin/test");
	3170	sh_files_pushfile_ro("/usr/bin/foo/test");
	3171
	3172	sh_files_pushdir_ro("/usr");
	3173	sh_files_pushdir_attr("/usr/bin");
	3174	sh_files_pushdir_ro("/usr/bin/foo");
	3175
	3176	add_to_dirlist(zdirListOne);
	3177	add_to_dirlist(zdirListTwo);
	3178	add_to_filelist(zfileList);
	3179
	3180	test = sh_files_findfile("/usr/tes");
	3181	CuAssertTrue(tc, test == NULL);
	3182	test = sh_files_findfile("/usr/test");
	3183	CuAssertPtrNotNull(tc, test);
	3184	test = sh_files_findfile("/usr/testi");
	3185	CuAssertTrue(tc, test == NULL);
	3186	test = sh_files_findfile("/test");
	3187	CuAssertTrue(tc, test == NULL);
	3188
	3189	test = sh_files_find_mostspecific_dir("/usr/bin/foo/test");
	3190	CuAssertStrEquals(tc, "/usr/bin/foo", test);
	3191	test = sh_files_find_mostspecific_dir("/usr/bin/test");
	3192	CuAssertStrEquals(tc, "/usr/bin", test);
	3193	test = sh_files_find_mostspecific_dir("/usr/test");
	3194	CuAssertStrEquals(tc, "/usr", test);
	3195	test = sh_files_find_mostspecific_dir("/test");
	3196	CuAssertTrue(tc, test == NULL);
	3197	test = sh_files_find_mostspecific_dir("/usr/foo/test");
	3198	CuAssertStrEquals(tc, "/usr", test);
	3199
	3200	test = sh_files_find_mostspecific_dir("/usr/bin");
	3201	CuAssertStrEquals(tc, "/usr/bin", test);
	3202
	3203	ret = hash_remove_tree_test("/usr", "/usr/test", strlen("/usr"));
	3204	CuAssertIntEquals(tc, S_FALSE, ret);
	3205	ret = hash_remove_tree_test("/usr", "/usr/testi", strlen("/usr"));
	3206	CuAssertIntEquals(tc, S_TRUE, ret);
	3207	ret = hash_remove_tree_test("/usr", "/usr/tes", strlen("/usr"));
	3208	CuAssertIntEquals(tc, S_TRUE, ret);
	3209
	3210	ret = hash_remove_tree_test("/usr/bin", "/usr/test", strlen("/usr/bin"));
	3211	CuAssertIntEquals(tc, S_FALSE, ret);
	3212	ret = hash_remove_tree_test("/usr/bin", "/usr/testi", strlen("/usr/bin"));
	3213	CuAssertIntEquals(tc, S_FALSE, ret);
	3214	ret = hash_remove_tree_test("/usr/bin", "/usr/tes", strlen("/usr/bin"));
	3215	CuAssertIntEquals(tc, S_FALSE, ret);
	3216
	3217	ret = hash_remove_tree_test("/usr/bin", "/usr/bin/test", strlen("/usr/bin"));
	3218	CuAssertIntEquals(tc, S_FALSE, ret);
	3219	ret = hash_remove_tree_test("/usr/bin", "/usr/bin/testi", strlen("/usr/bin"));
	3220	CuAssertIntEquals(tc, S_TRUE, ret);
	3221	ret = hash_remove_tree_test("/usr/bin", "/usr/bin/tes", strlen("/usr/bin"));
	3222	CuAssertIntEquals(tc, S_TRUE, ret);
	3223
	3224	ret = hash_remove_tree_test("/usr/bin", "/usr/bin", strlen("/usr/bin"));
	3225	CuAssertIntEquals(tc, S_TRUE, ret);
	3226	ret = hash_remove_tree_test("/usr", "/usr", strlen("/usr"));
	3227	CuAssertIntEquals(tc, S_TRUE, ret);
	3228	ret = hash_remove_tree_test("/usr", "/usrbin", strlen("/usr"));
	3229	CuAssertIntEquals(tc, S_FALSE, ret);
	3230	ret = hash_remove_tree_test("/", "/usrbin", strlen("/"));
	3231	CuAssertIntEquals(tc, S_TRUE, ret);
	3232	ret = hash_remove_tree_test("/", "/usr", strlen("/"));
	3233	CuAssertIntEquals(tc, S_FALSE, ret);
	3234
	3235	#else
	3236	(void) tc; /* fix compiler warning */
	3237	return;
	3238	#endif
	3239	}
	3240
[286]	3241	void Test_file_dequote (CuTest *tc)
	3242	{
	3243	#if (defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE))
	3244
	3245	char str1[] = "1234567890";
	3246	char str1a[] = "123456\\\"789\\r";
	3247	char str1b[] = "12345678\\r9";
	3248	char str1c[] = "12345678\\x0a_9";
	3249	char str1d[] = "12345678\\007_9";
	3250	char str1e[] = "123456789\\\\";
	3251
	3252	char str2[] = "1234567890\\xw";
	3253	char str3[] = "1234567890\\xw99";
	3254	char str4[] = "1234567890\\0ww";
	3255	char str5[] = "12345\\g67890";
	3256	char str6[] = "1234567890\\009a";
	3257
	3258	char s, p, *q;
	3259	size_t lo, lr;
	3260
	3261	s = SH_ALLOC(64); sl_strlcpy(s, str1, 64); p = s; lo = strlen(s); lr = lo;
	3262	q = sh_files_C_dequote(s, &lr);
	3263	CuAssertPtrNotNull(tc, q);
	3264	CuAssertTrue(tc, p == q);
	3265	CuAssertTrue(tc, lr == lo);
	3266
	3267	s = SH_ALLOC(64); sl_strlcpy(s, str1a, 64); p = s; lo = strlen(s); lr = lo;
	3268	q = sh_files_C_dequote(s, &lr);
	3269	CuAssertPtrNotNull(tc, q);
	3270	CuAssertTrue(tc, p != q);
	3271	CuAssertTrue(tc, 0 == strcmp(q, "123456\"789\r"));
	3272	CuAssertTrue(tc, lr == (lo-2));
	3273
	3274	s = SH_ALLOC(64); sl_strlcpy(s, str1b, 64); p = s; lo = strlen(s); lr = lo;
	3275	q = sh_files_C_dequote(s, &lr);
	3276	CuAssertPtrNotNull(tc, q);
	3277	CuAssertTrue(tc, p != q);
	3278	CuAssertTrue(tc, 0 == strcmp(q, "12345678\r9"));
	3279	CuAssertTrue(tc, lr == (lo-1));
	3280
	3281	s = SH_ALLOC(64); sl_strlcpy(s, str1c, 64); p = s; lo = strlen(s); lr = lo;
	3282	q = sh_files_C_dequote(s, &lr);
	3283	CuAssertPtrNotNull(tc, q);
	3284	CuAssertTrue(tc, p != q);
	3285	CuAssertTrue(tc, 0 == strcmp(q, "12345678\x0a_9"));
	3286	CuAssertTrue(tc, lr == (lo-3));
	3287
	3288	s = SH_ALLOC(64); sl_strlcpy(s, str1d, 64); p = s; lo = strlen(s); lr = lo;
	3289	q = sh_files_C_dequote(s, &lr);
	3290	CuAssertPtrNotNull(tc, q);
	3291	CuAssertTrue(tc, p != q);
	3292	CuAssertTrue(tc, 0 == strcmp(q, "12345678\007_9"));
	3293	CuAssertTrue(tc, lr == (lo-3));
	3294
	3295	s = SH_ALLOC(64); sl_strlcpy(s, str1e, 64); p = s; lo = strlen(s); lr = lo;
	3296	q = sh_files_C_dequote(s, &lr);
	3297	CuAssertPtrNotNull(tc, q);
	3298	CuAssertTrue(tc, p != q);
	3299	CuAssertTrue(tc, 0 == strcmp(q, "123456789\\"));
	3300	CuAssertTrue(tc, lr == (lo-1));
	3301
	3302	s = SH_ALLOC(64); sl_strlcpy(s, str2, 64); p = s; lo = strlen(s); lr = lo;
	3303	q = sh_files_C_dequote(s, &lr);
	3304	CuAssertTrue(tc, q == NULL);
	3305	CuAssertTrue(tc, lr == 0);
	3306
	3307	s = SH_ALLOC(64); sl_strlcpy(s, str3, 64); p = s; lo = strlen(s); lr = lo;
	3308	q = sh_files_C_dequote(s, &lr);
	3309	CuAssertTrue(tc, q == NULL);
	3310	CuAssertTrue(tc, lr == 0);
	3311
	3312	s = SH_ALLOC(64); sl_strlcpy(s, str4, 64); p = s; lo = strlen(s); lr = lo;
	3313	q = sh_files_C_dequote(s, &lr);
	3314	CuAssertTrue(tc, q == NULL);
	3315	CuAssertTrue(tc, lr == 0);
	3316
	3317	s = SH_ALLOC(64); sl_strlcpy(s, str5, 64); p = s; lo = strlen(s); lr = lo;
	3318	q = sh_files_C_dequote(s, &lr);
	3319	CuAssertTrue(tc, q == NULL);
	3320	CuAssertTrue(tc, lr == 0);
	3321
	3322	s = SH_ALLOC(64); sl_strlcpy(s, str6, 64); p = s; lo = strlen(s); lr = lo;
	3323	q = sh_files_C_dequote(s, &lr);
	3324	CuAssertTrue(tc, q == NULL);
	3325	CuAssertTrue(tc, lr == 0);
	3326
	3327	return;
	3328	#else
	3329	(void) tc; /* fix compiler warning */
	3330	return;
	3331	#endif
	3332	}
	3333	#endif
	3334

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

Download in other formats: