contrib/tcpdump/print-ospf.c

   1 /*
   2  * Copyright (c) 1992, 1993, 1994, 1995, 1996, 1997
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * OSPF support contributed by Jeffrey Honig (jch@mitchell.cit.cornell.edu)
  22  */
  23
  24 #ifndef lint
  25 static const char rcsid[] =
  26     "@(#) $Header: /tcpdump/master/tcpdump/print-ospf.c,v 1.29 2000/09/29 04:58:45 guy Exp $ (LBL)";
  27 #endif
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <sys/param.h>
  34 #include <sys/time.h>
  35 #include <sys/socket.h>
  36
  37 #include <netinet/in.h>
  38
  39 #include <ctype.h>
  40 #include <stdio.h>
  41
  42 #include "interface.h"
  43 #include "addrtoname.h"
  44
  45 #include "ospf.h"
  46
  47 #include "ip.h"
  48
  49 struct bits {
  50         u_int32_t bit;
  51         const char *str;
  52 };
  53
  54 static const struct bits ospf_option_bits[] = {
  55         { OSPF_OPTION_T,        "T" },
  56         { OSPF_OPTION_E,        "E" },
  57         { OSPF_OPTION_MC,       "MC" },
  58         { 0,                    NULL }
  59 };
  60
  61 static const struct bits ospf_rla_flag_bits[] = {
  62         { RLA_FLAG_B,           "B" },
  63         { RLA_FLAG_E,           "E" },
  64         { RLA_FLAG_W1,          "W1" },
  65         { RLA_FLAG_W2,          "W2" },
  66         { 0,                    NULL }
  67 };
  68
  69 static struct tok type2str[] = {
  70         { OSPF_TYPE_UMD,        "umd" },
  71         { OSPF_TYPE_HELLO,      "hello" },
  72         { OSPF_TYPE_DB,         "dd" },
  73         { OSPF_TYPE_LSR,        "ls_req" },
  74         { OSPF_TYPE_LSU,        "ls_upd" },
  75         { OSPF_TYPE_LSA,        "ls_ack" },
  76         { 0,                    NULL }
  77 };
  78
  79 static char tstr[] = " [|ospf]";
  80
  81 /* Forwards */
  82 static inline void ospf_print_seqage(u_int32_t, time_t);
  83 static inline void ospf_print_bits(const struct bits *, u_char);
  84 static void ospf_print_ls_type(u_int, const struct in_addr *,
  85     const struct in_addr *, const char *);
  86 static int ospf_print_lshdr(const struct lsa_hdr *);
  87 static int ospf_print_lsa(const struct lsa *);
  88 static int ospf_decode_v2(const struct ospfhdr *, const u_char *);
  89
  90 static inline void
  91 ospf_print_seqage(register u_int32_t seq, register time_t us)
  92 {
  93         register time_t sec = us % 60;
  94         register time_t mins = (us / 60) % 60;
  95         register time_t hour = us / 3600;
  96
  97         printf(" S %X age ", seq);
  98         if (hour)
  99                 printf("%u:%02u:%02u",
 100                     (u_int32_t) hour, (u_int32_t) mins, (u_int32_t) sec);
 101         else if (mins)
 102                 printf("%u:%02u", (u_int32_t) mins, (u_int32_t) sec);
 103         else
 104                 printf("%u", (u_int32_t) sec);
 105 }
 106
 107
 108 static inline void
 109 ospf_print_bits(register const struct bits *bp, register u_char options)
 110 {
 111         register char sep = ' ';
 112
 113         do {
 114                 if (options & bp->bit) {
 115                         printf("%c%s", sep, bp->str);
 116                         sep = '/';
 117                 }
 118         } while ((++bp)->bit);
 119 }
 120
 121 static void
 122 ospf_print_ls_type(register u_int ls_type,
 123     register const struct in_addr *ls_stateid,
 124     register const struct in_addr *ls_router, register const char *fmt)
 125 {
 126
 127         switch (ls_type) {
 128
 129         case LS_TYPE_ROUTER:
 130                 printf(" rtr %s ", ipaddr_string(ls_router));
 131                 break;
 132
 133         case LS_TYPE_NETWORK:
 134                 printf(" net dr %s if %s",
 135                     ipaddr_string(ls_router),
 136                     ipaddr_string(ls_stateid));
 137                 break;
 138
 139         case LS_TYPE_SUM_IP:
 140                 printf(" sum %s abr %s",
 141                     ipaddr_string(ls_stateid),
 142                     ipaddr_string(ls_router));
 143                 break;
 144
 145         case LS_TYPE_SUM_ABR:
 146                 printf(" abr %s rtr %s",
 147                     ipaddr_string(ls_router),
 148                     ipaddr_string(ls_stateid));
 149                 break;
 150
 151         case LS_TYPE_ASE:
 152                 printf(" ase %s asbr %s",
 153                     ipaddr_string(ls_stateid),
 154                     ipaddr_string(ls_router));
 155                 break;
 156
 157         case LS_TYPE_GROUP:
 158                 printf(" group %s rtr %s",
 159                     ipaddr_string(ls_stateid),
 160                     ipaddr_string(ls_router));
 161                 break;
 162
 163         default:
 164                 putchar(' ');
 165                 printf(fmt, ls_type);
 166                 break;
 167         }
 168 }
 169
 170 static int
 171 ospf_print_lshdr(register const struct lsa_hdr *lshp)
 172 {
 173
 174         TCHECK(lshp->ls_type);
 175         printf(" {");                                           /* } (ctags) */
 176
 177         TCHECK(lshp->ls_options);
 178         ospf_print_bits(ospf_option_bits, lshp->ls_options);
 179         TCHECK(lshp->ls_seq);
 180         ospf_print_seqage(ntohl(lshp->ls_seq), ntohs(lshp->ls_age));
 181         ospf_print_ls_type(lshp->ls_type, &lshp->ls_stateid, &lshp->ls_router,
 182             "ls_type %d");
 183
 184         return (0);
 185 trunc:
 186         return (1);
 187 }
 188
 189
 190 /*
 191  * Print a single link state advertisement.  If truncated return 1, else 0.
 192  */
 193 static int
 194 ospf_print_lsa(register const struct lsa *lsap)
 195 {
 196         register const u_char *ls_end;
 197         register const struct rlalink *rlp;
 198         register const struct tos_metric *tosp;
 199         register const struct in_addr *ap;
 200         register const struct aslametric *almp;
 201         register const struct mcla *mcp;
 202         register const u_int32_t *lp;
 203         register int j, k;
 204
 205         if (ospf_print_lshdr(&lsap->ls_hdr))
 206                 return (1);
 207         TCHECK(lsap->ls_hdr.ls_length);
 208         ls_end = (u_char *)lsap + ntohs(lsap->ls_hdr.ls_length);
 209         switch (lsap->ls_hdr.ls_type) {
 210
 211         case LS_TYPE_ROUTER:
 212                 TCHECK(lsap->lsa_un.un_rla.rla_flags);
 213                 ospf_print_bits(ospf_rla_flag_bits,
 214                     lsap->lsa_un.un_rla.rla_flags);
 215
 216                 TCHECK(lsap->lsa_un.un_rla.rla_count);
 217                 j = ntohs(lsap->lsa_un.un_rla.rla_count);
 218                 TCHECK(lsap->lsa_un.un_rla.rla_link);
 219                 rlp = lsap->lsa_un.un_rla.rla_link;
 220                 while (j--) {
 221                         TCHECK(*rlp);
 222                         printf(" {");                           /* } (ctags) */
 223                         switch (rlp->link_type) {
 224
 225                         case RLA_TYPE_VIRTUAL:
 226                                 printf(" virt");
 227                                 /* Fall through */
 228
 229                         case RLA_TYPE_ROUTER:
 230                                 printf(" nbrid %s if %s",
 231                                     ipaddr_string(&rlp->link_id),
 232                                     ipaddr_string(&rlp->link_data));
 233                                 break;
 234
 235                         case RLA_TYPE_TRANSIT:
 236                                 printf(" dr %s if %s",
 237                                     ipaddr_string(&rlp->link_id),
 238                                     ipaddr_string(&rlp->link_data));
 239                                 break;
 240
 241                         case RLA_TYPE_STUB:
 242                                 printf(" net %s mask %s",
 243                                     ipaddr_string(&rlp->link_id),
 244                                     ipaddr_string(&rlp->link_data));
 245                                 break;
 246
 247                         default:
 248                                                                 /* { (ctags) */
 249                                 printf(" ??RouterLinksType %d?? }",
 250                                     rlp->link_type);
 251                                 return (0);
 252                         }
 253                         printf(" tos 0 metric %d", ntohs(rlp->link_tos0metric));
 254                         tosp = (struct tos_metric *)
 255                             ((sizeof rlp->link_tos0metric) + (u_char *) rlp);
 256                         for (k = 0; k < (int) rlp->link_toscount; ++k, ++tosp) {
 257                                 TCHECK(*tosp);
 258                                 printf(" tos %d metric %d",
 259                                     tosp->tos_type,
 260                                     ntohs(tosp->tos_metric));
 261                         }
 262                                                                 /* { (ctags) */
 263                         printf(" }");
 264                         rlp = (struct rlalink *)((u_char *)(rlp + 1) +
 265                             ((rlp->link_toscount) * sizeof(*tosp)));
 266                 }
 267                 break;
 268
 269         case LS_TYPE_NETWORK:
 270                 TCHECK(lsap->lsa_un.un_nla.nla_mask);
 271                 printf(" mask %s rtrs",
 272                     ipaddr_string(&lsap->lsa_un.un_nla.nla_mask));
 273                 ap = lsap->lsa_un.un_nla.nla_router;
 274                 while ((u_char *)ap < ls_end) {
 275                         TCHECK(*ap);
 276                         printf(" %s", ipaddr_string(ap));
 277                         ++ap;
 278                 }
 279                 break;
 280
 281         case LS_TYPE_SUM_IP:
 282                 TCHECK(lsap->lsa_un.un_nla.nla_mask);
 283                 printf(" mask %s",
 284                     ipaddr_string(&lsap->lsa_un.un_sla.sla_mask));
 285                 /* Fall through */
 286
 287         case LS_TYPE_SUM_ABR:
 288                 TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
 289                 lp = lsap->lsa_un.un_sla.sla_tosmetric;
 290                 while ((u_char *)lp < ls_end) {
 291                         register u_int32_t ul;
 292
 293                         TCHECK(*lp);
 294                         ul = ntohl(*lp);
 295                         printf(" tos %d metric %d",
 296                             (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS,
 297                             ul & SLA_MASK_METRIC);
 298                         ++lp;
 299                 }
 300                 break;
 301
 302         case LS_TYPE_ASE:
 303                 TCHECK(lsap->lsa_un.un_nla.nla_mask);
 304                 printf(" mask %s",
 305                     ipaddr_string(&lsap->lsa_un.un_asla.asla_mask));
 306
 307                 TCHECK(lsap->lsa_un.un_sla.sla_tosmetric);
 308                 almp = lsap->lsa_un.un_asla.asla_metric;
 309                 while ((u_char *)almp < ls_end) {
 310                         register u_int32_t ul;
 311
 312                         TCHECK(almp->asla_tosmetric);
 313                         ul = ntohl(almp->asla_tosmetric);
 314                         printf(" type %d tos %d metric %d",
 315                             (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1,
 316                             (ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS,
 317                             (ul & ASLA_MASK_METRIC));
 318                         TCHECK(almp->asla_forward);
 319                         if (almp->asla_forward.s_addr) {
 320                                 printf(" forward %s",
 321                                     ipaddr_string(&almp->asla_forward));
 322                         }
 323                         TCHECK(almp->asla_tag);
 324                         if (almp->asla_tag.s_addr) {
 325                                 printf(" tag %s",
 326                                     ipaddr_string(&almp->asla_tag));
 327                         }
 328                         ++almp;
 329                 }
 330                 break;
 331
 332         case LS_TYPE_GROUP:
 333                 /* Multicast extensions as of 23 July 1991 */
 334                 mcp = lsap->lsa_un.un_mcla;
 335                 while ((u_char *)mcp < ls_end) {
 336                         TCHECK(mcp->mcla_vid);
 337                         switch (ntohl(mcp->mcla_vtype)) {
 338
 339                         case MCLA_VERTEX_ROUTER:
 340                                 printf(" rtr rtrid %s",
 341                                     ipaddr_string(&mcp->mcla_vid));
 342                                 break;
 343
 344                         case MCLA_VERTEX_NETWORK:
 345                                 printf(" net dr %s",
 346                                     ipaddr_string(&mcp->mcla_vid));
 347                                 break;
 348
 349                         default:
 350                                 printf(" ??VertexType %u??",
 351                                     (u_int32_t)ntohl(mcp->mcla_vtype));
 352                                 break;
 353                         }
 354                 ++mcp;
 355                 }
 356         }
 357
 358                                                                 /* { (ctags) */
 359         fputs(" }", stdout);
 360         return (0);
 361 trunc:
 362         fputs(" }", stdout);
 363         return (1);
 364 }
 365
 366 static int
 367 ospf_decode_v2(register const struct ospfhdr *op,
 368     register const u_char *dataend)
 369 {
 370         register const struct in_addr *ap;
 371         register const struct lsr *lsrp;
 372         register const struct lsa_hdr *lshp;
 373         register const struct lsa *lsap;
 374         register char sep;
 375         register int i;
 376
 377         switch (op->ospf_type) {
 378
 379         case OSPF_TYPE_UMD:
 380                 /*
 381                  * Rob Coltun's special monitoring packets;
 382                  * do nothing
 383                  */
 384                 break;
 385
 386         case OSPF_TYPE_HELLO:
 387                 if (vflag) {
 388                         TCHECK(op->ospf_hello.hello_deadint);
 389                         ospf_print_bits(ospf_option_bits,
 390                             op->ospf_hello.hello_options);
 391                         printf(" mask %s int %d pri %d dead %u",
 392                             ipaddr_string(&op->ospf_hello.hello_mask),
 393                             ntohs(op->ospf_hello.hello_helloint),
 394                             op->ospf_hello.hello_priority,
 395                             (u_int32_t)ntohl(op->ospf_hello.hello_deadint));
 396                 }
 397                 TCHECK(op->ospf_hello.hello_dr);
 398                 if (op->ospf_hello.hello_dr.s_addr != 0)
 399                         printf(" dr %s",
 400                             ipaddr_string(&op->ospf_hello.hello_dr));
 401                 TCHECK(op->ospf_hello.hello_bdr);
 402                 if (op->ospf_hello.hello_bdr.s_addr != 0)
 403                         printf(" bdr %s",
 404                             ipaddr_string(&op->ospf_hello.hello_bdr));
 405                 if (vflag) {
 406                         printf(" nbrs");
 407                         ap = op->ospf_hello.hello_neighbor;
 408                         while ((u_char *)ap < dataend) {
 409                                 TCHECK(*ap);
 410                                 printf(" %s", ipaddr_string(ap));
 411                                 ++ap;
 412                         }
 413                 }
 414                 break;  /* HELLO */
 415
 416         case OSPF_TYPE_DB:
 417                 TCHECK(op->ospf_db.db_options);
 418                 ospf_print_bits(ospf_option_bits, op->ospf_db.db_options);
 419                 sep = ' ';
 420                 TCHECK(op->ospf_db.db_flags);
 421                 if (op->ospf_db.db_flags & OSPF_DB_INIT) {
 422                         printf("%cI", sep);
 423                         sep = '/';
 424                 }
 425                 if (op->ospf_db.db_flags & OSPF_DB_MORE) {
 426                         printf("%cM", sep);
 427                         sep = '/';
 428                 }
 429                 if (op->ospf_db.db_flags & OSPF_DB_MASTER) {
 430                         printf("%cMS", sep);
 431                         sep = '/';
 432                 }
 433                 TCHECK(op->ospf_db.db_seq);
 434                 printf(" S %X", (u_int32_t)ntohl(op->ospf_db.db_seq));
 435
 436                 if (vflag) {
 437                         /* Print all the LS adv's */
 438                         lshp = op->ospf_db.db_lshdr;
 439
 440                         while (!ospf_print_lshdr(lshp)) {
 441                                                         /* { (ctags) */
 442                                 printf(" }");
 443                                 ++lshp;
 444                         }
 445                 }
 446                 break;
 447
 448         case OSPF_TYPE_LSR:
 449                 if (vflag) {
 450                         lsrp = op->ospf_lsr;
 451                         while ((u_char *)lsrp < dataend) {
 452                                 TCHECK(*lsrp);
 453                                 printf(" {");           /* } (ctags) */
 454                                 ospf_print_ls_type(ntohl(lsrp->ls_type),
 455                                     &lsrp->ls_stateid,
 456                                     &lsrp->ls_router,
 457                                     "LinkStateType %d");
 458                                                         /* { (ctags) */
 459                                 printf(" }");
 460                                 ++lsrp;
 461                         }
 462                 }
 463                 break;
 464
 465         case OSPF_TYPE_LSU:
 466                 if (vflag) {
 467                         lsap = op->ospf_lsu.lsu_lsa;
 468                         TCHECK(op->ospf_lsu.lsu_count);
 469                         i = ntohl(op->ospf_lsu.lsu_count);
 470                         while (i--) {
 471                                 if (ospf_print_lsa(lsap))
 472                                         goto trunc;
 473                                 lsap = (struct lsa *)((u_char *)lsap +
 474                                     ntohs(lsap->ls_hdr.ls_length));
 475                         }
 476                 }
 477                 break;
 478
 479
 480         case OSPF_TYPE_LSA:
 481                 if (vflag) {
 482                         lshp = op->ospf_lsa.lsa_lshdr;
 483
 484                         while (!ospf_print_lshdr(lshp)) {
 485                                                         /* { (ctags) */
 486                                 printf(" }");
 487                                 ++lshp;
 488                         }
 489                 }
 490                 break;
 491
 492         default:
 493                 printf("v2 type %d", op->ospf_type);
 494                 break;
 495         }
 496         return (0);
 497 trunc:
 498         return (1);
 499 }
 500
 501 void
 502 ospf_print(register const u_char *bp, register u_int length,
 503     register const u_char *bp2)
 504 {
 505         register const struct ospfhdr *op;
 506         register const struct ip *ip;
 507         register const u_char *dataend;
 508         register const char *cp;
 509
 510         op = (struct ospfhdr *)bp;
 511         ip = (struct ip *)bp2;
 512         /* Print the source and destination address  */
 513 #if 0
 514         (void) printf("%s > %s:",
 515             ipaddr_string(&ip->ip_src),
 516             ipaddr_string(&ip->ip_dst));
 517 #endif
 518
 519         /* XXX Before we do anything else, strip off the MD5 trailer */
 520         TCHECK(op->ospf_authtype);
 521         if (ntohs(op->ospf_authtype) == OSPF_AUTH_MD5) {
 522                 length -= OSPF_AUTH_MD5_LEN;
 523                 snapend -= OSPF_AUTH_MD5_LEN;
 524         }
 525
 526         /* If the type is valid translate it, or just print the type */
 527         /* value.  If it's not valid, say so and return */
 528         TCHECK(op->ospf_type);
 529         cp = tok2str(type2str, "type%d", op->ospf_type);
 530         printf(" OSPFv%d-%s %d:", op->ospf_version, cp, length);
 531         if (*cp == 't')
 532                 return;
 533
 534         TCHECK(op->ospf_len);
 535         if (length != ntohs(op->ospf_len)) {
 536                 printf(" [len %d]", ntohs(op->ospf_len));
 537                 return;
 538         }
 539         dataend = bp + length;
 540
 541         /* Print the routerid if it is not the same as the source */
 542         TCHECK(op->ospf_routerid);
 543         if (ip->ip_src.s_addr != op->ospf_routerid.s_addr)
 544                 printf(" rtrid %s", ipaddr_string(&op->ospf_routerid));
 545
 546         TCHECK(op->ospf_areaid);
 547         if (op->ospf_areaid.s_addr != 0)
 548                 printf(" area %s", ipaddr_string(&op->ospf_areaid));
 549         else
 550                 printf(" backbone");
 551
 552         if (vflag) {
 553                 /* Print authentication data (should we really do this?) */
 554                 TCHECK2(op->ospf_authdata[0], sizeof(op->ospf_authdata));
 555                 switch (ntohs(op->ospf_authtype)) {
 556
 557                 case OSPF_AUTH_NONE:
 558                         break;
 559
 560                 case OSPF_AUTH_SIMPLE:
 561                         printf(" auth \"");
 562                         (void)fn_printn(op->ospf_authdata,
 563                             sizeof(op->ospf_authdata), NULL);
 564                         printf("\"");
 565                         break;
 566
 567                 case OSPF_AUTH_MD5:
 568                         printf(" auth MD5");
 569                         break;
 570
 571                 default:
 572                         printf(" ??authtype-%d??", ntohs(op->ospf_authtype));
 573                         return;
 574                 }
 575         }
 576         /* Do rest according to version.         */
 577         switch (op->ospf_version) {
 578
 579         case 2:
 580                 /* ospf version 2 */
 581                 if (ospf_decode_v2(op, dataend))
 582                         goto trunc;
 583                 break;
 584
 585         default:
 586                 printf(" ospf [version %d]", op->ospf_version);
 587                 break;
 588         }                       /* end switch on version */
 589
 590         return;
 591 trunc:
 592         fputs(tstr, stdout);
 593 }