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