source: trunk/src/sh_readconf.c@ 520

Last change on this file since 520 was 514, checked in by katerina, 8 years ago

Fix for ticket #407 (option to set auditd flags).
File size: 41.6 KB
Line 
1/* SAMHAIN file system integrity testing */
2/* Copyright (C) 1999, 2000 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
23#include <stdlib.h>
24#include <stdio.h>
25#include <string.h>
26#include <ctype.h>
27
28
29#include "samhain.h"
30#include "sh_calls.h"
31#include "sh_error.h"
32#include "sh_extern.h"
33#include "sh_unix.h"
34#include "sh_files.h"
35#include "sh_xfer.h"
36#include "sh_gpg.h"
37#include "sh_hash.h"
38#include "sh_dbIO.h"
39#include "sh_ignore.h"
40#include "sh_database.h"
41#include "sh_mail.h"
42#include "sh_modules.h"
43#include "sh_nmail.h"
44#include "sh_prelink.h"
45#ifdef HAVE_LIBPRELUDE
46#include "sh_prelude.h"
47#endif
48#include "sh_tiger.h"
49#include "sh_tools.h"
50#include "sh_utils.h"
51#include "sh_restrict.h"
52#include "sh_socket.h"
53
54extern int set_reverse_lookup (const char * c);
55
56#undef FIL__
57#define FIL__ _("sh_readconf.c")
58
59typedef enum {
60 SH_SECTION_NONE,
61 SH_SECTION_LOG,
62 SH_SECTION_MISC,
63 SH_SECTION_ATTRIBUTES,
64 SH_SECTION_READONLY,
65 SH_SECTION_LOGFILES,
66 SH_SECTION_LOGGROW,
67 SH_SECTION_NOIGNORE,
68 SH_SECTION_ALLIGNORE,
69 SH_SECTION_USER0,
70 SH_SECTION_USER1,
71 SH_SECTION_USER2,
72 SH_SECTION_USER3,
73 SH_SECTION_USER4,
74 SH_SECTION_PRELINK,
75#if defined (SH_WITH_MAIL)
76 SH_SECTION_MAIL,
77#endif
78#if defined (SH_WITH_CLIENT)
79 SH_SECTION_CLT,
80#endif
81#ifdef WITH_EXTERNAL
82 SH_SECTION_EXTERNAL,
83#endif
84#ifdef WITH_DATABASE
85 SH_SECTION_DATABASE,
86#endif
87#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
88 SH_SECTION_OTHER,
89#endif
90#ifdef SH_WITH_SERVER
91 SH_SECTION_CLIENTS,
92 SH_SECTION_SRV,
93#endif
94 SH_SECTION_THRESHOLD
95} ShSectionType;
96
97typedef struct str_ListSections {
98 const char * name;
99 int type;
100} sh_str_ListSections;
101
102struct str_ListSections tab_ListSections[] = {
103 { N_("[Log]"), SH_SECTION_LOG},
104 { N_("[Misc]"), SH_SECTION_MISC},
105 { N_("[Attributes]"), SH_SECTION_ATTRIBUTES},
106 { N_("[ReadOnly]"), SH_SECTION_READONLY},
107 { N_("[LogFiles]"), SH_SECTION_LOGFILES},
108 { N_("[GrowingLogFiles]"), SH_SECTION_LOGGROW},
109 { N_("[IgnoreAll]"), SH_SECTION_ALLIGNORE},
110 { N_("[IgnoreNone]"), SH_SECTION_NOIGNORE},
111 { N_("[User0]"), SH_SECTION_USER0},
112 { N_("[User1]"), SH_SECTION_USER1},
113 { N_("[User2]"), SH_SECTION_USER2},
114 { N_("[User3]"), SH_SECTION_USER3},
115 { N_("[User4]"), SH_SECTION_USER4},
116 { N_("[Prelink]"), SH_SECTION_PRELINK},
117#ifdef WITH_EXTERNAL
118 { N_("[External]"), SH_SECTION_EXTERNAL},
119#endif
120#ifdef WITH_DATABASE
121 { N_("[Database]"), SH_SECTION_DATABASE},
122#endif
123 { N_("[EventSeverity]"), SH_SECTION_THRESHOLD},
124#ifdef SH_WITH_SERVER
125 { N_("[Clients]"), SH_SECTION_CLIENTS},
126 { N_("[Server]"), SH_SECTION_SRV},
127#endif
128#if defined (SH_WITH_CLIENT)
129 { N_("[Client]"), SH_SECTION_CLT},
130#endif
131#if defined (SH_WITH_MAIL)
132 { N_("[Mail]"), SH_SECTION_MAIL},
133#endif
134 { NULL, SH_SECTION_NONE}
135};
136
137static char * sh_readconf_expand_value (const char * str)
138{
139#ifdef SH_EVAL_SHELL
140 char * tmp = sh_util_strdup(str);
141 char * out;
142 char * tmp_orig = tmp;
143
144 while (tmp && isspace((int)*tmp)) ++tmp;
145
146 if (tmp && tmp[0] == '$' && tmp[1] == '(')
147 {
148 size_t len = strlen(tmp);
149 while (isspace((int) tmp[len-1])) { tmp[len-1] = '\0'; --len; }
150 if (tmp[len-1] == ')')
151 {
152 tmp[len-1] = '\0';
153 out = sh_ext_popen_str(&tmp[2]);
154 SH_FREE(tmp_orig);
155 return out;
156 }
157 }
158 SH_FREE(tmp_orig);
159#endif
160 return sh_util_strdup(str);
161}
162
163enum {
164 SH_RC_ANY = 0,
165 SH_RC_HOST = 1,
166 SH_RC_SYSTEM = 2,
167 SH_RC_FILE = 3,
168 SH_RC_IFACE = 4,
169#ifdef SH_EVAL_SHELL
170 SH_RC_CMD = 5
171#endif
172};
173
174
175static int sh_readconf_cond_match(char * str, int line)
176{
177 int match = 0;
178 int negate = 1;
179 int cond_type = SH_RC_ANY;
180 char myident[3*SH_MINIBUF+3];
181 struct stat buf;
182
183 char * p = str;
184
185 if (*p == '!') { negate = 0; ++p; }
186 if (*p == '$') {
187 cond_type = SH_RC_SYSTEM; ++p; /* [!]$system */
188 }
189 else { /* *p == '@' */
190
191 ++p; while (isspace((int)*p)) ++p;
192
193 if (0 != strncasecmp(p, _("if "), 3)) {
194 cond_type = SH_RC_HOST; /* [!]$host */
195 }
196
197 else {
198
199 p += 3; while (isspace((int)*p)) ++p; /* skip the 'if\s+' */
200
201 if (0 == strncasecmp(p, _("not "), 4))
202 {
203 p += 4; while (isspace((int)*p)) ++p;
204 negate = 0;
205 match = 1;
206 }
207 else if (0 == strncmp(p, _("!"), 1))
208 {
209 ++p; while (isspace((int)*p)) ++p;
210 negate = 0;
211 match = 1;
212 }
213
214 if (0 == strncasecmp(p, _("file_exists "), 12))
215 {
216 p += 12; cond_type = SH_RC_FILE;
217 }
218 else if (0 == strncasecmp(p, _("interface_exists "), 17))
219 {
220 p += 17; cond_type = SH_RC_IFACE;
221 }
222 else if (0 == strncasecmp(p, _("hostname_matches "), 17))
223 {
224 p += 17; cond_type = SH_RC_HOST;
225 }
226 else if (0 == strncasecmp(p, _("system_matches "), 15))
227 {
228 p += 15; cond_type = SH_RC_SYSTEM;
229 }
230#ifdef SH_EVAL_SHELL
231 else if (0 == strncasecmp(p, _("command_succeeds "), 17))
232 {
233 p += 17; cond_type = SH_RC_CMD;
234 }
235#endif
236 else
237 {
238 char errbuf[SH_ERRBUF_SIZE];
239 sl_snprintf(errbuf, sizeof(errbuf),
240 _("Unsupported test at line %d of configuration file"),
241 line);
242 sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, 0, MSG_E_SUBGEN,
243 errbuf,
244 _("sh_readconf_cond_match"));
245 return 0;
246 }
247 }
248 }
249
250 while (isspace((int)*p)) ++p;
251
252 switch (cond_type)
253 {
254 case SH_RC_HOST:
255 if (sl_strncmp (p, sh.host.name, strlen(sh.host.name)) == 0
256#ifdef HAVE_REGEX_H
257 || sh_util_regcmp (p, sh.host.name) == 0
258#endif
259 )
260 match = negate;
261 break;
262 case SH_RC_SYSTEM:
263 /*
264 * The system type, release, and machine.
265 */
266 sl_snprintf(myident, sizeof(myident), _("%s:%s:%s"),
267 sh.host.system, /* flawfinder: ignore */
268 sh.host.release, sh.host.machine);
269
270 if (sl_strncmp (p, myident, strlen(myident)) == 0
271#ifdef HAVE_REGEX_H
272 || sh_util_regcmp (p, myident) == 0
273#endif
274 )
275 match = negate;
276 break;
277 case SH_RC_FILE:
278 if (0 == retry_lstat(FIL__, __LINE__, p, &buf))
279 match = negate;
280 break;
281 case SH_RC_IFACE:
282 if (sh_tools_iface_is_present(p))
283 match = negate;
284 break;
285#ifdef SH_EVAL_SHELL
286 case SH_RC_CMD:
287 if (0 == sh_unix_run_command(p))
288 match = negate;
289 break;
290#endif
291 default:
292 /* do nothing */;
293 }
294 return match;
295}
296
297static int sh_readconf_is_end (char * str)
298{
299 int retval = 0;
300
301 if (str[0] == '@' || str[0] == '$')
302 {
303 char * p = str;
304 ++p; while (isspace((int)*p)) ++p;
305 if (
306 (0 == strncasecmp (p, _("end"), 3) && (p[3] == '\0' || isspace((int)p[3]))) ||
307 (0 == strncasecmp (p, _("fi"), 2) && (p[2] == '\0' || isspace((int)p[2])))
308 )
309 {
310 return 1;
311 }
312 }
313 return retval;
314}
315
316static int sh_readconf_is_else (char * str)
317{
318 int retval = 0;
319
320 if (str[0] == '@')
321 {
322 char * p = str;
323 ++p; while (isspace((int)*p)) ++p;
324 if ( 0 == strncasecmp (p, _("else"), 4) && (p[4] == '\0' || isspace((int)p[4])) )
325 {
326 return 1;
327 }
328 }
329 return retval;
330}
331
332static int sh_readconfig_line (char * line);
333
334static ShSectionType read_mode = SH_SECTION_NONE;
335
336static int conf_line = 0;
337
338/* --- Read the configuration file. ---
339 */
340int sh_readconf_read (void)
341{
342#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
343 /* This is for modules.
344 */
345 int modnum;
346#endif
347
348 int i;
349
350 SL_TICKET fd = -1;
351#if defined(SH_STEALTH) && !defined(SH_STEALTH_MICRO)
352 SL_TICKET fdTmp = -1;
353#endif
354#if defined(WITH_GPG) || defined(WITH_PGP)
355 SL_TICKET fdGpg = -1;
356#endif
357 char * tmp;
358
359#define SH_LINE_IN 16384
360 char * line_in;
361 char * line;
362
363 /* This is for nested conditionals.
364 */
365 int cond_depth = 0;
366 int cond_excl = 0;
367
368 int local_file = 1;
369 char local_flag = 'R';
370
371#if defined(WITH_GPG) || defined(WITH_PGP)
372 int signed_content = S_FALSE;
373 int true_content = S_FALSE;
374#endif
375#if defined(SH_STEALTH) && !defined(SH_STEALTH_MICRO)
376 int hidden_count = 0;
377#endif
378 uid_t euid;
379 char hashbuf[KEYBUF_SIZE];
380
381 SL_ENTER(_("sh_readconf_read"));
382
383 /* --- Open config file, exit on failure. ---
384 */
385#if defined(SH_WITH_CLIENT)
386 if (0 == sl_strcmp(file_path('C', 'R'), _("REQ_FROM_SERVER")))
387 {
388 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_D_START);
389
390 fd = sh_xfer_request_file(_("CONF"));
391
392 if (!SL_ISERROR(fd))
393 {
394 local_file = 0;
395 }
396 else if (sh.flag.checkSum != SH_CHECK_INIT)
397 {
398 sh_error_handle((-1), FIL__, __LINE__, 0, MSG_TCP_FBAD);
399 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
400 }
401 else
402 {
403 sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, 0, MSG_TCP_FBAD);
404 sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_D_FAIL);
405 local_file = 1;
406 local_flag = 'I';
407 }
408 }
409#endif
410
411 /* Use a local configuration file.
412 */
413 if (local_file == 1)
414 {
415 if (0 != tf_trust_check (file_path('C', local_flag), SL_YESPRIV))
416 {
417 sl_get_euid(&euid);
418 dlog(1, FIL__, __LINE__,
419 _("The configuration file: %s is untrusted, i.e. an\nuntrusted user owns or can write to some directory in the path.\n"),
420 ( (NULL == file_path('C', local_flag))
421 ? _("(null)") : file_path('C', local_flag) ));
422 sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_TRUST,
423 (long) euid,
424 ( (NULL == file_path('C', local_flag))
425 ? _("(null)") : file_path('C', local_flag) )
426 );
427 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
428 }
429 if (SL_ISERROR(fd = sl_open_read(FIL__, __LINE__,
430 file_path('C',local_flag),SL_YESPRIV)))
431 {
432 sl_get_euid(&euid);
433 dlog(1, FIL__, __LINE__,
434 _("Could not open the local configuration file 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"),
435 sl_get_errmsg(), fd, (int) euid);
436 sh_error_handle ((-1), FIL__, __LINE__, fd, MSG_NOACCESS,
437 (long) euid,
438 ( (NULL == file_path('C', local_flag))
439 ? _("(null)") : file_path('C', local_flag) )
440 );
441 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
442 }
443 }
444
445 /* Compute the checksum of the open file.
446 */
447 sl_strlcpy(sh.conf.hash,
448 sh_tiger_hash(file_path('C',local_flag), fd, TIGER_NOLIM,
449 hashbuf, sizeof(hashbuf)),
450 KEY_LEN+1);
451 sl_rewind (fd);
452
453 line_in = SH_ALLOC(SH_LINE_IN);
454
455#if defined(SH_STEALTH) && !defined(SH_STEALTH_MICRO)
456 /* extract the data and copy to temporary file
457 */
458 fdTmp = open_tmp();
459
460 sh_unix_getline_stealth (0, NULL, 0); /* initialize */
461
462 while ( sh_unix_getline_stealth (fd, line_in, SH_LINE_IN-2) > 0) {
463 hidden_count++;
464 if (line_in[0] == '\n')
465 {
466 sl_write(fdTmp, line_in, 1);
467 }
468 else
469 {
470 sl_write_line(fdTmp, line_in, sl_strlen(line_in));
471 }
472#if defined(WITH_GPG) || defined(WITH_PGP)
473 if (0 == sl_strncmp(line_in, _("-----END PGP SIGNATURE-----"), 25))
474 break;
475#else
476 if (0 == sl_strncmp(line_in, _("[EOF]"), 5))
477 break;
478#endif
479 if (hidden_count > 1048576) /* arbitrary safeguard, 1024*1024 */
480 break;
481 }
482 sl_close(fd);
483 fd = fdTmp;
484 sl_rewind (fd);
485#endif
486
487#if defined(WITH_GPG) || defined(WITH_PGP)
488
489 /* extract the data and copy to temporary file
490 */
491 fdGpg = sh_gpg_extract_signed(fd);
492
493 sl_close(fd);
494 fd = fdGpg;
495
496 /* Validate signature of open file.
497 */
498 if (0 != sh_gpg_check_sign (fd, SIG_CONF))
499 {
500 SH_FREE(line_in);
501 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1, sh.prg_name);
502 aud_exit (FIL__, __LINE__, EXIT_FAILURE);
503 }
504 sl_rewind (fd);
505#endif
506
507
508 /* --- Start reading lines. ---
509 */
510 conf_line = 0;
511
512 while ( sh_unix_getline (fd, line_in, SH_LINE_IN-2) > 0) {
513
514 ++conf_line;
515
516 line = &(line_in[0]);
517
518 /* fprintf(stderr, "<%s>\n", line); */
519
520 /* Sun May 27 18:40:05 CEST 2001
521 */
522#if defined(WITH_GPG) || defined(WITH_PGP)
523 if (signed_content == S_FALSE)
524 {
525 if (0 == sl_strcmp(line, _("-----BEGIN PGP SIGNED MESSAGE-----")))
526 signed_content = S_TRUE;
527 else
528 continue;
529 }
530 else if (true_content == S_FALSE)
531 {
532 if (line[0] == '\n')
533 true_content = S_TRUE;
534 else
535 continue;
536 }
537 else if (signed_content == S_TRUE)
538 {
539 if (0 == sl_strcmp(line, _("-----BEGIN PGP SIGNATURE-----")))
540 break;
541 else if (0 == sl_strcmp(line, _("-----BEGIN PGP SIGNED MESSAGE-----")))
542 {
543 sh_error_handle((-1), FIL__, __LINE__, 0, MSG_E_SUBGEN,
544 _("second signed message in file"),
545 _("sh_readconf_read"));
546 dlog(1, FIL__, __LINE__,
547 _("There seems to be more than one signed message in the configuration\nfile. Please make sure there is only one signed message.\n"));
548 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EXIT_ABORT1,
549 sh.prg_name);
550 SH_FREE(line_in);
551 aud_exit (FIL__, __LINE__,EXIT_FAILURE);
552 }
553 }
554#endif
555
556 /* Skip leading white space.
557 */
558 while (isspace((int)*line)) ++line;
559
560
561 /* Skip header etc.
562 */
563 if (line[0] == '#' || line[0] == '\0' || line[0] == ';' ||
564 (line[0] == '/' && line[1] == '/'))
565 continue;
566
567 /* Clip off trailing white space.
568 */
569 tmp = line + sl_strlen( line ); --tmp;
570 while( isspace((int) *tmp ) && tmp >= line ) *tmp-- = '\0';
571
572
573 /* --- an @host/@if/$system directive -------------- */
574
575 if (line[0] == '@' || (line[0] == '!' && line[1] == '@') ||
576 line[0] == '$' || (line[0] == '!' && line[1] == '$'))
577 {
578 if (sh_readconf_is_end(line))
579 {
580 if (0 == cond_depth) {
581 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALD,
582 _("config file"),
583 (long) conf_line);
584 }
585 else {
586 if (cond_excl == cond_depth)
587 cond_excl = 0;
588 --cond_depth;
589 }
590 }
591 else if (sh_readconf_is_else(line))
592 {
593 if (0 == cond_depth) {
594 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALD,
595 _("config file"),
596 (long) conf_line);
597 }
598 else if (cond_excl == cond_depth) {
599 cond_excl = 0;
600 }
601 else if (cond_excl == 0) {
602 cond_excl = cond_depth;
603 }
604 }
605 else
606 {
607 if (sh_readconf_cond_match(line, conf_line)) {
608 ++cond_depth;
609 }
610 else {
611 ++cond_depth;
612 if (cond_excl == 0)
613 cond_excl = cond_depth;
614 }
615 }
616 continue;
617 }
618
619 /* fprintf(stderr, "%d %s\n", cond_excl, line); */
620
621 /****************************************************
622 *
623 * Only carry on if this section is intended for us
624 *
625 ****************************************************/
626
627 if (cond_excl != 0) {
628 continue;
629 }
630
631 /* ------- starts a section ------------ */
632
633 else if (line[0] == '[')
634 {
635 read_mode = SH_SECTION_NONE;
636
637 if (0 == sl_strncasecmp (line, _("[EOF]"), 5)) {
638 goto nopel;
639 }
640
641 i = 0;
642
643 while (tab_ListSections[i].name != 0)
644 {
645 if (sl_strncasecmp (line, _(tab_ListSections[i].name),
646 sl_strlen(tab_ListSections[i].name)) == 0)
647 {
648 read_mode = tab_ListSections[i].type;
649 break;
650 }
651 ++i;
652 }
653
654#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
655 if (read_mode == SH_SECTION_NONE)
656 {
657 for (modnum = 0; modList[modnum].name != NULL; ++modnum)
658 {
659 if (0 == sl_strncasecmp (line, _(modList[modnum].conf_section),
660 sl_strlen(modList[modnum].conf_section)) )
661 read_mode = SH_SECTION_OTHER;
662 }
663 }
664#endif
665 if (read_mode == SH_SECTION_NONE)
666 {
667 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALHEAD,
668 (long) conf_line);
669 }
670 }
671
672 /* --- an %schedule directive ------------ */
673
674 else if (line[0] == '%' || (line[0] == '!' && line[1] == '%'))
675 {
676#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
677 if (line[0] == '!' && 0 == sl_strcasecmp(&(line[2]), _("SCHEDULE_TWO")))
678 set_dirList(1);
679 else if (0 == sl_strcasecmp(&(line[1]), _("SCHEDULE_TWO")))
680 set_dirList(2);
681#else
682 ;
683#endif
684 }
685
686 /* ------ no new section -------------- */
687
688
689 else if (read_mode != SH_SECTION_NONE)
690 {
691 if (0 != sh_readconfig_line (line))
692 {
693 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALCONF,
694 (long) conf_line);
695 }
696 }
697 } /* while getline() */
698
699 nopel:
700
701 if (0 != cond_depth)
702 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALDD,
703 _("config file"),
704 (long) conf_line);
705
706 sl_close (fd);
707
708 sh_error_fixup();
709
710 read_mode = SH_SECTION_NONE; /* reset b/o sighup reload */
711
712 SH_FREE(line_in);
713 SL_RETURN( 0, _("sh_readconf_read"));
714}
715
716int sh_readconf_set_path (char * which, const char * what)
717{
718 int len;
719 SL_ENTER( _("sh_readconf_set_path"));
720
721 if (which == NULL || what == NULL)
722 {
723 TPT((0, FIL__, __LINE__ , _("msg=<Input error>\n")));
724 SL_RETURN( -1, _("sh_readconf_set_path"));
725 }
726
727 if (0 == sl_strcmp(what, _("AUTO")))
728 {
729 len = sl_strlen(which);
730 if ( (len + sl_strlen(sh.host.name) + 2) > SH_PATHBUF)
731 {
732 TPT((0, FIL__, __LINE__ , _("msg=<Path too large: %s:%s>\n"),
733 which, sh.host.name));
734 SL_RETURN( -1, _("sh_readconf_set_path"));
735 }
736 else
737 {
738 which[len] = ':'; which[len+1] = '\0';
739 sl_strlcat(which, sh.host.name, SH_PATHBUF);
740 }
741 }
742 else /* not auto */
743 {
744 if (sl_strlen(what) > (SH_PATHBUF-1))
745 {
746 TPT((0, FIL__, __LINE__ , _("msg=<Path too large: %s>\n"), what));
747 SL_RETURN( -1, _("sh_readconf_set_path"));
748 }
749 else
750 {
751 sl_strlcpy(which, what, SH_PATHBUF);
752 }
753 }
754 SL_RETURN( 0, _("sh_readconf_set_path"));
755}
756
757int sh_readconf_set_database_path (const char * what)
758{
759 return (sh_readconf_set_path(sh.data.path, what));
760}
761
762int sh_readconf_set_logfile_path (const char * what)
763{
764 return (sh_readconf_set_path(sh.srvlog.name, what));
765}
766
767int sh_readconf_set_lockfile_path (const char * what)
768{
769 return( sh_readconf_set_path(sh.srvlog.alt, what));
770}
771
772
773
774
775typedef enum {
776 SET_MAILTIME,
777 SET_FILETIME
778} ShTimerItem;
779
780
781int sh_readconf_setTime (const char * str, ShTimerItem what)
782{
783 unsigned long i = atoi (str);
784
785 SL_ENTER( _("sh_readconf_setTime"));
786
787 if (i < LONG_MAX)
788 {
789 if (what == SET_MAILTIME)
790 {
791 TPT((0, FIL__, __LINE__, _("msg=<Set mail timer to %ld>\n"), i));
792 sh.mailTime.alarm_interval = i;
793 }
794 else if (what == SET_FILETIME)
795 {
796 TPT((0, FIL__, __LINE__, _("msg=<Set filecheck timer to %ld>\n"),i));
797 sh.fileCheck.alarm_interval = i;
798 }
799
800 SL_RETURN( 0, _("sh_readconf_setTime"));
801 }
802 else
803 {
804 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALL,
805 _("set timer"), (long) i);
806 SL_RETURN( (-1), _("sh_readconf_setTime"));
807 }
808}
809
810int sh_readconf_setMailtime (const char * c)
811{
812 return sh_readconf_setTime (c, SET_MAILTIME);
813}
814
815int sh_readconf_setFiletime (const char * c)
816{
817 return sh_readconf_setTime (c, SET_FILETIME);
818}
819
820int sh_readconf_set_nice (const char * c)
821{
822 long val;
823
824 SL_ENTER(_("sh_readconf_set_nice"));
825
826 val = strtol (c, (char **)NULL, 10);
827 if (val < -20 || val > 20)
828 {
829 SL_RETURN((-1), _("sh_readconf_set_nice"));
830 }
831
832 val = (val < -19 ? -19 : val);
833 val = (val > 19 ? 19 : val);
834
835 sh.flag.nice = val;
836 SL_RETURN((0), _("sh_readconf_set_nice"));
837}
838
839
840#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
841static int sh_readconf_set_delay (const char * c)
842{
843 unsigned long i = atol (c);
844
845 if (i > INT_MAX)
846 return -i;
847 sh.delayload = (int) i;
848 return 0;
849}
850#endif
851
852#ifdef FANCY_LIBCAP
853int sh_readconf_setCaps(const char * c)
854{
855 int i;
856 SL_ENTER(_("sh_readconf_setCaps"));
857
858 i = sh_util_flagval(c, &sl_useCaps);
859 SL_RETURN((i), _("sh_readconf_setCaps"));
860}
861#endif
862
863typedef struct _cfg_options {
864 const char * optname;
865 ShSectionType section;
866 ShSectionType alt_section;
867 int (*func)(const char * opt);
868} cfg_options;
869
870#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
871extern int sh_set_schedule_one(const char * str);
872extern int sh_set_schedule_two(const char * str);
873extern int sh_set_silent_full (const char * str);
874#endif
875#if defined (SH_WITH_SERVER)
876extern int sh_socket_use (const char * c);
877extern int sh_socket_uid (const char * c);
878extern int sh_socket_password (const char * c);
879#endif
880
881cfg_options ext_table[] = {
882#if defined(WITH_EXTERNAL)
883 { N_("opencommand"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
884 sh_ext_setcommand },
885 { N_("closecommand"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
886 sh_ext_close_command },
887 { N_("setcommandline"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
888 sh_ext_add_argv },
889 { N_("setchecksum"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
890 sh_ext_checksum },
891 { N_("setdefault"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
892 sh_ext_add_default },
893 { N_("setenviron"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
894 sh_ext_add_environ },
895 { N_("setdeadtime"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
896 sh_ext_deadtime },
897 { N_("settype"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
898 sh_ext_type },
899 { N_("setcredentials"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
900 sh_ext_priv },
901 { N_("setfilternot"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
902 sh_ext_add_not },
903 { N_("setfilterand"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
904 sh_ext_add_and },
905 { N_("setfilteror"), SH_SECTION_EXTERNAL, SH_SECTION_NONE,
906 sh_ext_add_or },
907 { N_("externalseverity"),SH_SECTION_LOG, SH_SECTION_EXTERNAL,
908 sh_error_set_external },
909 { N_("externalclass"), SH_SECTION_LOG, SH_SECTION_EXTERNAL,
910 sh_error_external_mask },
911#endif
912
913#if defined(WITH_DATABASE)
914 { N_("usepersistent"), SH_SECTION_DATABASE, SH_SECTION_NONE,
915 sh_database_use_persistent },
916 { N_("setdbname"), SH_SECTION_DATABASE, SH_SECTION_NONE,
917 sh_database_set_database },
918 { N_("setdbtable"), SH_SECTION_DATABASE, SH_SECTION_NONE,
919 sh_database_set_table },
920 { N_("setdbhost"), SH_SECTION_DATABASE, SH_SECTION_NONE,
921 sh_database_set_host },
922 { N_("setdbuser"), SH_SECTION_DATABASE, SH_SECTION_NONE,
923 sh_database_set_user },
924 { N_("setdbpassword"), SH_SECTION_DATABASE, SH_SECTION_NONE,
925 sh_database_set_password },
926 { N_("addtodbhash"), SH_SECTION_DATABASE, SH_SECTION_NONE,
927 sh_database_add_to_hash },
928 { N_("databaseseverity"),SH_SECTION_LOG, SH_SECTION_DATABASE,
929 sh_error_set_database },
930 { N_("databaseclass"), SH_SECTION_LOG, SH_SECTION_DATABASE,
931 sh_error_database_mask },
932 { N_("setdbservertstamp"), SH_SECTION_DATABASE, SH_SECTION_NONE,
933 set_enter_wrapper },
934#endif
935
936
937#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
938 { N_("dir"), SH_SECTION_ATTRIBUTES, SH_SECTION_NONE,
939 sh_files_pushdir_attr },
940 { N_("file"), SH_SECTION_ATTRIBUTES, SH_SECTION_NONE,
941 sh_files_pushfile_attr },
942 { N_("dir"), SH_SECTION_READONLY, SH_SECTION_NONE,
943 sh_files_pushdir_ro },
944 { N_("file"), SH_SECTION_READONLY, SH_SECTION_NONE,
945 sh_files_pushfile_ro },
946 { N_("dir"), SH_SECTION_LOGFILES, SH_SECTION_NONE,
947 sh_files_pushdir_log },
948 { N_("file"), SH_SECTION_LOGFILES, SH_SECTION_NONE,
949 sh_files_pushfile_log },
950 { N_("dir"), SH_SECTION_LOGGROW, SH_SECTION_NONE,
951 sh_files_pushdir_glog },
952 { N_("file"), SH_SECTION_LOGGROW, SH_SECTION_NONE,
953 sh_files_pushfile_glog },
954 { N_("dir"), SH_SECTION_NOIGNORE, SH_SECTION_NONE,
955 sh_files_pushdir_noig },
956 { N_("file"), SH_SECTION_NOIGNORE, SH_SECTION_NONE,
957 sh_files_pushfile_noig },
958 { N_("dir"), SH_SECTION_ALLIGNORE, SH_SECTION_NONE,
959 sh_files_pushdir_allig },
960 { N_("file"), SH_SECTION_ALLIGNORE, SH_SECTION_NONE,
961 sh_files_pushfile_allig },
962
963 { N_("dir"), SH_SECTION_USER0, SH_SECTION_NONE,
964 sh_files_pushdir_user0 },
965 { N_("file"), SH_SECTION_USER0, SH_SECTION_NONE,
966 sh_files_pushfile_user0 },
967 { N_("dir"), SH_SECTION_USER1, SH_SECTION_NONE,
968 sh_files_pushdir_user1 },
969 { N_("file"), SH_SECTION_USER1, SH_SECTION_NONE,
970 sh_files_pushfile_user1 },
971 { N_("dir"), SH_SECTION_USER2, SH_SECTION_NONE,
972 sh_files_pushdir_user2 },
973 { N_("file"), SH_SECTION_USER2, SH_SECTION_NONE,
974 sh_files_pushfile_user2 },
975 { N_("dir"), SH_SECTION_USER3, SH_SECTION_NONE,
976 sh_files_pushdir_user3 },
977 { N_("file"), SH_SECTION_USER3, SH_SECTION_NONE,
978 sh_files_pushfile_user3 },
979 { N_("dir"), SH_SECTION_USER4, SH_SECTION_NONE,
980 sh_files_pushdir_user4 },
981 { N_("file"), SH_SECTION_USER4, SH_SECTION_NONE,
982 sh_files_pushfile_user4 },
983 { N_("dir"), SH_SECTION_PRELINK, SH_SECTION_NONE,
984 sh_files_pushdir_prelink },
985 { N_("file"), SH_SECTION_PRELINK, SH_SECTION_NONE,
986 sh_files_pushfile_prelink },
987
988 { N_("ignoreadded"), SH_SECTION_MISC, SH_SECTION_NONE,
989 sh_ignore_add_new },
990 { N_("ignoremissing"), SH_SECTION_MISC, SH_SECTION_NONE,
991 sh_ignore_add_del },
992 { N_("ignoremodified"), SH_SECTION_MISC, SH_SECTION_NONE,
993 sh_ignore_add_mod },
994
995 { N_("skipchecksum"), SH_SECTION_MISC, SH_SECTION_NONE,
996 sh_restrict_define },
997 { N_("filetype"), SH_SECTION_MISC, SH_SECTION_NONE,
998 sh_restrict_add_ftype },
999
1000
1001 { N_("filecheckscheduleone"), SH_SECTION_MISC, SH_SECTION_NONE,
1002 sh_set_schedule_one },
1003 { N_("filecheckscheduletwo"), SH_SECTION_MISC, SH_SECTION_NONE,
1004 sh_set_schedule_two },
1005
1006 { N_("usehardlinkcheck"), SH_SECTION_MISC, SH_SECTION_NONE,
1007 sh_files_check_hardlinks },
1008 { N_("usersrccheck"), SH_SECTION_MISC, SH_SECTION_NONE,
1009 sh_files_use_rsrc },
1010 { N_("hardlinkoffset"), SH_SECTION_MISC, SH_SECTION_NONE,
1011 sh_files_hle_reg },
1012#if defined(USE_XATTR)
1013 { N_("useselinuxcheck"), SH_SECTION_MISC, SH_SECTION_NONE,
1014 sh_unix_setcheckselinux },
1015#endif
1016#if defined(USE_ACL)
1017 { N_("useaclcheck"), SH_SECTION_MISC, SH_SECTION_NONE,
1018 sh_unix_setcheckacl },
1019#endif
1020#if !defined(SH_COMPILE_STATIC) && defined(__linux__) && defined(HAVE_AUPARSE_H) && defined(HAVE_AUPARSE_LIB)
1021 { N_("setauditdflags"), SH_SECTION_MISC, SH_SECTION_NONE,
1022 sh_audit_set_flags },
1023#endif
1024 { N_("loosedircheck"), SH_SECTION_MISC, SH_SECTION_NONE,
1025 sh_hash_loosedircheck },
1026 { N_("addokchars"), SH_SECTION_MISC, SH_SECTION_NONE,
1027 sh_util_obscure_ok },
1028 { N_("filenamesareutf8"), SH_SECTION_MISC, SH_SECTION_NONE,
1029 sh_util_obscure_utf8 },
1030 { N_("setrecursionlevel"), SH_SECTION_MISC, SH_SECTION_NONE,
1031 sh_files_setrecursion },
1032 { N_("checksumtest"), SH_SECTION_MISC, SH_SECTION_NONE,
1033 sh_util_setchecksum },
1034 { N_("reportonlyonce"), SH_SECTION_MISC, SH_SECTION_NONE,
1035 sh_files_reportonce },
1036 { N_("reportfulldetail"), SH_SECTION_MISC, SH_SECTION_NONE,
1037 sh_files_fulldetail },
1038 { N_("uselocaltime"), SH_SECTION_MISC, SH_SECTION_NONE,
1039 sh_unix_uselocaltime },
1040
1041 { N_("setnicelevel"), SH_SECTION_MISC, SH_SECTION_NONE,
1042 sh_readconf_set_nice },
1043
1044 { N_("startuploaddelay"), SH_SECTION_MISC, SH_SECTION_NONE,
1045 sh_readconf_set_delay },
1046
1047#if defined(FANCY_LIBCAP)
1048 { N_("usecaps"), SH_SECTION_MISC, SH_SECTION_NONE,
1049 sh_readconf_setCaps },
1050#endif
1051
1052 { N_("reportcheckflags"), SH_SECTION_MISC, SH_SECTION_NONE,
1053 set_report_checkflags },
1054
1055 { N_("setdropcache"), SH_SECTION_MISC, SH_SECTION_NONE,
1056 sl_set_drop_cache },
1057
1058 { N_("setiolimit"), SH_SECTION_MISC, SH_SECTION_NONE,
1059 sh_unix_set_io_limit },
1060
1061 { N_("versionstring"), SH_SECTION_MISC, SH_SECTION_NONE,
1062 sh_dbIO_version_string },
1063
1064 { N_("digestalgo"), SH_SECTION_MISC, SH_SECTION_NONE,
1065 sh_tiger_hashtype },
1066
1067 { N_("redefreadonly"), SH_SECTION_MISC, SH_SECTION_NONE,
1068 sh_files_redef_readonly },
1069
1070 { N_("redeflogfiles"), SH_SECTION_MISC, SH_SECTION_NONE,
1071 sh_files_redef_logfiles },
1072
1073 { N_("redefgrowinglogfiles"), SH_SECTION_MISC, SH_SECTION_NONE,
1074 sh_files_redef_loggrow },
1075
1076 { N_("redefattributes"), SH_SECTION_MISC, SH_SECTION_NONE,
1077 sh_files_redef_attributes },
1078
1079 { N_("redefignorenone"), SH_SECTION_MISC, SH_SECTION_NONE,
1080 sh_files_redef_noignore },
1081
1082 { N_("redefignoreall"), SH_SECTION_MISC, SH_SECTION_NONE,
1083 sh_files_redef_allignore },
1084
1085 { N_("redefuser0"), SH_SECTION_MISC, SH_SECTION_NONE,
1086 sh_files_redef_user0 },
1087
1088 { N_("redefuser1"), SH_SECTION_MISC, SH_SECTION_NONE,
1089 sh_files_redef_user1 },
1090
1091 { N_("redefuser2"), SH_SECTION_MISC, SH_SECTION_NONE,
1092 sh_files_redef_user2 },
1093
1094 { N_("redefuser3"), SH_SECTION_MISC, SH_SECTION_NONE,
1095 sh_files_redef_user3 },
1096
1097 { N_("redefuser4"), SH_SECTION_MISC, SH_SECTION_NONE,
1098 sh_files_redef_user4 },
1099
1100 { N_("redefprelink"), SH_SECTION_MISC, SH_SECTION_NONE,
1101 sh_files_redef_prelink },
1102
1103
1104 { N_("setprelinkpath"), SH_SECTION_MISC, SH_SECTION_NONE,
1105 sh_prelink_set_path },
1106 { N_("setprelinkchecksum"), SH_SECTION_MISC, SH_SECTION_NONE,
1107 sh_prelink_set_hash },
1108
1109 { N_("setfullsilent"), SH_SECTION_MISC, SH_SECTION_NONE,
1110 sh_set_silent_full },
1111
1112 /* client or standalone
1113 */
1114#endif
1115
1116#ifdef SH_WITH_SERVER
1117#ifdef INET_SYSLOG
1118 { N_("setudpactive"), SH_SECTION_SRV, SH_SECTION_MISC,
1119 set_syslog_active },
1120#endif
1121 { N_("setusesocket"), SH_SECTION_SRV, SH_SECTION_MISC,
1122 sh_socket_use },
1123 { N_("setsocketallowuid"), SH_SECTION_SRV, SH_SECTION_MISC,
1124 sh_socket_uid },
1125 { N_("setsocketpassword"), SH_SECTION_SRV, SH_SECTION_MISC,
1126 sh_socket_password },
1127 { N_("setstripdomain"), SH_SECTION_SRV, SH_SECTION_MISC,
1128 sh_xfer_set_strip },
1129 { N_("useseparatelogs"), SH_SECTION_SRV, SH_SECTION_MISC,
1130 set_flag_sep_log },
1131 { N_("setchrootdir"), SH_SECTION_SRV, SH_SECTION_MISC,
1132 sh_unix_set_chroot },
1133 { N_("setclienttimelimit"), SH_SECTION_SRV, SH_SECTION_MISC,
1134 sh_xfer_set_time_limit },
1135 { N_("setconnectiontimeout"),SH_SECTION_SRV, SH_SECTION_MISC,
1136 sh_xfer_set_timeout },
1137 { N_("useclientseverity"), SH_SECTION_SRV, SH_SECTION_MISC,
1138 sh_xfer_use_clt_sev },
1139 { N_("useclientclass"), SH_SECTION_SRV, SH_SECTION_MISC,
1140 sh_xfer_use_clt_class },
1141 { N_("severitylookup"), SH_SECTION_SRV, SH_SECTION_MISC,
1142 sh_xfer_lookup_level },
1143 { N_("setclientfromaccept"), SH_SECTION_SRV, SH_SECTION_MISC,
1144 set_socket_peer },
1145 { N_("setserverport"), SH_SECTION_SRV, SH_SECTION_MISC,
1146 sh_xfer_set_port },
1147 { N_("setserverinterface"), SH_SECTION_SRV, SH_SECTION_MISC,
1148 sh_xfer_set_interface },
1149 { N_("client"), SH_SECTION_CLIENTS, SH_SECTION_NONE,
1150 sh_xfer_register_client },
1151#endif
1152
1153#if defined(SH_WITH_CLIENT) || defined(SH_WITH_SERVER)
1154 { N_("exportseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1155 sh_error_setexport },
1156 { N_("exportclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1157 sh_error_export_mask },
1158#if defined(SH_WITH_SERVER)
1159 { N_("setlogserver"), SH_SECTION_SRV, SH_SECTION_MISC,
1160 sh_xfer_set_logserver },
1161#else
1162 { N_("setlogserver"), SH_SECTION_CLT, SH_SECTION_MISC,
1163 sh_xfer_set_logserver },
1164 { N_("setthrottle"), SH_SECTION_CLT, SH_SECTION_MISC,
1165 sh_xfer_set_throttle_delay},
1166 { N_("setdeltaretrycount"), SH_SECTION_CLT, SH_SECTION_MISC,
1167 set_delta_retry_count},
1168 { N_("setdeltaretryinterval"),SH_SECTION_CLT, SH_SECTION_MISC,
1169 set_delta_retry_interval},
1170#endif
1171#endif
1172 { N_("setfilechecktime"), SH_SECTION_MISC, SH_SECTION_NONE,
1173 sh_readconf_setFiletime },
1174 { N_("setlooptime"), SH_SECTION_MISC, SH_SECTION_NONE,
1175 sh_util_setlooptime },
1176
1177#ifdef SH_WITH_MAIL
1178 { N_("mailseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1179 sh_error_setseverity },
1180 { N_("mailclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1181 sh_error_mail_mask },
1182 { N_("setmailtime"), SH_SECTION_MAIL, SH_SECTION_MISC,
1183 sh_readconf_setMailtime },
1184 { N_("setmailnum"), SH_SECTION_MAIL, SH_SECTION_MISC,
1185 sh_mail_setNum },
1186 { N_("setmailrelay"), SH_SECTION_MAIL, SH_SECTION_MISC,
1187 sh_mail_set_relay },
1188 { N_("setmailport"), SH_SECTION_MAIL, SH_SECTION_MISC,
1189 sh_mail_set_port },
1190 { N_("mailsingle"), SH_SECTION_MAIL, SH_SECTION_MISC,
1191 sh_mail_setFlag },
1192 { N_("mailsubject"), SH_SECTION_MAIL, SH_SECTION_MISC,
1193 set_mail_subject },
1194 { N_("setmailsender"), SH_SECTION_MAIL, SH_SECTION_MISC,
1195 sh_mail_set_sender },
1196 { N_("setmailalias"), SH_SECTION_MAIL, SH_SECTION_MISC,
1197 sh_nmail_add_alias },
1198 { N_("setmailaddress"), SH_SECTION_MAIL, SH_SECTION_MISC,
1199 sh_nmail_add_recipient },
1200 { N_("closeaddress"), SH_SECTION_MAIL, SH_SECTION_MISC,
1201 sh_nmail_close_recipient },
1202 { N_("setaddrseverity"), SH_SECTION_MAIL, SH_SECTION_MISC,
1203 sh_nmail_set_severity },
1204 { N_("setmailfilternot"), SH_SECTION_MAIL, SH_SECTION_MISC,
1205 sh_nmail_add_not },
1206 { N_("setmailfilterand"), SH_SECTION_MAIL, SH_SECTION_MISC,
1207 sh_nmail_add_and },
1208 { N_("setmailfilteror"), SH_SECTION_MAIL, SH_SECTION_MISC,
1209 sh_nmail_add_or },
1210#endif
1211 { N_("setbindaddress"), SH_SECTION_MISC, SH_SECTION_NONE,
1212 sh_calls_set_bind_addr },
1213 { N_("daemon"), SH_SECTION_MISC, SH_SECTION_NONE,
1214 sh_unix_setdeamon },
1215 { N_("samhainpath"), SH_SECTION_MISC, SH_SECTION_NONE,
1216 sh_unix_self_hash },
1217 { N_("trusteduser"), SH_SECTION_MISC, SH_SECTION_NONE,
1218 tf_add_trusted_user },
1219 { N_("settimeserver"), SH_SECTION_MISC, SH_SECTION_NONE,
1220 sh_unix_settimeserver },
1221
1222 { N_("printseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1223 sh_error_setprint },
1224 { N_("printclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1225 sh_error_print_mask },
1226
1227 { N_("logseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1228 sh_error_setlog },
1229 { N_("logclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1230 sh_error_log_mask },
1231
1232 { N_("syslogseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1233 sh_error_set_syslog },
1234 { N_("syslogclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1235 sh_error_syslog_mask },
1236#ifdef HAVE_LIBPRELUDE
1237 { N_("preludeseverity"), SH_SECTION_LOG, SH_SECTION_NONE,
1238 sh_error_set_prelude },
1239 { N_("preludeclass"), SH_SECTION_LOG, SH_SECTION_NONE,
1240 sh_error_prelude_mask },
1241 { N_("preludeprofile"), SH_SECTION_MISC, SH_SECTION_NONE,
1242 sh_prelude_set_profile },
1243 { N_("preludemaptoinfo"), SH_SECTION_MISC, SH_SECTION_NONE,
1244 sh_prelude_map_info },
1245 { N_("preludemaptolow"), SH_SECTION_MISC, SH_SECTION_NONE,
1246 sh_prelude_map_low },
1247 { N_("preludemaptomedium"), SH_SECTION_MISC, SH_SECTION_NONE,
1248 sh_prelude_map_medium },
1249 { N_("preludemaptohigh"), SH_SECTION_MISC, SH_SECTION_NONE,
1250 sh_prelude_map_high },
1251#endif
1252
1253 { N_("logcalls"), SH_SECTION_LOG, SH_SECTION_NONE,
1254 sh_aud_set_functions },
1255
1256 { N_("messageheader"), SH_SECTION_MISC, SH_SECTION_NONE,
1257 sh_error_ehead },
1258
1259 { N_("setconsole"), SH_SECTION_MISC, SH_SECTION_NONE,
1260 sh_log_set_console },
1261
1262 { N_("setreportfile"), SH_SECTION_MISC, SH_SECTION_NONE,
1263 sh_efile_path },
1264 { N_("setreportgroup"), SH_SECTION_MISC, SH_SECTION_NONE,
1265 sh_efile_group },
1266
1267#ifdef WITH_MESSAGE_QUEUE
1268 { N_("messagequeueactive"),SH_SECTION_MISC, SH_SECTION_NONE,
1269 enable_msgq },
1270#endif
1271
1272 { N_("setreverselookup"), SH_SECTION_MISC, SH_SECTION_NONE,
1273 set_reverse_lookup },
1274
1275 { N_("setdatabasepath"), SH_SECTION_MISC, SH_SECTION_NONE,
1276 sh_readconf_set_database_path },
1277
1278 { N_("setlogfilepath"), SH_SECTION_MISC, SH_SECTION_NONE,
1279 sh_readconf_set_logfile_path },
1280
1281 { N_("setlockfilepath"), SH_SECTION_MISC, SH_SECTION_NONE,
1282 sh_readconf_set_lockfile_path },
1283
1284 { N_("hidesetup"), SH_SECTION_MISC, SH_SECTION_NONE,
1285 sh_util_hidesetup },
1286
1287 { N_("syslogfacility"), SH_SECTION_LOG, SH_SECTION_MISC,
1288 sh_log_set_facility },
1289
1290 { N_("syslogmapstampto"), SH_SECTION_LOG, SH_SECTION_MISC,
1291 sh_log_set_stamp_priority },
1292
1293 { N_("mactype"), SH_SECTION_MISC, SH_SECTION_NONE,
1294 sh_util_sigtype },
1295
1296 { N_("avoidblock"), SH_SECTION_MISC, SH_SECTION_NONE,
1297 sh_calls_set_sub },
1298
1299#ifdef SCREW_IT_UP
1300 { N_("setsigtrapmaxduration"), SH_SECTION_MISC, SH_SECTION_MISC,
1301 sh_sigtrap_max_duration_set },
1302#endif
1303
1304 { NULL, 0, 0, NULL}
1305};
1306
1307
1308
1309
1310static int sh_readconfig_line (char * line)
1311{
1312 char * key;
1313 const char * value;
1314 char * value_dup;
1315 char * tmp;
1316 int i;
1317 int good_opt = -1;
1318
1319#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1320 int modnum, modkey;
1321#endif
1322
1323 static const char *dummy = N_("dummy");
1324
1325 static const char *closing[] = {
1326 N_("closecommand"),
1327 N_("closeaddress"),
1328 N_("logmonendgroup"),
1329 N_("logmonendhost"),
1330 NULL
1331 };
1332
1333 static const char *ident[] = {
1334 N_("severityreadonly"),
1335 N_("severitylogfiles"),
1336 N_("severitygrowinglogs"),
1337 N_("severityignorenone"),
1338 N_("severityignoreall"),
1339 N_("severityattributes"),
1340 N_("severitydirs"),
1341 N_("severityfiles"),
1342 N_("severitynames"),
1343 N_("severityuser0"),
1344 N_("severityuser1"),
1345 N_("severityuser2"),
1346 N_("severityuser3"),
1347 N_("severityuser4"),
1348 N_("severityprelink"),
1349 NULL
1350 };
1351
1352 static int identnum[] = {
1353 SH_ERR_T_RO,
1354 SH_ERR_T_LOGS,
1355 SH_ERR_T_GLOG,
1356 SH_ERR_T_NOIG,
1357 SH_ERR_T_ALLIG,
1358 SH_ERR_T_ATTR,
1359 SH_ERR_T_DIR,
1360 SH_ERR_T_FILE,
1361 SH_ERR_T_NAME,
1362 SH_ERR_T_USER0,
1363 SH_ERR_T_USER1,
1364 SH_ERR_T_USER2,
1365 SH_ERR_T_USER3,
1366 SH_ERR_T_USER4,
1367 SH_ERR_T_PRELINK,
1368 };
1369
1370 SL_ENTER(_("sh_readconf_line"));
1371
1372 /* convert to lowercase */
1373
1374 tmp = line;
1375 while (*tmp != '=' && *tmp != '\0')
1376 {
1377 *tmp = tolower( (int) *tmp);
1378 ++tmp;
1379 }
1380
1381 key = line;
1382
1383 /* interpret line */
1384
1385 value = strchr(line, '=');
1386
1387 if (value == NULL || (*value) == '\0')
1388 {
1389 if (key != NULL)
1390 {
1391 i = 0;
1392 while (closing[i] != NULL)
1393 {
1394 if (sl_strncmp(key,_(closing[i]),sl_strlen(closing[i])-1) == 0)
1395 {
1396 value = dummy;
1397 goto ok_novalue;
1398 }
1399 ++i;
1400 }
1401
1402 TPT(( 0, FIL__, __LINE__, _("msg=<ConfigFile: not key=value: %s>\n"),
1403 line));
1404 }
1405 SL_RETURN(good_opt, _("sh_readconf_line"));
1406 }
1407 else
1408 ++value;
1409
1410 /* skip leading whitespace
1411 */
1412 while ((*value) == ' ' || (*value) == '\t')
1413 ++value;
1414
1415 if ((*value) == '\0') /* no value */
1416 {
1417 if (key != NULL)
1418 {
1419 TPT(( 0, FIL__, __LINE__, _("msg=<ConfigFile: not key=value: %s>\n"),
1420 line));
1421 }
1422 SL_RETURN(good_opt, _("sh_readconf_line"));
1423 }
1424
1425 ok_novalue:
1426
1427 if (!sl_is_suid())
1428 {
1429 TPT(( 0, FIL__, __LINE__, _("msg=<ConfigFile: %s>\n"), line));
1430 }
1431
1432 /* Expand shell expressions. This return allocated memory which we must free.
1433 * If !defined(SH_EVAL_SHELL), this will reduce to a strdup.
1434 */
1435 value_dup = sh_readconf_expand_value(value);
1436
1437 if (!value_dup || (*value_dup) == '\0')
1438 {
1439 TPT(( 0, FIL__, __LINE__,
1440 _("msg=<ConfigFile: empty after shell expansion: %s>\n"),
1441 line));
1442 SL_RETURN(good_opt, _("sh_readconf_line"));
1443 }
1444
1445 value = value_dup;
1446
1447#if defined (SH_WITH_CLIENT) || defined (SH_STANDALONE)
1448 if (read_mode == SH_SECTION_OTHER)
1449 {
1450 for (modnum = 0; modList[modnum].name != NULL; ++modnum)
1451 {
1452 for (modkey = 0; modList[modnum].conf_table[modkey].the_opt != NULL;
1453 ++modkey)
1454 {
1455 if (sl_strncmp (key,
1456 _(modList[modnum].conf_table[modkey].the_opt),
1457 sl_strlen(modList[modnum].conf_table[modkey].the_opt) ) == 0)
1458 {
1459 good_opt = 0;
1460 if (0 != modList[modnum].conf_table[modkey].func(value))
1461 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALS,
1462 _(modList[modnum].conf_table[modkey].the_opt), value);
1463 if (!sl_is_suid())
1464 {
1465 TPT(( 0, FIL__, __LINE__,
1466 _("msg=<line = %s, option = %s>\n"), line,
1467 _(modList[modnum].conf_table[modkey].the_opt)));
1468 }
1469 goto outburst;
1470 }
1471 }
1472 }
1473 }
1474 outburst:
1475#endif
1476
1477
1478 if (read_mode == SH_SECTION_THRESHOLD)
1479 {
1480 i = 0;
1481 while (ident[i] != NULL) {
1482 if (sl_strncmp (key, _(ident[i]), sl_strlen(ident[i])) == 0)
1483 {
1484 good_opt = 0;
1485 sh_error_set_iv (identnum[i], value);
1486 break;
1487 }
1488 ++i;
1489 }
1490 }
1491 else
1492 {
1493 i = 0;
1494 while (ext_table[i].optname != NULL)
1495 {
1496 if ((ext_table[i].section == read_mode ||
1497 ext_table[i].alt_section == read_mode) &&
1498 sl_strncmp (key, _(ext_table[i].optname),
1499 sl_strlen(ext_table[i].optname)) == 0)
1500 {
1501 good_opt = 0;
1502 if (0 != ext_table[i].func (value))
1503 sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_EINVALS,
1504 _(ext_table[i].optname), value);
1505 break;
1506 }
1507 ++i;
1508 }
1509 }
1510
1511 SH_FREE(value_dup);
1512
1513 SL_RETURN(good_opt, _("sh_readconf_line"));
1514}
1515
1516
Note: See TracBrowser for help on using the repository browser.