[mirror_frr.git] / ldpd / log.c

/*	$OpenBSD$ */

/*
 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <zebra.h>

#include "ldpd.h"
#include "ldpe.h"
#include "lde.h"
#include "log.h"

#include <lib/log.h>
#include <lib/log_int.h>

const char	*log_procname;

void
logit(int pri, const char *fmt, ...)
{
	va_list	ap;

	va_start(ap, fmt);
	vlog(pri, fmt, ap);
	va_end(ap);
}

void
vlog(int pri, const char *fmt, va_list ap)
{
	char	 buf[1024];

	switch (ldpd_process) {
	case PROC_LDE_ENGINE:
		vsnprintf(buf, sizeof(buf), fmt, ap);
		lde_imsg_compose_parent_sync(IMSG_LOG, pri, buf,
		    strlen(buf) + 1);
		break;
	case PROC_LDP_ENGINE:
		vsnprintf(buf, sizeof(buf), fmt, ap);
		ldpe_imsg_compose_parent_sync(IMSG_LOG, pri, buf,
		    strlen(buf) + 1);
		break;
	case PROC_MAIN:
		vzlog(pri, fmt, ap);
		break;
	}
}

void
log_warn(const char *emsg, ...)
{
	char	*nfmt;
	va_list	 ap;

	/* best effort to even work in out of memory situations */
	if (emsg == NULL)
		logit(LOG_ERR, "%s", strerror(errno));
	else {
		va_start(ap, emsg);

		if (asprintf(&nfmt, "%s: %s", emsg, strerror(errno)) == -1) {
			/* we tried it... */
			vlog(LOG_ERR, emsg, ap);
			logit(LOG_ERR, "%s", strerror(errno));
		} else {
			vlog(LOG_ERR, nfmt, ap);
			free(nfmt);
		}
		va_end(ap);
	}
}

void
log_warnx(const char *emsg, ...)
{
	va_list	 ap;

	va_start(ap, emsg);
	vlog(LOG_ERR, emsg, ap);
	va_end(ap);
}

void
log_info(const char *emsg, ...)
{
	va_list	 ap;

	va_start(ap, emsg);
	vlog(LOG_INFO, emsg, ap);
	va_end(ap);
}

void
log_notice(const char *emsg, ...)
{
	va_list	 ap;

	va_start(ap, emsg);
	vlog(LOG_NOTICE, emsg, ap);
	va_end(ap);
}

void
log_debug(const char *emsg, ...)
{
	va_list	 ap;

	va_start(ap, emsg);
	vlog(LOG_DEBUG, emsg, ap);
	va_end(ap);
}

void
fatal(const char *emsg)
{
	if (emsg == NULL)
		logit(LOG_CRIT, "fatal in %s: %s", log_procname,
		    strerror(errno));
	else
		if (errno)
			logit(LOG_CRIT, "fatal in %s: %s: %s",
			    log_procname, emsg, strerror(errno));
		else
			logit(LOG_CRIT, "fatal in %s: %s",
			    log_procname, emsg);

	exit(1);
}

void
fatalx(const char *emsg)
{
	errno = 0;
	fatal(emsg);
}
Commit	Line	Data
8429abe0 RW	1	/* $OpenBSD$ */
	2
	3	/*
	4	* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
	5	*
	6	* Permission to use, copy, modify, and distribute this software for any
	7	* purpose with or without fee is hereby granted, provided that the above
	8	* copyright notice and this permission notice appear in all copies.
	9	*
	10	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	11	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	12	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	13	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	14	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	15	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	16	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	17	*/
	18
eac6e3f0	19	#include <zebra.h>
8429abe0 RW	20
	21	#include "ldpd.h"
	22	#include "ldpe.h"
	23	#include "lde.h"
	24	#include "log.h"
	25
eac6e3f0	26	#include <lib/log.h>
deaa50db	27	#include <lib/log_int.h>
eac6e3f0	28
fa68f9da	29	const char *log_procname;
8429abe0 RW	30
	31	void
	32	logit(int pri, const char *fmt, ...)
	33	{
	34	va_list ap;
	35
	36	va_start(ap, fmt);
	37	vlog(pri, fmt, ap);
	38	va_end(ap);
	39	}
	40
eac6e3f0	41	void
8429abe0 RW	42	vlog(int pri, const char *fmt, va_list ap)
8429abe0 RW	43	{
eac6e3f0	44	char buf[1024];
8429abe0	45
eac6e3f0 RW	46	switch (ldpd_process) {
	47	case PROC_LDE_ENGINE:
	48	vsnprintf(buf, sizeof(buf), fmt, ap);
f2232fdf RW	49	lde_imsg_compose_parent_sync(IMSG_LOG, pri, buf,
f2232fdf RW	50	strlen(buf) + 1);
eac6e3f0 RW	51	break;
	52	case PROC_LDP_ENGINE:
	53	vsnprintf(buf, sizeof(buf), fmt, ap);
f2232fdf RW	54	ldpe_imsg_compose_parent_sync(IMSG_LOG, pri, buf,
f2232fdf RW	55	strlen(buf) + 1);
eac6e3f0 RW	56	break;
eac6e3f0 RW	57	case PROC_MAIN:
bb85d700	58	vzlog(pri, fmt, ap);
eac6e3f0 RW	59	break;
eac6e3f0 RW	60	}
8429abe0 RW	61	}
	62
	63	void
	64	log_warn(const char *emsg, ...)
	65	{
	66	char *nfmt;
	67	va_list ap;
	68
	69	/* best effort to even work in out of memory situations */
	70	if (emsg == NULL)
a9916d2b	71	logit(LOG_ERR, "%s", strerror(errno));
8429abe0 RW	72	else {
	73	va_start(ap, emsg);
	74
	75	if (asprintf(&nfmt, "%s: %s", emsg, strerror(errno)) == -1) {
	76	/* we tried it... */
a9916d2b RW	77	vlog(LOG_ERR, emsg, ap);
a9916d2b RW	78	logit(LOG_ERR, "%s", strerror(errno));
8429abe0	79	} else {
a9916d2b	80	vlog(LOG_ERR, nfmt, ap);
8429abe0 RW	81	free(nfmt);
	82	}
	83	va_end(ap);
	84	}
	85	}
	86
	87	void
	88	log_warnx(const char *emsg, ...)
	89	{
	90	va_list ap;
	91
	92	va_start(ap, emsg);
a9916d2b	93	vlog(LOG_ERR, emsg, ap);
8429abe0 RW	94	va_end(ap);
	95	}
	96
	97	void
	98	log_info(const char *emsg, ...)
	99	{
	100	va_list ap;
	101
	102	va_start(ap, emsg);
	103	vlog(LOG_INFO, emsg, ap);
	104	va_end(ap);
	105	}
	106
eac6e3f0 RW	107	void
	108	log_notice(const char *emsg, ...)
	109	{
	110	va_list ap;
	111
	112	va_start(ap, emsg);
	113	vlog(LOG_NOTICE, emsg, ap);
	114	va_end(ap);
	115	}
	116
8429abe0 RW	117	void
	118	log_debug(const char *emsg, ...)
	119	{
	120	va_list ap;
	121
eac6e3f0 RW	122	va_start(ap, emsg);
	123	vlog(LOG_DEBUG, emsg, ap);
	124	va_end(ap);
8429abe0 RW	125	}
	126
	127	void
	128	fatal(const char *emsg)
	129	{
	130	if (emsg == NULL)
fa68f9da	131	logit(LOG_CRIT, "fatal in %s: %s", log_procname,
8429abe0 RW	132	strerror(errno));
	133	else
	134	if (errno)
	135	logit(LOG_CRIT, "fatal in %s: %s: %s",
fa68f9da	136	log_procname, emsg, strerror(errno));
8429abe0 RW	137	else
8429abe0 RW	138	logit(LOG_CRIT, "fatal in %s: %s",
fa68f9da	139	log_procname, emsg);
8429abe0 RW	140
	141	exit(1);
	142	}
	143
	144	void
	145	fatalx(const char *emsg)
	146	{
	147	errno = 0;
	148	fatal(emsg);
	149	}