Context Navigation

source: trunk/src/sh_hash.c@ 470

Last change on this file since 470 was 463, checked in by katerina, 10 years ago
Fix for ticket #363 (database load on init when missing file in config).
File size: 106.5 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 1999, 2000, 2001, 2002 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	/* define this if you want version 1.3 style database file */
	23	/* #define OLD_BUG */
	24
	25	/* make sure state changes of a file are always reported, even
	26	* with reportonlyonce=true
	27	*/
	28	/* #define REPLACE_OLD // moved to samhain.h */
	29
	30	#include <stdlib.h>
	31	#include <string.h>
	32	#include <stdio.h>
	33	#include <sys/types.h>
	34	#include <sys/stat.h>
	35	#include <unistd.h>
[444]	36	#include <ctype.h>
[1]	37
	38	#ifdef MAJOR_IN_MKDEV
	39	#include <sys/mkdev.h>
	40	#else
	41	#ifdef MAJOR_IN_SYSMACROS
	42	#include <sys/sysmacros.h>
	43	#endif
	44	#endif
	45
	46	#ifdef HAVE_MEMORY_H
	47	#include <memory.h>
	48	#endif
	49
	50	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
	51
	52	#include "sh_hash.h"
	53	#include "sh_utils.h"
	54	#include "sh_error.h"
	55	#include "sh_tiger.h"
	56	#include "sh_gpg.h"
	57	#include "sh_unix.h"
	58	#include "sh_files.h"
	59	#include "sh_ignore.h"
[149]	60	#include "sh_pthread.h"
[1]	61
	62	#if defined(SH_WITH_CLIENT)
	63	#include "sh_forward.h"
	64	#endif
	65
[105]	66
	67	#define SH_KEY_NULL _("000000000000000000000000000000000000000000000000")
	68
	69
[1]	70	#undef FIL__
	71	#define FIL__ _("sh_hash.c")
	72
[149]	73	SH_MUTEX_STATIC(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
	74
	75	const char notalink[2] = { '-', '\0' };
	76
[1]	77	static char * all_items (file_type * theFile, char * fileHash, int is_new);
	78
	79	#define QUOTE_CHAR '='
	80
[149]	81	char * unquote_string (const char * str, size_t len)
[1]	82	{
[34]	83	int i = 0, t1, t2;
[8]	84	char * tmp = NULL;
[149]	85	size_t l2, j, k = 0;
[1]	86
	87	SL_ENTER(_("unquote_string"));
	88
[8]	89	if (str != NULL)
[1]	90	{
[8]	91	l2 = len - 2;
	92	tmp = SH_ALLOC(len + 1);
[1]	93
[8]	94	for (j = 0; j <= len; ++j)
[1]	95	{
[8]	96	if (str[j] != QUOTE_CHAR)
[1]	97	{
[8]	98	tmp[k] = str[j];
[1]	99	}
[8]	100	else if (str[j] == QUOTE_CHAR && j < l2)
[1]	101	{
[8]	102	t1 = sh_util_hexchar(str[j+1]);
	103	t2 = sh_util_hexchar(str[j+2]);
	104	if ((t1\|t2) >= 0)
	105	{
	106	i = 16 * t1 + t2;
	107	tmp[k] = i;
	108	j += 2;
	109	}
	110	else
	111	{
	112	tmp[k] = str[j];
	113	}
[1]	114	}
[8]	115	else
	116	tmp[k] = str[j];
	117	++k;
[1]	118	}
	119	}
	120	SL_RETURN(tmp, _("unquote_string"));
	121	}
	122
	123
[149]	124	static char * int2hex (unsigned char i, char * i2h)
[1]	125	{
[34]	126	static char hexchars[] = "0123456789ABCDEF";
[1]	127
[34]	128	i2h[0] = hexchars[(((i) & 0xF0) >> 4)]; /* high */
	129	i2h[1] = hexchars[((i) & 0x0F)]; /* low */
[1]	130
	131	return i2h;
	132	}
	133
[34]	134
[149]	135	char * quote_string (const char * str, size_t len)
[1]	136	{
	137	char * tmp;
	138	char * tmp2;
[149]	139	size_t l2, j, i = 0, k = 0;
	140	char i2h[2];
[1]	141
	142	SL_ENTER(_("quote_string"));
	143
	144	if (str == NULL)
	145	{
	146	SL_RETURN(NULL, _("quote_string"));
	147	}
	148
	149	for (j = 0; j < len; ++j)
	150	if (str[j] == '\n' \|\| str[j] == QUOTE_CHAR) ++i;
	151
[34]	152	l2 = len + 1;
	153	if (sl_ok_muls(3, i) && sl_ok_adds(l2, (3*i)))
	154	{
	155	tmp = SH_ALLOC(len + 1 + 3*i);
	156	}
	157	else
	158	{
	159	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
	160	_("integer overflow"),
	161	_("quote_string"));
	162	SL_RETURN(NULL, _("quote_string"));
	163	}
	164
[1]	165	for (j = 0; j <= len; ++j)
	166	{
	167	if (str[j] == '\n')
	168	{
[149]	169	tmp2 = int2hex((unsigned char) '\n', i2h); /* was 'n', fixed in 1.5.4 */
[1]	170	tmp[k] = QUOTE_CHAR; ++k;
	171	tmp[k] = tmp2[0]; ++k;
	172	tmp[k] = tmp2[1];
	173	}
	174	else if (str[j] == QUOTE_CHAR)
	175	{
[149]	176	tmp2 = int2hex((unsigned char) QUOTE_CHAR, i2h);
[1]	177	tmp[k] = QUOTE_CHAR; ++k;
	178	tmp[k] = tmp2[0]; ++k;
	179	tmp[k] = tmp2[1];
	180	}
	181	else
	182	{
	183	tmp[k] = str[j];
	184	}
	185	++k;
	186	}
	187	SL_RETURN(tmp, _("quote_string"));
	188	}
	189
	190	static UINT32 * swap_32 (UINT32 * iptr)
	191	{
	192	#ifdef WORDS_BIGENDIAN
	193	unsigned char swap;
	194	unsigned char * ii = (unsigned char *) iptr;
	195	swap = ii[0]; ii[0] = ii[3]; ii[3] = swap;
	196	swap = ii[1]; ii[1] = ii[2]; ii[2] = swap;
	197	return iptr;
	198	#else
	199	return iptr;
	200	#endif
	201	}
	202
	203	static UINT64 * swap_64 (UINT64 * iptr)
	204	{
	205	#ifdef WORDS_BIGENDIAN
	206	#ifdef UINT64_IS_32
	207	swap_32 ((UINT32*) iptr);
	208	#else
	209	unsigned char swap;
	210	unsigned char * ii = (unsigned char *) iptr;
	211	swap = ii[0]; ii[0] = ii[7]; ii[7] = swap;
	212	swap = ii[1]; ii[1] = ii[6]; ii[6] = swap;
	213	swap = ii[2]; ii[2] = ii[5]; ii[5] = swap;
	214	swap = ii[3]; ii[3] = ii[4]; ii[4] = swap;
	215	#endif
	216	return iptr;
	217	#else
	218	return iptr;
	219	#endif
	220	}
	221
	222	static unsigned short * swap_short (unsigned short * iptr)
	223	{
	224	#ifdef WORDS_BIGENDIAN
	225	if (sizeof(short) == 4)
	226	swap_32 ((UINT32*) iptr);
	227	else
	228	{
	229	/* alignment problem */
	230	unsigned char swap;
	231	static unsigned short ooop;
	232	unsigned char * ii;
	233	ooop = *iptr;
	234	ii = (unsigned char *) &ooop;
	235	/* printf("SWAP0: %hd %d\n", iptr, sizeof(unsigned short)); /
	236	swap = ii[0]; ii[0] = ii[1]; ii[1] = swap;
	237	/* printf("SWAP1: %hd\n", (unsigned short) ooop); */
	238	#ifndef OLD_BUG
	239	return &ooop;
	240	#endif
	241	}
	242	return iptr;
	243	#else
	244	return iptr;
	245	#endif
	246	}
	247
	248
	249	typedef struct store_info {
[149]	250
[1]	251	UINT32 mode;
	252	UINT32 linkmode;
	253
	254	UINT64 dev;
	255	UINT64 rdev;
	256	UINT32 hardlinks;
	257	UINT32 ino;
	258	UINT64 size;
	259	UINT64 atime;
	260	UINT64 mtime;
	261	UINT64 ctime;
	262	UINT32 owner;
	263	UINT32 group;
	264
	265	#ifdef OLD_BUG
	266	#if defined(__linux__)
	267	UINT32 attributes;
[149]	268	char c_attributes[ATTRBUF_SIZE];
[1]	269	#endif
	270	#else
	271	/* #if defined(__linux__) */
	272	UINT32 attributes;
[149]	273	char c_attributes[ATTRBUF_SIZE];
[1]	274	/* endif */
	275	#endif
	276	unsigned short mark;
	277	char c_owner[USER_MAX+2];
	278	char c_group[GROUP_MAX+2];
[149]	279	char c_mode[CMODE_SIZE];
[1]	280	char checksum[KEY_LEN+1];
	281	} sh_filestore_t;
	282
	283	typedef struct file_info {
	284	sh_filestore_t theFile;
	285	char * fullpath;
	286	char * linkpath;
[68]	287	char * attr_string;
[114]	288	int fflags;
[1]	289	unsigned long modi_mask;
	290	struct file_info * next;
	291	} sh_file_t;
	292
[170]	293	static const char *policy[] = {
[1]	294	N_("[]"),
	295	N_("[ReadOnly]"),
	296	N_("[LogFiles]"),
	297	N_("[GrowingLogs]"),
	298	N_("[IgnoreNone]"),
	299	N_("[IgnoreAll]"),
	300	N_("[Attributes]"),
	301	N_("[User0]"),
	302	N_("[User1]"),
[27]	303	N_("[User2]"),
	304	N_("[User3]"),
	305	N_("[User4]"),
[1]	306	N_("[Prelink]"),
	307	NULL
	308	};
	309
[356]	310	const char * sh_hash_getpolicy(int class)
	311	{
	312	if (class > 0 && class < SH_ERR_T_DIR)
	313	return _(policy[class]);
	314	return _("[indef]");
	315	}
[1]	316
	317	/**********************************
	318	*
	319	* hash table functions
	320	*
	321	**********************************
	322	*/
	323
	324	#include "sh_hash.h"
	325
	326	/* must fit an int */
[8]	327	/* #define TABSIZE 2048 */
	328	#define TABSIZE 65536
[1]	329
	330	/* must fit an unsigned short */
	331	/* changed for V0.8, as the */
	332	/* database format has changed */
	333
	334	/* changed again for V0.9 */
	335	/* #define REC_MAGIC 19 */
	336	/* changed again for V1.3 */
	337	#ifdef OLD_BUG
	338	#define REC_MAGIC 20
	339	#else
	340	/* changed again for V1.4 */
	341	#define REC_MAGIC 21
	342	#endif
	343
[68]	344	#define REC_FLAGS_ATTR (1<<8)
	345	#define REC_FLAGS_MASK 0xFF00
[1]	346
	347	/**************************************************************
	348	*
	349	* create a file_type from a sh_file_t
	350	*
	351	**************************************************************/
	352	static file_type * sh_hash_create_ft (const sh_file_t * p, char * fileHash)
	353	{
	354	file_type * theFile;
	355
	356	SL_ENTER(_("sh_hash_create_ft"));
	357
	358	theFile = SH_ALLOC(sizeof(file_type));
	359
	360	sl_strlcpy(theFile->c_mode, p->theFile.c_mode, 11);
	361	theFile->mode = p->theFile.mode;
[10]	362	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[149]	363	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, ATTRBUF_SIZE);
[1]	364	theFile->attributes = p->theFile.attributes;
	365	#endif
	366
	367	sl_strlcpy(theFile->fullpath, p->fullpath, PATH_MAX);
[167]	368	if (p->linkpath != NULL /* && theFile->c_mode[0] == 'l' */)
[1]	369	{
[167]	370	theFile->link_path = sh_util_strdup(p->linkpath);
[1]	371	}
	372	else
	373	{
[167]	374	theFile->link_path = NULL;
[1]	375	}
	376	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	377
	378	theFile->mtime = p->theFile.mtime;
	379	theFile->ctime = p->theFile.ctime;
	380	theFile->atime = p->theFile.atime;
	381
	382	theFile->size = p->theFile.size;
	383
	384	sl_strlcpy(theFile->c_group, p->theFile.c_group, GROUP_MAX+2);
	385	theFile->group = p->theFile.group;
	386	sl_strlcpy(theFile->c_owner, p->theFile.c_owner, USER_MAX+2);
	387	theFile->owner = p->theFile.owner;
	388
	389	theFile->ino = p->theFile.ino;
	390	theFile->rdev = p->theFile.rdev;
	391	theFile->dev = p->theFile.dev;
	392	theFile->hardlinks = p->theFile.hardlinks;
	393
[68]	394	if (p->attr_string)
	395	theFile->attr_string = sh_util_strdup(p->attr_string);
	396	else
	397	theFile->attr_string = NULL;
	398
[1]	399	SL_RETURN((theFile), _("sh_hash_create_ft"));
	400	}
	401
[305]	402	struct two_sh_file_t {
	403	sh_file_t * prev;
	404	sh_file_t * this;
	405	};
	406
[294]	407	static sh_file_t * hashsearch (const char * s);
[305]	408	static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index);
[1]	409
	410	static sh_file_t * tab[TABSIZE];
	411
	412	/**************************************************************
	413	*
	414	* compute hash function
	415	*
	416	**************************************************************/
[8]	417
[294]	418	static int hashfunc(const char *s)
[1]	419	{
[18]	420	unsigned int n = 0;
[1]	421
	422	for ( ; *s; s++)
	423	n = 31 * n + *s;
[18]	424
	425	return n & (TABSIZE - 1); /* % TABSIZE */;
[1]	426	}
	427
[8]	428
[1]	429	int hashreport_missing( char *fullpath, int level)
	430	{
	431	sh_file_t * p;
	432	char * tmp;
	433	char fileHash[KEY_LEN + 1];
	434	file_type * theFile;
	435	char * str;
[133]	436	char hashbuf[KEYBUF_SIZE];
[367]	437	volatile int retval;
[1]	438
	439	/* -------- find the entry for the file ---------------- */
	440
[149]	441	SH_MUTEX_LOCK(mutex_hash);
	442
[170]	443	retval = 0;
	444
[1]	445	if (sl_strlen(fullpath) <= MAX_PATH_STORE)
	446	p = hashsearch(fullpath);
	447	else
	448	p = hashsearch( sh_tiger_hash(fullpath,
	449	TIGER_DATA,
[133]	450	sl_strlen(fullpath),
	451	hashbuf, sizeof(hashbuf))
[1]	452	);
	453	if (p == NULL)
[149]	454	{
	455	retval = -1;
	456	goto unlock_and_return;
	457	}
[1]	458
	459	theFile = sh_hash_create_ft (p, fileHash);
	460	str = all_items(theFile, fileHash, 0);
	461	tmp = sh_util_safe_name(fullpath);
[367]	462
	463	SH_MUTEX_LOCK(mutex_thread_nolog);
[1]	464	sh_error_handle (level, FIL__, __LINE__, 0,
	465	MSG_FI_MISS2, tmp, str);
[367]	466	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[405]	467	++sh.statistics.files_report;
[362]	468
[1]	469	SH_FREE(tmp);
	470	SH_FREE(str);
[167]	471	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	472	if (theFile->link_path) SH_FREE(theFile->link_path);
[1]	473	SH_FREE(theFile);
[149]	474
	475	unlock_and_return:
[153]	476	; /* 'label at end of compound statement */
[149]	477	SH_MUTEX_UNLOCK(mutex_hash);
[305]	478
[458]	479	/* remove here to avoid second message from hash_unvisited */
	480	if (retval == 0)
	481	sh_hash_remove (fullpath);
	482
[149]	483	return retval;
[1]	484	}
	485
	486
	487	/**************************************************************
	488	*
	489	* search for files not visited, and check whether they exist
	490	*
	491	**************************************************************/
[294]	492	static sh_file_t * delete_db_entry(sh_file_t *p)
	493	{
	494	if (p->fullpath)
	495	{
	496	SH_FREE(p->fullpath);
	497	p->fullpath = NULL;
	498	}
	499	if (p->linkpath)
	500	{
	501	if (p->linkpath != notalink)
	502	SH_FREE(p->linkpath);
	503	p->linkpath = NULL;
	504	}
	505	if (p->attr_string)
	506	{
	507	SH_FREE(p->attr_string);
	508	p->attr_string = NULL;
	509	}
	510	SH_FREE(p);
	511	return NULL;
	512	}
	513
[1]	514	static void hash_unvisited (int j,
	515	sh_file_t prev, sh_file_t p, ShErrLevel level)
	516	{
	517	struct stat buf;
	518	int i;
	519	char * tmp;
	520	char * ptr;
	521	char fileHash[KEY_LEN + 1];
	522	file_type * theFile;
	523
	524	char * str;
	525
	526
	527	SL_ENTER(_("hash_unvisited"));
	528
	529	if (p->next != NULL)
	530	hash_unvisited (j, p, p->next, level);
	531
	532	if (p->fullpath == NULL)
	533	{
	534	SL_RET0(_("hash_unvisited"));
	535	}
	536
[114]	537	/* Not a fully qualified path, i.e. some info stored by some module
[1]	538	*/
[114]	539	if (p->fullpath[0] != '/')
[1]	540	{
	541	SL_RET0(_("hash_unvisited"));
	542	}
[458]	543
[114]	544	/* visited flag not set: not seen;
	545	* checked flag set: not seen (i.e. missing), and already checked
	546	* reported flag not set: not reported yet
	547	* allignore flag not set: not under IgnoreAll
[1]	548	*
	549	* Files/directories under IgnoreAll are noticed as missing already
	550	* during the file check.
	551	*/
[114]	552	if (((!SH_FFLAG_VISITED_SET(p->fflags)) \|\| SH_FFLAG_CHECKED_SET(p->fflags))
	553	&& (!SH_FFLAG_REPORTED_SET(p->fflags))
	554	&& (!SH_FFLAG_ALLIGNORE_SET(p->fflags)))
[1]	555	{
	556	i = retry_lstat(FIL__, __LINE__, p->fullpath, &buf);
[458]	557
[457]	558	/* if file does not exist
[1]	559	*/
	560	if (0 != i)
	561	{
[34]	562	ptr = sh_util_dirname (p->fullpath);
[1]	563	if (ptr)
	564	{
	565	/* If any of the parent directories is under IgnoreAll
	566	*/
	567	if (0 != sh_files_is_allignore(ptr))
	568	level = ShDFLevel[SH_LEVEL_ALLIGNORE];
	569	SH_FREE(ptr);
	570	}
[114]	571
	572	/* Only report if !SH_FFLAG_CHECKED_SET
	573	*/
	574	if (!SH_FFLAG_CHECKED_SET(p->fflags))
[1]	575	{
	576	if (S_FALSE == sh_ignore_chk_del(p->fullpath))
	577	{
	578	tmp = sh_util_safe_name(p->fullpath);
	579
	580	theFile = sh_hash_create_ft (p, fileHash);
	581	str = all_items(theFile, fileHash, 0);
	582	sh_error_handle (level, FIL__, __LINE__, 0,
	583	MSG_FI_MISS2, tmp, str);
[405]	584	++sh.statistics.files_report;
[1]	585	SH_FREE(str);
[167]	586	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	587	if (theFile->link_path) SH_FREE(theFile->link_path);
[1]	588	SH_FREE(theFile);
	589
	590	SH_FREE(tmp);
	591	}
	592	}
	593
[77]	594	/* We rewrite the db on update, thus we need to keep this
[1]	595	* if the user does not want to purge it from the db.
	596	*/
	597
[77]	598	if ((sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE) \|\|
	599	(S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(p->fullpath)))
[1]	600	{
	601	#ifdef REPLACE_OLD
	602	/* Remove the old entry
	603	*/
	604	if (prev == p)
	605	tab[j] = p->next;
	606	else
	607	prev->next = p->next;
[294]	608
[383]	609	delete_db_entry(p);
[294]	610
[1]	611	SL_RET0(_("hash_unvisited"));
	612	#else
[114]	613	SET_SH_FFLAG_REPORTED(p->fflags);
[1]	614	#endif
	615	}
	616	}
	617	}
	618
[114]	619	else if (SH_FFLAG_VISITED_SET(p->fflags) && SH_FFLAG_REPORTED_SET(p->fflags)
	620	&& (!SH_FFLAG_ALLIGNORE_SET(p->fflags)))
[1]	621	{
	622	if (S_FALSE == sh_ignore_chk_new(p->fullpath))
	623	{
	624	tmp = sh_util_safe_name(p->fullpath);
	625
	626	theFile = sh_hash_create_ft (p, fileHash);
	627	str = all_items(theFile, fileHash, 0);
	628	sh_error_handle (level, FIL__, __LINE__, 0,
	629	MSG_FI_MISS2, tmp, str);
[405]	630	++sh.statistics.files_report;
[1]	631	SH_FREE(str);
[68]	632	if (theFile->attr_string)
	633	SH_FREE(theFile->attr_string);
[1]	634	SH_FREE(theFile);
	635
	636	SH_FREE(tmp);
	637	}
	638
[114]	639	CLEAR_SH_FFLAG_REPORTED(p->fflags);
[1]	640	}
	641
	642	if (sh.flag.reportonce == S_FALSE)
[114]	643	CLEAR_SH_FFLAG_REPORTED(p->fflags);
[1]	644
[114]	645	CLEAR_SH_FFLAG_VISITED(p->fflags);
	646	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[458]	647	SET_SH_FFLAG_ENOENT(p->fflags);
[114]	648
[1]	649	SL_RET0(_("hash_unvisited"));
	650	}
	651
	652
[305]	653
[1]	654	/*********************************************************************
	655	*
	656	* Search for files in the database that have been deleted from disk.
	657	*
	658	*********************************************************************/
	659	void sh_hash_unvisited (ShErrLevel level)
	660	{
	661	int i;
	662
	663	SL_ENTER(_("sh_hash_unvisited"));
[149]	664
	665	SH_MUTEX_LOCK(mutex_hash);
[1]	666	for (i = 0; i < TABSIZE; ++i)
	667	{
	668	if (tab[i] != NULL)
	669	hash_unvisited (i, tab[i], tab[i], level);
	670	}
[149]	671	SH_MUTEX_UNLOCK(mutex_hash);
	672
[1]	673	SL_RET0(_("hash_unvisited"));
	674	}
	675
[294]	676	/*********************************************************************
	677	*
[305]	678	* Remove a single file from the database.
	679	*
	680	*********************************************************************/
	681	void sh_hash_remove (const char * path)
	682	{
	683	struct two_sh_file_t entries;
	684	int index;
	685
	686	SL_ENTER(_("sh_hash_remove"));
	687
	688	SH_MUTEX_LOCK(mutex_hash);
	689
	690	if ((sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE) \|\|
	691	(S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(path)))
	692	{
	693	if (0 == hashsearch_prev (path, &entries, &index))
	694	{
	695	sh_file_t * p = entries.this;
	696	#ifdef REPLACE_OLD
	697	/* Remove the old entry
	698	*/
	699	if (entries.prev == p)
	700	tab[index] = p->next;
	701	else
	702	entries.prev->next = p->next;
	703
[383]	704	delete_db_entry(p);
[305]	705
	706	goto end;
	707	#else
	708	SET_SH_FFLAG_REPORTED(p->fflags);
	709	#endif
	710	}
	711	}
	712
	713	end:
	714	; /* 'label at end of compound statement' */
	715	SH_MUTEX_UNLOCK(mutex_hash);
	716
	717	SL_RET0(_("sh_hash_remove"));
	718	}
	719
	720
	721	/*********************************************************************
	722	*
[294]	723	* Search for unvisited entries in the database, custom error handler.
	724	*
	725	*********************************************************************/
	726	void sh_hash_unvisited_custom (char prefix, void(handler)(const char key))
	727	{
	728	int i;
	729	sh_file_t *p = NULL;
	730	sh_file_t *prev = NULL;
	731	sh_file_t *next = NULL;
[1]	732
[294]	733	SL_ENTER(_("sh_hash_unvisited_custom"));
	734
	735	SH_MUTEX_LOCK(mutex_hash);
	736	for (i = 0; i < TABSIZE; ++i)
	737	{
	738	if (tab[i] != NULL)
	739	{
	740	p = tab[i]; prev = p;
	741
	742	do
	743	{
	744	next = p->next;
	745
	746	if (p->fullpath &&
	747	prefix == p->fullpath[0])
	748	{
	749	if ((!SH_FFLAG_VISITED_SET(p->fflags))
	750	&& (!SH_FFLAG_REPORTED_SET(p->fflags)))
	751	{
	752	handler(p->fullpath);
	753
	754	if (!SH_FFLAG_CHECKED_SET(p->fflags))
	755	{
	756	/* delete */
	757	if (tab[i] == p)
	758	{
	759	tab[i] = p->next;
	760	prev = tab[i];
	761	next = prev;
	762	}
	763	else
	764	{
	765	prev->next = p->next;
	766	next = prev->next;
	767	}
	768
	769	p = delete_db_entry(p);
	770	}
	771	}
	772	if (p)
	773	{
	774	CLEAR_SH_FFLAG_VISITED(p->fflags);
	775	CLEAR_SH_FFLAG_CHECKED(p->fflags);
	776	}
	777	}
	778	if (p)
	779	prev = p;
	780	p = next;
	781	}
	782	while (p);
	783	}
	784	}
	785	SH_MUTEX_UNLOCK(mutex_hash);
	786
	787	SL_RET0(_("hash_unvisited_custom"));
	788	}
	789
	790
[1]	791	/**********************************************************************
	792	*
	793	* delete hash array
	794	*
	795	**********************************************************************/
	796	static void hash_kill (sh_file_t *p)
	797	{
	798	SL_ENTER(_("hash_kill"));
	799
	800	if (p == NULL)
	801	SL_RET0(_("hash_kill"));
	802
	803	if (p->next != NULL)
	804	hash_kill (p->next);
	805
	806	if (p->fullpath)
	807	{
	808	SH_FREE(p->fullpath);
	809	p->fullpath = NULL;
	810	}
	811	if (p->linkpath)
	812	{
[149]	813	if (p->linkpath != notalink)
	814	SH_FREE(p->linkpath);
[1]	815	p->linkpath = NULL;
	816	}
[68]	817	if (p->attr_string)
	818	{
	819	SH_FREE(p->attr_string);
	820	p->attr_string = NULL;
	821	}
[1]	822	SH_FREE(p);
	823	p = NULL;
	824	SL_RET0(_("hash_kill"));
	825	}
	826
	827
	828	/***********************************************************************
	829	*
	830	* get info out of hash array
	831	*
	832	***********************************************************************/
[294]	833	static sh_file_t * hashsearch (const char * s)
[1]	834	{
	835	sh_file_t * p;
	836
	837	SL_ENTER(_("hashsearch"));
	838
[8]	839	if (s)
	840	{
	841	for (p = tab[hashfunc(s)]; p; p = p->next)
	842	if ((p->fullpath != NULL) && (0 == strcmp(s, p->fullpath)))
	843	SL_RETURN( p, _("hashsearch"));
	844	}
[1]	845	SL_RETURN( NULL, _("hashsearch"));
	846	}
	847
[305]	848	static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index)
	849	{
	850	sh_file_t * this;
	851	sh_file_t * prev = NULL;
[1]	852
[305]	853	SL_ENTER(_("hashsearch_prev"));
	854
	855	if (s)
	856	{
	857	*index = hashfunc(s);
	858
	859	this = tab[*index];
	860
	861	prev = this;
	862
	863	if (this)
	864	{
	865	do {
	866
	867	if ((this->fullpath != NULL) && (0 == strcmp(s, this->fullpath)))
	868	{
	869	a->prev = prev;
	870	a->this = this;
	871
	872	SL_RETURN( 0, _("hashsearch_prev"));
	873	}
	874
	875	prev = this;
	876	this = this->next;
	877
	878	} while(this);
	879	}
	880	}
	881	SL_RETURN( -1, _("hashsearch"));
	882	}
	883
	884
[1]	885	/***********************************************************************
	886	*
	887	* insert into hash array
	888	*
	889	***********************************************************************/
	890	static void hashinsert (sh_file_t * s)
	891	{
	892	sh_file_t * p;
[3]	893	sh_file_t * q;
[1]	894	int key;
	895
	896	SL_ENTER(_("hashinsert"));
	897
	898	key = hashfunc(s->fullpath);
	899
	900	if (tab[key] == NULL)
	901	{
	902	tab[key] = s;
	903	tab[key]->next = NULL;
	904	SL_RET0(_("hashinsert"));
	905	}
	906	else
	907	{
	908	p = tab[key];
	909	while (1)
	910	{
	911	if (p && p->fullpath &&
[8]	912	0 == strcmp(s->fullpath, p->fullpath))
[1]	913	{
[3]	914	q = p->next;
	915	SH_FREE(p->fullpath);
[149]	916	if(p->linkpath && p->linkpath != notalink)
[3]	917	SH_FREE(p->linkpath);
[68]	918	if(p->attr_string)
	919	SH_FREE(p->attr_string);
[3]	920	memcpy(p, s, sizeof(sh_file_t));
	921	p->next = q;
[1]	922	SH_FREE(s);
	923	s = NULL;
	924	SL_RET0(_("hashinsert"));
	925	}
[383]	926	else if (p && p->next == NULL)
	927	{
	928	p->next = s;
	929	p->next->next = NULL;
	930	SL_RET0(_("hashinsert"));
	931	}
	932	if (p)
	933	p = p->next;
	934	else /* cannot really happen, but llvm/clang does not know */
	935	break;
[1]	936	}
	937	}
	938	/* notreached */
	939	}
	940
	941
	942	/******************************************************************
	943	*
	944	* Get a single line
	945	*
	946	******************************************************************/
	947	static FILE * sh_fin_fd = NULL;
	948
	949	static int sh_hash_getline (FILE * fd, char * line, int sizeofline)
	950	{
	951	register int n = 0;
	952	char * res;
	953
	954	if (sizeofline < 2) {
[34]	955	if (sizeofline > 0) line[0] = '\0';
[1]	956	return 0;
	957	}
	958	res = fgets(line, sizeofline, fd);
	959	if (res == NULL)
	960	{
	961	line[0] = '\0';
	962	return -1;
	963	}
	964	n = strlen(line);
[149]	965	if (n > 0) {
[1]	966	--n;
[34]	967	line[n] = '\0'; /* remove terminating '\n' */
[1]	968	}
	969	return n;
	970	}
	971
[170]	972	static void sh_hash_getline_end (void)
[1]	973	{
[252]	974	sl_fclose (FIL__, __LINE__, sh_fin_fd);
[1]	975	sh_fin_fd = NULL;
	976	return;
	977	}
	978
	979	/******************************************************************
	980	*
	981	* ------- Check functions -------
	982	*
	983	******************************************************************/
	984
	985	static int IsInit = 0;
	986
	987
	988	/******************************************************************
	989	*
	990	* Fast forward to start of data
	991	*
	992	******************************************************************/
[20]	993	int sh_hash_setdataent (SL_TICKET fd, char * line, int size, const char * file)
[1]	994	{
	995	long i;
	996	extern int get_the_fd (SL_TICKET ticket);
	997
	998	SL_ENTER(_("sh_hash_setdataent"));
	999
	1000	sl_rewind (fd);
	1001
	1002	if (sh_fin_fd != NULL)
	1003	{
[252]	1004	sl_fclose (FIL__, __LINE__, sh_fin_fd);
[1]	1005	sh_fin_fd = NULL;
	1006	}
	1007
[247]	1008	sh_fin_fd = fdopen(dup(get_the_fd(fd)), "rb");
[1]	1009	if (!sh_fin_fd)
	1010	{
	1011	dlog(1, FIL__, __LINE__,
	1012	_("The file signature database: %s is not readable.\n"),
	1013	(NULL == file) ? _("(null)") : file);
	1014	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1015	( (NULL == file) ? _("(null)") : file)
	1016	);
	1017	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1018	}
	1019
	1020	while (1)
	1021	{
[34]	1022	i = sh_hash_getline (sh_fin_fd, line, size);
[1]	1023	if (i < 0 )
	1024	{
	1025	SH_FREE(line);
	1026	dlog(1, FIL__, __LINE__,
	1027	_("The file signature database: %s does not\ncontain any data, or the start-of-file marker is missing (unlikely,\nunless modified by hand).\n"),
	1028	(NULL == file) ? _("(null)") : file);
	1029
	1030	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1031	( (NULL == file) ? _("(null)") : file)
	1032	);
	1033	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1034	}
	1035
	1036	#if defined(SH_STEALTH)
	1037	if (0 == sl_strncmp (line, N_("[SOF]"), 5))
	1038	#else
	1039	if (0 == sl_strncmp (line, _("[SOF]"), 5))
	1040	#endif
	1041	break;
	1042	}
	1043	SL_RETURN( 1, _("sh_hash_setdataent"));
	1044	}
	1045
	1046	static int sh_hash_setdataent_old (SL_TICKET fd, char * line, int size,
	1047	char * file)
	1048	{
	1049	long i;
	1050
	1051	SL_ENTER(_("sh_hash_setdataent_old"));
	1052
	1053	sl_rewind (fd);
	1054
	1055	while (1)
	1056	{
	1057	i = sh_unix_getline (fd, line, size-1);
	1058	if (i < 0 )
	1059	{
	1060	SH_FREE(line);
	1061	dlog(1, FIL__, __LINE__,
	1062	_("The file signature database: %s does not\ncontain any data, or the start-of-file marker is missing (unlikely,\nunless modified by hand).\n"),
	1063	(NULL == file) ? _("(null)") : file);
	1064
	1065	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1066	( (NULL == file) ? _("(null)") : file)
	1067	);
	1068	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1069	}
	1070
	1071	#if defined(SH_STEALTH)
	1072	if (0 == sl_strncmp (line, N_("[SOF]"), 5))
	1073	#else
	1074	if (0 == sl_strncmp (line, _("[SOF]"), 5))
	1075	#endif
	1076	break;
	1077	}
	1078	SL_RETURN( 1, _("sh_hash_setdataent_old"));
	1079	}
	1080
	1081	/******************************************************************
	1082	*
	1083	* Read next record
	1084	*
	1085	******************************************************************/
	1086	sh_file_t * sh_hash_getdataent (SL_TICKET fd, char * line, int size)
	1087	{
	1088	sh_file_t * p;
	1089	sh_filestore_t ft;
	1090	long i;
[34]	1091	size_t len;
[1]	1092	char * fullpath;
	1093	char * linkpath;
[68]	1094	char * attr_string = NULL;
[1]	1095	char * tmp;
	1096
	1097	SL_ENTER(_("sh_hash_getdataent"));
	1098
	1099	(void) fd;
	1100
	1101	/* Read next record -- Part One
	1102	*/
	1103	p = SH_ALLOC(sizeof(sh_file_t));
	1104
	1105	i = fread (&ft, sizeof(sh_filestore_t), 1, sh_fin_fd);
	1106	/* i = sl_read(fd, &ft, sizeof(sh_filestore_t)); */
	1107	/* if ( SL_ISERROR(i) \|\| i == 0) */
	1108	if (i < 1)
	1109	{
	1110	SH_FREE(p);
	1111	SL_RETURN( NULL, _("sh_hash_getdataent"));
	1112	}
	1113
	1114	swap_32(&(ft.mode));
	1115	swap_32(&(ft.linkmode));
	1116	swap_64(&(ft.dev));
	1117	swap_64(&(ft.rdev));
	1118	swap_32(&(ft.hardlinks));
	1119	swap_32(&(ft.ino));
	1120	swap_64(&(ft.size));
	1121	swap_64(&(ft.atime));
	1122	swap_64(&(ft.mtime));
	1123	swap_64(&(ft.ctime));
	1124	swap_32(&(ft.owner));
	1125	swap_32(&(ft.group));
[10]	1126	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1127	swap_32(&(ft.attributes));
	1128	#endif
	1129	#ifdef OLD_BUG
	1130	swap_short(&(ft.mark));
	1131	#else
	1132	ft.mark = *(swap_short(&(ft.mark)));
	1133	#endif
	1134
[68]	1135	if ((ft.mark & ~REC_FLAGS_MASK) != REC_MAGIC)
[1]	1136	{
	1137	SH_FREE(p);
	1138	SL_RETURN( NULL, _("sh_hash_getdataent"));
	1139	}
	1140
	1141	/* Read next record -- Part Two -- Fullpath
	1142	*/
[34]	1143	i = sh_hash_getline (sh_fin_fd, line, size);
[149]	1144	if (i <= 0 )
[1]	1145	{
	1146	SH_FREE(line);
	1147	SH_FREE(p);
	1148	dlog(1, FIL__, __LINE__,
	1149	_("There is a corrupt record in the file signature database: %s\nThe file path is missing.\n"),
	1150	(NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
	1151	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1152	( (NULL == file_path('D', 'R')) ? _("(null)") :
	1153	file_path('D', 'R'))
	1154	);
	1155	aud_exit (FIL__, __LINE__,EXIT_FAILURE);
	1156	}
	1157
[149]	1158	tmp = unquote_string (line, i);
[34]	1159	len = sl_strlen(tmp)+1;
	1160	fullpath = SH_ALLOC(len);
	1161	(void) sl_strlcpy (fullpath, tmp, len);
[1]	1162	if (tmp)
	1163	SH_FREE(tmp);
[34]	1164	if (fullpath[len-2] == '\n')
	1165	fullpath[len-2] = '\0';
[1]	1166
	1167	/* Read next record -- Part Three -- Linkpath
	1168	*/
[34]	1169	i = sh_hash_getline (sh_fin_fd, line, size);
[149]	1170	if (i <= 0 )
[1]	1171	{
	1172	SH_FREE(line);
	1173	SH_FREE(fullpath);
	1174	SH_FREE(p);
	1175	dlog(1, FIL__, __LINE__,
	1176	_("There is a corrupt record in the file signature database: %s\nThe link path (or its placeholder) is missing.\n"),
	1177	(NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
	1178	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1179	( (NULL == file_path('D', 'R')) ? _("(null)") :
	1180	file_path('D', 'R'))
	1181	);
	1182	aud_exit (FIL__, __LINE__,EXIT_FAILURE);
	1183	}
	1184
[149]	1185	tmp = unquote_string (line, i);
	1186
	1187	if ( tmp && tmp[0] == '-' &&
	1188	(tmp[1] == '\0' \|\| (tmp[1] == '\n' && tmp[2] == '\0')))
	1189	{
	1190	linkpath = (char *)notalink;
	1191	}
	1192	else
	1193	{
[167]	1194	len = sl_strlen(tmp);
	1195	linkpath = sh_util_strdup_l(tmp, len);
	1196	if (len > 0 && linkpath[len-1] == '\n')
	1197	linkpath[len-1] = '\0';
[149]	1198	}
	1199
[1]	1200	if (tmp)
	1201	SH_FREE(tmp);
	1202
[68]	1203	/* Read next record -- Part Four -- attr_string
	1204	*/
	1205	if ((ft.mark & REC_FLAGS_ATTR) != 0)
	1206	{
	1207	i = sh_hash_getline (sh_fin_fd, line, size);
[149]	1208	if (i <= 0 )
[68]	1209	{
	1210	SH_FREE(line);
	1211	SH_FREE(fullpath);
[149]	1212	if (linkpath != notalink)
	1213	SH_FREE(linkpath);
[68]	1214	SH_FREE(p);
	1215	dlog(1, FIL__, __LINE__,
	1216	_("There is a corrupt record in the file signature database: %s\nThe attribute string is missing.\n"),
	1217	(NULL == file_path('D', 'R'))? _("(null)"):file_path('D', 'R'));
	1218	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_P_NODATA,
	1219	( (NULL == file_path('D', 'R')) ? _("(null)") :
	1220	file_path('D', 'R'))
	1221	);
	1222	aud_exit (FIL__, __LINE__,EXIT_FAILURE);
	1223	}
	1224
[149]	1225	tmp = unquote_string (line, i);
[68]	1226
	1227	len = sl_strlen(tmp)+1;
	1228	attr_string = SH_ALLOC(len);
	1229	(void) sl_strlcpy (attr_string, tmp, len);
	1230	if (tmp)
	1231	SH_FREE(tmp);
	1232	if (attr_string[len-2] == '\n')
	1233	attr_string[len-2] = '\0';
	1234	}
	1235
[1]	1236	/* Read next record -- Part Four -- Decode
	1237	*/
	1238	#if defined(SH_STEALTH)
	1239	sh_do_decode(fullpath, sl_strlen(fullpath));
	1240
[10]	1241	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1242	sh_do_decode(ft.c_attributes, sl_strlen(ft.c_attributes));
	1243	#endif
	1244
	1245	sh_do_decode(ft.c_mode, sl_strlen(ft.c_mode));
	1246	sh_do_decode(ft.c_owner, sl_strlen(ft.c_owner));
	1247	sh_do_decode(ft.c_group, sl_strlen(ft.c_group));
	1248	sh_do_decode(ft.checksum, sl_strlen(ft.checksum));
	1249
[402]	1250	/* TXT entries are c_mode[0] != 'l' and do not get decoded
	1251	*/
[149]	1252	if (ft.c_mode[0] == 'l' && linkpath != notalink)
[1]	1253	{
	1254	sh_do_decode(linkpath, sl_strlen(linkpath));
	1255	}
[402]	1256
[68]	1257	if ((ft.mark & REC_FLAGS_ATTR) != 0)
	1258	{
	1259	sh_do_decode(attr_string, sl_strlen(attr_string));
	1260	}
[1]	1261	#endif
	1262
	1263	memcpy( &(*p).theFile, &ft, sizeof(sh_filestore_t) );
[114]	1264
[115]	1265	/* init fflags, such that suid files in
	1266	* database are recognized as such
	1267	*/
	1268	{
	1269	mode_t mode = (mode_t) ft.mode;
[114]	1270
[115]	1271	if (S_ISREG(mode) &&
	1272	(0 !=(S_ISUID & mode) \|\|
	1273	#if defined(HOST_IS_LINUX)
	1274	(0 !=(S_ISGID & mode) &&
	1275	0 !=(S_IXGRP & mode))
	1276	#else
	1277	0 !=(S_ISGID & mode)
	1278	#endif
	1279	)
	1280	)
	1281	p->fflags = SH_FFLAG_SUIDCHK;
	1282
	1283	else
	1284	p->fflags = 0;
	1285	}
	1286
[1]	1287	p->modi_mask = 0L;
	1288	p->fullpath = fullpath;
	1289	p->linkpath = linkpath;
	1290
[68]	1291	p->attr_string = attr_string;
	1292
[1]	1293	/* set to an invalid value
	1294	*/
	1295	ft.mark = (REC_MAGIC + 5);
	1296
	1297	SL_RETURN( p, _("sh_hash_getdataent"));
	1298	}
	1299
	1300	/******************************************************************
	1301	*
	1302	* Initialize
	1303	*
	1304	******************************************************************/
	1305	void sh_hash_init ()
	1306	{
[34]	1307
	1308	#define FGETS_BUF 16384
	1309
[1]	1310	sh_file_t * p;
[170]	1311	SL_TICKET fd;
[1]	1312	long i;
	1313	int count = 0;
	1314	char * line = NULL;
	1315
	1316	#if defined(WITH_GPG) \|\| defined(WITH_PGP)
	1317	extern int get_the_fd (SL_TICKET ticket);
	1318
	1319	SL_TICKET fdTmp = (-1);
	1320	#endif
[133]	1321	char hashbuf[KEYBUF_SIZE];
[1]	1322
[199]	1323	volatile int retval = 0;
	1324	volatile int exitval = EXIT_SUCCESS;
[185]	1325
[1]	1326	SL_ENTER(_("sh_hash_init"));
	1327
[463]	1328	if ( sh.flag.checkSum == SH_CHECK_INIT )
	1329	{
	1330	dlog(1, FIL__, __LINE__,
	1331	_("Attempt to load the baseline database during initialisation. This is an internal error, please report it to the developer.\n"));
	1332	SH_ABORT;
	1333	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1334	}
	1335
[149]	1336	SH_MUTEX_LOCK(mutex_hash);
[1]	1337
[149]	1338	if (IsInit == 1)
	1339	{
	1340	goto unlock_and_return;
	1341	}
[1]	1342
[170]	1343	fd = (-1);
	1344
[1]	1345	#if defined(SH_WITH_CLIENT)
	1346
	1347	/* Data file from Server
	1348	*/
	1349
	1350	if (fd == (-1) && 0 == sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
	1351	{
	1352	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_D_DSTART);
	1353	fd = sh_forward_req_file(_("DATA"));
	1354	if (SL_ISERROR(fd))
	1355	{
	1356	dlog(1, FIL__, __LINE__,
	1357	_("Could not retrieve the file signature database from the server(errnum = %ld).\nPossible reasons include:\n - the server is not running,\n - session key negotiation failed (see the manual for proper setup), or\n - the server cannot access the file.\n"), fd);
	1358	sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_EXIT_ABORT1,
	1359	sh.prg_name);
[185]	1360	retval = 1; exitval = EXIT_FAILURE;
	1361	goto unlock_and_return;
[1]	1362	}
	1363	sl_rewind (fd);
	1364
	1365	sl_strlcpy (sh.data.hash,
[354]	1366	sh_tiger_hash (file_path('D', 'R'),
[160]	1367	fd, TIGER_NOLIM, hashbuf, sizeof(hashbuf)),
[1]	1368	KEY_LEN+1);
	1369	sl_rewind (fd);
	1370	}
	1371	else
	1372	#endif
	1373	/* Local data file
	1374	*/
	1375
	1376	if (fd == (-1))
	1377	{
[248]	1378	if ( SL_ISERROR(fd = sl_open_read(FIL__, __LINE__,
	1379	file_path('D', 'R'), SL_YESPRIV)))
[1]	1380	{
	1381	TPT(( 0, FIL__, __LINE__, _("msg=<Error opening: %s>\n"),
	1382	file_path('D', 'R')));
	1383	dlog(1, FIL__, __LINE__,
	1384	_("Could not open the local file signature database for reading because\nof the following error: %s (errnum = %ld)\nIf this is a permission problem, you need to change file permissions\nto make the file readable for the effective UID: %d\n"),
	1385	sl_get_errmsg(), fd, (int) sl_ret_euid());
	1386	sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_EXIT_ABORT1,
	1387	sh.prg_name);
[185]	1388	retval = 1; exitval = EXIT_FAILURE;
	1389	goto unlock_and_return;
[1]	1390	}
	1391
	1392	TPT(( 0, FIL__, __LINE__, _("msg=<Opened database: %s>\n"),
	1393	file_path('D', 'R')));
	1394
	1395	if (0 != sl_strncmp(sh.data.hash,
[160]	1396	sh_tiger_hash (file_path('D', 'R'), fd, TIGER_NOLIM,
[133]	1397	hashbuf, sizeof(hashbuf)),
[1]	1398	KEY_LEN)
	1399	&& sh.flag.checkSum != SH_CHECK_INIT)
	1400	{
	1401	dlog(1, FIL__, __LINE__,
[162]	1402	_("The checksum of the file signature database has changed since startup: %s -> %s\n"),
	1403	sh.data.hash, sh_tiger_hash (file_path('D', 'R'), fd, TIGER_NOLIM,
	1404	hashbuf, sizeof(hashbuf)));
[1]	1405	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_E_AUTH,
	1406	( (NULL == file_path('D', 'R')) ? _("(null)") :
	1407	file_path('D', 'R') )
	1408	);
[185]	1409	retval = 1; exitval = EXIT_FAILURE;
	1410	goto unlock_and_return;
[1]	1411	}
	1412	sl_rewind (fd);
	1413
	1414	} /* new 1.4.8 */
	1415
	1416	if (sig_termfast == 1) /* SIGTERM */
	1417	{
	1418	TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
	1419	--sig_raised; --sig_urgent;
[185]	1420	retval = 1; exitval = EXIT_SUCCESS;
	1421	goto unlock_and_return;
[1]	1422	}
	1423
	1424	#if defined(WITH_GPG) \|\| defined(WITH_PGP)
	1425
	1426	/* extract the data and copy to temporary file
	1427	*/
[347]	1428	fdTmp = sh_gpg_extract_signed(fd);
[1]	1429
[347]	1430	if (sig_termfast == 1) /* SIGTERM */
[1]	1431	{
[347]	1432	TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
	1433	--sig_raised; --sig_urgent;
	1434	retval = 1; exitval = EXIT_SUCCESS;
	1435	goto unlock_and_return;
	1436	}
[1]	1437
	1438	sl_close(fd);
	1439	fd = fdTmp;
	1440
	1441	/* Validate signature of open file.
	1442	*/
	1443	if (0 != sh_gpg_check_sign (0, fd, 2))
	1444	{
[185]	1445	retval = 1; exitval = EXIT_FAILURE;
	1446	goto unlock_and_return;
[1]	1447	}
	1448	sl_rewind (fd);
	1449	#endif
	1450
[170]	1451	line = SH_ALLOC(MAX_PATH_STORE+2);
[1]	1452
	1453	/* fast forward to start of data
	1454	*/
[170]	1455	sh_hash_setdataent(fd, line, MAX_PATH_STORE+1, file_path('D', 'R'));
[1]	1456
[149]	1457	for (i = 0; i < TABSIZE; ++i)
	1458	tab[i] = NULL;
	1459
[1]	1460	while (1)
	1461	{
	1462	if (sig_termfast == 1) /* SIGTERM */
	1463	{
	1464	TPT((0, FIL__, __LINE__, _("msg=<Terminate.>\n")));
	1465	--sig_raised; --sig_urgent;
[185]	1466	retval = 1; exitval = EXIT_SUCCESS;
[227]	1467	SH_FREE(line);
	1468	line = NULL;
[185]	1469	goto unlock_and_return;
[1]	1470	}
	1471
[170]	1472	p = sh_hash_getdataent (fd, line, MAX_PATH_STORE+1);
[1]	1473	if (p != NULL)
	1474	{
	1475	hashinsert (p);
	1476	++count;
	1477	}
	1478	else
	1479	break;
	1480	}
	1481
[149]	1482	/* Initialization completed.
	1483	*/
	1484	IsInit = 1;
	1485
[1]	1486	if (line != NULL)
	1487	SH_FREE(line);
	1488
	1489	/* Always keep db in memory, so we have no open file
	1490	*/
	1491	sl_close (fd);
	1492	sh_hash_getline_end();
[383]	1493	/* fd = -1; */
[1]	1494
[149]	1495	unlock_and_return:
[153]	1496	; /* 'label at end of compound statement */
[149]	1497	SH_MUTEX_UNLOCK(mutex_hash);
[185]	1498	if (retval == 0)
	1499	{
	1500	SL_RET0(_("sh_hash_init"));
	1501	}
	1502	aud_exit (FIL__, __LINE__, exitval);
[1]	1503	}
	1504
	1505	/*****************************************************************
	1506	*
	1507	* delete hash array
	1508	*
	1509	*****************************************************************/
	1510	void sh_hash_hashdelete ()
	1511	{
	1512	int i;
	1513
	1514	SL_ENTER(_("sh_hash_hashdelete"));
	1515
[320]	1516	/* need deadlock detection here if called from exit handler
	1517	*/
	1518	SH_MUTEX_TRYLOCK(mutex_hash);
	1519
[1]	1520	if (IsInit == 0)
[149]	1521	goto unlock_and_exit;
	1522
[1]	1523	for (i = 0; i < TABSIZE; ++i)
	1524	if (tab[i] != NULL)
	1525	{
	1526	hash_kill (tab[i]);
	1527	tab[i] = NULL;
	1528	}
	1529	IsInit = 0;
[149]	1530
	1531	unlock_and_exit:
[153]	1532	; /* 'label at end of compound statement */
[371]	1533	SH_MUTEX_TRYLOCK_UNLOCK(mutex_hash);
[320]	1534
[1]	1535	SL_RET0(_("sh_hash_hashdelete"));
	1536	}
	1537
	1538	/******************************************************************
	1539	*
	1540	* Insert a file into the database.
	1541	*
	1542	******************************************************************/
	1543	static int pushdata_isfirst = 1;
	1544	static SL_TICKET pushdata_fd = -1;
	1545
	1546	static int pushdata_stdout = S_FALSE;
	1547
	1548	static char * sh_db_version_string = NULL;
	1549
[20]	1550	int sh_hash_pushdata_stdout (const char * str)
[1]	1551	{
	1552	if (!str)
	1553	{ pushdata_stdout = S_TRUE; return 0; }
	1554	return -1;
	1555	}
	1556
[22]	1557	int sh_hash_version_string(const char * str)
[1]	1558	{
	1559	if (str)
	1560	{
	1561	if (sh_db_version_string != NULL) {
	1562	SH_FREE(sh_db_version_string);
	1563	}
	1564	if (0 == sl_strncmp(str, _("NULL"), 4))
	1565	{
	1566	sh_db_version_string = NULL;
	1567	return 0;
	1568	}
[34]	1569	sh_db_version_string = sh_util_strdup(str);
[1]	1570	return 0;
	1571	}
	1572	return -1;
	1573	}
	1574
[205]	1575	static int sh_loosedircheck = S_FALSE;
[1]	1576
[205]	1577	int sh_hash_loosedircheck(const char * str)
	1578	{
	1579	return sh_util_flagval(str, &sh_loosedircheck);
	1580	}
	1581
	1582
[149]	1583	static void sh_hash_pushdata_int (file_type * buf, char * fileHash)
[1]	1584	{
	1585	static long p_count = 0;
	1586
	1587	int status = 0;
	1588
	1589	char * tmp;
	1590	size_t tmp_len = 0;
	1591	size_t old_len = 0;
[149]	1592	size_t path_len = 0;
[1]	1593
	1594	sh_filestore_t p;
	1595
	1596	struct stat sbuf;
	1597
	1598	char * fullpath = NULL;
	1599	char * linkpath = NULL;
[68]	1600	char * attr_string = NULL;
[1]	1601
	1602	char * line = NULL;
	1603
	1604	char timestring[81];
	1605
[10]	1606	#if !defined(__linux__) && !defined(HAVE_STAT_FLAGS)
[1]	1607	int i;
	1608	#endif
	1609
[149]	1610	SL_ENTER(_("sh_hash_pushdata_int"));
[1]	1611
	1612	fullpath = SH_ALLOC(MAX_PATH_STORE+1);
	1613	linkpath = SH_ALLOC(MAX_PATH_STORE+1);
	1614
	1615	linkpath[0] = '-';
	1616	linkpath[1] = '\0';
	1617	fullpath[0] = '-';
	1618	fullpath[1] = '\0';
	1619
	1620	if (!buf) {
	1621	memset(&p, '\0', sizeof(sh_filestore_t));
	1622	}
	1623
	1624	if ((pushdata_stdout == S_TRUE) && (sh.flag.update == S_TRUE))
	1625	{
	1626	dlog(1, FIL__, __LINE__,
	1627	_("You cannot write the database to stdout when you use update rather than init.\n"));
	1628	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
	1629	_("Writing database to stdout with update"),
	1630	sh.prg_name,
[149]	1631	_("sh_hash_pushdata_int"));
[1]	1632	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1633	}
	1634
	1635	if ((pushdata_stdout == S_TRUE) && (sl_is_suid()))
	1636	{
	1637	dlog(1, FIL__, __LINE__,
	1638	_("You cannot write the database to stdout when running with suid privileges.\n"));
	1639	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
	1640	_("Writing database to stdout when suid"),
	1641	sh.prg_name,
[149]	1642	_("sh_hash_pushdata_int"));
[1]	1643	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1644	}
	1645
	1646
[149]	1647	if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE) &&
[1]	1648	( (NULL == file_path('D', 'W')) \|\|
	1649	(0 == sl_strcmp(file_path('D', 'W'), _("REQ_FROM_SERVER"))) ))
	1650	{
	1651	dlog(1, FIL__, __LINE__,
	1652	_("You need to configure a local path for initializing the database\nlike ./configure --with-data-file=REQ_FROM_SERVER/some/local/path\n"));
	1653	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORTS,
	1654	_("No local path for database specified"),
	1655	sh.prg_name,
[149]	1656	_("sh_hash_pushdata_int"));
[1]	1657	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1658	}
	1659
	1660
[149]	1661	if ((pushdata_isfirst == 1) && (pushdata_stdout == S_FALSE))
[1]	1662	{
	1663	/* Warn that file already exists; file_path != NULL here because
	1664	* checked above
	1665	*/
	1666	if (0 == retry_lstat(FIL__, __LINE__, file_path('D', 'W'), &sbuf))
	1667	{
	1668	if (sh.flag.update == S_FALSE)
	1669	{
	1670	sh_error_handle((-1), FIL__, __LINE__, 0, MSG_FI_DBEX,
	1671	file_path('D', 'W'));
	1672	}
	1673	}
	1674	}
	1675
	1676
	1677	if (sh.flag.update == S_FALSE)
	1678	{
[76]	1679	if (pushdata_stdout == S_FALSE && pushdata_fd == -1)
[1]	1680	{
[248]	1681	if ( SL_ISERROR(pushdata_fd = sl_open_write(FIL__, __LINE__,
	1682	file_path('D', 'W'),
	1683	SL_YESPRIV)))
[76]	1684	{
	1685	SH_FREE(fullpath);
	1686	SH_FREE(linkpath);
	1687	sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
	1688	geteuid(), file_path('D', 'W'));
[212]	1689	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
[76]	1690	}
[212]	1691
	1692	if (SL_ISERROR(status = sl_lock (pushdata_fd)))
	1693	{
	1694	SH_FREE(fullpath);
	1695	SH_FREE(linkpath);
	1696	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
	1697	_("Failed to lock baseline database"), _("sh_hash_pushdata_int"),
	1698	file_path('D', 'W'));
	1699	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1700	}
	1701
[76]	1702	if ( SL_ISERROR(status = sl_forward(pushdata_fd)))
	1703	{
	1704	SH_FREE(fullpath);
	1705	SH_FREE(linkpath);
	1706	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
[248]	1707	_("Failed to seek to end of baseline database"),
	1708	_("sh_hash_pushdata_int"),
[76]	1709	file_path('D', 'W'));
[212]	1710	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
[76]	1711	}
[1]	1712	}
	1713	}
	1714	else /* update == TRUE */
	1715	{
	1716	if (pushdata_isfirst == 1)
	1717	{
	1718	TPT((0, FIL__, __LINE__, _("msg=<Update.>\n")))
[248]	1719	if ( SL_ISERROR(pushdata_fd = sl_open_rdwr(FIL__, __LINE__,
	1720	file_path('D', 'W'),
	1721	SL_YESPRIV))){
[212]	1722	SH_FREE(fullpath);
	1723	SH_FREE(linkpath);
	1724	sh_error_handle((-1), FIL__, __LINE__, pushdata_fd, MSG_E_ACCESS,
	1725	geteuid(), file_path('D', 'W'));
	1726	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1727	}
	1728
	1729	if (SL_ISERROR(status = sl_lock (pushdata_fd)))
	1730	{
	1731	SH_FREE(fullpath);
	1732	SH_FREE(linkpath);
	1733	sh_error_handle((-1), FIL__, __LINE__, status, MSG_E_SUBGPATH,
	1734	_("Failed to lock baseline database"), _("sh_hash_pushdata_int"),
	1735	file_path('D', 'W'));
	1736	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
	1737	}
	1738
[1]	1739	line = SH_ALLOC(MAX_PATH_STORE+1);
	1740	if (SL_ISERROR(sh_hash_setdataent_old (pushdata_fd, line,
	1741	MAX_PATH_STORE,
	1742	file_path('D', 'W'))))
	1743	{
	1744	SH_FREE(fullpath);
	1745	SH_FREE(linkpath);
	1746	SH_FREE(line);
[212]	1747	aud_exit(FIL__, __LINE__, EXIT_FAILURE);
[1]	1748	}
	1749	SH_FREE(line);
	1750	}
	1751	}
	1752
	1753	if (buf != NULL && buf->fullpath != NULL) {
	1754
	1755	old_len = sl_strlen(buf->fullpath);
	1756	#if defined(SH_STEALTH)
	1757	sh_do_encode(buf->fullpath, old_len);
	1758	#endif
[149]	1759	tmp = quote_string(buf->fullpath, old_len);
[1]	1760	tmp_len = sl_strlen(tmp);
	1761	#if defined(SH_STEALTH)
	1762	sh_do_decode(buf->fullpath, old_len);
	1763	#endif
	1764
[34]	1765	if (tmp && tmp_len <= MAX_PATH_STORE)
[1]	1766	{
	1767	sl_strlcpy(fullpath, buf->fullpath, MAX_PATH_STORE+1);
	1768	}
	1769	else
	1770	{
[133]	1771	char hashbuf[KEYBUF_SIZE];
	1772
[1]	1773	sl_strlcpy(fullpath,
	1774	sh_tiger_hash (buf->fullpath,
[133]	1775	TIGER_DATA, old_len,
	1776	hashbuf, sizeof(hashbuf)),
[1]	1777	KEY_LEN+1);
	1778	}
[34]	1779	if (tmp) SH_FREE(tmp);
[1]	1780	}
	1781
[149]	1782	path_len = sl_strlen(fullpath);
[1]	1783	#if defined(SH_STEALTH)
[149]	1784	sh_do_encode(fullpath, path_len);
[1]	1785	#endif
	1786
[149]	1787	tmp = quote_string(fullpath, path_len);
[34]	1788	if (tmp) {
	1789	sl_strlcpy(fullpath, tmp, MAX_PATH_STORE+1);
	1790	SH_FREE(tmp);
	1791	}
[1]	1792
[402]	1793	/* NOTE: TXT entries are c_mode[0] != 'l' and do not get decoded
	1794	*/
[167]	1795	if (buf != NULL /* && buf->c_mode[0] == 'l' */ && buf->link_path != NULL)
[1]	1796	{
	1797
[167]	1798	old_len = sl_strlen(buf->link_path);
[1]	1799	#if defined(SH_STEALTH)
[167]	1800	if (buf->c_mode[0] == 'l')
	1801	sh_do_encode(buf->link_path, old_len);
[1]	1802	#endif
[167]	1803	tmp = quote_string(buf->link_path, old_len);
[1]	1804	tmp_len = sl_strlen(tmp);
	1805	#if defined(SH_STEALTH)
[167]	1806	if (buf->c_mode[0] == 'l')
	1807	sh_do_decode(buf->link_path, old_len);
[1]	1808	#endif
	1809
[34]	1810	if (tmp && tmp_len <= MAX_PATH_STORE)
[1]	1811	{
[167]	1812	sl_strlcpy(linkpath, buf->link_path, MAX_PATH_STORE+1);
[1]	1813	}
	1814	else
	1815	{
[133]	1816	char hashbuf[KEYBUF_SIZE];
[1]	1817	sl_strlcpy(linkpath,
[167]	1818	sh_tiger_hash (buf->link_path,
[133]	1819	TIGER_DATA, old_len,
	1820	hashbuf, sizeof(hashbuf)),
[1]	1821	KEY_LEN+1);
	1822	}
[34]	1823	if (tmp) SH_FREE(tmp);
[1]	1824
[149]	1825	path_len = sl_strlen(linkpath);
[1]	1826	#if defined(SH_STEALTH)
[167]	1827	if (buf->c_mode[0] == 'l')
	1828	sh_do_encode(linkpath, path_len);
[1]	1829	#endif
[149]	1830	tmp = quote_string(linkpath, path_len);
[34]	1831	if (tmp)
	1832	{
	1833	sl_strlcpy(linkpath, tmp, MAX_PATH_STORE+1);
	1834	SH_FREE(tmp);
	1835	}
[1]	1836	}
	1837
[68]	1838	if (buf != NULL && buf->attr_string != NULL)
	1839	{
	1840	old_len = sl_strlen(buf->attr_string);
	1841	#if defined(SH_STEALTH)
	1842	sh_do_encode(buf->attr_string, old_len);
	1843	#endif
[149]	1844	tmp = quote_string(buf->attr_string, old_len);
[68]	1845	if (tmp)
	1846	{
	1847	attr_string = tmp;
	1848	tmp = NULL;
	1849	}
	1850	#if defined(SH_STEALTH)
	1851	sh_do_decode(buf->attr_string, old_len);
	1852	#endif
	1853	}
	1854
	1855
[1]	1856	if (buf != NULL) {
	1857	p.mark = REC_MAGIC;
[68]	1858	if (attr_string)
	1859	p.mark \|= REC_FLAGS_ATTR;
[149]	1860	sl_strlcpy(p.c_mode, buf->c_mode, CMODE_SIZE);
[1]	1861	sl_strlcpy(p.c_group, buf->c_group, GROUP_MAX+1);
	1862	sl_strlcpy(p.c_owner, buf->c_owner, USER_MAX+1);
	1863	if (fileHash) {
	1864	sl_strlcpy(p.checksum, fileHash, KEY_LEN+1);
	1865	}
[10]	1866	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[149]	1867	sl_strlcpy(p.c_attributes, buf->c_attributes, ATTRBUF_SIZE);
[1]	1868	#else
[149]	1869	for (i = 0; i < ATTRBUF_USED; ++i) p.c_attributes[i] = '-';
	1870	p.c_attributes[ATTRBUF_USED] = '\0';
[1]	1871	#endif
	1872
	1873	#if defined(SH_STEALTH)
	1874	sh_do_encode(p.c_mode, sl_strlen(p.c_mode));
	1875	sh_do_encode(p.c_owner, sl_strlen(p.c_owner));
	1876	sh_do_encode(p.c_group, sl_strlen(p.c_group));
	1877	sh_do_encode(p.checksum, sl_strlen(p.checksum));
	1878
	1879	sh_do_encode(p.c_attributes, sl_strlen(p.c_attributes));
	1880	#endif
	1881
[10]	1882	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1883	p.attributes = (UINT32) buf->attributes;
	1884	#else
	1885	p.attributes = 0;
	1886	#endif
	1887	p.linkmode = (UINT32) buf->linkmode;
	1888	p.hardlinks = (UINT32) buf->hardlinks;
	1889	p.dev = (UINT64) buf->dev;
	1890	p.rdev = (UINT64) buf->rdev;
	1891	p.mode = (UINT32) buf->mode;
	1892	p.ino = (UINT32) buf->ino;
	1893	p.size = (UINT64) buf->size;
	1894	p.mtime = (UINT64) buf->mtime;
	1895	p.atime = (UINT64) buf->atime;
	1896	p.ctime = (UINT64) buf->ctime;
	1897	p.owner = (UINT32) buf->owner;
	1898	p.group = (UINT32) buf->group;
	1899
	1900	swap_32(&(p.mode));
	1901	swap_32(&(p.linkmode));
	1902	swap_64(&(p.dev));
	1903	swap_64(&(p.rdev));
	1904	swap_32(&(p.hardlinks));
	1905	swap_32(&(p.ino));
	1906	swap_64(&(p.size));
	1907	swap_64(&(p.atime));
	1908	swap_64(&(p.mtime));
	1909	swap_64(&(p.ctime));
	1910	swap_32(&(p.owner));
	1911	swap_32(&(p.group));
	1912	swap_32(&(p.attributes));
	1913
	1914	#ifdef OLD_BUG
	1915	swap_short(&(p.mark));
	1916	#else
	1917	p.mark = *(swap_short(&(p.mark)));
	1918	#endif
	1919	}
	1920
	1921	/* write the start marker
	1922	*/
	1923	if (pushdata_isfirst == 1)
	1924	{
	1925	if (sh.flag.update == S_FALSE)
	1926	{
	1927	if (sh_db_version_string != NULL)
	1928	{
	1929	if (pushdata_stdout == S_FALSE)
	1930	{
	1931	sl_write (pushdata_fd, _("\n#Host "), 7);
	1932	sl_write (pushdata_fd, sh.host.name,
	1933	sl_strlen(sh.host.name));
	1934	sl_write (pushdata_fd, _(" Version "), 9);
	1935	sl_write (pushdata_fd, sh_db_version_string,
	1936	sl_strlen(sh_db_version_string));
	1937	sl_write (pushdata_fd, _(" Date "), 6);
[132]	1938	(void) sh_unix_time(0, timestring, sizeof(timestring));
[279]	1939	sl_write (pushdata_fd, timestring, strlen(timestring));
[1]	1940	sl_write (pushdata_fd, "\n", 1);
	1941	} else {
[210]	1942	printf ("%s",_("\n#Host "));
[1]	1943	printf ("%s", sh.host.name);
[210]	1944	printf ("%s",_(" Version "));
[1]	1945	printf ("%s", sh_db_version_string);
[210]	1946	printf ("%s",_(" Date "));
[132]	1947	(void) sh_unix_time(0, timestring, sizeof(timestring));
[1]	1948	printf ("%s\n", timestring);
	1949	}
	1950	}
	1951
	1952	if (pushdata_stdout == S_FALSE)
	1953	{
	1954	#if defined(SH_STEALTH)
	1955	sl_write (pushdata_fd, "\n", 1);
	1956	sl_write_line (pushdata_fd, N_("[SOF]"), 5);
	1957	#else
	1958	sl_write_line (pushdata_fd, _("\n[SOF]"), 6);
	1959	#endif
	1960	}
	1961	else
	1962	{
	1963	#if defined(SH_STEALTH)
	1964	printf ("\n%s\n", N_("[SOF]"));
	1965	#else
	1966	printf ("%s\n", _("\n[SOF]"));
	1967	#endif
	1968	}
	1969	}
	1970	pushdata_isfirst = 0;
	1971	}
	1972
	1973	if (pushdata_stdout == S_FALSE)
	1974	{
	1975	sl_write (pushdata_fd, &p, sizeof(sh_filestore_t));
[76]	1976	sl_write_line_fast (pushdata_fd, fullpath, sl_strlen(fullpath));
	1977	sl_write_line_fast (pushdata_fd, linkpath, sl_strlen(linkpath));
[68]	1978	if (attr_string)
[76]	1979	sl_write_line_fast (pushdata_fd, attr_string, sl_strlen(attr_string));
[1]	1980	} else {
[153]	1981	if (fwrite (&p, sizeof(sh_filestore_t), 1, stdout))
	1982	{
	1983	printf ("%s\n", fullpath);
	1984	printf ("%s\n", linkpath);
	1985	if (attr_string)
	1986	printf ("%s\n", attr_string);
	1987	}
	1988	else
	1989	{
	1990	perror(_("Error writing database"));
	1991	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1992	}
[1]	1993	}
	1994
	1995	++p_count;
	1996
	1997	if ((sh.flag.update != S_TRUE) && (pushdata_stdout == S_FALSE))
	1998	{
[76]	1999	if (sh.flag.checkSum != SH_CHECK_INIT \|\| (buf == NULL && fileHash == NULL))
	2000	{
	2001	sl_close (pushdata_fd);
	2002	pushdata_fd = -1;
	2003	}
[1]	2004	}
	2005
	2006	SH_FREE(fullpath);
	2007	SH_FREE(linkpath);
[68]	2008	if (attr_string)
	2009	SH_FREE(attr_string);
[1]	2010
[149]	2011	SL_RET0(_("sh_hash_pushdata_int"));
[1]	2012	}
	2013
[149]	2014	SH_MUTEX_STATIC(mutex_writeout,PTHREAD_MUTEX_INITIALIZER);
	2015
	2016	void sh_hash_pushdata (file_type * buf, char * fileHash)
	2017	{
	2018	SH_MUTEX_LOCK(mutex_writeout);
	2019	sh_hash_pushdata_int (buf, fileHash);
	2020	SH_MUTEX_UNLOCK(mutex_writeout);
	2021	return;
	2022	}
	2023
	2024
[1]	2025	int sh_hash_writeout()
	2026	{
	2027	sh_file_t * p;
	2028	int i;
	2029	file_type * f;
	2030	char fileHash[KEY_LEN + 1];
	2031
	2032	SL_ENTER(_("sh_hash_writeout"));
	2033
	2034	if (S_TRUE == file_is_remote())
	2035	{
	2036	sh_error_handle((-1), FIL__, __LINE__, S_FALSE, MSG_E_SUBGEN,
	2037	_("Baseline database is remote"), _("sh_hash_writeout"));
	2038	SL_RETURN (1, _("sh_hash_writeout"));
	2039	}
	2040
[149]	2041	SH_MUTEX_LOCK(mutex_writeout);
[1]	2042	if (!SL_ISERROR(pushdata_fd))
	2043	{
	2044	sl_close(pushdata_fd);
	2045	pushdata_fd = -1;
	2046	}
	2047	pushdata_isfirst = 1;
	2048
[149]	2049
	2050	SH_MUTEX_LOCK(mutex_hash);
[1]	2051	for (i = 0; i < TABSIZE; ++i)
	2052	{
	2053	for (p = tab[i]; p; p = p->next)
	2054	{
	2055	f = sh_hash_create_ft (p, fileHash);
[149]	2056	sh_hash_pushdata_int (f, fileHash);
[167]	2057	if (f->attr_string) SH_FREE(f->attr_string);
	2058	if (f->link_path) SH_FREE(f->link_path);
[1]	2059	SH_FREE(f);
	2060	}
	2061	}
[149]	2062	SH_MUTEX_UNLOCK(mutex_hash);
[1]	2063
	2064	if (!SL_ISERROR(pushdata_fd))
	2065	{
	2066	sl_close(pushdata_fd);
	2067	pushdata_fd = -1;
	2068	}
	2069	pushdata_isfirst = 1;
[149]	2070	SH_MUTEX_UNLOCK(mutex_writeout);
[1]	2071
	2072	SL_RETURN (0, _("sh_hash_writeout"));
	2073	}
	2074
	2075
	2076	/*********************************************************************
	2077	*
	2078	* Check whether a file is present in the database.
	2079	*
	2080	*********************************************************************/
[294]	2081	static sh_file_t * sh_hash_have_it_int (const char * newname)
[1]	2082	{
	2083	sh_file_t * p;
[133]	2084	char hashbuf[KEYBUF_SIZE];
[1]	2085
[115]	2086	SL_ENTER(_("sh_hash_have_it_int"));
[1]	2087
	2088	if (newname == NULL)
[115]	2089	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
[1]	2090
	2091	if (sl_strlen(newname) <= MAX_PATH_STORE)
	2092	p = hashsearch(newname);
	2093	else
[133]	2094	p = hashsearch ( sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
	2095	hashbuf, sizeof(hashbuf)) );
[1]	2096	if (p == NULL)
[115]	2097	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
[149]	2098
[115]	2099	SL_RETURN( (p), _("sh_hash_have_it_int"));
[1]	2100	}
	2101
[294]	2102	int sh_hash_have_it (const char * newname)
[1]	2103	{
[149]	2104	sh_file_t * p;
[170]	2105	int retval;
[1]	2106
[149]	2107	if (IsInit != 1)
	2108	sh_hash_init();
	2109
	2110	SH_MUTEX_LOCK(mutex_hash);
[170]	2111
	2112	retval = 0;
	2113
[149]	2114	p = sh_hash_have_it_int (newname);
	2115
	2116	if (!p)
	2117	retval = (-1);
	2118	else if ((!SH_FFLAG_ALLIGNORE_SET(p->fflags)) &&
	2119	(p->modi_mask & MODI_CHK) != 0 &&
	2120	(p->modi_mask & MODI_MOD) != 0)
	2121	retval = 1;
	2122	SH_MUTEX_UNLOCK(mutex_hash);
	2123
	2124	return retval;
[1]	2125	}
	2126
[294]	2127	int sh_hash_get_it (const char * newname, file_type * tmpFile, char * fileHash)
[1]	2128	{
[149]	2129	sh_file_t * p;
[170]	2130	int retval;
[68]	2131
[149]	2132	if (IsInit != 1)
	2133	sh_hash_init();
	2134
[167]	2135	tmpFile->link_path = NULL;
	2136	tmpFile->attr_string = NULL;
	2137
[149]	2138	SH_MUTEX_LOCK(mutex_hash);
[170]	2139
	2140	retval = (-1);
	2141
[149]	2142	p = sh_hash_have_it_int (newname);
	2143	if (p)
	2144	{
[167]	2145	sl_strlcpy(tmpFile->fullpath, p->fullpath, PATH_MAX);
	2146	if (p->linkpath)
	2147	tmpFile->link_path = sh_util_strdup (p->linkpath);
[149]	2148	tmpFile->size = p->theFile.size;
	2149	tmpFile->mtime = p->theFile.mtime;
	2150	tmpFile->ctime = p->theFile.ctime;
[294]	2151	tmpFile->atime = p->theFile.atime;
	2152
	2153	if (NULL != fileHash)
	2154	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	2155
[149]	2156	tmpFile->attr_string = NULL;
	2157	retval = 0;
	2158	}
	2159	SH_MUTEX_UNLOCK(mutex_hash);
	2160
	2161	return retval;
[1]	2162	}
	2163
[115]	2164	int sh_hash_getflags (char * filename)
	2165	{
[149]	2166	sh_file_t * p;
[463]	2167	int retval = 0;
[149]	2168
[463]	2169	if ( sh.flag.checkSum != SH_CHECK_INIT )
	2170	{
	2171	if (IsInit != 1)
	2172	sh_hash_init();
	2173
	2174	SH_MUTEX_LOCK(mutex_hash);
	2175	p = sh_hash_have_it_int (filename);
	2176	if (p)
	2177	retval = p->fflags;
	2178	else
	2179	retval = -1;
	2180	SH_MUTEX_UNLOCK(mutex_hash);
	2181	}
[149]	2182	return retval;
[115]	2183	}
	2184
	2185	int sh_hash_setflags (char * filename, int flags)
	2186	{
[149]	2187	sh_file_t * p;
[463]	2188	int retval = 0;
[149]	2189
[463]	2190	if ( sh.flag.checkSum != SH_CHECK_INIT )
[149]	2191	{
[463]	2192	if (IsInit != 1)
	2193	sh_hash_init();
	2194
	2195	SH_MUTEX_LOCK(mutex_hash);
	2196	p = sh_hash_have_it_int (filename);
	2197	if (p)
	2198	{
	2199	p->fflags = flags;
	2200	retval = 0;
	2201	}
	2202	else
	2203	retval = -1;
	2204	SH_MUTEX_UNLOCK(mutex_hash);
[149]	2205	}
	2206	return retval;
[115]	2207	}
	2208
	2209	/* needs lock to be threadsafe
	2210	*/
[458]	2211	void sh_hash_set_flag (char * filename, int flag_to_set)
[115]	2212	{
[149]	2213	sh_file_t * p;
[115]	2214
[463]	2215	if ( sh.flag.checkSum != SH_CHECK_INIT )
[115]	2216	{
[463]	2217	if (IsInit != 1)
	2218	sh_hash_init();
	2219
	2220	SH_MUTEX_LOCK(mutex_hash);
	2221	p = sh_hash_have_it_int (filename);
	2222	if (p)
	2223	{
	2224	p->fflags \|= flag_to_set;
	2225	}
	2226	SH_MUTEX_UNLOCK(mutex_hash);
[115]	2227	}
	2228	return;
	2229	}
	2230
[458]	2231	/* needs lock to be threadsafe
	2232	*/
	2233	void sh_hash_clear_flag (char * filename, int flag_to_clear)
	2234	{
	2235	sh_file_t * p;
	2236
[463]	2237	if ( sh.flag.checkSum != SH_CHECK_INIT )
[458]	2238	{
[463]	2239	if (IsInit != 1)
	2240	sh_hash_init();
	2241
	2242	SH_MUTEX_LOCK(mutex_hash);
	2243	p = sh_hash_have_it_int (filename);
	2244	if (p)
	2245	{
	2246	p->fflags &= ~flag_to_clear;
	2247	}
	2248	SH_MUTEX_UNLOCK(mutex_hash);
[458]	2249	}
	2250	return;
	2251	}
	2252
	2253
[1]	2254	/*****************************************************************
	2255	*
	2256	* Set a file's status to 'visited'. This is required for
	2257	* files that should be ignored, and may be present in the
	2258	* database, but not on disk.
	2259	*
	2260	*****************************************************************/
	2261	static int sh_hash_set_visited_int (char * newname, int flag)
	2262	{
	2263	sh_file_t * p;
[133]	2264	char hashbuf[KEYBUF_SIZE];
[170]	2265	int retval;
[1]	2266
	2267	SL_ENTER(_("sh_hash_set_visited_int"));
	2268
	2269	if (newname == NULL)
	2270	SL_RETURN((-1), _("sh_hash_set_visited_int"));
[149]	2271
[1]	2272	if (IsInit != 1)
	2273	sh_hash_init();
	2274
[149]	2275	SH_MUTEX_LOCK(mutex_hash);
	2276
[1]	2277	if (sl_strlen(newname) <= MAX_PATH_STORE)
	2278	p = hashsearch(newname);
	2279	else
[133]	2280	p = hashsearch (sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
	2281	hashbuf, sizeof(hashbuf)));
[1]	2282
[149]	2283	if (p)
[1]	2284	{
[149]	2285	if (flag == SH_FFLAG_CHECKED)
	2286	{
	2287	CLEAR_SH_FFLAG_REPORTED(p->fflags);
	2288	CLEAR_SH_FFLAG_VISITED(p->fflags);
	2289	SET_SH_FFLAG_CHECKED(p->fflags);
	2290	}
[114]	2291	else
[149]	2292	{
	2293	SET_SH_FFLAG_VISITED(p->fflags);
	2294	CLEAR_SH_FFLAG_CHECKED(p->fflags);
	2295	if (flag == SH_FFLAG_REPORTED)
	2296	SET_SH_FFLAG_REPORTED(p->fflags);
	2297	else
	2298	CLEAR_SH_FFLAG_REPORTED(p->fflags);
	2299	}
	2300	retval = 0;
[1]	2301	}
[170]	2302	else
	2303	retval = -1;
[149]	2304
	2305	SH_MUTEX_UNLOCK(mutex_hash);
	2306	SL_RETURN((retval), _("sh_hash_set_visited_int"));
[1]	2307	}
	2308
	2309
	2310	/* cause the record to be deleted without a 'missing' message
	2311	*/
	2312	int sh_hash_set_missing (char * newname)
	2313	{
	2314	int i;
[294]	2315	SL_ENTER(_("sh_hash_set_missing"));
[305]	2316
[114]	2317	i = sh_hash_set_visited_int(newname, SH_FFLAG_CHECKED);
[305]	2318
	2319	if (sh.flag.checkSum != SH_CHECK_INIT) {
	2320	sh_hash_remove(newname);
	2321	}
	2322
[294]	2323	SL_RETURN(i, _("sh_hash_set_missing"));
[1]	2324	}
	2325
[114]	2326	/* mark the file as visited and reported
	2327	*/
[1]	2328	int sh_hash_set_visited (char * newname)
	2329	{
	2330	int i;
	2331	SL_ENTER(_("sh_hash_set_visited"));
[114]	2332	i = sh_hash_set_visited_int(newname, SH_FFLAG_REPORTED);
[1]	2333	SL_RETURN(i, _("sh_hash_set_visited"));
	2334	}
	2335
[114]	2336	/* mark the file as visited and NOT reported
	2337	* used to avoid deletion of file from internal database
	2338	*/
[1]	2339	int sh_hash_set_visited_true (char * newname)
	2340	{
	2341	int i;
	2342	SL_ENTER(_("sh_hash_set_visited_true"));
[114]	2343	i = sh_hash_set_visited_int(newname, 0);
[1]	2344	SL_RETURN(i, _("sh_hash_set_visited_true"));
	2345	}
	2346
	2347
	2348	/******************************************************************
	2349	*
	2350	* Data entry for arbitrary data into database
	2351	*
	2352	******************************************************************/
	2353
[294]	2354	void sh_hash_push2db (const char * key, struct store2db * save)
[1]	2355	{
	2356	int i = 0;
	2357	char * p;
[137]	2358	char i2h[2];
[227]	2359	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
[1]	2360
[294]	2361	int size = save->size;
	2362	unsigned char * str = save->str;
	2363
	2364
[227]	2365	tmpFile->attr_string = NULL;
	2366	tmpFile->link_path = NULL;
[68]	2367
[227]	2368	sl_strlcpy(tmpFile->fullpath, key, PATH_MAX);
[294]	2369	tmpFile->size = save->val0;
	2370	tmpFile->mtime = save->val1;
	2371	tmpFile->ctime = save->val2;
	2372	tmpFile->atime = save->val3;
[1]	2373
[227]	2374	tmpFile->mode = 0;
	2375	tmpFile->owner = 0;
	2376	tmpFile->group = 0;
	2377	sl_strlcpy(tmpFile->c_owner, _("root"), 5);
	2378	sl_strlcpy(tmpFile->c_group, _("root"), 5);
[1]	2379
	2380	if ((str != NULL) && (size < (PATH_MAX/2)-1))
	2381	{
[227]	2382	tmpFile->c_mode[0] = 'l';
	2383	tmpFile->c_mode[1] = 'r'; tmpFile->c_mode[2] = 'w';
	2384	tmpFile->c_mode[3] = 'x'; tmpFile->c_mode[4] = 'r';
	2385	tmpFile->c_mode[5] = 'w'; tmpFile->c_mode[6] = 'x';
	2386	tmpFile->c_mode[7] = 'r'; tmpFile->c_mode[8] = 'w';
	2387	tmpFile->c_mode[9] = 'x'; tmpFile->c_mode[10] = '\0';
	2388	tmpFile->link_path = SH_ALLOC((size * 2) + 2);
[1]	2389	for (i = 0; i < size; ++i)
	2390	{
[137]	2391	p = sh_util_charhex (str[i],i2h);
[227]	2392	tmpFile->link_path[2*i] = p[0];
	2393	tmpFile->link_path[2*i+1] = p[1];
	2394	tmpFile->link_path[2*i+2] = '\0';
[1]	2395	}
	2396	}
	2397	else
	2398	{
[93]	2399	for (i = 0; i < 10; ++i)
[227]	2400	tmpFile->c_mode[i] = '-';
	2401	tmpFile->c_mode[10] = '\0';
	2402	tmpFile->link_path = sh_util_strdup("-");
[1]	2403	}
	2404
[294]	2405	if (sh.flag.checkSum == SH_CHECK_INIT)
	2406	sh_hash_pushdata (tmpFile,
	2407	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
[1]	2408	else
[294]	2409	sh_hash_pushdata_memory (tmpFile,
	2410	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
[1]	2411
[227]	2412	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	2413	SH_FREE(tmpFile);
[1]	2414	return;
	2415	}
	2416
	2417	extern int sh_util_hextobinary (char * binary, char * hex, int bytes);
	2418
[294]	2419	char * sh_hash_db2pop (const char * key, struct store2db * save)
[1]	2420	{
	2421	size_t len;
	2422	char * p;
	2423	int i;
[167]	2424	char * retval = NULL;
[294]	2425	char fileHash[KEY_LEN+1];
[227]	2426	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
[167]	2427
[294]	2428	save->size = 0;
[1]	2429
[294]	2430	if (0 == sh_hash_get_it (key, tmpFile, fileHash))
[1]	2431	{
[294]	2432	save->val0 = tmpFile->size;
	2433	save->val1 = tmpFile->mtime;
	2434	save->val2 = tmpFile->ctime;
	2435	save->val3 = tmpFile->atime;
[1]	2436
[294]	2437	sl_strlcpy(save->checksum, fileHash, KEY_LEN+1);
	2438
[227]	2439	if (tmpFile->link_path && tmpFile->link_path[0] != '-')
[1]	2440	{
[227]	2441	len = strlen(tmpFile->link_path);
[1]	2442
	2443	p = SH_ALLOC((len/2)+1);
[227]	2444	i = sh_util_hextobinary (p, tmpFile->link_path, len);
[1]	2445
	2446	if (i == 0)
	2447	{
[294]	2448	save->size = (len/2);
	2449	p[save->size] = '\0';
[167]	2450	retval = p;
[1]	2451	}
	2452	else
	2453	{
	2454	SH_FREE(p);
[294]	2455	save->size = 0;
[1]	2456	}
	2457	}
	2458	else
	2459	{
[294]	2460	save->size = 0;
[1]	2461	}
	2462	}
	2463	else
	2464	{
[294]	2465	save->size = -1;
	2466	save->val0 = 0;
	2467	save->val1 = 0;
	2468	save->val2 = 0;
	2469	save->val3 = 0;
[1]	2470	}
[227]	2471	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	2472	SH_FREE(tmpFile);
[167]	2473	return retval;
[1]	2474	}
	2475
	2476
	2477
	2478
	2479	/******************************************************************
	2480	*
	2481	* Data entry in hash table
	2482	*
	2483	******************************************************************/
	2484	sh_file_t * sh_hash_push_int (file_type * buf, char * fileHash)
	2485	{
	2486	sh_file_t * fp;
	2487	sh_filestore_t p;
[34]	2488
	2489	size_t len;
[1]	2490	char * fullpath;
	2491	char * linkpath;
[68]	2492	char * attr_string = NULL;
[133]	2493	char hashbuf[KEYBUF_SIZE];
[1]	2494
	2495	SL_ENTER(_("sh_hash_push_int"));
	2496
	2497	fp = SH_ALLOC(sizeof(sh_file_t));
	2498
	2499	p.mark = REC_MAGIC;
[68]	2500	if (buf->attr_string)
	2501	p.mark \|= REC_FLAGS_ATTR;
[1]	2502	sl_strlcpy(p.c_mode, buf->c_mode, 11);
	2503	sl_strlcpy(p.c_group, buf->c_group, GROUP_MAX+1);
	2504	sl_strlcpy(p.c_owner, buf->c_owner, USER_MAX+1);
	2505	sl_strlcpy(p.checksum, fileHash, KEY_LEN+1);
[10]	2506	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2507	sl_strlcpy(p.c_attributes, buf->c_attributes, 13);
	2508	#endif
	2509
[10]	2510	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2511	p.attributes = (UINT32) buf->attributes;
	2512	#endif
	2513	p.linkmode = (UINT32) buf->linkmode;
	2514	p.hardlinks = (UINT32) buf->hardlinks;
[40]	2515	p.dev = (UINT64) buf->dev;
	2516	p.rdev = (UINT64) buf->rdev;
[1]	2517	p.mode = (UINT32) buf->mode;
	2518	p.ino = (UINT32) buf->ino;
	2519	p.size = (UINT64) buf->size;
	2520	p.mtime = (UINT64) buf->mtime;
	2521	p.atime = (UINT64) buf->atime;
	2522	p.ctime = (UINT64) buf->ctime;
	2523	p.owner = (UINT32) buf->owner;
	2524	p.group = (UINT32) buf->group;
	2525
	2526	memcpy( &(*fp).theFile, &p, sizeof(sh_filestore_t) );
[115]	2527	fp->fflags = 0; /* init fflags */
[1]	2528	fp->modi_mask = 0L;
	2529
[68]	2530	if (buf->attr_string)
	2531	attr_string = sh_util_strdup(buf->attr_string);
	2532	fp->attr_string = attr_string;
	2533
[34]	2534	len = sl_strlen(buf->fullpath);
	2535	if (len <= MAX_PATH_STORE)
[1]	2536	{
[34]	2537	fullpath = SH_ALLOC(len+1);
	2538	sl_strlcpy(fullpath, buf->fullpath, len+1);
[1]	2539	}
	2540	else
	2541	{
	2542	fullpath = SH_ALLOC(KEY_LEN + 1);
	2543	sl_strlcpy(fullpath,
[133]	2544	sh_tiger_hash (buf->fullpath, TIGER_DATA, len,
	2545	hashbuf, sizeof(hashbuf)),
[1]	2546	KEY_LEN+1);
	2547	}
	2548	fp->fullpath = fullpath;
	2549
[167]	2550	if (buf->link_path)
[1]	2551	{
[167]	2552	len = sl_strlen(buf->link_path);
[34]	2553	if (len <= MAX_PATH_STORE)
[1]	2554	{
[34]	2555	linkpath = SH_ALLOC(len+1);
[167]	2556	sl_strlcpy(linkpath, buf->link_path, len+1);
[1]	2557	}
	2558	else
	2559	{
	2560	linkpath = SH_ALLOC(KEY_LEN + 1);
	2561	sl_strlcpy(linkpath,
[167]	2562	sh_tiger_hash (buf->link_path, TIGER_DATA, len,
[133]	2563	hashbuf, sizeof(hashbuf)),
[1]	2564	KEY_LEN+1);
	2565	}
	2566	fp->linkpath = linkpath;
	2567	}
	2568	else
	2569	fp->linkpath = NULL;
	2570
	2571	SL_RETURN( fp, _("sh_hash_push_int"));
	2572	}
	2573
	2574	#ifdef HAVE_INTTYPES_H
	2575	#include <inttypes.h>
	2576	#else
	2577	#ifdef HAVE_STDINT_H
	2578	#include <stdint.h>
	2579	#endif
	2580	#endif
	2581
[40]	2582	#ifndef PRIu64
	2583	#ifdef HAVE_LONG_32
	2584	#define PRIu64 "llu"
	2585	#else
	2586	#define PRIu64 "lu"
[1]	2587	#endif
[40]	2588	#endif
[1]	2589
	2590	char * sh_hash_size_format()
	2591	{
	2592	static char form_rval[81];
	2593
	2594	SL_ENTER(_("sh_hash_size_format"));
	2595
	2596
	2597	#ifdef SH_USE_XML
	2598	sl_snprintf(form_rval, 80, _("%s%s%s%s%s"),
[40]	2599	_("size_old=\"%"), PRIu64, _("\" size_new=\"%"), PRIu64, "\" ");
[1]	2600	#else
	2601	sl_snprintf(form_rval, 80, _("%s%s%s%s%s"),
[40]	2602	_("size_old=<%"), PRIu64, _(">, size_new=<%"), PRIu64, ">, ");
[1]	2603	#endif
	2604
	2605	SL_RETURN( form_rval, _("sh_hash_size_format"));
	2606	}
	2607
	2608
	2609	#ifdef SH_USE_XML
	2610	static char * all_items (file_type * theFile, char * fileHash, int is_new)
	2611	{
	2612	char timstr1c[32];
	2613	char timstr1a[32];
	2614	char timstr1m[32];
	2615
	2616	char * tmp_lnk;
	2617	char * format;
	2618
[170]	2619	char * tmp = SH_ALLOC(SH_MSG_BUF);
	2620	char * msg = SH_ALLOC(SH_MSG_BUF);
[1]	2621
	2622	tmp[0] = '\0';
	2623	msg[0] = '\0';
	2624
	2625
[10]	2626	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2627	if (is_new)
	2628	format = _("mode_new=\"%s\" attr_new=\"%s\" imode_new=\"%ld\" iattr_new=\"%ld\" ");
	2629	else
	2630	format = _("mode_old=\"%s\" attr_old=\"%s\" imode_old=\"%ld\" iattr_old=\"%ld\" ");
[170]	2631	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2632	theFile->c_mode,
	2633	theFile->c_attributes,
	2634	(long) theFile->mode,
	2635	(long) theFile->attributes
	2636	);
	2637	#else
	2638	if (is_new)
	2639	format = _("mode_new=\"%s\" imode_new=\"%ld\" ");
	2640	else
	2641	format = _("mode_old=\"%s\" imode_old=\"%ld\" ");
	2642
[170]	2643	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2644	theFile->c_mode,
	2645	(long) theFile->mode
	2646	);
	2647	#endif
[170]	2648	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2649
	2650	if (is_new)
[40]	2651	format = _("hardlinks_new=\"%lu\" ");
[1]	2652	else
[40]	2653	format = _("hardlinks_old=\"%lu\" ");
[170]	2654	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2655	(unsigned long) theFile->hardlinks);
[170]	2656	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2657
	2658
	2659	if (is_new)
[40]	2660	format = _("idevice_new=\"%lu\" ");
[1]	2661	else
[40]	2662	format = _("idevice_old=\"%lu\" ");
[170]	2663	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
	2664	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2665
	2666
	2667	if (is_new)
[40]	2668	format = _("inode_new=\"%lu\" ");
[1]	2669	else
[40]	2670	format = _("inode_old=\"%lu\" ");
[170]	2671	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
	2672	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2673
[40]	2674	/*
	2675	* also report device for prelude
	2676	*/
[181]	2677	#if defined(HAVE_LIBPRELUDE)
[40]	2678	if (is_new)
	2679	format = _("dev_new=\"%lu,%lu\" ");
	2680	else
	2681	format = _("dev_old=\"%lu,%lu\" ");
[170]	2682	sl_snprintf(tmp, SH_MSG_BUF, format,
[40]	2683	(unsigned long) major(theFile->dev),
	2684	(unsigned long) minor(theFile->dev));
[170]	2685	sl_strlcat(msg, tmp, SH_MSG_BUF);
[40]	2686	#endif
[1]	2687
[40]	2688
[1]	2689	if (is_new)
	2690	format = _("owner_new=\"%s\" iowner_new=\"%ld\" ");
	2691	else
	2692	format = _("owner_old=\"%s\" iowner_old=\"%ld\" ");
[170]	2693	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2694	theFile->c_owner, (long) theFile->owner);
[170]	2695	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2696
	2697
	2698	if (is_new)
	2699	format = _("group_new=\"%s\" igroup_new=\"%ld\" ");
	2700	else
	2701	format = _("group_old=\"%s\" igroup_old=\"%ld\" ");
[170]	2702	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2703	theFile->c_group, (long) theFile->group);
[170]	2704	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2705
	2706
	2707	if (is_new)
[170]	2708	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	2709	(UINT64) 0, (UINT64) theFile->size);
	2710	else
[170]	2711	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	2712	(UINT64) theFile->size, (UINT64) 0);
[170]	2713	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2714
	2715
[132]	2716	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
[1]	2717	if (is_new)
[170]	2718	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=\"%s\" "), timstr1c);
[1]	2719	else
[170]	2720	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" "), timstr1c);
	2721	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2722
[132]	2723	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
[1]	2724	if (is_new)
[170]	2725	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=\"%s\" "), timstr1a);
[1]	2726	else
[170]	2727	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" "), timstr1a);
	2728	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2729
[132]	2730	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
[1]	2731	if (is_new)
[170]	2732	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=\"%s\" "), timstr1m);
[1]	2733	else
[170]	2734	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" "), timstr1m);
	2735	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2736
	2737	if (is_new)
[170]	2738	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=\"%s\" "), fileHash);
[1]	2739	else
[170]	2740	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=\"%s\" "), fileHash);
	2741	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2742
[169]	2743	if (theFile->c_mode[0] == 'l' \|\|
	2744	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
[1]	2745	{
[167]	2746	tmp_lnk = sh_util_safe_name(theFile->link_path);
[1]	2747	if (tmp_lnk)
	2748	{
	2749	if (is_new)
[170]	2750	sl_snprintf(tmp, SH_MSG_BUF, _("link_new=\"%s\" "), tmp_lnk);
[1]	2751	else
[170]	2752	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" "), tmp_lnk);
[1]	2753	SH_FREE(tmp_lnk);
[170]	2754	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2755	}
	2756	}
[68]	2757
	2758	if (theFile->attr_string)
	2759	{
	2760	tmp_lnk = sh_util_safe_name(theFile->attr_string);
	2761	if (tmp_lnk)
	2762	{
	2763	if (is_new)
[170]	2764	sl_snprintf(tmp, SH_MSG_BUF, _("acl_new=\"%s\" "), tmp_lnk);
[68]	2765	else
[170]	2766	sl_snprintf(tmp, SH_MSG_BUF, _("acl_old=\"%s\" "), tmp_lnk);
[68]	2767	SH_FREE(tmp_lnk);
[170]	2768	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	2769	}
	2770	}
	2771
[1]	2772
	2773	SH_FREE(tmp);
	2774	return (msg);
	2775	}
	2776	#else
	2777	static char * all_items (file_type * theFile, char * fileHash, int is_new)
	2778	{
	2779	char timstr1c[32];
	2780	char timstr1a[32];
	2781	char timstr1m[32];
	2782
	2783	char * tmp_lnk;
	2784	char * format;
	2785
[170]	2786	char * tmp = SH_ALLOC(SH_MSG_BUF);
	2787	char * msg = SH_ALLOC(SH_MSG_BUF);
[1]	2788
	2789	tmp[0] = '\0';
	2790	msg[0] = '\0';
	2791
	2792
[10]	2793	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2794	if (is_new)
	2795	format = _("mode_new=<%s>, attr_new=<%s>, imode_new=<%ld>, iattr_new=<%ld>, ");
	2796	else
	2797	format = _("mode_old=<%s>, attr_old=<%s>, imode_old=<%ld>, iattr_old=<%ld>, ");
[170]	2798	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2799	theFile->c_mode,
	2800	theFile->c_attributes,
	2801	(long) theFile->mode,
	2802	(long) theFile->attributes
	2803	);
	2804	#else
	2805	if (is_new)
	2806	format = _("mode_new=<%s>, imode_new=<%ld>, ");
	2807	else
	2808	format = _("mode_old=<%s>, imode_old=<%ld>, ");
	2809
[170]	2810	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2811	theFile->c_mode,
	2812	(long) theFile->mode
	2813	);
	2814	#endif
[170]	2815	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2816
	2817	if (is_new)
[40]	2818	format = _("hardlinks_new=<%lu>, ");
[1]	2819	else
[40]	2820	format = _("hardlinks_old=<%lu>, ");
[170]	2821	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2822	(unsigned long) theFile->hardlinks);
[170]	2823	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2824
	2825
	2826	if (is_new)
[40]	2827	format = _("idevice_new=<%lu>, ");
[1]	2828	else
[40]	2829	format = _("idevice_old=<%lu>, ");
[170]	2830	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
	2831	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2832
	2833
	2834	if (is_new)
[40]	2835	format = _("inode_new=<%lu>, ");
[1]	2836	else
[40]	2837	format = _("inode_old=<%lu>, ");
[170]	2838	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
	2839	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2840
	2841
[40]	2842	/*
	2843	* also report device for prelude
	2844	*/
[181]	2845	#if defined(HAVE_LIBPRELUDE)
[1]	2846	if (is_new)
[40]	2847	format = _("dev_new=<%lu,%lu>, ");
	2848	else
	2849	format = _("dev_old=<%lu,%lu>, ");
[170]	2850	sl_snprintf(tmp, SH_MSG_BUF, format,
[40]	2851	(unsigned long) major(theFile->dev),
	2852	(unsigned long) minor(theFile->dev));
[170]	2853	sl_strlcat(msg, tmp, SH_MSG_BUF);
[40]	2854	#endif
	2855
	2856	if (is_new)
[1]	2857	format = _("owner_new=<%s>, iowner_new=<%ld>, ");
	2858	else
	2859	format = _("owner_old=<%s>, iowner_old=<%ld>, ");
[170]	2860	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2861	theFile->c_owner, (long) theFile->owner);
[170]	2862	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2863
	2864
	2865	if (is_new)
	2866	format = _("group_new=<%s>, igroup_new=<%ld>, ");
	2867	else
	2868	format = _("group_old=<%s>, igroup_old=<%ld>, ");
[170]	2869	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	2870	theFile->c_group, (long) theFile->group);
[170]	2871	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2872
	2873
	2874	if (is_new)
[170]	2875	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	2876	(UINT64) 0, (UINT64) theFile->size);
	2877	else
[170]	2878	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	2879	(UINT64) theFile->size, (UINT64) 0);
[170]	2880	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2881
	2882
[132]	2883	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
[1]	2884	if (is_new)
[170]	2885	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=<%s>, "), timstr1c);
[1]	2886	else
[170]	2887	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, "), timstr1c);
	2888	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2889
[132]	2890	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
[1]	2891	if (is_new)
[170]	2892	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=<%s>, "), timstr1a);
[1]	2893	else
[170]	2894	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, "), timstr1a);
	2895	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2896
[132]	2897	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
[1]	2898	if (is_new)
[170]	2899	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=<%s>, "), timstr1m);
[1]	2900	else
[170]	2901	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, "), timstr1m);
	2902	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2903
	2904	if (is_new)
[170]	2905	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=<%s>"), fileHash);
[1]	2906	else
[170]	2907	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=<%s>"), fileHash);
	2908	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2909
[169]	2910	if (theFile->c_mode[0] == 'l' \|\|
	2911	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
[1]	2912	{
[167]	2913	tmp_lnk = sh_util_safe_name(theFile->link_path);
[1]	2914	if (tmp_lnk)
	2915	{
	2916	if (is_new)
[170]	2917	sl_snprintf(tmp, SH_MSG_BUF, _(", link_new=<%s> "), tmp_lnk);
[1]	2918	else
[170]	2919	sl_snprintf(tmp, SH_MSG_BUF, _(", link_old=<%s> "), tmp_lnk);
[1]	2920	SH_FREE(tmp_lnk);
[170]	2921	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	2922	}
	2923	}
	2924
[68]	2925	if (theFile->attr_string)
	2926	{
	2927	tmp_lnk = sh_util_safe_name(theFile->attr_string);
	2928	if (tmp_lnk)
	2929	{
	2930	if (is_new)
[170]	2931	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_new=<%s> "), tmp_lnk);
[68]	2932	else
[170]	2933	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_old=<%s> "), tmp_lnk);
[68]	2934	SH_FREE(tmp_lnk);
[170]	2935	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	2936	}
	2937	}
	2938
[1]	2939	SH_FREE(tmp);
	2940	return (msg);
	2941	}
	2942	#endif
	2943
	2944	void sh_hash_pushdata_memory (file_type * theFile, char * fileHash)
	2945	{
	2946	sh_file_t * p;
	2947
	2948	SL_ENTER(_("sh_hash_pushdata_memory"));
	2949
	2950	p = sh_hash_push_int(theFile, fileHash);
	2951	if (p)
	2952	{
[149]	2953	SH_MUTEX_LOCK(mutex_hash);
[1]	2954	hashinsert (p);
	2955	p->modi_mask = theFile->check_mask;
[149]	2956	SH_MUTEX_UNLOCK(mutex_hash);
[1]	2957	}
	2958
	2959	SL_RET0(_("sh_hash_pushdata_memory"));
	2960	}
	2961
	2962
	2963	/*****************************************************************
	2964	*
	2965	* Compare a file with the database status.
	2966	*
	2967	*****************************************************************/
	2968	int sh_hash_compdata (int class, file_type * theFile, char * fileHash,
	2969	char * policy_override, int severity_override)
	2970	{
	2971	char * msg;
	2972	sh_file_t * p;
	2973	char * tmp;
	2974	char * tmp_path;
	2975	char * tmp_lnk;
	2976	char * tmp_lnk_old;
	2977
	2978	char * str;
	2979
	2980	char timstr1c[32];
	2981	char timstr2c[32];
	2982	char timstr1a[32];
	2983	char timstr2a[32];
	2984	char timstr1m[32];
	2985	char timstr2m[32];
	2986	char linkHash[KEY_LEN+1];
[169]	2987	char * linkComp;
[1]	2988	int maxcomp;
	2989
	2990	char change_code[16];
	2991	int i;
	2992
[170]	2993	unsigned long modi_mask;
[1]	2994
	2995	char log_policy[32];
[153]	2996	volatile int log_severity;
[133]	2997	char hashbuf[KEYBUF_SIZE];
[1]	2998
[170]	2999	int retval;
[149]	3000
[1]	3001	SL_ENTER(_("sh_hash_compdata"));
	3002
	3003	if (IsInit != 1) sh_hash_init();
	3004
	3005	if (severity_override < 0)
	3006	log_severity = ShDFLevel[class];
	3007	else
	3008	log_severity = severity_override;
	3009
	3010	if (policy_override != NULL)
	3011	sl_strlcpy (log_policy, policy_override, 32);
	3012
	3013	/* -------- find the entry for the file ---------------- */
	3014
[149]	3015	SH_MUTEX_LOCK(mutex_hash);
	3016
[170]	3017	modi_mask = 0;
	3018	retval = 0;
	3019
[1]	3020	if (sl_strlen(theFile->fullpath) <= MAX_PATH_STORE)
	3021	p = hashsearch(theFile->fullpath);
	3022	else
	3023	p = hashsearch( sh_tiger_hash(theFile->fullpath,
	3024	TIGER_DATA,
[133]	3025	sl_strlen(theFile->fullpath),
	3026	hashbuf, sizeof(hashbuf))
[1]	3027	);
	3028
	3029
	3030	/* --------- Not found in database. ------------
	3031	*/
	3032
	3033	if (p == NULL)
	3034	{
	3035	if (S_FALSE == sh_ignore_chk_new(theFile->fullpath))
	3036	{
	3037	tmp = sh_util_safe_name(theFile->fullpath);
	3038
	3039	str = all_items (theFile, fileHash, 1);
	3040	sh_error_handle (log_severity, FIL__, __LINE__, 0,
	3041	MSG_FI_ADD2,
	3042	tmp, str);
[405]	3043	++sh.statistics.files_report;
[1]	3044	SH_FREE(str);
	3045
	3046	SH_FREE(tmp);
	3047	}
	3048
	3049	if (sh.flag.reportonce == S_TRUE)
[114]	3050	SET_SH_FFLAG_REPORTED(theFile->file_reported);
[77]	3051
	3052	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
[1]	3053	{
[77]	3054	p = sh_hash_push_int(theFile, fileHash);
	3055	if (p)
[149]	3056	{
	3057	hashinsert (p);
	3058	p->modi_mask = theFile->check_mask;
	3059	}
[77]	3060	}
	3061
	3062	else if (S_TRUE == sh.flag.update)
	3063	{
	3064	if (S_TRUE == sh_util_ask_update (theFile->fullpath))
[1]	3065	{
[77]	3066	p = sh_hash_push_int(theFile, fileHash);
	3067	if (p)
[149]	3068	{
	3069	hashinsert (p);
	3070	p->modi_mask = theFile->check_mask;
	3071	}
[77]	3072	}
	3073	else
	3074	{
[149]	3075	retval = 1;
	3076	goto unlock_and_return;
[77]	3077	}
[1]	3078	}
[149]	3079
	3080	goto unlock_and_return;
[1]	3081	}
	3082
[425]	3083	/* --------- Skip if we don't want to report changes. ------------
	3084	*/
	3085
	3086	if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
	3087	{
	3088	goto unlock_and_return;
	3089	}
	3090
[149]	3091	p->modi_mask = theFile->check_mask;
	3092
[1]	3093	/* initialize change_code */
	3094	for (i = 0; i < 15; ++i)
	3095	change_code[i] = '-';
	3096	change_code[15] = '\0';
	3097
	3098	TPT ((0, FIL__, __LINE__, _("file=<%s>, cs_old=<%s>, cs_new=<%s>\n"),
	3099	theFile->fullpath, fileHash, p->theFile.checksum));
	3100
	3101	if ( (fileHash != NULL) && (p->theFile.checksum != NULL) &&
[19]	3102	(strncmp (fileHash, p->theFile.checksum, KEY_LEN) != 0) &&
[1]	3103	(theFile->check_mask & MODI_CHK) != 0)
	3104	{
[19]	3105	if ((theFile->check_mask & MODI_SGROW) == 0)
	3106	{
	3107	modi_mask \|= MODI_CHK;
	3108	change_code[0] = 'C';
	3109	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
	3110	}
	3111	else
	3112	{
[425]	3113	if (0 != strncmp (&fileHash[KEY_LEN + 1], p->theFile.checksum, KEY_LEN))
[19]	3114	{
[425]	3115	if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
	3116	(UINT64) p->theFile.ino, p->theFile.checksum))
	3117	{
	3118	modi_mask \|= MODI_CHK;
	3119	change_code[0] = 'C';
	3120	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
	3121	}
	3122	else
	3123	{
	3124	/* logfile has been rotated */
	3125	p->theFile.size = theFile->size;
	3126	p->theFile.ino = theFile->ino;
	3127	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	3128	}
[19]	3129	}
	3130	else
	3131	{
	3132	p->theFile.size = theFile->size;
	3133	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	3134	}
	3135	}
[1]	3136	}
	3137
	3138	if (p->theFile.c_mode[0] == 'l')
	3139	{
[169]	3140	if (!(theFile->link_path) &&
	3141	(theFile->check_mask & MODI_LNK) != 0)
[1]	3142	{
[169]	3143	linkComp = NULL;
[93]	3144	modi_mask \|= MODI_LNK;
	3145	change_code[1] = 'L';
	3146	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
[169]	3147	}
	3148	else
	3149	{
	3150	if (sl_strlen(theFile->link_path) >= MAX_PATH_STORE)
	3151	{
	3152	sl_strlcpy(linkHash,
	3153	sh_tiger_hash(theFile->link_path,
	3154	TIGER_DATA,
	3155	sl_strlen(theFile->link_path),
	3156	hashbuf, sizeof(hashbuf)),
	3157	MAX_PATH_STORE+1);
	3158	linkComp = linkHash;
	3159	maxcomp = KEY_LEN;
	3160	}
	3161	else
	3162	{
	3163	linkComp = theFile->link_path;
	3164	maxcomp = MAX_PATH_STORE;
	3165	}
	3166
	3167	if ( sl_strncmp (linkComp, p->linkpath, maxcomp) != 0 &&
	3168	(theFile->check_mask & MODI_LNK) != 0)
	3169	{
	3170	modi_mask \|= MODI_LNK;
	3171	change_code[1] = 'L';
	3172	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
	3173	}
	3174	}
[1]	3175	}
	3176
	3177	if (p->theFile.c_mode[0] == 'c' \|\| p->theFile.c_mode[0] == 'b')
	3178	{
	3179	if ( ( major(theFile->rdev) != major((dev_t)p->theFile.rdev) \|\|
	3180	minor(theFile->rdev) != minor((dev_t)p->theFile.rdev) ) &&
	3181	(theFile->check_mask & MODI_RDEV) != 0)
	3182	{
	3183	modi_mask \|= MODI_RDEV;
	3184	change_code[2] = 'D';
	3185	TPT ((0, FIL__, __LINE__, _("mod=<rdev>")));
	3186	}
	3187	}
	3188
	3189	/* cast to UINT32 in case ino_t is not 32bit
	3190	*/
	3191	if ( (UINT32) theFile->ino != (UINT32) p->theFile.ino &&
	3192	(theFile->check_mask & MODI_INO) != 0)
	3193	{
	3194	modi_mask \|= MODI_INO;
	3195	change_code[3] = 'I';
	3196	TPT ((0, FIL__, __LINE__, _("mod=<inode>")));
	3197	}
	3198
	3199	if ( theFile->hardlinks != (nlink_t) p->theFile.hardlinks &&
	3200	(theFile->check_mask & MODI_HLN) != 0)
	3201	{
	3202	modi_mask \|= MODI_HLN;
	3203	change_code[4] = 'H';
	3204	TPT ((0, FIL__, __LINE__, _("mod=<hardlink>")));
	3205	}
	3206
	3207
	3208	if ( ( (theFile->mode != p->theFile.mode)
[68]	3209	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	3210	\|\| ( (sh_unix_check_selinux\|sh_unix_check_acl) &&
	3211	(
	3212	(theFile->attr_string == NULL && p->attr_string != NULL) \|\|
	3213	(theFile->attr_string != NULL && p->attr_string == NULL) \|\|
	3214	(theFile->attr_string != NULL && 0 != strcmp(theFile->attr_string, p->attr_string))
	3215	)
	3216	)
	3217	#endif
[10]	3218	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	3219	\|\| (theFile->attributes != p->theFile.attributes)
	3220	#endif
[68]	3221	)
[1]	3222	&& (theFile->check_mask & MODI_MOD) != 0)
	3223	{
	3224	modi_mask \|= MODI_MOD;
	3225	change_code[5] = 'M';
	3226	TPT ((0, FIL__, __LINE__, _("mod=<mode>")));
	3227	/*
	3228	* report link path if switch link/no link
	3229	*/
	3230	if ((theFile->check_mask & MODI_LNK) != 0 &&
	3231	(theFile->c_mode[0] != p->theFile.c_mode[0]) &&
	3232	(theFile->c_mode[0] == 'l' \|\| p->theFile.c_mode[0] == 'l'))
	3233	{
	3234	modi_mask \|= MODI_LNK;
	3235	change_code[1] = 'L';
	3236	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
	3237	}
	3238	}
	3239
	3240	if ( theFile->owner != (uid_t) p->theFile.owner &&
	3241	(theFile->check_mask & MODI_USR) != 0)
	3242	{
	3243	modi_mask \|= MODI_USR;
	3244	change_code[6] = 'U';
	3245	TPT ((0, FIL__, __LINE__, _("mod=<user>")));
	3246	}
	3247
	3248	if ( theFile->group != (gid_t) p->theFile.group &&
	3249	(theFile->check_mask & MODI_GRP) != 0)
	3250	{
	3251	modi_mask \|= MODI_GRP;
	3252	change_code[7] = 'G';
	3253	TPT ((0, FIL__, __LINE__, _("mod=<group>")));
	3254	}
	3255
	3256
	3257	if ( theFile->mtime != (time_t) p->theFile.mtime &&
	3258	(theFile->check_mask & MODI_MTM) != 0)
	3259	{
	3260	modi_mask \|= MODI_MTM;
	3261	change_code[8] = 'T';
	3262	TPT ((0, FIL__, __LINE__, _("mod=<mtime>")));
	3263	}
	3264
[68]	3265	if ( (theFile->check_mask & MODI_ATM) != 0 &&
	3266	theFile->atime != (time_t) p->theFile.atime)
[1]	3267	{
	3268	modi_mask \|= MODI_ATM;
	3269	change_code[8] = 'T';
	3270	TPT ((0, FIL__, __LINE__, _("mod=<atime>")));
	3271	}
	3272
	3273
	3274	/* Resetting the access time will set a new ctime. Thus, either we ignore
	3275	* the access time or the ctime for NOIGNORE
	3276	*/
	3277	if ( theFile->ctime != (time_t) p->theFile.ctime &&
	3278	(theFile->check_mask & MODI_CTM) != 0)
	3279	{
	3280	modi_mask \|= MODI_CTM;
	3281	change_code[8] = 'T';
	3282	TPT ((0, FIL__, __LINE__, _("mod=<ctime>")));
	3283	}
	3284
	3285	if ( theFile->size != (off_t) p->theFile.size &&
	3286	(theFile->check_mask & MODI_SIZ) != 0)
	3287	{
[19]	3288	if ((theFile->check_mask & MODI_SGROW) == 0 \|\|
	3289	theFile->size < (off_t) p->theFile.size)
[1]	3290	{
	3291	modi_mask \|= MODI_SIZ;
	3292	change_code[9] = 'S';
	3293	TPT ((0, FIL__, __LINE__, _("mod=<size>")));
[19]	3294	}
[1]	3295	}
	3296	change_code[10] = '\0';
	3297
[205]	3298	/* --- Directories special case ---
	3299	*/
	3300	if (p->theFile.c_mode[0] == 'd' &&
	3301	0 == (modi_mask & ~(MODI_SIZ\|MODI_ATM\|MODI_CTM\|MODI_MTM)) &&
	3302	sh_loosedircheck == S_TRUE)
	3303	{
	3304	modi_mask = 0;
	3305	}
	3306
[1]	3307	/* --- Report full details. ---
	3308	*/
	3309	if (modi_mask != 0 && sh.flag.fulldetail == S_TRUE)
	3310	{
	3311	if ((theFile->check_mask & MODI_ATM) == 0)
	3312	modi_mask = MASK_READONLY_;
	3313	else
	3314	modi_mask = MASK_NOIGNORE_;
	3315	}
	3316
	3317	/* --- Report on modified files. ---
	3318	*/
[114]	3319	if (modi_mask != 0 && (!SH_FFLAG_REPORTED_SET(p->fflags)))
[1]	3320	{
[170]	3321	tmp = SH_ALLOC(SH_MSG_BUF);
	3322	msg = SH_ALLOC(SH_MSG_BUF);
[1]	3323	msg[0] = '\0';
	3324
	3325	if ( ((modi_mask & MODI_MOD) != 0)
[181]	3326	#if defined(HAVE_LIBPRELUDE)
[68]	3327	\|\| ((modi_mask & MODI_USR) != 0)
	3328	\|\| ((modi_mask & MODI_GRP) != 0)
[1]	3329	#endif
	3330	)
	3331	{
[10]	3332	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[170]	3333	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3334	#ifdef SH_USE_XML
	3335	_("mode_old=\"%s\" mode_new=\"%s\" attr_old=\"%s\" attr_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" iattr_old=\"%ld\" iattr_new=\"%ld\" "),
	3336	#else
	3337	_("mode_old=<%s>, mode_new=<%s>, attr_old=<%s>, attr_new=<%s>, "),
	3338	#endif
	3339	p->theFile.c_mode, theFile->c_mode,
	3340	p->theFile.c_attributes, theFile->c_attributes
	3341	#ifdef SH_USE_XML
	3342	, (long) p->theFile.mode, (long) theFile->mode,
	3343	(long) p->theFile.attributes,
	3344	(long) theFile->attributes
	3345	#endif
	3346	);
	3347	#else
	3348	#ifdef SH_USE_XML
[170]	3349	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3350	_("mode_old=\"%s\" mode_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" "),
[68]	3351	p->theFile.c_mode, theFile->c_mode,
	3352	(long) p->theFile.mode, (long) theFile->mode);
[1]	3353	#else
[170]	3354	sl_snprintf(tmp, SH_MSG_BUF, _("mode_old=<%s>, mode_new=<%s>, "),
[68]	3355	p->theFile.c_mode, theFile->c_mode);
[1]	3356	#endif
[68]	3357	#endif
[170]	3358	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	3359
	3360	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	3361	if (theFile->attr_string != NULL \|\| p->attr_string != NULL)
	3362	{
[170]	3363	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3364	#ifdef SH_USE_XML
[68]	3365	_("acl_old=\"%s\" acl_new=\"%s\" "),
	3366	#else
	3367	_("acl_old=<%s>, acl_new=<%s>, "),
[1]	3368	#endif
[68]	3369	(p->attr_string) ? p->attr_string : _("none"),
	3370	(theFile->attr_string) ? theFile->attr_string : _("none"));
	3371
[170]	3372	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	3373	}
[1]	3374	#endif
[68]	3375
[1]	3376	#ifdef REPLACE_OLD
	3377	if ((modi_mask & MODI_MOD) != 0)
	3378	{
	3379	/*
	3380	* We postpone update if sh.flag.update == S_TRUE because
	3381	* in interactive mode the user may not accept the change.
	3382	*/
	3383	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3384	{
	3385	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
	3386	p->theFile.mode = theFile->mode;
[10]	3387	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	3388	sl_strlcpy(p->theFile.c_attributes,theFile->c_attributes,16);
	3389	p->theFile.attributes = theFile->attributes;
	3390	#endif
[68]	3391	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	3392	if (p->attr_string == NULL && theFile->attr_string != NULL)
	3393	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
	3394	else if (p->attr_string != NULL && theFile->attr_string == NULL)
	3395	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
	3396	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	3397	{
	3398	if (0 != strcmp(theFile->attr_string, p->attr_string))
	3399	{
	3400	SH_FREE(p->attr_string);
	3401	p->attr_string = sh_util_strdup (theFile->attr_string);
	3402	}
	3403	}
	3404	#endif
[1]	3405	}
	3406	}
	3407	#endif
	3408	}
	3409
	3410	if ((modi_mask & MODI_HLN) != 0)
	3411	{
[170]	3412	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3413	#ifdef SH_USE_XML
[40]	3414	_("hardlinks_old=\"%lu\" hardlinks_new=\"%lu\" "),
[1]	3415	#else
[40]	3416	_("hardlinks_old=<%lu>, hardlinks_new=<%lu>, "),
[1]	3417	#endif
	3418	(unsigned long) p->theFile.hardlinks,
	3419	(unsigned long) theFile->hardlinks);
[170]	3420	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3421	#ifdef REPLACE_OLD
	3422	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3423	p->theFile.hardlinks = theFile->hardlinks;
	3424	#endif
	3425	}
	3426
	3427	if ((modi_mask & MODI_RDEV) != 0)
	3428	{
[170]	3429	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3430	#ifdef SH_USE_XML
[40]	3431	_("device_old=\"%lu,%lu\" device_new=\"%lu,%lu\" idevice_old=\"%lu\" idevice_new=\"%lu\" "),
[1]	3432	#else
[40]	3433	_("device_old=<%lu,%lu>, device_new=<%lu,%lu>, "),
[1]	3434	#endif
	3435	(unsigned long) major(p->theFile.rdev),
	3436	(unsigned long) minor(p->theFile.rdev),
	3437	(unsigned long) major(theFile->rdev),
	3438	(unsigned long) minor(theFile->rdev)
	3439	#ifdef SH_USE_XML
	3440	, (unsigned long) p->theFile.rdev,
	3441	(unsigned long) theFile->rdev
	3442	#endif
	3443	);
[170]	3444	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3445	#ifdef REPLACE_OLD
	3446	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3447	p->theFile.rdev = theFile->rdev;
	3448	#endif
	3449	}
	3450
	3451	if ((modi_mask & MODI_INO) != 0)
	3452	{
[170]	3453	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3454	#ifdef SH_USE_XML
[40]	3455	_("inode_old=\"%lu\" inode_new=\"%lu\" "),
[1]	3456	#else
[40]	3457	_("inode_old=<%lu>, inode_new=<%lu>, "),
[1]	3458	#endif
	3459	(unsigned long) p->theFile.ino,
	3460	(unsigned long) theFile->ino);
[170]	3461	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3462	#ifdef REPLACE_OLD
	3463	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
[40]	3464	{
	3465	p->theFile.ino = theFile->ino;
	3466	p->theFile.dev = theFile->dev;
	3467	}
[1]	3468	#endif
	3469	}
	3470
[40]	3471
	3472	/*
	3473	* also report device for prelude
	3474	*/
[181]	3475	#if defined(HAVE_LIBPRELUDE)
[40]	3476	if ((modi_mask & MODI_INO) != 0)
	3477	{
[170]	3478	sl_snprintf(tmp, SH_MSG_BUF,
[40]	3479	#ifdef SH_USE_XML
	3480	_("dev_old=\"%lu,%lu\" dev_new=\"%lu,%lu\" "),
	3481	#else
	3482	_("dev_old=<%lu,%lu>, dev_new=<%lu,%lu>, "),
	3483	#endif
	3484	(unsigned long) major(p->theFile.dev),
	3485	(unsigned long) minor(p->theFile.dev),
	3486	(unsigned long) major(theFile->dev),
	3487	(unsigned long) minor(theFile->dev)
	3488	);
[170]	3489	sl_strlcat(msg, tmp, SH_MSG_BUF);
[40]	3490	#ifdef REPLACE_OLD
	3491	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3492	p->theFile.dev = theFile->dev;
	3493	#endif
	3494	}
	3495	#endif
	3496
[1]	3497	if ( ((modi_mask & MODI_USR) != 0)
[181]	3498	#if defined(HAVE_LIBPRELUDE)
[1]	3499	\|\| ((modi_mask & MODI_MOD) != 0)
	3500	#endif
	3501	)
	3502	{
	3503	#ifdef SH_USE_XML
[170]	3504	sl_snprintf(tmp, SH_MSG_BUF,
[40]	3505	_("owner_old=\"%s\" owner_new=\"%s\" iowner_old=\"%ld\" iowner_new=\"%ld\" "),
[1]	3506	#else
[170]	3507	sl_snprintf(tmp, SH_MSG_BUF,
[40]	3508	_("owner_old=<%s>, owner_new=<%s>, iowner_old=<%ld>, iowner_new=<%ld>, "),
[1]	3509	#endif
[40]	3510	p->theFile.c_owner, theFile->c_owner,
	3511	(long) p->theFile.owner, (long) theFile->owner
[1]	3512	);
[170]	3513	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3514	#ifdef REPLACE_OLD
	3515	if ((modi_mask & MODI_USR) != 0) {
	3516	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3517	{
	3518	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
	3519	p->theFile.owner = theFile->owner;
	3520	}
	3521	}
	3522	#endif
	3523	}
	3524
	3525	if ( ((modi_mask & MODI_GRP) != 0)
[181]	3526	#if defined(HAVE_LIBPRELUDE)
[1]	3527	\|\| ((modi_mask & MODI_MOD) != 0)
	3528	#endif
	3529	)
	3530	{
	3531	#ifdef SH_USE_XML
[170]	3532	sl_snprintf(tmp, SH_MSG_BUF,
[40]	3533	_("group_old=\"%s\" group_new=\"%s\" igroup_old=\"%ld\" igroup_new=\"%ld\" "),
[1]	3534	p->theFile.c_group, theFile->c_group,
	3535	(long) p->theFile.group, (long) theFile->group);
	3536	#else
[170]	3537	sl_snprintf(tmp, SH_MSG_BUF,
[40]	3538	_("group_old=<%s>, group_new=<%s>, igroup_old=<%ld>, igroup_new=<%ld>, "),
	3539	p->theFile.c_group, theFile->c_group,
	3540	(long) p->theFile.group, (long) theFile->group);
[1]	3541	#endif
	3542
[170]	3543	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3544	#ifdef REPLACE_OLD
	3545	if ((modi_mask & MODI_GRP) != 0) {
	3546	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3547	{
	3548	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
	3549	p->theFile.group = theFile->group;
	3550	}
	3551	}
	3552	#endif
	3553	}
	3554
	3555	if ((modi_mask & MODI_SIZ) != 0)
	3556	{
[170]	3557	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	3558	(UINT64) p->theFile.size,
	3559	(UINT64) theFile->size);
[170]	3560	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3561	#ifdef REPLACE_OLD
	3562	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3563	p->theFile.size = theFile->size;
	3564	#endif
	3565	}
	3566
	3567	if ((modi_mask & MODI_CTM) != 0)
	3568	{
[132]	3569	(void) sh_unix_gmttime (p->theFile.ctime, timstr1c, sizeof(timstr1c));
	3570	(void) sh_unix_gmttime (theFile->ctime, timstr2c, sizeof(timstr2c));
[1]	3571	#ifdef SH_USE_XML
[170]	3572	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" ctime_new=\"%s\" "),
[1]	3573	timstr1c, timstr2c);
	3574	#else
[170]	3575	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, ctime_new=<%s>, "),
[1]	3576	timstr1c, timstr2c);
	3577	#endif
[170]	3578	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3579	#ifdef REPLACE_OLD
	3580	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3581	p->theFile.ctime = theFile->ctime;
	3582	#endif
	3583	}
	3584
	3585	if ((modi_mask & MODI_ATM) != 0)
	3586	{
[132]	3587	(void) sh_unix_gmttime (p->theFile.atime, timstr1a, sizeof(timstr1a));
	3588	(void) sh_unix_gmttime (theFile->atime, timstr2a, sizeof(timstr2a));
[1]	3589	#ifdef SH_USE_XML
[170]	3590	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" atime_new=\"%s\" "),
[1]	3591	timstr1a, timstr2a);
	3592	#else
[170]	3593	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, atime_new=<%s>, "),
[1]	3594	timstr1a, timstr2a);
	3595	#endif
[170]	3596	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3597	#ifdef REPLACE_OLD
	3598	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3599	p->theFile.atime = theFile->atime;
	3600	#endif
	3601	}
	3602
	3603	if ((modi_mask & MODI_MTM) != 0)
	3604	{
[132]	3605	(void) sh_unix_gmttime (p->theFile.mtime, timstr1m, sizeof(timstr1m));
	3606	(void) sh_unix_gmttime (theFile->mtime, timstr2m, sizeof(timstr2m));
[1]	3607	#ifdef SH_USE_XML
[170]	3608	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" mtime_new=\"%s\" "),
[1]	3609	timstr1m, timstr2m);
	3610	#else
[170]	3611	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, mtime_new=<%s>, "),
[1]	3612	timstr1m, timstr2m);
	3613	#endif
[170]	3614	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3615	#ifdef REPLACE_OLD
	3616	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3617	p->theFile.mtime = theFile->mtime;
	3618	#endif
	3619	}
	3620
	3621
	3622	if ((modi_mask & MODI_CHK) != 0)
	3623	{
[170]	3624	sl_snprintf(tmp, SH_MSG_BUF,
[1]	3625	#ifdef SH_USE_XML
	3626	_("chksum_old=\"%s\" chksum_new=\"%s\" "),
	3627	#else
	3628	_("chksum_old=<%s>, chksum_new=<%s>, "),
	3629	#endif
	3630	p->theFile.checksum, fileHash);
[170]	3631	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3632	#ifdef REPLACE_OLD
	3633	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
[107]	3634	{
	3635	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	3636	if ((theFile->check_mask & MODI_SGROW) != 0)
	3637	p->theFile.size = theFile->size;
	3638	}
[1]	3639	#endif
[169]	3640	/* FIXME is this correct? */
	3641	if (theFile->c_mode[0] != 'l' && theFile->link_path &&
	3642	strlen(theFile->link_path) > 2)
	3643	modi_mask \|= MODI_LNK;
[1]	3644	}
	3645
	3646
[169]	3647	if ((modi_mask & MODI_LNK) != 0 /* && theFile->c_mode[0] == 'l' */)
[1]	3648	{
[169]	3649	if (theFile->link_path)
	3650	tmp_lnk = sh_util_safe_name(theFile->link_path);
	3651	else
	3652	tmp_lnk = sh_util_strdup("-");
	3653	if (p->linkpath)
	3654	tmp_lnk_old = sh_util_safe_name(p->linkpath);
	3655	else
	3656	tmp_lnk_old = sh_util_strdup("-");
[1]	3657	#ifdef SH_USE_XML
[170]	3658	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" link_new=\"%s\" "),
[1]	3659	tmp_lnk_old, tmp_lnk);
	3660	#else
[294]	3661	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=<%s>, link_new=<%s>, "),
[1]	3662	tmp_lnk_old, tmp_lnk);
	3663	#endif
	3664	SH_FREE(tmp_lnk);
	3665	SH_FREE(tmp_lnk_old);
[170]	3666	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	3667	#ifdef REPLACE_OLD
	3668	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	3669	{
[149]	3670	if (p->linkpath != NULL && p->linkpath != notalink)
[1]	3671	SH_FREE(p->linkpath);
[167]	3672	if (!(theFile->link_path) \|\|
	3673	(theFile->link_path[0] == '-' && theFile->link_path[1] == '\0'))
[149]	3674	p->linkpath = (char *)notalink;
	3675	else
[167]	3676	p->linkpath = sh_util_strdup(theFile->link_path);
[1]	3677	}
	3678	#endif
	3679	}
	3680
[294]	3681	if (MODI_AUDIT_ENABLED(theFile->check_mask))
	3682	{
	3683	char result[256];
[1]	3684
[294]	3685	if (NULL != sh_audit_fetch (theFile->fullpath, theFile->mtime, result, sizeof(result)))
	3686	{
	3687	#ifdef SH_USE_XML
	3688	sl_strlcat(msg, _("obj=\""), SH_MSG_BUF);
	3689	#else
	3690	sl_strlcat(msg, _("obj=<"), SH_MSG_BUF);
	3691	#endif
	3692
	3693	sl_strlcat(msg, result, SH_MSG_BUF);
	3694
	3695	#ifdef SH_USE_XML
	3696	sl_strlcat(msg, _("\" "), SH_MSG_BUF);
	3697	#else
	3698	sl_strlcat(msg, _(">"), SH_MSG_BUF);
	3699	#endif
	3700	}
	3701	}
	3702
[1]	3703	tmp_path = sh_util_safe_name(theFile->fullpath);
	3704	sh_error_handle(log_severity, FIL__, __LINE__,
	3705	(long) modi_mask, MSG_FI_CHAN,
	3706	(policy_override == NULL) ? _(policy[class]):log_policy,
	3707	change_code, tmp_path, msg);
[405]	3708	++sh.statistics.files_report;
[1]	3709
	3710	SH_FREE(tmp_path);
	3711	SH_FREE(tmp);
	3712	SH_FREE(msg);
	3713
	3714	#ifndef REPLACE_OLD
[114]	3715	SET_SH_FFLAG_REPORTED(p->fflags);
[1]	3716	#endif
	3717
	3718	if (S_TRUE == sh.flag.update)
	3719	{
	3720	if (S_FALSE == sh_util_ask_update(theFile->fullpath))
	3721	{
	3722	/* user does not want to update, thus we replace
	3723	* with data from the baseline database
	3724	*/
	3725	sl_strlcpy(theFile->c_mode, p->theFile.c_mode, 11);
	3726	theFile->mode = p->theFile.mode;
[10]	3727	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	3728	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, 16);
	3729	theFile->attributes = p->theFile.attributes;
	3730	#endif
[68]	3731	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	3732	if (theFile->attr_string == NULL && p->attr_string != NULL)
	3733	{ theFile->attr_string = sh_util_strdup (p->attr_string); }
	3734	else if (theFile->attr_string != NULL && p->attr_string == NULL)
	3735	{ SH_FREE(theFile->attr_string); theFile->attr_string = NULL; }
	3736	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	3737	{
	3738	if (0 != strcmp(theFile->attr_string, p->attr_string))
	3739	{
	3740	SH_FREE(theFile->attr_string);
	3741	theFile->attr_string = sh_util_strdup (p->attr_string);
	3742	}
	3743	}
	3744	#endif
[1]	3745
	3746	if (theFile->c_mode[0] == 'l') /* c_mode is already copied */
	3747	{
[167]	3748	if (theFile->link_path)
	3749	SH_FREE(theFile->link_path);
	3750	if (p->linkpath)
	3751	theFile->link_path = sh_util_strdup(p->linkpath);
	3752	else
	3753	theFile->link_path = sh_util_strdup("-");
[1]	3754	}
	3755	else
	3756	{
[167]	3757	if (theFile->link_path)
	3758	SH_FREE(theFile->link_path);
	3759	if (p->linkpath && p->linkpath != notalink)
	3760	theFile->link_path = sh_util_strdup(p->linkpath);
	3761	else
	3762	theFile->link_path = NULL;
[1]	3763	}
	3764
	3765	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	3766
	3767	theFile->mtime = p->theFile.mtime;
	3768	theFile->ctime = p->theFile.ctime;
	3769	theFile->atime = p->theFile.atime;
	3770
	3771	theFile->size = p->theFile.size;
	3772
	3773	sl_strlcpy(theFile->c_group, p->theFile.c_group, GROUP_MAX+2);
	3774	theFile->group = p->theFile.group;
	3775	sl_strlcpy(theFile->c_owner, p->theFile.c_owner, USER_MAX+2);
	3776	theFile->owner = p->theFile.owner;
	3777
	3778	theFile->ino = p->theFile.ino;
	3779	theFile->rdev = p->theFile.rdev;
	3780	theFile->dev = p->theFile.dev;
	3781	theFile->hardlinks = p->theFile.hardlinks;
	3782
[114]	3783	SET_SH_FFLAG_VISITED(p->fflags);
	3784	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[149]	3785	retval = 1;
	3786	goto unlock_and_return;
[1]	3787	}
[77]	3788	else /* if (sh.flag.reportonce == S_TRUE) */
[1]	3789	{
	3790	/* we replace the data in the in-memory copy of the
	3791	* baseline database, because otherwise we would get
	3792	* another warning if the suidcheck runs
	3793	*/
	3794	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
	3795	p->theFile.mode = theFile->mode;
[10]	3796	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	3797	sl_strlcpy(p->theFile.c_attributes, theFile->c_attributes, 16);
	3798	p->theFile.attributes = theFile->attributes;
	3799	#endif
[68]	3800	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	3801	if (p->attr_string == NULL && theFile->attr_string != NULL)
	3802	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
	3803	else if (p->attr_string != NULL && theFile->attr_string == NULL)
	3804	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
	3805	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	3806	{
	3807	if (0 != strcmp(theFile->attr_string, p->attr_string))
	3808	{
	3809	SH_FREE(p->attr_string);
	3810	p->attr_string = sh_util_strdup (theFile->attr_string);
	3811	}
	3812	}
	3813	#endif
[1]	3814
[167]	3815	if (theFile->c_mode[0] == 'l' \|\| theFile->link_path)
[1]	3816	{
[149]	3817	if (p->linkpath != NULL && p->linkpath != notalink)
[1]	3818	SH_FREE(p->linkpath);
[167]	3819	p->linkpath = sh_util_strdup(theFile->link_path);
[1]	3820	}
	3821	else
	3822	{
[149]	3823	if (p->linkpath != NULL && p->linkpath != notalink) {
[167]	3824	SH_FREE(p->linkpath);
	3825	}
	3826	p->linkpath = (char *)notalink;
[1]	3827	}
	3828
	3829	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	3830
	3831	p->theFile.mtime = theFile->mtime;
	3832	p->theFile.ctime = theFile->ctime;
	3833	p->theFile.atime = theFile->atime;
	3834
	3835	p->theFile.size = theFile->size;
	3836
	3837	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
	3838	p->theFile.group = theFile->group;
	3839	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
	3840	p->theFile.owner = theFile->owner;
	3841
	3842	p->theFile.ino = theFile->ino;
	3843	p->theFile.rdev = theFile->rdev;
	3844	p->theFile.dev = theFile->dev;
	3845	p->theFile.hardlinks = theFile->hardlinks;
	3846	}
	3847	}
	3848	}
	3849
[114]	3850	SET_SH_FFLAG_VISITED(p->fflags);
	3851	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[1]	3852
[149]	3853	unlock_and_return:
[153]	3854	; /* 'label at end of compound statement */
[149]	3855	SH_MUTEX_UNLOCK(mutex_hash);
	3856	SL_RETURN(retval, _("sh_hash_compdata"));
[1]	3857	}
	3858
	3859	int hash_full_tree ()
	3860	{
	3861	sh_file_t * p;
	3862	int i;
	3863
[457]	3864	SL_ENTER(_("hash_full_tree"));
[1]	3865
	3866	if (IsInit != 1)
[457]	3867	SL_RETURN(0, _("hash_full_tree"));
[1]	3868
[149]	3869	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
[1]	3870	for (i = 0; i < TABSIZE; ++i)
	3871	{
	3872	for (p = tab[i]; p; p = p->next)
[114]	3873	CLEAR_SH_FFLAG_ALLIGNORE(p->fflags);
[1]	3874	}
[149]	3875	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
[457]	3876	SL_RETURN (0, _("hash_full_tree"));
[1]	3877	}
	3878
[457]	3879	#if !defined(SH_CUTEST)
	3880	static
	3881	#endif
	3882	int hash_remove_tree_test(char * s, char * fullpath, size_t len_s)
	3883	{
	3884	size_t len_p;
	3885	char * test;
[1]	3886
[457]	3887	len_p = strlen(fullpath);
	3888
	3889	if (len_p >= len_s)
	3890	{
	3891	if (0 == strncmp(s, fullpath, len_s))
	3892	{
	3893	if (len_p > len_s)
	3894	{
	3895	/* continue if not inside directory;
	3896	* len_s > 1 because everything is inside '/'
	3897	*/
	3898	if ((len_s > 1) && (fullpath[len_s] != '/'))
	3899	return S_FALSE;
	3900
	3901	test = sh_files_find_mostspecific_dir(fullpath);
	3902
	3903	if (test && 0 != strcmp(test, s)) {
	3904	/* There is a more specific directory, continue */
	3905	return S_FALSE;
	3906	}
	3907
	3908	if (NULL == sh_files_findfile(fullpath)) {
	3909	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
	3910	return S_TRUE;
	3911	}
	3912	}
	3913	else /* len_p == len */
	3914	{
	3915	/* it is 's' itself, mark and continue
	3916	* unless there is a policy for the inode itself
	3917	*/
	3918	if (NULL == sh_files_findfile(fullpath)) {
	3919	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
	3920	return S_TRUE;
	3921	}
	3922	else {
	3923	return S_FALSE;
	3924	}
	3925	}
	3926
	3927	} /* if path is in tree */
	3928	} /* if path is possibly in tree */
	3929	return S_FALSE;
	3930	}
	3931
	3932
[1]	3933	int hash_remove_tree (char * s)
	3934	{
[8]	3935	sh_file_t * p;
[457]	3936	size_t len_s;
[8]	3937	unsigned int i;
[1]	3938
	3939	SL_ENTER(_("hash_remove_tree"));
	3940
[8]	3941	if (!s \|\| *s == '\0')
[1]	3942	SL_RETURN ((-1), _("hash_remove_tree"));
	3943
[457]	3944	len_s = sl_strlen(s);
[8]	3945
[1]	3946	if (IsInit != 1)
	3947	sh_hash_init();
	3948
[149]	3949	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
[1]	3950	for (i = 0; i < TABSIZE; ++i)
	3951	{
	3952	for (p = tab[i]; p; p = p->next)
	3953	{
[457]	3954	if (p->fullpath)
	3955	{
	3956	/* if (0 == strncmp(s, p->fullpath, len_s)) // old */
	3957	if (S_TRUE == hash_remove_tree_test(s, p->fullpath, len_s))
	3958	SET_SH_FFLAG_ALLIGNORE(p->fflags);
	3959	} /* if path is not null */
	3960
[1]	3961	}
	3962	}
[149]	3963	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
[1]	3964	SL_RETURN ((0), _("hash_remove_tree"));
	3965	}
	3966
	3967	#if TIME_WITH_SYS_TIME
	3968	#include <sys/time.h>
	3969	#include <time.h>
	3970	#else
	3971	#if HAVE_SYS_TIME_H
	3972	#include <sys/time.h>
	3973	#else
	3974	#include <time.h>
	3975	#endif
	3976	#endif
	3977
[169]	3978	static int ListFullDetail = S_FALSE;
[1]	3979	static int ListWithDelimiter = S_FALSE;
[169]	3980	static char * ListFile = NULL;
[1]	3981
[169]	3982	int set_list_file (const char * c)
	3983	{
	3984	ListFile = sh_util_strdup(c);
	3985	return 0;
	3986	}
	3987
[20]	3988	int set_full_detail (const char * c)
[1]	3989	{
[149]	3990	(void) c;
[1]	3991	ListFullDetail = S_TRUE;
[149]	3992	return 0;
[1]	3993	}
	3994
[20]	3995	int set_list_delimited (const char * c)
[1]	3996	{
[149]	3997	(void) c;
[1]	3998	ListFullDetail = S_TRUE;
	3999	ListWithDelimiter = S_TRUE;
[149]	4000	return 0;
[1]	4001	}
[76]	4002
[149]	4003	/* Always quote the string, except if it is empty. Quote quotes by
[76]	4004	* doubling them.
	4005	*/
	4006	char * csv_escape(const char * str)
	4007	{
	4008	const char * p = str;
	4009	const char * q;
	4010
	4011	size_t size = 0;
	4012	size_t flag_quote = 0;
[362]	4013
[76]	4014	char * new;
	4015	char * pnew;
	4016
	4017	if (p)
	4018	{
	4019
	4020	while (*p)
	4021	{
[362]	4022	if (*p == '"')
[76]	4023	++flag_quote;
	4024
	4025	++size; ++p;
	4026	}
	4027
	4028	if (sl_ok_adds(size, flag_quote))
	4029	size += flag_quote; /* double each quote */
	4030	else
	4031	return NULL;
	4032
	4033	if (sl_ok_adds(size, 3))
	4034	size += 3; /* two quotes and terminating null */
	4035	else
	4036	return NULL;
	4037
	4038	new = SH_ALLOC(size);
	4039
	4040	if (flag_quote != 0)
	4041	{
	4042	new[0] = '"';
	4043	pnew = &new[1];
	4044	q = str;
	4045	while (*q)
	4046	{
	4047	pnew = q;
	4048	if (*pnew == '"')
	4049	{
	4050	++pnew; *pnew = '"';
	4051	}
	4052	++pnew; ++q;
	4053	}
	4054	*pnew = '"'; ++pnew;
	4055	*pnew = '\0';
	4056	}
	4057	else
	4058	{
	4059	if (size > 3)
	4060	{
	4061	new[0] = '"';
	4062	sl_strlcpy (&new[1], str, size-1);
	4063	new[size-2] = '"';
	4064	new[size-1] = '\0';
	4065	}
	4066	else
	4067	{
	4068	new[0] = '\0';
	4069	}
	4070	}
	4071
	4072	return new;
	4073	}
	4074	return NULL;
	4075	}
	4076
[444]	4077	int isHexKey(char * s)
	4078	{
	4079	int i;
	4080
	4081	for (i = 0; i < KEY_LEN; ++i)
	4082	{
	4083	if (*s)
	4084	{
	4085	if ((s >= '0' && s <= '9') \|\|
	4086	(s >= 'A' && s <= 'F') \|\|
	4087	(s >= 'a' && s <= 'f'))
	4088	{
	4089	++s;
	4090	continue;
	4091	}
	4092	}
	4093	return S_FALSE;
	4094	}
	4095	return S_TRUE;
	4096	}
	4097
	4098	#include "sh_checksum.h"
[76]	4099
[444]	4100	static char * KEYBUFtolower (char * s, char * result)
	4101	{
	4102	char * r = result;
	4103	if (s)
	4104	{
	4105	for (; *s; ++s)
	4106	{
	4107	r = tolower((unsigned char) s); ++r;
	4108	}
	4109	*r = '\0';
	4110	}
	4111	return result;
	4112	}
	4113
[1]	4114	void sh_hash_list_db_entry_full_detail (sh_file_t * p)
	4115	{
	4116	char * tmp;
[76]	4117	char * esc;
[1]	4118	char str[81];
[444]	4119	char hexdigest[SHA256_DIGEST_STRING_LENGTH];
	4120	char keybuffer[KEYBUF_SIZE];
[1]	4121
	4122	if (ListWithDelimiter == S_TRUE)
	4123	{
[40]	4124	printf(_("%7ld, %7ld, %10s, %5d, %12s, %5d, %3d, %-8s, %5d, %-8s, %5d, "),
	4125	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
[1]	4126	p->theFile.c_mode, (int) p->theFile.mode,
	4127	p->theFile.c_attributes, (int) p->theFile.attributes,
	4128	(int) p->theFile.hardlinks,
	4129	p->theFile.c_owner, (int) p->theFile.owner,
	4130	p->theFile.c_group, (int) p->theFile.group);
	4131	}
	4132	else
	4133	{
[40]	4134	printf(_("%7ld %7ld %10s %5d %12s %5d %3d %-8s %5d %-8s %5d "),
	4135	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
[1]	4136	p->theFile.c_mode, (int) p->theFile.mode,
	4137	p->theFile.c_attributes, (int) p->theFile.attributes,
	4138	(int) p->theFile.hardlinks,
	4139	p->theFile.c_owner, (int) p->theFile.owner,
	4140	p->theFile.c_group, (int) p->theFile.group);
	4141	}
	4142
	4143	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
[132]	4144	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.rdev);
[1]	4145	else
[132]	4146	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.size);
[1]	4147
	4148	printf( _(" %8s"), str);
	4149	if (ListWithDelimiter == S_TRUE)
	4150	putchar(',');
	4151
[132]	4152	printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime, str, sizeof(str)));
[1]	4153	if (ListWithDelimiter == S_TRUE)
	4154	putchar(',');
[132]	4155	printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime, str, sizeof(str)));
[1]	4156	if (ListWithDelimiter == S_TRUE)
	4157	putchar(',');
[132]	4158	printf( _(" %s"), sh_unix_gmttime (p->theFile.atime, str, sizeof(str)));
[1]	4159	if (ListWithDelimiter == S_TRUE)
	4160	putchar(',');
[444]	4161
	4162	if (isHexKey(p->theFile.checksum))
	4163	printf( _(" %s"), KEYBUFtolower(p->theFile.checksum, keybuffer));
	4164	else
	4165	printf( _(" %s"), SHA256_Base2Hex(p->theFile.checksum, hexdigest));
[1]	4166	if (ListWithDelimiter == S_TRUE)
	4167	putchar(',');
	4168
	4169	tmp = sh_util_safe_name(p->fullpath);
[76]	4170	if (ListWithDelimiter != S_TRUE)
	4171	{
	4172	printf( _(" %s"), tmp);
	4173	}
	4174	else
	4175	{
	4176	esc = csv_escape(tmp);
	4177	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
	4178	if (esc)
	4179	SH_FREE(esc);
	4180	}
[1]	4181	SH_FREE(tmp);
	4182
	4183	if ('l' == p->theFile.c_mode[0])
	4184	{
	4185	tmp = sh_util_safe_name(p->linkpath);
[76]	4186	if (ListWithDelimiter != S_TRUE)
	4187	{
	4188	printf(_(" -> %s"), tmp);
	4189	}
[1]	4190	else
[76]	4191	{
	4192	esc = csv_escape(tmp);
	4193	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
	4194	if (esc)
	4195	SH_FREE(esc);
	4196	}
[1]	4197	SH_FREE(tmp);
	4198	}
[68]	4199
	4200	if (p->attr_string)
	4201	{
	4202	tmp = sh_util_safe_name(p->attr_string);
[76]	4203	if (ListWithDelimiter != S_TRUE)
	4204	{
	4205	printf(_(" %s"), tmp);
	4206	}
	4207	else
	4208	{
	4209	esc = csv_escape(tmp);
	4210	printf( _(" %s"), (esc != NULL) ? esc : _("(null)"));
	4211	if (esc)
	4212	SH_FREE(esc);
	4213	}
[68]	4214	SH_FREE(tmp);
	4215	}
[1]	4216	else
[68]	4217	{
	4218	if (ListWithDelimiter == S_TRUE)
[210]	4219	printf("%s",_(" no_attr"));
[68]	4220	}
	4221	putchar('\n');
[1]	4222
	4223	return;
	4224	}
	4225
	4226	void sh_hash_list_db_entry (sh_file_t * p)
	4227	{
	4228	char nowtime[128];
	4229	char thetime[128];
	4230	char * tmp;
	4231	time_t now = time(NULL);
	4232	time_t then = (time_t) p->theFile.mtime;
	4233
[131]	4234	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
	4235	struct tm * time_ptr;
	4236	struct tm time_tm;
	4237
	4238	time_ptr = gmtime_r(&then, &time_tm);
	4239	strftime(thetime, 127, _("%b %d %Y"), time_ptr);
	4240	time_ptr = gmtime_r(&now, &time_tm);
	4241	strftime(nowtime, 127, _("%b %d %Y"), time_ptr);
	4242	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
	4243	{
	4244	time_ptr = gmtime_r(&then, &time_tm);
	4245	strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
	4246	}
	4247	#else
[1]	4248	strftime(thetime, 127, _("%b %d %Y"), gmtime(&then));
	4249	strftime(nowtime, 127, _("%b %d %Y"), gmtime(&now));
	4250	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
	4251	strftime(thetime, 127, _("%b %d %H:%M"), gmtime(&then));
[131]	4252	#endif
[1]	4253
	4254	tmp = sh_util_safe_name(p->fullpath);
	4255	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
	4256	printf(_("%10s %3d %-8s %-8s %3d,%4d %s %s"),
	4257	p->theFile.c_mode, (int) p->theFile.hardlinks,
	4258	p->theFile.c_owner, p->theFile.c_group,
	4259	(int) major((dev_t)p->theFile.rdev),
	4260	(int) minor((dev_t)p->theFile.rdev),
	4261	thetime,
	4262	tmp);
	4263	else
	4264	printf(_("%10s %3d %-8s %-8s %8ld %s %s"),
	4265	p->theFile.c_mode, (int) p->theFile.hardlinks,
	4266	p->theFile.c_owner, p->theFile.c_group, (long) p->theFile.size,
	4267	thetime,
	4268	tmp);
	4269	SH_FREE(tmp);
	4270
	4271	if ('l' == p->theFile.c_mode[0])
	4272	{
	4273	tmp = sh_util_safe_name(p->linkpath);
	4274	printf(_(" -> %s\n"), tmp);
	4275	SH_FREE(tmp);
	4276	}
	4277	else
	4278	printf("\n");
	4279
	4280	return;
	4281	}
	4282
[169]	4283	#ifdef HAVE_LIBZ
	4284	#include <zlib.h>
	4285	#endif
	4286
	4287	int sh_hash_printcontent(char * linkpath)
	4288	{
	4289	#ifdef HAVE_LIBZ
	4290	unsigned char * decoded;
	4291	unsigned char * decompressed = NULL;
	4292	size_t dlen;
	4293	unsigned long clen;
	4294	unsigned long clen_o;
	4295	int res;
	4296
	4297	if (linkpath && *linkpath != '-')
	4298	{
	4299	dlen = sh_util_base64_dec_alloc (&decoded,
	4300	(unsigned char *)linkpath,
	4301	strlen(linkpath));
[170]	4302
[169]	4303	clen = dlen * 2 + 1;
[170]	4304
[169]	4305	do {
	4306	if (decompressed)
	4307	SH_FREE(decompressed);
	4308	clen += dlen; clen_o = clen;
	4309	decompressed = SH_ALLOC(clen);
	4310	res = uncompress(decompressed, &clen, decoded, dlen);
	4311	if (res == Z_MEM_ERROR)
[210]	4312	{ fprintf(stderr, "%s",_("Error: Not enough memory\n")); return -1; }
[169]	4313	if (res == Z_DATA_ERROR)
[210]	4314	{ fprintf(stderr, "%s",_("Error: Data corrupt or incomplete\n")); return -1; }
[169]	4315	} while (res == Z_BUF_ERROR \|\| clen == clen_o);
[170]	4316
[169]	4317	decompressed[clen] = '\0';
	4318	fputs( (char*) decompressed, stdout);
[227]	4319	SH_FREE(decompressed);
[169]	4320	return 0;
	4321	}
	4322	#else
	4323	(void) linkpath;
	4324	#endif
[210]	4325	fprintf(stderr, "%s",_("Error: No data available\n"));
[169]	4326	return -1;
	4327	}
	4328
[20]	4329	int sh_hash_list_db (const char * db_file)
[1]	4330	{
	4331	sh_file_t * p;
	4332	SL_TICKET fd;
	4333	char * line;
[169]	4334	int flag = 0;
[1]	4335
	4336	if (!db_file)
	4337	{
	4338	_exit(EXIT_FAILURE);
	4339	return -1;
	4340	}
	4341	if (sl_is_suid())
	4342	{
[210]	4343	fprintf(stderr, "%s",_("ERROR: insufficient privilege\n"));
[1]	4344	_exit (EXIT_FAILURE);
	4345	return -1; /* for Mac OSX compiler */
	4346	}
	4347	if (0 == strcmp(db_file, _("default")))
	4348	db_file = file_path('D', 'W');
	4349	if (!db_file)
	4350	{
	4351	_exit(EXIT_FAILURE);
	4352	return -1;
	4353	}
	4354
[170]	4355	line = SH_ALLOC(MAX_PATH_STORE+2);
[1]	4356
[248]	4357	if ( SL_ISERROR(fd = sl_open_read(FIL__, __LINE__, db_file, SL_YESPRIV)))
[1]	4358	{
	4359	fprintf(stderr, _("ERROR: can't open %s for read (errnum = %ld)\n"),
	4360	db_file, fd);
	4361	_exit(EXIT_FAILURE);
	4362	return -1;
	4363	}
	4364
	4365	/* fast forward to start of data
	4366	*/
[170]	4367	sh_hash_setdataent(fd, line, MAX_PATH_STORE+1, db_file);
[1]	4368
	4369	while (1)
	4370	{
[170]	4371	p = sh_hash_getdataent (fd, line, MAX_PATH_STORE+1);
[169]	4372	if ((p != NULL) && (p->fullpath[0] == '/'))
[1]	4373	{
[169]	4374	if (!ListFile)
	4375	{
	4376	flag = 1;
	4377	if (ListFullDetail == S_FALSE)
	4378	sh_hash_list_db_entry (p);
	4379	else
	4380	sh_hash_list_db_entry_full_detail (p);
	4381	}
[1]	4382	else
[169]	4383	{
	4384	if (0 != sl_strcmp(ListFile, p->fullpath))
	4385	{
	4386	continue;
	4387	}
	4388	flag = 1;
	4389	if ('l' != p->theFile.c_mode[0])
	4390	{
	4391	if (sh_hash_printcontent(p->linkpath) < 0)
	4392	{
	4393	_exit(EXIT_FAILURE);
	4394	return -1;
	4395	}
	4396	}
	4397	else
	4398	{
[210]	4399	fprintf(stderr, "%s",_("File is a link\n"));
[169]	4400	_exit(EXIT_FAILURE);
	4401	return -1;
	4402	}
	4403	break;
	4404	}
[1]	4405	}
	4406	else if (p == NULL)
	4407	{
	4408	break;
	4409	}
	4410	}
	4411
	4412	if (line != NULL)
	4413	SH_FREE(line);
	4414	sl_close (fd);
	4415
	4416	fflush(NULL);
	4417
[169]	4418	if (flag == 0)
	4419	{
[210]	4420	fprintf(stderr, "%s",_("File not found\n"));
[169]	4421	_exit(EXIT_FAILURE);
	4422	}
[1]	4423	_exit(EXIT_SUCCESS);
	4424	return 0;
	4425	}
	4426
	4427	/* if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE) */
	4428	#endif

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

Download in other formats: