Context Navigation

source: trunk/src/sh_files.c@ 365

Last change on this file since 365 was 365, checked in by katerina, 13 years ago
Fix for ticket #269 (Issue with redefinition of policies).
File size: 65.6 KB

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

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

Download in other formats: