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 /* \summary: Open Shortest Path First (OSPF) printer */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include "netdissect-stdinc.h"
  31
  32 #include "netdissect.h"
  33 #include "addrtoname.h"
  34 #include "extract.h"
  35 #include "gmpls.h"
  36
  37 #include "ospf.h"
  38
  39
  40 static const struct tok ospf_option_values[] = {
  41         { OSPF_OPTION_MT,       "MultiTopology" }, /* draft-ietf-ospf-mt-09 */
  42         { OSPF_OPTION_E,        "External" },
  43         { OSPF_OPTION_MC,       "Multicast" },
  44         { OSPF_OPTION_NP,       "NSSA" },
  45         { OSPF_OPTION_L,        "LLS" },
  46         { OSPF_OPTION_DC,       "Demand Circuit" },
  47         { OSPF_OPTION_O,        "Opaque" },
  48         { OSPF_OPTION_DN,       "Up/Down" },
  49         { 0,                    NULL }
  50 };
  51
  52 static const struct tok ospf_authtype_values[] = {
  53         { OSPF_AUTH_NONE,       "none" },
  54         { OSPF_AUTH_SIMPLE,     "simple" },
  55         { OSPF_AUTH_MD5,        "MD5" },
  56         { 0,                    NULL }
  57 };
  58
  59 static const struct tok ospf_rla_flag_values[] = {
  60         { RLA_FLAG_B,           "ABR" },
  61         { RLA_FLAG_E,           "ASBR" },
  62         { RLA_FLAG_W1,          "Virtual" },
  63         { RLA_FLAG_W2,          "W2" },
  64         { 0,                    NULL }
  65 };
  66
  67 static const struct tok type2str[] = {
  68         { OSPF_TYPE_HELLO,      "Hello" },
  69         { OSPF_TYPE_DD,         "Database Description" },
  70         { OSPF_TYPE_LS_REQ,     "LS-Request" },
  71         { OSPF_TYPE_LS_UPDATE,  "LS-Update" },
  72         { OSPF_TYPE_LS_ACK,     "LS-Ack" },
  73         { 0,                    NULL }
  74 };
  75
  76 static const struct tok lsa_values[] = {
  77         { LS_TYPE_ROUTER,       "Router" },
  78         { LS_TYPE_NETWORK,      "Network" },
  79         { LS_TYPE_SUM_IP,       "Summary" },
  80         { LS_TYPE_SUM_ABR,      "ASBR Summary" },
  81         { LS_TYPE_ASE,          "External" },
  82         { LS_TYPE_GROUP,        "Multicast Group" },
  83         { LS_TYPE_NSSA,         "NSSA" },
  84         { LS_TYPE_OPAQUE_LL,    "Link Local Opaque" },
  85         { LS_TYPE_OPAQUE_AL,    "Area Local Opaque" },
  86         { LS_TYPE_OPAQUE_DW,    "Domain Wide Opaque" },
  87         { 0,                    NULL }
  88 };
  89
  90 static const struct tok ospf_dd_flag_values[] = {
  91         { OSPF_DB_INIT,         "Init" },
  92         { OSPF_DB_MORE,         "More" },
  93         { OSPF_DB_MASTER,       "Master" },
  94     { OSPF_DB_RESYNC,   "OOBResync" },
  95         { 0,                    NULL }
  96 };
  97
  98 static const struct tok lsa_opaque_values[] = {
  99         { LS_OPAQUE_TYPE_TE,    "Traffic Engineering" },
 100         { LS_OPAQUE_TYPE_GRACE, "Graceful restart" },
 101         { LS_OPAQUE_TYPE_RI,    "Router Information" },
 102         { 0,                    NULL }
 103 };
 104
 105 static const struct tok lsa_opaque_te_tlv_values[] = {
 106         { LS_OPAQUE_TE_TLV_ROUTER, "Router Address" },
 107         { LS_OPAQUE_TE_TLV_LINK,   "Link" },
 108         { 0,                    NULL }
 109 };
 110
 111 static const struct tok lsa_opaque_te_link_tlv_subtlv_values[] = {
 112         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_TYPE,            "Link Type" },
 113         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_ID,              "Link ID" },
 114         { LS_OPAQUE_TE_LINK_SUBTLV_LOCAL_IP,             "Local Interface IP address" },
 115         { LS_OPAQUE_TE_LINK_SUBTLV_REMOTE_IP,            "Remote Interface IP address" },
 116         { LS_OPAQUE_TE_LINK_SUBTLV_TE_METRIC,            "Traffic Engineering Metric" },
 117         { LS_OPAQUE_TE_LINK_SUBTLV_MAX_BW,               "Maximum Bandwidth" },
 118         { LS_OPAQUE_TE_LINK_SUBTLV_MAX_RES_BW,           "Maximum Reservable Bandwidth" },
 119         { LS_OPAQUE_TE_LINK_SUBTLV_UNRES_BW,             "Unreserved Bandwidth" },
 120         { LS_OPAQUE_TE_LINK_SUBTLV_ADMIN_GROUP,          "Administrative Group" },
 121         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_LOCAL_REMOTE_ID, "Link Local/Remote Identifier" },
 122         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_PROTECTION_TYPE, "Link Protection Type" },
 123         { LS_OPAQUE_TE_LINK_SUBTLV_INTF_SW_CAP_DESCR,    "Interface Switching Capability" },
 124         { LS_OPAQUE_TE_LINK_SUBTLV_SHARED_RISK_GROUP,    "Shared Risk Link Group" },
 125         { LS_OPAQUE_TE_LINK_SUBTLV_BW_CONSTRAINTS,       "Bandwidth Constraints" },
 126         { 0,                    NULL }
 127 };
 128
 129 static const struct tok lsa_opaque_grace_tlv_values[] = {
 130         { LS_OPAQUE_GRACE_TLV_PERIOD,             "Grace Period" },
 131         { LS_OPAQUE_GRACE_TLV_REASON,             "Graceful restart Reason" },
 132         { LS_OPAQUE_GRACE_TLV_INT_ADDRESS,        "IPv4 interface address" },
 133         { 0,                    NULL }
 134 };
 135
 136 static const struct tok lsa_opaque_grace_tlv_reason_values[] = {
 137         { LS_OPAQUE_GRACE_TLV_REASON_UNKNOWN,     "Unknown" },
 138         { LS_OPAQUE_GRACE_TLV_REASON_SW_RESTART,  "Software Restart" },
 139         { LS_OPAQUE_GRACE_TLV_REASON_SW_UPGRADE,  "Software Reload/Upgrade" },
 140         { LS_OPAQUE_GRACE_TLV_REASON_CP_SWITCH,   "Control Processor Switch" },
 141         { 0,                    NULL }
 142 };
 143
 144 static const struct tok lsa_opaque_te_tlv_link_type_sub_tlv_values[] = {
 145         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_TYPE_PTP, "Point-to-point" },
 146         { LS_OPAQUE_TE_LINK_SUBTLV_LINK_TYPE_MA,  "Multi-Access" },
 147         { 0,                    NULL }
 148 };
 149
 150 static const struct tok lsa_opaque_ri_tlv_values[] = {
 151         { LS_OPAQUE_RI_TLV_CAP, "Router Capabilities" },
 152         { 0,                    NULL }
 153 };
 154
 155 static const struct tok lsa_opaque_ri_tlv_cap_values[] = {
 156         { 1, "Reserved" },
 157         { 2, "Reserved" },
 158         { 4, "Reserved" },
 159         { 8, "Reserved" },
 160         { 16, "graceful restart capable" },
 161         { 32, "graceful restart helper" },
 162         { 64, "Stub router support" },
 163         { 128, "Traffic engineering" },
 164         { 256, "p2p over LAN" },
 165         { 512, "path computation server" },
 166         { 0,                    NULL }
 167 };
 168
 169 static const struct tok ospf_lls_tlv_values[] = {
 170         { OSPF_LLS_EO,  "Extended Options" },
 171         { OSPF_LLS_MD5, "MD5 Authentication" },
 172         { 0,    NULL }
 173 };
 174
 175 static const struct tok ospf_lls_eo_options[] = {
 176         { OSPF_LLS_EO_LR,       "LSDB resync" },
 177         { OSPF_LLS_EO_RS,       "Restart" },
 178         { 0,    NULL }
 179 };
 180
 181 int
 182 ospf_grace_lsa_print(netdissect_options *ndo,
 183                      const u_char *tptr, u_int ls_length)
 184 {
 185     u_int tlv_type, tlv_length;
 186
 187
 188     while (ls_length > 0) {
 189         ND_TCHECK_4(tptr);
 190         if (ls_length < 4) {
 191             ND_PRINT("\n\t    Remaining LS length %u < 4", ls_length);
 192             return -1;
 193         }
 194         tlv_type = GET_BE_U_2(tptr);
 195         tlv_length = GET_BE_U_2(tptr + 2);
 196         tptr+=4;
 197         ls_length-=4;
 198
 199         ND_PRINT("\n\t    %s TLV (%u), length %u, value: ",
 200                tok2str(lsa_opaque_grace_tlv_values,"unknown",tlv_type),
 201                tlv_type,
 202                tlv_length);
 203
 204         if (tlv_length > ls_length) {
 205             ND_PRINT("\n\t    Bogus length %u > %u", tlv_length,
 206                    ls_length);
 207             return -1;
 208         }
 209
 210         /* Infinite loop protection. */
 211         if (tlv_type == 0 || tlv_length ==0) {
 212             return -1;
 213         }
 214
 215         ND_TCHECK_LEN(tptr, tlv_length);
 216         switch(tlv_type) {
 217
 218         case LS_OPAQUE_GRACE_TLV_PERIOD:
 219             if (tlv_length != 4) {
 220                 ND_PRINT("\n\t    Bogus length %u != 4", tlv_length);
 221                 return -1;
 222             }
 223             ND_PRINT("%us", GET_BE_U_4(tptr));
 224             break;
 225
 226         case LS_OPAQUE_GRACE_TLV_REASON:
 227             if (tlv_length != 1) {
 228                 ND_PRINT("\n\t    Bogus length %u != 1", tlv_length);
 229                 return -1;
 230             }
 231             ND_PRINT("%s (%u)",
 232                    tok2str(lsa_opaque_grace_tlv_reason_values, "Unknown", GET_U_1(tptr)),
 233                    GET_U_1(tptr));
 234             break;
 235
 236         case LS_OPAQUE_GRACE_TLV_INT_ADDRESS:
 237             if (tlv_length != 4) {
 238                 ND_PRINT("\n\t    Bogus length %u != 4", tlv_length);
 239                 return -1;
 240             }
 241             ND_PRINT("%s", GET_IPADDR_STRING(tptr));
 242             break;
 243
 244         default:
 245             if (ndo->ndo_vflag <= 1) {
 246                 if (!print_unknown_data(ndo, tptr, "\n\t      ", tlv_length))
 247                     return -1;
 248             }
 249             break;
 250
 251         }
 252         /* in OSPF everything has to be 32-bit aligned, including TLVs */
 253         if (tlv_length%4 != 0)
 254             tlv_length+=4-(tlv_length%4);
 255         ls_length-=tlv_length;
 256         tptr+=tlv_length;
 257     }
 258
 259     return 0;
 260 trunc:
 261     return -1;
 262 }
 263
 264 int
 265 ospf_te_lsa_print(netdissect_options *ndo,
 266                   const u_char *tptr, u_int ls_length)
 267 {
 268     u_int tlv_type, tlv_length, subtlv_type, subtlv_length;
 269     u_int priority_level, te_class, count_srlg;
 270     union { /* int to float conversion buffer for several subTLVs */
 271         float f;
 272         uint32_t i;
 273     } bw;
 274
 275     while (ls_length != 0) {
 276         ND_TCHECK_4(tptr);
 277         if (ls_length < 4) {
 278             ND_PRINT("\n\t    Remaining LS length %u < 4", ls_length);
 279             return -1;
 280         }
 281         tlv_type = GET_BE_U_2(tptr);
 282         tlv_length = GET_BE_U_2(tptr + 2);
 283         tptr+=4;
 284         ls_length-=4;
 285
 286         ND_PRINT("\n\t    %s TLV (%u), length: %u",
 287                tok2str(lsa_opaque_te_tlv_values,"unknown",tlv_type),
 288                tlv_type,
 289                tlv_length);
 290
 291         if (tlv_length > ls_length) {
 292             ND_PRINT("\n\t    Bogus length %u > %u", tlv_length,
 293                    ls_length);
 294             return -1;
 295         }
 296
 297         /* Infinite loop protection. */
 298         if (tlv_type == 0 || tlv_length ==0) {
 299             return -1;
 300         }
 301
 302         switch(tlv_type) {
 303         case LS_OPAQUE_TE_TLV_LINK:
 304             while (tlv_length != 0) {
 305                 if (tlv_length < 4) {
 306                     ND_PRINT("\n\t    Remaining TLV length %u < 4",
 307                            tlv_length);
 308                     return -1;
 309                 }
 310                 subtlv_type = GET_BE_U_2(tptr);
 311                 subtlv_length = GET_BE_U_2(tptr + 2);
 312                 tptr+=4;
 313                 tlv_length-=4;
 314
 315                 /* Infinite loop protection */
 316                 if (subtlv_type == 0 || subtlv_length == 0)
 317                     goto invalid;
 318
 319                 ND_PRINT("\n\t      %s subTLV (%u), length: %u",
 320                        tok2str(lsa_opaque_te_link_tlv_subtlv_values,"unknown",subtlv_type),
 321                        subtlv_type,
 322                        subtlv_length);
 323
 324                 if (tlv_length < subtlv_length) {
 325                     ND_PRINT("\n\t    Remaining TLV length %u < %u",
 326                            tlv_length + 4, subtlv_length + 4);
 327                     return -1;
 328                 }
 329                 ND_TCHECK_LEN(tptr, subtlv_length);
 330                 switch(subtlv_type) {
 331                 case LS_OPAQUE_TE_LINK_SUBTLV_ADMIN_GROUP:
 332                     if (subtlv_length != 4) {
 333                         ND_PRINT(" != 4");
 334                         goto invalid;
 335                     }
 336                     ND_PRINT(", 0x%08x", GET_BE_U_4(tptr));
 337                     break;
 338                 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_ID:
 339                 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_LOCAL_REMOTE_ID:
 340                     if (subtlv_length != 4 && subtlv_length != 8) {
 341                         ND_PRINT(" != 4 && != 8");
 342                         goto invalid;
 343                     }
 344                     ND_PRINT(", %s (0x%08x)",
 345                            GET_IPADDR_STRING(tptr),
 346                            GET_BE_U_4(tptr));
 347                     if (subtlv_length == 8) /* rfc4203 */
 348                         ND_PRINT(", %s (0x%08x)",
 349                                GET_IPADDR_STRING(tptr+4),
 350                                GET_BE_U_4(tptr + 4));
 351                     break;
 352                 case LS_OPAQUE_TE_LINK_SUBTLV_LOCAL_IP:
 353                 case LS_OPAQUE_TE_LINK_SUBTLV_REMOTE_IP:
 354                     if (subtlv_length != 4) {
 355                         ND_PRINT(" != 4");
 356                         goto invalid;
 357                     }
 358                     ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
 359                     break;
 360                 case LS_OPAQUE_TE_LINK_SUBTLV_MAX_BW:
 361                 case LS_OPAQUE_TE_LINK_SUBTLV_MAX_RES_BW:
 362                     if (subtlv_length != 4) {
 363                         ND_PRINT(" != 4");
 364                         goto invalid;
 365                     }
 366                     bw.i = GET_BE_U_4(tptr);
 367                     ND_PRINT(", %.3f Mbps", bw.f * 8 / 1000000);
 368                     break;
 369                 case LS_OPAQUE_TE_LINK_SUBTLV_UNRES_BW:
 370                     if (subtlv_length != 32) {
 371                         ND_PRINT(" != 32");
 372                         goto invalid;
 373                     }
 374                     for (te_class = 0; te_class < 8; te_class++) {
 375                         bw.i = GET_BE_U_4(tptr + te_class * 4);
 376                         ND_PRINT("\n\t\tTE-Class %u: %.3f Mbps",
 377                                te_class,
 378                                bw.f * 8 / 1000000);
 379                     }
 380                     break;
 381                 case LS_OPAQUE_TE_LINK_SUBTLV_BW_CONSTRAINTS:
 382                     if (subtlv_length < 4) {
 383                         ND_PRINT(" < 4");
 384                         goto invalid;
 385                     }
 386                     /* BC Model Id (1 octet) + Reserved (3 octets) */
 387                     ND_PRINT("\n\t\tBandwidth Constraints Model ID: %s (%u)",
 388                            tok2str(diffserv_te_bc_values, "unknown", GET_U_1(tptr)),
 389                            GET_U_1(tptr));
 390                     if (subtlv_length % 4 != 0) {
 391                         ND_PRINT("\n\t\tlength %u != N x 4", subtlv_length);
 392                         goto invalid;
 393                     }
 394                     if (subtlv_length > 36) {
 395                         ND_PRINT("\n\t\tlength %u > 36", subtlv_length);
 396                         goto invalid;
 397                     }
 398                     /* decode BCs until the subTLV ends */
 399                     for (te_class = 0; te_class < (subtlv_length-4)/4; te_class++) {
 400                         bw.i = GET_BE_U_4(tptr + 4 + te_class * 4);
 401                         ND_PRINT("\n\t\t  Bandwidth constraint CT%u: %.3f Mbps",
 402                                te_class,
 403                                bw.f * 8 / 1000000);
 404                     }
 405                     break;
 406                 case LS_OPAQUE_TE_LINK_SUBTLV_TE_METRIC:
 407                     if (subtlv_length != 4) {
 408                         ND_PRINT(" != 4");
 409                         goto invalid;
 410                     }
 411                     ND_PRINT(", Metric %u", GET_BE_U_4(tptr));
 412                     break;
 413                 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_PROTECTION_TYPE:
 414                     /* Protection Cap (1 octet) + Reserved ((3 octets) */
 415                     if (subtlv_length != 4) {
 416                         ND_PRINT(" != 4");
 417                         goto invalid;
 418                     }
 419                     ND_PRINT(", %s",
 420                              bittok2str(gmpls_link_prot_values, "none", GET_U_1(tptr)));
 421                     break;
 422                 case LS_OPAQUE_TE_LINK_SUBTLV_INTF_SW_CAP_DESCR:
 423                     if (subtlv_length < 36) {
 424                         ND_PRINT(" < 36");
 425                         goto invalid;
 426                     }
 427                     /* Switching Cap (1 octet) + Encoding (1) +  Reserved (2) */
 428                     ND_PRINT("\n\t\tInterface Switching Capability: %s",
 429                            tok2str(gmpls_switch_cap_values, "Unknown", GET_U_1((tptr))));
 430                     ND_PRINT("\n\t\tLSP Encoding: %s\n\t\tMax LSP Bandwidth:",
 431                            tok2str(gmpls_encoding_values, "Unknown", GET_U_1((tptr + 1))));
 432                     for (priority_level = 0; priority_level < 8; priority_level++) {
 433                         bw.i = GET_BE_U_4(tptr + 4 + (priority_level * 4));
 434                         ND_PRINT("\n\t\t  priority level %u: %.3f Mbps",
 435                                priority_level,
 436                                bw.f * 8 / 1000000);
 437                     }
 438                     break;
 439                 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_TYPE:
 440                     if (subtlv_length != 1) {
 441                         ND_PRINT(" != 1");
 442                         goto invalid;
 443                     }
 444                     ND_PRINT(", %s (%u)",
 445                            tok2str(lsa_opaque_te_tlv_link_type_sub_tlv_values,"unknown",GET_U_1(tptr)),
 446                            GET_U_1(tptr));
 447                     break;
 448
 449                 case LS_OPAQUE_TE_LINK_SUBTLV_SHARED_RISK_GROUP:
 450                     if (subtlv_length % 4 != 0) {
 451                         ND_PRINT(" != N x 4");
 452                         goto invalid;
 453                     }
 454                     count_srlg = subtlv_length / 4;
 455                     if (count_srlg != 0)
 456                         ND_PRINT("\n\t\t  Shared risk group: ");
 457                     while (count_srlg > 0) {
 458                         bw.i = GET_BE_U_4(tptr);
 459                         ND_PRINT("%u", bw.i);
 460                         tptr+=4;
 461                         count_srlg--;
 462                         if (count_srlg > 0)
 463                             ND_PRINT(", ");
 464                     }
 465                     break;
 466
 467                 default:
 468                     if (ndo->ndo_vflag <= 1) {
 469                         if (!print_unknown_data(ndo, tptr, "\n\t\t", subtlv_length))
 470                             return -1;
 471                     }
 472                     break;
 473                 }
 474                 /* in OSPF everything has to be 32-bit aligned, including subTLVs */
 475                 if (subtlv_length%4 != 0)
 476                     subtlv_length+=4-(subtlv_length%4);
 477
 478                 if (tlv_length < subtlv_length) {
 479                     ND_PRINT("\n\t    Remaining TLV length %u < %u",
 480                            tlv_length + 4, subtlv_length + 4);
 481                     return -1;
 482                 }
 483                 tlv_length-=subtlv_length;
 484                 tptr+=subtlv_length;
 485
 486             }
 487             break;
 488
 489         case LS_OPAQUE_TE_TLV_ROUTER:
 490             if (tlv_length < 4) {
 491                 ND_PRINT("\n\t    TLV length %u < 4", tlv_length);
 492                 return -1;
 493             }
 494             ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
 495             break;
 496
 497         default:
 498             if (ndo->ndo_vflag <= 1) {
 499                 if (!print_unknown_data(ndo, tptr, "\n\t      ", tlv_length))
 500                     return -1;
 501             }
 502             break;
 503         }
 504         /* in OSPF everything has to be 32-bit aligned, including TLVs */
 505         if (tlv_length%4 != 0)
 506             tlv_length+=4-(tlv_length%4);
 507         if (tlv_length > ls_length) {
 508             ND_PRINT("\n\t    Bogus padded length %u > %u", tlv_length,
 509                    ls_length);
 510             return -1;
 511         }
 512         ls_length-=tlv_length;
 513         tptr+=tlv_length;
 514     }
 515     return 0;
 516 trunc:
 517     return -1;
 518 invalid:
 519     nd_print_invalid(ndo);
 520     return -1;
 521 }
 522
 523 static int
 524 ospf_print_lshdr(netdissect_options *ndo,
 525                  const struct lsa_hdr *lshp)
 526 {
 527         u_int ls_type;
 528         u_int ls_length;
 529
 530         ls_length = GET_BE_U_2(lshp->ls_length);
 531         if (ls_length < sizeof(struct lsa_hdr)) {
 532                 ND_PRINT("\n\t    Bogus length %u < header (%zu)", ls_length,
 533                     sizeof(struct lsa_hdr));
 534                 return(-1);
 535         }
 536         ND_PRINT("\n\t  Advertising Router %s, seq 0x%08x, age %us, length %zu",
 537                   GET_IPADDR_STRING(lshp->ls_router),
 538                   GET_BE_U_4(lshp->ls_seq),
 539                   GET_BE_U_2(lshp->ls_age),
 540                   ls_length - sizeof(struct lsa_hdr));
 541         ls_type = GET_U_1(lshp->ls_type);
 542         switch (ls_type) {
 543         /* the LSA header for opaque LSAs was slightly changed */
 544         case LS_TYPE_OPAQUE_LL:
 545         case LS_TYPE_OPAQUE_AL:
 546         case LS_TYPE_OPAQUE_DW:
 547             ND_PRINT("\n\t    %s LSA (%u), Opaque-Type %s LSA (%u), Opaque-ID %u",
 548                    tok2str(lsa_values,"unknown",ls_type),
 549                    ls_type,
 550
 551                    tok2str(lsa_opaque_values,
 552                            "unknown",
 553                            GET_U_1(lshp->un_lsa_id.opaque_field.opaque_type)),
 554                    GET_U_1(lshp->un_lsa_id.opaque_field.opaque_type),
 555                    GET_BE_U_3(lshp->un_lsa_id.opaque_field.opaque_id)
 556
 557                    );
 558             break;
 559
 560         /* all other LSA types use regular style LSA headers */
 561         default:
 562             ND_PRINT("\n\t    %s LSA (%u), LSA-ID: %s",
 563                    tok2str(lsa_values,"unknown",ls_type),
 564                    ls_type,
 565                    GET_IPADDR_STRING(lshp->un_lsa_id.lsa_id));
 566             break;
 567         }
 568         ND_PRINT("\n\t    Options: [%s]",
 569                  bittok2str(ospf_option_values, "none", GET_U_1(lshp->ls_options)));
 570
 571         return (ls_length);
 572 }
 573
 574 /* draft-ietf-ospf-mt-09 */
 575 static const struct tok ospf_topology_values[] = {
 576     { 0, "default" },
 577     { 1, "multicast" },
 578     { 2, "management" },
 579     { 0, NULL }
 580 };
 581
 582 /*
 583  * Print all the per-topology metrics.
 584  */
 585 static void
 586 ospf_print_tos_metrics(netdissect_options *ndo,
 587                        const union un_tos *tos)
 588 {
 589     u_int metric_count;
 590     u_int toscount;
 591     u_int tos_type;
 592
 593     toscount = GET_U_1(tos->link.link_tos_count)+1;
 594     metric_count = 0;
 595
 596     /*
 597      * All but the first metric contain a valid topology id.
 598      */
 599     while (toscount != 0) {
 600         tos_type = GET_U_1(tos->metrics.tos_type);
 601         ND_PRINT("\n\t\ttopology %s (%u), metric %u",
 602                tok2str(ospf_topology_values, "Unknown",
 603                        metric_count ? tos_type : 0),
 604                metric_count ? tos_type : 0,
 605                GET_BE_U_2(tos->metrics.tos_metric));
 606         metric_count++;
 607         tos++;
 608         toscount--;
 609     }
 610 }
 611
 612 /*
 613  * Print a single link state advertisement.  If truncated or if LSA length
 614  * field is less than the length of the LSA header, return NULl, else
 615  * return pointer to data past end of LSA.
 616  */
 617 static const uint8_t *
 618 ospf_print_lsa(netdissect_options *ndo,
 619                const struct lsa *lsap)
 620 {
 621         const uint8_t *ls_end;
 622         const struct rlalink *rlp;
 623         const nd_ipv4 *ap;
 624         const struct aslametric *almp;
 625         const struct mcla *mcp;
 626         const uint8_t *lp;
 627         u_int tlv_type, tlv_length, rla_count, topology;
 628         int ospf_print_lshdr_ret;
 629         u_int ls_length;
 630         const uint8_t *tptr;
 631
 632         tptr = (const uint8_t *)lsap->lsa_un.un_unknown; /* squelch compiler warnings */
 633         ospf_print_lshdr_ret = ospf_print_lshdr(ndo, &lsap->ls_hdr);
 634         if (ospf_print_lshdr_ret < 0)
 635                 return(NULL);
 636         ls_length = (u_int)ospf_print_lshdr_ret;
 637         ls_end = (const uint8_t *)lsap + ls_length;
 638         /*
 639          * ospf_print_lshdr() returns -1 if the length is too short,
 640          * so we know ls_length is >= sizeof(struct lsa_hdr).
 641          */
 642         ls_length -= sizeof(struct lsa_hdr);
 643
 644         switch (GET_U_1(lsap->ls_hdr.ls_type)) {
 645
 646         case LS_TYPE_ROUTER:
 647                 ND_PRINT("\n\t    Router LSA Options: [%s]",
 648                           bittok2str(ospf_rla_flag_values, "none", GET_U_1(lsap->lsa_un.un_rla.rla_flags)));
 649
 650                 rla_count = GET_BE_U_2(lsap->lsa_un.un_rla.rla_count);
 651                 ND_TCHECK_SIZE(lsap->lsa_un.un_rla.rla_link);
 652                 rlp = lsap->lsa_un.un_rla.rla_link;
 653                 for (u_int i = rla_count; i != 0; i--) {
 654                         ND_TCHECK_SIZE(rlp);
 655                         switch (GET_U_1(rlp->un_tos.link.link_type)) {
 656
 657                         case RLA_TYPE_VIRTUAL:
 658                                 ND_PRINT("\n\t      Virtual Link: Neighbor Router-ID: %s, Interface Address: %s",
 659                                     GET_IPADDR_STRING(rlp->link_id),
 660                                     GET_IPADDR_STRING(rlp->link_data));
 661                                 break;
 662
 663                         case RLA_TYPE_ROUTER:
 664                                 ND_PRINT("\n\t      Neighbor Router-ID: %s, Interface Address: %s",
 665                                     GET_IPADDR_STRING(rlp->link_id),
 666                                     GET_IPADDR_STRING(rlp->link_data));
 667                                 break;
 668
 669                         case RLA_TYPE_TRANSIT:
 670                                 ND_PRINT("\n\t      Neighbor Network-ID: %s, Interface Address: %s",
 671                                     GET_IPADDR_STRING(rlp->link_id),
 672                                     GET_IPADDR_STRING(rlp->link_data));
 673                                 break;
 674
 675                         case RLA_TYPE_STUB:
 676                                 ND_PRINT("\n\t      Stub Network: %s, Mask: %s",
 677                                     GET_IPADDR_STRING(rlp->link_id),
 678                                     GET_IPADDR_STRING(rlp->link_data));
 679                                 break;
 680
 681                         default:
 682                                 ND_PRINT("\n\t      Unknown Router Link Type (%u)",
 683                                     GET_U_1(rlp->un_tos.link.link_type));
 684                                 return (ls_end);
 685                         }
 686
 687                         ospf_print_tos_metrics(ndo, &rlp->un_tos);
 688
 689                         rlp = (const struct rlalink *)((const u_char *)(rlp + 1) +
 690                             (GET_U_1(rlp->un_tos.link.link_tos_count) * sizeof(union un_tos)));
 691                 }
 692                 break;
 693
 694         case LS_TYPE_NETWORK:
 695                 ND_PRINT("\n\t    Mask %s\n\t    Connected Routers:",
 696                     GET_IPADDR_STRING(lsap->lsa_un.un_nla.nla_mask));
 697                 ap = lsap->lsa_un.un_nla.nla_router;
 698                 while ((const u_char *)ap < ls_end) {
 699                         ND_TCHECK_SIZE(ap);
 700                         ND_PRINT("\n\t      %s", GET_IPADDR_STRING(*ap));
 701                         ++ap;
 702                 }
 703                 break;
 704
 705         case LS_TYPE_SUM_IP:
 706                 ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask);
 707                 ND_PRINT("\n\t    Mask %s",
 708                     GET_IPADDR_STRING(lsap->lsa_un.un_sla.sla_mask));
 709                 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric);
 710                 lp = (const uint8_t *)lsap->lsa_un.un_sla.sla_tosmetric;
 711                 while (lp < ls_end) {
 712                         uint32_t ul;
 713
 714                         ul = GET_BE_U_4(lp);
 715                         topology = (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS;
 716                         ND_PRINT("\n\t\ttopology %s (%u) metric %u",
 717                                tok2str(ospf_topology_values, "Unknown", topology),
 718                                topology,
 719                                ul & SLA_MASK_METRIC);
 720                         lp += 4;
 721                 }
 722                 break;
 723
 724         case LS_TYPE_SUM_ABR:
 725                 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric);
 726                 lp = (const uint8_t *)lsap->lsa_un.un_sla.sla_tosmetric;
 727                 while (lp < ls_end) {
 728                         uint32_t ul;
 729
 730                         ul = GET_BE_U_4(lp);
 731                         topology = (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS;
 732                         ND_PRINT("\n\t\ttopology %s (%u) metric %u",
 733                                tok2str(ospf_topology_values, "Unknown", topology),
 734                                topology,
 735                                ul & SLA_MASK_METRIC);
 736                         lp += 4;
 737                 }
 738                 break;
 739
 740         case LS_TYPE_ASE:
 741         case LS_TYPE_NSSA: /* fall through - those LSAs share the same format */
 742                 ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask);
 743                 ND_PRINT("\n\t    Mask %s",
 744                     GET_IPADDR_STRING(lsap->lsa_un.un_asla.asla_mask));
 745
 746                 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric);
 747                 almp = lsap->lsa_un.un_asla.asla_metric;
 748                 while ((const u_char *)almp < ls_end) {
 749                         uint32_t ul;
 750
 751                         ul = GET_BE_U_4(almp->asla_tosmetric);
 752                         topology = ((ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS);
 753                         ND_PRINT("\n\t\ttopology %s (%u), type %u, metric",
 754                                tok2str(ospf_topology_values, "Unknown", topology),
 755                                topology,
 756                                (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1);
 757                         if ((ul & ASLA_MASK_METRIC) == 0xffffff)
 758                                 ND_PRINT(" infinite");
 759                         else
 760                                 ND_PRINT(" %u", (ul & ASLA_MASK_METRIC));
 761
 762                         if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_forward) != 0) {
 763                                 ND_PRINT(", forward %s", GET_IPADDR_STRING(almp->asla_forward));
 764                         }
 765                         if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_tag) != 0) {
 766                                 ND_PRINT(", tag %s", GET_IPADDR_STRING(almp->asla_tag));
 767                         }
 768                         ++almp;
 769                 }
 770                 break;
 771
 772         case LS_TYPE_GROUP:
 773                 /* Multicast extensions as of 23 July 1991 */
 774                 mcp = lsap->lsa_un.un_mcla;
 775                 while ((const u_char *)mcp < ls_end) {
 776                         switch (GET_BE_U_4(mcp->mcla_vtype)) {
 777
 778                         case MCLA_VERTEX_ROUTER:
 779                                 ND_PRINT("\n\t    Router Router-ID %s",
 780                                     GET_IPADDR_STRING(mcp->mcla_vid));
 781                                 break;
 782
 783                         case MCLA_VERTEX_NETWORK:
 784                                 ND_PRINT("\n\t    Network Designated Router %s",
 785                                     GET_IPADDR_STRING(mcp->mcla_vid));
 786                                 break;
 787
 788                         default:
 789                                 ND_PRINT("\n\t    unknown VertexType (%u)",
 790                                     GET_BE_U_4(mcp->mcla_vtype));
 791                                 break;
 792                         }
 793                 ++mcp;
 794                 }
 795                 break;
 796
 797         case LS_TYPE_OPAQUE_LL: /* fall through */
 798         case LS_TYPE_OPAQUE_AL:
 799         case LS_TYPE_OPAQUE_DW:
 800
 801             switch (GET_U_1(lsap->ls_hdr.un_lsa_id.opaque_field.opaque_type)) {
 802             case LS_OPAQUE_TYPE_RI:
 803                 tptr = (const uint8_t *)(lsap->lsa_un.un_ri_tlv);
 804
 805                 u_int ls_length_remaining = ls_length;
 806                 while (ls_length_remaining != 0) {
 807                     ND_TCHECK_4(tptr);
 808                     if (ls_length_remaining < 4) {
 809                         ND_PRINT("\n\t    Remaining LS length %u < 4", ls_length_remaining);
 810                         return(ls_end);
 811                     }
 812                     tlv_type = GET_BE_U_2(tptr);
 813                     tlv_length = GET_BE_U_2(tptr + 2);
 814                     tptr+=4;
 815                     ls_length_remaining-=4;
 816
 817                     ND_PRINT("\n\t    %s TLV (%u), length: %u, value: ",
 818                            tok2str(lsa_opaque_ri_tlv_values,"unknown",tlv_type),
 819                            tlv_type,
 820                            tlv_length);
 821
 822                     if (tlv_length > ls_length_remaining) {
 823                         ND_PRINT("\n\t    Bogus length %u > remaining LS length %u", tlv_length,
 824                             ls_length_remaining);
 825                         return(ls_end);
 826                     }
 827                     ND_TCHECK_LEN(tptr, tlv_length);
 828                     switch(tlv_type) {
 829
 830                     case LS_OPAQUE_RI_TLV_CAP:
 831                         if (tlv_length != 4) {
 832                             ND_PRINT("\n\t    Bogus length %u != 4", tlv_length);
 833                             return(ls_end);
 834                         }
 835                         ND_PRINT("Capabilities: %s",
 836                                bittok2str(lsa_opaque_ri_tlv_cap_values, "Unknown", GET_BE_U_4(tptr)));
 837                         break;
 838                     default:
 839                         if (ndo->ndo_vflag <= 1) {
 840                             if (!print_unknown_data(ndo, tptr, "\n\t      ", tlv_length))
 841                                 return(ls_end);
 842                         }
 843                         break;
 844
 845                     }
 846                     tptr+=tlv_length;
 847                     ls_length_remaining-=tlv_length;
 848                 }
 849                 break;
 850
 851             case LS_OPAQUE_TYPE_GRACE:
 852                 if (ospf_grace_lsa_print(ndo, (const u_char *)(lsap->lsa_un.un_grace_tlv),
 853                                          ls_length) == -1) {
 854                     return(ls_end);
 855                 }
 856                 break;
 857
 858             case LS_OPAQUE_TYPE_TE:
 859                 if (ospf_te_lsa_print(ndo, (const u_char *)(lsap->lsa_un.un_te_lsa_tlv),
 860                                       ls_length) == -1) {
 861                     return(ls_end);
 862                 }
 863                 break;
 864
 865             default:
 866                 if (ndo->ndo_vflag <= 1) {
 867                     if (!print_unknown_data(ndo, (const uint8_t *)lsap->lsa_un.un_unknown,
 868                                            "\n\t    ", ls_length))
 869                         return(ls_end);
 870                 }
 871                 break;
 872             }
 873         }
 874
 875         /* do we want to see an additionally hexdump ? */
 876         if (ndo->ndo_vflag> 1)
 877             if (!print_unknown_data(ndo, (const uint8_t *)lsap->lsa_un.un_unknown,
 878                                    "\n\t    ", ls_length)) {
 879                 return(ls_end);
 880             }
 881
 882         return (ls_end);
 883 trunc:
 884         return (NULL);
 885 }
 886
 887 static void
 888 ospf_decode_lls(netdissect_options *ndo,
 889                 const struct ospfhdr *op, u_int length)
 890 {
 891     const u_char *dptr;
 892     const u_char *dataend;
 893     u_int length2;
 894     uint16_t lls_type, lls_len;
 895     uint32_t lls_flags;
 896
 897     switch (GET_U_1(op->ospf_type)) {
 898
 899     case OSPF_TYPE_HELLO:
 900         if (!(GET_U_1(op->ospf_hello.hello_options) & OSPF_OPTION_L))
 901             return;
 902         break;
 903
 904     case OSPF_TYPE_DD:
 905         if (!(GET_U_1(op->ospf_db.db_options) & OSPF_OPTION_L))
 906             return;
 907         break;
 908
 909     default:
 910         return;
 911     }
 912
 913     /* dig deeper if LLS data is available; see RFC4813 */
 914     length2 = GET_BE_U_2(op->ospf_len);
 915     dptr = (const u_char *)op + length2;
 916     dataend = (const u_char *)op + length;
 917
 918     if (GET_BE_U_2(op->ospf_authtype) == OSPF_AUTH_MD5) {
 919         dptr = dptr + GET_U_1(op->ospf_authdata + 3);
 920         length2 += GET_U_1(op->ospf_authdata + 3);
 921     }
 922     if (length2 >= length) {
 923         ND_PRINT("\n\t[LLS truncated]");
 924         return;
 925     }
 926     ND_PRINT("\n\t  LLS: checksum: 0x%04x", (u_int) GET_BE_U_2(dptr));
 927
 928     dptr += 2;
 929     length2 = GET_BE_U_2(dptr);
 930     ND_PRINT(", length: %u", length2);
 931
 932     dptr += 2;
 933     while (dptr < dataend) {
 934         lls_type = GET_BE_U_2(dptr);
 935         ND_PRINT("\n\t    %s (%u)",
 936                tok2str(ospf_lls_tlv_values,"Unknown TLV",lls_type),
 937                lls_type);
 938         dptr += 2;
 939         lls_len = GET_BE_U_2(dptr);
 940         ND_PRINT(", length: %u", lls_len);
 941         dptr += 2;
 942         switch (lls_type) {
 943
 944         case OSPF_LLS_EO:
 945             if (lls_len != 4) {
 946                 ND_PRINT(" [should be 4]");
 947                 lls_len = 4;
 948             }
 949             lls_flags = GET_BE_U_4(dptr);
 950             ND_PRINT("\n\t      Options: 0x%08x [%s]", lls_flags,
 951                    bittok2str(ospf_lls_eo_options, "?", lls_flags));
 952
 953             break;
 954
 955         case OSPF_LLS_MD5:
 956             if (lls_len != 20) {
 957                 ND_PRINT(" [should be 20]");
 958                 lls_len = 20;
 959             }
 960             ND_PRINT("\n\t      Sequence number: 0x%08x", GET_BE_U_4(dptr));
 961             break;
 962         }
 963
 964         dptr += lls_len;
 965     }
 966 }
 967
 968 static int
 969 ospf_decode_v2(netdissect_options *ndo,
 970                const struct ospfhdr *op, const u_char *dataend)
 971 {
 972         const nd_ipv4 *ap;
 973         const struct lsr *lsrp;
 974         const struct lsa_hdr *lshp;
 975         const struct lsa *lsap;
 976         uint32_t lsa_count,lsa_count_max;
 977
 978         switch (GET_U_1(op->ospf_type)) {
 979
 980         case OSPF_TYPE_HELLO:
 981                 ND_PRINT("\n\tOptions [%s]",
 982                           bittok2str(ospf_option_values,"none",GET_U_1(op->ospf_hello.hello_options)));
 983
 984                 ND_PRINT("\n\t  Hello Timer %us, Dead Timer %us, Mask %s, Priority %u",
 985                           GET_BE_U_2(op->ospf_hello.hello_helloint),
 986                           GET_BE_U_4(op->ospf_hello.hello_deadint),
 987                           GET_IPADDR_STRING(op->ospf_hello.hello_mask),
 988                           GET_U_1(op->ospf_hello.hello_priority));
 989
 990                 if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_dr) != 0)
 991                         ND_PRINT("\n\t  Designated Router %s",
 992                             GET_IPADDR_STRING(op->ospf_hello.hello_dr));
 993
 994                 if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_bdr) != 0)
 995                         ND_PRINT(", Backup Designated Router %s",
 996                                   GET_IPADDR_STRING(op->ospf_hello.hello_bdr));
 997
 998                 ap = op->ospf_hello.hello_neighbor;
 999                 if ((const u_char *)ap < dataend)
1000                         ND_PRINT("\n\t  Neighbor List:");
1001                 while ((const u_char *)ap < dataend) {
1002                         ND_TCHECK_SIZE(ap);
1003                         ND_PRINT("\n\t    %s", GET_IPADDR_STRING(*ap));
1004                         ++ap;
1005                 }
1006                 break;  /* HELLO */
1007
1008         case OSPF_TYPE_DD:
1009                 ND_PRINT("\n\tOptions [%s]",
1010                           bittok2str(ospf_option_values, "none", GET_U_1(op->ospf_db.db_options)));
1011                 ND_PRINT(", DD Flags [%s]",
1012                           bittok2str(ospf_dd_flag_values, "none", GET_U_1(op->ospf_db.db_flags)));
1013                 if (GET_BE_U_2(op->ospf_db.db_ifmtu)) {
1014                         ND_PRINT(", MTU: %u",
1015                                  GET_BE_U_2(op->ospf_db.db_ifmtu));
1016                 }
1017                 ND_PRINT(", Sequence: 0x%08x", GET_BE_U_4(op->ospf_db.db_seq));
1018
1019                 /* Print all the LS adv's */
1020                 lshp = op->ospf_db.db_lshdr;
1021                 while (((const u_char *)lshp < dataend) && ospf_print_lshdr(ndo, lshp) != -1) {
1022                         ++lshp;
1023                 }
1024                 break;
1025
1026         case OSPF_TYPE_LS_REQ:
1027                 lsrp = op->ospf_lsr;
1028                 while ((const u_char *)lsrp < dataend) {
1029                     ND_TCHECK_SIZE(lsrp);
1030
1031                     ND_PRINT("\n\t  Advertising Router: %s, %s LSA (%u)",
1032                            GET_IPADDR_STRING(lsrp->ls_router),
1033                            tok2str(lsa_values,"unknown",GET_BE_U_4(lsrp->ls_type)),
1034                            GET_BE_U_4(lsrp->ls_type));
1035
1036                     switch (GET_BE_U_4(lsrp->ls_type)) {
1037                         /* the LSA header for opaque LSAs was slightly changed */
1038                     case LS_TYPE_OPAQUE_LL:
1039                     case LS_TYPE_OPAQUE_AL:
1040                     case LS_TYPE_OPAQUE_DW:
1041                         ND_PRINT(", Opaque-Type: %s LSA (%u), Opaque-ID: %u",
1042                                tok2str(lsa_opaque_values, "unknown",GET_U_1(lsrp->un_ls_stateid.opaque_field.opaque_type)),
1043                                GET_U_1(lsrp->un_ls_stateid.opaque_field.opaque_type),
1044                                GET_BE_U_3(lsrp->un_ls_stateid.opaque_field.opaque_id));
1045                         break;
1046                     default:
1047                         ND_PRINT(", LSA-ID: %s",
1048                                GET_IPADDR_STRING(lsrp->un_ls_stateid.ls_stateid));
1049                         break;
1050                     }
1051
1052                     ++lsrp;
1053                 }
1054                 break;
1055
1056         case OSPF_TYPE_LS_UPDATE:
1057                 lsap = op->ospf_lsu.lsu_lsa;
1058                 lsa_count_max = GET_BE_U_4(op->ospf_lsu.lsu_count);
1059                 ND_PRINT(", %u LSA%s", lsa_count_max, PLURAL_SUFFIX(lsa_count_max));
1060                 for (lsa_count=1;lsa_count <= lsa_count_max;lsa_count++) {
1061                     ND_PRINT("\n\t  LSA #%u", lsa_count);
1062                         lsap = (const struct lsa *)ospf_print_lsa(ndo, lsap);
1063                         if (lsap == NULL)
1064                                 goto trunc;
1065                 }
1066                 break;
1067
1068         case OSPF_TYPE_LS_ACK:
1069                 lshp = op->ospf_lsa.lsa_lshdr;
1070                 while (ospf_print_lshdr(ndo, lshp) != -1) {
1071                     ++lshp;
1072                 }
1073                 break;
1074
1075         default:
1076                 break;
1077         }
1078         return (0);
1079 trunc:
1080         return (1);
1081 }
1082
1083 void
1084 ospf_print(netdissect_options *ndo,
1085            const u_char *bp, u_int length,
1086            const u_char *bp2 _U_)
1087 {
1088         const struct ospfhdr *op;
1089         const u_char *dataend;
1090         const char *cp;
1091
1092         ndo->ndo_protocol = "ospf2";
1093         op = (const struct ospfhdr *)bp;
1094
1095         /* XXX Before we do anything else, strip off the MD5 trailer */
1096         if (GET_BE_U_2(op->ospf_authtype) == OSPF_AUTH_MD5) {
1097                 length -= OSPF_AUTH_MD5_LEN;
1098                 ndo->ndo_snapend -= OSPF_AUTH_MD5_LEN;
1099         }
1100
1101         /* If the type is valid translate it, or just print the type */
1102         /* value.  If it's not valid, say so and return */
1103         cp = tok2str(type2str, "unknown LS-type %u", GET_U_1(op->ospf_type));
1104         ND_PRINT("OSPFv%u, %s, length %u", GET_U_1(op->ospf_version), cp,
1105                  length);
1106         if (*cp == 'u')
1107                 return;
1108
1109         if (!ndo->ndo_vflag) { /* non verbose - so lets bail out here */
1110                 return;
1111         }
1112
1113         if (length != GET_BE_U_2(op->ospf_len)) {
1114                 ND_PRINT(" [len %u]", GET_BE_U_2(op->ospf_len));
1115         }
1116
1117         if (length > GET_BE_U_2(op->ospf_len)) {
1118                 dataend = bp + GET_BE_U_2(op->ospf_len);
1119         } else {
1120                 dataend = bp + length;
1121         }
1122
1123         ND_PRINT("\n\tRouter-ID %s", GET_IPADDR_STRING(op->ospf_routerid));
1124
1125         if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_areaid) != 0)
1126                 ND_PRINT(", Area %s", GET_IPADDR_STRING(op->ospf_areaid));
1127         else
1128                 ND_PRINT(", Backbone Area");
1129
1130         if (ndo->ndo_vflag) {
1131                 /* Print authentication data (should we really do this?) */
1132                 ND_TCHECK_LEN(op->ospf_authdata, sizeof(op->ospf_authdata));
1133
1134                 ND_PRINT(", Authentication Type: %s (%u)",
1135                           tok2str(ospf_authtype_values, "unknown", GET_BE_U_2(op->ospf_authtype)),
1136                           GET_BE_U_2(op->ospf_authtype));
1137
1138                 switch (GET_BE_U_2(op->ospf_authtype)) {
1139
1140                 case OSPF_AUTH_NONE:
1141                         break;
1142
1143                 case OSPF_AUTH_SIMPLE:
1144                         ND_PRINT("\n\tSimple text password: ");
1145                         nd_printjnp(ndo, op->ospf_authdata, OSPF_AUTH_SIMPLE_LEN);
1146                         break;
1147
1148                 case OSPF_AUTH_MD5:
1149                         ND_PRINT("\n\tKey-ID: %u, Auth-Length: %u, Crypto Sequence Number: 0x%08x",
1150                                   GET_U_1(op->ospf_authdata + 2),
1151                                   GET_U_1(op->ospf_authdata + 3),
1152                                   GET_BE_U_4((op->ospf_authdata) + 4));
1153                         break;
1154
1155                 default:
1156                         return;
1157                 }
1158         }
1159         /* Do rest according to version.         */
1160         switch (GET_U_1(op->ospf_version)) {
1161
1162         case 2:
1163                 /* ospf version 2 */
1164                 if (ospf_decode_v2(ndo, op, dataend))
1165                         goto trunc;
1166                 if (length > GET_BE_U_2(op->ospf_len))
1167                         ospf_decode_lls(ndo, op, length);
1168                 break;
1169
1170         default:
1171                 ND_PRINT(" ospf [version %u]", GET_U_1(op->ospf_version));
1172                 break;
1173         }                       /* end switch on version */
1174
1175         return;
1176 trunc:
1177         nd_trunc_longjmp(ndo);
1178 }