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