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