Context Navigation

source: trunk/src/sh_hash.c@ 306

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

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

Download in other formats: