The Tcpdump Group git mirrors - tcpdump/blob - print-lmp.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  */
  15
  16 #ifndef lint
  17 static const char rcsid[] _U_ =
  18     "@(#) $Header: /tcpdump/master/tcpdump/print-lmp.c,v 1.3 2004-04-26 13:22:50 hannes Exp $";
  19 #endif
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <tcpdump-stdinc.h>
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "interface.h"
  32 #include "extract.h"
  33 #include "addrtoname.h"
  34 #include "gmpls.h"
  35
  36 /*
  37  * LMP common header
  38  *
  39  *  0                   1                   2                   3
  40  *  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
  41  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  42  * | Vers  |      (Reserved)       |    Flags      |    Msg Type   |
  43  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  44  * |          LMP Length           |          (Reserved)           |
  45  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  46  */
  47
  48 struct lmp_common_header {
  49     u_int8_t version_res[2];
  50     u_int8_t flags;
  51     u_int8_t msg_type;
  52     u_int8_t length[2];
  53     u_int8_t reserved[2];
  54 };
  55
  56 #define LMP_VERSION            1
  57 #define LMP_EXTRACT_VERSION(x) (((x)&0xf0)>>4)
  58
  59 static const struct tok lmp_header_flag_values[] = {
  60     { 0x00, "Control Channel Down"},
  61     { 0x02, "LMP restart"},
  62     { 0, NULL}
  63 };
  64
  65 static const struct tok lmp_obj_te_link_flag_values[] = {
  66     { 0x01, "Fault Management Supported"},
  67     { 0x02, "Link Verification Supported"},
  68     { 0, NULL}
  69 };
  70
  71 static const struct tok lmp_obj_data_link_flag_values[] = {
  72     { 0x01, "Data Link Port"},
  73     { 0x02, "Allocated for user traffic"},
  74     { 0x04, "Failed link"},
  75     { 0, NULL}
  76 };
  77
  78 static const struct tok lmp_obj_channel_status_values[] = {
  79     { 1, "Signal Okay"},
  80     { 2, "Signal Degraded"},
  81     { 3, "Signal Fail"},
  82     { 0, NULL}
  83 };
  84
  85 static const struct tok lmp_obj_begin_verify_flag_values[] = {
  86     { 0x0001, "Verify all links"},
  87     { 0x0002, "Data link type"},
  88     { 0, NULL}
  89 };
  90
  91 static const struct tok lmp_obj_begin_verify_error_values[] = {
  92     { 0x01, "\n\t\tLink Verification Procedure Not supported"},
  93     { 0x02, "\n\t\tUnwilling to verify"},
  94     { 0x04, "\n\t\tUnsupported verification transport mechanism"},
  95     { 0x08, "\n\t\tLink_Id configuration error"},
  96     { 0x10, "\n\t\tUnknown object c-type"},
  97     { 0, NULL}
  98 };
  99
 100 static const struct tok lmp_obj_link_summary_error_values[] = {
 101     { 0x01, "\n\t\tUnacceptable non-negotiable LINK_SUMMARY parameters"},
 102     { 0x02, "\n\t\tRenegotiate LINK_SUMMARY parameters"},
 103     { 0x04, "\n\t\tInvalid TE-LINK Object"},
 104     { 0x08, "\n\t\tInvalid DATA-LINK Object"},
 105     { 0x10, "\n\t\tUnknown TE-LINK Object c-type"},
 106     { 0x20, "\n\t\tUnknown DATA-LINK Object c-type"},
 107     { 0, NULL}
 108 };
 109
 110 #define LMP_MSGTYPE_CONFIG                 1
 111 #define LMP_MSGTYPE_CONFIG_ACK             2
 112 #define LMP_MSGTYPE_CONFIG_NACK            3
 113 #define LMP_MSGTYPE_HELLO                  4
 114 #define LMP_MSGTYPE_VERIFY_BEGIN           5
 115 #define LMP_MSGTYPE_VERIFY_BEGIN_ACK       6
 116 #define LMP_MSGTYPE_VERIFY_BEGIN_NACK      7
 117 #define LMP_MSGTYPE_VERIFY_END             8
 118 #define LMP_MSGTYPE_VERIFY_END_ACK         9
 119 #define LMP_MSGTYPE_TEST                  10
 120 #define LMP_MSGTYPE_TEST_STATUS_SUCCESS   11
 121 #define LMP_MSGTYPE_TEST_STATUS_FAILURE   12
 122 #define LMP_MSGTYPE_TEST_STATUS_ACK       13
 123 #define LMP_MSGTYPE_LINK_SUMMARY          14
 124 #define LMP_MSGTYPE_LINK_SUMMARY_ACK      15
 125 #define LMP_MSGTYPE_LINK_SUMMARY_NACK     16
 126 #define LMP_MSGTYPE_CHANNEL_STATUS        17
 127 #define LMP_MSGTYPE_CHANNEL_STATUS_ACK    18
 128 #define LMP_MSGTYPE_CHANNEL_STATUS_REQ    19
 129 #define LMP_MSGTYPE_CHANNEL_STATUS_RESP   20
 130
 131 static const struct tok lmp_msg_type_values[] = {
 132     { LMP_MSGTYPE_CONFIG, "Config"},
 133     { LMP_MSGTYPE_CONFIG_ACK, "Config ACK"},
 134     { LMP_MSGTYPE_CONFIG_NACK, "Config NACK"},
 135     { LMP_MSGTYPE_HELLO, "Hello"},
 136     { LMP_MSGTYPE_VERIFY_BEGIN, "Begin Verify"},
 137     { LMP_MSGTYPE_VERIFY_BEGIN_ACK, "Begin Verify ACK"},
 138     { LMP_MSGTYPE_VERIFY_BEGIN_NACK, "Begin Verify NACK"},
 139     { LMP_MSGTYPE_VERIFY_END, "End Verify"},
 140     { LMP_MSGTYPE_VERIFY_END_ACK, "End Verify ACK"},
 141     { LMP_MSGTYPE_TEST, "Test"},
 142     { LMP_MSGTYPE_TEST_STATUS_SUCCESS, "Test Status Success"},
 143     { LMP_MSGTYPE_TEST_STATUS_FAILURE, "Test Status Failure"},
 144     { LMP_MSGTYPE_TEST_STATUS_ACK, "Test Status ACK"},
 145     { LMP_MSGTYPE_LINK_SUMMARY, "Link Summary"},
 146     { LMP_MSGTYPE_LINK_SUMMARY_ACK, "Link Summary ACK"},
 147     { LMP_MSGTYPE_LINK_SUMMARY_NACK, "Link Summary NACK"},
 148     { LMP_MSGTYPE_CHANNEL_STATUS, "Channel Status"},
 149     { LMP_MSGTYPE_CHANNEL_STATUS_ACK, "Channel Status ACK"},
 150     { LMP_MSGTYPE_CHANNEL_STATUS_REQ, "Channel Status Request"},
 151     { LMP_MSGTYPE_CHANNEL_STATUS_RESP, "Channel Status Response"},
 152     { 0, NULL}
 153 };
 154
 155 /*
 156  * LMP object header
 157  *
 158  *  0                   1                   2                   3
 159  *  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
 160  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 161  * |N|   C-Type    |     Class     |            Length             |
 162  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 163  * |                                                               |
 164  * //                       (object contents)                     //
 165  * |                                                               |
 166  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 167  */
 168
 169 struct lmp_object_header {
 170     u_int8_t ctype;
 171     u_int8_t class_num;
 172     u_int8_t length[2];
 173 };
 174
 175 #define LMP_OBJ_CC_ID                 1
 176 #define LMP_OBJ_NODE_ID               2
 177 #define LMP_OBJ_LINK_ID               3
 178 #define LMP_OBJ_INTERFACE_ID          4
 179 #define LMP_OBJ_MESSAGE_ID            5
 180 #define LMP_OBJ_CONFIG                6
 181 #define LMP_OBJ_HELLO                 7
 182 #define LMP_OBJ_VERIFY_BEGIN          8
 183 #define LMP_OBJ_VERIFY_BEGIN_ACK      9
 184 #define LMP_OBJ_VERIFY_ID            10
 185 #define LMP_OBJ_TE_LINK              11
 186 #define LMP_OBJ_DATA_LINK            12
 187 #define LMP_OBJ_CHANNEL_STATUS       13
 188 #define LMP_OBJ_CHANNEL_STATUS_REQ   14
 189 #define LMP_OBJ_ERROR_CODE           20
 190
 191 static const struct tok lmp_obj_values[] = {
 192     { LMP_OBJ_CC_ID, "Control Channel ID" },
 193     { LMP_OBJ_NODE_ID, "Node ID" },
 194     { LMP_OBJ_LINK_ID, "Link ID" },
 195     { LMP_OBJ_INTERFACE_ID, "Interface ID" },
 196     { LMP_OBJ_MESSAGE_ID, "Message ID" },
 197     { LMP_OBJ_CONFIG, "Configuration" },
 198     { LMP_OBJ_HELLO, "Hello" },
 199     { LMP_OBJ_VERIFY_BEGIN, "Verify Begin" },
 200     { LMP_OBJ_VERIFY_BEGIN_ACK, "Verify Begin ACK" },
 201     { LMP_OBJ_VERIFY_ID, "Verify ID" },
 202     { LMP_OBJ_TE_LINK, "TE Link" },
 203     { LMP_OBJ_DATA_LINK, "Data Link" },
 204     { LMP_OBJ_CHANNEL_STATUS, "Channel Status" },
 205     { LMP_OBJ_CHANNEL_STATUS_REQ, "Channel Status Request" },
 206     { LMP_OBJ_ERROR_CODE, "Error Code" },
 207     { 0, NULL}
 208 };
 209
 210 #define INT_SWITCHING_TYPE_SUBOBJ 1
 211 #define WAVELENGTH_SUBOBJ         2
 212
 213 static const struct tok lmp_data_link_subobj[] = {
 214     { INT_SWITCHING_TYPE_SUBOBJ, "Interface Switching Type" },
 215     { WAVELENGTH_SUBOBJ        , "Wavelength" },
 216     { 0, NULL}
 217 };
 218
 219 #define LMP_CTYPE_IPV4       1
 220 #define LMP_CTYPE_IPV6       2
 221
 222 #define LMP_CTYPE_LOC        1
 223 #define LMP_CTYPE_RMT        2
 224 #define LMP_CTYPE_UNMD       3
 225
 226 #define LMP_CTYPE_IPV4_LOC   1
 227 #define LMP_CTYPE_IPV4_RMT   2
 228 #define LMP_CTYPE_IPV6_LOC   3
 229 #define LMP_CTYPE_IPV6_RMT   4
 230 #define LMP_CTYPE_UNMD_LOC   5
 231 #define LMP_CTYPE_UNMD_RMT   6
 232
 233 #define LMP_CTYPE_1          1
 234 #define LMP_CTYPE_2          2
 235
 236 #define LMP_CTYPE_HELLO_CONFIG  1
 237 #define LMP_CTYPE_HELLO         1
 238
 239 #define LMP_CTYPE_BEGIN_VERIFY_ERROR 1
 240 #define LMP_CTYPE_LINK_SUMMARY_ERROR 2
 241
 242 #define FALSE 0
 243 #define TRUE  1
 244
 245 /*
 246  * the ctypes are not globally unique so for
 247  * translating it to strings we build a table based
 248  * on objects offsetted by the ctype
 249  */
 250
 251 static const struct tok lmp_ctype_values[] = {
 252     { 256*LMP_OBJ_CC_ID+LMP_CTYPE_LOC, "Local" },
 253     { 256*LMP_OBJ_CC_ID+LMP_CTYPE_RMT, "Remote" },
 254     { 256*LMP_OBJ_NODE_ID+LMP_CTYPE_LOC, "Local" },
 255     { 256*LMP_OBJ_NODE_ID+LMP_CTYPE_RMT, "Remote" },
 256     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV4_LOC, "IPv4 Local" },
 257     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV4_RMT, "IPv4 Remote" },
 258     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV6_LOC, "IPv6 Local" },
 259     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_IPV6_RMT, "IPv6 Remote" },
 260     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_UNMD_LOC, "Unnumbered Local" },
 261     { 256*LMP_OBJ_LINK_ID+LMP_CTYPE_UNMD_RMT, "Unnumbered Remote" },
 262     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV4_LOC, "IPv4 Local" },
 263     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV4_RMT, "IPv4 Remote" },
 264     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV6_LOC, "IPv6 Local" },
 265     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_IPV6_RMT, "IPv6 Remote" },
 266     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_UNMD_LOC, "Unnumbered Local" },
 267     { 256*LMP_OBJ_INTERFACE_ID+LMP_CTYPE_UNMD_RMT, "Unnumbered Remote" },
 268     { 256*LMP_OBJ_MESSAGE_ID+LMP_CTYPE_1, "1" },
 269     { 256*LMP_OBJ_MESSAGE_ID+LMP_CTYPE_2, "2" },
 270     { 256*LMP_OBJ_CONFIG+LMP_CTYPE_1, "1" },
 271     { 256*LMP_OBJ_HELLO+LMP_CTYPE_1, "1" },
 272     { 256*LMP_OBJ_VERIFY_BEGIN+LMP_CTYPE_1, "1" },
 273     { 256*LMP_OBJ_VERIFY_BEGIN_ACK+LMP_CTYPE_1, "1" },
 274     { 256*LMP_OBJ_VERIFY_ID+LMP_CTYPE_1, "1" },
 275     { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_IPV4, "IPv4" },
 276     { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_IPV6, "IPv6" },
 277     { 256*LMP_OBJ_TE_LINK+LMP_CTYPE_UNMD, "Unnumbered" },
 278     { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_IPV4, "IPv4" },
 279     { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_IPV6, "IPv6" },
 280     { 256*LMP_OBJ_DATA_LINK+LMP_CTYPE_UNMD, "Unnumbered" },
 281     { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_IPV4, "IPv4" },
 282     { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_IPV6, "IPv6" },
 283     { 256*LMP_OBJ_CHANNEL_STATUS+LMP_CTYPE_UNMD, "Unnumbered" },
 284     { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_IPV4, "IPv4" },
 285     { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_IPV6, "IPv6" },
 286     { 256*LMP_OBJ_CHANNEL_STATUS_REQ+LMP_CTYPE_UNMD, "Unnumbered" },
 287     { 256*LMP_OBJ_ERROR_CODE+LMP_CTYPE_1, "1" },
 288     { 256*LMP_OBJ_ERROR_CODE+LMP_CTYPE_2, "2" },
 289     { 0, NULL}
 290 };
 291
 292 void
 293 lmp_print(register const u_char *pptr, register u_int len) {
 294
 295     const struct lmp_common_header *lmp_com_header;
 296     const struct lmp_object_header *lmp_obj_header;
 297     const u_char *tptr,*obj_tptr;
 298     int tlen,lmp_obj_len,lmp_obj_ctype,obj_tlen;
 299     int hexdump;
 300     int offset;
 301
 302     tptr=pptr;
 303     lmp_com_header = (const struct lmp_common_header *)pptr;
 304     TCHECK(*lmp_com_header);
 305
 306     /*
 307      * Sanity checking of the header.
 308      */
 309     if (LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]) != LMP_VERSION) {
 310         printf("LMP version %u packet not supported",
 311                LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]));
 312         return;
 313     }
 314
 315     /* in non-verbose mode just lets print the basic Message Type*/
 316     if (vflag < 1) {
 317         printf("LMPv%u %s Message, length: %u",
 318                LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]),
 319                tok2str(lmp_msg_type_values, "unknown (%u)",lmp_com_header->msg_type),
 320                len);
 321         return;
 322     }
 323
 324     /* ok they seem to want to know everything - lets fully decode it */
 325
 326     tlen=EXTRACT_16BITS(lmp_com_header->length);
 327
 328     printf("\n\tLMPv%u, msg-type: %s, Flags: [%s], length: %u",
 329            LMP_EXTRACT_VERSION(lmp_com_header->version_res[0]),
 330            tok2str(lmp_msg_type_values, "unknown, type: %u",lmp_com_header->msg_type),
 331            bittok2str(lmp_header_flag_values,"none",lmp_com_header->flags),
 332            tlen);
 333
 334     tptr+=sizeof(const struct lmp_common_header);
 335     tlen-=sizeof(const struct lmp_common_header);
 336
 337     while(tlen>0) {
 338         /* did we capture enough for fully decoding the object header ? */
 339         if (!TTEST2(*tptr, sizeof(struct lmp_object_header)))
 340             goto trunc;
 341
 342         lmp_obj_header = (const struct lmp_object_header *)tptr;
 343         lmp_obj_len=EXTRACT_16BITS(lmp_obj_header->length);
 344         lmp_obj_ctype=(lmp_obj_header->ctype)&0x7f;
 345
 346         if(lmp_obj_len % 4 || lmp_obj_len < 4)
 347             return;
 348
 349         printf("\n\t  %s Object (%u), Class-Type: %s (%u) Flags: [%snegotiable], length: %u",
 350                tok2str(lmp_obj_values,
 351                        "Unknown",
 352                        lmp_obj_header->class_num),
 353                lmp_obj_header->class_num,
 354                tok2str(lmp_ctype_values,
 355                        "Unknown",
 356                        ((lmp_obj_header->class_num)<<8)+lmp_obj_ctype),
 357                lmp_obj_ctype,
 358                (lmp_obj_header->ctype)&0x80 ? "" : "non-",
 359                lmp_obj_len);
 360
 361         obj_tptr=tptr+sizeof(struct lmp_object_header);
 362         obj_tlen=lmp_obj_len-sizeof(struct lmp_object_header);
 363
 364         /* did we capture enough for fully decoding the object ? */
 365         if (!TTEST2(*tptr, lmp_obj_len))
 366             goto trunc;
 367         hexdump=FALSE;
 368
 369         switch(lmp_obj_header->class_num) {
 370
 371         case LMP_OBJ_CC_ID:
 372             switch(lmp_obj_ctype) {
 373             case LMP_CTYPE_LOC:
 374             case LMP_CTYPE_RMT:
 375                 printf("\n\t    Control Channel ID: %u (0x%08x)",
 376                        EXTRACT_32BITS(obj_tptr),
 377                        EXTRACT_32BITS(obj_tptr));
 378                 break;
 379
 380             default:
 381                 hexdump=TRUE;
 382             }
 383             break;
 384
 385         case LMP_OBJ_LINK_ID:
 386         case LMP_OBJ_INTERFACE_ID:
 387             switch(lmp_obj_ctype) {
 388             case LMP_CTYPE_IPV4_LOC:
 389             case LMP_CTYPE_IPV4_RMT:
 390                 printf("\n\t    IPv4 Link ID: %s (0x%08x)",
 391                        ipaddr_string(obj_tptr),
 392                        EXTRACT_32BITS(obj_tptr));
 393                 break;
 394 #ifdef INET6
 395             case LMP_CTYPE_IPV6_LOC:
 396             case LMP_CTYPE_IPV6_RMT:
 397                 printf("\n\t    IPv6 Link ID: %s (0x%08x)",
 398                        ip6addr_string(obj_tptr),
 399                        EXTRACT_32BITS(obj_tptr));
 400                 break;
 401 #endif
 402             case LMP_CTYPE_UNMD_LOC:
 403             case LMP_CTYPE_UNMD_RMT:
 404                 printf("\n\t    Link ID: %u (0x%08x)",
 405                        EXTRACT_32BITS(obj_tptr),
 406                        EXTRACT_32BITS(obj_tptr));
 407                 break;
 408             default:
 409                 hexdump=TRUE;
 410             }
 411             break;
 412
 413         case LMP_OBJ_MESSAGE_ID:
 414             switch(lmp_obj_ctype) {
 415             case LMP_CTYPE_1:
 416                 printf("\n\t    Message ID: %u (0x%08x)",
 417                        EXTRACT_32BITS(obj_tptr),
 418                        EXTRACT_32BITS(obj_tptr));
 419                 break;
 420             case LMP_CTYPE_2:
 421                 printf("\n\t    Message ID Ack: %u (0x%08x)",
 422                        EXTRACT_32BITS(obj_tptr),
 423                        EXTRACT_32BITS(obj_tptr));
 424                 break;
 425             default:
 426                 hexdump=TRUE;
 427             }
 428             break;
 429
 430         case LMP_OBJ_NODE_ID:
 431             switch(lmp_obj_ctype) {
 432             case LMP_CTYPE_LOC:
 433             case LMP_CTYPE_RMT:
 434                 printf("\n\t    Node ID: %s (0x%08x)",
 435                        ipaddr_string(obj_tptr),
 436                        EXTRACT_32BITS(obj_tptr));
 437                 break;
 438
 439             default:
 440                 hexdump=TRUE;
 441             }
 442             break;
 443
 444         case LMP_OBJ_CONFIG:
 445             switch(lmp_obj_ctype) {
 446             case LMP_CTYPE_HELLO_CONFIG:
 447                 printf("\n\t    Hello Interval: %u\n\t    Hello Dead Interval: %u",
 448                        EXTRACT_16BITS(obj_tptr),
 449                        EXTRACT_16BITS(obj_tptr+2));
 450                 break;
 451
 452             default:
 453                 hexdump=TRUE;
 454             }
 455             break;
 456
 457         case LMP_OBJ_HELLO:
 458             switch(lmp_obj_ctype) {
 459             case LMP_CTYPE_HELLO:
 460                 printf("\n\t    TxSeqNum: %u\n\t    RcvSeqNum: %u",
 461                        EXTRACT_32BITS(obj_tptr),
 462                        EXTRACT_32BITS(obj_tptr+4));
 463                 break;
 464
 465             default:
 466                 hexdump=TRUE;
 467             }
 468             break;
 469
 470         case LMP_OBJ_TE_LINK:
 471                 printf("\n\t    Flags: [%s]",
 472                 bittok2str(lmp_obj_te_link_flag_values,
 473                         "none",
 474                         EXTRACT_16BITS(obj_tptr)>>8));
 475
 476             switch(lmp_obj_ctype) {
 477             case LMP_CTYPE_IPV4:
 478                 printf("\n\t    Local Link-ID: %s (0x%08x) \
 479                         \n\t    Remote Link-ID: %s (0x%08x)",
 480                        ipaddr_string(obj_tptr+4),
 481                        EXTRACT_32BITS(obj_tptr+4),
 482                        ipaddr_string(obj_tptr+8),
 483                        EXTRACT_32BITS(obj_tptr+8));
 484                 break;
 485
 486 #ifdef INET6
 487             case LMP_CTYPE_IPV6:
 488 #endif
 489             case LMP_CTYPE_UNMD:
 490             default:
 491                 hexdump=TRUE;
 492             }
 493             break;
 494
 495         case LMP_OBJ_DATA_LINK:
 496                 printf("\n\t    Flags: [%s]",
 497                 bittok2str(lmp_obj_data_link_flag_values,
 498                         "none",
 499                         EXTRACT_16BITS(obj_tptr)>>8));
 500
 501             switch(lmp_obj_ctype) {
 502             case LMP_CTYPE_IPV4:
 503             case LMP_CTYPE_UNMD:
 504                 printf("\n\t    Local Interface ID: %s (0x%08x) \
 505                         \n\t    Remote Interface ID: %s (0x%08x)",
 506                        ipaddr_string(obj_tptr+4),
 507                        EXTRACT_32BITS(obj_tptr+4),
 508                        ipaddr_string(obj_tptr+8),
 509                        EXTRACT_32BITS(obj_tptr+8));
 510
 511                 /* FIXME: Missing Data link Subobjects decoder */
 512
 513                 break;
 514 #ifdef INET6
 515             case LMP_CTYPE_IPV6:
 516 #endif
 517             default:
 518                 hexdump=TRUE;
 519             }
 520             break;
 521
 522         case LMP_OBJ_VERIFY_BEGIN:
 523             switch(lmp_obj_ctype) {
 524             case LMP_CTYPE_1:
 525                 printf("\n\t    Flags: %s",
 526                 bittok2str(lmp_obj_begin_verify_flag_values,
 527                         "none",
 528                         EXTRACT_16BITS(obj_tptr)));
 529                 printf("\n\t    Verify Interval: %u",
 530                         EXTRACT_16BITS(obj_tptr+2));
 531                 printf("\n\t    Data links: %u",
 532                         EXTRACT_32BITS(obj_tptr+4));
 533                 printf("\n\t    Encoding type: %s",
 534                         tok2str(gmpls_encoding_values, "Unknown", *(obj_tptr+8)));
 535                 printf("\n\t    Verify Tranport Mechanism: %u (0x%x) %s",
 536                         EXTRACT_16BITS(obj_tptr+10),
 537                         EXTRACT_16BITS(obj_tptr+10),
 538                         EXTRACT_16BITS(obj_tptr+10)&8000 ? "(Payload test messages capable)" : "");
 539                 printf("\n\t    Transmission Rate: (0x%x)",
 540                         EXTRACT_32BITS(obj_tptr+12));
 541                 printf("\n\t    Wavelength: %u",
 542                         EXTRACT_32BITS(obj_tptr+16));
 543                 break;
 544
 545             default:
 546                 hexdump=TRUE;
 547             }
 548             break;
 549
 550         case LMP_OBJ_VERIFY_BEGIN_ACK:
 551             switch(lmp_obj_ctype) {
 552             case LMP_CTYPE_1:
 553                 printf("\n\t    Verify Dead Interval: %u        \
 554                         \n\t    Verify Transport Response: %u",
 555                        EXTRACT_16BITS(obj_tptr),
 556                        EXTRACT_16BITS(obj_tptr+2));
 557                 break;
 558
 559             default:
 560                 hexdump=TRUE;
 561             }
 562             break;
 563
 564         case LMP_OBJ_VERIFY_ID:
 565             switch(lmp_obj_ctype) {
 566             case LMP_CTYPE_1:
 567                 printf("\n\t    Verify ID: %u",
 568                        EXTRACT_32BITS(obj_tptr));
 569                 break;
 570
 571             default:
 572                 hexdump=TRUE;
 573             }
 574             break;
 575
 576         case LMP_OBJ_CHANNEL_STATUS:
 577             switch(lmp_obj_ctype) {
 578             case LMP_CTYPE_IPV4:
 579             case LMP_CTYPE_UNMD:
 580                 offset = 0;
 581                 /* Decode pairs: <Interface_ID (4 bytes), Channel_status (4 bytes)> */
 582                 while (offset < (lmp_obj_len-(int)sizeof(struct lmp_object_header)) ) {
 583                         printf("\n\t    Interface ID: %s (0x%08x)",
 584                         ipaddr_string(obj_tptr+offset),
 585                         EXTRACT_32BITS(obj_tptr+offset));
 586
 587                         printf("\n\t\t    Active: %s (%u)",             (EXTRACT_32BITS(obj_tptr+offset+4)>>31) ?
 588                                                 "Allocated" : "Non-allocated",
 589                                 (EXTRACT_32BITS(obj_tptr+offset+4)>>31));
 590
 591                         printf("\n\t\t    Direction: %s (%u)", (EXTRACT_32BITS(obj_tptr+offset+4)>>30)&0x1 ?
 592                                                 "Transmit" : "Receive",
 593                                 (EXTRACT_32BITS(obj_tptr+offset+4)>>30)&0x1);
 594
 595                         printf("\n\t\t    Channel Status: %s (%u)",
 596                                         tok2str(lmp_obj_channel_status_values,
 597                                         "Unknown",
 598                                         EXTRACT_32BITS(obj_tptr+offset+4)&0x3FFFFFF),
 599                         EXTRACT_32BITS(obj_tptr+offset+4)&0x3FFFFFF);
 600                         offset+=8;
 601                 }
 602                 break;
 603 #ifdef INET6
 604             case LMP_CTYPE_IPV6:
 605 #endif
 606             default:
 607                 hexdump=TRUE;
 608             }
 609             break;
 610
 611         case LMP_OBJ_CHANNEL_STATUS_REQ:
 612             switch(lmp_obj_ctype) {
 613             case LMP_CTYPE_IPV4:
 614             case LMP_CTYPE_UNMD:
 615                 offset = 0;
 616                 while (offset < (lmp_obj_len-(int)sizeof(struct lmp_object_header)) ) {
 617                         printf("\n\t    Interface ID: %s (0x%08x)",
 618                         ipaddr_string(obj_tptr+offset),
 619                         EXTRACT_32BITS(obj_tptr+offset));
 620                         offset+=4;
 621                 }
 622                 break;
 623 #ifdef INET6
 624             case LMP_CTYPE_IPV6:
 625 #endif
 626             default:
 627                 hexdump=TRUE;
 628             }
 629             break;
 630
 631         case LMP_OBJ_ERROR_CODE:
 632             switch(lmp_obj_ctype) {
 633             case LMP_CTYPE_BEGIN_VERIFY_ERROR:
 634                 printf("\n\t    Error Code: %s",
 635                 bittok2str(lmp_obj_begin_verify_error_values,
 636                         "none",
 637                         EXTRACT_32BITS(obj_tptr)));
 638                 break;
 639
 640             case LMP_CTYPE_LINK_SUMMARY_ERROR:
 641                 printf("\n\t    Error Code: %s",
 642                 bittok2str(lmp_obj_link_summary_error_values,
 643                         "none",
 644                         EXTRACT_32BITS(obj_tptr)));
 645                 break;
 646             default:
 647                 hexdump=TRUE;
 648             }
 649             break;
 650
 651         default:
 652             if (vflag <= 1)
 653                 print_unknown_data(obj_tptr,"\n\t    ",obj_tlen);
 654             break;
 655         }
 656         /* do we want to see an additionally hexdump ? */
 657         if (vflag > 1 || hexdump==TRUE)
 658             print_unknown_data(tptr+sizeof(sizeof(struct lmp_object_header)),"\n\t    ",
 659                                lmp_obj_len-sizeof(struct lmp_object_header));
 660
 661         tptr+=lmp_obj_len;
 662         tlen-=lmp_obj_len;
 663     }
 664     return;
 665 trunc:
 666     printf("\n\t\t packet exceeded snapshot");
 667 }