source: trunk/src/sh_readconf.c@ 448

Last change on this file since 448 was 432, checked in by katerina, 12 years ago

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