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