source: trunk/src/sh_hash.c@ 190

Last change on this file since 190 was 185, checked in by katerina, 16 years ago

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