Context Navigation

source: trunk/src/sh_hash.c@ 81

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

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

Download in other formats: