Context Navigation

source: trunk/src/sh_hash.c@ 93

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

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

Download in other formats: