ldpd/logmsg.c

   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 #include "lib/printfrr.h"
  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 *
  63 log_in6addr_scope(const struct in6_addr *addr, ifindex_t ifindex)
  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;
 119         case MPLS_LABEL_IMPLICIT_NULL:
 120                 snprintf(buf, TF_LEN, "imp-null");
 121                 break;
 122         case MPLS_LABEL_IPV4_EXPLICIT_NULL:
 123         case MPLS_LABEL_IPV6_EXPLICIT_NULL:
 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         uint64_t         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                 snprintfrr(buf, TF_LEN,
 159                            "%02" PRIu64 "w%01" PRIu64 "d%02" PRIu64 "h", week,
 160                            day, hrs);
 161         else if (day > 0)
 162                 snprintfrr(buf, TF_LEN,
 163                            "%01" PRIu64 "d%02" PRIu64 "h%02" PRIu64 "m", day,
 164                            hrs, min);
 165         else
 166                 snprintfrr(buf, TF_LEN,
 167                            "%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64, hrs, min,
 168                            sec);
 169
 170         return (buf);
 171 }
 172
 173 char *
 174 log_hello_src(const struct hello_source *src)
 175 {
 176         static char buf[64];
 177
 178         switch (src->type) {
 179         case HELLO_LINK:
 180                 snprintf(buf, sizeof(buf), "iface %s",
 181                     src->link.ia->iface->name);
 182                 break;
 183         case HELLO_TARGETED:
 184                 snprintf(buf, sizeof(buf), "source %s",
 185                     log_addr(src->target->af, &src->target->addr));
 186                 break;
 187         }
 188
 189         return (buf);
 190 }
 191
 192 const char *
 193 log_map(const struct map *map)
 194 {
 195         static char     buf[128];
 196
 197         switch (map->type) {
 198         case MAP_TYPE_WILDCARD:
 199                 if (snprintf(buf, sizeof(buf), "wildcard") < 0)
 200                         return ("???");
 201                 break;
 202         case MAP_TYPE_PREFIX:
 203                 if (snprintf(buf, sizeof(buf), "%s/%u",
 204                     log_addr(map->fec.prefix.af, &map->fec.prefix.prefix),
 205                     map->fec.prefix.prefixlen) == -1)
 206                         return ("???");
 207                 break;
 208         case MAP_TYPE_PWID:
 209                 if (snprintf(buf, sizeof(buf), "pw-id %u group-id %u (%s)",
 210                     map->fec.pwid.pwid, map->fec.pwid.group_id,
 211                     pw_type_name(map->fec.pwid.type)) == -1)
 212                         return ("???");
 213                 break;
 214         case MAP_TYPE_TYPED_WCARD:
 215                 if (snprintf(buf, sizeof(buf), "typed wildcard") < 0)
 216                         return ("???");
 217                 switch (map->fec.twcard.type) {
 218                 case MAP_TYPE_PREFIX:
 219                         if (snprintf(buf + strlen(buf), sizeof(buf) -
 220                             strlen(buf), " (prefix, address-family %s)",
 221                             af_name(map->fec.twcard.u.prefix_af)) < 0)
 222                                 return ("???");
 223                         break;
 224                 case MAP_TYPE_PWID:
 225                         if (snprintf(buf + strlen(buf), sizeof(buf) -
 226                             strlen(buf), " (pwid, type %s)",
 227                             pw_type_name(map->fec.twcard.u.pw_type)) < 0)
 228                                 return ("???");
 229                         break;
 230                 default:
 231                         if (snprintf(buf + strlen(buf), sizeof(buf) -
 232                             strlen(buf), " (unknown type)") < 0)
 233                                 return ("???");
 234                         break;
 235                 }
 236                 break;
 237         default:
 238                 return ("???");
 239         }
 240
 241         return (buf);
 242 }
 243
 244 const char *
 245 log_fec(const struct fec *fec)
 246 {
 247         static char     buf[64];
 248         union ldpd_addr addr;
 249
 250         switch (fec->type) {
 251         case FEC_TYPE_IPV4:
 252                 addr.v4 = fec->u.ipv4.prefix;
 253                 if (snprintf(buf, sizeof(buf), "ipv4 %s/%u",
 254                     log_addr(AF_INET, &addr), fec->u.ipv4.prefixlen) == -1)
 255                         return ("???");
 256                 break;
 257         case FEC_TYPE_IPV6:
 258                 addr.v6 = fec->u.ipv6.prefix;
 259                 if (snprintf(buf, sizeof(buf), "ipv6 %s/%u",
 260                     log_addr(AF_INET6, &addr), fec->u.ipv6.prefixlen) == -1)
 261                         return ("???");
 262                 break;
 263         case FEC_TYPE_PWID:
 264                 if (snprintfrr(buf, sizeof(buf),
 265                                "pwid %u (%s) - %pI4",
 266                                fec->u.pwid.pwid, pw_type_name(fec->u.pwid.type),
 267                                &fec->u.pwid.lsr_id) == -1)
 268                         return ("???");
 269                 break;
 270         default:
 271                 return ("???");
 272         }
 273
 274         return (buf);
 275 }
 276
 277 /* names */
 278 const char *
 279 af_name(int af)
 280 {
 281         switch (af) {
 282         case AF_INET:
 283                 return ("ipv4");
 284         case AF_INET6:
 285                 return ("ipv6");
 286 #ifdef AF_MPLS
 287         case AF_MPLS:
 288                 return ("mpls");
 289 #endif
 290         default:
 291                 return ("UNKNOWN");
 292         }
 293 }
 294
 295 const char *
 296 socket_name(int type)
 297 {
 298         switch (type) {
 299         case LDP_SOCKET_DISC:
 300                 return ("discovery");
 301         case LDP_SOCKET_EDISC:
 302                 return ("extended discovery");
 303         case LDP_SOCKET_SESSION:
 304                 return ("session");
 305         default:
 306                 return ("UNKNOWN");
 307         }
 308 }
 309
 310 const char *
 311 nbr_state_name(int state)
 312 {
 313         switch (state) {
 314         case NBR_STA_PRESENT:
 315                 return ("PRESENT");
 316         case NBR_STA_INITIAL:
 317                 return ("INITIALIZED");
 318         case NBR_STA_OPENREC:
 319                 return ("OPENREC");
 320         case NBR_STA_OPENSENT:
 321                 return ("OPENSENT");
 322         case NBR_STA_OPER:
 323                 return ("OPERATIONAL");
 324         default:
 325                 return ("UNKNOWN");
 326         }
 327 }
 328
 329 const char *
 330 if_state_name(int state)
 331 {
 332         switch (state) {
 333         case IF_STA_DOWN:
 334                 return ("DOWN");
 335         case IF_STA_ACTIVE:
 336                 return ("ACTIVE");
 337         default:
 338                 return ("UNKNOWN");
 339         }
 340 }
 341
 342 const char *
 343 if_type_name(enum iface_type type)
 344 {
 345         switch (type) {
 346         case IF_TYPE_POINTOPOINT:
 347                 return ("POINTOPOINT");
 348         case IF_TYPE_BROADCAST:
 349                 return ("BROADCAST");
 350         }
 351         /* NOTREACHED */
 352         return ("UNKNOWN");
 353 }
 354
 355 const char *
 356 msg_name(uint16_t msg)
 357 {
 358         static char buf[16];
 359
 360         switch (msg) {
 361         case MSG_TYPE_NOTIFICATION:
 362                 return ("notification");
 363         case MSG_TYPE_HELLO:
 364                 return ("hello");
 365         case MSG_TYPE_INIT:
 366                 return ("initialization");
 367         case MSG_TYPE_KEEPALIVE:
 368                 return ("keepalive");
 369         case MSG_TYPE_CAPABILITY:
 370                 return ("capability");
 371         case MSG_TYPE_ADDR:
 372                 return ("address");
 373         case MSG_TYPE_ADDRWITHDRAW:
 374                 return ("address withdraw");
 375         case MSG_TYPE_LABELMAPPING:
 376                 return ("label mapping");
 377         case MSG_TYPE_LABELREQUEST:
 378                 return ("label request");
 379         case MSG_TYPE_LABELWITHDRAW:
 380                 return ("label withdraw");
 381         case MSG_TYPE_LABELRELEASE:
 382                 return ("label release");
 383         case MSG_TYPE_LABELABORTREQ:
 384         default:
 385                 snprintf(buf, sizeof(buf), "[%08x]", msg);
 386                 return (buf);
 387         }
 388 }
 389
 390 const char *
 391 status_code_name(uint32_t status)
 392 {
 393         static char buf[16];
 394
 395         switch (status) {
 396         case S_SUCCESS:
 397                 return ("Success");
 398         case S_BAD_LDP_ID:
 399                 return ("Bad LDP Identifier");
 400         case S_BAD_PROTO_VER:
 401                 return ("Bad Protocol Version");
 402         case S_BAD_PDU_LEN:
 403                 return ("Bad PDU Length");
 404         case S_UNKNOWN_MSG:
 405                 return ("Unknown Message Type");
 406         case S_BAD_MSG_LEN:
 407                 return ("Bad Message Length");
 408         case S_UNKNOWN_TLV:
 409                 return ("Unknown TLV");
 410         case S_BAD_TLV_LEN:
 411                 return ("Bad TLV Length");
 412         case S_BAD_TLV_VAL:
 413                 return ("Malformed TLV Value");
 414         case S_HOLDTIME_EXP:
 415                 return ("Hold Timer Expired");
 416         case S_SHUTDOWN:
 417                 return ("Shutdown");
 418         case S_LOOP_DETECTED:
 419                 return ("Loop Detected");
 420         case S_UNKNOWN_FEC:
 421                 return ("Unknown FEC");
 422         case S_NO_ROUTE:
 423                 return ("No Route");
 424         case S_NO_LABEL_RES:
 425                 return ("No Label Resources");
 426         case S_AVAILABLE:
 427                 return ("Label Resources Available");
 428         case S_NO_HELLO:
 429                 return ("Session Rejected, No Hello");
 430         case S_PARM_ADV_MODE:
 431                 return ("Rejected Advertisement Mode Parameter");
 432         case S_MAX_PDU_LEN:
 433                 return ("Rejected Max PDU Length Parameter");
 434         case S_PARM_L_RANGE:
 435                 return ("Rejected Label Range Parameter");
 436         case S_KEEPALIVE_TMR:
 437                 return ("KeepAlive Timer Expired");
 438         case S_LAB_REQ_ABRT:
 439                 return ("Label Request Aborted");
 440         case S_MISS_MSG:
 441                 return ("Missing Message Parameters");
 442         case S_UNSUP_ADDR:
 443                 return ("Unsupported Address Family");
 444         case S_KEEPALIVE_BAD:
 445                 return ("Bad KeepAlive Time");
 446         case S_INTERN_ERR:
 447                 return ("Internal Error");
 448         case S_ILLEGAL_CBIT:
 449                 return ("Illegal C-Bit");
 450         case S_WRONG_CBIT:
 451                 return ("Wrong C-Bit");
 452         case S_INCPT_BITRATE:
 453                 return ("Incompatible bit-rate");
 454         case S_CEP_MISCONF:
 455                 return ("CEP-TDM mis-configuration");
 456         case S_PW_STATUS:
 457                 return ("PW Status");
 458         case S_UNASSIGN_TAI:
 459                 return ("Unassigned/Unrecognized TAI");
 460         case S_MISCONF_ERR:
 461                 return ("Generic Misconfiguration Error");
 462         case S_WITHDRAW_MTHD:
 463                 return ("Label Withdraw PW Status Method");
 464         case S_UNSSUPORTDCAP:
 465                 return ("Unsupported Capability");
 466         case S_ENDOFLIB:
 467                 return ("End-of-LIB");
 468         case S_TRANS_MISMTCH:
 469                 return ("Transport Connection Mismatch");
 470         case S_DS_NONCMPLNCE:
 471                 return ("Dual-Stack Noncompliance");
 472         default:
 473                 snprintf(buf, sizeof(buf), "[%08x]", status);
 474                 return (buf);
 475         }
 476 }
 477
 478 const char *
 479 pw_type_name(uint16_t pw_type)
 480 {
 481         static char buf[64];
 482
 483         switch (pw_type) {
 484         case PW_TYPE_ETHERNET_TAGGED:
 485                 return ("Eth Tagged");
 486         case PW_TYPE_ETHERNET:
 487                 return ("Ethernet");
 488         case PW_TYPE_WILDCARD:
 489                 return ("Wildcard");
 490         default:
 491                 snprintf(buf, sizeof(buf), "[%0x]", pw_type);
 492                 return (buf);
 493         }
 494 }
 495
 496 const char *
 497 pw_error_code(uint8_t status)
 498 {
 499         static char buf[16];
 500
 501         switch (status) {
 502         case F_PW_NO_ERR:
 503                 return ("No Error");
 504         case F_PW_LOCAL_NOT_FWD:
 505                 return ("local not forwarding");
 506         case F_PW_REMOTE_NOT_FWD:
 507                 return ("remote not forwarding");
 508         case F_PW_NO_REMOTE_LABEL:
 509                 return ("no remote label");
 510         case F_PW_MTU_MISMATCH:
 511                 return ("mtu mismatch between peers");
 512         default:
 513                 snprintf(buf, sizeof(buf), "[%0x]", status);
 514                 return (buf);
 515         }
 516 }