Context Navigation

source: trunk/src/sh_files.c@ 361

Last change on this file since 361 was 356, checked in by katerina, 13 years ago
Patch for ticket #261: show policy for checked files in verbose mode.
File size: 64.1 KB

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

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

Download in other formats: