Context Navigation

source: trunk/src/sh_hash.c@ 272

Last change on this file since 272 was 252, checked in by katerina, 15 years ago
Add code to check for stale file records on close() and fclose(), fix sl_close() to handle open stream (ticket #163).
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));
[1]	1807	sl_write (pushdata_fd, timestring, sl_strlen(timestring));
	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: