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
  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 *
  62 log_in6addr_scope(const struct in6_addr *addr, unsigned int ifindex)
  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;
 118         case MPLS_LABEL_IMPLICIT_NULL:
 119                 snprintf(buf, TF_LEN, "imp-null");
 120                 break;
 121         case MPLS_LABEL_IPV4_EXPLICIT_NULL:
 122         case MPLS_LABEL_IPV6_EXPLICIT_NULL:
 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 }