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