]>
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"); |
110 | break; | |
70e98a7f DS |
111 | case MPLS_LABEL_IPV4_EXPLICIT_NULL: |
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 | } |