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

   1 /*
   2  * Copyright (c) 1998-2007 The TCPDUMP project
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that: (1) source code
   6  * distributions retain the above copyright notice and this paragraph
   7  * in its entirety, and (2) distributions including binary code include
   8  * the above copyright notice and this paragraph in its entirety in
   9  * the documentation or other materials provided with the distribution.
  10  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND
  11  * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
  12  * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  13  * FOR A PARTICULAR PURPOSE.
  14  *
  15  * support for the IEEE Link Discovery Protocol as per 802.1ab
  16  *
  17  * Original code by Hannes Gredler (hannes@juniper.net)
  18  */
  19
  20 #ifndef lint
  21 static const char rcsid[] _U_ =
  22 "@(#) $Header: /tcpdump/master/tcpdump/print-lldp.c,v 1.2 2007-08-08 14:39:52 hannes Exp $";
  23 #endif
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <tcpdump-stdinc.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "interface.h"
  36 #include "extract.h"
  37 #include "addrtoname.h"
  38 #include "af.h"
  39 #include "oui.h"
  40
  41 #define LLDP_EXTRACT_TYPE(x) (((x)&0xfe00)>>9)
  42 #define LLDP_EXTRACT_LEN(x) ((x)&0x01ff)
  43
  44 /*
  45  * TLV type codes
  46  */
  47 #define LLDP_END_TLV             0
  48 #define LLDP_CHASSIS_ID_TLV      1
  49 #define LLDP_PORT_ID_TLV         2
  50 #define LLDP_TTL_TLV             3
  51 #define LLDP_PORT_DESCR_TLV      4
  52 #define LLDP_SYSTEM_NAME_TLV     5
  53 #define LLDP_SYSTEM_DESCR_TLV    6
  54 #define LLDP_SYSTEM_CAP_TLV      7
  55 #define LLDP_MGMT_ADDR_TLV       8
  56 #define LLDP_PRIVATE_TLV       127
  57
  58 static const struct tok lldp_tlv_values[] = {
  59     { LLDP_END_TLV, "End" },
  60     { LLDP_CHASSIS_ID_TLV, "Chassis ID" },
  61     { LLDP_PORT_ID_TLV, "Port ID" },
  62     { LLDP_TTL_TLV, "Time to Live" },
  63     { LLDP_PORT_DESCR_TLV, "Port Description" },
  64     { LLDP_SYSTEM_NAME_TLV, "System Name" },
  65     { LLDP_SYSTEM_DESCR_TLV, "System Description" },
  66     { LLDP_SYSTEM_CAP_TLV, "System Capabilities" },
  67     { LLDP_MGMT_ADDR_TLV, "Management Address" },
  68     { LLDP_PRIVATE_TLV, "Organization specific" },
  69     { 0, NULL}
  70 };
  71
  72 /*
  73  * Chassis ID subtypes
  74  */
  75 #define LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE  1
  76 #define LLDP_CHASSIS_INTF_ALIAS_SUBTYPE    2
  77 #define LLDP_CHASSIS_PORT_COMP_SUBTYPE     3
  78 #define LLDP_CHASSIS_MAC_ADDR_SUBTYPE      4
  79 #define LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE  5
  80 #define LLDP_CHASSIS_INTF_NAME_SUBTYPE     6
  81 #define LLDP_CHASSIS_LOCAL_SUBTYPE         7
  82
  83 static const struct tok lldp_chassis_subtype_values[] = {
  84     { LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE, "Chassis component"},
  85     { LLDP_CHASSIS_INTF_ALIAS_SUBTYPE, "Interface alias"},
  86     { LLDP_CHASSIS_PORT_COMP_SUBTYPE, "Port component"},
  87     { LLDP_CHASSIS_MAC_ADDR_SUBTYPE, "MAC address"},
  88     { LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE, "Network address"},
  89     { LLDP_CHASSIS_INTF_NAME_SUBTYPE, "Interface name"},
  90     { LLDP_CHASSIS_LOCAL_SUBTYPE, "Local"},
  91     { 0, NULL}
  92 };
  93
  94 /*
  95  * Port ID subtypes
  96  */
  97 #define LLDP_PORT_INTF_ALIAS_SUBTYPE       1
  98 #define LLDP_PORT_PORT_COMP_SUBTYPE        2
  99 #define LLDP_PORT_MAC_ADDR_SUBTYPE         3
 100 #define LLDP_PORT_NETWORK_ADDR_SUBTYPE     4
 101 #define LLDP_PORT_INTF_NAME_SUBTYPE        5
 102 #define LLDP_PORT_AGENT_CIRC_ID_SUBTYPE    6
 103 #define LLDP_PORT_LOCAL_SUBTYPE            7
 104
 105 static const struct tok lldp_port_subtype_values[] = {
 106     { LLDP_PORT_INTF_ALIAS_SUBTYPE, "Interface alias"},
 107     { LLDP_PORT_PORT_COMP_SUBTYPE, "Port component"},
 108     { LLDP_PORT_MAC_ADDR_SUBTYPE, "MAC address"},
 109     { LLDP_PORT_NETWORK_ADDR_SUBTYPE, "Network Address"},
 110     { LLDP_PORT_INTF_NAME_SUBTYPE, "Interface Name"},
 111     { LLDP_PORT_AGENT_CIRC_ID_SUBTYPE, "Agent circuit ID"},
 112     { LLDP_PORT_LOCAL_SUBTYPE, "Local"},
 113     { 0, NULL}
 114 };
 115
 116 /*
 117  * System Capabilities
 118  */
 119 #define LLDP_CAP_OTHER               1 <<  0
 120 #define LLDP_CAP_REPEATER            1 <<  1
 121 #define LLDP_CAP_BRIDGE              1 <<  2
 122 #define LLDP_CAP_WLAN_AP             1 <<  3
 123 #define LLDP_CAP_ROUTER              1 <<  4
 124 #define LLDP_CAP_PHONE               1 <<  5
 125 #define LLDP_CAP_DOCSIS              1 <<  6
 126 #define LLDP_CAP_STATION_ONLY        1 <<  7
 127
 128 static const struct tok lldp_cap_values[] = {
 129     { LLDP_CAP_OTHER, "Other"},
 130     { LLDP_CAP_REPEATER, "Repeater"},
 131     { LLDP_CAP_BRIDGE, "Bridge"},
 132     { LLDP_CAP_WLAN_AP, "WLAN AP"},
 133     { LLDP_CAP_ROUTER, "Router"},
 134     { LLDP_CAP_PHONE, "Telephone"},
 135     { LLDP_CAP_DOCSIS, "Docsis"},
 136     { LLDP_CAP_STATION_ONLY, "Station Only"},
 137     { 0, NULL}
 138 };
 139
 140 /*
 141  * Interface numbering subtypes.
 142  */
 143 #define LLDP_INTF_NUMB_IFX_SUBTYPE         2
 144 #define LLDP_INTF_NUMB_SYSPORT_SUBTYPE     3
 145
 146 static const struct tok lldp_intf_numb_subtype_values[] = {
 147     { LLDP_INTF_NUMB_IFX_SUBTYPE, "Interface Index" },
 148     { LLDP_INTF_NUMB_SYSPORT_SUBTYPE, "System Port Number" },
 149     { 0, NULL}
 150 };
 151
 152
 153 static char *
 154 lldp_network_addr_print(const u_char *tptr) {
 155
 156     u_int8_t af;
 157     static char buf[BUFSIZE];
 158     const char * (*pfunc)(const u_char *);
 159
 160     af = *(tptr);
 161     switch (af) {
 162     case AFNUM_INET:
 163         pfunc = getname;
 164         break;
 165 #ifdef INET6
 166     case AFNUM_INET6:
 167         pfunc = getname6;
 168         break;
 169 #endif
 170     case AFNUM_802:
 171         pfunc = etheraddr_string;
 172         break;
 173     default:
 174         pfunc = NULL;
 175         break;
 176     }
 177
 178     if (!pfunc) {
 179         snprintf(buf, sizeof(buf), "AFI %s (%u) XXX",
 180                  tok2str(af_values, "Unknown", af), af);
 181     } else {
 182         snprintf(buf, sizeof(buf), "AFI %s (%u): %s",
 183                  tok2str(af_values, "Unknown", af), af, (*pfunc)(tptr+1));
 184     }
 185
 186     return buf;
 187 }
 188
 189 static int
 190 lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len)  {
 191
 192     u_int8_t mgmt_addr_len, intf_num_subtype, oid_len;
 193     const u_char *tptr;
 194     u_int tlen;
 195
 196     tlen = len;
 197     tptr = pptr;
 198
 199     mgmt_addr_len = *tptr++;
 200     tlen--;
 201
 202     if (tlen < mgmt_addr_len) {
 203         return 0;
 204     }
 205
 206     printf("\n\t  Management Address length %u, %s",
 207            mgmt_addr_len,
 208            lldp_network_addr_print(tptr));
 209     tptr += mgmt_addr_len;
 210     tlen -= mgmt_addr_len;
 211
 212     if (tlen < 5) {
 213         return 0;
 214     }
 215
 216     intf_num_subtype = *tptr;
 217     printf("\n\t  %s Interface Numbering (%u): %u",
 218            tok2str(lldp_intf_numb_subtype_values, "Unknown", intf_num_subtype),
 219            intf_num_subtype,
 220            EXTRACT_32BITS(tptr+1));
 221     tptr += 5;
 222     tlen -= 5;
 223
 224     /*
 225      * The OID is optional.
 226      */
 227     if (tlen) {
 228         oid_len = *tptr;
 229
 230         if (oid_len) {
 231             printf("\n\t  OID length %u", oid_len);
 232             safeputs((const char *)tptr+1, oid_len);
 233         }
 234     }
 235
 236     return 1;
 237 }
 238
 239 void
 240 lldp_print(register const u_char *pptr, register u_int len) {
 241
 242     u_int8_t subtype;
 243     u_int16_t tlv, cap, ena_cap;
 244     u_int oui, tlen, hexdump, tlv_type, tlv_len;
 245     const u_char *tptr;
 246
 247     tptr = pptr;
 248     tlen = len;
 249
 250     if (vflag) {
 251         printf("LLDP, length %u", len);
 252     }
 253
 254     while (tlen >= sizeof(tlv)) {
 255
 256         TCHECK2(*tptr, sizeof(tlv));
 257
 258         tlv = EXTRACT_16BITS(tptr);
 259
 260         tlv_type = LLDP_EXTRACT_TYPE(tlv);
 261         tlv_len = LLDP_EXTRACT_LEN(tlv);
 262         hexdump = FALSE;
 263
 264         tlen -= sizeof(tlv);
 265         tptr += sizeof(tlv);
 266
 267         if (vflag) {
 268             printf("\n\t%s TLV (%u), length %u",
 269                    tok2str(lldp_tlv_values, "Unknown", tlv_type),
 270                    tlv_type, tlv_len);
 271         }
 272
 273         /* infinite loop check */
 274         if (!tlv_type || !tlv_len) {
 275             break;
 276         }
 277
 278         TCHECK2(*tptr, tlv_len);
 279
 280         switch (tlv_type) {
 281         case LLDP_TTL_TLV:
 282             if (vflag) {
 283                 printf(": TTL %us", EXTRACT_16BITS(tptr));
 284             }
 285             break;
 286
 287         case LLDP_SYSTEM_NAME_TLV:
 288
 289             /*
 290              * The system name is also print in non-verbose mode
 291              * similar to the CDP printer.
 292              */
 293             if (vflag) {
 294                 printf(": ");
 295                 safeputs((const char *)tptr, tlv_len);
 296             } else {
 297                 printf("LLDP, name ");
 298                 safeputs((const char *)tptr, tlv_len);
 299                 printf(", length %u", len);
 300             }
 301             break;
 302
 303         case LLDP_PORT_DESCR_TLV:
 304             if (vflag) {
 305                 printf(": ");
 306                 safeputs((const char *)tptr, tlv_len);
 307             }
 308             break;
 309
 310         case LLDP_SYSTEM_DESCR_TLV:
 311             if (vflag) {
 312                 printf("\n\t  ");
 313                 safeputs((const char *)tptr, tlv_len);
 314             }
 315             break;
 316
 317
 318         case LLDP_CHASSIS_ID_TLV:
 319             if (vflag) {
 320                 subtype = *tptr;
 321                 printf("\n\t  Subtype %s (%u): ",
 322                        tok2str(lldp_chassis_subtype_values, "Unknown", subtype),
 323                        subtype);
 324
 325                 switch (subtype) {
 326                 case LLDP_CHASSIS_MAC_ADDR_SUBTYPE:
 327                     printf("%s", etheraddr_string(tptr+1));
 328                     break;
 329
 330                 case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */
 331                 case LLDP_CHASSIS_LOCAL_SUBTYPE:
 332                 case LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE:
 333                 case LLDP_CHASSIS_INTF_ALIAS_SUBTYPE:
 334                 case LLDP_CHASSIS_PORT_COMP_SUBTYPE:
 335                     safeputs((const char *)tptr+1, tlv_len-1);
 336                     break;
 337
 338                 case LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE:
 339                     printf("%s", lldp_network_addr_print(tptr+1));
 340                     break;
 341
 342                 default:
 343                     hexdump = TRUE;
 344                     break;
 345                 }
 346             }
 347             break;
 348
 349         case LLDP_PORT_ID_TLV:
 350             if (vflag) {
 351                 subtype = *tptr;
 352                 printf("\n\t  Subtype %s (%u): ",
 353                        tok2str(lldp_port_subtype_values, "Unknown", subtype),
 354                        subtype);
 355
 356                 switch (subtype) {
 357                 case LLDP_PORT_MAC_ADDR_SUBTYPE:
 358                     printf("%s", etheraddr_string(tptr+1));
 359                     break;
 360
 361                 case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */
 362                 case LLDP_PORT_LOCAL_SUBTYPE:
 363                 case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE:
 364                 case LLDP_PORT_INTF_ALIAS_SUBTYPE:
 365                 case LLDP_PORT_PORT_COMP_SUBTYPE:
 366                     safeputs((const char *)tptr+1, tlv_len-1);
 367                     break;
 368
 369                 case LLDP_PORT_NETWORK_ADDR_SUBTYPE:
 370                     printf("%s", lldp_network_addr_print(tptr+1));
 371                     break;
 372
 373                 default:
 374                     hexdump = TRUE;
 375                     break;
 376                 }
 377             }
 378             break;
 379
 380         case LLDP_PRIVATE_TLV:
 381             if (vflag) {
 382
 383                 oui = EXTRACT_24BITS(tptr);
 384                 printf(": OUI %s (0x%06x)", tok2str(oui_values, "Unknown", oui), oui);
 385                 hexdump = TRUE;
 386             }
 387             break;
 388
 389         case LLDP_SYSTEM_CAP_TLV:
 390             if (vflag) {
 391                 cap = EXTRACT_16BITS(tptr);
 392                 ena_cap = EXTRACT_16BITS(tptr+2);
 393                 printf("\n\t  System  Capabilities [%s] (0x%04x)",
 394                        bittok2str(lldp_cap_values, "none", cap), cap);
 395                 printf("\n\t  Enabled Capabilities [%s] (0x%04x)",
 396                        bittok2str(lldp_cap_values, "none", ena_cap), ena_cap);
 397             }
 398             break;
 399
 400         case LLDP_MGMT_ADDR_TLV:
 401             if (vflag) {
 402                 if (!lldp_mgmt_addr_tlv_print(tptr, tlen)) {
 403                     goto trunc;
 404                 }
 405             }
 406             break;
 407
 408         default:
 409             hexdump = TRUE;
 410             break;
 411         }
 412
 413         /* do we also want to see a hex dump ? */
 414         if (vflag > 1 || (vflag && hexdump)) {
 415             print_unknown_data(tptr,"\n\t  ", tlv_len);
 416         }
 417
 418         tlen -= tlv_len;
 419         tptr += tlv_len;
 420     }
 421     return;
 422  trunc:
 423     printf("\n\t[|LLDP]");
 424 }
 425
 426 /*
 427  * Local Variables:
 428  * c-style: whitesmith
 429  * c-basic-offset: 4
 430  * End:
 431  */