Context Navigation

source: trunk/src/sh_hash.c@ 494

Last change on this file since 494 was 492, checked in by katerina, 9 years ago
Fix for ticket #388 (logfile rotation).
File size: 79.1 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	#include <stdlib.h>
	23	#include <string.h>
	24	#include <stdio.h>
	25	#include <sys/types.h>
	26	#include <sys/stat.h>
	27	#include <unistd.h>
[444]	28	#include <ctype.h>
[1]	29
	30	#ifdef MAJOR_IN_MKDEV
	31	#include <sys/mkdev.h>
	32	#else
	33	#ifdef MAJOR_IN_SYSMACROS
	34	#include <sys/sysmacros.h>
	35	#endif
	36	#endif
	37
	38	#ifdef HAVE_MEMORY_H
	39	#include <memory.h>
	40	#endif
	41
[481]	42
[1]	43	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
	44
[481]	45	#include "samhain.h"
	46	#include "sh_utils.h"
	47	#include "sh_unix.h"
	48	#include "sh_dbIO_int.h"
	49	#include "sh_dbIO.h"
[1]	50	#include "sh_hash.h"
	51	#include "sh_error.h"
	52	#include "sh_tiger.h"
	53	#include "sh_gpg.h"
	54	#include "sh_unix.h"
	55	#include "sh_files.h"
	56	#include "sh_ignore.h"
[149]	57	#include "sh_pthread.h"
[1]	58
	59	#if defined(SH_WITH_CLIENT)
[481]	60	#include "sh_xfer.h"
[1]	61	#endif
	62
[105]	63
	64	#define SH_KEY_NULL _("000000000000000000000000000000000000000000000000")
	65
	66
[1]	67	#undef FIL__
	68	#define FIL__ _("sh_hash.c")
	69
[481]	70	SH_MUTEX_INIT(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
[149]	71
[1]	72	static char * all_items (file_type * theFile, char * fileHash, int is_new);
	73
[481]	74	static const char *policy[] = {
	75	N_("[]"),
	76	N_("[ReadOnly]"),
	77	N_("[LogFiles]"),
	78	N_("[GrowingLogs]"),
	79	N_("[IgnoreNone]"),
	80	N_("[IgnoreAll]"),
	81	N_("[Attributes]"),
	82	N_("[User0]"),
	83	N_("[User1]"),
	84	N_("[User2]"),
	85	N_("[User3]"),
	86	N_("[User4]"),
	87	N_("[Prelink]"),
	88	NULL
	89	};
[1]	90
[481]	91	static int report_checkflags = S_FALSE;
	92	int set_report_checkflags(const char * c)
[1]	93	{
[481]	94	return sh_util_flagval(c, &report_checkflags);
[1]	95	}
[481]	96	int get_report_checkflags()
[1]	97	{
[481]	98	return report_checkflags;
[1]	99	}
	100
[34]	101
[1]	102
[356]	103	const char * sh_hash_getpolicy(int class)
	104	{
	105	if (class > 0 && class < SH_ERR_T_DIR)
	106	return _(policy[class]);
	107	return _("[indef]");
	108	}
[1]	109
	110	/**********************************
	111	*
	112	* hash table functions
	113	*
	114	**********************************
	115	*/
	116
	117	#include "sh_hash.h"
	118
	119
	120	/**************************************************************
	121	*
	122	* create a file_type from a sh_file_t
	123	*
	124	**************************************************************/
[481]	125	file_type * sh_hash_create_ft (const sh_file_t * p, char * fileHash)
[1]	126	{
	127	file_type * theFile;
	128
	129	SL_ENTER(_("sh_hash_create_ft"));
	130
	131	theFile = SH_ALLOC(sizeof(file_type));
	132
	133	sl_strlcpy(theFile->c_mode, p->theFile.c_mode, 11);
	134	theFile->mode = p->theFile.mode;
[10]	135	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[149]	136	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, ATTRBUF_SIZE);
[1]	137	theFile->attributes = p->theFile.attributes;
	138	#endif
	139
	140	sl_strlcpy(theFile->fullpath, p->fullpath, PATH_MAX);
[167]	141	if (p->linkpath != NULL /* && theFile->c_mode[0] == 'l' */)
[1]	142	{
[167]	143	theFile->link_path = sh_util_strdup(p->linkpath);
[1]	144	}
	145	else
	146	{
[167]	147	theFile->link_path = NULL;
[1]	148	}
	149	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	150
	151	theFile->mtime = p->theFile.mtime;
	152	theFile->ctime = p->theFile.ctime;
	153	theFile->atime = p->theFile.atime;
	154
	155	theFile->size = p->theFile.size;
	156
	157	sl_strlcpy(theFile->c_group, p->theFile.c_group, GROUP_MAX+2);
	158	theFile->group = p->theFile.group;
	159	sl_strlcpy(theFile->c_owner, p->theFile.c_owner, USER_MAX+2);
	160	theFile->owner = p->theFile.owner;
	161
	162	theFile->ino = p->theFile.ino;
	163	theFile->rdev = p->theFile.rdev;
	164	theFile->dev = p->theFile.dev;
	165	theFile->hardlinks = p->theFile.hardlinks;
[481]	166	theFile->check_flags = p->theFile.checkflags;
[1]	167
[68]	168	if (p->attr_string)
	169	theFile->attr_string = sh_util_strdup(p->attr_string);
	170	else
	171	theFile->attr_string = NULL;
	172
[1]	173	SL_RETURN((theFile), _("sh_hash_create_ft"));
	174	}
	175
[305]	176	struct two_sh_file_t {
	177	sh_file_t * prev;
	178	sh_file_t * this;
	179	};
	180
[294]	181	static sh_file_t * hashsearch (const char * s);
[305]	182	static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index);
[1]	183
[481]	184
	185	/**************************************************************
	186	*
	187	* >>>> The internal database <<<
	188	*
	189	**************************************************************/
	190
[1]	191	static sh_file_t * tab[TABSIZE];
	192
[481]	193	sh_file_t ** get_default_data_table()
	194	{
	195	return tab;
	196	}
	197
[1]	198	/**************************************************************
	199	*
	200	* compute hash function
	201	*
	202	**************************************************************/
[8]	203
[294]	204	static int hashfunc(const char *s)
[1]	205	{
[18]	206	unsigned int n = 0;
[1]	207
	208	for ( ; *s; s++)
	209	n = 31 * n + *s;
[18]	210
	211	return n & (TABSIZE - 1); /* % TABSIZE */;
[1]	212	}
	213
[8]	214
[1]	215	int hashreport_missing( char *fullpath, int level)
	216	{
	217	sh_file_t * p;
	218	char * tmp;
	219	char fileHash[KEY_LEN + 1];
	220	file_type * theFile;
	221	char * str;
[133]	222	char hashbuf[KEYBUF_SIZE];
[367]	223	volatile int retval;
[1]	224
	225	/* -------- find the entry for the file ---------------- */
	226
[149]	227	SH_MUTEX_LOCK(mutex_hash);
	228
[170]	229	retval = 0;
	230
[1]	231	if (sl_strlen(fullpath) <= MAX_PATH_STORE)
	232	p = hashsearch(fullpath);
	233	else
	234	p = hashsearch( sh_tiger_hash(fullpath,
	235	TIGER_DATA,
[133]	236	sl_strlen(fullpath),
	237	hashbuf, sizeof(hashbuf))
[1]	238	);
	239	if (p == NULL)
[149]	240	{
	241	retval = -1;
	242	goto unlock_and_return;
	243	}
[1]	244
	245	theFile = sh_hash_create_ft (p, fileHash);
	246	str = all_items(theFile, fileHash, 0);
	247	tmp = sh_util_safe_name(fullpath);
[367]	248
	249	SH_MUTEX_LOCK(mutex_thread_nolog);
[488]	250	if (!sh_global_check_silent)
	251	sh_error_handle (level, FIL__, __LINE__, 0,
	252	MSG_FI_MISS2, tmp, str);
[367]	253	SH_MUTEX_UNLOCK(mutex_thread_nolog);
[405]	254	++sh.statistics.files_report;
[362]	255
[1]	256	SH_FREE(tmp);
	257	SH_FREE(str);
[167]	258	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	259	if (theFile->link_path) SH_FREE(theFile->link_path);
[1]	260	SH_FREE(theFile);
[149]	261
	262	unlock_and_return:
[153]	263	; /* 'label at end of compound statement */
[149]	264	SH_MUTEX_UNLOCK(mutex_hash);
[305]	265
[458]	266	/* remove here to avoid second message from hash_unvisited */
	267	if (retval == 0)
	268	sh_hash_remove (fullpath);
	269
[149]	270	return retval;
[1]	271	}
	272
	273
	274	/**************************************************************
	275	*
	276	* search for files not visited, and check whether they exist
	277	*
	278	**************************************************************/
[294]	279	static sh_file_t * delete_db_entry(sh_file_t *p)
	280	{
	281	if (p->fullpath)
	282	{
	283	SH_FREE(p->fullpath);
	284	p->fullpath = NULL;
	285	}
	286	if (p->linkpath)
	287	{
[481]	288	SH_FREE(p->linkpath);
[294]	289	p->linkpath = NULL;
	290	}
	291	if (p->attr_string)
	292	{
	293	SH_FREE(p->attr_string);
	294	p->attr_string = NULL;
	295	}
	296	SH_FREE(p);
	297	return NULL;
	298	}
	299
[1]	300	static void hash_unvisited (int j,
	301	sh_file_t prev, sh_file_t p, ShErrLevel level)
	302	{
	303	struct stat buf;
	304	int i;
	305	char * tmp;
	306	char * ptr;
	307	char fileHash[KEY_LEN + 1];
	308	file_type * theFile;
	309	char * str;
	310
	311	SL_ENTER(_("hash_unvisited"));
	312
	313	if (p->next != NULL)
	314	hash_unvisited (j, p, p->next, level);
	315
	316	if (p->fullpath == NULL)
	317	{
	318	SL_RET0(_("hash_unvisited"));
	319	}
	320
[114]	321	/* Not a fully qualified path, i.e. some info stored by some module
[1]	322	*/
[114]	323	if (p->fullpath[0] != '/')
[1]	324	{
	325	SL_RET0(_("hash_unvisited"));
	326	}
[458]	327
[114]	328	/* visited flag not set: not seen;
	329	* checked flag set: not seen (i.e. missing), and already checked
	330	* reported flag not set: not reported yet
	331	* allignore flag not set: not under IgnoreAll
[1]	332	*
	333	* Files/directories under IgnoreAll are noticed as missing already
	334	* during the file check.
	335	*/
[114]	336	if (((!SH_FFLAG_VISITED_SET(p->fflags)) \|\| SH_FFLAG_CHECKED_SET(p->fflags))
	337	&& (!SH_FFLAG_REPORTED_SET(p->fflags))
[481]	338	/* && (!SH_FFLAG_ALLIGNORE_SET(p->fflags)) */)
[1]	339	{
	340	i = retry_lstat(FIL__, __LINE__, p->fullpath, &buf);
[458]	341
[457]	342	/* if file does not exist
[1]	343	*/
	344	if (0 != i)
	345	{
[34]	346	ptr = sh_util_dirname (p->fullpath);
[1]	347	if (ptr)
	348	{
	349	/* If any of the parent directories is under IgnoreAll
	350	*/
[481]	351	if ((0 != sh_files_is_allignore(ptr)) \|\| SH_FFLAG_ALLIGNORE_SET(p->fflags))
[1]	352	level = ShDFLevel[SH_LEVEL_ALLIGNORE];
	353	SH_FREE(ptr);
	354	}
[114]	355
	356	/* Only report if !SH_FFLAG_CHECKED_SET
	357	*/
	358	if (!SH_FFLAG_CHECKED_SET(p->fflags))
[1]	359	{
	360	if (S_FALSE == sh_ignore_chk_del(p->fullpath))
	361	{
	362	tmp = sh_util_safe_name(p->fullpath);
	363
	364	theFile = sh_hash_create_ft (p, fileHash);
	365	str = all_items(theFile, fileHash, 0);
[488]	366	if (!sh_global_check_silent)
	367	sh_error_handle (level, FIL__, __LINE__, 0,
	368	MSG_FI_MISS2, tmp, str);
[405]	369	++sh.statistics.files_report;
[1]	370	SH_FREE(str);
[167]	371	if (theFile->attr_string) SH_FREE(theFile->attr_string);
	372	if (theFile->link_path) SH_FREE(theFile->link_path);
[1]	373	SH_FREE(theFile);
	374
	375	SH_FREE(tmp);
	376	}
	377	}
	378
[77]	379	/* We rewrite the db on update, thus we need to keep this
[1]	380	* if the user does not want to purge it from the db.
	381	*/
	382
[77]	383	if ((sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE) \|\|
	384	(S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(p->fullpath)))
[1]	385	{
	386	/* Remove the old entry
	387	*/
	388	if (prev == p)
	389	tab[j] = p->next;
	390	else
	391	prev->next = p->next;
[294]	392
[383]	393	delete_db_entry(p);
[294]	394
[1]	395	SL_RET0(_("hash_unvisited"));
	396	}
	397	}
	398	}
	399
[114]	400	else if (SH_FFLAG_VISITED_SET(p->fflags) && SH_FFLAG_REPORTED_SET(p->fflags)
	401	&& (!SH_FFLAG_ALLIGNORE_SET(p->fflags)))
[1]	402	{
	403	if (S_FALSE == sh_ignore_chk_new(p->fullpath))
	404	{
	405	tmp = sh_util_safe_name(p->fullpath);
	406
	407	theFile = sh_hash_create_ft (p, fileHash);
	408	str = all_items(theFile, fileHash, 0);
[488]	409	if (!sh_global_check_silent)
	410	sh_error_handle (level, FIL__, __LINE__, 0,
	411	MSG_FI_MISS2, tmp, str);
[405]	412	++sh.statistics.files_report;
[1]	413	SH_FREE(str);
[68]	414	if (theFile->attr_string)
	415	SH_FREE(theFile->attr_string);
[1]	416	SH_FREE(theFile);
	417
	418	SH_FREE(tmp);
	419	}
	420
[114]	421	CLEAR_SH_FFLAG_REPORTED(p->fflags);
[1]	422	}
	423
	424	if (sh.flag.reportonce == S_FALSE)
[114]	425	CLEAR_SH_FFLAG_REPORTED(p->fflags);
[1]	426
[114]	427	CLEAR_SH_FFLAG_VISITED(p->fflags);
	428	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[458]	429	SET_SH_FFLAG_ENOENT(p->fflags);
[114]	430
[1]	431	SL_RET0(_("hash_unvisited"));
	432	}
	433
	434
[305]	435
[1]	436	/*********************************************************************
	437	*
	438	* Search for files in the database that have been deleted from disk.
	439	*
	440	*********************************************************************/
	441	void sh_hash_unvisited (ShErrLevel level)
	442	{
	443	int i;
	444
	445	SL_ENTER(_("sh_hash_unvisited"));
[149]	446
	447	SH_MUTEX_LOCK(mutex_hash);
[1]	448	for (i = 0; i < TABSIZE; ++i)
	449	{
	450	if (tab[i] != NULL)
	451	hash_unvisited (i, tab[i], tab[i], level);
	452	}
[149]	453	SH_MUTEX_UNLOCK(mutex_hash);
	454
[1]	455	SL_RET0(_("hash_unvisited"));
	456	}
	457
[294]	458	/*********************************************************************
	459	*
[305]	460	* Remove a single file from the database.
	461	*
	462	*********************************************************************/
[481]	463	void sh_hash_remove_unconditional (const char * path)
[305]	464	{
	465	struct two_sh_file_t entries;
	466	int index;
	467
[481]	468	SL_ENTER(_("sh_hash_remove_unconditional"));
[305]	469
	470	SH_MUTEX_LOCK(mutex_hash);
[481]	471	if (0 == hashsearch_prev (path, &entries, &index))
	472	{
	473	sh_file_t * p = entries.this;
	474
	475	/* Remove the old entry
	476	*/
	477	if (entries.prev == p)
	478	tab[index] = p->next;
	479	else
	480	entries.prev->next = p->next;
	481
	482	delete_db_entry(p);
	483	}
	484	SH_MUTEX_UNLOCK(mutex_hash);
[305]	485
[481]	486	SL_RET0(_("sh_hash_remove_unconditional"));
	487	}
	488
	489	void sh_hash_remove (const char * path)
	490	{
	491	SL_ENTER(_("sh_hash_remove"));
	492
[305]	493	if ((sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE) \|\|
	494	(S_TRUE == sh.flag.update && S_TRUE == sh_util_ask_update(path)))
	495	{
[481]	496	sh_hash_remove_unconditional (path);
[305]	497	}
	498	SL_RET0(_("sh_hash_remove"));
	499	}
	500
	501
	502	/*********************************************************************
	503	*
[294]	504	* Search for unvisited entries in the database, custom error handler.
	505	*
	506	*********************************************************************/
	507	void sh_hash_unvisited_custom (char prefix, void(handler)(const char key))
	508	{
	509	int i;
	510	sh_file_t *p = NULL;
	511	sh_file_t *prev = NULL;
	512	sh_file_t *next = NULL;
[1]	513
[294]	514	SL_ENTER(_("sh_hash_unvisited_custom"));
	515
	516	SH_MUTEX_LOCK(mutex_hash);
	517	for (i = 0; i < TABSIZE; ++i)
	518	{
	519	if (tab[i] != NULL)
	520	{
	521	p = tab[i]; prev = p;
	522
	523	do
	524	{
	525	next = p->next;
	526
	527	if (p->fullpath &&
	528	prefix == p->fullpath[0])
	529	{
	530	if ((!SH_FFLAG_VISITED_SET(p->fflags))
	531	&& (!SH_FFLAG_REPORTED_SET(p->fflags)))
	532	{
	533	handler(p->fullpath);
	534
	535	if (!SH_FFLAG_CHECKED_SET(p->fflags))
	536	{
	537	/* delete */
	538	if (tab[i] == p)
	539	{
	540	tab[i] = p->next;
	541	prev = tab[i];
	542	next = prev;
	543	}
	544	else
	545	{
	546	prev->next = p->next;
	547	next = prev->next;
	548	}
	549
	550	p = delete_db_entry(p);
	551	}
	552	}
	553	if (p)
	554	{
	555	CLEAR_SH_FFLAG_VISITED(p->fflags);
	556	CLEAR_SH_FFLAG_CHECKED(p->fflags);
	557	}
	558	}
	559	if (p)
	560	prev = p;
	561	p = next;
	562	}
	563	while (p);
	564	}
	565	}
	566	SH_MUTEX_UNLOCK(mutex_hash);
	567
	568	SL_RET0(_("hash_unvisited_custom"));
	569	}
	570
	571
[1]	572	/**********************************************************************
	573	*
	574	* delete hash array
	575	*
	576	**********************************************************************/
	577	static void hash_kill (sh_file_t *p)
	578	{
	579	SL_ENTER(_("hash_kill"));
	580
	581	if (p == NULL)
	582	SL_RET0(_("hash_kill"));
	583
	584	if (p->next != NULL)
	585	hash_kill (p->next);
	586
	587	if (p->fullpath)
	588	{
	589	SH_FREE(p->fullpath);
	590	p->fullpath = NULL;
	591	}
	592	if (p->linkpath)
	593	{
[481]	594	SH_FREE(p->linkpath);
[1]	595	p->linkpath = NULL;
	596	}
[68]	597	if (p->attr_string)
	598	{
	599	SH_FREE(p->attr_string);
	600	p->attr_string = NULL;
	601	}
[1]	602	SH_FREE(p);
	603	p = NULL;
	604	SL_RET0(_("hash_kill"));
	605	}
	606
	607
	608	/***********************************************************************
	609	*
	610	* get info out of hash array
	611	*
	612	***********************************************************************/
[294]	613	static sh_file_t * hashsearch (const char * s)
[1]	614	{
	615	sh_file_t * p;
	616
	617	SL_ENTER(_("hashsearch"));
	618
[8]	619	if (s)
	620	{
	621	for (p = tab[hashfunc(s)]; p; p = p->next)
	622	if ((p->fullpath != NULL) && (0 == strcmp(s, p->fullpath)))
	623	SL_RETURN( p, _("hashsearch"));
	624	}
[1]	625	SL_RETURN( NULL, _("hashsearch"));
	626	}
	627
[305]	628	static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index)
	629	{
	630	sh_file_t * this;
	631	sh_file_t * prev = NULL;
[1]	632
[305]	633	SL_ENTER(_("hashsearch_prev"));
	634
	635	if (s)
	636	{
	637	*index = hashfunc(s);
[481]	638	this = tab[*index];
	639	prev = this;
[305]	640
	641	if (this)
	642	{
	643	do {
	644	if ((this->fullpath != NULL) && (0 == strcmp(s, this->fullpath)))
	645	{
	646	a->prev = prev;
[481]	647	a->this = this;
[305]	648	SL_RETURN( 0, _("hashsearch_prev"));
	649	}
	650	prev = this;
	651	this = this->next;
	652	} while(this);
	653	}
	654	}
	655	SL_RETURN( -1, _("hashsearch"));
	656	}
	657
	658
[1]	659	/***********************************************************************
	660	*
	661	* insert into hash array
	662	*
	663	***********************************************************************/
[481]	664	void hashinsert (sh_file_t * mtab[TABSIZE], sh_file_t * s)
[1]	665	{
	666	sh_file_t * p;
[3]	667	sh_file_t * q;
[1]	668	int key;
	669
	670	SL_ENTER(_("hashinsert"));
	671
	672	key = hashfunc(s->fullpath);
	673
[481]	674	if (mtab[key] == NULL)
[1]	675	{
[481]	676	mtab[key] = s;
	677	mtab[key]->next = NULL;
[1]	678	SL_RET0(_("hashinsert"));
	679	}
	680	else
	681	{
[481]	682	p = mtab[key];
[1]	683	while (1)
	684	{
[481]	685	if (p && p->fullpath && 0 == strcmp(s->fullpath, p->fullpath))
[1]	686	{
[3]	687	q = p->next;
	688	SH_FREE(p->fullpath);
[481]	689	if(p->linkpath) SH_FREE(p->linkpath);
	690	if(p->attr_string) SH_FREE(p->attr_string);
[3]	691	memcpy(p, s, sizeof(sh_file_t));
	692	p->next = q;
[481]	693	SH_FREE(s); s = NULL;
[1]	694	SL_RET0(_("hashinsert"));
	695	}
[383]	696	else if (p && p->next == NULL)
	697	{
	698	p->next = s;
	699	p->next->next = NULL;
	700	SL_RET0(_("hashinsert"));
	701	}
	702	if (p)
	703	p = p->next;
	704	else /* cannot really happen, but llvm/clang does not know */
	705	break;
[1]	706	}
	707	}
	708	/* notreached */
	709	}
	710
	711
	712
	713	/******************************************************************
	714	*
	715	* ------- Check functions -------
	716	*
	717	******************************************************************/
	718
	719	static int IsInit = 0;
	720
[481]	721	void sh_hash_set_initialized()
[1]	722	{
[481]	723	IsInit = 1;
	724	return;
[1]	725	}
	726
[481]	727	int sh_hash_get_initialized()
[1]	728	{
[481]	729	return IsInit;
[1]	730	}
	731
	732
	733	/******************************************************************
	734	*
	735	* Initialize
	736	*
	737	******************************************************************/
	738	void sh_hash_init ()
	739	{
[199]	740	volatile int retval = 0;
	741	volatile int exitval = EXIT_SUCCESS;
[185]	742
[1]	743	SL_ENTER(_("sh_hash_init"));
	744
[463]	745	if ( sh.flag.checkSum == SH_CHECK_INIT )
	746	{
	747	dlog(1, FIL__, __LINE__,
	748	_("Attempt to load the baseline database during initialisation. This is an internal error, please report it to the developer.\n"));
	749	SH_ABORT;
	750	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	751	}
	752
[149]	753	SH_MUTEX_LOCK(mutex_hash);
[1]	754
[149]	755	if (IsInit == 1)
	756	{
	757	goto unlock_and_return;
	758	}
[1]	759
[149]	760	/* Initialization completed.
	761	*/
[481]	762	retval = sh_dbIO_load_db(tab);
[149]	763
[481]	764	if (0 == retval)
	765	IsInit = 1;
	766	else
	767	exitval = EXIT_FAILURE;
[1]	768
[149]	769	unlock_and_return:
[153]	770	; /* 'label at end of compound statement */
[149]	771	SH_MUTEX_UNLOCK(mutex_hash);
[185]	772	if (retval == 0)
	773	{
	774	SL_RET0(_("sh_hash_init"));
	775	}
[481]	776	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
[185]	777	aud_exit (FIL__, __LINE__, exitval);
[1]	778	}
[481]	779
	780	void sh_hash_init_and_checksum()
	781	{
	782	TPT((0, FIL__, __LINE__, _("msg=<Get checksum of the database.>\n")))
	783	if (sh.flag.checkSum == SH_CHECK_CHECK)
	784	{
	785	if (0 != sl_strcmp(file_path('D', 'R'), _("REQ_FROM_SERVER")))
	786	{
	787	char hashbuf[KEYBUF_SIZE];
	788	(void) sl_strlcpy(sh.data.hash,
	789	sh_tiger_hash (file_path('D', 'R'),
	790	TIGER_FILE, TIGER_NOLIM,
	791	hashbuf, sizeof(hashbuf)),
	792	KEY_LEN+1);
	793	}
	794
	795	/* this eventually fetches the file from server to get checksum
	796	*/
	797	sh_hash_init ();
	798	}
	799	return;
	800	}
[1]	801
	802	/*****************************************************************
	803	*
	804	* delete hash array
	805	*
	806	*****************************************************************/
	807	void sh_hash_hashdelete ()
	808	{
	809	int i;
	810
	811	SL_ENTER(_("sh_hash_hashdelete"));
	812
[320]	813	/* need deadlock detection here if called from exit handler
	814	*/
	815	SH_MUTEX_TRYLOCK(mutex_hash);
	816
[1]	817	if (IsInit == 0)
[149]	818	goto unlock_and_exit;
	819
[1]	820	for (i = 0; i < TABSIZE; ++i)
	821	if (tab[i] != NULL)
	822	{
	823	hash_kill (tab[i]);
	824	tab[i] = NULL;
	825	}
	826	IsInit = 0;
[149]	827
	828	unlock_and_exit:
[153]	829	; /* 'label at end of compound statement */
[371]	830	SH_MUTEX_TRYLOCK_UNLOCK(mutex_hash);
[320]	831
[1]	832	SL_RET0(_("sh_hash_hashdelete"));
	833	}
	834
[205]	835	static int sh_loosedircheck = S_FALSE;
[1]	836
[205]	837	int sh_hash_loosedircheck(const char * str)
	838	{
	839	return sh_util_flagval(str, &sh_loosedircheck);
	840	}
	841
	842
[1]	843
	844
	845	/*********************************************************************
	846	*
	847	* Check whether a file is present in the database.
	848	*
	849	*********************************************************************/
[294]	850	static sh_file_t * sh_hash_have_it_int (const char * newname)
[1]	851	{
	852	sh_file_t * p;
[133]	853	char hashbuf[KEYBUF_SIZE];
[1]	854
[115]	855	SL_ENTER(_("sh_hash_have_it_int"));
[1]	856
	857	if (newname == NULL)
[115]	858	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
[1]	859
	860	if (sl_strlen(newname) <= MAX_PATH_STORE)
	861	p = hashsearch(newname);
	862	else
[133]	863	p = hashsearch ( sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
	864	hashbuf, sizeof(hashbuf)) );
[1]	865	if (p == NULL)
[115]	866	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
[149]	867
[115]	868	SL_RETURN( (p), _("sh_hash_have_it_int"));
[1]	869	}
	870
[294]	871	int sh_hash_have_it (const char * newname)
[1]	872	{
[149]	873	sh_file_t * p;
[170]	874	int retval;
[1]	875
[149]	876	if (IsInit != 1)
	877	sh_hash_init();
	878
	879	SH_MUTEX_LOCK(mutex_hash);
[170]	880
	881	retval = 0;
	882
[149]	883	p = sh_hash_have_it_int (newname);
	884
	885	if (!p)
	886	retval = (-1);
	887	else if ((!SH_FFLAG_ALLIGNORE_SET(p->fflags)) &&
	888	(p->modi_mask & MODI_CHK) != 0 &&
	889	(p->modi_mask & MODI_MOD) != 0)
	890	retval = 1;
	891	SH_MUTEX_UNLOCK(mutex_hash);
	892
	893	return retval;
[1]	894	}
	895
[294]	896	int sh_hash_get_it (const char * newname, file_type * tmpFile, char * fileHash)
[1]	897	{
[149]	898	sh_file_t * p;
[170]	899	int retval;
[68]	900
[149]	901	if (IsInit != 1)
	902	sh_hash_init();
	903
[167]	904	tmpFile->link_path = NULL;
	905	tmpFile->attr_string = NULL;
	906
[149]	907	SH_MUTEX_LOCK(mutex_hash);
[170]	908
	909	retval = (-1);
	910
[149]	911	p = sh_hash_have_it_int (newname);
	912	if (p)
	913	{
[167]	914	sl_strlcpy(tmpFile->fullpath, p->fullpath, PATH_MAX);
	915	if (p->linkpath)
	916	tmpFile->link_path = sh_util_strdup (p->linkpath);
[149]	917	tmpFile->size = p->theFile.size;
	918	tmpFile->mtime = p->theFile.mtime;
	919	tmpFile->ctime = p->theFile.ctime;
[294]	920	tmpFile->atime = p->theFile.atime;
	921
	922	if (NULL != fileHash)
	923	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	924
[149]	925	tmpFile->attr_string = NULL;
	926	retval = 0;
	927	}
	928	SH_MUTEX_UNLOCK(mutex_hash);
	929
	930	return retval;
[1]	931	}
	932
[115]	933	int sh_hash_getflags (char * filename)
	934	{
[149]	935	sh_file_t * p;
[463]	936	int retval = 0;
[149]	937
[463]	938	if ( sh.flag.checkSum != SH_CHECK_INIT )
	939	{
	940	if (IsInit != 1)
	941	sh_hash_init();
	942
	943	SH_MUTEX_LOCK(mutex_hash);
	944	p = sh_hash_have_it_int (filename);
	945	if (p)
	946	retval = p->fflags;
	947	else
	948	retval = -1;
	949	SH_MUTEX_UNLOCK(mutex_hash);
	950	}
[149]	951	return retval;
[115]	952	}
	953
	954	int sh_hash_setflags (char * filename, int flags)
	955	{
[149]	956	sh_file_t * p;
[463]	957	int retval = 0;
[149]	958
[463]	959	if ( sh.flag.checkSum != SH_CHECK_INIT )
[149]	960	{
[463]	961	if (IsInit != 1)
	962	sh_hash_init();
	963
	964	SH_MUTEX_LOCK(mutex_hash);
	965	p = sh_hash_have_it_int (filename);
	966	if (p)
	967	{
	968	p->fflags = flags;
	969	retval = 0;
	970	}
	971	else
	972	retval = -1;
	973	SH_MUTEX_UNLOCK(mutex_hash);
[149]	974	}
	975	return retval;
[115]	976	}
	977
	978	/* needs lock to be threadsafe
	979	*/
[458]	980	void sh_hash_set_flag (char * filename, int flag_to_set)
[115]	981	{
[149]	982	sh_file_t * p;
[115]	983
[463]	984	if ( sh.flag.checkSum != SH_CHECK_INIT )
[115]	985	{
[463]	986	if (IsInit != 1)
	987	sh_hash_init();
	988
	989	SH_MUTEX_LOCK(mutex_hash);
	990	p = sh_hash_have_it_int (filename);
	991	if (p)
	992	{
	993	p->fflags \|= flag_to_set;
	994	}
	995	SH_MUTEX_UNLOCK(mutex_hash);
[115]	996	}
	997	return;
	998	}
	999
[458]	1000	/* needs lock to be threadsafe
	1001	*/
	1002	void sh_hash_clear_flag (char * filename, int flag_to_clear)
	1003	{
	1004	sh_file_t * p;
	1005
[463]	1006	if ( sh.flag.checkSum != SH_CHECK_INIT )
[458]	1007	{
[463]	1008	if (IsInit != 1)
	1009	sh_hash_init();
	1010
	1011	SH_MUTEX_LOCK(mutex_hash);
	1012	p = sh_hash_have_it_int (filename);
	1013	if (p)
	1014	{
	1015	p->fflags &= ~flag_to_clear;
	1016	}
	1017	SH_MUTEX_UNLOCK(mutex_hash);
[458]	1018	}
	1019	return;
	1020	}
	1021
	1022
[1]	1023	/*****************************************************************
	1024	*
	1025	* Set a file's status to 'visited'. This is required for
	1026	* files that should be ignored, and may be present in the
	1027	* database, but not on disk.
	1028	*
	1029	*****************************************************************/
	1030	static int sh_hash_set_visited_int (char * newname, int flag)
	1031	{
	1032	sh_file_t * p;
[133]	1033	char hashbuf[KEYBUF_SIZE];
[170]	1034	int retval;
[1]	1035
	1036	SL_ENTER(_("sh_hash_set_visited_int"));
	1037
	1038	if (newname == NULL)
	1039	SL_RETURN((-1), _("sh_hash_set_visited_int"));
[149]	1040
[1]	1041	if (IsInit != 1)
	1042	sh_hash_init();
	1043
[149]	1044	SH_MUTEX_LOCK(mutex_hash);
	1045
[1]	1046	if (sl_strlen(newname) <= MAX_PATH_STORE)
	1047	p = hashsearch(newname);
	1048	else
[133]	1049	p = hashsearch (sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
	1050	hashbuf, sizeof(hashbuf)));
[1]	1051
[149]	1052	if (p)
[1]	1053	{
[149]	1054	if (flag == SH_FFLAG_CHECKED)
	1055	{
	1056	CLEAR_SH_FFLAG_REPORTED(p->fflags);
	1057	CLEAR_SH_FFLAG_VISITED(p->fflags);
	1058	SET_SH_FFLAG_CHECKED(p->fflags);
	1059	}
[114]	1060	else
[149]	1061	{
	1062	SET_SH_FFLAG_VISITED(p->fflags);
	1063	CLEAR_SH_FFLAG_CHECKED(p->fflags);
	1064	if (flag == SH_FFLAG_REPORTED)
	1065	SET_SH_FFLAG_REPORTED(p->fflags);
	1066	else
	1067	CLEAR_SH_FFLAG_REPORTED(p->fflags);
	1068	}
	1069	retval = 0;
[1]	1070	}
[170]	1071	else
	1072	retval = -1;
[149]	1073
	1074	SH_MUTEX_UNLOCK(mutex_hash);
	1075	SL_RETURN((retval), _("sh_hash_set_visited_int"));
[1]	1076	}
	1077
	1078
	1079	/* cause the record to be deleted without a 'missing' message
	1080	*/
	1081	int sh_hash_set_missing (char * newname)
	1082	{
	1083	int i;
[294]	1084	SL_ENTER(_("sh_hash_set_missing"));
[305]	1085
[114]	1086	i = sh_hash_set_visited_int(newname, SH_FFLAG_CHECKED);
[305]	1087
	1088	if (sh.flag.checkSum != SH_CHECK_INIT) {
	1089	sh_hash_remove(newname);
	1090	}
	1091
[294]	1092	SL_RETURN(i, _("sh_hash_set_missing"));
[1]	1093	}
	1094
[114]	1095	/* mark the file as visited and reported
	1096	*/
[1]	1097	int sh_hash_set_visited (char * newname)
	1098	{
	1099	int i;
	1100	SL_ENTER(_("sh_hash_set_visited"));
[114]	1101	i = sh_hash_set_visited_int(newname, SH_FFLAG_REPORTED);
[1]	1102	SL_RETURN(i, _("sh_hash_set_visited"));
	1103	}
	1104
[114]	1105	/* mark the file as visited and NOT reported
	1106	* used to avoid deletion of file from internal database
	1107	*/
[1]	1108	int sh_hash_set_visited_true (char * newname)
	1109	{
	1110	int i;
	1111	SL_ENTER(_("sh_hash_set_visited_true"));
[114]	1112	i = sh_hash_set_visited_int(newname, 0);
[1]	1113	SL_RETURN(i, _("sh_hash_set_visited_true"));
	1114	}
	1115
	1116
	1117	/******************************************************************
	1118	*
	1119	* Data entry for arbitrary data into database
	1120	*
	1121	******************************************************************/
	1122
[294]	1123	void sh_hash_push2db (const char * key, struct store2db * save)
[1]	1124	{
	1125	int i = 0;
	1126	char * p;
[137]	1127	char i2h[2];
[227]	1128	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
[1]	1129
[294]	1130	int size = save->size;
	1131	unsigned char * str = save->str;
	1132
	1133
[227]	1134	tmpFile->attr_string = NULL;
	1135	tmpFile->link_path = NULL;
[68]	1136
[227]	1137	sl_strlcpy(tmpFile->fullpath, key, PATH_MAX);
[294]	1138	tmpFile->size = save->val0;
	1139	tmpFile->mtime = save->val1;
	1140	tmpFile->ctime = save->val2;
	1141	tmpFile->atime = save->val3;
[1]	1142
[227]	1143	tmpFile->mode = 0;
	1144	tmpFile->owner = 0;
	1145	tmpFile->group = 0;
	1146	sl_strlcpy(tmpFile->c_owner, _("root"), 5);
	1147	sl_strlcpy(tmpFile->c_group, _("root"), 5);
[1]	1148
[481]	1149	tmpFile->check_flags = 0;
	1150
[1]	1151	if ((str != NULL) && (size < (PATH_MAX/2)-1))
	1152	{
[227]	1153	tmpFile->c_mode[0] = 'l';
	1154	tmpFile->c_mode[1] = 'r'; tmpFile->c_mode[2] = 'w';
	1155	tmpFile->c_mode[3] = 'x'; tmpFile->c_mode[4] = 'r';
	1156	tmpFile->c_mode[5] = 'w'; tmpFile->c_mode[6] = 'x';
	1157	tmpFile->c_mode[7] = 'r'; tmpFile->c_mode[8] = 'w';
	1158	tmpFile->c_mode[9] = 'x'; tmpFile->c_mode[10] = '\0';
	1159	tmpFile->link_path = SH_ALLOC((size * 2) + 2);
[1]	1160	for (i = 0; i < size; ++i)
	1161	{
[137]	1162	p = sh_util_charhex (str[i],i2h);
[227]	1163	tmpFile->link_path[2*i] = p[0];
	1164	tmpFile->link_path[2*i+1] = p[1];
	1165	tmpFile->link_path[2*i+2] = '\0';
[1]	1166	}
	1167	}
	1168	else
	1169	{
[93]	1170	for (i = 0; i < 10; ++i)
[227]	1171	tmpFile->c_mode[i] = '-';
	1172	tmpFile->c_mode[10] = '\0';
	1173	tmpFile->link_path = sh_util_strdup("-");
[1]	1174	}
	1175
[294]	1176	if (sh.flag.checkSum == SH_CHECK_INIT)
[481]	1177	sh_dbIO_data_write (tmpFile,
	1178	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
[1]	1179	else
[294]	1180	sh_hash_pushdata_memory (tmpFile,
	1181	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
[1]	1182
[227]	1183	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	1184	SH_FREE(tmpFile);
[1]	1185	return;
	1186	}
	1187
	1188	extern int sh_util_hextobinary (char * binary, char * hex, int bytes);
	1189
[294]	1190	char * sh_hash_db2pop (const char * key, struct store2db * save)
[1]	1191	{
	1192	size_t len;
	1193	char * p;
	1194	int i;
[167]	1195	char * retval = NULL;
[294]	1196	char fileHash[KEY_LEN+1];
[227]	1197	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
[167]	1198
[294]	1199	save->size = 0;
[1]	1200
[294]	1201	if (0 == sh_hash_get_it (key, tmpFile, fileHash))
[1]	1202	{
[294]	1203	save->val0 = tmpFile->size;
	1204	save->val1 = tmpFile->mtime;
	1205	save->val2 = tmpFile->ctime;
	1206	save->val3 = tmpFile->atime;
[1]	1207
[294]	1208	sl_strlcpy(save->checksum, fileHash, KEY_LEN+1);
	1209
[227]	1210	if (tmpFile->link_path && tmpFile->link_path[0] != '-')
[1]	1211	{
[227]	1212	len = strlen(tmpFile->link_path);
[1]	1213
	1214	p = SH_ALLOC((len/2)+1);
[227]	1215	i = sh_util_hextobinary (p, tmpFile->link_path, len);
[1]	1216
	1217	if (i == 0)
	1218	{
[294]	1219	save->size = (len/2);
	1220	p[save->size] = '\0';
[167]	1221	retval = p;
[1]	1222	}
	1223	else
	1224	{
	1225	SH_FREE(p);
[294]	1226	save->size = 0;
[1]	1227	}
	1228	}
	1229	else
	1230	{
[294]	1231	save->size = 0;
[1]	1232	}
	1233	}
	1234	else
	1235	{
[294]	1236	save->size = -1;
	1237	save->val0 = 0;
	1238	save->val1 = 0;
	1239	save->val2 = 0;
	1240	save->val3 = 0;
[1]	1241	}
[227]	1242	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
	1243	SH_FREE(tmpFile);
[167]	1244	return retval;
[1]	1245	}
	1246
	1247
	1248
	1249
	1250	/******************************************************************
	1251	*
	1252	* Data entry in hash table
	1253	*
	1254	******************************************************************/
	1255	sh_file_t * sh_hash_push_int (file_type * buf, char * fileHash)
	1256	{
	1257	sh_file_t * fp;
	1258	sh_filestore_t p;
[34]	1259
	1260	size_t len;
[1]	1261	char * fullpath;
	1262	char * linkpath;
[68]	1263	char * attr_string = NULL;
[133]	1264	char hashbuf[KEYBUF_SIZE];
[1]	1265
	1266	SL_ENTER(_("sh_hash_push_int"));
	1267
	1268	fp = SH_ALLOC(sizeof(sh_file_t));
	1269
	1270	p.mark = REC_MAGIC;
[68]	1271	if (buf->attr_string)
	1272	p.mark \|= REC_FLAGS_ATTR;
[1]	1273	sl_strlcpy(p.c_mode, buf->c_mode, 11);
	1274	sl_strlcpy(p.c_group, buf->c_group, GROUP_MAX+1);
	1275	sl_strlcpy(p.c_owner, buf->c_owner, USER_MAX+1);
	1276	sl_strlcpy(p.checksum, fileHash, KEY_LEN+1);
[10]	1277	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1278	sl_strlcpy(p.c_attributes, buf->c_attributes, 13);
	1279	#endif
	1280
[10]	1281	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1282	p.attributes = (UINT32) buf->attributes;
	1283	#endif
	1284	p.linkmode = (UINT32) buf->linkmode;
	1285	p.hardlinks = (UINT32) buf->hardlinks;
[40]	1286	p.dev = (UINT64) buf->dev;
	1287	p.rdev = (UINT64) buf->rdev;
[1]	1288	p.mode = (UINT32) buf->mode;
	1289	p.ino = (UINT32) buf->ino;
	1290	p.size = (UINT64) buf->size;
	1291	p.mtime = (UINT64) buf->mtime;
	1292	p.atime = (UINT64) buf->atime;
	1293	p.ctime = (UINT64) buf->ctime;
	1294	p.owner = (UINT32) buf->owner;
	1295	p.group = (UINT32) buf->group;
	1296
[481]	1297	p.checkflags = (UINT32) buf->check_flags;
	1298
[1]	1299	memcpy( &(*fp).theFile, &p, sizeof(sh_filestore_t) );
[115]	1300	fp->fflags = 0; /* init fflags */
[1]	1301	fp->modi_mask = 0L;
	1302
[68]	1303	if (buf->attr_string)
	1304	attr_string = sh_util_strdup(buf->attr_string);
	1305	fp->attr_string = attr_string;
	1306
[34]	1307	len = sl_strlen(buf->fullpath);
	1308	if (len <= MAX_PATH_STORE)
[1]	1309	{
[34]	1310	fullpath = SH_ALLOC(len+1);
	1311	sl_strlcpy(fullpath, buf->fullpath, len+1);
[1]	1312	}
	1313	else
	1314	{
	1315	fullpath = SH_ALLOC(KEY_LEN + 1);
	1316	sl_strlcpy(fullpath,
[133]	1317	sh_tiger_hash (buf->fullpath, TIGER_DATA, len,
	1318	hashbuf, sizeof(hashbuf)),
[1]	1319	KEY_LEN+1);
	1320	}
	1321	fp->fullpath = fullpath;
	1322
[167]	1323	if (buf->link_path)
[1]	1324	{
[167]	1325	len = sl_strlen(buf->link_path);
[34]	1326	if (len <= MAX_PATH_STORE)
[1]	1327	{
[34]	1328	linkpath = SH_ALLOC(len+1);
[167]	1329	sl_strlcpy(linkpath, buf->link_path, len+1);
[1]	1330	}
	1331	else
	1332	{
	1333	linkpath = SH_ALLOC(KEY_LEN + 1);
	1334	sl_strlcpy(linkpath,
[167]	1335	sh_tiger_hash (buf->link_path, TIGER_DATA, len,
[133]	1336	hashbuf, sizeof(hashbuf)),
[1]	1337	KEY_LEN+1);
	1338	}
	1339	fp->linkpath = linkpath;
	1340	}
	1341	else
	1342	fp->linkpath = NULL;
	1343
	1344	SL_RETURN( fp, _("sh_hash_push_int"));
	1345	}
	1346
	1347	#ifdef HAVE_INTTYPES_H
	1348	#include <inttypes.h>
	1349	#else
	1350	#ifdef HAVE_STDINT_H
	1351	#include <stdint.h>
	1352	#endif
	1353	#endif
	1354
[40]	1355	#ifndef PRIu64
	1356	#ifdef HAVE_LONG_32
	1357	#define PRIu64 "llu"
	1358	#else
	1359	#define PRIu64 "lu"
[1]	1360	#endif
[40]	1361	#endif
[1]	1362
	1363	char * sh_hash_size_format()
	1364	{
	1365	static char form_rval[81];
	1366
	1367	SL_ENTER(_("sh_hash_size_format"));
	1368
	1369
	1370	#ifdef SH_USE_XML
	1371	sl_snprintf(form_rval, 80, _("%s%s%s%s%s"),
[40]	1372	_("size_old=\"%"), PRIu64, _("\" size_new=\"%"), PRIu64, "\" ");
[1]	1373	#else
	1374	sl_snprintf(form_rval, 80, _("%s%s%s%s%s"),
[40]	1375	_("size_old=<%"), PRIu64, _(">, size_new=<%"), PRIu64, ">, ");
[1]	1376	#endif
	1377
	1378	SL_RETURN( form_rval, _("sh_hash_size_format"));
	1379	}
	1380
	1381
	1382	#ifdef SH_USE_XML
	1383	static char * all_items (file_type * theFile, char * fileHash, int is_new)
	1384	{
	1385	char timstr1c[32];
	1386	char timstr1a[32];
	1387	char timstr1m[32];
	1388
	1389	char * tmp_lnk;
	1390	char * format;
	1391
[170]	1392	char * tmp = SH_ALLOC(SH_MSG_BUF);
	1393	char * msg = SH_ALLOC(SH_MSG_BUF);
[1]	1394
	1395	tmp[0] = '\0';
	1396	msg[0] = '\0';
	1397
[481]	1398	if (report_checkflags != S_FALSE)
	1399	{
	1400	if (is_new)
	1401	format = _("checkflags_new=\"0%lo\" ");
	1402	else
	1403	format = _("checkflags_old=\"0%lo\" ");
	1404	sl_snprintf(tmp, SH_MSG_BUF, format,
	1405	(unsigned long) theFile->check_flags);
	1406	sl_strlcat(msg, tmp, SH_MSG_BUF);
	1407	}
[1]	1408
[10]	1409	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1410	if (is_new)
	1411	format = _("mode_new=\"%s\" attr_new=\"%s\" imode_new=\"%ld\" iattr_new=\"%ld\" ");
	1412	else
	1413	format = _("mode_old=\"%s\" attr_old=\"%s\" imode_old=\"%ld\" iattr_old=\"%ld\" ");
[170]	1414	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1415	theFile->c_mode,
	1416	theFile->c_attributes,
	1417	(long) theFile->mode,
	1418	(long) theFile->attributes
	1419	);
	1420	#else
	1421	if (is_new)
	1422	format = _("mode_new=\"%s\" imode_new=\"%ld\" ");
	1423	else
	1424	format = _("mode_old=\"%s\" imode_old=\"%ld\" ");
	1425
[170]	1426	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1427	theFile->c_mode,
	1428	(long) theFile->mode
	1429	);
	1430	#endif
[170]	1431	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1432
	1433	if (is_new)
[40]	1434	format = _("hardlinks_new=\"%lu\" ");
[1]	1435	else
[40]	1436	format = _("hardlinks_old=\"%lu\" ");
[170]	1437	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1438	(unsigned long) theFile->hardlinks);
[170]	1439	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1440
	1441
	1442	if (is_new)
[40]	1443	format = _("idevice_new=\"%lu\" ");
[1]	1444	else
[40]	1445	format = _("idevice_old=\"%lu\" ");
[170]	1446	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
	1447	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1448
	1449
	1450	if (is_new)
[40]	1451	format = _("inode_new=\"%lu\" ");
[1]	1452	else
[40]	1453	format = _("inode_old=\"%lu\" ");
[170]	1454	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
	1455	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1456
[40]	1457	/*
	1458	* also report device for prelude
	1459	*/
[181]	1460	#if defined(HAVE_LIBPRELUDE)
[40]	1461	if (is_new)
	1462	format = _("dev_new=\"%lu,%lu\" ");
	1463	else
	1464	format = _("dev_old=\"%lu,%lu\" ");
[170]	1465	sl_snprintf(tmp, SH_MSG_BUF, format,
[40]	1466	(unsigned long) major(theFile->dev),
	1467	(unsigned long) minor(theFile->dev));
[170]	1468	sl_strlcat(msg, tmp, SH_MSG_BUF);
[40]	1469	#endif
[1]	1470
[40]	1471
[1]	1472	if (is_new)
	1473	format = _("owner_new=\"%s\" iowner_new=\"%ld\" ");
	1474	else
	1475	format = _("owner_old=\"%s\" iowner_old=\"%ld\" ");
[170]	1476	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1477	theFile->c_owner, (long) theFile->owner);
[170]	1478	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1479
	1480
	1481	if (is_new)
	1482	format = _("group_new=\"%s\" igroup_new=\"%ld\" ");
	1483	else
	1484	format = _("group_old=\"%s\" igroup_old=\"%ld\" ");
[170]	1485	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1486	theFile->c_group, (long) theFile->group);
[170]	1487	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1488
	1489
	1490	if (is_new)
[170]	1491	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	1492	(UINT64) 0, (UINT64) theFile->size);
	1493	else
[170]	1494	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	1495	(UINT64) theFile->size, (UINT64) 0);
[170]	1496	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1497
	1498
[132]	1499	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
[1]	1500	if (is_new)
[170]	1501	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=\"%s\" "), timstr1c);
[1]	1502	else
[170]	1503	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" "), timstr1c);
	1504	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1505
[132]	1506	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
[1]	1507	if (is_new)
[170]	1508	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=\"%s\" "), timstr1a);
[1]	1509	else
[170]	1510	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" "), timstr1a);
	1511	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1512
[132]	1513	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
[1]	1514	if (is_new)
[170]	1515	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=\"%s\" "), timstr1m);
[1]	1516	else
[170]	1517	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" "), timstr1m);
	1518	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1519
	1520	if (is_new)
[170]	1521	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=\"%s\" "), fileHash);
[1]	1522	else
[170]	1523	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=\"%s\" "), fileHash);
	1524	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1525
[169]	1526	if (theFile->c_mode[0] == 'l' \|\|
	1527	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
[1]	1528	{
[167]	1529	tmp_lnk = sh_util_safe_name(theFile->link_path);
[1]	1530	if (tmp_lnk)
	1531	{
	1532	if (is_new)
[170]	1533	sl_snprintf(tmp, SH_MSG_BUF, _("link_new=\"%s\" "), tmp_lnk);
[1]	1534	else
[170]	1535	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" "), tmp_lnk);
[1]	1536	SH_FREE(tmp_lnk);
[170]	1537	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1538	}
	1539	}
[68]	1540
	1541	if (theFile->attr_string)
	1542	{
	1543	tmp_lnk = sh_util_safe_name(theFile->attr_string);
	1544	if (tmp_lnk)
	1545	{
	1546	if (is_new)
[170]	1547	sl_snprintf(tmp, SH_MSG_BUF, _("acl_new=\"%s\" "), tmp_lnk);
[68]	1548	else
[170]	1549	sl_snprintf(tmp, SH_MSG_BUF, _("acl_old=\"%s\" "), tmp_lnk);
[68]	1550	SH_FREE(tmp_lnk);
[170]	1551	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	1552	}
	1553	}
	1554
[1]	1555
	1556	SH_FREE(tmp);
	1557	return (msg);
	1558	}
	1559	#else
	1560	static char * all_items (file_type * theFile, char * fileHash, int is_new)
	1561	{
	1562	char timstr1c[32];
	1563	char timstr1a[32];
	1564	char timstr1m[32];
	1565
	1566	char * tmp_lnk;
	1567	char * format;
	1568
[170]	1569	char * tmp = SH_ALLOC(SH_MSG_BUF);
	1570	char * msg = SH_ALLOC(SH_MSG_BUF);
[1]	1571
	1572	tmp[0] = '\0';
	1573	msg[0] = '\0';
	1574
[481]	1575	if (report_checkflags == S_TRUE)
	1576	{
	1577	if (is_new)
	1578	format = _("checkflags_new=<0%lo> ");
	1579	else
	1580	format = _("checkflags_old=<0%lo> ");
	1581	sl_snprintf(tmp, SH_MSG_BUF, format,
	1582	(unsigned long) theFile->check_flags);
	1583	sl_strlcat(msg, tmp, SH_MSG_BUF);
	1584	}
[1]	1585
[481]	1586
[10]	1587	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	1588	if (is_new)
	1589	format = _("mode_new=<%s>, attr_new=<%s>, imode_new=<%ld>, iattr_new=<%ld>, ");
	1590	else
	1591	format = _("mode_old=<%s>, attr_old=<%s>, imode_old=<%ld>, iattr_old=<%ld>, ");
[170]	1592	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1593	theFile->c_mode,
	1594	theFile->c_attributes,
	1595	(long) theFile->mode,
	1596	(long) theFile->attributes
	1597	);
	1598	#else
	1599	if (is_new)
	1600	format = _("mode_new=<%s>, imode_new=<%ld>, ");
	1601	else
	1602	format = _("mode_old=<%s>, imode_old=<%ld>, ");
	1603
[170]	1604	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1605	theFile->c_mode,
	1606	(long) theFile->mode
	1607	);
	1608	#endif
[170]	1609	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1610
	1611	if (is_new)
[40]	1612	format = _("hardlinks_new=<%lu>, ");
[1]	1613	else
[40]	1614	format = _("hardlinks_old=<%lu>, ");
[170]	1615	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1616	(unsigned long) theFile->hardlinks);
[170]	1617	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1618
	1619
	1620	if (is_new)
[40]	1621	format = _("idevice_new=<%lu>, ");
[1]	1622	else
[40]	1623	format = _("idevice_old=<%lu>, ");
[170]	1624	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
	1625	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1626
	1627
	1628	if (is_new)
[40]	1629	format = _("inode_new=<%lu>, ");
[1]	1630	else
[40]	1631	format = _("inode_old=<%lu>, ");
[170]	1632	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
	1633	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1634
	1635
[40]	1636	/*
	1637	* also report device for prelude
	1638	*/
[181]	1639	#if defined(HAVE_LIBPRELUDE)
[1]	1640	if (is_new)
[40]	1641	format = _("dev_new=<%lu,%lu>, ");
	1642	else
	1643	format = _("dev_old=<%lu,%lu>, ");
[170]	1644	sl_snprintf(tmp, SH_MSG_BUF, format,
[40]	1645	(unsigned long) major(theFile->dev),
	1646	(unsigned long) minor(theFile->dev));
[170]	1647	sl_strlcat(msg, tmp, SH_MSG_BUF);
[40]	1648	#endif
	1649
	1650	if (is_new)
[1]	1651	format = _("owner_new=<%s>, iowner_new=<%ld>, ");
	1652	else
	1653	format = _("owner_old=<%s>, iowner_old=<%ld>, ");
[170]	1654	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1655	theFile->c_owner, (long) theFile->owner);
[170]	1656	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1657
	1658
	1659	if (is_new)
	1660	format = _("group_new=<%s>, igroup_new=<%ld>, ");
	1661	else
	1662	format = _("group_old=<%s>, igroup_old=<%ld>, ");
[170]	1663	sl_snprintf(tmp, SH_MSG_BUF, format,
[1]	1664	theFile->c_group, (long) theFile->group);
[170]	1665	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1666
	1667
	1668	if (is_new)
[170]	1669	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	1670	(UINT64) 0, (UINT64) theFile->size);
	1671	else
[170]	1672	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	1673	(UINT64) theFile->size, (UINT64) 0);
[170]	1674	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1675
	1676
[132]	1677	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
[1]	1678	if (is_new)
[170]	1679	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=<%s>, "), timstr1c);
[1]	1680	else
[170]	1681	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, "), timstr1c);
	1682	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1683
[132]	1684	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
[1]	1685	if (is_new)
[170]	1686	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=<%s>, "), timstr1a);
[1]	1687	else
[170]	1688	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, "), timstr1a);
	1689	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1690
[132]	1691	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
[1]	1692	if (is_new)
[170]	1693	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=<%s>, "), timstr1m);
[1]	1694	else
[170]	1695	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, "), timstr1m);
	1696	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1697
	1698	if (is_new)
[170]	1699	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=<%s>"), fileHash);
[1]	1700	else
[170]	1701	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=<%s>"), fileHash);
	1702	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1703
[169]	1704	if (theFile->c_mode[0] == 'l' \|\|
	1705	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
[1]	1706	{
[167]	1707	tmp_lnk = sh_util_safe_name(theFile->link_path);
[1]	1708	if (tmp_lnk)
	1709	{
	1710	if (is_new)
[170]	1711	sl_snprintf(tmp, SH_MSG_BUF, _(", link_new=<%s> "), tmp_lnk);
[1]	1712	else
[170]	1713	sl_snprintf(tmp, SH_MSG_BUF, _(", link_old=<%s> "), tmp_lnk);
[1]	1714	SH_FREE(tmp_lnk);
[170]	1715	sl_strlcat(msg, tmp, SH_MSG_BUF);
[1]	1716	}
	1717	}
	1718
[68]	1719	if (theFile->attr_string)
	1720	{
	1721	tmp_lnk = sh_util_safe_name(theFile->attr_string);
	1722	if (tmp_lnk)
	1723	{
	1724	if (is_new)
[170]	1725	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_new=<%s> "), tmp_lnk);
[68]	1726	else
[170]	1727	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_old=<%s> "), tmp_lnk);
[68]	1728	SH_FREE(tmp_lnk);
[170]	1729	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	1730	}
	1731	}
	1732
[1]	1733	SH_FREE(tmp);
	1734	return (msg);
	1735	}
	1736	#endif
	1737
	1738	void sh_hash_pushdata_memory (file_type * theFile, char * fileHash)
	1739	{
	1740	sh_file_t * p;
	1741
	1742	SL_ENTER(_("sh_hash_pushdata_memory"));
	1743
	1744	p = sh_hash_push_int(theFile, fileHash);
	1745	if (p)
	1746	{
[149]	1747	SH_MUTEX_LOCK(mutex_hash);
[481]	1748	hashinsert (tab, p);
	1749	p->modi_mask = theFile->check_flags;
[149]	1750	SH_MUTEX_UNLOCK(mutex_hash);
[1]	1751	}
	1752
	1753	SL_RET0(_("sh_hash_pushdata_memory"));
	1754	}
	1755
[481]	1756	int sh_hash_is_null_file(file_type * theFile)
	1757	{
	1758	if (theFile->hardlinks == SH_DEADFILE && theFile->mode == 0 &&
	1759	theFile->ino == 0 && theFile->ctime == 0)
	1760	{
	1761	return S_TRUE;
	1762	}
	1763	return S_FALSE;
	1764	}
[1]	1765
[481]	1766	int sh_hash_is_null_record(sh_filestore_t * theFile)
	1767	{
	1768	if (theFile->hardlinks == SH_DEADFILE && theFile->mode == 0 &&
	1769	theFile->ino == 0 && theFile->ctime == 0)
	1770	{
	1771	return S_TRUE;
	1772	}
	1773	return S_FALSE;
	1774	}
	1775
	1776	void sh_hash_insert_null(char * str)
	1777	{
	1778	file_type theFile = { 0, 0, {'\0'}, 0, 0, 0, 0, 0,
	1779	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
	1780	0, {'\0'},
	1781	#endif
	1782	{'\0'}, 0, {'\0'}, 0, {'\0'},
	1783	0, 0, 0, 0, 0, 0, 0, NULL, 0, {'\0'}, 0, NULL
	1784	}; /* clang compiler bails out on standard conforming init with just {0} */
	1785	char fileHash[KEY_LEN+1];
	1786	char hashbuf[KEYBUF_SIZE];
	1787
	1788	sl_strlcpy(fileHash, SH_KEY_NULL, sizeof(fileHash));
	1789	theFile.hardlinks = SH_DEADFILE;
	1790
	1791	if (sl_strlen(str) < PATH_MAX)
	1792	sl_strlcpy(theFile.fullpath, str, PATH_MAX);
	1793	else
	1794	sl_strlcpy(theFile.fullpath,
	1795	sh_tiger_hash(str, TIGER_DATA, sl_strlen(str),
	1796	hashbuf, sizeof(hashbuf)),
	1797	PATH_MAX);
	1798
	1799	sh_hash_pushdata_memory(&theFile, fileHash);
	1800	return;
	1801	}
	1802
	1803	static int handle_notfound(int log_severity, int class,
	1804	file_type * theFile, char * fileHash)
	1805	{
	1806	sh_file_t * p;
	1807	int retval = 0;
	1808
	1809	if (S_FALSE == sh_ignore_chk_new(theFile->fullpath))
	1810	{
	1811	char * tmp = sh_util_safe_name(theFile->fullpath);
	1812	char * str;
	1813
	1814	sh_files_fixup_mask(class, &(theFile->check_flags));
	1815	str = all_items (theFile, fileHash, 1);
	1816
[488]	1817	if (!sh_global_check_silent)
	1818	sh_error_handle (log_severity, FIL__, __LINE__, 0,
	1819	MSG_FI_ADD2,
	1820	tmp, str);
[481]	1821	++sh.statistics.files_report;
	1822	SH_FREE(str);
	1823	SH_FREE(tmp);
	1824	}
	1825
	1826	if (sh.flag.reportonce == S_TRUE)
	1827	SET_SH_FFLAG_REPORTED(theFile->file_reported);
	1828
	1829	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	1830	{
	1831	p = sh_hash_push_int(theFile, fileHash);
	1832	if (p)
	1833	{
	1834	hashinsert (tab, p);
	1835	p->modi_mask = theFile->check_flags;
	1836	p->theFile.checkflags = p->modi_mask;
	1837	}
	1838	}
	1839
	1840	else if (S_TRUE == sh.flag.update)
	1841	{
	1842	if (S_TRUE == sh_util_ask_update (theFile->fullpath))
	1843	{
	1844	p = sh_hash_push_int(theFile, fileHash);
	1845	if (p)
	1846	{
	1847	hashinsert (tab, p);
	1848	p->modi_mask = theFile->check_flags;
	1849	p->theFile.checkflags = p->modi_mask;
	1850	}
	1851	}
	1852	else
	1853	retval = 1;
	1854	}
	1855	return retval;
	1856	}
	1857
[1]	1858	/*****************************************************************
	1859	*
	1860	* Compare a file with the database status.
	1861	*
	1862	*****************************************************************/
	1863	int sh_hash_compdata (int class, file_type * theFile, char * fileHash,
	1864	char * policy_override, int severity_override)
	1865	{
	1866	char * msg;
	1867	sh_file_t * p;
	1868	char * tmp;
	1869	char * tmp_path;
	1870	char * tmp_lnk;
	1871	char * tmp_lnk_old;
	1872
	1873	char timstr1c[32];
	1874	char timstr2c[32];
	1875	char timstr1a[32];
	1876	char timstr2a[32];
	1877	char timstr1m[32];
	1878	char timstr2m[32];
	1879	char linkHash[KEY_LEN+1];
[169]	1880	char * linkComp;
[1]	1881	int maxcomp;
[492]	1882	volatile int checksum_flag = 0;
[1]	1883
	1884	char change_code[16];
	1885	int i;
	1886
[170]	1887	unsigned long modi_mask;
[1]	1888
	1889	char log_policy[32];
[153]	1890	volatile int log_severity;
[133]	1891	char hashbuf[KEYBUF_SIZE];
[481]	1892	struct {
	1893	unsigned long oldflags;
	1894	unsigned long newflags;
	1895	} cf_report;
[1]	1896
[170]	1897	int retval;
[149]	1898
[1]	1899	SL_ENTER(_("sh_hash_compdata"));
	1900
	1901	if (IsInit != 1) sh_hash_init();
	1902
	1903	if (severity_override < 0)
	1904	log_severity = ShDFLevel[class];
	1905	else
	1906	log_severity = severity_override;
	1907
	1908	if (policy_override != NULL)
	1909	sl_strlcpy (log_policy, policy_override, 32);
	1910
	1911	/* -------- find the entry for the file ---------------- */
	1912
[149]	1913	SH_MUTEX_LOCK(mutex_hash);
	1914
[170]	1915	modi_mask = 0;
	1916	retval = 0;
	1917
[1]	1918	if (sl_strlen(theFile->fullpath) <= MAX_PATH_STORE)
	1919	p = hashsearch(theFile->fullpath);
	1920	else
	1921	p = hashsearch( sh_tiger_hash(theFile->fullpath,
	1922	TIGER_DATA,
[133]	1923	sl_strlen(theFile->fullpath),
	1924	hashbuf, sizeof(hashbuf))
[1]	1925	);
	1926
	1927
	1928	/* --------- Not found in database. ------------
	1929	*/
	1930
	1931	if (p == NULL)
	1932	{
[481]	1933	retval = handle_notfound(log_severity, class, theFile, fileHash);
[149]	1934	goto unlock_and_return;
[1]	1935	}
	1936
[425]	1937	/* --------- Skip if we don't want to report changes. ------------
	1938	*/
	1939
	1940	if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
	1941	{
[481]	1942	MODI_SET(theFile->check_flags, MODI_NOCHECK);
	1943	p->modi_mask = theFile->check_flags;
	1944	p->theFile.checkflags = p->modi_mask;
[425]	1945	goto unlock_and_return;
	1946	}
	1947
[481]	1948	cf_report.oldflags = p->theFile.checkflags;
	1949	cf_report.newflags = theFile->check_flags;
[149]	1950
[481]	1951	p->modi_mask = theFile->check_flags;
	1952	p->theFile.checkflags = p->modi_mask;
	1953
[1]	1954	/* initialize change_code */
	1955	for (i = 0; i < 15; ++i)
	1956	change_code[i] = '-';
	1957	change_code[15] = '\0';
	1958
	1959	TPT ((0, FIL__, __LINE__, _("file=<%s>, cs_old=<%s>, cs_new=<%s>\n"),
	1960	theFile->fullpath, fileHash, p->theFile.checksum));
	1961
[474]	1962	if ( (fileHash != NULL) &&
[19]	1963	(strncmp (fileHash, p->theFile.checksum, KEY_LEN) != 0) &&
[481]	1964	(theFile->check_flags & MODI_CHK) != 0)
[1]	1965	{
[492]	1966	checksum_flag = 1;
	1967
[481]	1968	if ((theFile->check_flags & MODI_SGROW) == 0)
[19]	1969	{
	1970	modi_mask \|= MODI_CHK;
	1971	change_code[0] = 'C';
	1972	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
	1973	}
	1974	else
	1975	{
[425]	1976	if (0 != strncmp (&fileHash[KEY_LEN + 1], p->theFile.checksum, KEY_LEN))
[19]	1977	{
[425]	1978	if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
[481]	1979	(UINT64) p->theFile.ino, p->theFile.checksum,
	1980	p->theFile.checkflags))
[425]	1981	{
	1982	modi_mask \|= MODI_CHK;
	1983	change_code[0] = 'C';
	1984	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
	1985	}
	1986	else
	1987	{
	1988	/* logfile has been rotated */
	1989	p->theFile.size = theFile->size;
	1990	p->theFile.ino = theFile->ino;
	1991	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	1992	}
[19]	1993	}
	1994	else
	1995	{
	1996	p->theFile.size = theFile->size;
	1997	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	1998	}
	1999	}
[1]	2000	}
	2001
	2002	if (p->theFile.c_mode[0] == 'l')
	2003	{
[169]	2004	if (!(theFile->link_path) &&
[481]	2005	(theFile->check_flags & MODI_LNK) != 0)
[1]	2006	{
[169]	2007	linkComp = NULL;
[93]	2008	modi_mask \|= MODI_LNK;
	2009	change_code[1] = 'L';
	2010	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
[169]	2011	}
	2012	else
	2013	{
	2014	if (sl_strlen(theFile->link_path) >= MAX_PATH_STORE)
	2015	{
	2016	sl_strlcpy(linkHash,
	2017	sh_tiger_hash(theFile->link_path,
	2018	TIGER_DATA,
	2019	sl_strlen(theFile->link_path),
	2020	hashbuf, sizeof(hashbuf)),
	2021	MAX_PATH_STORE+1);
	2022	linkComp = linkHash;
	2023	maxcomp = KEY_LEN;
	2024	}
	2025	else
	2026	{
	2027	linkComp = theFile->link_path;
	2028	maxcomp = MAX_PATH_STORE;
	2029	}
	2030
	2031	if ( sl_strncmp (linkComp, p->linkpath, maxcomp) != 0 &&
[481]	2032	(theFile->check_flags & MODI_LNK) != 0)
[169]	2033	{
	2034	modi_mask \|= MODI_LNK;
	2035	change_code[1] = 'L';
	2036	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
	2037	}
	2038	}
[1]	2039	}
	2040
	2041	if (p->theFile.c_mode[0] == 'c' \|\| p->theFile.c_mode[0] == 'b')
	2042	{
	2043	if ( ( major(theFile->rdev) != major((dev_t)p->theFile.rdev) \|\|
	2044	minor(theFile->rdev) != minor((dev_t)p->theFile.rdev) ) &&
[481]	2045	(theFile->check_flags & MODI_RDEV) != 0)
[1]	2046	{
	2047	modi_mask \|= MODI_RDEV;
	2048	change_code[2] = 'D';
	2049	TPT ((0, FIL__, __LINE__, _("mod=<rdev>")));
	2050	}
	2051	}
	2052
	2053	/* cast to UINT32 in case ino_t is not 32bit
	2054	*/
	2055	if ( (UINT32) theFile->ino != (UINT32) p->theFile.ino &&
[481]	2056	(theFile->check_flags & MODI_INO) != 0)
[1]	2057	{
[492]	2058	if ((theFile->check_flags & MODI_SGROW) == 0)
	2059	{
	2060	modi_mask \|= MODI_INO;
	2061	change_code[3] = 'I';
	2062	TPT ((0, FIL__, __LINE__, _("mod=<inode>")));
	2063	}
	2064	else
	2065	{
	2066	/* growing log, checksum ok but inode changed
	2067	*/
	2068	if (checksum_flag == 0)
	2069	{
	2070	if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
	2071	(UINT64) p->theFile.ino, p->theFile.checksum,
	2072	p->theFile.checkflags))
	2073	{
	2074	modi_mask \|= MODI_INO;
	2075	change_code[3] = 'I';
	2076	TPT ((0, FIL__, __LINE__, _("mod=<inode>")));
	2077	}
	2078	else
	2079	{
	2080	/* logfile has been rotated */
	2081	p->theFile.size = theFile->size;
	2082	p->theFile.ino = theFile->ino;
	2083	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	2084	}
	2085	}
	2086	else
	2087	{
	2088	modi_mask \|= MODI_INO;
	2089	change_code[3] = 'I';
	2090	TPT ((0, FIL__, __LINE__, _("mod=<inode>")));
	2091	}
	2092	}
[1]	2093	}
	2094
	2095	if ( theFile->hardlinks != (nlink_t) p->theFile.hardlinks &&
[481]	2096	(theFile->check_flags & MODI_HLN) != 0)
[1]	2097	{
	2098	modi_mask \|= MODI_HLN;
	2099	change_code[4] = 'H';
	2100	TPT ((0, FIL__, __LINE__, _("mod=<hardlink>")));
	2101	}
	2102
	2103
	2104	if ( ( (theFile->mode != p->theFile.mode)
[68]	2105	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	2106	\|\| ( (sh_unix_check_selinux\|sh_unix_check_acl) &&
	2107	(
	2108	(theFile->attr_string == NULL && p->attr_string != NULL) \|\|
	2109	(theFile->attr_string != NULL && p->attr_string == NULL) \|\|
	2110	(theFile->attr_string != NULL && 0 != strcmp(theFile->attr_string, p->attr_string))
	2111	)
	2112	)
	2113	#endif
[10]	2114	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2115	\|\| (theFile->attributes != p->theFile.attributes)
	2116	#endif
[68]	2117	)
[481]	2118	&& (theFile->check_flags & MODI_MOD) != 0)
[1]	2119	{
	2120	modi_mask \|= MODI_MOD;
	2121	change_code[5] = 'M';
	2122	TPT ((0, FIL__, __LINE__, _("mod=<mode>")));
	2123	/*
	2124	* report link path if switch link/no link
	2125	*/
[481]	2126	if ((theFile->check_flags & MODI_LNK) != 0 &&
[1]	2127	(theFile->c_mode[0] != p->theFile.c_mode[0]) &&
	2128	(theFile->c_mode[0] == 'l' \|\| p->theFile.c_mode[0] == 'l'))
	2129	{
	2130	modi_mask \|= MODI_LNK;
	2131	change_code[1] = 'L';
	2132	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
	2133	}
	2134	}
	2135
	2136	if ( theFile->owner != (uid_t) p->theFile.owner &&
[481]	2137	(theFile->check_flags & MODI_USR) != 0)
[1]	2138	{
	2139	modi_mask \|= MODI_USR;
	2140	change_code[6] = 'U';
	2141	TPT ((0, FIL__, __LINE__, _("mod=<user>")));
	2142	}
	2143
	2144	if ( theFile->group != (gid_t) p->theFile.group &&
[481]	2145	(theFile->check_flags & MODI_GRP) != 0)
[1]	2146	{
	2147	modi_mask \|= MODI_GRP;
	2148	change_code[7] = 'G';
	2149	TPT ((0, FIL__, __LINE__, _("mod=<group>")));
	2150	}
	2151
	2152
	2153	if ( theFile->mtime != (time_t) p->theFile.mtime &&
[481]	2154	(theFile->check_flags & MODI_MTM) != 0)
[1]	2155	{
	2156	modi_mask \|= MODI_MTM;
	2157	change_code[8] = 'T';
	2158	TPT ((0, FIL__, __LINE__, _("mod=<mtime>")));
	2159	}
	2160
[481]	2161	if ( (theFile->check_flags & MODI_ATM) != 0 &&
[68]	2162	theFile->atime != (time_t) p->theFile.atime)
[1]	2163	{
	2164	modi_mask \|= MODI_ATM;
	2165	change_code[8] = 'T';
	2166	TPT ((0, FIL__, __LINE__, _("mod=<atime>")));
	2167	}
	2168
	2169
	2170	/* Resetting the access time will set a new ctime. Thus, either we ignore
	2171	* the access time or the ctime for NOIGNORE
	2172	*/
	2173	if ( theFile->ctime != (time_t) p->theFile.ctime &&
[481]	2174	(theFile->check_flags & MODI_CTM) != 0)
[1]	2175	{
	2176	modi_mask \|= MODI_CTM;
	2177	change_code[8] = 'T';
	2178	TPT ((0, FIL__, __LINE__, _("mod=<ctime>")));
	2179	}
	2180
	2181	if ( theFile->size != (off_t) p->theFile.size &&
[481]	2182	(theFile->check_flags & MODI_SIZ) != 0)
[1]	2183	{
[481]	2184	if ((theFile->check_flags & MODI_SGROW) == 0 \|\|
[19]	2185	theFile->size < (off_t) p->theFile.size)
[1]	2186	{
	2187	modi_mask \|= MODI_SIZ;
	2188	change_code[9] = 'S';
	2189	TPT ((0, FIL__, __LINE__, _("mod=<size>")));
[19]	2190	}
[1]	2191	}
	2192	change_code[10] = '\0';
	2193
[205]	2194	/* --- Directories special case ---
	2195	*/
	2196	if (p->theFile.c_mode[0] == 'd' &&
	2197	0 == (modi_mask & ~(MODI_SIZ\|MODI_ATM\|MODI_CTM\|MODI_MTM)) &&
	2198	sh_loosedircheck == S_TRUE)
	2199	{
	2200	modi_mask = 0;
	2201	}
	2202
[1]	2203	/* --- Report full details. ---
	2204	*/
	2205	if (modi_mask != 0 && sh.flag.fulldetail == S_TRUE)
	2206	{
[481]	2207	if ((theFile->check_flags & MODI_ATM) == 0)
[1]	2208	modi_mask = MASK_READONLY_;
	2209	else
	2210	modi_mask = MASK_NOIGNORE_;
	2211	}
	2212
	2213	/* --- Report on modified files. ---
	2214	*/
[114]	2215	if (modi_mask != 0 && (!SH_FFLAG_REPORTED_SET(p->fflags)))
[1]	2216	{
[170]	2217	tmp = SH_ALLOC(SH_MSG_BUF);
	2218	msg = SH_ALLOC(SH_MSG_BUF);
[1]	2219	msg[0] = '\0';
	2220
[481]	2221	sh_files_fixup_mask(class, &(cf_report.newflags));
	2222
	2223	if ( (report_checkflags != S_FALSE) && (cf_report.oldflags != cf_report.newflags))
	2224	{
	2225	sl_snprintf(tmp, SH_MSG_BUF,
	2226	#ifdef SH_USE_XML
	2227	_("checkflags_old=\"0%lo\" checkflags_new=\"0%lo\" "),
	2228	#else
	2229	_("checkflags_old=<0%lo>, checkflags_new=<0%lo>, "),
	2230	#endif
	2231	cf_report.oldflags, cf_report.newflags);
	2232	sl_strlcat(msg, tmp, SH_MSG_BUF);
	2233	}
	2234
[1]	2235	if ( ((modi_mask & MODI_MOD) != 0)
[181]	2236	#if defined(HAVE_LIBPRELUDE)
[68]	2237	\|\| ((modi_mask & MODI_USR) != 0)
	2238	\|\| ((modi_mask & MODI_GRP) != 0)
[1]	2239	#endif
	2240	)
	2241	{
[10]	2242	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[170]	2243	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2244	#ifdef SH_USE_XML
	2245	_("mode_old=\"%s\" mode_new=\"%s\" attr_old=\"%s\" attr_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" iattr_old=\"%ld\" iattr_new=\"%ld\" "),
	2246	#else
	2247	_("mode_old=<%s>, mode_new=<%s>, attr_old=<%s>, attr_new=<%s>, "),
	2248	#endif
	2249	p->theFile.c_mode, theFile->c_mode,
	2250	p->theFile.c_attributes, theFile->c_attributes
	2251	#ifdef SH_USE_XML
	2252	, (long) p->theFile.mode, (long) theFile->mode,
	2253	(long) p->theFile.attributes,
	2254	(long) theFile->attributes
	2255	#endif
	2256	);
	2257	#else
	2258	#ifdef SH_USE_XML
[170]	2259	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2260	_("mode_old=\"%s\" mode_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" "),
[68]	2261	p->theFile.c_mode, theFile->c_mode,
	2262	(long) p->theFile.mode, (long) theFile->mode);
[1]	2263	#else
[170]	2264	sl_snprintf(tmp, SH_MSG_BUF, _("mode_old=<%s>, mode_new=<%s>, "),
[68]	2265	p->theFile.c_mode, theFile->c_mode);
[1]	2266	#endif
[68]	2267	#endif
[170]	2268	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	2269
	2270	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	2271	if (theFile->attr_string != NULL \|\| p->attr_string != NULL)
	2272	{
[170]	2273	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2274	#ifdef SH_USE_XML
[68]	2275	_("acl_old=\"%s\" acl_new=\"%s\" "),
	2276	#else
	2277	_("acl_old=<%s>, acl_new=<%s>, "),
[1]	2278	#endif
[68]	2279	(p->attr_string) ? p->attr_string : _("none"),
	2280	(theFile->attr_string) ? theFile->attr_string : _("none"));
	2281
[170]	2282	sl_strlcat(msg, tmp, SH_MSG_BUF);
[68]	2283	}
[1]	2284	#endif
[68]	2285
[1]	2286	if ((modi_mask & MODI_MOD) != 0)
	2287	{
	2288	/*
	2289	* We postpone update if sh.flag.update == S_TRUE because
	2290	* in interactive mode the user may not accept the change.
	2291	*/
	2292	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2293	{
	2294	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
	2295	p->theFile.mode = theFile->mode;
[10]	2296	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2297	sl_strlcpy(p->theFile.c_attributes,theFile->c_attributes,16);
	2298	p->theFile.attributes = theFile->attributes;
	2299	#endif
[68]	2300	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	2301	if (p->attr_string == NULL && theFile->attr_string != NULL)
	2302	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
	2303	else if (p->attr_string != NULL && theFile->attr_string == NULL)
	2304	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
	2305	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	2306	{
	2307	if (0 != strcmp(theFile->attr_string, p->attr_string))
	2308	{
	2309	SH_FREE(p->attr_string);
	2310	p->attr_string = sh_util_strdup (theFile->attr_string);
	2311	}
	2312	}
	2313	#endif
[1]	2314	}
	2315	}
[481]	2316
[1]	2317	}
	2318
	2319	if ((modi_mask & MODI_HLN) != 0)
	2320	{
[170]	2321	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2322	#ifdef SH_USE_XML
[40]	2323	_("hardlinks_old=\"%lu\" hardlinks_new=\"%lu\" "),
[1]	2324	#else
[40]	2325	_("hardlinks_old=<%lu>, hardlinks_new=<%lu>, "),
[1]	2326	#endif
	2327	(unsigned long) p->theFile.hardlinks,
	2328	(unsigned long) theFile->hardlinks);
[170]	2329	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2330
[1]	2331	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2332	p->theFile.hardlinks = theFile->hardlinks;
	2333	}
	2334
	2335	if ((modi_mask & MODI_RDEV) != 0)
	2336	{
[170]	2337	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2338	#ifdef SH_USE_XML
[40]	2339	_("device_old=\"%lu,%lu\" device_new=\"%lu,%lu\" idevice_old=\"%lu\" idevice_new=\"%lu\" "),
[1]	2340	#else
[40]	2341	_("device_old=<%lu,%lu>, device_new=<%lu,%lu>, "),
[1]	2342	#endif
	2343	(unsigned long) major(p->theFile.rdev),
	2344	(unsigned long) minor(p->theFile.rdev),
	2345	(unsigned long) major(theFile->rdev),
	2346	(unsigned long) minor(theFile->rdev)
	2347	#ifdef SH_USE_XML
	2348	, (unsigned long) p->theFile.rdev,
	2349	(unsigned long) theFile->rdev
	2350	#endif
	2351	);
[170]	2352	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2353
[1]	2354	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2355	p->theFile.rdev = theFile->rdev;
	2356	}
	2357
	2358	if ((modi_mask & MODI_INO) != 0)
	2359	{
[170]	2360	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2361	#ifdef SH_USE_XML
[40]	2362	_("inode_old=\"%lu\" inode_new=\"%lu\" "),
[1]	2363	#else
[40]	2364	_("inode_old=<%lu>, inode_new=<%lu>, "),
[1]	2365	#endif
	2366	(unsigned long) p->theFile.ino,
	2367	(unsigned long) theFile->ino);
[170]	2368	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2369
[1]	2370	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
[40]	2371	{
	2372	p->theFile.ino = theFile->ino;
	2373	p->theFile.dev = theFile->dev;
	2374	}
[1]	2375	}
	2376
[40]	2377
	2378	/*
	2379	* also report device for prelude
	2380	*/
[181]	2381	#if defined(HAVE_LIBPRELUDE)
[40]	2382	if ((modi_mask & MODI_INO) != 0)
	2383	{
[170]	2384	sl_snprintf(tmp, SH_MSG_BUF,
[40]	2385	#ifdef SH_USE_XML
	2386	_("dev_old=\"%lu,%lu\" dev_new=\"%lu,%lu\" "),
	2387	#else
	2388	_("dev_old=<%lu,%lu>, dev_new=<%lu,%lu>, "),
	2389	#endif
	2390	(unsigned long) major(p->theFile.dev),
	2391	(unsigned long) minor(p->theFile.dev),
	2392	(unsigned long) major(theFile->dev),
	2393	(unsigned long) minor(theFile->dev)
	2394	);
[170]	2395	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2396
[40]	2397	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2398	p->theFile.dev = theFile->dev;
	2399	}
	2400	#endif
	2401
[1]	2402	if ( ((modi_mask & MODI_USR) != 0)
[181]	2403	#if defined(HAVE_LIBPRELUDE)
[1]	2404	\|\| ((modi_mask & MODI_MOD) != 0)
	2405	#endif
	2406	)
	2407	{
	2408	#ifdef SH_USE_XML
[170]	2409	sl_snprintf(tmp, SH_MSG_BUF,
[40]	2410	_("owner_old=\"%s\" owner_new=\"%s\" iowner_old=\"%ld\" iowner_new=\"%ld\" "),
[1]	2411	#else
[170]	2412	sl_snprintf(tmp, SH_MSG_BUF,
[40]	2413	_("owner_old=<%s>, owner_new=<%s>, iowner_old=<%ld>, iowner_new=<%ld>, "),
[1]	2414	#endif
[40]	2415	p->theFile.c_owner, theFile->c_owner,
	2416	(long) p->theFile.owner, (long) theFile->owner
[1]	2417	);
[170]	2418	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2419
[1]	2420	if ((modi_mask & MODI_USR) != 0) {
	2421	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2422	{
	2423	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
	2424	p->theFile.owner = theFile->owner;
	2425	}
	2426	}
	2427	}
	2428
	2429	if ( ((modi_mask & MODI_GRP) != 0)
[181]	2430	#if defined(HAVE_LIBPRELUDE)
[1]	2431	\|\| ((modi_mask & MODI_MOD) != 0)
	2432	#endif
	2433	)
	2434	{
	2435	#ifdef SH_USE_XML
[170]	2436	sl_snprintf(tmp, SH_MSG_BUF,
[40]	2437	_("group_old=\"%s\" group_new=\"%s\" igroup_old=\"%ld\" igroup_new=\"%ld\" "),
[1]	2438	p->theFile.c_group, theFile->c_group,
	2439	(long) p->theFile.group, (long) theFile->group);
	2440	#else
[170]	2441	sl_snprintf(tmp, SH_MSG_BUF,
[40]	2442	_("group_old=<%s>, group_new=<%s>, igroup_old=<%ld>, igroup_new=<%ld>, "),
	2443	p->theFile.c_group, theFile->c_group,
	2444	(long) p->theFile.group, (long) theFile->group);
[1]	2445	#endif
	2446
[170]	2447	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2448
[1]	2449	if ((modi_mask & MODI_GRP) != 0) {
	2450	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2451	{
	2452	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
	2453	p->theFile.group = theFile->group;
	2454	}
	2455	}
	2456	}
	2457
	2458	if ((modi_mask & MODI_SIZ) != 0)
	2459	{
[170]	2460	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
[1]	2461	(UINT64) p->theFile.size,
	2462	(UINT64) theFile->size);
[170]	2463	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2464
[1]	2465	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2466	p->theFile.size = theFile->size;
	2467	}
	2468
	2469	if ((modi_mask & MODI_CTM) != 0)
	2470	{
[132]	2471	(void) sh_unix_gmttime (p->theFile.ctime, timstr1c, sizeof(timstr1c));
	2472	(void) sh_unix_gmttime (theFile->ctime, timstr2c, sizeof(timstr2c));
[1]	2473	#ifdef SH_USE_XML
[170]	2474	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" ctime_new=\"%s\" "),
[1]	2475	timstr1c, timstr2c);
	2476	#else
[170]	2477	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, ctime_new=<%s>, "),
[1]	2478	timstr1c, timstr2c);
	2479	#endif
[170]	2480	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2481
[1]	2482	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2483	p->theFile.ctime = theFile->ctime;
	2484	}
	2485
	2486	if ((modi_mask & MODI_ATM) != 0)
	2487	{
[132]	2488	(void) sh_unix_gmttime (p->theFile.atime, timstr1a, sizeof(timstr1a));
	2489	(void) sh_unix_gmttime (theFile->atime, timstr2a, sizeof(timstr2a));
[1]	2490	#ifdef SH_USE_XML
[170]	2491	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" atime_new=\"%s\" "),
[1]	2492	timstr1a, timstr2a);
	2493	#else
[170]	2494	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, atime_new=<%s>, "),
[1]	2495	timstr1a, timstr2a);
	2496	#endif
[170]	2497	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2498
[1]	2499	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2500	p->theFile.atime = theFile->atime;
	2501	}
	2502
	2503	if ((modi_mask & MODI_MTM) != 0)
	2504	{
[132]	2505	(void) sh_unix_gmttime (p->theFile.mtime, timstr1m, sizeof(timstr1m));
	2506	(void) sh_unix_gmttime (theFile->mtime, timstr2m, sizeof(timstr2m));
[1]	2507	#ifdef SH_USE_XML
[170]	2508	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" mtime_new=\"%s\" "),
[1]	2509	timstr1m, timstr2m);
	2510	#else
[170]	2511	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, mtime_new=<%s>, "),
[1]	2512	timstr1m, timstr2m);
	2513	#endif
[170]	2514	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2515
[1]	2516	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2517	p->theFile.mtime = theFile->mtime;
	2518	}
	2519
	2520
	2521	if ((modi_mask & MODI_CHK) != 0)
	2522	{
[170]	2523	sl_snprintf(tmp, SH_MSG_BUF,
[1]	2524	#ifdef SH_USE_XML
	2525	_("chksum_old=\"%s\" chksum_new=\"%s\" "),
	2526	#else
	2527	_("chksum_old=<%s>, chksum_new=<%s>, "),
	2528	#endif
	2529	p->theFile.checksum, fileHash);
[170]	2530	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2531
[1]	2532	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
[107]	2533	{
	2534	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
[481]	2535	if ((theFile->check_flags & MODI_SGROW) != 0)
[107]	2536	p->theFile.size = theFile->size;
	2537	}
[481]	2538
	2539
[169]	2540	if (theFile->c_mode[0] != 'l' && theFile->link_path &&
	2541	strlen(theFile->link_path) > 2)
	2542	modi_mask \|= MODI_LNK;
[1]	2543	}
	2544
	2545
[169]	2546	if ((modi_mask & MODI_LNK) != 0 /* && theFile->c_mode[0] == 'l' */)
[1]	2547	{
[169]	2548	if (theFile->link_path)
	2549	tmp_lnk = sh_util_safe_name(theFile->link_path);
	2550	else
	2551	tmp_lnk = sh_util_strdup("-");
	2552	if (p->linkpath)
	2553	tmp_lnk_old = sh_util_safe_name(p->linkpath);
	2554	else
	2555	tmp_lnk_old = sh_util_strdup("-");
[1]	2556	#ifdef SH_USE_XML
[170]	2557	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" link_new=\"%s\" "),
[1]	2558	tmp_lnk_old, tmp_lnk);
	2559	#else
[294]	2560	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=<%s>, link_new=<%s>, "),
[1]	2561	tmp_lnk_old, tmp_lnk);
	2562	#endif
	2563	SH_FREE(tmp_lnk);
	2564	SH_FREE(tmp_lnk_old);
[170]	2565	sl_strlcat(msg, tmp, SH_MSG_BUF);
[481]	2566
[1]	2567	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
	2568	{
[481]	2569	if (p->linkpath != NULL)
[1]	2570	SH_FREE(p->linkpath);
[481]	2571	if (!(theFile->link_path))
	2572	p->linkpath = sh_util_strdup("-");
[149]	2573	else
[167]	2574	p->linkpath = sh_util_strdup(theFile->link_path);
[1]	2575	}
	2576	}
	2577
[481]	2578	if (MODI_AUDIT_ENABLED(theFile->check_flags))
[294]	2579	{
	2580	char result[256];
[488]	2581
	2582	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__,
	2583	0, MSG_E_SUBGPATH,
	2584	_("Fetching audit record"),
	2585	_("sh_hash"), theFile->fullpath );
[1]	2586
[488]	2587	if (NULL != sh_audit_fetch (theFile->fullpath, theFile->mtime, theFile->ctime, result, sizeof(result)))
[294]	2588	{
	2589	#ifdef SH_USE_XML
	2590	sl_strlcat(msg, _("obj=\""), SH_MSG_BUF);
	2591	#else
	2592	sl_strlcat(msg, _("obj=<"), SH_MSG_BUF);
	2593	#endif
	2594
	2595	sl_strlcat(msg, result, SH_MSG_BUF);
	2596
	2597	#ifdef SH_USE_XML
	2598	sl_strlcat(msg, _("\" "), SH_MSG_BUF);
	2599	#else
	2600	sl_strlcat(msg, _(">"), SH_MSG_BUF);
	2601	#endif
	2602	}
	2603	}
	2604
[481]	2605	/****************************************************
	2606	*
	2607	* REPORT on file change
	2608	*
	2609	****************************************************/
[1]	2610	tmp_path = sh_util_safe_name(theFile->fullpath);
[488]	2611	if (!sh_global_check_silent)
	2612	sh_error_handle(log_severity, FIL__, __LINE__,
	2613	(long) modi_mask, MSG_FI_CHAN,
	2614	(policy_override == NULL) ? _(policy[class]):log_policy,
	2615	change_code, tmp_path, msg);
[405]	2616	++sh.statistics.files_report;
[1]	2617
	2618	SH_FREE(tmp_path);
	2619	SH_FREE(tmp);
	2620	SH_FREE(msg);
	2621
	2622	if (S_TRUE == sh.flag.update)
	2623	{
	2624	if (S_FALSE == sh_util_ask_update(theFile->fullpath))
	2625	{
	2626	/* user does not want to update, thus we replace
	2627	* with data from the baseline database
	2628	*/
	2629	sl_strlcpy(theFile->c_mode, p->theFile.c_mode, 11);
	2630	theFile->mode = p->theFile.mode;
[10]	2631	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2632	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, 16);
	2633	theFile->attributes = p->theFile.attributes;
	2634	#endif
[68]	2635	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	2636	if (theFile->attr_string == NULL && p->attr_string != NULL)
	2637	{ theFile->attr_string = sh_util_strdup (p->attr_string); }
	2638	else if (theFile->attr_string != NULL && p->attr_string == NULL)
	2639	{ SH_FREE(theFile->attr_string); theFile->attr_string = NULL; }
	2640	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	2641	{
	2642	if (0 != strcmp(theFile->attr_string, p->attr_string))
	2643	{
	2644	SH_FREE(theFile->attr_string);
	2645	theFile->attr_string = sh_util_strdup (p->attr_string);
	2646	}
	2647	}
	2648	#endif
[1]	2649
	2650	if (theFile->c_mode[0] == 'l') /* c_mode is already copied */
	2651	{
[167]	2652	if (theFile->link_path)
	2653	SH_FREE(theFile->link_path);
	2654	if (p->linkpath)
	2655	theFile->link_path = sh_util_strdup(p->linkpath);
	2656	else
	2657	theFile->link_path = sh_util_strdup("-");
[1]	2658	}
	2659	else
	2660	{
[167]	2661	if (theFile->link_path)
	2662	SH_FREE(theFile->link_path);
[481]	2663	if (p->linkpath)
[167]	2664	theFile->link_path = sh_util_strdup(p->linkpath);
	2665	else
	2666	theFile->link_path = NULL;
[1]	2667	}
	2668
	2669	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
	2670
	2671	theFile->mtime = p->theFile.mtime;
	2672	theFile->ctime = p->theFile.ctime;
	2673	theFile->atime = p->theFile.atime;
	2674
	2675	theFile->size = p->theFile.size;
	2676
	2677	sl_strlcpy(theFile->c_group, p->theFile.c_group, GROUP_MAX+2);
	2678	theFile->group = p->theFile.group;
	2679	sl_strlcpy(theFile->c_owner, p->theFile.c_owner, USER_MAX+2);
	2680	theFile->owner = p->theFile.owner;
	2681
	2682	theFile->ino = p->theFile.ino;
	2683	theFile->rdev = p->theFile.rdev;
	2684	theFile->dev = p->theFile.dev;
	2685	theFile->hardlinks = p->theFile.hardlinks;
	2686
[114]	2687	SET_SH_FFLAG_VISITED(p->fflags);
	2688	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[149]	2689	retval = 1;
	2690	goto unlock_and_return;
[1]	2691	}
[77]	2692	else /* if (sh.flag.reportonce == S_TRUE) */
[1]	2693	{
	2694	/* we replace the data in the in-memory copy of the
	2695	* baseline database, because otherwise we would get
	2696	* another warning if the suidcheck runs
	2697	*/
	2698	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
	2699	p->theFile.mode = theFile->mode;
[10]	2700	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
[1]	2701	sl_strlcpy(p->theFile.c_attributes, theFile->c_attributes, 16);
	2702	p->theFile.attributes = theFile->attributes;
	2703	#endif
[68]	2704	#if defined(USE_ACL) \|\| defined(USE_XATTR)
	2705	if (p->attr_string == NULL && theFile->attr_string != NULL)
	2706	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
	2707	else if (p->attr_string != NULL && theFile->attr_string == NULL)
	2708	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
	2709	else if (theFile->attr_string != NULL && p->attr_string != NULL)
	2710	{
	2711	if (0 != strcmp(theFile->attr_string, p->attr_string))
	2712	{
	2713	SH_FREE(p->attr_string);
	2714	p->attr_string = sh_util_strdup (theFile->attr_string);
	2715	}
	2716	}
	2717	#endif
[1]	2718
[167]	2719	if (theFile->c_mode[0] == 'l' \|\| theFile->link_path)
[1]	2720	{
[481]	2721	if (p->linkpath != NULL)
[1]	2722	SH_FREE(p->linkpath);
[167]	2723	p->linkpath = sh_util_strdup(theFile->link_path);
[1]	2724	}
	2725	else
	2726	{
[481]	2727	if (p->linkpath != NULL)
[167]	2728	SH_FREE(p->linkpath);
[481]	2729	p->linkpath = sh_util_strdup("-");
[1]	2730	}
	2731
	2732	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
	2733
	2734	p->theFile.mtime = theFile->mtime;
	2735	p->theFile.ctime = theFile->ctime;
	2736	p->theFile.atime = theFile->atime;
	2737
	2738	p->theFile.size = theFile->size;
	2739
	2740	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
	2741	p->theFile.group = theFile->group;
	2742	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
	2743	p->theFile.owner = theFile->owner;
	2744
	2745	p->theFile.ino = theFile->ino;
	2746	p->theFile.rdev = theFile->rdev;
	2747	p->theFile.dev = theFile->dev;
	2748	p->theFile.hardlinks = theFile->hardlinks;
	2749	}
	2750	}
	2751	}
	2752
[114]	2753	SET_SH_FFLAG_VISITED(p->fflags);
	2754	CLEAR_SH_FFLAG_CHECKED(p->fflags);
[1]	2755
[149]	2756	unlock_and_return:
[153]	2757	; /* 'label at end of compound statement */
[149]	2758	SH_MUTEX_UNLOCK(mutex_hash);
	2759	SL_RETURN(retval, _("sh_hash_compdata"));
[1]	2760	}
	2761
	2762	int hash_full_tree ()
	2763	{
	2764	sh_file_t * p;
	2765	int i;
	2766
[457]	2767	SL_ENTER(_("hash_full_tree"));
[1]	2768
	2769	if (IsInit != 1)
[457]	2770	SL_RETURN(0, _("hash_full_tree"));
[1]	2771
[149]	2772	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
[1]	2773	for (i = 0; i < TABSIZE; ++i)
	2774	{
	2775	for (p = tab[i]; p; p = p->next)
[114]	2776	CLEAR_SH_FFLAG_ALLIGNORE(p->fflags);
[1]	2777	}
[149]	2778	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
[457]	2779	SL_RETURN (0, _("hash_full_tree"));
[1]	2780	}
	2781
[457]	2782	#if !defined(SH_CUTEST)
	2783	static
	2784	#endif
	2785	int hash_remove_tree_test(char * s, char * fullpath, size_t len_s)
	2786	{
	2787	size_t len_p;
	2788	char * test;
[1]	2789
[457]	2790	len_p = strlen(fullpath);
	2791
	2792	if (len_p >= len_s)
	2793	{
	2794	if (0 == strncmp(s, fullpath, len_s))
	2795	{
	2796	if (len_p > len_s)
	2797	{
	2798	/* continue if not inside directory;
	2799	* len_s > 1 because everything is inside '/'
	2800	*/
	2801	if ((len_s > 1) && (fullpath[len_s] != '/'))
	2802	return S_FALSE;
	2803
	2804	test = sh_files_find_mostspecific_dir(fullpath);
	2805
	2806	if (test && 0 != strcmp(test, s)) {
	2807	/* There is a more specific directory, continue */
	2808	return S_FALSE;
	2809	}
	2810
	2811	if (NULL == sh_files_findfile(fullpath)) {
	2812	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
	2813	return S_TRUE;
	2814	}
	2815	}
	2816	else /* len_p == len */
	2817	{
	2818	/* it is 's' itself, mark and continue
	2819	* unless there is a policy for the inode itself
	2820	*/
	2821	if (NULL == sh_files_findfile(fullpath)) {
	2822	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
	2823	return S_TRUE;
	2824	}
	2825	else {
	2826	return S_FALSE;
	2827	}
	2828	}
	2829
	2830	} /* if path is in tree */
	2831	} /* if path is possibly in tree */
	2832	return S_FALSE;
	2833	}
	2834
	2835
[1]	2836	int hash_remove_tree (char * s)
	2837	{
[8]	2838	sh_file_t * p;
[457]	2839	size_t len_s;
[8]	2840	unsigned int i;
[1]	2841
	2842	SL_ENTER(_("hash_remove_tree"));
	2843
[8]	2844	if (!s \|\| *s == '\0')
[1]	2845	SL_RETURN ((-1), _("hash_remove_tree"));
	2846
[457]	2847	len_s = sl_strlen(s);
[8]	2848
[1]	2849	if (IsInit != 1)
	2850	sh_hash_init();
	2851
[149]	2852	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
[1]	2853	for (i = 0; i < TABSIZE; ++i)
	2854	{
	2855	for (p = tab[i]; p; p = p->next)
	2856	{
[457]	2857	if (p->fullpath)
	2858	{
	2859	/* if (0 == strncmp(s, p->fullpath, len_s)) // old */
[481]	2860	if (S_TRUE == hash_remove_tree_test(s, p->fullpath, len_s)) {
[457]	2861	SET_SH_FFLAG_ALLIGNORE(p->fflags);
[481]	2862	MODI_SET(p->theFile.checkflags, MODI_ALLIGNORE);
	2863	}
[457]	2864	} /* if path is not null */
	2865
[1]	2866	}
	2867	}
[149]	2868	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
[1]	2869	SL_RETURN ((0), _("hash_remove_tree"));
	2870	}
	2871
	2872	#if TIME_WITH_SYS_TIME
	2873	#include <sys/time.h>
	2874	#include <time.h>
	2875	#else
	2876	#if HAVE_SYS_TIME_H
	2877	#include <sys/time.h>
	2878	#else
	2879	#include <time.h>
	2880	#endif
	2881	#endif
	2882
[169]	2883	static int ListFullDetail = S_FALSE;
[1]	2884	static int ListWithDelimiter = S_FALSE;
[169]	2885	static char * ListFile = NULL;
[1]	2886
[169]	2887	int set_list_file (const char * c)
	2888	{
	2889	ListFile = sh_util_strdup(c);
	2890	return 0;
	2891	}
[481]	2892	char * get_list_file()
	2893	{
	2894	return ListFile;
	2895	}
[169]	2896
[20]	2897	int set_full_detail (const char * c)
[1]	2898	{
[149]	2899	(void) c;
[1]	2900	ListFullDetail = S_TRUE;
[149]	2901	return 0;
[1]	2902	}
	2903
[20]	2904	int set_list_delimited (const char * c)
[1]	2905	{
[149]	2906	(void) c;
[1]	2907	ListFullDetail = S_TRUE;
	2908	ListWithDelimiter = S_TRUE;
[149]	2909	return 0;
[1]	2910	}
[76]	2911
[149]	2912	/* Always quote the string, except if it is empty. Quote quotes by
[76]	2913	* doubling them.
	2914	*/
	2915	char * csv_escape(const char * str)
	2916	{
	2917	const char * p = str;
	2918	const char * q;
	2919
	2920	size_t size = 0;
	2921	size_t flag_quote = 0;
[362]	2922
[76]	2923	char * new;
	2924	char * pnew;
	2925
	2926	if (p)
	2927	{
	2928
	2929	while (*p)
	2930	{
[362]	2931	if (*p == '"')
[76]	2932	++flag_quote;
	2933
	2934	++size; ++p;
	2935	}
	2936
	2937	if (sl_ok_adds(size, flag_quote))
	2938	size += flag_quote; /* double each quote */
	2939	else
	2940	return NULL;
	2941
	2942	if (sl_ok_adds(size, 3))
	2943	size += 3; /* two quotes and terminating null */
	2944	else
	2945	return NULL;
	2946
	2947	new = SH_ALLOC(size);
	2948
	2949	if (flag_quote != 0)
	2950	{
	2951	new[0] = '"';
	2952	pnew = &new[1];
	2953	q = str;
	2954	while (*q)
	2955	{
	2956	pnew = q;
	2957	if (*pnew == '"')
	2958	{
	2959	++pnew; *pnew = '"';
	2960	}
	2961	++pnew; ++q;
	2962	}
	2963	*pnew = '"'; ++pnew;
	2964	*pnew = '\0';
	2965	}
	2966	else
	2967	{
	2968	if (size > 3)
	2969	{
	2970	new[0] = '"';
	2971	sl_strlcpy (&new[1], str, size-1);
	2972	new[size-2] = '"';
	2973	new[size-1] = '\0';
	2974	}
	2975	else
	2976	{
	2977	new[0] = '\0';
	2978	}
	2979	}
	2980
	2981	return new;
	2982	}
	2983	return NULL;
	2984	}
	2985
[444]	2986	int isHexKey(char * s)
	2987	{
	2988	int i;
	2989
	2990	for (i = 0; i < KEY_LEN; ++i)
	2991	{
	2992	if (*s)
	2993	{
	2994	if ((s >= '0' && s <= '9') \|\|
	2995	(s >= 'A' && s <= 'F') \|\|
	2996	(s >= 'a' && s <= 'f'))
	2997	{
	2998	++s;
	2999	continue;
	3000	}
	3001	}
	3002	return S_FALSE;
	3003	}
	3004	return S_TRUE;
	3005	}
	3006
	3007	#include "sh_checksum.h"
[76]	3008
[444]	3009	static char * KEYBUFtolower (char * s, char * result)
	3010	{
	3011	char * r = result;
	3012	if (s)
	3013	{
	3014	for (; *s; ++s)
	3015	{
	3016	r = tolower((unsigned char) s); ++r;
	3017	}
	3018	*r = '\0';
	3019	}
	3020	return result;
	3021	}
	3022
[1]	3023	void sh_hash_list_db_entry_full_detail (sh_file_t * p)
	3024	{
	3025	char * tmp;
[76]	3026	char * esc;
[1]	3027	char str[81];
[444]	3028	char hexdigest[SHA256_DIGEST_STRING_LENGTH];
	3029	char keybuffer[KEYBUF_SIZE];
[1]	3030
	3031	if (ListWithDelimiter == S_TRUE)
	3032	{
[40]	3033	printf(_("%7ld, %7ld, %10s, %5d, %12s, %5d, %3d, %-8s, %5d, %-8s, %5d, "),
	3034	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
[1]	3035	p->theFile.c_mode, (int) p->theFile.mode,
	3036	p->theFile.c_attributes, (int) p->theFile.attributes,
	3037	(int) p->theFile.hardlinks,
	3038	p->theFile.c_owner, (int) p->theFile.owner,
	3039	p->theFile.c_group, (int) p->theFile.group);
	3040	}
	3041	else
	3042	{
[40]	3043	printf(_("%7ld %7ld %10s %5d %12s %5d %3d %-8s %5d %-8s %5d "),
	3044	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
[1]	3045	p->theFile.c_mode, (int) p->theFile.mode,
	3046	p->theFile.c_attributes, (int) p->theFile.attributes,
	3047	(int) p->theFile.hardlinks,
	3048	p->theFile.c_owner, (int) p->theFile.owner,
	3049	p->theFile.c_group, (int) p->theFile.group);
	3050	}
	3051
	3052	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
[132]	3053	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.rdev);
[1]	3054	else
[132]	3055	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.size);
[1]	3056
	3057	printf( _(" %8s"), str);
	3058	if (ListWithDelimiter == S_TRUE)
	3059	putchar(',');
	3060
[132]	3061	printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime, str, sizeof(str)));
[1]	3062	if (ListWithDelimiter == S_TRUE)
	3063	putchar(',');
[132]	3064	printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime, str, sizeof(str)));
[1]	3065	if (ListWithDelimiter == S_TRUE)
	3066	putchar(',');
[132]	3067	printf( _(" %s"), sh_unix_gmttime (p->theFile.atime, str, sizeof(str)));
[1]	3068	if (ListWithDelimiter == S_TRUE)
	3069	putchar(',');
[444]	3070
	3071	if (isHexKey(p->theFile.checksum))
	3072	printf( _(" %s"), KEYBUFtolower(p->theFile.checksum, keybuffer));
	3073	else
	3074	printf( _(" %s"), SHA256_Base2Hex(p->theFile.checksum, hexdigest));
[1]	3075	if (ListWithDelimiter == S_TRUE)
	3076	putchar(',');
	3077
	3078	tmp = sh_util_safe_name(p->fullpath);
[76]	3079	if (ListWithDelimiter != S_TRUE)
	3080	{
	3081	printf( _(" %s"), tmp);
	3082	}
	3083	else
	3084	{
	3085	esc = csv_escape(tmp);
	3086	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
	3087	if (esc)
	3088	SH_FREE(esc);
	3089	}
[1]	3090	SH_FREE(tmp);
	3091
	3092	if ('l' == p->theFile.c_mode[0])
	3093	{
	3094	tmp = sh_util_safe_name(p->linkpath);
[76]	3095	if (ListWithDelimiter != S_TRUE)
	3096	{
	3097	printf(_(" -> %s"), tmp);
	3098	}
[1]	3099	else
[76]	3100	{
	3101	esc = csv_escape(tmp);
	3102	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
	3103	if (esc)
	3104	SH_FREE(esc);
	3105	}
[1]	3106	SH_FREE(tmp);
	3107	}
[68]	3108
	3109	if (p->attr_string)
	3110	{
	3111	tmp = sh_util_safe_name(p->attr_string);
[76]	3112	if (ListWithDelimiter != S_TRUE)
	3113	{
	3114	printf(_(" %s"), tmp);
	3115	}
	3116	else
	3117	{
	3118	esc = csv_escape(tmp);
	3119	printf( _(" %s"), (esc != NULL) ? esc : _("(null)"));
	3120	if (esc)
	3121	SH_FREE(esc);
	3122	}
[68]	3123	SH_FREE(tmp);
	3124	}
[1]	3125	else
[68]	3126	{
	3127	if (ListWithDelimiter == S_TRUE)
[210]	3128	printf("%s",_(" no_attr"));
[68]	3129	}
	3130	putchar('\n');
[1]	3131
	3132	return;
	3133	}
	3134
	3135	void sh_hash_list_db_entry (sh_file_t * p)
	3136	{
	3137	char nowtime[128];
	3138	char thetime[128];
	3139	char * tmp;
	3140	time_t now = time(NULL);
	3141	time_t then = (time_t) p->theFile.mtime;
[481]	3142	struct tm * time_ptr;
[1]	3143
[131]	3144	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
	3145	struct tm time_tm;
[481]	3146	#endif
[131]	3147
[481]	3148	if (ListFullDetail != S_FALSE)
	3149	{
	3150	sh_hash_list_db_entry_full_detail (p);
	3151	return;
	3152	}
	3153
	3154	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
[131]	3155	time_ptr = gmtime_r(&then, &time_tm);
[481]	3156	if (!time_ptr)
	3157	return;
[131]	3158	strftime(thetime, 127, _("%b %d %Y"), time_ptr);
	3159	time_ptr = gmtime_r(&now, &time_tm);
[481]	3160	if (!time_ptr)
	3161	return;
[131]	3162	strftime(nowtime, 127, _("%b %d %Y"), time_ptr);
	3163	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
	3164	{
	3165	time_ptr = gmtime_r(&then, &time_tm);
[481]	3166	if (!time_ptr)
	3167	return;
[131]	3168	strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
	3169	}
	3170	#else
[481]	3171	time_ptr = gmtime(&then);
	3172	if (!time_ptr)
	3173	return;
	3174	strftime(thetime, 127, _("%b %d %Y"), time_ptr);
	3175	time_ptr = gmtime(&now);
	3176	if (!time_ptr)
	3177	return;
	3178	strftime(nowtime, 127, _("%b %d %Y"), time_ptr);
[1]	3179	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
[481]	3180	{
	3181	time_ptr = gmtime(&then);
	3182	if (!time_ptr)
	3183	return;
	3184	strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
	3185	}
[131]	3186	#endif
[1]	3187
	3188	tmp = sh_util_safe_name(p->fullpath);
	3189	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
	3190	printf(_("%10s %3d %-8s %-8s %3d,%4d %s %s"),
	3191	p->theFile.c_mode, (int) p->theFile.hardlinks,
	3192	p->theFile.c_owner, p->theFile.c_group,
	3193	(int) major((dev_t)p->theFile.rdev),
	3194	(int) minor((dev_t)p->theFile.rdev),
	3195	thetime,
	3196	tmp);
	3197	else
	3198	printf(_("%10s %3d %-8s %-8s %8ld %s %s"),
	3199	p->theFile.c_mode, (int) p->theFile.hardlinks,
	3200	p->theFile.c_owner, p->theFile.c_group, (long) p->theFile.size,
	3201	thetime,
	3202	tmp);
	3203	SH_FREE(tmp);
	3204
	3205	if ('l' == p->theFile.c_mode[0])
	3206	{
	3207	tmp = sh_util_safe_name(p->linkpath);
	3208	printf(_(" -> %s\n"), tmp);
	3209	SH_FREE(tmp);
	3210	}
	3211	else
	3212	printf("\n");
	3213
	3214	return;
	3215	}
	3216
[169]	3217	#ifdef HAVE_LIBZ
	3218	#include <zlib.h>
	3219	#endif
	3220
	3221	int sh_hash_printcontent(char * linkpath)
	3222	{
	3223	#ifdef HAVE_LIBZ
	3224	unsigned char * decoded;
	3225	unsigned char * decompressed = NULL;
	3226	size_t dlen;
	3227	unsigned long clen;
	3228	unsigned long clen_o;
	3229	int res;
	3230
	3231	if (linkpath && *linkpath != '-')
	3232	{
	3233	dlen = sh_util_base64_dec_alloc (&decoded,
	3234	(unsigned char *)linkpath,
	3235	strlen(linkpath));
[170]	3236
[169]	3237	clen = dlen * 2 + 1;
[170]	3238
[169]	3239	do {
	3240	if (decompressed)
	3241	SH_FREE(decompressed);
	3242	clen += dlen; clen_o = clen;
	3243	decompressed = SH_ALLOC(clen);
	3244	res = uncompress(decompressed, &clen, decoded, dlen);
	3245	if (res == Z_MEM_ERROR)
[210]	3246	{ fprintf(stderr, "%s",_("Error: Not enough memory\n")); return -1; }
[169]	3247	if (res == Z_DATA_ERROR)
[210]	3248	{ fprintf(stderr, "%s",_("Error: Data corrupt or incomplete\n")); return -1; }
[169]	3249	} while (res == Z_BUF_ERROR \|\| clen == clen_o);
[170]	3250
[169]	3251	decompressed[clen] = '\0';
	3252	fputs( (char*) decompressed, stdout);
[227]	3253	SH_FREE(decompressed);
[169]	3254	return 0;
	3255	}
	3256	#else
	3257	(void) linkpath;
	3258	#endif
[210]	3259	fprintf(stderr, "%s",_("Error: No data available\n"));
[169]	3260	return -1;
	3261	}
	3262
[1]	3263	/* if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE) */
	3264	#endif

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

Download in other formats: