The Tcpdump Group git mirrors - tcpdump/blob - print-ldp.c

   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@gredler.at)
  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 /*
  34  * ldp common header
  35  *
  36  *  0                   1                   2                   3
  37  *  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
  38  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  39  * |  Version                      |         PDU Length            |
  40  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  41  * |                         LDP Identifier                        |
  42  * +                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  43  * |                               |
  44  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  45  *
  46  */
  47
  48 struct ldp_common_header {
  49     nd_uint16_t version;
  50     nd_uint16_t pdu_length;
  51     nd_ipv4     lsr_id;
  52     nd_uint16_t label_space;
  53 };
  54
  55 #define LDP_VERSION 1
  56
  57 /*
  58  * ldp message header
  59  *
  60  *  0                   1                   2                   3
  61  *  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
  62  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  63  * |U|   Message Type              |      Message Length           |
  64  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  65  * |                     Message ID                                |
  66  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  67  * |                                                               |
  68  * +                                                               +
  69  * |                     Mandatory Parameters                      |
  70  * +                                                               +
  71  * |                                                               |
  72  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  73  * |                                                               |
  74  * +                                                               +
  75  * |                     Optional Parameters                       |
  76  * +                                                               +
  77  * |                                                               |
  78  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  79  */
  80
  81 struct ldp_msg_header {
  82     nd_uint16_t type;
  83     nd_uint16_t length;
  84     nd_uint32_t id;
  85 };
  86
  87 #define LDP_MASK_MSG_TYPE(x)  ((x)&0x7fff)
  88 #define LDP_MASK_U_BIT(x)     ((x)&0x8000)
  89
  90 #define LDP_MSG_NOTIF                0x0001
  91 #define LDP_MSG_HELLO                0x0100
  92 #define LDP_MSG_INIT                 0x0200
  93 #define LDP_MSG_KEEPALIVE            0x0201
  94 #define LDP_MSG_ADDRESS              0x0300
  95 #define LDP_MSG_ADDRESS_WITHDRAW     0x0301
  96 #define LDP_MSG_LABEL_MAPPING        0x0400
  97 #define LDP_MSG_LABEL_REQUEST        0x0401
  98 #define LDP_MSG_LABEL_WITHDRAW       0x0402
  99 #define LDP_MSG_LABEL_RELEASE        0x0403
 100 #define LDP_MSG_LABEL_ABORT_REQUEST  0x0404
 101
 102 #define LDP_VENDOR_PRIVATE_MIN       0x3e00
 103 #define LDP_VENDOR_PRIVATE_MAX       0x3eff
 104 #define LDP_EXPERIMENTAL_MIN         0x3f00
 105 #define LDP_EXPERIMENTAL_MAX         0x3fff
 106
 107 static const struct tok ldp_msg_values[] = {
 108     { LDP_MSG_NOTIF,                 "Notification" },
 109     { LDP_MSG_HELLO,                 "Hello" },
 110     { LDP_MSG_INIT,                  "Initialization" },
 111     { LDP_MSG_KEEPALIVE,             "Keepalive" },
 112     { LDP_MSG_ADDRESS,               "Address" },
 113     { LDP_MSG_ADDRESS_WITHDRAW,      "Address Withdraw" },
 114     { LDP_MSG_LABEL_MAPPING,         "Label Mapping" },
 115     { LDP_MSG_LABEL_REQUEST,         "Label Request" },
 116     { LDP_MSG_LABEL_WITHDRAW,        "Label Withdraw" },
 117     { LDP_MSG_LABEL_RELEASE,         "Label Release" },
 118     { LDP_MSG_LABEL_ABORT_REQUEST,   "Label Abort Request" },
 119     { 0, NULL}
 120 };
 121
 122 #define LDP_MASK_TLV_TYPE(x)  ((x)&0x3fff)
 123 #define LDP_MASK_F_BIT(x) ((x)&0x4000)
 124
 125 #define LDP_TLV_FEC                  0x0100
 126 #define LDP_TLV_ADDRESS_LIST         0x0101
 127 #define LDP_TLV_ADDRESS_LIST_AFNUM_LEN 2
 128 #define LDP_TLV_HOP_COUNT            0x0103
 129 #define LDP_TLV_PATH_VECTOR          0x0104
 130 #define LDP_TLV_GENERIC_LABEL        0x0200
 131 #define LDP_TLV_ATM_LABEL            0x0201
 132 #define LDP_TLV_FR_LABEL             0x0202
 133 #define LDP_TLV_STATUS               0x0300
 134 #define LDP_TLV_EXTD_STATUS          0x0301
 135 #define LDP_TLV_RETURNED_PDU         0x0302
 136 #define LDP_TLV_RETURNED_MSG         0x0303
 137 #define LDP_TLV_COMMON_HELLO         0x0400
 138 #define LDP_TLV_IPV4_TRANSPORT_ADDR  0x0401
 139 #define LDP_TLV_CONFIG_SEQ_NUMBER    0x0402
 140 #define LDP_TLV_IPV6_TRANSPORT_ADDR  0x0403
 141 #define LDP_TLV_COMMON_SESSION       0x0500
 142 #define LDP_TLV_ATM_SESSION_PARM     0x0501
 143 #define LDP_TLV_FR_SESSION_PARM      0x0502
 144 #define LDP_TLV_FT_SESSION           0x0503
 145 #define LDP_TLV_TYPED_WC_FEC_CAP     0x050b /* rfc 5918 */
 146 #define LDP_TLV_LABEL_REQUEST_MSG_ID 0x0600
 147 #define LDP_TLV_MTU                  0x0601 /* rfc 3988 */
 148 #define LDP_TLV_DUAL_STACK_CAP       0x0701 /* rfc 7552 */
 149
 150 static const struct tok ldp_tlv_values[] = {
 151     { LDP_TLV_FEC,                   "FEC" },
 152     { LDP_TLV_ADDRESS_LIST,          "Address List" },
 153     { LDP_TLV_HOP_COUNT,             "Hop Count" },
 154     { LDP_TLV_PATH_VECTOR,           "Path Vector" },
 155     { LDP_TLV_GENERIC_LABEL,         "Generic Label" },
 156     { LDP_TLV_ATM_LABEL,             "ATM Label" },
 157     { LDP_TLV_FR_LABEL,              "Frame-Relay Label" },
 158     { LDP_TLV_STATUS,                "Status" },
 159     { LDP_TLV_EXTD_STATUS,           "Extended Status" },
 160     { LDP_TLV_RETURNED_PDU,          "Returned PDU" },
 161     { LDP_TLV_RETURNED_MSG,          "Returned Message" },
 162     { LDP_TLV_COMMON_HELLO,          "Common Hello Parameters" },
 163     { LDP_TLV_IPV4_TRANSPORT_ADDR,   "IPv4 Transport Address" },
 164     { LDP_TLV_CONFIG_SEQ_NUMBER,     "Configuration Sequence Number" },
 165     { LDP_TLV_IPV6_TRANSPORT_ADDR,   "IPv6 Transport Address" },
 166     { LDP_TLV_COMMON_SESSION,        "Common Session Parameters" },
 167     { LDP_TLV_ATM_SESSION_PARM,      "ATM Session Parameters" },
 168     { LDP_TLV_FR_SESSION_PARM,       "Frame-Relay Session Parameters" },
 169     { LDP_TLV_FT_SESSION,            "Fault-Tolerant Session Parameters" },
 170     { LDP_TLV_TYPED_WC_FEC_CAP,      "Typed Wildcard FEC Capability" },
 171     { LDP_TLV_LABEL_REQUEST_MSG_ID,  "Label Request Message ID" },
 172     { LDP_TLV_MTU,                   "MTU" },
 173     { LDP_TLV_DUAL_STACK_CAP,        "Dual-Stack Capability" },
 174     { 0, NULL}
 175 };
 176
 177 static const struct tok ldp_status_code_values[] = {
 178     /* rfc 5036 */
 179     { 0x00000000, "Success" },
 180     { 0x00000001, "Bad LDP Identifier" },
 181     { 0x00000002, "Bad Protocol Version" },
 182     { 0x00000003, "Bad PDU Length" },
 183     { 0x00000004, "Unknown Message Type" },
 184     { 0x00000005, "Bad Message Length" },
 185     { 0x00000006, "Unknown TLV" },
 186     { 0x00000007, "Bad TLV Length" },
 187     { 0x00000008, "Malformted TLV Value" },
 188     { 0x00000009, "Hold Timer Expired" },
 189     { 0x0000000A, "Shutdown" },
 190     { 0x0000000B, "Loop Detected" },
 191     { 0x0000000C, "Unknown FEC" },
 192     { 0x0000000D, "No Route" },
 193     { 0x0000000E, "No Label Resources" },
 194     { 0x0000000F, "Label Resources/Available" },
 195     { 0x00000010, "Session Rejected/No Hello" },
 196     { 0x00000011, "Session Rejected/Parameters Advertisement Mode" },
 197     { 0x00000012, "Session Rejected/Parameters Max PDU Length" },
 198     { 0x00000013, "Session Rejected/Parameters Label Range" },
 199     { 0x00000014, "KeepAlive Timer Expired" },
 200     { 0x00000015, "Label Request Aborted" },
 201     { 0x00000016, "Missing Message Parameters" },
 202     { 0x00000017, "Unsupported Address Family" },
 203     { 0x00000018, "Session Rejected/Bad KeepAlive Time" },
 204     { 0x00000019, "Internal Error" },
 205     { 0, NULL}
 206 };
 207
 208 #define LDP_FEC_WILDCARD        0x01
 209 #define LDP_FEC_PREFIX          0x02
 210 #define LDP_FEC_HOSTADDRESS     0x03
 211 /* From RFC 4906; should probably be updated to RFC 4447 (e.g., VC -> PW) */
 212 #define LDP_FEC_MARTINI_VC      0x80
 213
 214 static const struct tok ldp_fec_values[] = {
 215     { LDP_FEC_WILDCARD,         "Wildcard" },
 216     { LDP_FEC_PREFIX,           "Prefix" },
 217     { LDP_FEC_HOSTADDRESS,      "Host address" },
 218     { LDP_FEC_MARTINI_VC,       "Martini VC" },
 219     { 0, NULL}
 220 };
 221
 222 #define LDP_FEC_MARTINI_IFPARM_MTU  0x01
 223 #define LDP_FEC_MARTINI_IFPARM_DESC 0x03
 224 #define LDP_FEC_MARTINI_IFPARM_VCCV 0x0c
 225
 226 static const struct tok ldp_fec_martini_ifparm_values[] = {
 227     { LDP_FEC_MARTINI_IFPARM_MTU, "MTU" },
 228     { LDP_FEC_MARTINI_IFPARM_DESC, "Description" },
 229     { LDP_FEC_MARTINI_IFPARM_VCCV, "VCCV" },
 230     { 0, NULL}
 231 };
 232
 233 /* draft-ietf-pwe3-vccv-04.txt */
 234 static const struct tok ldp_fec_martini_ifparm_vccv_cc_values[] = {
 235     { 0x01, "PWE3 control word" },
 236     { 0x02, "MPLS Router Alert Label" },
 237     { 0x04, "MPLS inner label TTL = 1" },
 238     { 0, NULL}
 239 };
 240
 241 /* draft-ietf-pwe3-vccv-04.txt */
 242 static const struct tok ldp_fec_martini_ifparm_vccv_cv_values[] = {
 243     { 0x01, "ICMP Ping" },
 244     { 0x02, "LSP Ping" },
 245     { 0x04, "BFD" },
 246     { 0, NULL}
 247 };
 248
 249 /* rfc 7552 */
 250 #define LDP_DUAL_STACK_TRANSPORT_PREF_IPV4  0x40
 251 #define LDP_DUAL_STACK_TRANSPORT_PREF_IPV6  0x60
 252
 253 static const struct tok ldp_dual_stack_transport_pref_values[] = {
 254     { LDP_DUAL_STACK_TRANSPORT_PREF_IPV4, "IPv4" },
 255     { LDP_DUAL_STACK_TRANSPORT_PREF_IPV6, "IPv6" },
 256     { 0, NULL}
 257 };
 258
 259 static u_int ldp_pdu_print(netdissect_options *, const u_char *);
 260
 261 /*
 262  * ldp tlv header
 263  *
 264  *  0                   1                   2                   3
 265  *  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
 266  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 267  * |U|F|        Type               |            Length             |
 268  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 269  * |                                                               |
 270  * |                             Value                             |
 271  * ~                                                               ~
 272  * |                                                               |
 273  * |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 274  * |                               |
 275  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 276  */
 277
 278 #define TLV_TCHECK(minlen) \
 279     if (tlv_tlen < minlen) { \
 280         ND_PRINT(" [tlv length %u < %u]", tlv_tlen, minlen); \
 281         nd_print_invalid(ndo); \
 282         goto invalid; \
 283     }
 284
 285 static u_int
 286 ldp_tlv_print(netdissect_options *ndo,
 287               const u_char *tptr,
 288               u_int msg_tlen)
 289 {
 290     struct ldp_tlv_header {
 291         nd_uint16_t type;
 292         nd_uint16_t length;
 293     };
 294
 295     const struct ldp_tlv_header *ldp_tlv_header;
 296     u_short tlv_type,tlv_len,tlv_tlen,af,ft_flags;
 297     u_char fec_type, transport_pref;
 298     u_int ui,vc_info_len, vc_info_tlv_type, vc_info_tlv_len,idx;
 299     char buf[100];
 300     int i;
 301
 302     ldp_tlv_header = (const struct ldp_tlv_header *)tptr;
 303     ND_TCHECK_SIZE(ldp_tlv_header);
 304     tlv_len=GET_BE_U_2(ldp_tlv_header->length);
 305     if (tlv_len + 4U > msg_tlen) {
 306         ND_PRINT("\n\t\t TLV contents go past end of message");
 307         return 0;
 308     }
 309     tlv_tlen=tlv_len;
 310     tlv_type=LDP_MASK_TLV_TYPE(GET_BE_U_2(ldp_tlv_header->type));
 311
 312     /* FIXME vendor private / experimental check */
 313     ND_PRINT("\n\t    %s TLV (0x%04x), length: %u, Flags: [%s and %s forward if unknown]",
 314            tok2str(ldp_tlv_values,
 315                    "Unknown",
 316                    tlv_type),
 317            tlv_type,
 318            tlv_len,
 319            LDP_MASK_U_BIT(GET_BE_U_2(ldp_tlv_header->type)) ? "continue processing" : "ignore",
 320            LDP_MASK_F_BIT(GET_BE_U_2(ldp_tlv_header->type)) ? "do" : "don't");
 321
 322     tptr+=sizeof(struct ldp_tlv_header);
 323
 324     switch(tlv_type) {
 325
 326     case LDP_TLV_COMMON_HELLO:
 327         TLV_TCHECK(4);
 328         ND_PRINT("\n\t      Hold Time: %us, Flags: [%s Hello%s]",
 329                GET_BE_U_2(tptr),
 330                (GET_BE_U_2(tptr + 2)&0x8000) ? "Targeted" : "Link",
 331                (GET_BE_U_2(tptr + 2)&0x4000) ? ", Request for targeted Hellos" : "");
 332         break;
 333
 334     case LDP_TLV_IPV4_TRANSPORT_ADDR:
 335         TLV_TCHECK(4);
 336         ND_PRINT("\n\t      IPv4 Transport Address: %s", GET_IPADDR_STRING(tptr));
 337         break;
 338     case LDP_TLV_IPV6_TRANSPORT_ADDR:
 339         TLV_TCHECK(16);
 340         ND_PRINT("\n\t      IPv6 Transport Address: %s", GET_IP6ADDR_STRING(tptr));
 341         break;
 342     case LDP_TLV_CONFIG_SEQ_NUMBER:
 343         TLV_TCHECK(4);
 344         ND_PRINT("\n\t      Sequence Number: %u", GET_BE_U_4(tptr));
 345         break;
 346
 347     case LDP_TLV_ADDRESS_LIST:
 348         TLV_TCHECK(LDP_TLV_ADDRESS_LIST_AFNUM_LEN);
 349         af = GET_BE_U_2(tptr);
 350         tptr+=LDP_TLV_ADDRESS_LIST_AFNUM_LEN;
 351         tlv_tlen -= LDP_TLV_ADDRESS_LIST_AFNUM_LEN;
 352         ND_PRINT("\n\t      Address Family: %s, addresses",
 353                tok2str(af_values, "Unknown (%u)", af));
 354         switch (af) {
 355         case AFNUM_IP:
 356             while(tlv_tlen >= sizeof(nd_ipv4)) {
 357                 ND_PRINT(" %s", GET_IPADDR_STRING(tptr));
 358                 tlv_tlen-=sizeof(nd_ipv4);
 359                 tptr+=sizeof(nd_ipv4);
 360             }
 361             break;
 362         case AFNUM_IP6:
 363             while(tlv_tlen >= sizeof(nd_ipv6)) {
 364                 ND_PRINT(" %s", GET_IP6ADDR_STRING(tptr));
 365                 tlv_tlen-=sizeof(nd_ipv6);
 366                 tptr+=sizeof(nd_ipv6);
 367             }
 368             break;
 369         default:
 370             /* unknown AF */
 371             break;
 372         }
 373         break;
 374
 375     case LDP_TLV_HOP_COUNT:
 376         TLV_TCHECK(1);
 377         ND_PRINT("\n\t      Hop Count: %u", GET_U_1(tptr));
 378         break;
 379
 380     case LDP_TLV_PATH_VECTOR:
 381         TLV_TCHECK(4);
 382         ND_PRINT("\n\t      Path Vector: %s", GET_IPADDR_STRING(tptr));
 383         tptr += 4;
 384         tlv_tlen -= 4;
 385         while (tlv_tlen >= 4) {
 386             ND_PRINT(", %s", GET_IPADDR_STRING(tptr));
 387             tptr += 4;
 388             tlv_tlen -= 4;
 389         }
 390         break;
 391
 392     case LDP_TLV_COMMON_SESSION:
 393         TLV_TCHECK(14);
 394         ND_PRINT("\n\t      Version: %u, Keepalive: %us, Flags: [Downstream %s, Loop Detection %s]",
 395                GET_BE_U_2(tptr), GET_BE_U_2(tptr + 2),
 396                (GET_BE_U_2(tptr + 4)&0x8000) ? "On Demand" : "Unsolicited",
 397                (GET_BE_U_2(tptr + 4)&0x4000) ? "Enabled" : "Disabled"
 398                );
 399         ND_PRINT("\n\t      Path Vector Limit %u, Max-PDU length: %u, Receiver Label-Space-ID %s:%u",
 400                GET_U_1(tptr+5),
 401                GET_BE_U_2(tptr+6),
 402                GET_IPADDR_STRING(tptr+8),
 403                GET_BE_U_2(tptr+12)
 404                );
 405         break;
 406
 407     case LDP_TLV_FEC:
 408         TLV_TCHECK(1);
 409         fec_type = GET_U_1(tptr);
 410         ND_PRINT("\n\t      %s FEC (0x%02x)",
 411                tok2str(ldp_fec_values, "Unknown", fec_type),
 412                fec_type);
 413
 414         tptr+=1;
 415         tlv_tlen-=1;
 416         switch(fec_type) {
 417
 418         case LDP_FEC_WILDCARD:
 419             break;
 420         case LDP_FEC_PREFIX:
 421             TLV_TCHECK(2);
 422             af = GET_BE_U_2(tptr);
 423             tptr+=2;
 424             tlv_tlen-=2;
 425             if (af == AFNUM_IP) {
 426                 i=decode_prefix4(ndo, tptr, tlv_tlen, buf, sizeof(buf));
 427                 if (i == -2)
 428                     goto trunc;
 429                 if (i == -3)
 430                     ND_PRINT(": IPv4 prefix (goes past end of TLV)");
 431                 else if (i == -1)
 432                     ND_PRINT(": IPv4 prefix (invalid length)");
 433                 else
 434                     ND_PRINT(": IPv4 prefix %s", buf);
 435             } else if (af == AFNUM_IP6) {
 436                 i=decode_prefix6(ndo, tptr, tlv_tlen, buf, sizeof(buf));
 437                 if (i == -2)
 438                     goto trunc;
 439                 if (i == -3)
 440                     ND_PRINT(": IPv4 prefix (goes past end of TLV)");
 441                 else if (i == -1)
 442                     ND_PRINT(": IPv6 prefix (invalid length)");
 443                 else
 444                     ND_PRINT(": IPv6 prefix %s", buf);
 445             } else
 446                 ND_PRINT(": Address family %u prefix", af);
 447             break;
 448         case LDP_FEC_HOSTADDRESS:
 449             break;
 450         case LDP_FEC_MARTINI_VC:
 451             /*
 452              * We assume the type was supposed to be one of the MPLS
 453              * Pseudowire Types.
 454              */
 455             TLV_TCHECK(7);
 456             vc_info_len = GET_U_1(tptr + 2);
 457
 458             /*
 459              * According to RFC 4908, the VC info Length field can be zero,
 460              * in which case not only are there no interface parameters,
 461              * there's no VC ID.
 462              */
 463             if (vc_info_len == 0) {
 464                 ND_PRINT(": %s, %scontrol word, group-ID %u, VC-info-length: %u",
 465                        tok2str(mpls_pw_types_values, "Unknown", GET_BE_U_2(tptr)&0x7fff),
 466                        GET_BE_U_2(tptr)&0x8000 ? "" : "no ",
 467                        GET_BE_U_4(tptr + 3),
 468                        vc_info_len);
 469                 break;
 470             }
 471
 472             /* Make sure we have the VC ID as well */
 473             TLV_TCHECK(11);
 474             ND_PRINT(": %s, %scontrol word, group-ID %u, VC-ID %u, VC-info-length: %u",
 475                    tok2str(mpls_pw_types_values, "Unknown", GET_BE_U_2(tptr)&0x7fff),
 476                    GET_BE_U_2(tptr)&0x8000 ? "" : "no ",
 477                    GET_BE_U_4(tptr + 3),
 478                    GET_BE_U_4(tptr + 7),
 479                    vc_info_len);
 480             if (vc_info_len < 4) {
 481                 /* minimum 4, for the VC ID */
 482                 ND_PRINT(" (invalid, < 4");
 483                 return(tlv_len+4); /* Type & Length fields not included */
 484             }
 485             vc_info_len -= 4; /* subtract out the VC ID, giving the length of the interface parameters */
 486
 487             /* Skip past the fixed information and the VC ID */
 488             tptr+=11;
 489             tlv_tlen-=11;
 490             TLV_TCHECK(vc_info_len);
 491
 492             while (vc_info_len > 2) {
 493                 vc_info_tlv_type = GET_U_1(tptr);
 494                 vc_info_tlv_len = GET_U_1(tptr + 1);
 495                 if (vc_info_tlv_len < 2)
 496                     break;
 497                 if (vc_info_len < vc_info_tlv_len)
 498                     break;
 499
 500                 ND_PRINT("\n\t\tInterface Parameter: %s (0x%02x), len %u",
 501                        tok2str(ldp_fec_martini_ifparm_values,"Unknown",vc_info_tlv_type),
 502                        vc_info_tlv_type,
 503                        vc_info_tlv_len);
 504
 505                 switch(vc_info_tlv_type) {
 506                 case LDP_FEC_MARTINI_IFPARM_MTU:
 507                     ND_PRINT(": %u", GET_BE_U_2(tptr + 2));
 508                     break;
 509
 510                 case LDP_FEC_MARTINI_IFPARM_DESC:
 511                     ND_PRINT(": ");
 512                     for (idx = 2; idx < vc_info_tlv_len; idx++)
 513                         fn_print_char(ndo, GET_U_1(tptr + idx));
 514                     break;
 515
 516                 case LDP_FEC_MARTINI_IFPARM_VCCV:
 517                     ND_PRINT("\n\t\t  Control Channels (0x%02x) = [%s]",
 518                            GET_U_1((tptr + 2)),
 519                            bittok2str(ldp_fec_martini_ifparm_vccv_cc_values, "none", GET_U_1((tptr + 2))));
 520                     ND_PRINT("\n\t\t  CV Types (0x%02x) = [%s]",
 521                            GET_U_1((tptr + 3)),
 522                            bittok2str(ldp_fec_martini_ifparm_vccv_cv_values, "none", GET_U_1((tptr + 3))));
 523                     break;
 524
 525                 default:
 526                     print_unknown_data(ndo, tptr+2, "\n\t\t  ", vc_info_tlv_len-2);
 527                     break;
 528                 }
 529
 530                 vc_info_len -= vc_info_tlv_len;
 531                 tptr += vc_info_tlv_len;
 532             }
 533             break;
 534         }
 535
 536         break;
 537
 538     case LDP_TLV_GENERIC_LABEL:
 539         TLV_TCHECK(4);
 540         ND_PRINT("\n\t      Label: %u", GET_BE_U_4(tptr) & 0xfffff);
 541         break;
 542
 543     case LDP_TLV_STATUS:
 544         TLV_TCHECK(10);
 545         ui = GET_BE_U_4(tptr);
 546         tptr+=4;
 547         ND_PRINT("\n\t      Status Code: %s, Flags: [%s and %s forward]",
 548                  tok2str(ldp_status_code_values, "Unknown", ui&0x3fffffff),
 549                  ui&0x80000000 ? "Fatal error" : "Advisory Notification",
 550                  ui&0x40000000 ? "do" : "don't");
 551         ui = GET_BE_U_4(tptr);
 552         tptr+=4;
 553         if (ui)
 554             ND_PRINT(", causing Message ID: 0x%08x", ui);
 555         ui = GET_BE_U_2(tptr);
 556         if (ui)
 557             ND_PRINT(", Message ID: %s", tok2str(ldp_msg_values, "Unknown", ui));
 558
 559         break;
 560
 561     case LDP_TLV_FT_SESSION:
 562         TLV_TCHECK(12);
 563         ft_flags = GET_BE_U_2(tptr);
 564         ND_PRINT("\n\t      Flags: [%sReconnect, %sSave State, %sAll-Label Protection, %s Checkpoint, %sRe-Learn State]",
 565                ft_flags&0x8000 ? "" : "No ",
 566                ft_flags&0x8 ? "" : "Don't ",
 567                ft_flags&0x4 ? "" : "No ",
 568                ft_flags&0x2 ? "Sequence Numbered Label" : "All Labels",
 569                ft_flags&0x1 ? "" : "Don't ");
 570         /* 16 bits (FT Flags) + 16 bits (Reserved) */
 571         tptr+=4;
 572         ui = GET_BE_U_4(tptr);
 573         if (ui)
 574             ND_PRINT(", Reconnect Timeout: %ums", ui);
 575         tptr+=4;
 576         ui = GET_BE_U_4(tptr);
 577         if (ui)
 578             ND_PRINT(", Recovery Time: %ums", ui);
 579         break;
 580
 581     case LDP_TLV_TYPED_WC_FEC_CAP:
 582         TLV_TCHECK(1);
 583         ND_PRINT("\n\t      %s", GET_U_1(tptr)&0x80 ? "Support" : "No Support");
 584         break;
 585
 586     case LDP_TLV_MTU:
 587         TLV_TCHECK(2);
 588         ND_PRINT("\n\t      MTU: %u", GET_BE_U_2(tptr));
 589         break;
 590
 591     case LDP_TLV_DUAL_STACK_CAP:
 592         TLV_TCHECK(4);
 593         transport_pref = GET_U_1(tptr);
 594         ND_PRINT("\n\t      Transport Connection Preference: %s",
 595                  tok2str(ldp_dual_stack_transport_pref_values,
 596                          "Unknown",
 597                          transport_pref));
 598         break;
 599
 600
 601     /*
 602      *  FIXME those are the defined TLVs that lack a decoder
 603      *  you are welcome to contribute code ;-)
 604      */
 605
 606     case LDP_TLV_ATM_LABEL:
 607     case LDP_TLV_FR_LABEL:
 608     case LDP_TLV_EXTD_STATUS:
 609     case LDP_TLV_RETURNED_PDU:
 610     case LDP_TLV_RETURNED_MSG:
 611     case LDP_TLV_ATM_SESSION_PARM:
 612     case LDP_TLV_FR_SESSION_PARM:
 613     case LDP_TLV_LABEL_REQUEST_MSG_ID:
 614
 615     default:
 616         if (ndo->ndo_vflag <= 1)
 617             print_unknown_data(ndo, tptr, "\n\t      ", tlv_tlen);
 618         break;
 619     }
 620     return(tlv_len+4); /* Type & Length fields not included */
 621
 622 trunc:
 623     nd_trunc_longjmp(ndo);
 624
 625 invalid:
 626     return(tlv_len+4); /* Type & Length fields not included */
 627 }
 628
 629 void
 630 ldp_print(netdissect_options *ndo,
 631           const u_char *pptr, u_int len)
 632 {
 633     u_int processed;
 634
 635     ndo->ndo_protocol = "ldp";
 636     while (len > (sizeof(struct ldp_common_header) + sizeof(struct ldp_msg_header))) {
 637         processed = ldp_pdu_print(ndo, pptr);
 638         if (processed == 0)
 639             return;
 640         if (len < processed) {
 641             ND_PRINT(" [remaining length %u < %u]", len, processed);
 642             nd_print_invalid(ndo);
 643             break;
 644         }
 645         len -= processed;
 646         pptr += processed;
 647     }
 648 }
 649
 650 static u_int
 651 ldp_pdu_print(netdissect_options *ndo,
 652               const u_char *pptr)
 653 {
 654     const struct ldp_common_header *ldp_com_header;
 655     const struct ldp_msg_header *ldp_msg_header;
 656     const u_char *tptr,*msg_tptr;
 657     u_short tlen;
 658     u_short pdu_len,msg_len,msg_type;
 659     u_int msg_tlen;
 660     int hexdump,processed;
 661
 662     ldp_com_header = (const struct ldp_common_header *)pptr;
 663     ND_TCHECK_SIZE(ldp_com_header);
 664
 665     /*
 666      * Sanity checking of the header.
 667      */
 668     if (GET_BE_U_2(ldp_com_header->version) != LDP_VERSION) {
 669         ND_PRINT("%sLDP version %u packet not supported",
 670                (ndo->ndo_vflag < 1) ? "" : "\n\t",
 671                GET_BE_U_2(ldp_com_header->version));
 672         return 0;
 673     }
 674
 675     pdu_len = GET_BE_U_2(ldp_com_header->pdu_length);
 676     if (pdu_len < sizeof(struct ldp_common_header)-4) {
 677         /* length too short */
 678         ND_PRINT("%sLDP, pdu-length: %u (too short, < %zu)",
 679                  (ndo->ndo_vflag < 1) ? "" : "\n\t",
 680                  pdu_len,
 681                  sizeof(struct ldp_common_header)-4);
 682         return 0;
 683     }
 684
 685     /* print the LSR-ID, label-space & length */
 686     ND_PRINT("%sLDP, Label-Space-ID: %s:%u, pdu-length: %u",
 687            (ndo->ndo_vflag < 1) ? "" : "\n\t",
 688            GET_IPADDR_STRING(ldp_com_header->lsr_id),
 689            GET_BE_U_2(ldp_com_header->label_space),
 690            pdu_len);
 691
 692     /* bail out if non-verbose */
 693     if (ndo->ndo_vflag < 1)
 694         return 0;
 695
 696     /* ok they seem to want to know everything - lets fully decode it */
 697     tptr = pptr + sizeof(struct ldp_common_header);
 698     tlen = pdu_len - (sizeof(struct ldp_common_header)-4);      /* Type & Length fields not included */
 699
 700     while(tlen>0) {
 701         /* did we capture enough for fully decoding the msg header ? */
 702         ND_TCHECK_LEN(tptr, sizeof(struct ldp_msg_header));
 703
 704         ldp_msg_header = (const struct ldp_msg_header *)tptr;
 705         msg_len=GET_BE_U_2(ldp_msg_header->length);
 706         msg_type=LDP_MASK_MSG_TYPE(GET_BE_U_2(ldp_msg_header->type));
 707
 708         if (msg_len < sizeof(struct ldp_msg_header)-4) {
 709             /* length too short */
 710             /* FIXME vendor private / experimental check */
 711             ND_PRINT("\n\t  %s Message (0x%04x), length: %u (too short, < %zu)",
 712                      tok2str(ldp_msg_values,
 713                              "Unknown",
 714                              msg_type),
 715                      msg_type,
 716                      msg_len,
 717                      sizeof(struct ldp_msg_header)-4);
 718             return 0;
 719         }
 720
 721         /* FIXME vendor private / experimental check */
 722         ND_PRINT("\n\t  %s Message (0x%04x), length: %u, Message ID: 0x%08x, Flags: [%s if unknown]",
 723                tok2str(ldp_msg_values,
 724                        "Unknown",
 725                        msg_type),
 726                msg_type,
 727                msg_len,
 728                GET_BE_U_4(ldp_msg_header->id),
 729                LDP_MASK_U_BIT(GET_BE_U_2(ldp_msg_header->type)) ? "continue processing" : "ignore");
 730
 731         msg_tptr=tptr+sizeof(struct ldp_msg_header);
 732         msg_tlen=msg_len-(sizeof(struct ldp_msg_header)-4); /* Type & Length fields not included */
 733
 734         /* did we capture enough for fully decoding the message ? */
 735         ND_TCHECK_LEN(tptr, msg_len);
 736         hexdump=FALSE;
 737
 738         switch(msg_type) {
 739
 740         case LDP_MSG_NOTIF:
 741         case LDP_MSG_HELLO:
 742         case LDP_MSG_INIT:
 743         case LDP_MSG_KEEPALIVE:
 744         case LDP_MSG_ADDRESS:
 745         case LDP_MSG_LABEL_MAPPING:
 746         case LDP_MSG_ADDRESS_WITHDRAW:
 747         case LDP_MSG_LABEL_WITHDRAW:
 748         case LDP_MSG_LABEL_REQUEST:
 749         case LDP_MSG_LABEL_RELEASE:
 750         case LDP_MSG_LABEL_ABORT_REQUEST:
 751             while(msg_tlen >= 4) {
 752                 processed = ldp_tlv_print(ndo, msg_tptr, msg_tlen);
 753                 if (processed == 0)
 754                     break;
 755                 msg_tlen-=processed;
 756                 msg_tptr+=processed;
 757             }
 758             break;
 759
 760         default:
 761             if (ndo->ndo_vflag <= 1)
 762                 print_unknown_data(ndo, msg_tptr, "\n\t  ", msg_tlen);
 763             break;
 764         }
 765         /* do we want to see an additionally hexdump ? */
 766         if (ndo->ndo_vflag > 1 || hexdump==TRUE)
 767             print_unknown_data(ndo, tptr+sizeof(struct ldp_msg_header), "\n\t  ",
 768                                msg_len);
 769
 770         tptr += msg_len+4;
 771         tlen -= msg_len+4;
 772     }
 773     return pdu_len+4;
 774 trunc:
 775     nd_trunc_longjmp(ndo);
 776 }