Context Navigation

source: trunk/src/sh_hash.c@ 488

Last change on this file since 488 was 488, checked in by katerina, 9 years ago
Fix for tickets #386 (silent check) and #387 (linux audit support).
File size: 78.3 KB

Line
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>
28	#include <ctype.h>
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
42
43	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
44
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"
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"
57	#include "sh_pthread.h"
58
59	#if defined(SH_WITH_CLIENT)
60	#include "sh_xfer.h"
61	#endif
62
63
64	#define SH_KEY_NULL _("000000000000000000000000000000000000000000000000")
65
66
67	#undef FIL__
68	#define FIL__ _("sh_hash.c")
69
70	SH_MUTEX_INIT(mutex_hash,PTHREAD_MUTEX_INITIALIZER);
71
72	static char * all_items (file_type * theFile, char * fileHash, int is_new);
73
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	};
90
91	static int report_checkflags = S_FALSE;
92	int set_report_checkflags(const char * c)
93	{
94	return sh_util_flagval(c, &report_checkflags);
95	}
96	int get_report_checkflags()
97	{
98	return report_checkflags;
99	}
100
101
102
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	}
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	**************************************************************/
125	file_type * sh_hash_create_ft (const sh_file_t * p, char * fileHash)
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;
135	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
136	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, ATTRBUF_SIZE);
137	theFile->attributes = p->theFile.attributes;
138	#endif
139
140	sl_strlcpy(theFile->fullpath, p->fullpath, PATH_MAX);
141	if (p->linkpath != NULL /* && theFile->c_mode[0] == 'l' */)
142	{
143	theFile->link_path = sh_util_strdup(p->linkpath);
144	}
145	else
146	{
147	theFile->link_path = NULL;
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;
166	theFile->check_flags = p->theFile.checkflags;
167
168	if (p->attr_string)
169	theFile->attr_string = sh_util_strdup(p->attr_string);
170	else
171	theFile->attr_string = NULL;
172
173	SL_RETURN((theFile), _("sh_hash_create_ft"));
174	}
175
176	struct two_sh_file_t {
177	sh_file_t * prev;
178	sh_file_t * this;
179	};
180
181	static sh_file_t * hashsearch (const char * s);
182	static int hashsearch_prev (const char * s, struct two_sh_file_t * a, int * index);
183
184
185	/**************************************************************
186	*
187	* >>>> The internal database <<<
188	*
189	**************************************************************/
190
191	static sh_file_t * tab[TABSIZE];
192
193	sh_file_t ** get_default_data_table()
194	{
195	return tab;
196	}
197
198	/**************************************************************
199	*
200	* compute hash function
201	*
202	**************************************************************/
203
204	static int hashfunc(const char *s)
205	{
206	unsigned int n = 0;
207
208	for ( ; *s; s++)
209	n = 31 * n + *s;
210
211	return n & (TABSIZE - 1); /* % TABSIZE */;
212	}
213
214
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;
222	char hashbuf[KEYBUF_SIZE];
223	volatile int retval;
224
225	/* -------- find the entry for the file ---------------- */
226
227	SH_MUTEX_LOCK(mutex_hash);
228
229	retval = 0;
230
231	if (sl_strlen(fullpath) <= MAX_PATH_STORE)
232	p = hashsearch(fullpath);
233	else
234	p = hashsearch( sh_tiger_hash(fullpath,
235	TIGER_DATA,
236	sl_strlen(fullpath),
237	hashbuf, sizeof(hashbuf))
238	);
239	if (p == NULL)
240	{
241	retval = -1;
242	goto unlock_and_return;
243	}
244
245	theFile = sh_hash_create_ft (p, fileHash);
246	str = all_items(theFile, fileHash, 0);
247	tmp = sh_util_safe_name(fullpath);
248
249	SH_MUTEX_LOCK(mutex_thread_nolog);
250	if (!sh_global_check_silent)
251	sh_error_handle (level, FIL__, __LINE__, 0,
252	MSG_FI_MISS2, tmp, str);
253	SH_MUTEX_UNLOCK(mutex_thread_nolog);
254	++sh.statistics.files_report;
255
256	SH_FREE(tmp);
257	SH_FREE(str);
258	if (theFile->attr_string) SH_FREE(theFile->attr_string);
259	if (theFile->link_path) SH_FREE(theFile->link_path);
260	SH_FREE(theFile);
261
262	unlock_and_return:
263	; /* 'label at end of compound statement */
264	SH_MUTEX_UNLOCK(mutex_hash);
265
266	/* remove here to avoid second message from hash_unvisited */
267	if (retval == 0)
268	sh_hash_remove (fullpath);
269
270	return retval;
271	}
272
273
274	/**************************************************************
275	*
276	* search for files not visited, and check whether they exist
277	*
278	**************************************************************/
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	{
288	SH_FREE(p->linkpath);
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
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
321	/* Not a fully qualified path, i.e. some info stored by some module
322	*/
323	if (p->fullpath[0] != '/')
324	{
325	SL_RET0(_("hash_unvisited"));
326	}
327
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
332	*
333	* Files/directories under IgnoreAll are noticed as missing already
334	* during the file check.
335	*/
336	if (((!SH_FFLAG_VISITED_SET(p->fflags)) \|\| SH_FFLAG_CHECKED_SET(p->fflags))
337	&& (!SH_FFLAG_REPORTED_SET(p->fflags))
338	/* && (!SH_FFLAG_ALLIGNORE_SET(p->fflags)) */)
339	{
340	i = retry_lstat(FIL__, __LINE__, p->fullpath, &buf);
341
342	/* if file does not exist
343	*/
344	if (0 != i)
345	{
346	ptr = sh_util_dirname (p->fullpath);
347	if (ptr)
348	{
349	/* If any of the parent directories is under IgnoreAll
350	*/
351	if ((0 != sh_files_is_allignore(ptr)) \|\| SH_FFLAG_ALLIGNORE_SET(p->fflags))
352	level = ShDFLevel[SH_LEVEL_ALLIGNORE];
353	SH_FREE(ptr);
354	}
355
356	/* Only report if !SH_FFLAG_CHECKED_SET
357	*/
358	if (!SH_FFLAG_CHECKED_SET(p->fflags))
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);
366	if (!sh_global_check_silent)
367	sh_error_handle (level, FIL__, __LINE__, 0,
368	MSG_FI_MISS2, tmp, str);
369	++sh.statistics.files_report;
370	SH_FREE(str);
371	if (theFile->attr_string) SH_FREE(theFile->attr_string);
372	if (theFile->link_path) SH_FREE(theFile->link_path);
373	SH_FREE(theFile);
374
375	SH_FREE(tmp);
376	}
377	}
378
379	/* We rewrite the db on update, thus we need to keep this
380	* if the user does not want to purge it from the db.
381	*/
382
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)))
385	{
386	/* Remove the old entry
387	*/
388	if (prev == p)
389	tab[j] = p->next;
390	else
391	prev->next = p->next;
392
393	delete_db_entry(p);
394
395	SL_RET0(_("hash_unvisited"));
396	}
397	}
398	}
399
400	else if (SH_FFLAG_VISITED_SET(p->fflags) && SH_FFLAG_REPORTED_SET(p->fflags)
401	&& (!SH_FFLAG_ALLIGNORE_SET(p->fflags)))
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);
409	if (!sh_global_check_silent)
410	sh_error_handle (level, FIL__, __LINE__, 0,
411	MSG_FI_MISS2, tmp, str);
412	++sh.statistics.files_report;
413	SH_FREE(str);
414	if (theFile->attr_string)
415	SH_FREE(theFile->attr_string);
416	SH_FREE(theFile);
417
418	SH_FREE(tmp);
419	}
420
421	CLEAR_SH_FFLAG_REPORTED(p->fflags);
422	}
423
424	if (sh.flag.reportonce == S_FALSE)
425	CLEAR_SH_FFLAG_REPORTED(p->fflags);
426
427	CLEAR_SH_FFLAG_VISITED(p->fflags);
428	CLEAR_SH_FFLAG_CHECKED(p->fflags);
429	SET_SH_FFLAG_ENOENT(p->fflags);
430
431	SL_RET0(_("hash_unvisited"));
432	}
433
434
435
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"));
446
447	SH_MUTEX_LOCK(mutex_hash);
448	for (i = 0; i < TABSIZE; ++i)
449	{
450	if (tab[i] != NULL)
451	hash_unvisited (i, tab[i], tab[i], level);
452	}
453	SH_MUTEX_UNLOCK(mutex_hash);
454
455	SL_RET0(_("hash_unvisited"));
456	}
457
458	/*********************************************************************
459	*
460	* Remove a single file from the database.
461	*
462	*********************************************************************/
463	void sh_hash_remove_unconditional (const char * path)
464	{
465	struct two_sh_file_t entries;
466	int index;
467
468	SL_ENTER(_("sh_hash_remove_unconditional"));
469
470	SH_MUTEX_LOCK(mutex_hash);
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);
485
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
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	{
496	sh_hash_remove_unconditional (path);
497	}
498	SL_RET0(_("sh_hash_remove"));
499	}
500
501
502	/*********************************************************************
503	*
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;
513
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
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	{
594	SH_FREE(p->linkpath);
595	p->linkpath = NULL;
596	}
597	if (p->attr_string)
598	{
599	SH_FREE(p->attr_string);
600	p->attr_string = NULL;
601	}
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	***********************************************************************/
613	static sh_file_t * hashsearch (const char * s)
614	{
615	sh_file_t * p;
616
617	SL_ENTER(_("hashsearch"));
618
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	}
625	SL_RETURN( NULL, _("hashsearch"));
626	}
627
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;
632
633	SL_ENTER(_("hashsearch_prev"));
634
635	if (s)
636	{
637	*index = hashfunc(s);
638	this = tab[*index];
639	prev = this;
640
641	if (this)
642	{
643	do {
644	if ((this->fullpath != NULL) && (0 == strcmp(s, this->fullpath)))
645	{
646	a->prev = prev;
647	a->this = this;
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
659	/***********************************************************************
660	*
661	* insert into hash array
662	*
663	***********************************************************************/
664	void hashinsert (sh_file_t * mtab[TABSIZE], sh_file_t * s)
665	{
666	sh_file_t * p;
667	sh_file_t * q;
668	int key;
669
670	SL_ENTER(_("hashinsert"));
671
672	key = hashfunc(s->fullpath);
673
674	if (mtab[key] == NULL)
675	{
676	mtab[key] = s;
677	mtab[key]->next = NULL;
678	SL_RET0(_("hashinsert"));
679	}
680	else
681	{
682	p = mtab[key];
683	while (1)
684	{
685	if (p && p->fullpath && 0 == strcmp(s->fullpath, p->fullpath))
686	{
687	q = p->next;
688	SH_FREE(p->fullpath);
689	if(p->linkpath) SH_FREE(p->linkpath);
690	if(p->attr_string) SH_FREE(p->attr_string);
691	memcpy(p, s, sizeof(sh_file_t));
692	p->next = q;
693	SH_FREE(s); s = NULL;
694	SL_RET0(_("hashinsert"));
695	}
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;
706	}
707	}
708	/* notreached */
709	}
710
711
712
713	/******************************************************************
714	*
715	* ------- Check functions -------
716	*
717	******************************************************************/
718
719	static int IsInit = 0;
720
721	void sh_hash_set_initialized()
722	{
723	IsInit = 1;
724	return;
725	}
726
727	int sh_hash_get_initialized()
728	{
729	return IsInit;
730	}
731
732
733	/******************************************************************
734	*
735	* Initialize
736	*
737	******************************************************************/
738	void sh_hash_init ()
739	{
740	volatile int retval = 0;
741	volatile int exitval = EXIT_SUCCESS;
742
743	SL_ENTER(_("sh_hash_init"));
744
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
753	SH_MUTEX_LOCK(mutex_hash);
754
755	if (IsInit == 1)
756	{
757	goto unlock_and_return;
758	}
759
760	/* Initialization completed.
761	*/
762	retval = sh_dbIO_load_db(tab);
763
764	if (0 == retval)
765	IsInit = 1;
766	else
767	exitval = EXIT_FAILURE;
768
769	unlock_and_return:
770	; /* 'label at end of compound statement */
771	SH_MUTEX_UNLOCK(mutex_hash);
772	if (retval == 0)
773	{
774	SL_RET0(_("sh_hash_init"));
775	}
776	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
777	aud_exit (FIL__, __LINE__, exitval);
778	}
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	}
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
813	/* need deadlock detection here if called from exit handler
814	*/
815	SH_MUTEX_TRYLOCK(mutex_hash);
816
817	if (IsInit == 0)
818	goto unlock_and_exit;
819
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;
827
828	unlock_and_exit:
829	; /* 'label at end of compound statement */
830	SH_MUTEX_TRYLOCK_UNLOCK(mutex_hash);
831
832	SL_RET0(_("sh_hash_hashdelete"));
833	}
834
835	static int sh_loosedircheck = S_FALSE;
836
837	int sh_hash_loosedircheck(const char * str)
838	{
839	return sh_util_flagval(str, &sh_loosedircheck);
840	}
841
842
843
844
845	/*********************************************************************
846	*
847	* Check whether a file is present in the database.
848	*
849	*********************************************************************/
850	static sh_file_t * sh_hash_have_it_int (const char * newname)
851	{
852	sh_file_t * p;
853	char hashbuf[KEYBUF_SIZE];
854
855	SL_ENTER(_("sh_hash_have_it_int"));
856
857	if (newname == NULL)
858	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
859
860	if (sl_strlen(newname) <= MAX_PATH_STORE)
861	p = hashsearch(newname);
862	else
863	p = hashsearch ( sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
864	hashbuf, sizeof(hashbuf)) );
865	if (p == NULL)
866	SL_RETURN( (NULL), _("sh_hash_have_it_int"));
867
868	SL_RETURN( (p), _("sh_hash_have_it_int"));
869	}
870
871	int sh_hash_have_it (const char * newname)
872	{
873	sh_file_t * p;
874	int retval;
875
876	if (IsInit != 1)
877	sh_hash_init();
878
879	SH_MUTEX_LOCK(mutex_hash);
880
881	retval = 0;
882
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;
894	}
895
896	int sh_hash_get_it (const char * newname, file_type * tmpFile, char * fileHash)
897	{
898	sh_file_t * p;
899	int retval;
900
901	if (IsInit != 1)
902	sh_hash_init();
903
904	tmpFile->link_path = NULL;
905	tmpFile->attr_string = NULL;
906
907	SH_MUTEX_LOCK(mutex_hash);
908
909	retval = (-1);
910
911	p = sh_hash_have_it_int (newname);
912	if (p)
913	{
914	sl_strlcpy(tmpFile->fullpath, p->fullpath, PATH_MAX);
915	if (p->linkpath)
916	tmpFile->link_path = sh_util_strdup (p->linkpath);
917	tmpFile->size = p->theFile.size;
918	tmpFile->mtime = p->theFile.mtime;
919	tmpFile->ctime = p->theFile.ctime;
920	tmpFile->atime = p->theFile.atime;
921
922	if (NULL != fileHash)
923	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
924
925	tmpFile->attr_string = NULL;
926	retval = 0;
927	}
928	SH_MUTEX_UNLOCK(mutex_hash);
929
930	return retval;
931	}
932
933	int sh_hash_getflags (char * filename)
934	{
935	sh_file_t * p;
936	int retval = 0;
937
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	}
951	return retval;
952	}
953
954	int sh_hash_setflags (char * filename, int flags)
955	{
956	sh_file_t * p;
957	int retval = 0;
958
959	if ( sh.flag.checkSum != SH_CHECK_INIT )
960	{
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);
974	}
975	return retval;
976	}
977
978	/* needs lock to be threadsafe
979	*/
980	void sh_hash_set_flag (char * filename, int flag_to_set)
981	{
982	sh_file_t * p;
983
984	if ( sh.flag.checkSum != SH_CHECK_INIT )
985	{
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);
996	}
997	return;
998	}
999
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
1006	if ( sh.flag.checkSum != SH_CHECK_INIT )
1007	{
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);
1018	}
1019	return;
1020	}
1021
1022
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;
1033	char hashbuf[KEYBUF_SIZE];
1034	int retval;
1035
1036	SL_ENTER(_("sh_hash_set_visited_int"));
1037
1038	if (newname == NULL)
1039	SL_RETURN((-1), _("sh_hash_set_visited_int"));
1040
1041	if (IsInit != 1)
1042	sh_hash_init();
1043
1044	SH_MUTEX_LOCK(mutex_hash);
1045
1046	if (sl_strlen(newname) <= MAX_PATH_STORE)
1047	p = hashsearch(newname);
1048	else
1049	p = hashsearch (sh_tiger_hash(newname, TIGER_DATA, sl_strlen(newname),
1050	hashbuf, sizeof(hashbuf)));
1051
1052	if (p)
1053	{
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	}
1060	else
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;
1070	}
1071	else
1072	retval = -1;
1073
1074	SH_MUTEX_UNLOCK(mutex_hash);
1075	SL_RETURN((retval), _("sh_hash_set_visited_int"));
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;
1084	SL_ENTER(_("sh_hash_set_missing"));
1085
1086	i = sh_hash_set_visited_int(newname, SH_FFLAG_CHECKED);
1087
1088	if (sh.flag.checkSum != SH_CHECK_INIT) {
1089	sh_hash_remove(newname);
1090	}
1091
1092	SL_RETURN(i, _("sh_hash_set_missing"));
1093	}
1094
1095	/* mark the file as visited and reported
1096	*/
1097	int sh_hash_set_visited (char * newname)
1098	{
1099	int i;
1100	SL_ENTER(_("sh_hash_set_visited"));
1101	i = sh_hash_set_visited_int(newname, SH_FFLAG_REPORTED);
1102	SL_RETURN(i, _("sh_hash_set_visited"));
1103	}
1104
1105	/* mark the file as visited and NOT reported
1106	* used to avoid deletion of file from internal database
1107	*/
1108	int sh_hash_set_visited_true (char * newname)
1109	{
1110	int i;
1111	SL_ENTER(_("sh_hash_set_visited_true"));
1112	i = sh_hash_set_visited_int(newname, 0);
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
1123	void sh_hash_push2db (const char * key, struct store2db * save)
1124	{
1125	int i = 0;
1126	char * p;
1127	char i2h[2];
1128	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
1129
1130	int size = save->size;
1131	unsigned char * str = save->str;
1132
1133
1134	tmpFile->attr_string = NULL;
1135	tmpFile->link_path = NULL;
1136
1137	sl_strlcpy(tmpFile->fullpath, key, PATH_MAX);
1138	tmpFile->size = save->val0;
1139	tmpFile->mtime = save->val1;
1140	tmpFile->ctime = save->val2;
1141	tmpFile->atime = save->val3;
1142
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);
1148
1149	tmpFile->check_flags = 0;
1150
1151	if ((str != NULL) && (size < (PATH_MAX/2)-1))
1152	{
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);
1160	for (i = 0; i < size; ++i)
1161	{
1162	p = sh_util_charhex (str[i],i2h);
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';
1166	}
1167	}
1168	else
1169	{
1170	for (i = 0; i < 10; ++i)
1171	tmpFile->c_mode[i] = '-';
1172	tmpFile->c_mode[10] = '\0';
1173	tmpFile->link_path = sh_util_strdup("-");
1174	}
1175
1176	if (sh.flag.checkSum == SH_CHECK_INIT)
1177	sh_dbIO_data_write (tmpFile,
1178	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
1179	else
1180	sh_hash_pushdata_memory (tmpFile,
1181	(save->checksum[0] == '\0') ? SH_KEY_NULL : save->checksum);
1182
1183	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
1184	SH_FREE(tmpFile);
1185	return;
1186	}
1187
1188	extern int sh_util_hextobinary (char * binary, char * hex, int bytes);
1189
1190	char * sh_hash_db2pop (const char * key, struct store2db * save)
1191	{
1192	size_t len;
1193	char * p;
1194	int i;
1195	char * retval = NULL;
1196	char fileHash[KEY_LEN+1];
1197	file_type * tmpFile = SH_ALLOC(sizeof(file_type));
1198
1199	save->size = 0;
1200
1201	if (0 == sh_hash_get_it (key, tmpFile, fileHash))
1202	{
1203	save->val0 = tmpFile->size;
1204	save->val1 = tmpFile->mtime;
1205	save->val2 = tmpFile->ctime;
1206	save->val3 = tmpFile->atime;
1207
1208	sl_strlcpy(save->checksum, fileHash, KEY_LEN+1);
1209
1210	if (tmpFile->link_path && tmpFile->link_path[0] != '-')
1211	{
1212	len = strlen(tmpFile->link_path);
1213
1214	p = SH_ALLOC((len/2)+1);
1215	i = sh_util_hextobinary (p, tmpFile->link_path, len);
1216
1217	if (i == 0)
1218	{
1219	save->size = (len/2);
1220	p[save->size] = '\0';
1221	retval = p;
1222	}
1223	else
1224	{
1225	SH_FREE(p);
1226	save->size = 0;
1227	}
1228	}
1229	else
1230	{
1231	save->size = 0;
1232	}
1233	}
1234	else
1235	{
1236	save->size = -1;
1237	save->val0 = 0;
1238	save->val1 = 0;
1239	save->val2 = 0;
1240	save->val3 = 0;
1241	}
1242	if (tmpFile->link_path) SH_FREE(tmpFile->link_path);
1243	SH_FREE(tmpFile);
1244	return retval;
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;
1259
1260	size_t len;
1261	char * fullpath;
1262	char * linkpath;
1263	char * attr_string = NULL;
1264	char hashbuf[KEYBUF_SIZE];
1265
1266	SL_ENTER(_("sh_hash_push_int"));
1267
1268	fp = SH_ALLOC(sizeof(sh_file_t));
1269
1270	p.mark = REC_MAGIC;
1271	if (buf->attr_string)
1272	p.mark \|= REC_FLAGS_ATTR;
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);
1277	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
1278	sl_strlcpy(p.c_attributes, buf->c_attributes, 13);
1279	#endif
1280
1281	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
1282	p.attributes = (UINT32) buf->attributes;
1283	#endif
1284	p.linkmode = (UINT32) buf->linkmode;
1285	p.hardlinks = (UINT32) buf->hardlinks;
1286	p.dev = (UINT64) buf->dev;
1287	p.rdev = (UINT64) buf->rdev;
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
1297	p.checkflags = (UINT32) buf->check_flags;
1298
1299	memcpy( &(*fp).theFile, &p, sizeof(sh_filestore_t) );
1300	fp->fflags = 0; /* init fflags */
1301	fp->modi_mask = 0L;
1302
1303	if (buf->attr_string)
1304	attr_string = sh_util_strdup(buf->attr_string);
1305	fp->attr_string = attr_string;
1306
1307	len = sl_strlen(buf->fullpath);
1308	if (len <= MAX_PATH_STORE)
1309	{
1310	fullpath = SH_ALLOC(len+1);
1311	sl_strlcpy(fullpath, buf->fullpath, len+1);
1312	}
1313	else
1314	{
1315	fullpath = SH_ALLOC(KEY_LEN + 1);
1316	sl_strlcpy(fullpath,
1317	sh_tiger_hash (buf->fullpath, TIGER_DATA, len,
1318	hashbuf, sizeof(hashbuf)),
1319	KEY_LEN+1);
1320	}
1321	fp->fullpath = fullpath;
1322
1323	if (buf->link_path)
1324	{
1325	len = sl_strlen(buf->link_path);
1326	if (len <= MAX_PATH_STORE)
1327	{
1328	linkpath = SH_ALLOC(len+1);
1329	sl_strlcpy(linkpath, buf->link_path, len+1);
1330	}
1331	else
1332	{
1333	linkpath = SH_ALLOC(KEY_LEN + 1);
1334	sl_strlcpy(linkpath,
1335	sh_tiger_hash (buf->link_path, TIGER_DATA, len,
1336	hashbuf, sizeof(hashbuf)),
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
1355	#ifndef PRIu64
1356	#ifdef HAVE_LONG_32
1357	#define PRIu64 "llu"
1358	#else
1359	#define PRIu64 "lu"
1360	#endif
1361	#endif
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"),
1372	_("size_old=\"%"), PRIu64, _("\" size_new=\"%"), PRIu64, "\" ");
1373	#else
1374	sl_snprintf(form_rval, 80, _("%s%s%s%s%s"),
1375	_("size_old=<%"), PRIu64, _(">, size_new=<%"), PRIu64, ">, ");
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
1392	char * tmp = SH_ALLOC(SH_MSG_BUF);
1393	char * msg = SH_ALLOC(SH_MSG_BUF);
1394
1395	tmp[0] = '\0';
1396	msg[0] = '\0';
1397
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	}
1408
1409	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
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\" ");
1414	sl_snprintf(tmp, SH_MSG_BUF, format,
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
1426	sl_snprintf(tmp, SH_MSG_BUF, format,
1427	theFile->c_mode,
1428	(long) theFile->mode
1429	);
1430	#endif
1431	sl_strlcat(msg, tmp, SH_MSG_BUF);
1432
1433	if (is_new)
1434	format = _("hardlinks_new=\"%lu\" ");
1435	else
1436	format = _("hardlinks_old=\"%lu\" ");
1437	sl_snprintf(tmp, SH_MSG_BUF, format,
1438	(unsigned long) theFile->hardlinks);
1439	sl_strlcat(msg, tmp, SH_MSG_BUF);
1440
1441
1442	if (is_new)
1443	format = _("idevice_new=\"%lu\" ");
1444	else
1445	format = _("idevice_old=\"%lu\" ");
1446	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
1447	sl_strlcat(msg, tmp, SH_MSG_BUF);
1448
1449
1450	if (is_new)
1451	format = _("inode_new=\"%lu\" ");
1452	else
1453	format = _("inode_old=\"%lu\" ");
1454	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
1455	sl_strlcat(msg, tmp, SH_MSG_BUF);
1456
1457	/*
1458	* also report device for prelude
1459	*/
1460	#if defined(HAVE_LIBPRELUDE)
1461	if (is_new)
1462	format = _("dev_new=\"%lu,%lu\" ");
1463	else
1464	format = _("dev_old=\"%lu,%lu\" ");
1465	sl_snprintf(tmp, SH_MSG_BUF, format,
1466	(unsigned long) major(theFile->dev),
1467	(unsigned long) minor(theFile->dev));
1468	sl_strlcat(msg, tmp, SH_MSG_BUF);
1469	#endif
1470
1471
1472	if (is_new)
1473	format = _("owner_new=\"%s\" iowner_new=\"%ld\" ");
1474	else
1475	format = _("owner_old=\"%s\" iowner_old=\"%ld\" ");
1476	sl_snprintf(tmp, SH_MSG_BUF, format,
1477	theFile->c_owner, (long) theFile->owner);
1478	sl_strlcat(msg, tmp, SH_MSG_BUF);
1479
1480
1481	if (is_new)
1482	format = _("group_new=\"%s\" igroup_new=\"%ld\" ");
1483	else
1484	format = _("group_old=\"%s\" igroup_old=\"%ld\" ");
1485	sl_snprintf(tmp, SH_MSG_BUF, format,
1486	theFile->c_group, (long) theFile->group);
1487	sl_strlcat(msg, tmp, SH_MSG_BUF);
1488
1489
1490	if (is_new)
1491	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
1492	(UINT64) 0, (UINT64) theFile->size);
1493	else
1494	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
1495	(UINT64) theFile->size, (UINT64) 0);
1496	sl_strlcat(msg, tmp, SH_MSG_BUF);
1497
1498
1499	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
1500	if (is_new)
1501	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=\"%s\" "), timstr1c);
1502	else
1503	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" "), timstr1c);
1504	sl_strlcat(msg, tmp, SH_MSG_BUF);
1505
1506	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
1507	if (is_new)
1508	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=\"%s\" "), timstr1a);
1509	else
1510	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" "), timstr1a);
1511	sl_strlcat(msg, tmp, SH_MSG_BUF);
1512
1513	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
1514	if (is_new)
1515	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=\"%s\" "), timstr1m);
1516	else
1517	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" "), timstr1m);
1518	sl_strlcat(msg, tmp, SH_MSG_BUF);
1519
1520	if (is_new)
1521	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=\"%s\" "), fileHash);
1522	else
1523	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=\"%s\" "), fileHash);
1524	sl_strlcat(msg, tmp, SH_MSG_BUF);
1525
1526	if (theFile->c_mode[0] == 'l' \|\|
1527	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
1528	{
1529	tmp_lnk = sh_util_safe_name(theFile->link_path);
1530	if (tmp_lnk)
1531	{
1532	if (is_new)
1533	sl_snprintf(tmp, SH_MSG_BUF, _("link_new=\"%s\" "), tmp_lnk);
1534	else
1535	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" "), tmp_lnk);
1536	SH_FREE(tmp_lnk);
1537	sl_strlcat(msg, tmp, SH_MSG_BUF);
1538	}
1539	}
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)
1547	sl_snprintf(tmp, SH_MSG_BUF, _("acl_new=\"%s\" "), tmp_lnk);
1548	else
1549	sl_snprintf(tmp, SH_MSG_BUF, _("acl_old=\"%s\" "), tmp_lnk);
1550	SH_FREE(tmp_lnk);
1551	sl_strlcat(msg, tmp, SH_MSG_BUF);
1552	}
1553	}
1554
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
1569	char * tmp = SH_ALLOC(SH_MSG_BUF);
1570	char * msg = SH_ALLOC(SH_MSG_BUF);
1571
1572	tmp[0] = '\0';
1573	msg[0] = '\0';
1574
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	}
1585
1586
1587	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
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>, ");
1592	sl_snprintf(tmp, SH_MSG_BUF, format,
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
1604	sl_snprintf(tmp, SH_MSG_BUF, format,
1605	theFile->c_mode,
1606	(long) theFile->mode
1607	);
1608	#endif
1609	sl_strlcat(msg, tmp, SH_MSG_BUF);
1610
1611	if (is_new)
1612	format = _("hardlinks_new=<%lu>, ");
1613	else
1614	format = _("hardlinks_old=<%lu>, ");
1615	sl_snprintf(tmp, SH_MSG_BUF, format,
1616	(unsigned long) theFile->hardlinks);
1617	sl_strlcat(msg, tmp, SH_MSG_BUF);
1618
1619
1620	if (is_new)
1621	format = _("idevice_new=<%lu>, ");
1622	else
1623	format = _("idevice_old=<%lu>, ");
1624	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->rdev);
1625	sl_strlcat(msg, tmp, SH_MSG_BUF);
1626
1627
1628	if (is_new)
1629	format = _("inode_new=<%lu>, ");
1630	else
1631	format = _("inode_old=<%lu>, ");
1632	sl_snprintf(tmp, SH_MSG_BUF, format, (unsigned long) theFile->ino);
1633	sl_strlcat(msg, tmp, SH_MSG_BUF);
1634
1635
1636	/*
1637	* also report device for prelude
1638	*/
1639	#if defined(HAVE_LIBPRELUDE)
1640	if (is_new)
1641	format = _("dev_new=<%lu,%lu>, ");
1642	else
1643	format = _("dev_old=<%lu,%lu>, ");
1644	sl_snprintf(tmp, SH_MSG_BUF, format,
1645	(unsigned long) major(theFile->dev),
1646	(unsigned long) minor(theFile->dev));
1647	sl_strlcat(msg, tmp, SH_MSG_BUF);
1648	#endif
1649
1650	if (is_new)
1651	format = _("owner_new=<%s>, iowner_new=<%ld>, ");
1652	else
1653	format = _("owner_old=<%s>, iowner_old=<%ld>, ");
1654	sl_snprintf(tmp, SH_MSG_BUF, format,
1655	theFile->c_owner, (long) theFile->owner);
1656	sl_strlcat(msg, tmp, SH_MSG_BUF);
1657
1658
1659	if (is_new)
1660	format = _("group_new=<%s>, igroup_new=<%ld>, ");
1661	else
1662	format = _("group_old=<%s>, igroup_old=<%ld>, ");
1663	sl_snprintf(tmp, SH_MSG_BUF, format,
1664	theFile->c_group, (long) theFile->group);
1665	sl_strlcat(msg, tmp, SH_MSG_BUF);
1666
1667
1668	if (is_new)
1669	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
1670	(UINT64) 0, (UINT64) theFile->size);
1671	else
1672	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
1673	(UINT64) theFile->size, (UINT64) 0);
1674	sl_strlcat(msg, tmp, SH_MSG_BUF);
1675
1676
1677	(void) sh_unix_gmttime (theFile->ctime, timstr1c, sizeof(timstr1c));
1678	if (is_new)
1679	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_new=<%s>, "), timstr1c);
1680	else
1681	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, "), timstr1c);
1682	sl_strlcat(msg, tmp, SH_MSG_BUF);
1683
1684	(void) sh_unix_gmttime (theFile->atime, timstr1a, sizeof(timstr1a));
1685	if (is_new)
1686	sl_snprintf(tmp, SH_MSG_BUF, _("atime_new=<%s>, "), timstr1a);
1687	else
1688	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, "), timstr1a);
1689	sl_strlcat(msg, tmp, SH_MSG_BUF);
1690
1691	(void) sh_unix_gmttime (theFile->mtime, timstr1m, sizeof(timstr1m));
1692	if (is_new)
1693	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_new=<%s>, "), timstr1m);
1694	else
1695	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, "), timstr1m);
1696	sl_strlcat(msg, tmp, SH_MSG_BUF);
1697
1698	if (is_new)
1699	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_new=<%s>"), fileHash);
1700	else
1701	sl_snprintf(tmp, SH_MSG_BUF, _("chksum_old=<%s>"), fileHash);
1702	sl_strlcat(msg, tmp, SH_MSG_BUF);
1703
1704	if (theFile->c_mode[0] == 'l' \|\|
1705	(theFile->link_path != NULL && theFile->link_path[0] != '-'))
1706	{
1707	tmp_lnk = sh_util_safe_name(theFile->link_path);
1708	if (tmp_lnk)
1709	{
1710	if (is_new)
1711	sl_snprintf(tmp, SH_MSG_BUF, _(", link_new=<%s> "), tmp_lnk);
1712	else
1713	sl_snprintf(tmp, SH_MSG_BUF, _(", link_old=<%s> "), tmp_lnk);
1714	SH_FREE(tmp_lnk);
1715	sl_strlcat(msg, tmp, SH_MSG_BUF);
1716	}
1717	}
1718
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)
1725	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_new=<%s> "), tmp_lnk);
1726	else
1727	sl_snprintf(tmp, SH_MSG_BUF, _(", acl_old=<%s> "), tmp_lnk);
1728	SH_FREE(tmp_lnk);
1729	sl_strlcat(msg, tmp, SH_MSG_BUF);
1730	}
1731	}
1732
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	{
1747	SH_MUTEX_LOCK(mutex_hash);
1748	hashinsert (tab, p);
1749	p->modi_mask = theFile->check_flags;
1750	SH_MUTEX_UNLOCK(mutex_hash);
1751	}
1752
1753	SL_RET0(_("sh_hash_pushdata_memory"));
1754	}
1755
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	}
1765
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
1817	if (!sh_global_check_silent)
1818	sh_error_handle (log_severity, FIL__, __LINE__, 0,
1819	MSG_FI_ADD2,
1820	tmp, str);
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
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];
1880	char * linkComp;
1881	int maxcomp;
1882
1883	char change_code[16];
1884	int i;
1885
1886	unsigned long modi_mask;
1887
1888	char log_policy[32];
1889	volatile int log_severity;
1890	char hashbuf[KEYBUF_SIZE];
1891	struct {
1892	unsigned long oldflags;
1893	unsigned long newflags;
1894	} cf_report;
1895
1896	int retval;
1897
1898	SL_ENTER(_("sh_hash_compdata"));
1899
1900	if (IsInit != 1) sh_hash_init();
1901
1902	if (severity_override < 0)
1903	log_severity = ShDFLevel[class];
1904	else
1905	log_severity = severity_override;
1906
1907	if (policy_override != NULL)
1908	sl_strlcpy (log_policy, policy_override, 32);
1909
1910	/* -------- find the entry for the file ---------------- */
1911
1912	SH_MUTEX_LOCK(mutex_hash);
1913
1914	modi_mask = 0;
1915	retval = 0;
1916
1917	if (sl_strlen(theFile->fullpath) <= MAX_PATH_STORE)
1918	p = hashsearch(theFile->fullpath);
1919	else
1920	p = hashsearch( sh_tiger_hash(theFile->fullpath,
1921	TIGER_DATA,
1922	sl_strlen(theFile->fullpath),
1923	hashbuf, sizeof(hashbuf))
1924	);
1925
1926
1927	/* --------- Not found in database. ------------
1928	*/
1929
1930	if (p == NULL)
1931	{
1932	retval = handle_notfound(log_severity, class, theFile, fileHash);
1933	goto unlock_and_return;
1934	}
1935
1936	/* --------- Skip if we don't want to report changes. ------------
1937	*/
1938
1939	if (S_TRUE == sh_ignore_chk_mod(theFile->fullpath))
1940	{
1941	MODI_SET(theFile->check_flags, MODI_NOCHECK);
1942	p->modi_mask = theFile->check_flags;
1943	p->theFile.checkflags = p->modi_mask;
1944	goto unlock_and_return;
1945	}
1946
1947	cf_report.oldflags = p->theFile.checkflags;
1948	cf_report.newflags = theFile->check_flags;
1949
1950	p->modi_mask = theFile->check_flags;
1951	p->theFile.checkflags = p->modi_mask;
1952
1953	/* initialize change_code */
1954	for (i = 0; i < 15; ++i)
1955	change_code[i] = '-';
1956	change_code[15] = '\0';
1957
1958	TPT ((0, FIL__, __LINE__, _("file=<%s>, cs_old=<%s>, cs_new=<%s>\n"),
1959	theFile->fullpath, fileHash, p->theFile.checksum));
1960
1961	if ( (fileHash != NULL) &&
1962	(strncmp (fileHash, p->theFile.checksum, KEY_LEN) != 0) &&
1963	(theFile->check_flags & MODI_CHK) != 0)
1964	{
1965	if ((theFile->check_flags & MODI_SGROW) == 0)
1966	{
1967	modi_mask \|= MODI_CHK;
1968	change_code[0] = 'C';
1969	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
1970	}
1971	else
1972	{
1973	if (0 != strncmp (&fileHash[KEY_LEN + 1], p->theFile.checksum, KEY_LEN))
1974	{
1975	if (S_FALSE == sh_check_rotated_log (theFile->fullpath, (UINT64) p->theFile.size,
1976	(UINT64) p->theFile.ino, p->theFile.checksum,
1977	p->theFile.checkflags))
1978	{
1979	modi_mask \|= MODI_CHK;
1980	change_code[0] = 'C';
1981	TPT ((0, FIL__, __LINE__, _("mod=<checksum>")));
1982	}
1983	else
1984	{
1985	/* logfile has been rotated */
1986	p->theFile.size = theFile->size;
1987	p->theFile.ino = theFile->ino;
1988	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
1989	}
1990	}
1991	else
1992	{
1993	p->theFile.size = theFile->size;
1994	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
1995	}
1996	}
1997	}
1998
1999	if (p->theFile.c_mode[0] == 'l')
2000	{
2001	if (!(theFile->link_path) &&
2002	(theFile->check_flags & MODI_LNK) != 0)
2003	{
2004	linkComp = NULL;
2005	modi_mask \|= MODI_LNK;
2006	change_code[1] = 'L';
2007	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
2008	}
2009	else
2010	{
2011	if (sl_strlen(theFile->link_path) >= MAX_PATH_STORE)
2012	{
2013	sl_strlcpy(linkHash,
2014	sh_tiger_hash(theFile->link_path,
2015	TIGER_DATA,
2016	sl_strlen(theFile->link_path),
2017	hashbuf, sizeof(hashbuf)),
2018	MAX_PATH_STORE+1);
2019	linkComp = linkHash;
2020	maxcomp = KEY_LEN;
2021	}
2022	else
2023	{
2024	linkComp = theFile->link_path;
2025	maxcomp = MAX_PATH_STORE;
2026	}
2027
2028	if ( sl_strncmp (linkComp, p->linkpath, maxcomp) != 0 &&
2029	(theFile->check_flags & MODI_LNK) != 0)
2030	{
2031	modi_mask \|= MODI_LNK;
2032	change_code[1] = 'L';
2033	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
2034	}
2035	}
2036	}
2037
2038	if (p->theFile.c_mode[0] == 'c' \|\| p->theFile.c_mode[0] == 'b')
2039	{
2040	if ( ( major(theFile->rdev) != major((dev_t)p->theFile.rdev) \|\|
2041	minor(theFile->rdev) != minor((dev_t)p->theFile.rdev) ) &&
2042	(theFile->check_flags & MODI_RDEV) != 0)
2043	{
2044	modi_mask \|= MODI_RDEV;
2045	change_code[2] = 'D';
2046	TPT ((0, FIL__, __LINE__, _("mod=<rdev>")));
2047	}
2048	}
2049
2050	/* cast to UINT32 in case ino_t is not 32bit
2051	*/
2052	if ( (UINT32) theFile->ino != (UINT32) p->theFile.ino &&
2053	(theFile->check_flags & MODI_INO) != 0)
2054	{
2055	modi_mask \|= MODI_INO;
2056	change_code[3] = 'I';
2057	TPT ((0, FIL__, __LINE__, _("mod=<inode>")));
2058	}
2059
2060	if ( theFile->hardlinks != (nlink_t) p->theFile.hardlinks &&
2061	(theFile->check_flags & MODI_HLN) != 0)
2062	{
2063	modi_mask \|= MODI_HLN;
2064	change_code[4] = 'H';
2065	TPT ((0, FIL__, __LINE__, _("mod=<hardlink>")));
2066	}
2067
2068
2069	if ( ( (theFile->mode != p->theFile.mode)
2070	#if defined(USE_ACL) \|\| defined(USE_XATTR)
2071	\|\| ( (sh_unix_check_selinux\|sh_unix_check_acl) &&
2072	(
2073	(theFile->attr_string == NULL && p->attr_string != NULL) \|\|
2074	(theFile->attr_string != NULL && p->attr_string == NULL) \|\|
2075	(theFile->attr_string != NULL && 0 != strcmp(theFile->attr_string, p->attr_string))
2076	)
2077	)
2078	#endif
2079	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
2080	\|\| (theFile->attributes != p->theFile.attributes)
2081	#endif
2082	)
2083	&& (theFile->check_flags & MODI_MOD) != 0)
2084	{
2085	modi_mask \|= MODI_MOD;
2086	change_code[5] = 'M';
2087	TPT ((0, FIL__, __LINE__, _("mod=<mode>")));
2088	/*
2089	* report link path if switch link/no link
2090	*/
2091	if ((theFile->check_flags & MODI_LNK) != 0 &&
2092	(theFile->c_mode[0] != p->theFile.c_mode[0]) &&
2093	(theFile->c_mode[0] == 'l' \|\| p->theFile.c_mode[0] == 'l'))
2094	{
2095	modi_mask \|= MODI_LNK;
2096	change_code[1] = 'L';
2097	TPT ((0, FIL__, __LINE__, _("mod=<link>")));
2098	}
2099	}
2100
2101	if ( theFile->owner != (uid_t) p->theFile.owner &&
2102	(theFile->check_flags & MODI_USR) != 0)
2103	{
2104	modi_mask \|= MODI_USR;
2105	change_code[6] = 'U';
2106	TPT ((0, FIL__, __LINE__, _("mod=<user>")));
2107	}
2108
2109	if ( theFile->group != (gid_t) p->theFile.group &&
2110	(theFile->check_flags & MODI_GRP) != 0)
2111	{
2112	modi_mask \|= MODI_GRP;
2113	change_code[7] = 'G';
2114	TPT ((0, FIL__, __LINE__, _("mod=<group>")));
2115	}
2116
2117
2118	if ( theFile->mtime != (time_t) p->theFile.mtime &&
2119	(theFile->check_flags & MODI_MTM) != 0)
2120	{
2121	modi_mask \|= MODI_MTM;
2122	change_code[8] = 'T';
2123	TPT ((0, FIL__, __LINE__, _("mod=<mtime>")));
2124	}
2125
2126	if ( (theFile->check_flags & MODI_ATM) != 0 &&
2127	theFile->atime != (time_t) p->theFile.atime)
2128	{
2129	modi_mask \|= MODI_ATM;
2130	change_code[8] = 'T';
2131	TPT ((0, FIL__, __LINE__, _("mod=<atime>")));
2132	}
2133
2134
2135	/* Resetting the access time will set a new ctime. Thus, either we ignore
2136	* the access time or the ctime for NOIGNORE
2137	*/
2138	if ( theFile->ctime != (time_t) p->theFile.ctime &&
2139	(theFile->check_flags & MODI_CTM) != 0)
2140	{
2141	modi_mask \|= MODI_CTM;
2142	change_code[8] = 'T';
2143	TPT ((0, FIL__, __LINE__, _("mod=<ctime>")));
2144	}
2145
2146	if ( theFile->size != (off_t) p->theFile.size &&
2147	(theFile->check_flags & MODI_SIZ) != 0)
2148	{
2149	if ((theFile->check_flags & MODI_SGROW) == 0 \|\|
2150	theFile->size < (off_t) p->theFile.size)
2151	{
2152	modi_mask \|= MODI_SIZ;
2153	change_code[9] = 'S';
2154	TPT ((0, FIL__, __LINE__, _("mod=<size>")));
2155	}
2156	}
2157	change_code[10] = '\0';
2158
2159	/* --- Directories special case ---
2160	*/
2161	if (p->theFile.c_mode[0] == 'd' &&
2162	0 == (modi_mask & ~(MODI_SIZ\|MODI_ATM\|MODI_CTM\|MODI_MTM)) &&
2163	sh_loosedircheck == S_TRUE)
2164	{
2165	modi_mask = 0;
2166	}
2167
2168	/* --- Report full details. ---
2169	*/
2170	if (modi_mask != 0 && sh.flag.fulldetail == S_TRUE)
2171	{
2172	if ((theFile->check_flags & MODI_ATM) == 0)
2173	modi_mask = MASK_READONLY_;
2174	else
2175	modi_mask = MASK_NOIGNORE_;
2176	}
2177
2178	/* --- Report on modified files. ---
2179	*/
2180	if (modi_mask != 0 && (!SH_FFLAG_REPORTED_SET(p->fflags)))
2181	{
2182	tmp = SH_ALLOC(SH_MSG_BUF);
2183	msg = SH_ALLOC(SH_MSG_BUF);
2184	msg[0] = '\0';
2185
2186	sh_files_fixup_mask(class, &(cf_report.newflags));
2187
2188	if ( (report_checkflags != S_FALSE) && (cf_report.oldflags != cf_report.newflags))
2189	{
2190	sl_snprintf(tmp, SH_MSG_BUF,
2191	#ifdef SH_USE_XML
2192	_("checkflags_old=\"0%lo\" checkflags_new=\"0%lo\" "),
2193	#else
2194	_("checkflags_old=<0%lo>, checkflags_new=<0%lo>, "),
2195	#endif
2196	cf_report.oldflags, cf_report.newflags);
2197	sl_strlcat(msg, tmp, SH_MSG_BUF);
2198	}
2199
2200	if ( ((modi_mask & MODI_MOD) != 0)
2201	#if defined(HAVE_LIBPRELUDE)
2202	\|\| ((modi_mask & MODI_USR) != 0)
2203	\|\| ((modi_mask & MODI_GRP) != 0)
2204	#endif
2205	)
2206	{
2207	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
2208	sl_snprintf(tmp, SH_MSG_BUF,
2209	#ifdef SH_USE_XML
2210	_("mode_old=\"%s\" mode_new=\"%s\" attr_old=\"%s\" attr_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" iattr_old=\"%ld\" iattr_new=\"%ld\" "),
2211	#else
2212	_("mode_old=<%s>, mode_new=<%s>, attr_old=<%s>, attr_new=<%s>, "),
2213	#endif
2214	p->theFile.c_mode, theFile->c_mode,
2215	p->theFile.c_attributes, theFile->c_attributes
2216	#ifdef SH_USE_XML
2217	, (long) p->theFile.mode, (long) theFile->mode,
2218	(long) p->theFile.attributes,
2219	(long) theFile->attributes
2220	#endif
2221	);
2222	#else
2223	#ifdef SH_USE_XML
2224	sl_snprintf(tmp, SH_MSG_BUF,
2225	_("mode_old=\"%s\" mode_new=\"%s\" imode_old=\"%ld\" imode_new=\"%ld\" "),
2226	p->theFile.c_mode, theFile->c_mode,
2227	(long) p->theFile.mode, (long) theFile->mode);
2228	#else
2229	sl_snprintf(tmp, SH_MSG_BUF, _("mode_old=<%s>, mode_new=<%s>, "),
2230	p->theFile.c_mode, theFile->c_mode);
2231	#endif
2232	#endif
2233	sl_strlcat(msg, tmp, SH_MSG_BUF);
2234
2235	#if defined(USE_ACL) \|\| defined(USE_XATTR)
2236	if (theFile->attr_string != NULL \|\| p->attr_string != NULL)
2237	{
2238	sl_snprintf(tmp, SH_MSG_BUF,
2239	#ifdef SH_USE_XML
2240	_("acl_old=\"%s\" acl_new=\"%s\" "),
2241	#else
2242	_("acl_old=<%s>, acl_new=<%s>, "),
2243	#endif
2244	(p->attr_string) ? p->attr_string : _("none"),
2245	(theFile->attr_string) ? theFile->attr_string : _("none"));
2246
2247	sl_strlcat(msg, tmp, SH_MSG_BUF);
2248	}
2249	#endif
2250
2251	if ((modi_mask & MODI_MOD) != 0)
2252	{
2253	/*
2254	* We postpone update if sh.flag.update == S_TRUE because
2255	* in interactive mode the user may not accept the change.
2256	*/
2257	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2258	{
2259	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
2260	p->theFile.mode = theFile->mode;
2261	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
2262	sl_strlcpy(p->theFile.c_attributes,theFile->c_attributes,16);
2263	p->theFile.attributes = theFile->attributes;
2264	#endif
2265	#if defined(USE_ACL) \|\| defined(USE_XATTR)
2266	if (p->attr_string == NULL && theFile->attr_string != NULL)
2267	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
2268	else if (p->attr_string != NULL && theFile->attr_string == NULL)
2269	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
2270	else if (theFile->attr_string != NULL && p->attr_string != NULL)
2271	{
2272	if (0 != strcmp(theFile->attr_string, p->attr_string))
2273	{
2274	SH_FREE(p->attr_string);
2275	p->attr_string = sh_util_strdup (theFile->attr_string);
2276	}
2277	}
2278	#endif
2279	}
2280	}
2281
2282	}
2283
2284	if ((modi_mask & MODI_HLN) != 0)
2285	{
2286	sl_snprintf(tmp, SH_MSG_BUF,
2287	#ifdef SH_USE_XML
2288	_("hardlinks_old=\"%lu\" hardlinks_new=\"%lu\" "),
2289	#else
2290	_("hardlinks_old=<%lu>, hardlinks_new=<%lu>, "),
2291	#endif
2292	(unsigned long) p->theFile.hardlinks,
2293	(unsigned long) theFile->hardlinks);
2294	sl_strlcat(msg, tmp, SH_MSG_BUF);
2295
2296	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2297	p->theFile.hardlinks = theFile->hardlinks;
2298	}
2299
2300	if ((modi_mask & MODI_RDEV) != 0)
2301	{
2302	sl_snprintf(tmp, SH_MSG_BUF,
2303	#ifdef SH_USE_XML
2304	_("device_old=\"%lu,%lu\" device_new=\"%lu,%lu\" idevice_old=\"%lu\" idevice_new=\"%lu\" "),
2305	#else
2306	_("device_old=<%lu,%lu>, device_new=<%lu,%lu>, "),
2307	#endif
2308	(unsigned long) major(p->theFile.rdev),
2309	(unsigned long) minor(p->theFile.rdev),
2310	(unsigned long) major(theFile->rdev),
2311	(unsigned long) minor(theFile->rdev)
2312	#ifdef SH_USE_XML
2313	, (unsigned long) p->theFile.rdev,
2314	(unsigned long) theFile->rdev
2315	#endif
2316	);
2317	sl_strlcat(msg, tmp, SH_MSG_BUF);
2318
2319	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2320	p->theFile.rdev = theFile->rdev;
2321	}
2322
2323	if ((modi_mask & MODI_INO) != 0)
2324	{
2325	sl_snprintf(tmp, SH_MSG_BUF,
2326	#ifdef SH_USE_XML
2327	_("inode_old=\"%lu\" inode_new=\"%lu\" "),
2328	#else
2329	_("inode_old=<%lu>, inode_new=<%lu>, "),
2330	#endif
2331	(unsigned long) p->theFile.ino,
2332	(unsigned long) theFile->ino);
2333	sl_strlcat(msg, tmp, SH_MSG_BUF);
2334
2335	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2336	{
2337	p->theFile.ino = theFile->ino;
2338	p->theFile.dev = theFile->dev;
2339	}
2340	}
2341
2342
2343	/*
2344	* also report device for prelude
2345	*/
2346	#if defined(HAVE_LIBPRELUDE)
2347	if ((modi_mask & MODI_INO) != 0)
2348	{
2349	sl_snprintf(tmp, SH_MSG_BUF,
2350	#ifdef SH_USE_XML
2351	_("dev_old=\"%lu,%lu\" dev_new=\"%lu,%lu\" "),
2352	#else
2353	_("dev_old=<%lu,%lu>, dev_new=<%lu,%lu>, "),
2354	#endif
2355	(unsigned long) major(p->theFile.dev),
2356	(unsigned long) minor(p->theFile.dev),
2357	(unsigned long) major(theFile->dev),
2358	(unsigned long) minor(theFile->dev)
2359	);
2360	sl_strlcat(msg, tmp, SH_MSG_BUF);
2361
2362	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2363	p->theFile.dev = theFile->dev;
2364	}
2365	#endif
2366
2367	if ( ((modi_mask & MODI_USR) != 0)
2368	#if defined(HAVE_LIBPRELUDE)
2369	\|\| ((modi_mask & MODI_MOD) != 0)
2370	#endif
2371	)
2372	{
2373	#ifdef SH_USE_XML
2374	sl_snprintf(tmp, SH_MSG_BUF,
2375	_("owner_old=\"%s\" owner_new=\"%s\" iowner_old=\"%ld\" iowner_new=\"%ld\" "),
2376	#else
2377	sl_snprintf(tmp, SH_MSG_BUF,
2378	_("owner_old=<%s>, owner_new=<%s>, iowner_old=<%ld>, iowner_new=<%ld>, "),
2379	#endif
2380	p->theFile.c_owner, theFile->c_owner,
2381	(long) p->theFile.owner, (long) theFile->owner
2382	);
2383	sl_strlcat(msg, tmp, SH_MSG_BUF);
2384
2385	if ((modi_mask & MODI_USR) != 0) {
2386	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2387	{
2388	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
2389	p->theFile.owner = theFile->owner;
2390	}
2391	}
2392	}
2393
2394	if ( ((modi_mask & MODI_GRP) != 0)
2395	#if defined(HAVE_LIBPRELUDE)
2396	\|\| ((modi_mask & MODI_MOD) != 0)
2397	#endif
2398	)
2399	{
2400	#ifdef SH_USE_XML
2401	sl_snprintf(tmp, SH_MSG_BUF,
2402	_("group_old=\"%s\" group_new=\"%s\" igroup_old=\"%ld\" igroup_new=\"%ld\" "),
2403	p->theFile.c_group, theFile->c_group,
2404	(long) p->theFile.group, (long) theFile->group);
2405	#else
2406	sl_snprintf(tmp, SH_MSG_BUF,
2407	_("group_old=<%s>, group_new=<%s>, igroup_old=<%ld>, igroup_new=<%ld>, "),
2408	p->theFile.c_group, theFile->c_group,
2409	(long) p->theFile.group, (long) theFile->group);
2410	#endif
2411
2412	sl_strlcat(msg, tmp, SH_MSG_BUF);
2413
2414	if ((modi_mask & MODI_GRP) != 0) {
2415	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2416	{
2417	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
2418	p->theFile.group = theFile->group;
2419	}
2420	}
2421	}
2422
2423	if ((modi_mask & MODI_SIZ) != 0)
2424	{
2425	sl_snprintf(tmp, SH_MSG_BUF, sh_hash_size_format(),
2426	(UINT64) p->theFile.size,
2427	(UINT64) theFile->size);
2428	sl_strlcat(msg, tmp, SH_MSG_BUF);
2429
2430	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2431	p->theFile.size = theFile->size;
2432	}
2433
2434	if ((modi_mask & MODI_CTM) != 0)
2435	{
2436	(void) sh_unix_gmttime (p->theFile.ctime, timstr1c, sizeof(timstr1c));
2437	(void) sh_unix_gmttime (theFile->ctime, timstr2c, sizeof(timstr2c));
2438	#ifdef SH_USE_XML
2439	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=\"%s\" ctime_new=\"%s\" "),
2440	timstr1c, timstr2c);
2441	#else
2442	sl_snprintf(tmp, SH_MSG_BUF, _("ctime_old=<%s>, ctime_new=<%s>, "),
2443	timstr1c, timstr2c);
2444	#endif
2445	sl_strlcat(msg, tmp, SH_MSG_BUF);
2446
2447	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2448	p->theFile.ctime = theFile->ctime;
2449	}
2450
2451	if ((modi_mask & MODI_ATM) != 0)
2452	{
2453	(void) sh_unix_gmttime (p->theFile.atime, timstr1a, sizeof(timstr1a));
2454	(void) sh_unix_gmttime (theFile->atime, timstr2a, sizeof(timstr2a));
2455	#ifdef SH_USE_XML
2456	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=\"%s\" atime_new=\"%s\" "),
2457	timstr1a, timstr2a);
2458	#else
2459	sl_snprintf(tmp, SH_MSG_BUF, _("atime_old=<%s>, atime_new=<%s>, "),
2460	timstr1a, timstr2a);
2461	#endif
2462	sl_strlcat(msg, tmp, SH_MSG_BUF);
2463
2464	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2465	p->theFile.atime = theFile->atime;
2466	}
2467
2468	if ((modi_mask & MODI_MTM) != 0)
2469	{
2470	(void) sh_unix_gmttime (p->theFile.mtime, timstr1m, sizeof(timstr1m));
2471	(void) sh_unix_gmttime (theFile->mtime, timstr2m, sizeof(timstr2m));
2472	#ifdef SH_USE_XML
2473	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=\"%s\" mtime_new=\"%s\" "),
2474	timstr1m, timstr2m);
2475	#else
2476	sl_snprintf(tmp, SH_MSG_BUF, _("mtime_old=<%s>, mtime_new=<%s>, "),
2477	timstr1m, timstr2m);
2478	#endif
2479	sl_strlcat(msg, tmp, SH_MSG_BUF);
2480
2481	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2482	p->theFile.mtime = theFile->mtime;
2483	}
2484
2485
2486	if ((modi_mask & MODI_CHK) != 0)
2487	{
2488	sl_snprintf(tmp, SH_MSG_BUF,
2489	#ifdef SH_USE_XML
2490	_("chksum_old=\"%s\" chksum_new=\"%s\" "),
2491	#else
2492	_("chksum_old=<%s>, chksum_new=<%s>, "),
2493	#endif
2494	p->theFile.checksum, fileHash);
2495	sl_strlcat(msg, tmp, SH_MSG_BUF);
2496
2497	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2498	{
2499	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
2500	if ((theFile->check_flags & MODI_SGROW) != 0)
2501	p->theFile.size = theFile->size;
2502	}
2503
2504
2505	if (theFile->c_mode[0] != 'l' && theFile->link_path &&
2506	strlen(theFile->link_path) > 2)
2507	modi_mask \|= MODI_LNK;
2508	}
2509
2510
2511	if ((modi_mask & MODI_LNK) != 0 /* && theFile->c_mode[0] == 'l' */)
2512	{
2513	if (theFile->link_path)
2514	tmp_lnk = sh_util_safe_name(theFile->link_path);
2515	else
2516	tmp_lnk = sh_util_strdup("-");
2517	if (p->linkpath)
2518	tmp_lnk_old = sh_util_safe_name(p->linkpath);
2519	else
2520	tmp_lnk_old = sh_util_strdup("-");
2521	#ifdef SH_USE_XML
2522	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=\"%s\" link_new=\"%s\" "),
2523	tmp_lnk_old, tmp_lnk);
2524	#else
2525	sl_snprintf(tmp, SH_MSG_BUF, _("link_old=<%s>, link_new=<%s>, "),
2526	tmp_lnk_old, tmp_lnk);
2527	#endif
2528	SH_FREE(tmp_lnk);
2529	SH_FREE(tmp_lnk_old);
2530	sl_strlcat(msg, tmp, SH_MSG_BUF);
2531
2532	if (sh.flag.reportonce == S_TRUE && sh.flag.update == S_FALSE)
2533	{
2534	if (p->linkpath != NULL)
2535	SH_FREE(p->linkpath);
2536	if (!(theFile->link_path))
2537	p->linkpath = sh_util_strdup("-");
2538	else
2539	p->linkpath = sh_util_strdup(theFile->link_path);
2540	}
2541	}
2542
2543	if (MODI_AUDIT_ENABLED(theFile->check_flags))
2544	{
2545	char result[256];
2546
2547	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__,
2548	0, MSG_E_SUBGPATH,
2549	_("Fetching audit record"),
2550	_("sh_hash"), theFile->fullpath );
2551
2552	if (NULL != sh_audit_fetch (theFile->fullpath, theFile->mtime, theFile->ctime, result, sizeof(result)))
2553	{
2554	#ifdef SH_USE_XML
2555	sl_strlcat(msg, _("obj=\""), SH_MSG_BUF);
2556	#else
2557	sl_strlcat(msg, _("obj=<"), SH_MSG_BUF);
2558	#endif
2559
2560	sl_strlcat(msg, result, SH_MSG_BUF);
2561
2562	#ifdef SH_USE_XML
2563	sl_strlcat(msg, _("\" "), SH_MSG_BUF);
2564	#else
2565	sl_strlcat(msg, _(">"), SH_MSG_BUF);
2566	#endif
2567	}
2568	}
2569
2570	/****************************************************
2571	*
2572	* REPORT on file change
2573	*
2574	****************************************************/
2575	tmp_path = sh_util_safe_name(theFile->fullpath);
2576	if (!sh_global_check_silent)
2577	sh_error_handle(log_severity, FIL__, __LINE__,
2578	(long) modi_mask, MSG_FI_CHAN,
2579	(policy_override == NULL) ? _(policy[class]):log_policy,
2580	change_code, tmp_path, msg);
2581	++sh.statistics.files_report;
2582
2583	SH_FREE(tmp_path);
2584	SH_FREE(tmp);
2585	SH_FREE(msg);
2586
2587	if (S_TRUE == sh.flag.update)
2588	{
2589	if (S_FALSE == sh_util_ask_update(theFile->fullpath))
2590	{
2591	/* user does not want to update, thus we replace
2592	* with data from the baseline database
2593	*/
2594	sl_strlcpy(theFile->c_mode, p->theFile.c_mode, 11);
2595	theFile->mode = p->theFile.mode;
2596	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
2597	sl_strlcpy(theFile->c_attributes, p->theFile.c_attributes, 16);
2598	theFile->attributes = p->theFile.attributes;
2599	#endif
2600	#if defined(USE_ACL) \|\| defined(USE_XATTR)
2601	if (theFile->attr_string == NULL && p->attr_string != NULL)
2602	{ theFile->attr_string = sh_util_strdup (p->attr_string); }
2603	else if (theFile->attr_string != NULL && p->attr_string == NULL)
2604	{ SH_FREE(theFile->attr_string); theFile->attr_string = NULL; }
2605	else if (theFile->attr_string != NULL && p->attr_string != NULL)
2606	{
2607	if (0 != strcmp(theFile->attr_string, p->attr_string))
2608	{
2609	SH_FREE(theFile->attr_string);
2610	theFile->attr_string = sh_util_strdup (p->attr_string);
2611	}
2612	}
2613	#endif
2614
2615	if (theFile->c_mode[0] == 'l') /* c_mode is already copied */
2616	{
2617	if (theFile->link_path)
2618	SH_FREE(theFile->link_path);
2619	if (p->linkpath)
2620	theFile->link_path = sh_util_strdup(p->linkpath);
2621	else
2622	theFile->link_path = sh_util_strdup("-");
2623	}
2624	else
2625	{
2626	if (theFile->link_path)
2627	SH_FREE(theFile->link_path);
2628	if (p->linkpath)
2629	theFile->link_path = sh_util_strdup(p->linkpath);
2630	else
2631	theFile->link_path = NULL;
2632	}
2633
2634	sl_strlcpy(fileHash, p->theFile.checksum, KEY_LEN+1);
2635
2636	theFile->mtime = p->theFile.mtime;
2637	theFile->ctime = p->theFile.ctime;
2638	theFile->atime = p->theFile.atime;
2639
2640	theFile->size = p->theFile.size;
2641
2642	sl_strlcpy(theFile->c_group, p->theFile.c_group, GROUP_MAX+2);
2643	theFile->group = p->theFile.group;
2644	sl_strlcpy(theFile->c_owner, p->theFile.c_owner, USER_MAX+2);
2645	theFile->owner = p->theFile.owner;
2646
2647	theFile->ino = p->theFile.ino;
2648	theFile->rdev = p->theFile.rdev;
2649	theFile->dev = p->theFile.dev;
2650	theFile->hardlinks = p->theFile.hardlinks;
2651
2652	SET_SH_FFLAG_VISITED(p->fflags);
2653	CLEAR_SH_FFLAG_CHECKED(p->fflags);
2654	retval = 1;
2655	goto unlock_and_return;
2656	}
2657	else /* if (sh.flag.reportonce == S_TRUE) */
2658	{
2659	/* we replace the data in the in-memory copy of the
2660	* baseline database, because otherwise we would get
2661	* another warning if the suidcheck runs
2662	*/
2663	sl_strlcpy(p->theFile.c_mode, theFile->c_mode, 11);
2664	p->theFile.mode = theFile->mode;
2665	#if defined(__linux__) \|\| defined(HAVE_STAT_FLAGS)
2666	sl_strlcpy(p->theFile.c_attributes, theFile->c_attributes, 16);
2667	p->theFile.attributes = theFile->attributes;
2668	#endif
2669	#if defined(USE_ACL) \|\| defined(USE_XATTR)
2670	if (p->attr_string == NULL && theFile->attr_string != NULL)
2671	{ p->attr_string = sh_util_strdup (theFile->attr_string); }
2672	else if (p->attr_string != NULL && theFile->attr_string == NULL)
2673	{ SH_FREE(p->attr_string); p->attr_string = NULL; }
2674	else if (theFile->attr_string != NULL && p->attr_string != NULL)
2675	{
2676	if (0 != strcmp(theFile->attr_string, p->attr_string))
2677	{
2678	SH_FREE(p->attr_string);
2679	p->attr_string = sh_util_strdup (theFile->attr_string);
2680	}
2681	}
2682	#endif
2683
2684	if (theFile->c_mode[0] == 'l' \|\| theFile->link_path)
2685	{
2686	if (p->linkpath != NULL)
2687	SH_FREE(p->linkpath);
2688	p->linkpath = sh_util_strdup(theFile->link_path);
2689	}
2690	else
2691	{
2692	if (p->linkpath != NULL)
2693	SH_FREE(p->linkpath);
2694	p->linkpath = sh_util_strdup("-");
2695	}
2696
2697	sl_strlcpy(p->theFile.checksum, fileHash, KEY_LEN+1);
2698
2699	p->theFile.mtime = theFile->mtime;
2700	p->theFile.ctime = theFile->ctime;
2701	p->theFile.atime = theFile->atime;
2702
2703	p->theFile.size = theFile->size;
2704
2705	sl_strlcpy(p->theFile.c_group, theFile->c_group, GROUP_MAX+2);
2706	p->theFile.group = theFile->group;
2707	sl_strlcpy(p->theFile.c_owner, theFile->c_owner, USER_MAX+2);
2708	p->theFile.owner = theFile->owner;
2709
2710	p->theFile.ino = theFile->ino;
2711	p->theFile.rdev = theFile->rdev;
2712	p->theFile.dev = theFile->dev;
2713	p->theFile.hardlinks = theFile->hardlinks;
2714	}
2715	}
2716	}
2717
2718	SET_SH_FFLAG_VISITED(p->fflags);
2719	CLEAR_SH_FFLAG_CHECKED(p->fflags);
2720
2721	unlock_and_return:
2722	; /* 'label at end of compound statement */
2723	SH_MUTEX_UNLOCK(mutex_hash);
2724	SL_RETURN(retval, _("sh_hash_compdata"));
2725	}
2726
2727	int hash_full_tree ()
2728	{
2729	sh_file_t * p;
2730	int i;
2731
2732	SL_ENTER(_("hash_full_tree"));
2733
2734	if (IsInit != 1)
2735	SL_RETURN(0, _("hash_full_tree"));
2736
2737	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
2738	for (i = 0; i < TABSIZE; ++i)
2739	{
2740	for (p = tab[i]; p; p = p->next)
2741	CLEAR_SH_FFLAG_ALLIGNORE(p->fflags);
2742	}
2743	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
2744	SL_RETURN (0, _("hash_full_tree"));
2745	}
2746
2747	#if !defined(SH_CUTEST)
2748	static
2749	#endif
2750	int hash_remove_tree_test(char * s, char * fullpath, size_t len_s)
2751	{
2752	size_t len_p;
2753	char * test;
2754
2755	len_p = strlen(fullpath);
2756
2757	if (len_p >= len_s)
2758	{
2759	if (0 == strncmp(s, fullpath, len_s))
2760	{
2761	if (len_p > len_s)
2762	{
2763	/* continue if not inside directory;
2764	* len_s > 1 because everything is inside '/'
2765	*/
2766	if ((len_s > 1) && (fullpath[len_s] != '/'))
2767	return S_FALSE;
2768
2769	test = sh_files_find_mostspecific_dir(fullpath);
2770
2771	if (test && 0 != strcmp(test, s)) {
2772	/* There is a more specific directory, continue */
2773	return S_FALSE;
2774	}
2775
2776	if (NULL == sh_files_findfile(fullpath)) {
2777	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
2778	return S_TRUE;
2779	}
2780	}
2781	else /* len_p == len */
2782	{
2783	/* it is 's' itself, mark and continue
2784	* unless there is a policy for the inode itself
2785	*/
2786	if (NULL == sh_files_findfile(fullpath)) {
2787	/* SET_SH_FFLAG_ALLIGNORE(p->fflags); */
2788	return S_TRUE;
2789	}
2790	else {
2791	return S_FALSE;
2792	}
2793	}
2794
2795	} /* if path is in tree */
2796	} /* if path is possibly in tree */
2797	return S_FALSE;
2798	}
2799
2800
2801	int hash_remove_tree (char * s)
2802	{
2803	sh_file_t * p;
2804	size_t len_s;
2805	unsigned int i;
2806
2807	SL_ENTER(_("hash_remove_tree"));
2808
2809	if (!s \|\| *s == '\0')
2810	SL_RETURN ((-1), _("hash_remove_tree"));
2811
2812	len_s = sl_strlen(s);
2813
2814	if (IsInit != 1)
2815	sh_hash_init();
2816
2817	SH_MUTEX_LOCK_UNSAFE(mutex_hash);
2818	for (i = 0; i < TABSIZE; ++i)
2819	{
2820	for (p = tab[i]; p; p = p->next)
2821	{
2822	if (p->fullpath)
2823	{
2824	/* if (0 == strncmp(s, p->fullpath, len_s)) // old */
2825	if (S_TRUE == hash_remove_tree_test(s, p->fullpath, len_s)) {
2826	SET_SH_FFLAG_ALLIGNORE(p->fflags);
2827	MODI_SET(p->theFile.checkflags, MODI_ALLIGNORE);
2828	}
2829	} /* if path is not null */
2830
2831	}
2832	}
2833	SH_MUTEX_UNLOCK_UNSAFE(mutex_hash);
2834	SL_RETURN ((0), _("hash_remove_tree"));
2835	}
2836
2837	#if TIME_WITH_SYS_TIME
2838	#include <sys/time.h>
2839	#include <time.h>
2840	#else
2841	#if HAVE_SYS_TIME_H
2842	#include <sys/time.h>
2843	#else
2844	#include <time.h>
2845	#endif
2846	#endif
2847
2848	static int ListFullDetail = S_FALSE;
2849	static int ListWithDelimiter = S_FALSE;
2850	static char * ListFile = NULL;
2851
2852	int set_list_file (const char * c)
2853	{
2854	ListFile = sh_util_strdup(c);
2855	return 0;
2856	}
2857	char * get_list_file()
2858	{
2859	return ListFile;
2860	}
2861
2862	int set_full_detail (const char * c)
2863	{
2864	(void) c;
2865	ListFullDetail = S_TRUE;
2866	return 0;
2867	}
2868
2869	int set_list_delimited (const char * c)
2870	{
2871	(void) c;
2872	ListFullDetail = S_TRUE;
2873	ListWithDelimiter = S_TRUE;
2874	return 0;
2875	}
2876
2877	/* Always quote the string, except if it is empty. Quote quotes by
2878	* doubling them.
2879	*/
2880	char * csv_escape(const char * str)
2881	{
2882	const char * p = str;
2883	const char * q;
2884
2885	size_t size = 0;
2886	size_t flag_quote = 0;
2887
2888	char * new;
2889	char * pnew;
2890
2891	if (p)
2892	{
2893
2894	while (*p)
2895	{
2896	if (*p == '"')
2897	++flag_quote;
2898
2899	++size; ++p;
2900	}
2901
2902	if (sl_ok_adds(size, flag_quote))
2903	size += flag_quote; /* double each quote */
2904	else
2905	return NULL;
2906
2907	if (sl_ok_adds(size, 3))
2908	size += 3; /* two quotes and terminating null */
2909	else
2910	return NULL;
2911
2912	new = SH_ALLOC(size);
2913
2914	if (flag_quote != 0)
2915	{
2916	new[0] = '"';
2917	pnew = &new[1];
2918	q = str;
2919	while (*q)
2920	{
2921	pnew = q;
2922	if (*pnew == '"')
2923	{
2924	++pnew; *pnew = '"';
2925	}
2926	++pnew; ++q;
2927	}
2928	*pnew = '"'; ++pnew;
2929	*pnew = '\0';
2930	}
2931	else
2932	{
2933	if (size > 3)
2934	{
2935	new[0] = '"';
2936	sl_strlcpy (&new[1], str, size-1);
2937	new[size-2] = '"';
2938	new[size-1] = '\0';
2939	}
2940	else
2941	{
2942	new[0] = '\0';
2943	}
2944	}
2945
2946	return new;
2947	}
2948	return NULL;
2949	}
2950
2951	int isHexKey(char * s)
2952	{
2953	int i;
2954
2955	for (i = 0; i < KEY_LEN; ++i)
2956	{
2957	if (*s)
2958	{
2959	if ((s >= '0' && s <= '9') \|\|
2960	(s >= 'A' && s <= 'F') \|\|
2961	(s >= 'a' && s <= 'f'))
2962	{
2963	++s;
2964	continue;
2965	}
2966	}
2967	return S_FALSE;
2968	}
2969	return S_TRUE;
2970	}
2971
2972	#include "sh_checksum.h"
2973
2974	static char * KEYBUFtolower (char * s, char * result)
2975	{
2976	char * r = result;
2977	if (s)
2978	{
2979	for (; *s; ++s)
2980	{
2981	r = tolower((unsigned char) s); ++r;
2982	}
2983	*r = '\0';
2984	}
2985	return result;
2986	}
2987
2988	void sh_hash_list_db_entry_full_detail (sh_file_t * p)
2989	{
2990	char * tmp;
2991	char * esc;
2992	char str[81];
2993	char hexdigest[SHA256_DIGEST_STRING_LENGTH];
2994	char keybuffer[KEYBUF_SIZE];
2995
2996	if (ListWithDelimiter == S_TRUE)
2997	{
2998	printf(_("%7ld, %7ld, %10s, %5d, %12s, %5d, %3d, %-8s, %5d, %-8s, %5d, "),
2999	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
3000	p->theFile.c_mode, (int) p->theFile.mode,
3001	p->theFile.c_attributes, (int) p->theFile.attributes,
3002	(int) p->theFile.hardlinks,
3003	p->theFile.c_owner, (int) p->theFile.owner,
3004	p->theFile.c_group, (int) p->theFile.group);
3005	}
3006	else
3007	{
3008	printf(_("%7ld %7ld %10s %5d %12s %5d %3d %-8s %5d %-8s %5d "),
3009	(unsigned long) p->theFile.ino, (unsigned long) p->theFile.dev,
3010	p->theFile.c_mode, (int) p->theFile.mode,
3011	p->theFile.c_attributes, (int) p->theFile.attributes,
3012	(int) p->theFile.hardlinks,
3013	p->theFile.c_owner, (int) p->theFile.owner,
3014	p->theFile.c_group, (int) p->theFile.group);
3015	}
3016
3017	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
3018	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.rdev);
3019	else
3020	sl_snprintf(str, sizeof(str), "%"PRIu64, p->theFile.size);
3021
3022	printf( _(" %8s"), str);
3023	if (ListWithDelimiter == S_TRUE)
3024	putchar(',');
3025
3026	printf( _(" %s"), sh_unix_gmttime (p->theFile.ctime, str, sizeof(str)));
3027	if (ListWithDelimiter == S_TRUE)
3028	putchar(',');
3029	printf( _(" %s"), sh_unix_gmttime (p->theFile.mtime, str, sizeof(str)));
3030	if (ListWithDelimiter == S_TRUE)
3031	putchar(',');
3032	printf( _(" %s"), sh_unix_gmttime (p->theFile.atime, str, sizeof(str)));
3033	if (ListWithDelimiter == S_TRUE)
3034	putchar(',');
3035
3036	if (isHexKey(p->theFile.checksum))
3037	printf( _(" %s"), KEYBUFtolower(p->theFile.checksum, keybuffer));
3038	else
3039	printf( _(" %s"), SHA256_Base2Hex(p->theFile.checksum, hexdigest));
3040	if (ListWithDelimiter == S_TRUE)
3041	putchar(',');
3042
3043	tmp = sh_util_safe_name(p->fullpath);
3044	if (ListWithDelimiter != S_TRUE)
3045	{
3046	printf( _(" %s"), tmp);
3047	}
3048	else
3049	{
3050	esc = csv_escape(tmp);
3051	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
3052	if (esc)
3053	SH_FREE(esc);
3054	}
3055	SH_FREE(tmp);
3056
3057	if ('l' == p->theFile.c_mode[0])
3058	{
3059	tmp = sh_util_safe_name(p->linkpath);
3060	if (ListWithDelimiter != S_TRUE)
3061	{
3062	printf(_(" -> %s"), tmp);
3063	}
3064	else
3065	{
3066	esc = csv_escape(tmp);
3067	printf( _(" %s,"), (esc != NULL) ? esc : _("(null)"));
3068	if (esc)
3069	SH_FREE(esc);
3070	}
3071	SH_FREE(tmp);
3072	}
3073
3074	if (p->attr_string)
3075	{
3076	tmp = sh_util_safe_name(p->attr_string);
3077	if (ListWithDelimiter != S_TRUE)
3078	{
3079	printf(_(" %s"), tmp);
3080	}
3081	else
3082	{
3083	esc = csv_escape(tmp);
3084	printf( _(" %s"), (esc != NULL) ? esc : _("(null)"));
3085	if (esc)
3086	SH_FREE(esc);
3087	}
3088	SH_FREE(tmp);
3089	}
3090	else
3091	{
3092	if (ListWithDelimiter == S_TRUE)
3093	printf("%s",_(" no_attr"));
3094	}
3095	putchar('\n');
3096
3097	return;
3098	}
3099
3100	void sh_hash_list_db_entry (sh_file_t * p)
3101	{
3102	char nowtime[128];
3103	char thetime[128];
3104	char * tmp;
3105	time_t now = time(NULL);
3106	time_t then = (time_t) p->theFile.mtime;
3107	struct tm * time_ptr;
3108
3109	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
3110	struct tm time_tm;
3111	#endif
3112
3113	if (ListFullDetail != S_FALSE)
3114	{
3115	sh_hash_list_db_entry_full_detail (p);
3116	return;
3117	}
3118
3119	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_GMTIME_R)
3120	time_ptr = gmtime_r(&then, &time_tm);
3121	if (!time_ptr)
3122	return;
3123	strftime(thetime, 127, _("%b %d %Y"), time_ptr);
3124	time_ptr = gmtime_r(&now, &time_tm);
3125	if (!time_ptr)
3126	return;
3127	strftime(nowtime, 127, _("%b %d %Y"), time_ptr);
3128	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
3129	{
3130	time_ptr = gmtime_r(&then, &time_tm);
3131	if (!time_ptr)
3132	return;
3133	strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
3134	}
3135	#else
3136	time_ptr = gmtime(&then);
3137	if (!time_ptr)
3138	return;
3139	strftime(thetime, 127, _("%b %d %Y"), time_ptr);
3140	time_ptr = gmtime(&now);
3141	if (!time_ptr)
3142	return;
3143	strftime(nowtime, 127, _("%b %d %Y"), time_ptr);
3144	if (0 == strncmp(&nowtime[7], &thetime[7], 4))
3145	{
3146	time_ptr = gmtime(&then);
3147	if (!time_ptr)
3148	return;
3149	strftime(thetime, 127, _("%b %d %H:%M"), time_ptr);
3150	}
3151	#endif
3152
3153	tmp = sh_util_safe_name(p->fullpath);
3154	if ('c' == p->theFile.c_mode[0] \|\| 'b' == p->theFile.c_mode[0])
3155	printf(_("%10s %3d %-8s %-8s %3d,%4d %s %s"),
3156	p->theFile.c_mode, (int) p->theFile.hardlinks,
3157	p->theFile.c_owner, p->theFile.c_group,
3158	(int) major((dev_t)p->theFile.rdev),
3159	(int) minor((dev_t)p->theFile.rdev),
3160	thetime,
3161	tmp);
3162	else
3163	printf(_("%10s %3d %-8s %-8s %8ld %s %s"),
3164	p->theFile.c_mode, (int) p->theFile.hardlinks,
3165	p->theFile.c_owner, p->theFile.c_group, (long) p->theFile.size,
3166	thetime,
3167	tmp);
3168	SH_FREE(tmp);
3169
3170	if ('l' == p->theFile.c_mode[0])
3171	{
3172	tmp = sh_util_safe_name(p->linkpath);
3173	printf(_(" -> %s\n"), tmp);
3174	SH_FREE(tmp);
3175	}
3176	else
3177	printf("\n");
3178
3179	return;
3180	}
3181
3182	#ifdef HAVE_LIBZ
3183	#include <zlib.h>
3184	#endif
3185
3186	int sh_hash_printcontent(char * linkpath)
3187	{
3188	#ifdef HAVE_LIBZ
3189	unsigned char * decoded;
3190	unsigned char * decompressed = NULL;
3191	size_t dlen;
3192	unsigned long clen;
3193	unsigned long clen_o;
3194	int res;
3195
3196	if (linkpath && *linkpath != '-')
3197	{
3198	dlen = sh_util_base64_dec_alloc (&decoded,
3199	(unsigned char *)linkpath,
3200	strlen(linkpath));
3201
3202	clen = dlen * 2 + 1;
3203
3204	do {
3205	if (decompressed)
3206	SH_FREE(decompressed);
3207	clen += dlen; clen_o = clen;
3208	decompressed = SH_ALLOC(clen);
3209	res = uncompress(decompressed, &clen, decoded, dlen);
3210	if (res == Z_MEM_ERROR)
3211	{ fprintf(stderr, "%s",_("Error: Not enough memory\n")); return -1; }
3212	if (res == Z_DATA_ERROR)
3213	{ fprintf(stderr, "%s",_("Error: Data corrupt or incomplete\n")); return -1; }
3214	} while (res == Z_BUF_ERROR \|\| clen == clen_o);
3215
3216	decompressed[clen] = '\0';
3217	fputs( (char*) decompressed, stdout);
3218	SH_FREE(decompressed);
3219	return 0;
3220	}
3221	#else
3222	(void) linkpath;
3223	#endif
3224	fprintf(stderr, "%s",_("Error: No data available\n"));
3225	return -1;
3226	}
3227
3228	/* if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE) */
3229	#endif

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

Download in other formats: