1 /* $OpenBSD: logmsg.c,v 1.1 2017/01/20 12:19:18 benno 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[64]; 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), "pwid %u (%s)", 172 map->fec.pwid.pwid, 173 pw_type_name(map->fec.pwid.type)) == -1) 174 return ("???"); 175 break; 176 default: 177 return ("???"); 178 } 179 180 return (buf); 181 } 182 183 const char * 184 log_fec(const struct fec *fec) 185 { 186 static char buf[64]; 187 union ldpd_addr addr; 188 189 switch (fec->type) { 190 case FEC_TYPE_IPV4: 191 addr.v4 = fec->u.ipv4.prefix; 192 if (snprintf(buf, sizeof(buf), "ipv4 %s/%u", 193 log_addr(AF_INET, &addr), fec->u.ipv4.prefixlen) == -1) 194 return ("???"); 195 break; 196 case FEC_TYPE_IPV6: 197 addr.v6 = fec->u.ipv6.prefix; 198 if (snprintf(buf, sizeof(buf), "ipv6 %s/%u", 199 log_addr(AF_INET6, &addr), fec->u.ipv6.prefixlen) == -1) 200 return ("???"); 201 break; 202 case FEC_TYPE_PWID: 203 if (snprintf(buf, sizeof(buf), 204 "pwid %u (%s) - %s", 205 fec->u.pwid.pwid, pw_type_name(fec->u.pwid.type), 206 inet_ntoa(fec->u.pwid.lsr_id)) == -1) 207 return ("???"); 208 break; 209 default: 210 return ("???"); 211 } 212 213 return (buf); 214 } 215 216 /* names */ 217 const char * 218 af_name(int af) 219 { 220 switch (af) { 221 case AF_INET: 222 return ("ipv4"); 223 case AF_INET6: 224 return ("ipv6"); 225 case AF_MPLS: 226 return ("mpls"); 227 default: 228 return ("UNKNOWN"); 229 } 230 } 231 232 const char * 233 socket_name(int type) 234 { 235 switch (type) { 236 case LDP_SOCKET_DISC: 237 return ("discovery"); 238 case LDP_SOCKET_EDISC: 239 return ("extended discovery"); 240 case LDP_SOCKET_SESSION: 241 return ("session"); 242 default: 243 return ("UNKNOWN"); 244 } 245 } 246 247 const char * 248 nbr_state_name(int state) 249 { 250 switch (state) { 251 case NBR_STA_PRESENT: 252 return ("PRESENT"); 253 case NBR_STA_INITIAL: 254 return ("INITIALIZED"); 255 case NBR_STA_OPENREC: 256 return ("OPENREC"); 257 case NBR_STA_OPENSENT: 258 return ("OPENSENT"); 259 case NBR_STA_OPER: 260 return ("OPERATIONAL"); 261 default: 262 return ("UNKNOWN"); 263 } 264 } 265 266 const char * 267 if_state_name(int state) 268 { 269 switch (state) { 270 case IF_STA_DOWN: 271 return ("DOWN"); 272 case IF_STA_ACTIVE: 273 return ("ACTIVE"); 274 default: 275 return ("UNKNOWN"); 276 } 277 } 278 279 const char * 280 if_type_name(enum iface_type type) 281 { 282 switch (type) { 283 case IF_TYPE_POINTOPOINT: 284 return ("POINTOPOINT"); 285 case IF_TYPE_BROADCAST: 286 return ("BROADCAST"); 287 } 288 /* NOTREACHED */ 289 return ("UNKNOWN"); 290 } 291 292 const char * 293 msg_name(uint16_t msg) 294 { 295 static char buf[16]; 296 297 switch (msg) { 298 case MSG_TYPE_NOTIFICATION: 299 return ("notification"); 300 case MSG_TYPE_HELLO: 301 return ("hello"); 302 case MSG_TYPE_INIT: 303 return ("initialization"); 304 case MSG_TYPE_KEEPALIVE: 305 return ("keepalive"); 306 case MSG_TYPE_ADDR: 307 return ("address"); 308 case MSG_TYPE_ADDRWITHDRAW: 309 return ("address withdraw"); 310 case MSG_TYPE_LABELMAPPING: 311 return ("label mapping"); 312 case MSG_TYPE_LABELREQUEST: 313 return ("label request"); 314 case MSG_TYPE_LABELWITHDRAW: 315 return ("label withdraw"); 316 case MSG_TYPE_LABELRELEASE: 317 return ("label release"); 318 case MSG_TYPE_LABELABORTREQ: 319 default: 320 snprintf(buf, sizeof(buf), "[%08x]", msg); 321 return (buf); 322 } 323 } 324 325 const char * 326 status_code_name(uint32_t status) 327 { 328 static char buf[16]; 329 330 switch (status) { 331 case S_SUCCESS: 332 return ("Success"); 333 case S_BAD_LDP_ID: 334 return ("Bad LDP Identifier"); 335 case S_BAD_PROTO_VER: 336 return ("Bad Protocol Version"); 337 case S_BAD_PDU_LEN: 338 return ("Bad PDU Length"); 339 case S_UNKNOWN_MSG: 340 return ("Unknown Message Type"); 341 case S_BAD_MSG_LEN: 342 return ("Bad Message Length"); 343 case S_UNKNOWN_TLV: 344 return ("Unknown TLV"); 345 case S_BAD_TLV_LEN: 346 return ("Bad TLV Length"); 347 case S_BAD_TLV_VAL: 348 return ("Malformed TLV Value"); 349 case S_HOLDTIME_EXP: 350 return ("Hold Timer Expired"); 351 case S_SHUTDOWN: 352 return ("Shutdown"); 353 case S_LOOP_DETECTED: 354 return ("Loop Detected"); 355 case S_UNKNOWN_FEC: 356 return ("Unknown FEC"); 357 case S_NO_ROUTE: 358 return ("No Route"); 359 case S_NO_LABEL_RES: 360 return ("No Label Resources"); 361 case S_AVAILABLE: 362 return ("Label Resources Available"); 363 case S_NO_HELLO: 364 return ("Session Rejected, No Hello"); 365 case S_PARM_ADV_MODE: 366 return ("Rejected Advertisement Mode Parameter"); 367 case S_MAX_PDU_LEN: 368 return ("Rejected Max PDU Length Parameter"); 369 case S_PARM_L_RANGE: 370 return ("Rejected Label Range Parameter"); 371 case S_KEEPALIVE_TMR: 372 return ("KeepAlive Timer Expired"); 373 case S_LAB_REQ_ABRT: 374 return ("Label Request Aborted"); 375 case S_MISS_MSG: 376 return ("Missing Message Parameters"); 377 case S_UNSUP_ADDR: 378 return ("Unsupported Address Family"); 379 case S_KEEPALIVE_BAD: 380 return ("Bad KeepAlive Time"); 381 case S_INTERN_ERR: 382 return ("Internal Error"); 383 case S_ILLEGAL_CBIT: 384 return ("Illegal C-Bit"); 385 case S_WRONG_CBIT: 386 return ("Wrong C-Bit"); 387 case S_INCPT_BITRATE: 388 return ("Incompatible bit-rate"); 389 case S_CEP_MISCONF: 390 return ("CEP-TDM mis-configuration"); 391 case S_PW_STATUS: 392 return ("PW Status"); 393 case S_UNASSIGN_TAI: 394 return ("Unassigned/Unrecognized TAI"); 395 case S_MISCONF_ERR: 396 return ("Generic Misconfiguration Error"); 397 case S_WITHDRAW_MTHD: 398 return ("Label Withdraw PW Status Method"); 399 case S_TRANS_MISMTCH: 400 return ("Transport Connection Mismatch"); 401 case S_DS_NONCMPLNCE: 402 return ("Dual-Stack Noncompliance"); 403 default: 404 snprintf(buf, sizeof(buf), "[%08x]", status); 405 return (buf); 406 } 407 } 408 409 const char * 410 pw_type_name(uint16_t pw_type) 411 { 412 static char buf[64]; 413 414 switch (pw_type) { 415 case PW_TYPE_ETHERNET_TAGGED: 416 return ("Eth Tagged"); 417 case PW_TYPE_ETHERNET: 418 return ("Ethernet"); 419 default: 420 snprintf(buf, sizeof(buf), "[%0x]", pw_type); 421 return (buf); 422 } 423 } 424