1/* 2 * Redistribution and use in source and binary forms, with or without 3 * modification, are permitted provided that: (1) source code 4 * distributions retain the above copyright notice and this paragraph 5 * in its entirety, and (2) distributions including binary code include 6 * the above copyright notice and this paragraph in its entirety in 7 * the documentation or other materials provided with the distribution. 8 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND 9 * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT 10 * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 11 * FOR A PARTICULAR PURPOSE. 12 * 13 * Original code by Hannes Gredler (hannes@juniper.net) 14 * and Steinar Haug (sthaug@nethelp.no) 15 */ 16 17/* \summary: Label Distribution Protocol (LDP) printer */ 18 19#ifdef HAVE_CONFIG_H 20#include "config.h" 21#endif 22 23#include <netdissect-stdinc.h> 24 25#include "netdissect.h" 26#include "extract.h" 27#include "addrtoname.h" 28 29#include "l2vpn.h" 30#include "af.h" 31 32/* 33 * ldp common header 34 * 35 * 0 1 2 3 36 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 37 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 38 * | Version | PDU Length | 39 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 40 * | LDP Identifier | 41 * + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 42 * | | 43 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 44 * 45 */ 46 47struct ldp_common_header { 48 uint8_t version[2]; 49 uint8_t pdu_length[2]; 50 uint8_t lsr_id[4]; 51 uint8_t label_space[2]; 52}; 53 54#define LDP_VERSION 1 55 56/* 57 * ldp message header 58 * 59 * 0 1 2 3 60 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 61 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 62 * |U| Message Type | Message Length | 63 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 64 * | Message ID | 65 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 66 * | | 67 * + + 68 * | Mandatory Parameters | 69 * + + 70 * | | 71 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 72 * | | 73 * + + 74 * | Optional Parameters | 75 * + + 76 * | | 77 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 78 */ 79 80struct ldp_msg_header { 81 uint8_t type[2]; 82 uint8_t length[2]; 83 uint8_t id[4]; 84}; 85 86#define LDP_MASK_MSG_TYPE(x) ((x)&0x7fff) 87#define LDP_MASK_U_BIT(x) ((x)&0x8000) 88 89#define LDP_MSG_NOTIF 0x0001 90#define LDP_MSG_HELLO 0x0100 91#define LDP_MSG_INIT 0x0200 92#define LDP_MSG_KEEPALIVE 0x0201 93#define LDP_MSG_ADDRESS 0x0300 94#define LDP_MSG_ADDRESS_WITHDRAW 0x0301 95#define LDP_MSG_LABEL_MAPPING 0x0400 96#define LDP_MSG_LABEL_REQUEST 0x0401 97#define LDP_MSG_LABEL_WITHDRAW 0x0402 98#define LDP_MSG_LABEL_RELEASE 0x0403 99#define LDP_MSG_LABEL_ABORT_REQUEST 0x0404 100 101#define LDP_VENDOR_PRIVATE_MIN 0x3e00 102#define LDP_VENDOR_PRIVATE_MAX 0x3eff 103#define LDP_EXPERIMENTAL_MIN 0x3f00 104#define LDP_EXPERIMENTAL_MAX 0x3fff 105 106static const struct tok ldp_msg_values[] = { 107 { LDP_MSG_NOTIF, "Notification" }, 108 { LDP_MSG_HELLO, "Hello" }, 109 { LDP_MSG_INIT, "Initialization" }, 110 { LDP_MSG_KEEPALIVE, "Keepalive" }, 111 { LDP_MSG_ADDRESS, "Address" }, 112 { LDP_MSG_ADDRESS_WITHDRAW, "Address Withdraw" }, 113 { LDP_MSG_LABEL_MAPPING, "Label Mapping" }, 114 { LDP_MSG_LABEL_REQUEST, "Label Request" }, 115 { LDP_MSG_LABEL_WITHDRAW, "Label Withdraw" }, 116 { LDP_MSG_LABEL_RELEASE, "Label Release" }, 117 { LDP_MSG_LABEL_ABORT_REQUEST, "Label Abort Request" }, 118 { 0, NULL} 119}; 120 121#define LDP_MASK_TLV_TYPE(x) ((x)&0x3fff) 122#define LDP_MASK_F_BIT(x) ((x)&0x4000) 123 124#define LDP_TLV_FEC 0x0100 125#define LDP_TLV_ADDRESS_LIST 0x0101 126#define LDP_TLV_ADDRESS_LIST_AFNUM_LEN 2 127#define LDP_TLV_HOP_COUNT 0x0103 128#define LDP_TLV_PATH_VECTOR 0x0104 129#define LDP_TLV_GENERIC_LABEL 0x0200 130#define LDP_TLV_ATM_LABEL 0x0201 131#define LDP_TLV_FR_LABEL 0x0202 132#define LDP_TLV_STATUS 0x0300 133#define LDP_TLV_EXTD_STATUS 0x0301 134#define LDP_TLV_RETURNED_PDU 0x0302 135#define LDP_TLV_RETURNED_MSG 0x0303 136#define LDP_TLV_COMMON_HELLO 0x0400 137#define LDP_TLV_IPV4_TRANSPORT_ADDR 0x0401 138#define LDP_TLV_CONFIG_SEQ_NUMBER 0x0402 139#define LDP_TLV_IPV6_TRANSPORT_ADDR 0x0403 140#define LDP_TLV_COMMON_SESSION 0x0500 141#define LDP_TLV_ATM_SESSION_PARM 0x0501 142#define LDP_TLV_FR_SESSION_PARM 0x0502 143#define LDP_TLV_FT_SESSION 0x0503 144#define LDP_TLV_LABEL_REQUEST_MSG_ID 0x0600 145#define LDP_TLV_MTU 0x0601 /* rfc 3988 */ 146 147static const struct tok ldp_tlv_values[] = { 148 { LDP_TLV_FEC, "FEC" }, 149 { LDP_TLV_ADDRESS_LIST, "Address List" }, 150 { LDP_TLV_HOP_COUNT, "Hop Count" }, 151 { LDP_TLV_PATH_VECTOR, "Path Vector" }, 152 { LDP_TLV_GENERIC_LABEL, "Generic Label" }, 153 { LDP_TLV_ATM_LABEL, "ATM Label" }, 154 { LDP_TLV_FR_LABEL, "Frame-Relay Label" }, 155 { LDP_TLV_STATUS, "Status" }, 156 { LDP_TLV_EXTD_STATUS, "Extended Status" }, 157 { LDP_TLV_RETURNED_PDU, "Returned PDU" }, 158 { LDP_TLV_RETURNED_MSG, "Returned Message" }, 159 { LDP_TLV_COMMON_HELLO, "Common Hello Parameters" }, 160 { LDP_TLV_IPV4_TRANSPORT_ADDR, "IPv4 Transport Address" }, 161 { LDP_TLV_CONFIG_SEQ_NUMBER, "Configuration Sequence Number" }, 162 { LDP_TLV_IPV6_TRANSPORT_ADDR, "IPv6 Transport Address" }, 163 { LDP_TLV_COMMON_SESSION, "Common Session Parameters" }, 164 { LDP_TLV_ATM_SESSION_PARM, "ATM Session Parameters" }, 165 { LDP_TLV_FR_SESSION_PARM, "Frame-Relay Session Parameters" }, 166 { LDP_TLV_FT_SESSION, "Fault-Tolerant Session Parameters" }, 167 { LDP_TLV_LABEL_REQUEST_MSG_ID, "Label Request Message ID" }, 168 { LDP_TLV_MTU, "MTU" }, 169 { 0, NULL} 170}; 171 172#define LDP_FEC_WILDCARD 0x01 173#define LDP_FEC_PREFIX 0x02 174#define LDP_FEC_HOSTADDRESS 0x03 175/* From RFC 4906; should probably be updated to RFC 4447 (e.g., VC -> PW) */ 176#define LDP_FEC_MARTINI_VC 0x80 177 178static const struct tok ldp_fec_values[] = { 179 { LDP_FEC_WILDCARD, "Wildcard" }, 180 { LDP_FEC_PREFIX, "Prefix" }, 181 { LDP_FEC_HOSTADDRESS, "Host address" }, 182 { LDP_FEC_MARTINI_VC, "Martini VC" }, 183 { 0, NULL} 184}; 185 186#define LDP_FEC_MARTINI_IFPARM_MTU 0x01 187#define LDP_FEC_MARTINI_IFPARM_DESC 0x03 188#define LDP_FEC_MARTINI_IFPARM_VCCV 0x0c 189 190static const struct tok ldp_fec_martini_ifparm_values[] = { 191 { LDP_FEC_MARTINI_IFPARM_MTU, "MTU" }, 192 { LDP_FEC_MARTINI_IFPARM_DESC, "Description" }, 193 { LDP_FEC_MARTINI_IFPARM_VCCV, "VCCV" }, 194 { 0, NULL} 195}; 196 197/* draft-ietf-pwe3-vccv-04.txt */ 198static const struct tok ldp_fec_martini_ifparm_vccv_cc_values[] = { 199 { 0x01, "PWE3 control word" }, 200 { 0x02, "MPLS Router Alert Label" }, 201 { 0x04, "MPLS inner label TTL = 1" }, 202 { 0, NULL} 203}; 204 205/* draft-ietf-pwe3-vccv-04.txt */ 206static const struct tok ldp_fec_martini_ifparm_vccv_cv_values[] = { 207 { 0x01, "ICMP Ping" }, 208 { 0x02, "LSP Ping" }, 209 { 0x04, "BFD" }, 210 { 0, NULL} 211}; 212 213static int ldp_pdu_print(netdissect_options *, register const u_char *); 214 215/* 216 * ldp tlv header 217 * 218 * 0 1 2 3 219 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 220 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 221 * |U|F| Type | Length | 222 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 223 * | | 224 * | Value | 225 * ~ ~ 226 * | | 227 * | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 228 * | | 229 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 230 */ 231 232#define TLV_TCHECK(minlen) \ 233 ND_TCHECK2(*tptr, minlen); if (tlv_tlen < minlen) goto badtlv; 234 235static int 236ldp_tlv_print(netdissect_options *ndo, 237 register const u_char *tptr, 238 u_short msg_tlen) 239{ 240 struct ldp_tlv_header { 241 uint8_t type[2]; 242 uint8_t length[2]; 243 }; 244 245 const struct ldp_tlv_header *ldp_tlv_header; 246 u_short tlv_type,tlv_len,tlv_tlen,af,ft_flags; 247 u_char fec_type; 248 u_int ui,vc_info_len, vc_info_tlv_type, vc_info_tlv_len,idx; 249 char buf[100]; 250 int i; 251 252 ldp_tlv_header = (const struct ldp_tlv_header *)tptr; 253 ND_TCHECK(*ldp_tlv_header); 254 tlv_len=EXTRACT_16BITS(ldp_tlv_header->length); 255 if (tlv_len + 4 > msg_tlen) { 256 ND_PRINT((ndo, "\n\t\t TLV contents go past end of message")); 257 return 0; 258 } 259 tlv_tlen=tlv_len; 260 tlv_type=LDP_MASK_TLV_TYPE(EXTRACT_16BITS(ldp_tlv_header->type)); 261 262 /* FIXME vendor private / experimental check */ 263 ND_PRINT((ndo, "\n\t %s TLV (0x%04x), length: %u, Flags: [%s and %s forward if unknown]", 264 tok2str(ldp_tlv_values, 265 "Unknown", 266 tlv_type), 267 tlv_type, 268 tlv_len, 269 LDP_MASK_U_BIT(EXTRACT_16BITS(&ldp_tlv_header->type)) ? "continue processing" : "ignore", 270 LDP_MASK_F_BIT(EXTRACT_16BITS(&ldp_tlv_header->type)) ? "do" : "don't")); 271 272 tptr+=sizeof(struct ldp_tlv_header); 273 274 switch(tlv_type) { 275 276 case LDP_TLV_COMMON_HELLO: 277 TLV_TCHECK(4); 278 ND_PRINT((ndo, "\n\t Hold Time: %us, Flags: [%s Hello%s]", 279 EXTRACT_16BITS(tptr), 280 (EXTRACT_16BITS(tptr+2)&0x8000) ? "Targeted" : "Link", 281 (EXTRACT_16BITS(tptr+2)&0x4000) ? ", Request for targeted Hellos" : "")); 282 break; 283 284 case LDP_TLV_IPV4_TRANSPORT_ADDR: 285 TLV_TCHECK(4); 286 ND_PRINT((ndo, "\n\t IPv4 Transport Address: %s", ipaddr_string(ndo, tptr))); 287 break; 288 case LDP_TLV_IPV6_TRANSPORT_ADDR: 289 TLV_TCHECK(16); 290 ND_PRINT((ndo, "\n\t IPv6 Transport Address: %s", ip6addr_string(ndo, tptr))); 291 break; 292 case LDP_TLV_CONFIG_SEQ_NUMBER: 293 TLV_TCHECK(4); 294 ND_PRINT((ndo, "\n\t Sequence Number: %u", EXTRACT_32BITS(tptr))); 295 break; 296 297 case LDP_TLV_ADDRESS_LIST: 298 TLV_TCHECK(LDP_TLV_ADDRESS_LIST_AFNUM_LEN); 299 af = EXTRACT_16BITS(tptr); 300 tptr+=LDP_TLV_ADDRESS_LIST_AFNUM_LEN; 301 tlv_tlen -= LDP_TLV_ADDRESS_LIST_AFNUM_LEN; 302 ND_PRINT((ndo, "\n\t Address Family: %s, addresses", 303 tok2str(af_values, "Unknown (%u)", af))); 304 switch (af) { 305 case AFNUM_INET: 306 while(tlv_tlen >= sizeof(struct in_addr)) { 307 ND_TCHECK2(*tptr, sizeof(struct in_addr)); 308 ND_PRINT((ndo, " %s", ipaddr_string(ndo, tptr))); 309 tlv_tlen-=sizeof(struct in_addr); 310 tptr+=sizeof(struct in_addr); 311 } 312 break; 313 case AFNUM_INET6: 314 while(tlv_tlen >= sizeof(struct in6_addr)) { 315 ND_TCHECK2(*tptr, sizeof(struct in6_addr)); 316 ND_PRINT((ndo, " %s", ip6addr_string(ndo, tptr))); 317 tlv_tlen-=sizeof(struct in6_addr); 318 tptr+=sizeof(struct in6_addr); 319 } 320 break; 321 default: 322 /* unknown AF */ 323 break; 324 } 325 break; 326 327 case LDP_TLV_COMMON_SESSION: 328 TLV_TCHECK(8); 329 ND_PRINT((ndo, "\n\t Version: %u, Keepalive: %us, Flags: [Downstream %s, Loop Detection %s]", 330 EXTRACT_16BITS(tptr), EXTRACT_16BITS(tptr+2), 331 (EXTRACT_16BITS(tptr+6)&0x8000) ? "On Demand" : "Unsolicited", 332 (EXTRACT_16BITS(tptr+6)&0x4000) ? "Enabled" : "Disabled" 333 )); 334 break; 335 336 case LDP_TLV_FEC: 337 TLV_TCHECK(1); 338 fec_type = *tptr; 339 ND_PRINT((ndo, "\n\t %s FEC (0x%02x)", 340 tok2str(ldp_fec_values, "Unknown", fec_type), 341 fec_type)); 342 343 tptr+=1; 344 tlv_tlen-=1; 345 switch(fec_type) { 346 347 case LDP_FEC_WILDCARD: 348 break; 349 case LDP_FEC_PREFIX: 350 TLV_TCHECK(2); 351 af = EXTRACT_16BITS(tptr); 352 tptr+=LDP_TLV_ADDRESS_LIST_AFNUM_LEN; 353 tlv_tlen-=LDP_TLV_ADDRESS_LIST_AFNUM_LEN; 354 if (af == AFNUM_INET) { 355 i=decode_prefix4(ndo, tptr, tlv_tlen, buf, sizeof(buf)); 356 if (i == -2) 357 goto trunc; 358 if (i == -3) 359 ND_PRINT((ndo, ": IPv4 prefix (goes past end of TLV)")); 360 else if (i == -1) 361 ND_PRINT((ndo, ": IPv4 prefix (invalid length)")); 362 else 363 ND_PRINT((ndo, ": IPv4 prefix %s", buf)); 364 } 365 else if (af == AFNUM_INET6) { 366 i=decode_prefix6(ndo, tptr, tlv_tlen, buf, sizeof(buf)); 367 if (i == -2) 368 goto trunc; 369 if (i == -3) 370 ND_PRINT((ndo, ": IPv4 prefix (goes past end of TLV)")); 371 else if (i == -1) 372 ND_PRINT((ndo, ": IPv6 prefix (invalid length)")); 373 else 374 ND_PRINT((ndo, ": IPv6 prefix %s", buf)); 375 } 376 else 377 ND_PRINT((ndo, ": Address family %u prefix", af)); 378 break; 379 case LDP_FEC_HOSTADDRESS: 380 break; 381 case LDP_FEC_MARTINI_VC: 382 /* 383 * We assume the type was supposed to be one of the MPLS 384 * Pseudowire Types. 385 */ 386 TLV_TCHECK(7); 387 vc_info_len = *(tptr+2); 388 389 /* 390 * According to RFC 4908, the VC info Length field can be zero, 391 * in which case not only are there no interface parameters, 392 * there's no VC ID. 393 */ 394 if (vc_info_len == 0) { 395 ND_PRINT((ndo, ": %s, %scontrol word, group-ID %u, VC-info-length: %u", 396 tok2str(mpls_pw_types_values, "Unknown", EXTRACT_16BITS(tptr)&0x7fff), 397 EXTRACT_16BITS(tptr)&0x8000 ? "" : "no ", 398 EXTRACT_32BITS(tptr+3), 399 vc_info_len)); 400 break; 401 } 402 403 /* Make sure we have the VC ID as well */ 404 TLV_TCHECK(11); 405 ND_PRINT((ndo, ": %s, %scontrol word, group-ID %u, VC-ID %u, VC-info-length: %u", 406 tok2str(mpls_pw_types_values, "Unknown", EXTRACT_16BITS(tptr)&0x7fff), 407 EXTRACT_16BITS(tptr)&0x8000 ? "" : "no ", 408 EXTRACT_32BITS(tptr+3), 409 EXTRACT_32BITS(tptr+7), 410 vc_info_len)); 411 if (vc_info_len < 4) { 412 /* minimum 4, for the VC ID */ 413 ND_PRINT((ndo, " (invalid, < 4")); 414 return(tlv_len+4); /* Type & Length fields not included */ 415 } 416 vc_info_len -= 4; /* subtract out the VC ID, giving the length of the interface parameters */ 417 418 /* Skip past the fixed information and the VC ID */ 419 tptr+=11; 420 tlv_tlen-=11; 421 TLV_TCHECK(vc_info_len); 422 423 while (vc_info_len > 2) { 424 vc_info_tlv_type = *tptr; 425 vc_info_tlv_len = *(tptr+1); 426 if (vc_info_tlv_len < 2) 427 break; 428 if (vc_info_len < vc_info_tlv_len) 429 break; 430 431 ND_PRINT((ndo, "\n\t\tInterface Parameter: %s (0x%02x), len %u", 432 tok2str(ldp_fec_martini_ifparm_values,"Unknown",vc_info_tlv_type), 433 vc_info_tlv_type, 434 vc_info_tlv_len)); 435 436 switch(vc_info_tlv_type) { 437 case LDP_FEC_MARTINI_IFPARM_MTU: 438 ND_PRINT((ndo, ": %u", EXTRACT_16BITS(tptr+2))); 439 break; 440 441 case LDP_FEC_MARTINI_IFPARM_DESC: 442 ND_PRINT((ndo, ": ")); 443 for (idx = 2; idx < vc_info_tlv_len; idx++) 444 safeputchar(ndo, *(tptr + idx)); 445 break; 446 447 case LDP_FEC_MARTINI_IFPARM_VCCV: 448 ND_PRINT((ndo, "\n\t\t Control Channels (0x%02x) = [%s]", 449 *(tptr+2), 450 bittok2str(ldp_fec_martini_ifparm_vccv_cc_values, "none", *(tptr+2)))); 451 ND_PRINT((ndo, "\n\t\t CV Types (0x%02x) = [%s]", 452 *(tptr+3), 453 bittok2str(ldp_fec_martini_ifparm_vccv_cv_values, "none", *(tptr+3)))); 454 break; 455 456 default: 457 print_unknown_data(ndo, tptr+2, "\n\t\t ", vc_info_tlv_len-2); 458 break; 459 } 460 461 vc_info_len -= vc_info_tlv_len; 462 tptr += vc_info_tlv_len; 463 } 464 break; 465 } 466 467 break; 468 469 case LDP_TLV_GENERIC_LABEL: 470 TLV_TCHECK(4); 471 ND_PRINT((ndo, "\n\t Label: %u", EXTRACT_32BITS(tptr) & 0xfffff)); 472 break; 473 474 case LDP_TLV_STATUS: 475 TLV_TCHECK(8); 476 ui = EXTRACT_32BITS(tptr); 477 tptr+=4; 478 ND_PRINT((ndo, "\n\t Status: 0x%02x, Flags: [%s and %s forward]", 479 ui&0x3fffffff, 480 ui&0x80000000 ? "Fatal error" : "Advisory Notification", 481 ui&0x40000000 ? "do" : "don't")); 482 ui = EXTRACT_32BITS(tptr); 483 tptr+=4; 484 if (ui) 485 ND_PRINT((ndo, ", causing Message ID: 0x%08x", ui)); 486 break; 487 488 case LDP_TLV_FT_SESSION: 489 TLV_TCHECK(8); 490 ft_flags = EXTRACT_16BITS(tptr); 491 ND_PRINT((ndo, "\n\t Flags: [%sReconnect, %sSave State, %sAll-Label Protection, %s Checkpoint, %sRe-Learn State]", 492 ft_flags&0x8000 ? "" : "No ", 493 ft_flags&0x8 ? "" : "Don't ", 494 ft_flags&0x4 ? "" : "No ", 495 ft_flags&0x2 ? "Sequence Numbered Label" : "All Labels", 496 ft_flags&0x1 ? "" : "Don't ")); 497 tptr+=4; 498 ui = EXTRACT_32BITS(tptr); 499 if (ui) 500 ND_PRINT((ndo, ", Reconnect Timeout: %ums", ui)); 501 tptr+=4; 502 ui = EXTRACT_32BITS(tptr); 503 if (ui) 504 ND_PRINT((ndo, ", Recovery Time: %ums", ui)); 505 break; 506 507 case LDP_TLV_MTU: 508 TLV_TCHECK(2); 509 ND_PRINT((ndo, "\n\t MTU: %u", EXTRACT_16BITS(tptr))); 510 break; 511 512 513 /* 514 * FIXME those are the defined TLVs that lack a decoder 515 * you are welcome to contribute code ;-) 516 */ 517 518 case LDP_TLV_HOP_COUNT: 519 case LDP_TLV_PATH_VECTOR: 520 case LDP_TLV_ATM_LABEL: 521 case LDP_TLV_FR_LABEL: 522 case LDP_TLV_EXTD_STATUS: 523 case LDP_TLV_RETURNED_PDU: 524 case LDP_TLV_RETURNED_MSG: 525 case LDP_TLV_ATM_SESSION_PARM: 526 case LDP_TLV_FR_SESSION_PARM: 527 case LDP_TLV_LABEL_REQUEST_MSG_ID: 528 529 default: 530 if (ndo->ndo_vflag <= 1) 531 print_unknown_data(ndo, tptr, "\n\t ", tlv_tlen); 532 break; 533 } 534 return(tlv_len+4); /* Type & Length fields not included */ 535 536trunc: 537 ND_PRINT((ndo, "\n\t\t packet exceeded snapshot")); 538 return 0; 539 540badtlv: 541 ND_PRINT((ndo, "\n\t\t TLV contents go past end of TLV")); 542 return(tlv_len+4); /* Type & Length fields not included */ 543} 544 545void 546ldp_print(netdissect_options *ndo, 547 register const u_char *pptr, register u_int len) 548{ 549 int processed; 550 while (len > (sizeof(struct ldp_common_header) + sizeof(struct ldp_msg_header))) { 551 processed = ldp_pdu_print(ndo, pptr); 552 if (processed == 0) 553 return; 554 len -= processed; 555 pptr += processed; 556 } 557} 558 559static int 560ldp_pdu_print(netdissect_options *ndo, 561 register const u_char *pptr) 562{ 563 const struct ldp_common_header *ldp_com_header; 564 const struct ldp_msg_header *ldp_msg_header; 565 const u_char *tptr,*msg_tptr; 566 u_short tlen; 567 u_short pdu_len,msg_len,msg_type,msg_tlen; 568 int hexdump,processed; 569 570 ldp_com_header = (const struct ldp_common_header *)pptr; 571 ND_TCHECK(*ldp_com_header); 572 573 /* 574 * Sanity checking of the header. 575 */ 576 if (EXTRACT_16BITS(&ldp_com_header->version) != LDP_VERSION) { 577 ND_PRINT((ndo, "%sLDP version %u packet not supported", 578 (ndo->ndo_vflag < 1) ? "" : "\n\t", 579 EXTRACT_16BITS(&ldp_com_header->version))); 580 return 0; 581 } 582 583 pdu_len = EXTRACT_16BITS(&ldp_com_header->pdu_length); 584 if (pdu_len < sizeof(const struct ldp_common_header)-4) { 585 /* length too short */ 586 ND_PRINT((ndo, "%sLDP, pdu-length: %u (too short, < %u)", 587 (ndo->ndo_vflag < 1) ? "" : "\n\t", 588 pdu_len, 589 (u_int)(sizeof(const struct ldp_common_header)-4))); 590 return 0; 591 } 592 593 /* print the LSR-ID, label-space & length */ 594 ND_PRINT((ndo, "%sLDP, Label-Space-ID: %s:%u, pdu-length: %u", 595 (ndo->ndo_vflag < 1) ? "" : "\n\t", 596 ipaddr_string(ndo, &ldp_com_header->lsr_id), 597 EXTRACT_16BITS(&ldp_com_header->label_space), 598 pdu_len)); 599 600 /* bail out if non-verbose */ 601 if (ndo->ndo_vflag < 1) 602 return 0; 603 604 /* ok they seem to want to know everything - lets fully decode it */ 605 tptr = pptr + sizeof(const struct ldp_common_header); 606 tlen = pdu_len - (sizeof(const struct ldp_common_header)-4); /* Type & Length fields not included */ 607 608 while(tlen>0) { 609 /* did we capture enough for fully decoding the msg header ? */ 610 ND_TCHECK2(*tptr, sizeof(struct ldp_msg_header)); 611 612 ldp_msg_header = (const struct ldp_msg_header *)tptr; 613 msg_len=EXTRACT_16BITS(ldp_msg_header->length); 614 msg_type=LDP_MASK_MSG_TYPE(EXTRACT_16BITS(ldp_msg_header->type)); 615 616 if (msg_len < sizeof(struct ldp_msg_header)-4) { 617 /* length too short */ 618 /* FIXME vendor private / experimental check */ 619 ND_PRINT((ndo, "\n\t %s Message (0x%04x), length: %u (too short, < %u)", 620 tok2str(ldp_msg_values, 621 "Unknown", 622 msg_type), 623 msg_type, 624 msg_len, 625 (u_int)(sizeof(struct ldp_msg_header)-4))); 626 return 0; 627 } 628 629 /* FIXME vendor private / experimental check */ 630 ND_PRINT((ndo, "\n\t %s Message (0x%04x), length: %u, Message ID: 0x%08x, Flags: [%s if unknown]", 631 tok2str(ldp_msg_values, 632 "Unknown", 633 msg_type), 634 msg_type, 635 msg_len, 636 EXTRACT_32BITS(&ldp_msg_header->id), 637 LDP_MASK_U_BIT(EXTRACT_16BITS(&ldp_msg_header->type)) ? "continue processing" : "ignore")); 638 639 msg_tptr=tptr+sizeof(struct ldp_msg_header); 640 msg_tlen=msg_len-(sizeof(struct ldp_msg_header)-4); /* Type & Length fields not included */ 641 642 /* did we capture enough for fully decoding the message ? */ 643 ND_TCHECK2(*tptr, msg_len); 644 hexdump=FALSE; 645 646 switch(msg_type) { 647 648 case LDP_MSG_NOTIF: 649 case LDP_MSG_HELLO: 650 case LDP_MSG_INIT: 651 case LDP_MSG_KEEPALIVE: 652 case LDP_MSG_ADDRESS: 653 case LDP_MSG_LABEL_MAPPING: 654 case LDP_MSG_ADDRESS_WITHDRAW: 655 case LDP_MSG_LABEL_WITHDRAW: 656 while(msg_tlen >= 4) { 657 processed = ldp_tlv_print(ndo, msg_tptr, msg_tlen); 658 if (processed == 0) 659 break; 660 msg_tlen-=processed; 661 msg_tptr+=processed; 662 } 663 break; 664 665 /* 666 * FIXME those are the defined messages that lack a decoder 667 * you are welcome to contribute code ;-) 668 */ 669 670 case LDP_MSG_LABEL_REQUEST: 671 case LDP_MSG_LABEL_RELEASE: 672 case LDP_MSG_LABEL_ABORT_REQUEST: 673 674 default: 675 if (ndo->ndo_vflag <= 1) 676 print_unknown_data(ndo, msg_tptr, "\n\t ", msg_tlen); 677 break; 678 } 679 /* do we want to see an additionally hexdump ? */ 680 if (ndo->ndo_vflag > 1 || hexdump==TRUE) 681 print_unknown_data(ndo, tptr+sizeof(struct ldp_msg_header), "\n\t ", 682 msg_len); 683 684 tptr += msg_len+4; 685 tlen -= msg_len+4; 686 } 687 return pdu_len+4; 688trunc: 689 ND_PRINT((ndo, "\n\t\t packet exceeded snapshot")); 690 return 0; 691} 692 693/* 694 * Local Variables: 695 * c-style: whitesmith 696 * c-basic-offset: 8 697 * End: 698 */ 699