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 40static 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 52static 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 59static const struct tok ospf_rla_flag_values[] = { 60 { RLA_FLAG_B, "ABR" }, 61 { RLA_FLAG_E, "ASBR" }, 62 { RLA_FLAG_V, "Virtual" }, 63 { RLA_FLAG_W, "Wildcard" }, 64 { RLA_FLAG_NT, "Nt" }, 65 { RLA_FLAG_H, "Host" }, 66 { 0, NULL } 67}; 68 69static const struct tok type2str[] = { 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 78static 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 92static 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 100static 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 107static 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 113static 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 131static 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 138static 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 146static 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 152static const struct tok lsa_opaque_ri_tlv_values[] = { 153 { LS_OPAQUE_RI_TLV_CAP, "Router Capabilities" }, 154 { 0, NULL } 155}; 156 157static 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 171static const struct tok ospf_lls_tlv_values[] = { 172 { OSPF_LLS_EO, "Extended Options" }, 173 { OSPF_LLS_MD5, "MD5 Authentication" }, 174 { 0, NULL } 175}; 176 177static 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 183int 184ospf_grace_lsa_print(netdissect_options *ndo, 185 const u_char *tptr, u_int ls_length) 186{ 187 u_int tlv_type, tlv_length; 188 189 190 while (ls_length > 0) { 191 ND_TCHECK_4(tptr); 192 if (ls_length < 4) { 193 ND_PRINT("\n\t Remaining LS length %u < 4", ls_length); 194 return -1; 195 } 196 tlv_type = GET_BE_U_2(tptr); 197 tlv_length = GET_BE_U_2(tptr + 2); 198 tptr+=4; 199 ls_length-=4; 200 201 ND_PRINT("\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("\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_TCHECK_LEN(tptr, tlv_length); 218 switch(tlv_type) { 219 220 case LS_OPAQUE_GRACE_TLV_PERIOD: 221 if (tlv_length != 4) { 222 ND_PRINT("\n\t Bogus length %u != 4", tlv_length); 223 return -1; 224 } 225 ND_PRINT("%us", GET_BE_U_4(tptr)); 226 break; 227 228 case LS_OPAQUE_GRACE_TLV_REASON: 229 if (tlv_length != 1) { 230 ND_PRINT("\n\t Bogus length %u != 1", tlv_length); 231 return -1; 232 } 233 ND_PRINT("%s (%u)", 234 tok2str(lsa_opaque_grace_tlv_reason_values, "Unknown", GET_U_1(tptr)), 235 GET_U_1(tptr)); 236 break; 237 238 case LS_OPAQUE_GRACE_TLV_INT_ADDRESS: 239 if (tlv_length != 4) { 240 ND_PRINT("\n\t Bogus length %u != 4", tlv_length); 241 return -1; 242 } 243 ND_PRINT("%s", GET_IPADDR_STRING(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; 262trunc: 263 return -1; 264} 265 266int 267ospf_te_lsa_print(netdissect_options *ndo, 268 const u_char *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_TCHECK_4(tptr); 279 if (ls_length < 4) { 280 ND_PRINT("\n\t Remaining LS length %u < 4", ls_length); 281 return -1; 282 } 283 tlv_type = GET_BE_U_2(tptr); 284 tlv_length = GET_BE_U_2(tptr + 2); 285 tptr+=4; 286 ls_length-=4; 287 288 ND_PRINT("\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("\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 != 0) { 307 if (tlv_length < 4) { 308 ND_PRINT("\n\t Remaining TLV length %u < 4", 309 tlv_length); 310 return -1; 311 } 312 subtlv_type = GET_BE_U_2(tptr); 313 subtlv_length = GET_BE_U_2(tptr + 2); 314 tptr+=4; 315 tlv_length-=4; 316 317 /* Infinite loop protection */ 318 if (subtlv_type == 0 || subtlv_length == 0) 319 goto invalid; 320 321 ND_PRINT("\n\t %s subTLV (%u), length: %u", 322 tok2str(lsa_opaque_te_link_tlv_subtlv_values,"unknown",subtlv_type), 323 subtlv_type, 324 subtlv_length); 325 326 if (tlv_length < subtlv_length) { 327 ND_PRINT("\n\t Remaining TLV length %u < %u", 328 tlv_length + 4, subtlv_length + 4); 329 return -1; 330 } 331 ND_TCHECK_LEN(tptr, subtlv_length); 332 switch(subtlv_type) { 333 case LS_OPAQUE_TE_LINK_SUBTLV_ADMIN_GROUP: 334 if (subtlv_length != 4) { 335 ND_PRINT(" != 4"); 336 goto invalid; 337 } 338 ND_PRINT(", 0x%08x", GET_BE_U_4(tptr)); 339 break; 340 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_ID: 341 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_LOCAL_REMOTE_ID: 342 if (subtlv_length != 4 && subtlv_length != 8) { 343 ND_PRINT(" != 4 && != 8"); 344 goto invalid; 345 } 346 ND_PRINT(", %s (0x%08x)", 347 GET_IPADDR_STRING(tptr), 348 GET_BE_U_4(tptr)); 349 if (subtlv_length == 8) /* rfc4203 */ 350 ND_PRINT(", %s (0x%08x)", 351 GET_IPADDR_STRING(tptr+4), 352 GET_BE_U_4(tptr + 4)); 353 break; 354 case LS_OPAQUE_TE_LINK_SUBTLV_LOCAL_IP: 355 case LS_OPAQUE_TE_LINK_SUBTLV_REMOTE_IP: 356 if (subtlv_length != 4) { 357 ND_PRINT(" != 4"); 358 goto invalid; 359 } 360 ND_PRINT(", %s", GET_IPADDR_STRING(tptr)); 361 break; 362 case LS_OPAQUE_TE_LINK_SUBTLV_MAX_BW: 363 case LS_OPAQUE_TE_LINK_SUBTLV_MAX_RES_BW: 364 if (subtlv_length != 4) { 365 ND_PRINT(" != 4"); 366 goto invalid; 367 } 368 bw.i = GET_BE_U_4(tptr); 369 ND_PRINT(", %.3f Mbps", bw.f * 8 / 1000000); 370 break; 371 case LS_OPAQUE_TE_LINK_SUBTLV_UNRES_BW: 372 if (subtlv_length != 32) { 373 ND_PRINT(" != 32"); 374 goto invalid; 375 } 376 for (te_class = 0; te_class < 8; te_class++) { 377 bw.i = GET_BE_U_4(tptr + te_class * 4); 378 ND_PRINT("\n\t\tTE-Class %u: %.3f Mbps", 379 te_class, 380 bw.f * 8 / 1000000); 381 } 382 break; 383 case LS_OPAQUE_TE_LINK_SUBTLV_BW_CONSTRAINTS: 384 if (subtlv_length < 4) { 385 ND_PRINT(" < 4"); 386 goto invalid; 387 } 388 /* BC Model Id (1 octet) + Reserved (3 octets) */ 389 ND_PRINT("\n\t\tBandwidth Constraints Model ID: %s (%u)", 390 tok2str(diffserv_te_bc_values, "unknown", GET_U_1(tptr)), 391 GET_U_1(tptr)); 392 if (subtlv_length % 4 != 0) { 393 ND_PRINT("\n\t\tlength %u != N x 4", subtlv_length); 394 goto invalid; 395 } 396 if (subtlv_length > 36) { 397 ND_PRINT("\n\t\tlength %u > 36", subtlv_length); 398 goto invalid; 399 } 400 /* decode BCs until the subTLV ends */ 401 for (te_class = 0; te_class < (subtlv_length-4)/4; te_class++) { 402 bw.i = GET_BE_U_4(tptr + 4 + te_class * 4); 403 ND_PRINT("\n\t\t Bandwidth constraint CT%u: %.3f Mbps", 404 te_class, 405 bw.f * 8 / 1000000); 406 } 407 break; 408 case LS_OPAQUE_TE_LINK_SUBTLV_TE_METRIC: 409 if (subtlv_length != 4) { 410 ND_PRINT(" != 4"); 411 goto invalid; 412 } 413 ND_PRINT(", Metric %u", GET_BE_U_4(tptr)); 414 break; 415 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_PROTECTION_TYPE: 416 /* Protection Cap (1 octet) + Reserved ((3 octets) */ 417 if (subtlv_length != 4) { 418 ND_PRINT(" != 4"); 419 goto invalid; 420 } 421 ND_PRINT(", %s", 422 bittok2str(gmpls_link_prot_values, "none", GET_U_1(tptr))); 423 break; 424 case LS_OPAQUE_TE_LINK_SUBTLV_INTF_SW_CAP_DESCR: 425 if (subtlv_length < 36) { 426 ND_PRINT(" < 36"); 427 goto invalid; 428 } 429 /* Switching Cap (1 octet) + Encoding (1) + Reserved (2) */ 430 ND_PRINT("\n\t\tInterface Switching Capability: %s", 431 tok2str(gmpls_switch_cap_values, "Unknown", GET_U_1((tptr)))); 432 ND_PRINT("\n\t\tLSP Encoding: %s\n\t\tMax LSP Bandwidth:", 433 tok2str(gmpls_encoding_values, "Unknown", GET_U_1((tptr + 1)))); 434 for (priority_level = 0; priority_level < 8; priority_level++) { 435 bw.i = GET_BE_U_4(tptr + 4 + (priority_level * 4)); 436 ND_PRINT("\n\t\t priority level %u: %.3f Mbps", 437 priority_level, 438 bw.f * 8 / 1000000); 439 } 440 break; 441 case LS_OPAQUE_TE_LINK_SUBTLV_LINK_TYPE: 442 if (subtlv_length != 1) { 443 ND_PRINT(" != 1"); 444 goto invalid; 445 } 446 ND_PRINT(", %s (%u)", 447 tok2str(lsa_opaque_te_tlv_link_type_sub_tlv_values,"unknown",GET_U_1(tptr)), 448 GET_U_1(tptr)); 449 break; 450 451 case LS_OPAQUE_TE_LINK_SUBTLV_SHARED_RISK_GROUP: 452 if (subtlv_length % 4 != 0) { 453 ND_PRINT(" != N x 4"); 454 goto invalid; 455 } 456 count_srlg = subtlv_length / 4; 457 if (count_srlg != 0) 458 ND_PRINT("\n\t\t Shared risk group: "); 459 while (count_srlg > 0) { 460 bw.i = GET_BE_U_4(tptr); 461 ND_PRINT("%u", bw.i); 462 tptr+=4; 463 count_srlg--; 464 if (count_srlg > 0) 465 ND_PRINT(", "); 466 } 467 break; 468 469 default: 470 if (ndo->ndo_vflag <= 1) { 471 if (!print_unknown_data(ndo, tptr, "\n\t\t", subtlv_length)) 472 return -1; 473 } 474 break; 475 } 476 /* in OSPF everything has to be 32-bit aligned, including subTLVs */ 477 if (subtlv_length%4 != 0) 478 subtlv_length+=4-(subtlv_length%4); 479 480 if (tlv_length < subtlv_length) { 481 ND_PRINT("\n\t Remaining TLV length %u < %u", 482 tlv_length + 4, subtlv_length + 4); 483 return -1; 484 } 485 tlv_length-=subtlv_length; 486 tptr+=subtlv_length; 487 488 } 489 break; 490 491 case LS_OPAQUE_TE_TLV_ROUTER: 492 if (tlv_length < 4) { 493 ND_PRINT("\n\t TLV length %u < 4", tlv_length); 494 return -1; 495 } 496 ND_PRINT(", %s", GET_IPADDR_STRING(tptr)); 497 break; 498 499 default: 500 if (ndo->ndo_vflag <= 1) { 501 if (!print_unknown_data(ndo, tptr, "\n\t ", tlv_length)) 502 return -1; 503 } 504 break; 505 } 506 /* in OSPF everything has to be 32-bit aligned, including TLVs */ 507 if (tlv_length%4 != 0) 508 tlv_length+=4-(tlv_length%4); 509 if (tlv_length > ls_length) { 510 ND_PRINT("\n\t Bogus padded length %u > %u", tlv_length, 511 ls_length); 512 return -1; 513 } 514 ls_length-=tlv_length; 515 tptr+=tlv_length; 516 } 517 return 0; 518trunc: 519 return -1; 520invalid: 521 nd_print_invalid(ndo); 522 return -1; 523} 524 525static int 526ospf_print_lshdr(netdissect_options *ndo, 527 const struct lsa_hdr *lshp) 528{ 529 u_int ls_type; 530 u_int ls_length; 531 532 ls_length = GET_BE_U_2(lshp->ls_length); 533 if (ls_length < sizeof(struct lsa_hdr)) { 534 ND_PRINT("\n\t Bogus length %u < header (%zu)", ls_length, 535 sizeof(struct lsa_hdr)); 536 return(-1); 537 } 538 ND_PRINT("\n\t Advertising Router %s, seq 0x%08x, age %us, length %zu", 539 GET_IPADDR_STRING(lshp->ls_router), 540 GET_BE_U_4(lshp->ls_seq), 541 GET_BE_U_2(lshp->ls_age), 542 ls_length - sizeof(struct lsa_hdr)); 543 ls_type = GET_U_1(lshp->ls_type); 544 switch (ls_type) { 545 /* the LSA header for opaque LSAs was slightly changed */ 546 case LS_TYPE_OPAQUE_LL: 547 case LS_TYPE_OPAQUE_AL: 548 case LS_TYPE_OPAQUE_DW: 549 ND_PRINT("\n\t %s LSA (%u), Opaque-Type %s LSA (%u), Opaque-ID %u", 550 tok2str(lsa_values,"unknown",ls_type), 551 ls_type, 552 553 tok2str(lsa_opaque_values, 554 "unknown", 555 GET_U_1(lshp->un_lsa_id.opaque_field.opaque_type)), 556 GET_U_1(lshp->un_lsa_id.opaque_field.opaque_type), 557 GET_BE_U_3(lshp->un_lsa_id.opaque_field.opaque_id) 558 559 ); 560 break; 561 562 /* all other LSA types use regular style LSA headers */ 563 default: 564 ND_PRINT("\n\t %s LSA (%u), LSA-ID: %s", 565 tok2str(lsa_values,"unknown",ls_type), 566 ls_type, 567 GET_IPADDR_STRING(lshp->un_lsa_id.lsa_id)); 568 break; 569 } 570 ND_PRINT("\n\t Options: [%s]", 571 bittok2str(ospf_option_values, "none", GET_U_1(lshp->ls_options))); 572 573 return (ls_length); 574} 575 576/* draft-ietf-ospf-mt-09 */ 577static const struct tok ospf_topology_values[] = { 578 { 0, "default" }, 579 { 1, "multicast" }, 580 { 2, "management" }, 581 { 0, NULL } 582}; 583 584/* 585 * Print all the per-topology metrics. 586 */ 587static void 588ospf_print_tos_metrics(netdissect_options *ndo, 589 const union un_tos *tos) 590{ 591 u_int metric_count; 592 u_int toscount; 593 u_int tos_type; 594 595 toscount = GET_U_1(tos->link.link_tos_count)+1; 596 metric_count = 0; 597 598 /* 599 * All but the first metric contain a valid topology id. 600 */ 601 while (toscount != 0) { 602 tos_type = GET_U_1(tos->metrics.tos_type); 603 ND_PRINT("\n\t\ttopology %s (%u), metric %u", 604 tok2str(ospf_topology_values, "Unknown", 605 metric_count ? tos_type : 0), 606 metric_count ? tos_type : 0, 607 GET_BE_U_2(tos->metrics.tos_metric)); 608 metric_count++; 609 tos++; 610 toscount--; 611 } 612} 613 614/* 615 * Print a single link state advertisement. If truncated or if LSA length 616 * field is less than the length of the LSA header, return NULl, else 617 * return pointer to data past end of LSA. 618 */ 619static const uint8_t * 620ospf_print_lsa(netdissect_options *ndo, 621 const struct lsa *lsap) 622{ 623 const uint8_t *ls_end; 624 const struct rlalink *rlp; 625 const nd_ipv4 *ap; 626 const struct aslametric *almp; 627 const struct mcla *mcp; 628 const uint8_t *lp; 629 u_int tlv_type, tlv_length, rla_count, topology; 630 int ospf_print_lshdr_ret; 631 u_int ls_length; 632 const uint8_t *tptr; 633 634 tptr = (const uint8_t *)lsap->lsa_un.un_unknown; /* squelch compiler warnings */ 635 ospf_print_lshdr_ret = ospf_print_lshdr(ndo, &lsap->ls_hdr); 636 if (ospf_print_lshdr_ret < 0) 637 return(NULL); 638 ls_length = (u_int)ospf_print_lshdr_ret; 639 ls_end = (const uint8_t *)lsap + ls_length; 640 /* 641 * ospf_print_lshdr() returns -1 if the length is too short, 642 * so we know ls_length is >= sizeof(struct lsa_hdr). 643 */ 644 ls_length -= sizeof(struct lsa_hdr); 645 646 switch (GET_U_1(lsap->ls_hdr.ls_type)) { 647 648 case LS_TYPE_ROUTER: 649 ND_PRINT("\n\t Router LSA Options: [%s]", 650 bittok2str(ospf_rla_flag_values, "none", GET_U_1(lsap->lsa_un.un_rla.rla_flags))); 651 652 rla_count = GET_BE_U_2(lsap->lsa_un.un_rla.rla_count); 653 ND_TCHECK_SIZE(lsap->lsa_un.un_rla.rla_link); 654 rlp = lsap->lsa_un.un_rla.rla_link; 655 for (u_int i = rla_count; i != 0; i--) { 656 ND_TCHECK_SIZE(rlp); 657 switch (GET_U_1(rlp->un_tos.link.link_type)) { 658 659 case RLA_TYPE_VIRTUAL: 660 ND_PRINT("\n\t Virtual Link: Neighbor Router-ID: %s, Interface Address: %s", 661 GET_IPADDR_STRING(rlp->link_id), 662 GET_IPADDR_STRING(rlp->link_data)); 663 break; 664 665 case RLA_TYPE_ROUTER: 666 ND_PRINT("\n\t Neighbor Router-ID: %s, Interface Address: %s", 667 GET_IPADDR_STRING(rlp->link_id), 668 GET_IPADDR_STRING(rlp->link_data)); 669 break; 670 671 case RLA_TYPE_TRANSIT: 672 ND_PRINT("\n\t Neighbor Network-ID: %s, Interface Address: %s", 673 GET_IPADDR_STRING(rlp->link_id), 674 GET_IPADDR_STRING(rlp->link_data)); 675 break; 676 677 case RLA_TYPE_STUB: 678 ND_PRINT("\n\t Stub Network: %s, Mask: %s", 679 GET_IPADDR_STRING(rlp->link_id), 680 GET_IPADDR_STRING(rlp->link_data)); 681 break; 682 683 default: 684 ND_PRINT("\n\t Unknown Router Link Type (%u)", 685 GET_U_1(rlp->un_tos.link.link_type)); 686 return (ls_end); 687 } 688 689 ospf_print_tos_metrics(ndo, &rlp->un_tos); 690 691 rlp = (const struct rlalink *)((const u_char *)(rlp + 1) + 692 (GET_U_1(rlp->un_tos.link.link_tos_count) * sizeof(union un_tos))); 693 } 694 break; 695 696 case LS_TYPE_NETWORK: 697 ND_PRINT("\n\t Mask %s\n\t Connected Routers:", 698 GET_IPADDR_STRING(lsap->lsa_un.un_nla.nla_mask)); 699 ap = lsap->lsa_un.un_nla.nla_router; 700 while ((const u_char *)ap < ls_end) { 701 ND_PRINT("\n\t %s", GET_IPADDR_STRING(ap)); 702 ++ap; 703 } 704 break; 705 706 case LS_TYPE_SUM_IP: 707 ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask); 708 ND_PRINT("\n\t Mask %s", 709 GET_IPADDR_STRING(lsap->lsa_un.un_sla.sla_mask)); 710 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric); 711 lp = (const uint8_t *)lsap->lsa_un.un_sla.sla_tosmetric; 712 while (lp < ls_end) { 713 uint32_t ul; 714 715 ul = GET_BE_U_4(lp); 716 topology = (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS; 717 ND_PRINT("\n\t\ttopology %s (%u) metric %u", 718 tok2str(ospf_topology_values, "Unknown", topology), 719 topology, 720 ul & SLA_MASK_METRIC); 721 lp += 4; 722 } 723 break; 724 725 case LS_TYPE_SUM_ABR: 726 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric); 727 lp = (const uint8_t *)lsap->lsa_un.un_sla.sla_tosmetric; 728 while (lp < ls_end) { 729 uint32_t ul; 730 731 ul = GET_BE_U_4(lp); 732 topology = (ul & SLA_MASK_TOS) >> SLA_SHIFT_TOS; 733 ND_PRINT("\n\t\ttopology %s (%u) metric %u", 734 tok2str(ospf_topology_values, "Unknown", topology), 735 topology, 736 ul & SLA_MASK_METRIC); 737 lp += 4; 738 } 739 break; 740 741 case LS_TYPE_ASE: 742 case LS_TYPE_NSSA: /* fall through - those LSAs share the same format */ 743 ND_TCHECK_4(lsap->lsa_un.un_nla.nla_mask); 744 ND_PRINT("\n\t Mask %s", 745 GET_IPADDR_STRING(lsap->lsa_un.un_asla.asla_mask)); 746 747 ND_TCHECK_SIZE(lsap->lsa_un.un_sla.sla_tosmetric); 748 almp = lsap->lsa_un.un_asla.asla_metric; 749 while ((const u_char *)almp < ls_end) { 750 uint32_t ul; 751 752 ul = GET_BE_U_4(almp->asla_tosmetric); 753 topology = ((ul & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS); 754 ND_PRINT("\n\t\ttopology %s (%u), type %u, metric", 755 tok2str(ospf_topology_values, "Unknown", topology), 756 topology, 757 (ul & ASLA_FLAG_EXTERNAL) ? 2 : 1); 758 if ((ul & ASLA_MASK_METRIC) == 0xffffff) 759 ND_PRINT(" infinite"); 760 else 761 ND_PRINT(" %u", (ul & ASLA_MASK_METRIC)); 762 763 if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_forward) != 0) { 764 ND_PRINT(", forward %s", GET_IPADDR_STRING(almp->asla_forward)); 765 } 766 if (GET_IPV4_TO_NETWORK_ORDER(almp->asla_tag) != 0) { 767 ND_PRINT(", tag %s", GET_IPADDR_STRING(almp->asla_tag)); 768 } 769 ++almp; 770 } 771 break; 772 773 case LS_TYPE_GROUP: 774 /* Multicast extensions as of 23 July 1991 */ 775 mcp = lsap->lsa_un.un_mcla; 776 while ((const u_char *)mcp < ls_end) { 777 switch (GET_BE_U_4(mcp->mcla_vtype)) { 778 779 case MCLA_VERTEX_ROUTER: 780 ND_PRINT("\n\t Router Router-ID %s", 781 GET_IPADDR_STRING(mcp->mcla_vid)); 782 break; 783 784 case MCLA_VERTEX_NETWORK: 785 ND_PRINT("\n\t Network Designated Router %s", 786 GET_IPADDR_STRING(mcp->mcla_vid)); 787 break; 788 789 default: 790 ND_PRINT("\n\t unknown VertexType (%u)", 791 GET_BE_U_4(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 (GET_U_1(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); 805 806 u_int ls_length_remaining = ls_length; 807 while (ls_length_remaining != 0) { 808 ND_TCHECK_4(tptr); 809 if (ls_length_remaining < 4) { 810 ND_PRINT("\n\t Remaining LS length %u < 4", ls_length_remaining); 811 return(ls_end); 812 } 813 tlv_type = GET_BE_U_2(tptr); 814 tlv_length = GET_BE_U_2(tptr + 2); 815 tptr+=4; 816 ls_length_remaining-=4; 817 818 ND_PRINT("\n\t %s TLV (%u), length: %u, value: ", 819 tok2str(lsa_opaque_ri_tlv_values,"unknown",tlv_type), 820 tlv_type, 821 tlv_length); 822 823 if (tlv_length > ls_length_remaining) { 824 ND_PRINT("\n\t Bogus length %u > remaining LS length %u", tlv_length, 825 ls_length_remaining); 826 return(ls_end); 827 } 828 ND_TCHECK_LEN(tptr, tlv_length); 829 switch(tlv_type) { 830 831 case LS_OPAQUE_RI_TLV_CAP: 832 if (tlv_length != 4) { 833 ND_PRINT("\n\t Bogus length %u != 4", tlv_length); 834 return(ls_end); 835 } 836 ND_PRINT("Capabilities: %s", 837 bittok2str(lsa_opaque_ri_tlv_cap_values, "Unknown", GET_BE_U_4(tptr))); 838 break; 839 default: 840 if (ndo->ndo_vflag <= 1) { 841 if (!print_unknown_data(ndo, tptr, "\n\t ", tlv_length)) 842 return(ls_end); 843 } 844 break; 845 846 } 847 tptr+=tlv_length; 848 ls_length_remaining-=tlv_length; 849 } 850 break; 851 852 case LS_OPAQUE_TYPE_GRACE: 853 if (ospf_grace_lsa_print(ndo, (const u_char *)(lsap->lsa_un.un_grace_tlv), 854 ls_length) == -1) { 855 return(ls_end); 856 } 857 break; 858 859 case LS_OPAQUE_TYPE_TE: 860 if (ospf_te_lsa_print(ndo, (const u_char *)(lsap->lsa_un.un_te_lsa_tlv), 861 ls_length) == -1) { 862 return(ls_end); 863 } 864 break; 865 866 default: 867 if (ndo->ndo_vflag <= 1) { 868 if (!print_unknown_data(ndo, (const uint8_t *)lsap->lsa_un.un_unknown, 869 "\n\t ", ls_length)) 870 return(ls_end); 871 } 872 break; 873 } 874 } 875 876 /* do we want to see an additionally hexdump ? */ 877 if (ndo->ndo_vflag> 1) 878 if (!print_unknown_data(ndo, (const uint8_t *)lsap->lsa_un.un_unknown, 879 "\n\t ", ls_length)) { 880 return(ls_end); 881 } 882 883 return (ls_end); 884trunc: 885 return (NULL); 886} 887 888static void 889ospf_decode_lls(netdissect_options *ndo, 890 const struct ospfhdr *op, u_int length) 891{ 892 const u_char *dptr; 893 const u_char *dataend; 894 u_int length2; 895 uint16_t lls_type, lls_len; 896 uint32_t lls_flags; 897 898 switch (GET_U_1(op->ospf_type)) { 899 900 case OSPF_TYPE_HELLO: 901 if (!(GET_U_1(op->ospf_hello.hello_options) & OSPF_OPTION_L)) 902 return; 903 break; 904 905 case OSPF_TYPE_DD: 906 if (!(GET_U_1(op->ospf_db.db_options) & OSPF_OPTION_L)) 907 return; 908 break; 909 910 default: 911 return; 912 } 913 914 /* dig deeper if LLS data is available; see RFC4813 */ 915 length2 = GET_BE_U_2(op->ospf_len); 916 dptr = (const u_char *)op + length2; 917 dataend = (const u_char *)op + length; 918 919 if (GET_BE_U_2(op->ospf_authtype) == OSPF_AUTH_MD5) { 920 dptr = dptr + GET_U_1(op->ospf_authdata + 3); 921 length2 += GET_U_1(op->ospf_authdata + 3); 922 } 923 if (length2 >= length) { 924 ND_PRINT("\n\t[LLS truncated]"); 925 return; 926 } 927 ND_PRINT("\n\t LLS: checksum: 0x%04x", (u_int) GET_BE_U_2(dptr)); 928 929 dptr += 2; 930 length2 = GET_BE_U_2(dptr); 931 ND_PRINT(", length: %u", length2); 932 933 dptr += 2; 934 while (dptr < dataend) { 935 lls_type = GET_BE_U_2(dptr); 936 ND_PRINT("\n\t %s (%u)", 937 tok2str(ospf_lls_tlv_values,"Unknown TLV",lls_type), 938 lls_type); 939 dptr += 2; 940 lls_len = GET_BE_U_2(dptr); 941 ND_PRINT(", length: %u", lls_len); 942 dptr += 2; 943 switch (lls_type) { 944 945 case OSPF_LLS_EO: 946 if (lls_len != 4) { 947 ND_PRINT(" [should be 4]"); 948 lls_len = 4; 949 } 950 lls_flags = GET_BE_U_4(dptr); 951 ND_PRINT("\n\t Options: 0x%08x [%s]", lls_flags, 952 bittok2str(ospf_lls_eo_options, "?", lls_flags)); 953 954 break; 955 956 case OSPF_LLS_MD5: 957 if (lls_len != 20) { 958 ND_PRINT(" [should be 20]"); 959 lls_len = 20; 960 } 961 ND_PRINT("\n\t Sequence number: 0x%08x", GET_BE_U_4(dptr)); 962 break; 963 } 964 965 dptr += lls_len; 966 } 967} 968 969static int 970ospf_decode_v2(netdissect_options *ndo, 971 const struct ospfhdr *op, const u_char *dataend) 972{ 973 const nd_ipv4 *ap; 974 const struct lsr *lsrp; 975 const struct lsa_hdr *lshp; 976 const struct lsa *lsap; 977 uint32_t lsa_count,lsa_count_max; 978 979 switch (GET_U_1(op->ospf_type)) { 980 981 case OSPF_TYPE_HELLO: 982 ND_PRINT("\n\tOptions [%s]", 983 bittok2str(ospf_option_values,"none",GET_U_1(op->ospf_hello.hello_options))); 984 985 ND_PRINT("\n\t Hello Timer %us, Dead Timer %us, Mask %s, Priority %u", 986 GET_BE_U_2(op->ospf_hello.hello_helloint), 987 GET_BE_U_4(op->ospf_hello.hello_deadint), 988 GET_IPADDR_STRING(op->ospf_hello.hello_mask), 989 GET_U_1(op->ospf_hello.hello_priority)); 990 991 if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_dr) != 0) 992 ND_PRINT("\n\t Designated Router %s", 993 GET_IPADDR_STRING(op->ospf_hello.hello_dr)); 994 995 if (GET_IPV4_TO_NETWORK_ORDER(op->ospf_hello.hello_bdr) != 0) 996 ND_PRINT(", Backup Designated Router %s", 997 GET_IPADDR_STRING(op->ospf_hello.hello_bdr)); 998 999 ap = op->ospf_hello.hello_neighbor; 1000 if ((const u_char *)ap < dataend) 1001 ND_PRINT("\n\t Neighbor List:"); 1002 while ((const u_char *)ap < dataend) { 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); 1079trunc: 1080 return (1); 1081} 1082 1083void 1084ospf_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; 1176trunc: 1177 nd_trunc_longjmp(ndo); 1178} 1179