Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/ldpd/logmsg.c	Lines:	0	177	0.0 %
Date:	2017-11-07	Branches:	0	124	0.0 %


/*	$OpenBSD: logmsg.c,v 1.6 2017/03/04 00:15:35 renato Exp $ */

/*
 * 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 <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netmpls/mpls.h>
#include <stdio.h>
#include <string.h>
#include <netdb.h>

#include "ldp.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, sa->sa_len, 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));
	sa_in6.sin6_len = sizeof(sa_in6);
	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, unsigned int ifindex)
{
	struct sockaddr_in6	sa_in6;

	memset(&sa_in6, 0, sizeof(sa_in6));
	sa_in6.sin6_len = sizeof(sa_in6);
	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_IMPLNULL:
		snprintf(buf, TF_LEN, "imp-null");
		break;
	case MPLS_LABEL_IPV4NULL:
	case MPLS_LABEL_IPV6NULL:
		snprintf(buf, TF_LEN, "exp-null");
		break;
	default:
		snprintf(buf, TF_LEN, "%u", label);
		break;
	}

	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 (snprintf(buf, sizeof(buf),
		    "pwid %u (%s) - %s",
		    fec->u.pwid.pwid, pw_type_name(fec->u.pwid.type),
		    inet_ntoa(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");
	case AF_MPLS:
		return ("mpls");
	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);
	}
}


Generated by: GCOVR (Version 3.3)

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