Context Navigation

source: trunk/src/sh_error.c@ 499

Last change on this file since 499 was 488, checked in by katerina, 9 years ago
Fix for tickets #386 (silent check) and #387 (linux audit support).
File size: 42.9 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	/* Required on Linux to get the correct strerror_r function. Also
23	* for recursive mutexes (_XOPEN_SOURCE >= 500). Gives funny error
24	* on Solaris 10/gcc ('c99' compiler required - huh? Isn't gcc
25	* good enough?).
26	*/
27	#if !defined(__sun__) && !defined(__sun)
28	#define _XOPEN_SOURCE 600
29	#undef _GNU_SOURCE
30	#endif
31	#include <string.h>
32	#include <stdio.h>
33	#include <stdlib.h>
34	#include <stdarg.h>
35	#include <ctype.h>
36	#include <limits.h>
37	#include <errno.h>
38
39	/* Required on FreeBSD
40	*/
41	#include <sys/types.h>
42
43	#ifdef HAVE_MEMORY_H
44	#include <memory.h>
45	#endif
46
47	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
48	#include <sys/mman.h>
49	#endif
50
51
52
53	#include "samhain.h"
54
55	#include "sh_cat.h"
56	#include "sh_database.h"
57	#include "sh_error.h"
58	#include "sh_utils.h"
59	#include "sh_unix.h"
60	#include "sh_tiger.h"
61	#include "sh_nmail.h"
62	#include "sh_xfer.h"
63	#include "sh_prelude.h"
64	#include "sh_pthread.h"
65
66	#if defined(WITH_DATABASE)
67	#include "sh_tools.h"
68	#endif
69
70	#if defined(WITH_EXTERNAL)
71	#include "sh_extern.h"
72	#endif
73
74	#undef FIL__
75	#define FIL__ _("sh_error.c")
76	/@-noret -compmempass@/
77	extern int clt_class;
78
79	int flag_err_debug = S_FALSE;
80	int flag_err_info = S_FALSE;
81
82	int ShDFLevel[SH_ERR_T_END];
83
84	typedef struct _log_t {
85	char file[SH_PATHBUF];
86	char format[SH_PATHBUF];
87	/@null@/char * msg;
88	size_t msg_len;
89	int severity;
90	int class;
91	int pid;
92	long status;
93	long line;
94	char timestamp[TIM_MAX];
95	} sh_log_t;
96
97
98	struct _errFlags errFlags;
99
100	static int sh_error_init (void);
101
102	inline
103	static const char * get_format(unsigned long msg_id, int * priority,
104	unsigned int * class);
105
106	static int sh_error_string (struct _log_t * lmsg, va_list vl);
107
108	extern int sh_log_console (/@null@/const char *message);
109	extern int sh_log_syslog (int severity, /@null@/char *message);
110	extern int sh_log_file (/@null@/char *message,
111	/@null@/char * inet_peer);
112	/* convert a string to a numeric priority
113	*/
114	int sh_error_convert_level (const char * str_s);
115
116	static int IsInitialized = BAD;
117
118	/* --- Only log to stderr. ---
119	*/
120	int OnlyStderr = S_TRUE;
121
122	/* --- Enable facilities not safe for closeall(). ---
123	*/
124	int enableUnsafe = S_FALSE;
125
126	/*********************************************
127	* utility functions for verifying entries
128	*********************************************/
129
130	int sh_error_verify (const char * s)
131	{
132	char * foo;
133	char hashbuf[KEYBUF_SIZE];
134
135	if (s[0] == '/')
136	{
137	foo = sh_tiger_hash_gpg (s, TIGER_FILE, TIGER_NOLIM);
138	fprintf (stdout, _("%s\n"), foo);
139	SH_FREE(foo);
140	}
141	else
142	{
143	fprintf (stdout, _("string=<%s>, hash=<%s>\n"),
144	s, sh_tiger_hash (s, TIGER_DATA,
145	(unsigned long) sl_strlen(s),
146	hashbuf, sizeof(hashbuf))
147	);
148	}
149	(void) fflush(stdout);
150	_exit (EXIT_SUCCESS);
151	/@i@/return 0;
152	}
153
154
155
156	/*********************************************
157	* end utility functions
158	*********************************************/
159
160	void sh_error_only_stderr (int flag)
161	{
162	OnlyStderr = flag;
163	return;
164	}
165
166	void sh_error_enable_unsafe (int flag)
167	{
168	enableUnsafe = flag;
169	return;
170	}
171
172	static int dbg_store = 0;
173	static int dbg_flag = 0;
174
175	static
176	void compute_flag_err_debug(void)
177	{
178	if ((errFlags.loglevel & SH_ERR_ALL) != 0)
179	flag_err_debug = S_TRUE;
180	else if ((errFlags.printlevel & SH_ERR_ALL) != 0)
181	flag_err_debug = S_TRUE;
182	else if ((errFlags.maillevel & SH_ERR_ALL) != 0)
183	flag_err_debug = S_TRUE;
184	else if ((errFlags.exportlevel & SH_ERR_ALL) != 0)
185	flag_err_debug = S_TRUE;
186	else if ((errFlags.sysloglevel & SH_ERR_ALL) != 0)
187	flag_err_debug = S_TRUE;
188	else if ((errFlags.externallevel & SH_ERR_ALL) != 0)
189	flag_err_debug = S_TRUE;
190	else if ((errFlags.databaselevel & SH_ERR_ALL) != 0)
191	flag_err_debug = S_TRUE;
192	else if ((errFlags.preludelevel & SH_ERR_ALL) != 0)
193	flag_err_debug = S_TRUE;
194	else
195	flag_err_debug = S_FALSE;
196	return;
197	}
198
199	static
200	void compute_flag_err_info(void)
201	{
202	if ((errFlags.loglevel & SH_ERR_INFO) != 0)
203	flag_err_info = S_TRUE;
204	else if ((errFlags.printlevel & SH_ERR_INFO) != 0)
205	flag_err_info = S_TRUE;
206	else if ((errFlags.maillevel & SH_ERR_INFO) != 0)
207	flag_err_info = S_TRUE;
208	else if ((errFlags.exportlevel & SH_ERR_INFO) != 0)
209	flag_err_info = S_TRUE;
210	else if ((errFlags.sysloglevel & SH_ERR_INFO) != 0)
211	flag_err_info = S_TRUE;
212	else if ((errFlags.externallevel & SH_ERR_INFO) != 0)
213	flag_err_info = S_TRUE;
214	else if ((errFlags.databaselevel & SH_ERR_INFO) != 0)
215	flag_err_info = S_TRUE;
216	else if ((errFlags.preludelevel & SH_ERR_INFO) != 0)
217	flag_err_info = S_TRUE;
218	else
219	flag_err_info = S_FALSE;
220	return;
221	}
222
223	void sh_error_dbg_switch(void)
224	{
225	if (dbg_flag == 0)
226	{
227	dbg_store = errFlags.printlevel;
228	errFlags.printlevel = (SH_ERR_ALL \| SH_ERR_INFO \| SH_ERR_NOTICE \|
229	SH_ERR_WARN \| SH_ERR_STAMP \| SH_ERR_ERR \|
230	SH_ERR_SEVERE \| SH_ERR_FATAL);
231	dbg_flag = 1;
232	flag_err_debug = S_TRUE;
233	}
234	else {
235	errFlags.printlevel = dbg_store;
236	dbg_store = 0;
237	dbg_flag = 0;
238	compute_flag_err_debug();
239	}
240	return;
241	}
242
243	static int sh_error_set_classmask (const char * str, int * facility_mask)
244	{
245	char * p;
246	int num = 0;
247	unsigned int i;
248	size_t len;
249	char * c;
250
251	SL_ENTER(_("sh_error_set_classmask"));
252
253	if (str == NULL)
254	SL_RETURN( -1, _("sh_error_set_classmask"));
255
256	if (IsInitialized == BAD)
257	(void) sh_error_init();
258
259	if (str[0] == (char) 34)
260	++str;
261	len = strlen(str);
262
263	c = SH_ALLOC(len+1);
264	sl_strlcpy(c, str, len+1);
265
266	if (c[len-1] == (char) 34)
267	c[len-1] = '\0';
268
269	*facility_mask = 0;
270
271	do {
272	#if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_STRTOK_R)
273	char * saveptr;
274	if (num == 0) {
275	p = strtok_r (c, " ,\t", &saveptr);
276	++num;
277	} else {
278	p = strtok_r (NULL, " ,\t", &saveptr);
279	}
280	#else
281	if (num == 0) {
282	p = strtok (c, " ,\t");
283	++num;
284	} else {
285	p = strtok (NULL, " ,\t");
286	}
287	#endif
288
289	if (p == NULL)
290	break;
291
292	for (i = 0; i < SH_CLA_MAX; ++i)
293	{
294	if (i < SH_CLA_RAW_MAX) {
295	if (0 == strcmp(p, _(class_cat[i])))
296	*facility_mask \|= (1 << i);
297	} else {
298	if (0 == strcmp(p, _(class_cat[SH_CLA_RAW_MAX + 0])))
299	*facility_mask \|= OTHER_CLA;
300	if (0 == strcmp(p, _(class_cat[SH_CLA_RAW_MAX + 1])))
301	*facility_mask \|= RUN_NEW;
302	if (0 == strcmp(p, _(class_cat[SH_CLA_RAW_MAX + 2])))
303	*facility_mask \|= FIL_NEW;
304	if (0 == strcmp(p, _(class_cat[SH_CLA_RAW_MAX + 3])))
305	*facility_mask \|= ERROR_CLA;
306	}
307	}
308
309	} while (p);
310
311	SH_FREE(c);
312	SL_RETURN( 0, _("sh_error_set_classmask"));
313	}
314
315	int sh_error_log_mask (const char * c)
316	{
317	return (sh_error_set_classmask(c, &(errFlags.log_class)));
318	}
319	int sh_error_mail_mask (const char * c)
320	{
321	return (sh_error_set_classmask(c, &(errFlags.mail_class)));
322	}
323	int sh_error_print_mask (const char * c)
324	{
325	return (sh_error_set_classmask(c, &(errFlags.print_class)));
326	}
327	int sh_error_export_mask (const char * c)
328	{
329	return (sh_error_set_classmask(c, &(errFlags.export_class)));
330	}
331	int sh_error_syslog_mask (const char * c)
332	{
333	return (sh_error_set_classmask(c, &(errFlags.syslog_class)));
334	}
335	int sh_error_external_mask (const char * c)
336	{
337	return (sh_error_set_classmask(c, &(errFlags.external_class)));
338	}
339	int sh_error_database_mask (const char * c)
340	{
341	return (sh_error_set_classmask(c, &(errFlags.database_class)));
342	}
343	int sh_error_prelude_mask (const char * c)
344	{
345	return (sh_error_set_classmask(c, &(errFlags.prelude_class)));
346	}
347
348
349
350	char * sh_error_message (int tellme, char * str, size_t len)
351	{
352
353	#if defined(HAVE_STRERROR_R)
354	if (len > 0) str[0] = '\0';
355	strerror_r(tellme, str, len);
356	return str;
357	#elif defined(HAVE_STRERROR)
358	sl_strlcpy(str, strerror(tellme), len);
359	return str;
360	#else
361
362	char *p = NULL;
363	#ifdef EACCES
364	if (tellme == EACCES) p = _("Permission denied.");
365	#endif
366	#ifdef EAGAIN
367	if (tellme == EAGAIN) p = _("Try again.");
368	#endif
369	#ifdef EBADF
370	if (tellme == EBADF) p = _("File descriptor in bad state.");
371	#endif
372	#ifdef EEXIST
373	if (tellme == EEXIST) p = _("File exists.");
374	#endif
375	#ifdef EFAULT
376	if (tellme == EFAULT) p = _("Bad address.");
377	#endif
378	#ifdef EINVAL
379	if (tellme == EINVAL) p = _("Invalid argument.");
380	#endif
381	#ifdef EISDIR
382	if (tellme == EISDIR) p = _("Is a directory.");
383	#endif
384	#ifdef EINTR
385	if (tellme == EINTR) p = _("System call was interrupted.");
386	#endif
387	#ifdef EIO
388	if (tellme == EIO) p = _("Low-level I/O error.");
389	#endif
390	#ifdef ELOOP
391	if (tellme == ELOOP) p = _("Too many symbolic links encountered.");
392	#endif
393	#ifdef EMFILE
394	if (tellme == EMFILE) p = _("Too many open files.");
395	#endif
396	#ifdef EMLINK
397	if (tellme == EMLINK) p = _("Too many links.");
398	#endif
399	#ifdef ENAMETOOLONG
400	if (tellme == ENAMETOOLONG)
401	p = _("File name too long.");
402	#endif
403	#ifdef ENFILE
404	if (tellme == ENFILE) p = _("File table overflow.");
405	#endif
406	#ifdef ENOENT
407	if (tellme == ENOENT) p = _("File does not exist.");
408	#endif
409	#ifdef ENOMEM
410	if (tellme == ENOMEM) p = _("Out of memory.");
411	#endif
412	#ifdef ENOSPC
413	if (tellme == ENOSPC) p = _("No space on device.");
414	#endif
415	#ifdef ENOTDIR
416	if (tellme == ENOTDIR) p = _("Not a directory.");
417	#endif
418	#ifdef ENOTSOCK
419	if (tellme == ENOTSOCK) p = _("Not a socket.");
420	#endif
421	#ifdef EOPNOTSUPP
422	if (tellme == EOPNOTSUPP) p = _("Socket is not of type SOCK_STREAM.");
423	#endif
424	#ifdef EPERM
425	if (tellme == EPERM) p = _("Permission denied.");
426	#endif
427	#ifdef EPIPE
428	if (tellme == EPIPE) p = _("No read on pipe.");
429	#endif
430	#ifdef EROFS
431	if (tellme == EROFS) p = _("Read-only file system.");
432	#endif
433	#ifdef ETXTBSY
434	if (tellme == ETXTBSY) p = _("Text file busy.");
435	#endif
436	#ifdef EWOULDBLOCK
437	if (tellme == EWOULDBLOCK)
438	p = _("No connections on non-blocking socket.");
439	#endif
440	#ifdef EXDEV
441	if (tellme == EXDEV) p = _("Not on same file system.");
442	#endif
443	if (!p) p = _("Unknown error");
444	sl_strlcpy(str, p, len);
445	return str;
446	#endif /* ifndef HAVE_STRERROR */
447	}
448
449
450	/* switch off file log
451	*/
452	void sh_error_logoff()
453	{
454	errFlags.HaveLog = BAD;
455	return;
456	}
457
458	/* switch on file log
459	*/
460	void sh_error_logrestore()
461	{
462	errFlags.HaveLog = GOOD;
463	return;
464	}
465
466	/* --- Relate priority levels to literals. ---
467	*/
468	typedef struct eef
469	{
470	const char * str;
471	int val;
472	} eef_struc;
473
474	static eef_struc eef_tab[] =
475	{
476	{ N_("none"), SH_ERR_NOT },
477	{ N_("debug"), SH_ERR_ALL },
478	{ N_("info"), SH_ERR_INFO },
479	{ N_("notice"), SH_ERR_NOTICE },
480	{ N_("warn"), SH_ERR_WARN },
481	{ N_("mark"), SH_ERR_STAMP },
482	{ N_("err"), SH_ERR_ERR },
483	{ N_("crit"), SH_ERR_SEVERE },
484	{ N_("alert"), SH_ERR_FATAL },
485	#if defined(SH_WITH_SERVER)
486	#define SH_EEF_MAX 10
487	{ N_("inet"), SH_ERR_INET },
488	#else
489	#define SH_EEF_MAX 9
490	#endif
491	};
492
493	int sh_error_convert_level (const char * str_s)
494	{
495	int i;
496	int level = (-1);
497
498	SL_ENTER(_("sh_error_convert_level"));
499
500	if (str_s == NULL)
501	SL_RETURN( -1, _("sh_error_convert_level"));
502
503	for (i = 0; i < SH_EEF_MAX; ++i)
504	{
505	if (0 == sl_strncmp(str_s, _(eef_tab[i].str),
506	sl_strlen(eef_tab[i].str)))
507	{
508	level = eef_tab[i].val;
509	break;
510	}
511	}
512
513	SL_RETURN( level, _("sh_error_convert_level"));
514	}
515
516
517	/* --- Set severity levels. ---
518	*/
519	int sh_error_set_iv (int iv, const char * str_s)
520	{
521	int level = (-1);
522
523	SL_ENTER(_("sh_error_set_iv"));
524
525	if (IsInitialized == BAD)
526	(void) sh_error_init();
527
528	level = sh_error_convert_level (str_s);
529
530	if (level == (-1))
531	{
532	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
533	_("severity"),
534	str_s != NULL ? str_s : _("(NULL)"));
535	SL_RETURN (-1, _("sh_error_set_iv"));
536	}
537
538	if (iv > SH_ERR_T_START && iv < SH_ERR_T_END)
539	{
540	ShDFLevel[iv] = level;
541	}
542	else
543	{
544	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALL,
545	_("severity"), (long) iv);
546	SL_RETURN (-1, _("sh_error_set_iv"));
547	}
548	SL_RETURN (0, _("sh_error_set_iv"));
549	}
550
551	int sh_error_set_level(const char * str_in, int * facility)
552	{
553	register int i, j, f = BAD;
554
555	int old_facility;
556	const char * str_s = str_in;
557
558	SL_ENTER(_("sh_error_set_level"));
559
560	if (IsInitialized == BAD)
561	(void) sh_error_init();
562
563	old_facility = *facility;
564	*facility = 0;
565
566	checkstr:
567
568	if (str_s != NULL)
569	{
570	if (0 == sl_strncmp(str_s, _(eef_tab[0].str), sl_strlen(eef_tab[0].str)))
571	{
572	facility \|= eef_tab[0].val; / This is 'none' */
573	for (i = 1; i < SH_EEF_MAX; ++i)
574	*facility &= ~eef_tab[i].val;
575	f = GOOD;
576	}
577	else if (str_s[0] == '') / all */
578	{
579	for (i = 1; i < SH_EEF_MAX; ++i)
580	*facility \|= eef_tab[i].val;
581	f = GOOD;
582	}
583	else if (str_s[0] == '=')
584	{
585	for (i = 1; i < SH_EEF_MAX; ++i)
586	if (0 == sl_strncmp(&str_s[1], _(eef_tab[i].str),
587	sl_strlen(eef_tab[i].str)))
588	{
589	*facility \|= eef_tab[i].val;
590	f = GOOD;
591	}
592	}
593	else if (str_s[0] == '!')
594	{
595	if (str_s[1] == '*' \|\|
596	0 == sl_strncmp(&str_s[1], _(eef_tab[1].str),
597	sl_strlen(eef_tab[1].str)))
598	{
599	facility \|= eef_tab[0].val; / This is 'none' */
600	for (i = 1; i < SH_EEF_MAX; ++i)
601	*facility &= ~eef_tab[i].val;
602	f = GOOD;
603	}
604	else if (str_s[1] == '=')
605	{
606	for (i = 1; i < SH_EEF_MAX; ++i)
607	{
608	if (0 == sl_strncmp(&str_s[2], _(eef_tab[i].str),
609	sl_strlen(eef_tab[i].str)))
610	{
611	*facility &= ~eef_tab[i].val;
612	f = GOOD;
613	}
614	}
615	}
616	else
617	{
618	for (i = 1; i < SH_EEF_MAX; ++i)
619	{
620	if (0 == sl_strncmp(&str_s[1], _(eef_tab[i].str),
621	sl_strlen(eef_tab[i].str)))
622	{
623	for (j = i; j < SH_EEF_MAX; ++j)
624	{
625	*facility &= ~eef_tab[j].val;
626	}
627	f = GOOD;
628	}
629	}
630	}
631	}
632	else /* plain severity name */
633	{
634	for (i = 1; i < SH_EEF_MAX; ++i)
635	{
636	if (0 == sl_strncmp(str_s, _(eef_tab[i].str),
637	sl_strlen(eef_tab[i].str)))
638	{
639	for (j = i; j < SH_EEF_MAX; ++j)
640	{
641	*facility \|= eef_tab[j].val;
642	}
643	f = GOOD;
644	break;
645	}
646	}
647	}
648	}
649
650	if (!str_s)
651	{
652	SL_RETURN ((-1), _("sh_error_set_level"));
653	}
654	/* skip to end of string
655	*/
656	while (str_s != '\0' && str_s != ';' && *str_s != ',' &&
657	str_s != ' ' && str_s != '\t')
658	++str_s;
659
660	/* skip seperator
661	*/
662	while ((*str_s != '\0') &&
663	(str_s == ';' \|\| str_s == ',' \|\| str_s == ' ' \|\| str_s == '\t'))
664	++str_s;
665
666	if (*str_s != '\0')
667	{
668	f = BAD;
669	goto checkstr;
670	}
671
672	if (f == BAD)
673	{
674	*facility = old_facility;
675	sh_error_handle ((-1), FIL__, __LINE__, EINVAL, MSG_EINVALS,
676	_("priority"), str_in);
677	SL_RETURN (-1, _("sh_error_set_level"));
678	}
679	compute_flag_err_debug();
680	compute_flag_err_info();
681	SL_RETURN (0, _("sh_error_set_level"));
682	}
683
684	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
685	/* set severity for TCP export
686	*/
687	int sh_error_setexport(const char * str_s)
688	{
689	static int reject = 0;
690	if (reject == 1)
691	return (0);
692
693	if (sh.flag.opts == S_TRUE)
694	reject = 1;
695
696	return (sh_error_set_level(str_s, &errFlags.exportlevel));
697	}
698	#endif
699
700	/* set severity for printing
701	*/
702	extern void dlog_set_active(int flag);
703
704	int sh_error_setprint(const char * str_s)
705	{
706	static int reject = 0;
707	int retval;
708
709	if (reject == 1)
710	return (0);
711
712	if (sh.flag.opts == S_TRUE)
713	reject = 1;
714
715	retval = sh_error_set_level(str_s, &errFlags.printlevel);
716
717	if (0 != (errFlags.printlevel & SH_ERR_INFO))
718	dlog_set_active(1);
719	if (0 != (errFlags.printlevel & SH_ERR_ALL))
720	dlog_set_active(2);
721	return retval;
722	}
723
724
725	/* set level for error logging
726	*/
727	int sh_error_setlog(const char * str_s)
728	{
729	static int reject = 0;
730	if (reject == 1)
731	return (0);
732
733	if (sh.flag.opts == S_TRUE)
734	reject = 1;
735
736	return ( sh_error_set_level(str_s, &errFlags.loglevel) );
737	}
738
739
740	/* set severity for syslog
741	*/
742	int sh_error_set_syslog (const char * str_s)
743	{
744	static int reject = 0;
745	if (reject == 1)
746	return (0);
747
748	if (sh.flag.opts == S_TRUE)
749	reject = 1;
750
751	return (sh_error_set_level(str_s, &errFlags.sysloglevel));
752	}
753
754	#if defined(WITH_EXTERNAL)
755	/* set severity for external
756	*/
757	int sh_error_set_external (const char * str_s)
758	{
759	static int reject = 0;
760	if (reject == 1)
761	return (0);
762
763	if (sh.flag.opts == S_TRUE)
764	reject = 1;
765
766	return (sh_error_set_level(str_s, &errFlags.externallevel));
767	}
768	#endif
769
770	#if defined(WITH_DATABASE)
771	/* set severity for database
772	*/
773	int sh_error_set_database (const char * str_s)
774	{
775	static int reject = 0;
776	if (reject == 1)
777	return (0);
778
779	if (sh.flag.opts == S_TRUE)
780	reject = 1;
781
782	return (sh_error_set_level(str_s, &errFlags.databaselevel));
783	}
784	#endif
785
786	#if defined(HAVE_LIBPRELUDE)
787	/* set severity for prelude
788	*/
789	int sh_error_set_prelude (const char * str_s)
790	{
791	static int reject = 0;
792
793	if (reject == 1)
794	return (0);
795
796	if (sh.flag.opts == S_TRUE)
797	reject = 1;
798
799	return sh_error_set_level(str_s, &errFlags.preludelevel);
800	}
801	#endif
802
803	/* init or re-init log facilities that need it
804	*/
805	void sh_error_fixup(void)
806	{
807	#if defined(HAVE_LIBPRELUDE)
808	if ((errFlags.preludelevel & SH_ERR_NOT) == 0)
809	sh_prelude_init();
810	else
811	sh_prelude_stop();
812	#endif
813	#ifdef WITH_DATABASE
814	sh_database_reset();
815	#endif
816	return;
817	}
818
819	/* to be called from sh_prelude_reset
820	*/
821	void sh_error_init_prelude(void)
822	{
823	#if defined(HAVE_LIBPRELUDE)
824	if ((errFlags.preludelevel & SH_ERR_NOT) == 0)
825	sh_prelude_init();
826	else
827	sh_prelude_stop();
828	#endif
829	return;
830	}
831
832
833	/* set severity for mailing
834	*/
835	int sh_error_setseverity (const char * str_s)
836	{
837	static int reject = 0;
838	if (reject == 1)
839	return (0);
840
841	if (sh.flag.opts == S_TRUE)
842	reject = 1;
843
844	return (sh_error_set_level(str_s, &errFlags.maillevel));
845	}
846
847	#ifdef SH_WITH_SERVER
848	static char inet_peer[SH_MINIBUF] = { '\0' };
849	#ifdef HAVE_LIBPRELUDE
850	static char inet_peer_ip[SH_IP_BUF] = { '\0' };
851
852	void sh_error_set_peer_ip(const char * str)
853	{
854	if (str == NULL)
855	inet_peer_ip[0] = '\0';
856	else
857	sl_strlcpy(inet_peer_ip, str, sizeof(inet_peer_ip));
858	}
859	#endif
860
861	void sh_error_set_peer(const char * str)
862	{
863	if (str == NULL)
864	inet_peer[0] = '\0';
865	else
866	sl_strlcpy(inet_peer, str, sizeof(inet_peer));
867	}
868	#endif
869
870	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
871	#include "sh_checksum.h"
872	static char * sh_error_replace(const char * msg)
873	{
874	char * ret = NULL;
875
876	if (sh_tiger_get_hashtype () == SH_SHA256)
877	{
878	char * store = NULL;
879
880	#ifdef SH_USE_XML
881	char c_end = '"';
882	char * str = _("chksum_old=\"");
883	char * str2 = _("chksum_new=\"");
884	#else
885	char c_end = '>';
886	char * str = _("chksum_old=<");
887	char * str2 = _("chksum_new=<");
888	#endif
889
890	ret = SHA256_ReplaceBaseByHex(msg, str, c_end);
891
892	if (ret) {
893	store = ret;
894	ret = SHA256_ReplaceBaseByHex(ret, str2, c_end);
895	if (ret)
896	SH_FREE(store);
897	else
898	ret = store;
899	} else {
900	ret = SHA256_ReplaceBaseByHex(msg, str2, c_end);
901	}
902	}
903	return ret;
904	}
905	static void sh_replace_free(char * msg)
906	{
907	if (msg)
908	SH_FREE(msg);
909	return;
910	}
911	#else
912	static char * sh_error_replace(const char * msg) { (void) msg; return NULL; }
913	static void sh_replace_free(char * msg) { (void) msg; return; }
914	#endif
915
916	/**********************************************************
917	**********************************************************
918	*
919	* -------- MAIN ERROR HANDLING FUNCTION -----------------
920	*
921	*
922	* this function should be called to report an error
923	*
924	**********************************************************
925	**********************************************************/
926
927	SH_MUTEX_RECURSIVE(mutex_err_handle);
928
929	void sh_error_handle (int sev1, const char * file, long line,
930	long status, unsigned long msg_id, ...)
931	{
932	va_list vl; /* argument list */
933	struct _log_t * lmsg;
934
935	int severity;
936	unsigned int class;
937	const char * fmt;
938	volatile int sev = sev1; /* Avoids the 'clobbered by longjmp' warning. */
939
940	int flag_inet;
941
942	#ifdef SH_WITH_SERVER
943	int class_inet = clt_class; /* initialize from global */
944	char local_inet_peer[SH_MINIBUF];
945	#ifdef HAVE_LIBPRELUDE
946	char local_inet_peer_ip[SH_IP_BUF];
947	#endif
948	#endif
949
950	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
951	char * ex_msg;
952	#endif
953	#if defined(WITH_DATABASE)
954	char * escape_msg;
955	#endif
956
957	char * hexmsg = NULL;
958
959	static int own_block = 0;
960
961	/*
962	* Block a facility for errors generated
963	* within that facility.
964	*/
965	static int print_block = 0;
966	#if defined(SH_WITH_MAIL)
967	static int mail_block = 0;
968	#endif
969	static int syslog_block = 0;
970	static int log_block = 0;
971	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
972	static int export_block = 0;
973	#endif
974	#if defined(WITH_EXTERNAL)
975	static int external_block = 0;
976	#endif
977	#if defined(WITH_DATABASE)
978	static int database_block = 0;
979	#endif
980	#ifdef HAVE_LIBPRELUDE
981	static int prelude_block = 0;
982	#endif
983
984	SL_ENTER(_("sh_error_handle"));
985
986	SH_MUTEX_RECURSIVE_INIT(mutex_err_handle);
987	SH_MUTEX_RECURSIVE_LOCK(mutex_err_handle);
988
989	#ifdef SH_WITH_SERVER
990	/* copy the global string into a local array
991	*/
992	if ((msg_id == MSG_TCP_MSG) && (inet_peer[0] != '\0'))
993	{
994	sl_strlcpy(local_inet_peer, inet_peer, sizeof(local_inet_peer));
995	sh_error_set_peer(NULL);
996	}
997	else
998	local_inet_peer[0] = '\0';
999
1000	#ifdef HAVE_LIBPRELUDE
1001	if ((msg_id == MSG_TCP_MSG) && (inet_peer_ip[0] != '\0'))
1002	{
1003	sl_strlcpy(local_inet_peer_ip, inet_peer_ip, sizeof(local_inet_peer_ip));
1004	sh_error_set_peer_ip(NULL);
1005	}
1006	else
1007	local_inet_peer_ip[0] = '\0';
1008	#endif
1009
1010	clt_class = (-1); /* reset global */
1011	#endif
1012
1013
1014	if (own_block == 1)
1015	{
1016	goto exit_here;
1017	}
1018
1019	/* --- Initialize to default values. ---
1020	*/
1021	if (IsInitialized == BAD)
1022	(void) sh_error_init();
1023
1024	/* Returns pointer to (constant\|thread-specific) static memory
1025	*/
1026	fmt = /@i@/get_format (msg_id, &severity, &class);
1027
1028	#ifdef SH_WITH_SERVER
1029	if (class_inet != (-1))
1030	class = (unsigned int) class_inet;
1031	#endif
1032
1033	/* --- Consistency check. ---
1034	*/
1035	ASSERT((fmt != NULL), _("fmt != NULL"))
1036	if (fmt == NULL)
1037	{
1038	fprintf(stderr,
1039	_("ERROR: msg=<NULL format>, file=<%s>, line=<%ld>\n"),
1040	file, line);
1041	goto exit_here;
1042	}
1043
1044	/* --- Override the catalogue severity. ---
1045	*/
1046	if (sev != (-1))
1047	severity = sev;
1048
1049	/* --- Some statistics. ---
1050	*/
1051	#if defined (SH_WITH_CLIENT) \|\| defined (SH_STANDALONE)
1052	if ( ((1 << class) & ERROR_CLA) &&
1053	(severity & (SH_ERR_ERR\|SH_ERR_SEVERE\|SH_ERR_FATAL)))
1054	{
1055	++sh.statistics.files_error;
1056	}
1057	#endif
1058
1059	/* these are messages from remote sources
1060	*/
1061	if ((severity & SH_ERR_INET) != 0)
1062	{
1063	flag_inet = S_TRUE;
1064	}
1065	else
1066	{
1067	flag_inet = S_FALSE;
1068	}
1069
1070	/* --- Messages not wanted for logging. ---
1071	*/
1072	if ( ( (errFlags.printlevel & severity ) == 0 \|\|
1073	(errFlags.print_class & (1 << class)) == 0 ) &&
1074	( (errFlags.loglevel & severity ) == 0 \|\|
1075	(errFlags.log_class & (1 << class)) == 0 ) &&
1076	( (errFlags.sysloglevel & severity ) == 0 \|\|
1077	(errFlags.syslog_class & (1 << class)) == 0 ) &&
1078	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_CLIENT)
1079	( (errFlags.exportlevel & severity ) == 0 \|\|
1080	(errFlags.export_class & (1 << class)) == 0 ) &&
1081	#endif
1082	#ifdef WITH_EXTERNAL
1083	( (errFlags.externallevel & severity ) == 0 \|\|
1084	(errFlags.external_class & (1 << class)) == 0 ) &&
1085	#endif
1086	#ifdef HAVE_LIBPRELUDE
1087	( (errFlags.preludelevel & severity ) == 0 \|\|
1088	(errFlags.prelude_class & (1 << class)) == 0 ) &&
1089	#endif
1090	#ifdef WITH_DATABASE
1091	( (errFlags.databaselevel & severity ) == 0 \|\|
1092	(errFlags.database_class & (1 << class)) == 0 ) &&
1093	#endif
1094	( (errFlags.maillevel & severity ) == 0 \|\|
1095	(errFlags.mail_class & (1 << class)) == 0 )
1096	#ifdef SH_WITH_SERVER
1097	&& (flag_inet == S_FALSE) /* still log messages from remote sources */
1098	#endif
1099	)
1100	{
1101	goto exit_here;
1102	}
1103
1104	if ((severity & SH_ERR_NOT) != 0)
1105	{
1106	goto exit_here;
1107	}
1108
1109	#if defined(SH_WITH_CLIENT) \|\| defined(SH_STANDALONE)
1110	if ((sh_global_check_silent > SH_SILENT_STD) &&
1111	(((1 << FIL) & (1 << class)) != 0))
1112	{
1113	goto exit_here;
1114	}
1115	#endif
1116
1117	/* Allocate space for the message.
1118	*/
1119	own_block = 1;
1120	lmsg = (struct _log_t *) SH_ALLOC(sizeof(struct _log_t));
1121	MLOCK( (char *) lmsg, sizeof(struct _log_t));
1122	/@i@/lmsg->msg = NULL;
1123
1124	/@i@/(void) sl_strlcpy(lmsg->format, fmt, SH_PATHBUF);
1125	(void) sl_strlcpy(lmsg->file, file, SH_PATHBUF);
1126	lmsg->severity = severity;
1127	lmsg->class = (int) class;
1128	lmsg->line = line;
1129	lmsg->status = status;
1130
1131	/* Format the log message with timestamp etc.
1132	* Allocate lmsg->msg
1133	*/
1134	va_start (vl, msg_id);
1135	(void) sh_error_string (lmsg, vl);
1136	va_end (vl);
1137	own_block = 0;
1138
1139	hexmsg = sh_error_replace(lmsg->msg);
1140
1141	/* Log to stderr.
1142	*/
1143	if ( ((errFlags.printlevel & severity) != 0 &&
1144	(errFlags.print_class & (1 << class)) != 0 &&
1145	(errFlags.printlevel & SH_ERR_NOT) == 0)
1146	#ifdef SH_WITH_SERVER
1147	\|\| (flag_inet == S_TRUE)
1148	#endif
1149	)
1150	{
1151	if (print_block == 0 && (errFlags.printlevel & SH_ERR_NOT) == 0)
1152	{
1153	/* no truncation
1154	*/
1155	print_block = 1;
1156	TPT(( 0, FIL__, __LINE__, lmsg->msg));
1157	/*
1158	* Reports first error after failure. Always tries.
1159	*/
1160	(void) sh_log_console (hexmsg ? hexmsg : lmsg->msg);
1161	print_block = 0;
1162	}
1163	}
1164
1165
1166	/* Full logging enabled.
1167	*/
1168	if (OnlyStderr == S_FALSE) /* full error logging enabled */
1169	{
1170
1171	/* Log to syslog.
1172	*/
1173	if ( (errFlags.sysloglevel & severity) != 0 &&
1174	(errFlags.syslog_class & (1 << class)) != 0 &&
1175	#ifndef INET_SYSLOG
1176	(flag_inet != S_TRUE) && /* !inet->syslog */
1177	#endif
1178	(errFlags.sysloglevel & SH_ERR_NOT) == 0 )
1179	{
1180	/* will truncate to 1023 bytes
1181	*/
1182	if (syslog_block == 0)
1183	{
1184	syslog_block = 1;
1185	/*
1186	* Ignores errors. Always tries.
1187	*/
1188	(void) sh_log_syslog (lmsg->severity, hexmsg ? hexmsg : lmsg->msg);
1189	syslog_block = 0;
1190	}
1191	}
1192
1193	#if defined(WITH_EXTERNAL)
1194	/*
1195	* -- external facility
1196	*/
1197	if ((errFlags.externallevel & severity) != 0 &&
1198	(errFlags.external_class & (1 << class)) != 0 &&
1199	(errFlags.externallevel & SH_ERR_NOT) == 0 &&
1200	class != AUD)
1201	{
1202	if (external_block == 0)
1203	{
1204	/* no truncation
1205	*/
1206	external_block = 1;
1207	/*
1208	* Reports first error after failure. Always tries.
1209	*/
1210	(void) sh_ext_execute ('l', 'o', 'g', hexmsg ? hexmsg : lmsg->msg, 0);
1211	external_block = 0;
1212	}
1213	}
1214	#endif
1215
1216	#if defined(WITH_DATABASE)
1217	/*
1218	* -- database facility
1219	*/
1220	if ((errFlags.databaselevel & severity) != 0 &&
1221	(errFlags.database_class & (1 << class)) != 0 &&
1222	(errFlags.databaselevel & SH_ERR_NOT) == 0 &&
1223	class != AUD)
1224	{
1225	if (database_block == 0 && enableUnsafe == S_TRUE)
1226	{
1227	/* truncates; query_max is 16k
1228	*/
1229	database_block = 1;
1230	#ifndef SH_STANDALONE
1231	if (msg_id == MSG_TCP_MSG
1232	#ifdef INET_SYSLOG
1233	\|\| msg_id == MSG_INET_SYSLOG
1234	#endif
1235	)
1236	{
1237	/* do not escape twice
1238	*/
1239	/*
1240	* Reports failure every 60 min. Always tries.
1241	*/
1242	(void) sh_database_insert (lmsg->msg);
1243	}
1244	else
1245	#endif
1246	{
1247	escape_msg = sh_tools_safe_name(lmsg->msg, 0);
1248	/*
1249	* Reports failure every 60 min. Always tries.
1250	*/
1251	(void) sh_database_insert (escape_msg);
1252	SH_FREE(escape_msg);
1253	}
1254	database_block = 0;
1255	}
1256	}
1257	#endif
1258
1259	/****************************************************
1260	* Optionally include client code for TCP forwarding
1261	* to log server
1262	****************************************************/
1263	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
1264	/* Export by TCP.
1265	*/
1266
1267	if ( ((errFlags.exportlevel & severity ) != 0 &&
1268	(errFlags.export_class & (1 << class)) != 0 &&
1269	(errFlags.exportlevel & SH_ERR_NOT) == 0 &&
1270	class != AUD )
1271	#ifdef SH_WITH_SERVER
1272	/* always log inet to export */
1273	\|\| (flag_inet == S_TRUE && sh.srvexport.name[0] != '\0')
1274	#endif
1275	/* sh.flag.isserver != GOOD && */
1276	/* (flag_inet == S_FALSE) / / don't log inet to export */
1277	)
1278	{
1279	if (export_block == 0)
1280	{
1281	int retval;
1282	size_t ex_len;
1283
1284	/* will truncate to 65280 bytes
1285	*/
1286	export_block = 1;
1287	/* ex_len = 64 + sl_strlen(lmsg->msg) + 1; */
1288	ex_len = sl_strlen(lmsg->msg);
1289	if (sl_ok_adds(ex_len, 65))
1290	ex_len = 64 + ex_len + 1;
1291	ex_msg = SH_ALLOC (ex_len);
1292
1293	sl_snprintf(ex_msg, ex_len, _("%d?%u?%s"),
1294	severity, class, lmsg->msg);
1295	retval = sh_xfer_report (ex_msg);
1296	SH_FREE(ex_msg);
1297	export_block = 0;
1298	if (retval == -2)
1299	{
1300	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_QUEUE_FULL,
1301	_("log server"));
1302	}
1303	}
1304	}
1305	#endif
1306
1307
1308	/* Log to mail.
1309	*/
1310	#if defined(SH_WITH_MAIL)
1311	if ((errFlags.maillevel & severity ) != 0 &&
1312	(errFlags.mail_class & (1 << class)) != 0 &&
1313	(errFlags.maillevel & SH_ERR_NOT) == 0 &&
1314	class != AUD &&
1315	(flag_inet == S_FALSE) ) /* don't log inet to email */
1316	{
1317	if (mail_block == 0)
1318	{
1319	int retval;
1320
1321	/* will truncate to 998 bytes
1322	*/
1323	mail_block = 1;
1324
1325	BREAKEXIT(sh_nmail_msg);
1326	if ( (severity & SH_ERR_FATAL) == 0)
1327	retval = sh_nmail_pushstack (severity, hexmsg ? hexmsg : lmsg->msg, NULL);
1328	else
1329	retval = sh_nmail_msg (severity, hexmsg ? hexmsg : lmsg->msg, NULL);
1330
1331	mail_block = 0;
1332	if (retval == -2)
1333	{
1334	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_QUEUE_FULL,
1335	_("email"));
1336	}
1337	}
1338	}
1339	#endif
1340
1341	#ifdef HAVE_LIBPRELUDE
1342	if (((errFlags.preludelevel & severity ) != 0 &&
1343	(errFlags.prelude_class & (1 << class)) != 0 &&
1344	(errFlags.preludelevel & SH_ERR_NOT) == 0 &&
1345	(class != AUD))
1346	#ifdef SH_WITH_SERVER
1347	\|\| (flag_inet == S_TRUE)
1348	#endif
1349	)
1350	{
1351	if (prelude_block == 0 && enableUnsafe == S_TRUE)
1352	{
1353	/* will truncate to 998 bytes
1354	*/
1355	prelude_block = 1;
1356
1357	BREAKEXIT(sh_prelude_alert);
1358	/*
1359	* Reports first error after failure. Always tries.
1360	*/
1361	#if defined(HAVE_LIBPRELUDE) && defined(SH_WITH_SERVER)
1362	(void) sh_prelude_alert (severity, (int) class,
1363	hexmsg ? hexmsg : lmsg->msg, lmsg->status, msg_id,
1364	local_inet_peer_ip);
1365	#else
1366	(void) sh_prelude_alert (severity, (int) class,
1367	hexmsg ? hexmsg : lmsg->msg, lmsg->status, msg_id,
1368	NULL);
1369	#endif
1370	prelude_block = 0;
1371	}
1372	}
1373	#endif
1374
1375	/* Log to logfile
1376	*/
1377
1378	if ( ( ( (errFlags.loglevel & severity) != 0 &&
1379	(errFlags.log_class & (1 << class)) != 0 &&
1380	(errFlags.loglevel & SH_ERR_NOT) == 0 )
1381	#ifdef SH_WITH_SERVER
1382	\|\| (flag_inet == S_TRUE)
1383	#endif
1384	) &&
1385	class != AUD &&
1386	(errFlags.HaveLog != BAD) && /* temporary switched off */
1387	(severity & SH_ERR_NOT) == 0 /* paranoia */
1388	)
1389	{
1390	if (log_block == 0)
1391	{
1392	/* no truncation
1393	*/
1394	log_block = 1;
1395	BREAKEXIT(sh_log_file);
1396	#ifdef SH_WITH_SERVER
1397	if (0 != sl_ret_euid())
1398	{
1399	/*
1400	* Reports first error after failure. Always tries.
1401	*/
1402	if (local_inet_peer[0] == '\0')
1403	(void) sh_log_file (lmsg->msg, NULL);
1404	else
1405	(void) sh_log_file (lmsg->msg, local_inet_peer);
1406	}
1407	#else
1408	(void) sh_log_file (hexmsg ? hexmsg : lmsg->msg, NULL);
1409	#endif
1410	/* sh_log_file (lmsg->msg); */
1411	log_block = 0;
1412	}
1413	}
1414
1415	}
1416
1417	/* Cleanup.
1418	*/
1419	own_block = 1;
1420
1421	if (lmsg->msg)
1422	SH_FREE( lmsg->msg );
1423	sh_replace_free(hexmsg);
1424
1425	memset ( lmsg, (int) '\0', sizeof(struct _log_t) );
1426	MUNLOCK( (char *) lmsg, sizeof(struct _log_t) );
1427	SH_FREE( lmsg );
1428	own_block = 0;
1429
1430	exit_here:
1431	; /* label at end of compound statement */
1432	SH_MUTEX_RECURSIVE_UNLOCK(mutex_err_handle);
1433
1434	/@i@/SL_RET0(_("sh_error_handle"));
1435	/@i@/}
1436
1437	#if defined(SH_WITH_MAIL)
1438	void sh_error_mail (const char * alias, int sev,
1439	const char * file, long line,
1440	long status, unsigned long msg_id, ...)
1441	{
1442	va_list vl; /* argument list */
1443	struct _log_t * lmsg;
1444
1445	int severity;
1446	unsigned int class;
1447	const char * fmt;
1448	int retval;
1449
1450	SL_ENTER(_("sh_error_mail"));
1451
1452	/* Returns pointer to (constant\|thread-specific) static memory
1453	*/
1454	fmt = /@i@/get_format (msg_id, &severity, &class);
1455
1456	if (!fmt)
1457	{
1458	SL_RET0(_("sh_error_mail"));
1459	}
1460
1461	/* --- Override the catalogue severity. ---
1462	*/
1463	if (sev != (-1))
1464	severity = sev;
1465
1466	/* --- Build the message. ---
1467	*/
1468	lmsg = (struct _log_t *) SH_ALLOC(sizeof(struct _log_t));
1469	MLOCK( (char *) lmsg, sizeof(struct _log_t));
1470	/@i@/lmsg->msg = NULL;
1471
1472	/@i@/(void) sl_strlcpy(lmsg->format, fmt, SH_PATHBUF);
1473	(void) sl_strlcpy(lmsg->file, file, SH_PATHBUF);
1474	lmsg->severity = severity;
1475	lmsg->class = (int) class;
1476	lmsg->line = line;
1477	lmsg->status = status;
1478
1479	/* Format the log message with timestamp etc.
1480	* Allocate lmsg->msg
1481	*/
1482	va_start (vl, msg_id);
1483	(void) sh_error_string (lmsg, vl);
1484	va_end (vl);
1485
1486	if ( (severity & SH_ERR_FATAL) == 0)
1487	retval = sh_nmail_pushstack (severity, lmsg->msg, alias);
1488	else
1489	retval = sh_nmail_msg (severity, lmsg->msg, alias);
1490
1491	if (retval == -2)
1492	{
1493	sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_QUEUE_FULL,
1494	_("email"));
1495	}
1496	SL_RET0(_("sh_error_mail"));
1497	}
1498	#else
1499	void sh_error_mail (const char * alias, int sev,
1500	const char * file, long line,
1501	long status, unsigned long msg_id, ...)
1502	{
1503	(void) alias;
1504	(void) sev;
1505	(void) file;
1506	(void) line;
1507	(void) status;
1508	(void) msg_id;
1509
1510	return;
1511	}
1512	/* defined(SH_WITH_MAIL) */
1513	#endif
1514
1515	/* -------------------------
1516	*
1517	* private functions below
1518	*
1519	* -------------------------
1520	*/
1521
1522
1523	/* --- Get the format from the message catalog. ---
1524	*/
1525	/@owned@/ /@null@/inline
1526	static const char * get_format(unsigned long msg_id, /@out@/ int * priority,
1527	/@out@/unsigned int * class)
1528	{
1529	int i = 0;
1530
1531	SL_ENTER(_("get_format"));
1532	while (1 == 1)
1533	{
1534	if ( msg_cat[i].format == NULL )
1535	break;
1536
1537	if ( (unsigned long) msg_cat[i].id == msg_id)
1538	{
1539	*priority = (int) msg_cat[i].priority;
1540	*class = (unsigned int) msg_cat[i].class;
1541	SL_RETURN (((const char *) _(msg_cat[i].format)), _("get_format"));
1542	}
1543	++i;
1544	}
1545	*priority = SH_ERR_ERR;
1546	*class = ERR;
1547	SL_RETURN (NULL, _("get_format"));
1548	}
1549
1550	/@null@//@only@/static char * ehead_format = NULL;
1551
1552	/* allocate space for user-defined message header
1553	*/
1554	int sh_error_ehead (/@null@/const char * str_s)
1555	{
1556	size_t size;
1557	const char * s;
1558
1559	SL_ENTER(_("sh_error_ehead"));
1560
1561	if (str_s == NULL)
1562	{
1563	SL_RETURN (-1, _("sh_error_ehead"));
1564	}
1565
1566	/* ascii 34 ist t\"ttelchen
1567	*/
1568	/@i@/ if (str_s[0] == 34) s = &str_s[1];
1569	else s = str_s;
1570
1571	size = /@i@/strlen(s);
1572	if (/@i@/s[size-1] == (char) 34) --size; /* truncate */
1573
1574	if (ehead_format != NULL)
1575	SH_FREE(ehead_format);
1576
1577	/@i@/ehead_format = SH_ALLOC(size+1);
1578	/@i@/ (void) sl_strlcpy(ehead_format, s, size+1);
1579
1580	SL_RETURN( 0, _("sh_error_ehead"));
1581	}
1582
1583	#if !defined(VA_COPY)
1584	#if defined(__GNUC__) && defined(__PPC__) && (defined(_CALL_SYSV) \|\| defined(_WIN32))
1585	#define VA_COPY(ap1, ap2) ((ap1) = (ap2))
1586	#elif defined(VA_COPY_AS_ARRAY)
1587	#define VA_COPY(ap1, ap2) memmove ((ap1), (ap2), sizeof (va_list))
1588	#else /* va_list is a pointer */
1589	#define VA_COPY(ap1, ap2) ((ap1) = (ap2))
1590	#endif
1591	#endif
1592
1593
1594	/* print an error into string
1595	*/
1596	static int sh_error_string (struct _log_t * lmsg, va_list vl)
1597	{
1598	size_t len;
1599	int required;
1600	unsigned long line;
1601	char sev[16] = "";
1602	char cla[16] = "";
1603	char tst[64] = "";
1604	char *p;
1605	va_list vl2;
1606
1607	st_format rep_ehead_tab[] = {
1608	{ 'S', S_FMT_STRING, 0, 0, NULL}, /* severity */
1609	{ 'T', S_FMT_STRING, 0, 0, NULL}, /* timestamp */
1610	{ 'F', S_FMT_STRING, 0, 0, NULL}, /* file */
1611	{ 'L', S_FMT_ULONG, 0, 0, NULL}, /* line */
1612	{ 'C', S_FMT_STRING, 0, 0, NULL}, /* class */
1613	{ 'E', S_FMT_LONG, 0, 0, NULL}, /* status */
1614	{'\0', S_FMT_ULONG, 0, 0, NULL},
1615	};
1616
1617	SL_ENTER(_("sh_error_string"));
1618
1619	if (ehead_format == NULL)
1620	{
1621	ehead_format = SH_ALLOC(64);
1622	#ifdef SH_USE_XML
1623	if ((errFlags.printlevel & SH_ERR_ALL) == 0)
1624	(void) sl_strlcpy(ehead_format,
1625	_("<log sev=\"%S\" tstamp=\"%T\" "), 64);
1626	else
1627	(void) sl_strlcpy(ehead_format,
1628	_("<log sev=\"%S\" tstamp=\"%T\" p.f=\"%F\" p.l=\"%L\" p.s=\"%E\" "), 64);
1629	#else
1630	if ((errFlags.printlevel & SH_ERR_ALL) == 0)
1631	(void) sl_strlcpy(ehead_format, _("%S %T "), 64);
1632	else
1633	(void) sl_strlcpy(ehead_format, _("%S %T (%F, %L, %E) "), 64);
1634	#endif
1635	}
1636
1637	/* header of error message
1638	*/
1639	#ifdef SH_USE_XML
1640	if ( (lmsg->severity & SH_ERR_INET) != 0)
1641	(void) sl_strlcpy (sev, _("RCVT"), 11);
1642	else if ( (lmsg->severity & SH_ERR_ALL) != 0)
1643	(void) sl_strlcpy (sev, _("DEBG"), 11);
1644	else if ( (lmsg->severity & SH_ERR_INFO) != 0)
1645	(void) sl_strlcpy (sev, _("INFO"), 11);
1646	else if ( (lmsg->severity & SH_ERR_NOTICE) != 0)
1647	(void) sl_strlcpy (sev, _("NOTE"), 11);
1648	else if ( (lmsg->severity & SH_ERR_WARN) != 0)
1649	(void) sl_strlcpy (sev, _("WARN"), 11);
1650	else if ( (lmsg->severity & SH_ERR_STAMP) != 0)
1651	(void) sl_strlcpy (sev, _("MARK"), 11);
1652	else if ( (lmsg->severity & SH_ERR_ERR) != 0)
1653	(void) sl_strlcpy (sev, _("ERRO"), 11);
1654	else if ( (lmsg->severity & SH_ERR_SEVERE) != 0)
1655	(void) sl_strlcpy (sev, _("CRIT"), 11);
1656	else if ( (lmsg->severity & SH_ERR_FATAL) != 0)
1657	(void) sl_strlcpy (sev, _("ALRT"), 11);
1658	else {
1659	(void) sl_strlcpy (sev, _("????"), 11);
1660	#else
1661	#if defined(INET_SYSLOG)
1662	if ( (lmsg->severity & SH_ERR_INET) != 0)
1663	(void) sl_strlcpy (sev, _("<NET> : "), 11);
1664	#else
1665	if ( (lmsg->severity & SH_ERR_INET) != 0)
1666	(void) sl_strlcpy (sev, _("<TCP> : "), 11);
1667	#endif
1668	else if ( (lmsg->severity & SH_ERR_ALL) != 0)
1669	(void) sl_strlcpy (sev, _("DEBUG : "), 11);
1670	else if ( (lmsg->severity & SH_ERR_INFO) != 0)
1671	(void) sl_strlcpy (sev, _("INFO : "), 11);
1672	else if ( (lmsg->severity & SH_ERR_NOTICE) != 0)
1673	(void) sl_strlcpy (sev, _("NOTICE : "), 11);
1674	else if ( (lmsg->severity & SH_ERR_WARN) != 0)
1675	(void) sl_strlcpy (sev, _("WARN : "), 11);
1676	else if ( (lmsg->severity & SH_ERR_STAMP) != 0)
1677	(void) sl_strlcpy (sev, _("MARK : "), 11);
1678	else if ( (lmsg->severity & SH_ERR_ERR) != 0)
1679	(void) sl_strlcpy (sev, _("ERROR : "), 11);
1680	else if ( (lmsg->severity & SH_ERR_SEVERE) != 0)
1681	(void) sl_strlcpy (sev, _("CRIT : "), 11);
1682	else if ( (lmsg->severity & SH_ERR_FATAL) != 0)
1683	(void) sl_strlcpy (sev, _("ALERT : "), 11);
1684	else {
1685	(void) sl_strlcpy (sev, _("??? : "), 11);
1686	#endif
1687	}
1688
1689	(void) sh_unix_time (0, tst, 64);
1690	line = (unsigned long) lmsg->line;
1691	(void) sl_strlcpy (cla, _(class_cat[lmsg->class]), 11);
1692
1693	/@i@/rep_ehead_tab[0].data_str = sev;
1694	/@i@/rep_ehead_tab[1].data_str = tst;
1695	/@i@/rep_ehead_tab[2].data_str = lmsg->file;
1696	/@i@/rep_ehead_tab[3].data_ulong = line;
1697	/@i@/rep_ehead_tab[4].data_str = cla;
1698	/@i@/rep_ehead_tab[5].data_long = lmsg->status;
1699
1700	p = /@i@/sh_util_formatted(ehead_format, rep_ehead_tab);
1701
1702	/* --- copy the header to lmsg->msg ---
1703	*/
1704	/@i@/lmsg->msg = SH_ALLOC(SH_BUFSIZE);
1705	lmsg->msg_len = SH_BUFSIZE;
1706
1707	if (p)
1708	{
1709	(void) sl_strlcpy (lmsg->msg, p, SH_BUFSIZE);
1710	SH_FREE(p);
1711	}
1712	else
1713	{
1714	lmsg->msg[0] = '\0';
1715	}
1716
1717
1718	/* --- copy message to lmsg->msg ---
1719	*/
1720	if ( NULL == strchr(lmsg->format, '%') )
1721	{
1722	(void) sl_strlcat (lmsg->msg, lmsg->format, (size_t) lmsg->msg_len);
1723	}
1724	else
1725	{
1726	/* use VA_COPY */
1727	/@i@/VA_COPY(vl2, vl);
1728	len = sl_strlen(lmsg->msg);
1729	/@i@/required = sl_vsnprintf(&(lmsg->msg[len]),
1730	(lmsg->msg_len - len), lmsg->format, vl);
1731
1732	if ((required >= 0) &&
1733	sl_ok_adds(required, len) &&
1734	sl_ok_adds((required+len), 4) &&
1735	((required + len) > (lmsg->msg_len - 4)) )
1736	{
1737	/@i@/p = SH_ALLOC(required + len + 4);
1738	(void) sl_strlcpy (p, lmsg->msg, required + len + 1);
1739	SH_FREE(lmsg->msg);
1740	lmsg->msg = p;
1741	lmsg->msg_len = required + len + 4;
1742	(void) sl_vsnprintf(&(lmsg->msg[len]),
1743	(required + 1), lmsg->format, vl2);
1744	}
1745	va_end(vl2);
1746	}
1747
1748	#ifdef SH_USE_XML
1749	/* closing tag
1750	*/
1751	if (lmsg->msg[sl_strlen(lmsg->msg)-1] != '>')
1752	(void) sl_strlcat (lmsg->msg, _(" />"), lmsg->msg_len);
1753	#endif
1754
1755	SL_RETURN(0, _("sh_error_string"));
1756	}
1757
1758
1759
1760
1761	/* --- Initialize. ---
1762	*/
1763	static int sh_error_init ()
1764	{
1765	register int j;
1766
1767	SL_ENTER(_("sh_error_init"));
1768
1769	errFlags.debug = 0;
1770	errFlags.HaveLog = GOOD;
1771	errFlags.sysloglevel = SH_ERR_NOT;
1772	#if defined(SH_STEALTH)
1773	errFlags.loglevel = SH_ERR_NOT;
1774	#else
1775	errFlags.loglevel = (SH_ERR_STAMP \| SH_ERR_ERR \| SH_ERR_SEVERE \|
1776	SH_ERR_FATAL);
1777	#endif
1778	errFlags.externallevel = SH_ERR_NOT;
1779	errFlags.databaselevel = SH_ERR_NOT;
1780	errFlags.preludelevel = SH_ERR_NOT;
1781	errFlags.maillevel = SH_ERR_FATAL;
1782	#if defined(SH_STEALTH)
1783	errFlags.printlevel = SH_ERR_NOT;
1784	#else
1785	errFlags.printlevel = (SH_ERR_INFO \| SH_ERR_NOTICE \| SH_ERR_WARN \|
1786	SH_ERR_STAMP \| SH_ERR_ERR \| SH_ERR_SEVERE \|
1787	SH_ERR_FATAL);
1788	flag_err_info = S_TRUE;
1789	#endif
1790
1791	#if defined(SH_WITH_SERVER)
1792	errFlags.exportlevel = SH_ERR_NOT;
1793	#else
1794	errFlags.exportlevel = (SH_ERR_STAMP \| SH_ERR_ERR \| SH_ERR_SEVERE \|
1795	SH_ERR_FATAL);
1796	#endif
1797
1798	errFlags.log_class = 0xFFFF;
1799	errFlags.print_class = 0xFFFF;
1800	errFlags.mail_class = 0xFFFF;
1801	errFlags.export_class = 0xFFFF;
1802	errFlags.syslog_class = 0xFFFF;
1803	errFlags.external_class = 0xFFFF;
1804	errFlags.database_class = 0xFFFF;
1805	errFlags.prelude_class = 0xFFFF;
1806
1807
1808	for (j = 0; j < SH_ERR_T_END; ++j)
1809	ShDFLevel[j] = SH_ERR_SEVERE;
1810
1811	IsInitialized = GOOD;
1812	SL_RETURN (0, _("sh_error_init"));
1813	}

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

Download in other formats: