Context Navigation

source: trunk/src/sh_hash.c@ 285

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

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

Download in other formats: