Context Navigation

source: trunk/src/sh_files.c@ 297

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

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

Download in other formats: