[mirror_frr.git] / ldpd / logmsg.c

// SPDX-License-Identifier: ISC
/*	$OpenBSD$ */

/*
 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
 */

#include <zebra.h>
#include "lib/printfrr.h"

#include "mpls.h"

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

#define NUM_LOGS	4
const char *
log_sockaddr(void *vp)
{
	static char	 buf[NUM_LOGS][NI_MAXHOST];
	static int	 round = 0;
	struct sockaddr	*sa = vp;

	round = (round + 1) % NUM_LOGS;

	if (getnameinfo(sa, sockaddr_len(sa), buf[round], NI_MAXHOST, NULL, 0,
	    NI_NUMERICHOST))
		return ("(unknown)");
	else
		return (buf[round]);
}

const char *
log_in6addr(const struct in6_addr *addr)
{
	struct sockaddr_in6	sa_in6;

	memset(&sa_in6, 0, sizeof(sa_in6));
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	sa_in6.sin6_len = sizeof(sa_in6);
#endif
	sa_in6.sin6_family = AF_INET6;
	sa_in6.sin6_addr = *addr;

	recoverscope(&sa_in6);

	return (log_sockaddr(&sa_in6));
}

const char *
log_in6addr_scope(const struct in6_addr *addr, ifindex_t ifindex)
{
	struct sockaddr_in6	sa_in6;

	memset(&sa_in6, 0, sizeof(sa_in6));
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	sa_in6.sin6_len = sizeof(sa_in6);
#endif
	sa_in6.sin6_family = AF_INET6;
	sa_in6.sin6_addr = *addr;

	addscope(&sa_in6, ifindex);

	return (log_sockaddr(&sa_in6));
}

const char *
log_addr(int af, const union ldpd_addr *addr)
{
	static char	 buf[NUM_LOGS][INET6_ADDRSTRLEN];
	static int	 round = 0;

	switch (af) {
	case AF_INET:
		round = (round + 1) % NUM_LOGS;
		if (inet_ntop(AF_INET, &addr->v4, buf[round],
		    sizeof(buf[round])) == NULL)
			return ("???");
		return (buf[round]);
	case AF_INET6:
		return (log_in6addr(&addr->v6));
	default:
		break;
	}

	return ("???");
}

#define	TF_BUFS	4
#define	TF_LEN	32

char *
log_label(uint32_t label)
{
	char		*buf;
	static char	 tfbuf[TF_BUFS][TF_LEN];	/* ring buffer */
	static int	 idx = 0;

	buf = tfbuf[idx++];
	if (idx == TF_BUFS)
		idx = 0;

	switch (label) {
	case NO_LABEL:
		snprintf(buf, TF_LEN, "-");
		break;
	case MPLS_LABEL_IMPLICIT_NULL:
		snprintf(buf, TF_LEN, "imp-null");
		break;
	case MPLS_LABEL_IPV4_EXPLICIT_NULL:
	case MPLS_LABEL_IPV6_EXPLICIT_NULL:
		snprintf(buf, TF_LEN, "exp-null");
		break;
	default:
		snprintf(buf, TF_LEN, "%u", label);
		break;
	}

	return (buf);
}

const char *
log_time(time_t t)
{
	char		*buf;
	static char	 tfbuf[TF_BUFS][TF_LEN];	/* ring buffer */
	static int	 idx = 0;
	uint64_t	 sec, min, hrs, day, week;

	buf = tfbuf[idx++];
	if (idx == TF_BUFS)
		idx = 0;

	week = t;

	sec = week % 60;
	week /= 60;
	min = week % 60;
	week /= 60;
	hrs = week % 24;
	week /= 24;
	day = week % 7;
	week /= 7;

	if (week > 0)
		snprintfrr(buf, TF_LEN,
			   "%02" PRIu64 "w%01" PRIu64 "d%02" PRIu64 "h", week,
			   day, hrs);
	else if (day > 0)
		snprintfrr(buf, TF_LEN,
			   "%01" PRIu64 "d%02" PRIu64 "h%02" PRIu64 "m", day,
			   hrs, min);
	else
		snprintfrr(buf, TF_LEN,
			   "%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64, hrs, min,
			   sec);

	return (buf);
}

char *
log_hello_src(const struct hello_source *src)
{
	static char buf[64];

	switch (src->type) {
	case HELLO_LINK:
		snprintf(buf, sizeof(buf), "iface %s",
		    src->link.ia->iface->name);
		break;
	case HELLO_TARGETED:
		snprintf(buf, sizeof(buf), "source %s",
		    log_addr(src->target->af, &src->target->addr));
		break;
	}

	return (buf);
}

const char *
log_map(const struct map *map)
{
	static char	buf[128];

	switch (map->type) {
	case MAP_TYPE_WILDCARD:
		if (snprintf(buf, sizeof(buf), "wildcard") < 0)
			return ("???");
		break;
	case MAP_TYPE_PREFIX:
		if (snprintf(buf, sizeof(buf), "%s/%u",
		    log_addr(map->fec.prefix.af, &map->fec.prefix.prefix),
		    map->fec.prefix.prefixlen) == -1)
			return ("???");
		break;
	case MAP_TYPE_PWID:
		if (snprintf(buf, sizeof(buf), "pw-id %u group-id %u (%s)",
		    map->fec.pwid.pwid, map->fec.pwid.group_id,
		    pw_type_name(map->fec.pwid.type)) == -1)
			return ("???");
		break;
	case MAP_TYPE_TYPED_WCARD:
		if (snprintf(buf, sizeof(buf), "typed wildcard") < 0)
			return ("???");
		switch (map->fec.twcard.type) {
		case MAP_TYPE_PREFIX:
			if (snprintf(buf + strlen(buf), sizeof(buf) -
			    strlen(buf), " (prefix, address-family %s)",
			    af_name(map->fec.twcard.u.prefix_af)) < 0)
				return ("???");
			break;
		case MAP_TYPE_PWID:
			if (snprintf(buf + strlen(buf), sizeof(buf) -
			    strlen(buf), " (pwid, type %s)",
			    pw_type_name(map->fec.twcard.u.pw_type)) < 0)
				return ("???");
			break;
		default:
			if (snprintf(buf + strlen(buf), sizeof(buf) -
			    strlen(buf), " (unknown type)") < 0)
				return ("???");
			break;
		}
		break;
	default:
		return ("???");
	}

	return (buf);
}

const char *
log_fec(const struct fec *fec)
{
	static char	buf[64];
	union ldpd_addr	addr;

	switch (fec->type) {
	case FEC_TYPE_IPV4:
		addr.v4 = fec->u.ipv4.prefix;
		if (snprintf(buf, sizeof(buf), "ipv4 %s/%u",
		    log_addr(AF_INET, &addr), fec->u.ipv4.prefixlen) == -1)
			return ("???");
		break;
	case FEC_TYPE_IPV6:
		addr.v6 = fec->u.ipv6.prefix;
		if (snprintf(buf, sizeof(buf), "ipv6 %s/%u",
		    log_addr(AF_INET6, &addr), fec->u.ipv6.prefixlen) == -1)
			return ("???");
		break;
	case FEC_TYPE_PWID:
		if (snprintfrr(buf, sizeof(buf),
			       "pwid %u (%s) - %pI4",
			       fec->u.pwid.pwid, pw_type_name(fec->u.pwid.type),
			       &fec->u.pwid.lsr_id) == -1)
			return ("???");
		break;
	default:
		return ("???");
	}

	return (buf);
}

/* names */
const char *
af_name(int af)
{
	switch (af) {
	case AF_INET:
		return ("ipv4");
	case AF_INET6:
		return ("ipv6");
#ifdef AF_MPLS
	case AF_MPLS:
		return ("mpls");
#endif
	default:
		return ("UNKNOWN");
	}
}

const char *
socket_name(int type)
{
	switch (type) {
	case LDP_SOCKET_DISC:
		return ("discovery");
	case LDP_SOCKET_EDISC:
		return ("extended discovery");
	case LDP_SOCKET_SESSION:
		return ("session");
	default:
		return ("UNKNOWN");
	}
}

const char *
nbr_state_name(int state)
{
	switch (state) {
	case NBR_STA_PRESENT:
		return ("PRESENT");
	case NBR_STA_INITIAL:
		return ("INITIALIZED");
	case NBR_STA_OPENREC:
		return ("OPENREC");
	case NBR_STA_OPENSENT:
		return ("OPENSENT");
	case NBR_STA_OPER:
		return ("OPERATIONAL");
	default:
		return ("UNKNOWN");
	}
}

const char *
if_state_name(int state)
{
	switch (state) {
	case IF_STA_DOWN:
		return ("DOWN");
	case IF_STA_ACTIVE:
		return ("ACTIVE");
	default:
		return ("UNKNOWN");
	}
}

const char *
if_type_name(enum iface_type type)
{
	switch (type) {
	case IF_TYPE_POINTOPOINT:
		return ("POINTOPOINT");
	case IF_TYPE_BROADCAST:
		return ("BROADCAST");
	}
	/* NOTREACHED */
	return ("UNKNOWN");
}

const char *
msg_name(uint16_t msg)
{
	static char buf[16];

	switch (msg) {
	case MSG_TYPE_NOTIFICATION:
		return ("notification");
	case MSG_TYPE_HELLO:
		return ("hello");
	case MSG_TYPE_INIT:
		return ("initialization");
	case MSG_TYPE_KEEPALIVE:
		return ("keepalive");
	case MSG_TYPE_CAPABILITY:
		return ("capability");
	case MSG_TYPE_ADDR:
		return ("address");
	case MSG_TYPE_ADDRWITHDRAW:
		return ("address withdraw");
	case MSG_TYPE_LABELMAPPING:
		return ("label mapping");
	case MSG_TYPE_LABELREQUEST:
		return ("label request");
	case MSG_TYPE_LABELWITHDRAW:
		return ("label withdraw");
	case MSG_TYPE_LABELRELEASE:
		return ("label release");
	case MSG_TYPE_LABELABORTREQ:
	default:
		snprintf(buf, sizeof(buf), "[%08x]", msg);
		return (buf);
	}
}

const char *
status_code_name(uint32_t status)
{
	static char buf[16];

	switch (status) {
	case S_SUCCESS:
		return ("Success");
	case S_BAD_LDP_ID:
		return ("Bad LDP Identifier");
	case S_BAD_PROTO_VER:
		return ("Bad Protocol Version");
	case S_BAD_PDU_LEN:
		return ("Bad PDU Length");
	case S_UNKNOWN_MSG:
		return ("Unknown Message Type");
	case S_BAD_MSG_LEN:
		return ("Bad Message Length");
	case S_UNKNOWN_TLV:
		return ("Unknown TLV");
	case S_BAD_TLV_LEN:
		return ("Bad TLV Length");
	case S_BAD_TLV_VAL:
		return ("Malformed TLV Value");
	case S_HOLDTIME_EXP:
		return ("Hold Timer Expired");
	case S_SHUTDOWN:
		return ("Shutdown");
	case S_LOOP_DETECTED:
		return ("Loop Detected");
	case S_UNKNOWN_FEC:
		return ("Unknown FEC");
	case S_NO_ROUTE:
		return ("No Route");
	case S_NO_LABEL_RES:
		return ("No Label Resources");
	case S_AVAILABLE:
		return ("Label Resources Available");
	case S_NO_HELLO:
		return ("Session Rejected, No Hello");
	case S_PARM_ADV_MODE:
		return ("Rejected Advertisement Mode Parameter");
	case S_MAX_PDU_LEN:
		return ("Rejected Max PDU Length Parameter");
	case S_PARM_L_RANGE:
		return ("Rejected Label Range Parameter");
	case S_KEEPALIVE_TMR:
		return ("KeepAlive Timer Expired");
	case S_LAB_REQ_ABRT:
		return ("Label Request Aborted");
	case S_MISS_MSG:
		return ("Missing Message Parameters");
	case S_UNSUP_ADDR:
		return ("Unsupported Address Family");
	case S_KEEPALIVE_BAD:
		return ("Bad KeepAlive Time");
	case S_INTERN_ERR:
		return ("Internal Error");
	case S_ILLEGAL_CBIT:
		return ("Illegal C-Bit");
	case S_WRONG_CBIT:
		return ("Wrong C-Bit");
	case S_INCPT_BITRATE:
		return ("Incompatible bit-rate");
	case S_CEP_MISCONF:
		return ("CEP-TDM mis-configuration");
	case S_PW_STATUS:
		return ("PW Status");
	case S_UNASSIGN_TAI:
		return ("Unassigned/Unrecognized TAI");
	case S_MISCONF_ERR:
		return ("Generic Misconfiguration Error");
	case S_WITHDRAW_MTHD:
		return ("Label Withdraw PW Status Method");
	case S_UNSSUPORTDCAP:
		return ("Unsupported Capability");
	case S_ENDOFLIB:
		return ("End-of-LIB");
	case S_TRANS_MISMTCH:
		return ("Transport Connection Mismatch");
	case S_DS_NONCMPLNCE:
		return ("Dual-Stack Noncompliance");
	default:
		snprintf(buf, sizeof(buf), "[%08x]", status);
		return (buf);
	}
}

const char *
pw_type_name(uint16_t pw_type)
{
	static char buf[64];

	switch (pw_type) {
	case PW_TYPE_ETHERNET_TAGGED:
		return ("Eth Tagged");
	case PW_TYPE_ETHERNET:
		return ("Ethernet");
	case PW_TYPE_WILDCARD:
		return ("Wildcard");
	default:
		snprintf(buf, sizeof(buf), "[%0x]", pw_type);
		return (buf);
	}
}

const char *
pw_error_code(uint8_t status)
{
	static char buf[16];

	switch (status) {
	case F_PW_NO_ERR:
		return ("No Error");
	case F_PW_LOCAL_NOT_FWD:
		return ("local not forwarding");
	case F_PW_REMOTE_NOT_FWD:
		return ("remote not forwarding");
	case F_PW_NO_REMOTE_LABEL:
		return ("no remote label");
	case F_PW_MTU_MISMATCH:
		return ("mtu mismatch between peers");
	default:
		snprintf(buf, sizeof(buf), "[%0x]", status);
		return (buf);
	}
}
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: ISC
fa68f9da RW	2	/* $OpenBSD$ */
	3
	4	/*
	5	* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
fa68f9da RW	6	*/
	7
	8	#include <zebra.h>
903a7226	9	#include "lib/printfrr.h"
fa68f9da RW	10
	11	#include "mpls.h"
	12
	13	#include "ldpd.h"
	14	#include "ldpe.h"
	15	#include "lde.h"
	16
	17	#define NUM_LOGS 4
	18	const char *
	19	log_sockaddr(void *vp)
	20	{
	21	static char buf[NUM_LOGS][NI_MAXHOST];
	22	static int round = 0;
	23	struct sockaddr *sa = vp;
	24
	25	round = (round + 1) % NUM_LOGS;
	26
	27	if (getnameinfo(sa, sockaddr_len(sa), buf[round], NI_MAXHOST, NULL, 0,
	28	NI_NUMERICHOST))
	29	return ("(unknown)");
	30	else
	31	return (buf[round]);
	32	}
	33
	34	const char *
	35	log_in6addr(const struct in6_addr *addr)
	36	{
	37	struct sockaddr_in6 sa_in6;
	38
	39	memset(&sa_in6, 0, sizeof(sa_in6));
	40	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	41	sa_in6.sin6_len = sizeof(sa_in6);
	42	#endif
	43	sa_in6.sin6_family = AF_INET6;
	44	sa_in6.sin6_addr = *addr;
	45
	46	recoverscope(&sa_in6);
	47
	48	return (log_sockaddr(&sa_in6));
	49	}
	50
	51	const char *
6cd8093d	52	log_in6addr_scope(const struct in6_addr *addr, ifindex_t ifindex)
fa68f9da RW	53	{
	54	struct sockaddr_in6 sa_in6;
	55
	56	memset(&sa_in6, 0, sizeof(sa_in6));
	57	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	58	sa_in6.sin6_len = sizeof(sa_in6);
	59	#endif
	60	sa_in6.sin6_family = AF_INET6;
	61	sa_in6.sin6_addr = *addr;
	62
	63	addscope(&sa_in6, ifindex);
	64
	65	return (log_sockaddr(&sa_in6));
	66	}
	67
	68	const char *
	69	log_addr(int af, const union ldpd_addr *addr)
	70	{
	71	static char buf[NUM_LOGS][INET6_ADDRSTRLEN];
	72	static int round = 0;
	73
	74	switch (af) {
	75	case AF_INET:
	76	round = (round + 1) % NUM_LOGS;
	77	if (inet_ntop(AF_INET, &addr->v4, buf[round],
	78	sizeof(buf[round])) == NULL)
	79	return ("???");
	80	return (buf[round]);
	81	case AF_INET6:
	82	return (log_in6addr(&addr->v6));
	83	default:
	84	break;
	85	}
	86
	87	return ("???");
	88	}
	89
	90	#define TF_BUFS 4
	91	#define TF_LEN 32
	92
	93	char *
	94	log_label(uint32_t label)
	95	{
	96	char *buf;
	97	static char tfbuf[TF_BUFS][TF_LEN]; /* ring buffer */
	98	static int idx = 0;
	99
	100	buf = tfbuf[idx++];
	101	if (idx == TF_BUFS)
	102	idx = 0;
	103
	104	switch (label) {
	105	case NO_LABEL:
	106	snprintf(buf, TF_LEN, "-");
	107	break;
70e98a7f	108	case MPLS_LABEL_IMPLICIT_NULL:
fa68f9da RW	109	snprintf(buf, TF_LEN, "imp-null");
fa68f9da RW	110	break;
70e98a7f DS	111	case MPLS_LABEL_IPV4_EXPLICIT_NULL:
70e98a7f DS	112	case MPLS_LABEL_IPV6_EXPLICIT_NULL:
fa68f9da RW	113	snprintf(buf, TF_LEN, "exp-null");
	114	break;
	115	default:
	116	snprintf(buf, TF_LEN, "%u", label);
	117	break;
	118	}
	119
	120	return (buf);
	121	}
	122
	123	const char *
	124	log_time(time_t t)
	125	{
	126	char *buf;
	127	static char tfbuf[TF_BUFS][TF_LEN]; /* ring buffer */
	128	static int idx = 0;
b6ee94b5	129	uint64_t sec, min, hrs, day, week;
fa68f9da RW	130
	131	buf = tfbuf[idx++];
	132	if (idx == TF_BUFS)
	133	idx = 0;
	134
	135	week = t;
	136
	137	sec = week % 60;
	138	week /= 60;
	139	min = week % 60;
	140	week /= 60;
	141	hrs = week % 24;
	142	week /= 24;
	143	day = week % 7;
	144	week /= 7;
	145
	146	if (week > 0)
b6ee94b5 RZ	147	snprintfrr(buf, TF_LEN,
	148	"%02" PRIu64 "w%01" PRIu64 "d%02" PRIu64 "h", week,
	149	day, hrs);
fa68f9da	150	else if (day > 0)
b6ee94b5 RZ	151	snprintfrr(buf, TF_LEN,
	152	"%01" PRIu64 "d%02" PRIu64 "h%02" PRIu64 "m", day,
	153	hrs, min);
fa68f9da	154	else
b6ee94b5 RZ	155	snprintfrr(buf, TF_LEN,
	156	"%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64, hrs, min,
	157	sec);
fa68f9da RW	158
	159	return (buf);
	160	}
	161
	162	char *
	163	log_hello_src(const struct hello_source *src)
	164	{
	165	static char buf[64];
	166
	167	switch (src->type) {
	168	case HELLO_LINK:
	169	snprintf(buf, sizeof(buf), "iface %s",
	170	src->link.ia->iface->name);
	171	break;
	172	case HELLO_TARGETED:
	173	snprintf(buf, sizeof(buf), "source %s",
	174	log_addr(src->target->af, &src->target->addr));
	175	break;
	176	}
	177
	178	return (buf);
	179	}
	180
	181	const char *
	182	log_map(const struct map *map)
	183	{
	184	static char buf[128];
	185
	186	switch (map->type) {
	187	case MAP_TYPE_WILDCARD:
	188	if (snprintf(buf, sizeof(buf), "wildcard") < 0)
	189	return ("???");
	190	break;
	191	case MAP_TYPE_PREFIX:
	192	if (snprintf(buf, sizeof(buf), "%s/%u",
	193	log_addr(map->fec.prefix.af, &map->fec.prefix.prefix),
	194	map->fec.prefix.prefixlen) == -1)
	195	return ("???");
	196	break;
	197	case MAP_TYPE_PWID:
	198	if (snprintf(buf, sizeof(buf), "pw-id %u group-id %u (%s)",
	199	map->fec.pwid.pwid, map->fec.pwid.group_id,
	200	pw_type_name(map->fec.pwid.type)) == -1)
	201	return ("???");
	202	break;
	203	case MAP_TYPE_TYPED_WCARD:
	204	if (snprintf(buf, sizeof(buf), "typed wildcard") < 0)
	205	return ("???");
	206	switch (map->fec.twcard.type) {
	207	case MAP_TYPE_PREFIX:
	208	if (snprintf(buf + strlen(buf), sizeof(buf) -
	209	strlen(buf), " (prefix, address-family %s)",
	210	af_name(map->fec.twcard.u.prefix_af)) < 0)
	211	return ("???");
	212	break;
	213	case MAP_TYPE_PWID:
	214	if (snprintf(buf + strlen(buf), sizeof(buf) -
	215	strlen(buf), " (pwid, type %s)",
	216	pw_type_name(map->fec.twcard.u.pw_type)) < 0)
	217	return ("???");
	218	break;
	219	default:
	220	if (snprintf(buf + strlen(buf), sizeof(buf) -
	221	strlen(buf), " (unknown type)") < 0)
222	return ("???");
223	break;
224	}
225	break;
226	default:
227	return ("???");
228	}
229
230	return (buf);
231	}
232
233	const char *
234	log_fec(const struct fec *fec)
235	{
236	static char buf[64];
237	union ldpd_addr addr;
238
239	switch (fec->type) {
240	case FEC_TYPE_IPV4:
241	addr.v4 = fec->u.ipv4.prefix;
242	if (snprintf(buf, sizeof(buf), "ipv4 %s/%u",
243	log_addr(AF_INET, &addr), fec->u.ipv4.prefixlen) == -1)
244	return ("???");
245	break;
246	case FEC_TYPE_IPV6:
247	addr.v6 = fec->u.ipv6.prefix;
248	if (snprintf(buf, sizeof(buf), "ipv6 %s/%u",
249	log_addr(AF_INET6, &addr), fec->u.ipv6.prefixlen) == -1)
250	return ("???");
251	break;
252	case FEC_TYPE_PWID:
903a7226 MS	253	if (snprintfrr(buf, sizeof(buf),
	254	"pwid %u (%s) - %pI4",
	255	fec->u.pwid.pwid, pw_type_name(fec->u.pwid.type),
	256	&fec->u.pwid.lsr_id) == -1)
fa68f9da RW	257	return ("???");
	258	break;
	259	default:
	260	return ("???");
	261	}
	262
	263	return (buf);
	264	}
	265
	266	/* names */
	267	const char *
	268	af_name(int af)
	269	{
	270	switch (af) {
	271	case AF_INET:
	272	return ("ipv4");
	273	case AF_INET6:
	274	return ("ipv6");
	275	#ifdef AF_MPLS
	276	case AF_MPLS:
	277	return ("mpls");
	278	#endif
	279	default:
	280	return ("UNKNOWN");
	281	}
	282	}
	283
	284	const char *
	285	socket_name(int type)
	286	{
	287	switch (type) {
	288	case LDP_SOCKET_DISC:
	289	return ("discovery");
	290	case LDP_SOCKET_EDISC:
	291	return ("extended discovery");
	292	case LDP_SOCKET_SESSION:
	293	return ("session");
	294	default:
	295	return ("UNKNOWN");
	296	}
	297	}
	298
	299	const char *
	300	nbr_state_name(int state)
	301	{
	302	switch (state) {
	303	case NBR_STA_PRESENT:
	304	return ("PRESENT");
	305	case NBR_STA_INITIAL:
	306	return ("INITIALIZED");
	307	case NBR_STA_OPENREC:
	308	return ("OPENREC");
	309	case NBR_STA_OPENSENT:
	310	return ("OPENSENT");
	311	case NBR_STA_OPER:
	312	return ("OPERATIONAL");
	313	default:
	314	return ("UNKNOWN");
	315	}
	316	}
	317
	318	const char *
	319	if_state_name(int state)
	320	{
321	switch (state) {
322	case IF_STA_DOWN:
323	return ("DOWN");
324	case IF_STA_ACTIVE:
325	return ("ACTIVE");
326	default:
327	return ("UNKNOWN");
328	}
329	}
330
331	const char *
332	if_type_name(enum iface_type type)
333	{
334	switch (type) {
335	case IF_TYPE_POINTOPOINT:
336	return ("POINTOPOINT");
337	case IF_TYPE_BROADCAST:
338	return ("BROADCAST");
339	}
340	/* NOTREACHED */
341	return ("UNKNOWN");
342	}
343
344	const char *
345	msg_name(uint16_t msg)
346	{
347	static char buf[16];
348
349	switch (msg) {
350	case MSG_TYPE_NOTIFICATION:
351	return ("notification");
352	case MSG_TYPE_HELLO:
353	return ("hello");
354	case MSG_TYPE_INIT:
355	return ("initialization");
356	case MSG_TYPE_KEEPALIVE:
357	return ("keepalive");
358	case MSG_TYPE_CAPABILITY:
359	return ("capability");
360	case MSG_TYPE_ADDR:
361	return ("address");
362	case MSG_TYPE_ADDRWITHDRAW:
363	return ("address withdraw");
364	case MSG_TYPE_LABELMAPPING:
365	return ("label mapping");
366	case MSG_TYPE_LABELREQUEST:
367	return ("label request");
368	case MSG_TYPE_LABELWITHDRAW:
369	return ("label withdraw");
370	case MSG_TYPE_LABELRELEASE:
371	return ("label release");
372	case MSG_TYPE_LABELABORTREQ:
373	default:
374	snprintf(buf, sizeof(buf), "[%08x]", msg);
375	return (buf);
376	}
377	}
378
379	const char *
380	status_code_name(uint32_t status)
381	{
382	static char buf[16];
383
384	switch (status) {
385	case S_SUCCESS:
386	return ("Success");
387	case S_BAD_LDP_ID:
388	return ("Bad LDP Identifier");
389	case S_BAD_PROTO_VER:
390	return ("Bad Protocol Version");
391	case S_BAD_PDU_LEN:
392	return ("Bad PDU Length");
393	case S_UNKNOWN_MSG:
394	return ("Unknown Message Type");
395	case S_BAD_MSG_LEN:
396	return ("Bad Message Length");
397	case S_UNKNOWN_TLV:
398	return ("Unknown TLV");
399	case S_BAD_TLV_LEN:
400	return ("Bad TLV Length");
401	case S_BAD_TLV_VAL:
402	return ("Malformed TLV Value");
403	case S_HOLDTIME_EXP:
404	return ("Hold Timer Expired");
405	case S_SHUTDOWN:
406	return ("Shutdown");
407	case S_LOOP_DETECTED:
408	return ("Loop Detected");
409	case S_UNKNOWN_FEC:
410	return ("Unknown FEC");
411	case S_NO_ROUTE:
412	return ("No Route");
413	case S_NO_LABEL_RES:
414	return ("No Label Resources");
415	case S_AVAILABLE:
416	return ("Label Resources Available");
417	case S_NO_HELLO:
418	return ("Session Rejected, No Hello");
419	case S_PARM_ADV_MODE:
420	return ("Rejected Advertisement Mode Parameter");
421	case S_MAX_PDU_LEN:
422	return ("Rejected Max PDU Length Parameter");
423	case S_PARM_L_RANGE:
424	return ("Rejected Label Range Parameter");
425	case S_KEEPALIVE_TMR:
426	return ("KeepAlive Timer Expired");
427	case S_LAB_REQ_ABRT:
428	return ("Label Request Aborted");
429	case S_MISS_MSG:
430	return ("Missing Message Parameters");
431	case S_UNSUP_ADDR:
432	return ("Unsupported Address Family");
433	case S_KEEPALIVE_BAD:
434	return ("Bad KeepAlive Time");
435	case S_INTERN_ERR:
436	return ("Internal Error");
437	case S_ILLEGAL_CBIT:
438	return ("Illegal C-Bit");
439	case S_WRONG_CBIT:
440	return ("Wrong C-Bit");
441	case S_INCPT_BITRATE:
442	return ("Incompatible bit-rate");
443	case S_CEP_MISCONF:
444	return ("CEP-TDM mis-configuration");
445	case S_PW_STATUS:
446	return ("PW Status");
447	case S_UNASSIGN_TAI:
448	return ("Unassigned/Unrecognized TAI");
449	case S_MISCONF_ERR:
450	return ("Generic Misconfiguration Error");
451	case S_WITHDRAW_MTHD:
452	return ("Label Withdraw PW Status Method");
453	case S_UNSSUPORTDCAP:
454	return ("Unsupported Capability");
455	case S_ENDOFLIB:
456	return ("End-of-LIB");
457	case S_TRANS_MISMTCH:
458	return ("Transport Connection Mismatch");
459	case S_DS_NONCMPLNCE:
460	return ("Dual-Stack Noncompliance");
461	default:
462	snprintf(buf, sizeof(buf), "[%08x]", status);
463	return (buf);
464	}
465	}
466
467	const char *
468	pw_type_name(uint16_t pw_type)
469	{
470	static char buf[64];
471
472	switch (pw_type) {
473	case PW_TYPE_ETHERNET_TAGGED:
474	return ("Eth Tagged");
475	case PW_TYPE_ETHERNET:
476	return ("Ethernet");
477	case PW_TYPE_WILDCARD:
478	return ("Wildcard");
479	default:
480	snprintf(buf, sizeof(buf), "[%0x]", pw_type);
481	return (buf);
482	}
483	}
6bbdd9e9	484
	485	const char *
	486	pw_error_code(uint8_t status)
	487	{
	488	static char buf[16];
	489
	490	switch (status) {
	491	case F_PW_NO_ERR:
	492	return ("No Error");
	493	case F_PW_LOCAL_NOT_FWD:
	494	return ("local not forwarding");
	495	case F_PW_REMOTE_NOT_FWD:
	496	return ("remote not forwarding");
	497	case F_PW_NO_REMOTE_LABEL:
	498	return ("no remote label");
	499	case F_PW_MTU_MISMATCH:
	500	return ("mtu mismatch between peers");
	501	default:
	502	snprintf(buf, sizeof(buf), "[%0x]", status);
	503	return (buf);
	504	}
	505	}