Context Navigation

source: trunk/src/sh_hash.c@ 383

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

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

Download in other formats: