Context Navigation

source: trunk/src/sh_error.c@ 526

Last change on this file since 526 was 510, checked in by katerina, 8 years ago
Fix for ticket #403 (case sensitivity of severity/class).
File size: 43.3 KB

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

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

Download in other formats: