print-lldp.c revision 190207
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 * IEEE and TIA extensions by Carles Kishimoto <carles.kishimoto@gmail.com> 19 */ 20 21#ifndef lint 22static const char rcsid[] _U_ = 23"@(#) $Header: /tcpdump/master/tcpdump/print-lldp.c,v 1.7.2.3 2008-03-20 09:33:52 hannes Exp $"; 24#endif 25 26#ifdef HAVE_CONFIG_H 27#include "config.h" 28#endif 29 30#include <tcpdump-stdinc.h> 31 32#include <stdio.h> 33#include <stdlib.h> 34#include <string.h> 35 36#include "interface.h" 37#include "extract.h" 38#include "addrtoname.h" 39#include "af.h" 40#include "oui.h" 41 42#define LLDP_EXTRACT_TYPE(x) (((x)&0xfe00)>>9) 43#define LLDP_EXTRACT_LEN(x) ((x)&0x01ff) 44 45/* 46 * TLV type codes 47 */ 48#define LLDP_END_TLV 0 49#define LLDP_CHASSIS_ID_TLV 1 50#define LLDP_PORT_ID_TLV 2 51#define LLDP_TTL_TLV 3 52#define LLDP_PORT_DESCR_TLV 4 53#define LLDP_SYSTEM_NAME_TLV 5 54#define LLDP_SYSTEM_DESCR_TLV 6 55#define LLDP_SYSTEM_CAP_TLV 7 56#define LLDP_MGMT_ADDR_TLV 8 57#define LLDP_PRIVATE_TLV 127 58 59static const struct tok lldp_tlv_values[] = { 60 { LLDP_END_TLV, "End" }, 61 { LLDP_CHASSIS_ID_TLV, "Chassis ID" }, 62 { LLDP_PORT_ID_TLV, "Port ID" }, 63 { LLDP_TTL_TLV, "Time to Live" }, 64 { LLDP_PORT_DESCR_TLV, "Port Description" }, 65 { LLDP_SYSTEM_NAME_TLV, "System Name" }, 66 { LLDP_SYSTEM_DESCR_TLV, "System Description" }, 67 { LLDP_SYSTEM_CAP_TLV, "System Capabilities" }, 68 { LLDP_MGMT_ADDR_TLV, "Management Address" }, 69 { LLDP_PRIVATE_TLV, "Organization specific" }, 70 { 0, NULL} 71}; 72 73/* 74 * Chassis ID subtypes 75 */ 76#define LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE 1 77#define LLDP_CHASSIS_INTF_ALIAS_SUBTYPE 2 78#define LLDP_CHASSIS_PORT_COMP_SUBTYPE 3 79#define LLDP_CHASSIS_MAC_ADDR_SUBTYPE 4 80#define LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE 5 81#define LLDP_CHASSIS_INTF_NAME_SUBTYPE 6 82#define LLDP_CHASSIS_LOCAL_SUBTYPE 7 83 84static const struct tok lldp_chassis_subtype_values[] = { 85 { LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE, "Chassis component"}, 86 { LLDP_CHASSIS_INTF_ALIAS_SUBTYPE, "Interface alias"}, 87 { LLDP_CHASSIS_PORT_COMP_SUBTYPE, "Port component"}, 88 { LLDP_CHASSIS_MAC_ADDR_SUBTYPE, "MAC address"}, 89 { LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE, "Network address"}, 90 { LLDP_CHASSIS_INTF_NAME_SUBTYPE, "Interface name"}, 91 { LLDP_CHASSIS_LOCAL_SUBTYPE, "Local"}, 92 { 0, NULL} 93}; 94 95/* 96 * Port ID subtypes 97 */ 98#define LLDP_PORT_INTF_ALIAS_SUBTYPE 1 99#define LLDP_PORT_PORT_COMP_SUBTYPE 2 100#define LLDP_PORT_MAC_ADDR_SUBTYPE 3 101#define LLDP_PORT_NETWORK_ADDR_SUBTYPE 4 102#define LLDP_PORT_INTF_NAME_SUBTYPE 5 103#define LLDP_PORT_AGENT_CIRC_ID_SUBTYPE 6 104#define LLDP_PORT_LOCAL_SUBTYPE 7 105 106static const struct tok lldp_port_subtype_values[] = { 107 { LLDP_PORT_INTF_ALIAS_SUBTYPE, "Interface alias"}, 108 { LLDP_PORT_PORT_COMP_SUBTYPE, "Port component"}, 109 { LLDP_PORT_MAC_ADDR_SUBTYPE, "MAC address"}, 110 { LLDP_PORT_NETWORK_ADDR_SUBTYPE, "Network Address"}, 111 { LLDP_PORT_INTF_NAME_SUBTYPE, "Interface Name"}, 112 { LLDP_PORT_AGENT_CIRC_ID_SUBTYPE, "Agent circuit ID"}, 113 { LLDP_PORT_LOCAL_SUBTYPE, "Local"}, 114 { 0, NULL} 115}; 116 117/* 118 * System Capabilities 119 */ 120#define LLDP_CAP_OTHER (1 << 0) 121#define LLDP_CAP_REPEATER (1 << 1) 122#define LLDP_CAP_BRIDGE (1 << 2) 123#define LLDP_CAP_WLAN_AP (1 << 3) 124#define LLDP_CAP_ROUTER (1 << 4) 125#define LLDP_CAP_PHONE (1 << 5) 126#define LLDP_CAP_DOCSIS (1 << 6) 127#define LLDP_CAP_STATION_ONLY (1 << 7) 128 129static const struct tok lldp_cap_values[] = { 130 { LLDP_CAP_OTHER, "Other"}, 131 { LLDP_CAP_REPEATER, "Repeater"}, 132 { LLDP_CAP_BRIDGE, "Bridge"}, 133 { LLDP_CAP_WLAN_AP, "WLAN AP"}, 134 { LLDP_CAP_ROUTER, "Router"}, 135 { LLDP_CAP_PHONE, "Telephone"}, 136 { LLDP_CAP_DOCSIS, "Docsis"}, 137 { LLDP_CAP_STATION_ONLY, "Station Only"}, 138 { 0, NULL} 139}; 140 141#define LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID 1 142#define LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID 2 143#define LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME 3 144#define LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY 4 145 146static const struct tok lldp_8021_subtype_values[] = { 147 { LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID, "Port VLAN Id"}, 148 { LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID, "Port and Protocol VLAN ID"}, 149 { LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME, "VLAN name"}, 150 { LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY, "Protocol Identity"}, 151 { 0, NULL} 152}; 153 154#define LLDP_8021_PORT_PROTOCOL_VLAN_SUPPORT (1 << 1) 155#define LLDP_8021_PORT_PROTOCOL_VLAN_STATUS (1 << 2) 156 157static const struct tok lldp_8021_port_protocol_id_values[] = { 158 { LLDP_8021_PORT_PROTOCOL_VLAN_SUPPORT, "supported"}, 159 { LLDP_8021_PORT_PROTOCOL_VLAN_STATUS, "enabled"}, 160 { 0, NULL} 161}; 162 163#define LLDP_PRIVATE_8023_SUBTYPE_MACPHY 1 164#define LLDP_PRIVATE_8023_SUBTYPE_MDIPOWER 2 165#define LLDP_PRIVATE_8023_SUBTYPE_LINKAGGR 3 166#define LLDP_PRIVATE_8023_SUBTYPE_MTU 4 167 168static const struct tok lldp_8023_subtype_values[] = { 169 { LLDP_PRIVATE_8023_SUBTYPE_MACPHY, "MAC/PHY configuration/status"}, 170 { LLDP_PRIVATE_8023_SUBTYPE_MDIPOWER, "Power via MDI"}, 171 { LLDP_PRIVATE_8023_SUBTYPE_LINKAGGR, "Link aggregation"}, 172 { LLDP_PRIVATE_8023_SUBTYPE_MTU, "Max frame size"}, 173 { 0, NULL} 174}; 175 176#define LLDP_PRIVATE_TIA_SUBTYPE_CAPABILITIES 1 177#define LLDP_PRIVATE_TIA_SUBTYPE_NETWORK_POLICY 2 178#define LLDP_PRIVATE_TIA_SUBTYPE_LOCAL_ID 3 179#define LLDP_PRIVATE_TIA_SUBTYPE_EXTENDED_POWER_MDI 4 180#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_HARDWARE_REV 5 181#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_FIRMWARE_REV 6 182#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SOFTWARE_REV 7 183#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SERIAL_NUMBER 8 184#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME 9 185#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME 10 186#define LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID 11 187 188static const struct tok lldp_tia_subtype_values[] = { 189 { LLDP_PRIVATE_TIA_SUBTYPE_CAPABILITIES, "LLDP-MED Capabilities" }, 190 { LLDP_PRIVATE_TIA_SUBTYPE_NETWORK_POLICY, "Network policy" }, 191 { LLDP_PRIVATE_TIA_SUBTYPE_LOCAL_ID, "Location identification" }, 192 { LLDP_PRIVATE_TIA_SUBTYPE_EXTENDED_POWER_MDI, "Extended power-via-MDI" }, 193 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_HARDWARE_REV, "Inventory - hardware revision" }, 194 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_FIRMWARE_REV, "Inventory - firmware revision" }, 195 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SOFTWARE_REV, "Inventory - software revision" }, 196 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SERIAL_NUMBER, "Inventory - serial number" }, 197 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME, "Inventory - manufacturer name" }, 198 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME, "Inventory - model name" }, 199 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID, "Inventory - asset ID" }, 200 { 0, NULL} 201}; 202 203#define LLDP_PRIVATE_TIA_LOCATION_ALTITUDE_METERS 1 204#define LLDP_PRIVATE_TIA_LOCATION_ALTITUDE_FLOORS 2 205 206static const struct tok lldp_tia_location_altitude_type_values[] = { 207 { LLDP_PRIVATE_TIA_LOCATION_ALTITUDE_METERS, "meters"}, 208 { LLDP_PRIVATE_TIA_LOCATION_ALTITUDE_FLOORS, "floors"}, 209 { 0, NULL} 210}; 211 212/* ANSI/TIA-1057 - Annex B */ 213#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A1 1 214#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A2 2 215#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A3 3 216#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A4 4 217#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A5 5 218#define LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A6 6 219 220static const struct tok lldp_tia_location_lci_catype_values[] = { 221 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A1, "national subdivisions (state,canton,region,province,prefecture)"}, 222 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A2, "county, parish, gun, district"}, 223 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A3, "city, township, shi"}, 224 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A4, "city division, borough, city district, ward chou"}, 225 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A5, "neighborhood, block"}, 226 { LLDP_PRIVATE_TIA_LOCATION_LCI_CATYPE_A6, "street"}, 227 { 0, NULL} 228}; 229 230static const struct tok lldp_tia_location_lci_what_values[] = { 231 { 0, "location of DHCP server"}, 232 { 1, "location of the network element believed to be closest to the client"}, 233 { 2, "location of the client"}, 234 { 0, NULL} 235}; 236 237/* 238 * From RFC 3636 - dot3MauType 239 */ 240#define LLDP_MAU_TYPE_UNKNOWN 0 241#define LLDP_MAU_TYPE_AUI 1 242#define LLDP_MAU_TYPE_10BASE_5 2 243#define LLDP_MAU_TYPE_FOIRL 3 244#define LLDP_MAU_TYPE_10BASE_2 4 245#define LLDP_MAU_TYPE_10BASE_T 5 246#define LLDP_MAU_TYPE_10BASE_FP 6 247#define LLDP_MAU_TYPE_10BASE_FB 7 248#define LLDP_MAU_TYPE_10BASE_FL 8 249#define LLDP_MAU_TYPE_10BROAD36 9 250#define LLDP_MAU_TYPE_10BASE_T_HD 10 251#define LLDP_MAU_TYPE_10BASE_T_FD 11 252#define LLDP_MAU_TYPE_10BASE_FL_HD 12 253#define LLDP_MAU_TYPE_10BASE_FL_FD 13 254#define LLDP_MAU_TYPE_100BASE_T4 14 255#define LLDP_MAU_TYPE_100BASE_TX_HD 15 256#define LLDP_MAU_TYPE_100BASE_TX_FD 16 257#define LLDP_MAU_TYPE_100BASE_FX_HD 17 258#define LLDP_MAU_TYPE_100BASE_FX_FD 18 259#define LLDP_MAU_TYPE_100BASE_T2_HD 19 260#define LLDP_MAU_TYPE_100BASE_T2_FD 20 261#define LLDP_MAU_TYPE_1000BASE_X_HD 21 262#define LLDP_MAU_TYPE_1000BASE_X_FD 22 263#define LLDP_MAU_TYPE_1000BASE_LX_HD 23 264#define LLDP_MAU_TYPE_1000BASE_LX_FD 24 265#define LLDP_MAU_TYPE_1000BASE_SX_HD 25 266#define LLDP_MAU_TYPE_1000BASE_SX_FD 26 267#define LLDP_MAU_TYPE_1000BASE_CX_HD 27 268#define LLDP_MAU_TYPE_1000BASE_CX_FD 28 269#define LLDP_MAU_TYPE_1000BASE_T_HD 29 270#define LLDP_MAU_TYPE_1000BASE_T_FD 30 271#define LLDP_MAU_TYPE_10GBASE_X 31 272#define LLDP_MAU_TYPE_10GBASE_LX4 32 273#define LLDP_MAU_TYPE_10GBASE_R 33 274#define LLDP_MAU_TYPE_10GBASE_ER 34 275#define LLDP_MAU_TYPE_10GBASE_LR 35 276#define LLDP_MAU_TYPE_10GBASE_SR 36 277#define LLDP_MAU_TYPE_10GBASE_W 37 278#define LLDP_MAU_TYPE_10GBASE_EW 38 279#define LLDP_MAU_TYPE_10GBASE_LW 39 280#define LLDP_MAU_TYPE_10GBASE_SW 40 281 282static const struct tok lldp_mau_types_values[] = { 283 { LLDP_MAU_TYPE_UNKNOWN, "Unknown"}, 284 { LLDP_MAU_TYPE_AUI, "AUI"}, 285 { LLDP_MAU_TYPE_10BASE_5, "10BASE_5"}, 286 { LLDP_MAU_TYPE_FOIRL, "FOIRL"}, 287 { LLDP_MAU_TYPE_10BASE_2, "10BASE2"}, 288 { LLDP_MAU_TYPE_10BASE_T, "10BASET duplex mode unknown"}, 289 { LLDP_MAU_TYPE_10BASE_FP, "10BASEFP"}, 290 { LLDP_MAU_TYPE_10BASE_FB, "10BASEFB"}, 291 { LLDP_MAU_TYPE_10BASE_FL, "10BASEFL duplex mode unknown"}, 292 { LLDP_MAU_TYPE_10BROAD36, "10BROAD36"}, 293 { LLDP_MAU_TYPE_10BASE_T_HD, "10BASET hdx"}, 294 { LLDP_MAU_TYPE_10BASE_T_FD, "10BASET fdx"}, 295 { LLDP_MAU_TYPE_10BASE_FL_HD, "10BASEFL hdx"}, 296 { LLDP_MAU_TYPE_10BASE_FL_FD, "10BASEFL fdx"}, 297 { LLDP_MAU_TYPE_100BASE_T4, "100BASET4"}, 298 { LLDP_MAU_TYPE_100BASE_TX_HD, "100BASETX hdx"}, 299 { LLDP_MAU_TYPE_100BASE_TX_FD, "100BASETX fdx"}, 300 { LLDP_MAU_TYPE_100BASE_FX_HD, "100BASEFX hdx"}, 301 { LLDP_MAU_TYPE_100BASE_FX_FD, "100BASEFX fdx"}, 302 { LLDP_MAU_TYPE_100BASE_T2_HD, "100BASET2 hdx"}, 303 { LLDP_MAU_TYPE_100BASE_T2_FD, "100BASET2 fdx"}, 304 { LLDP_MAU_TYPE_1000BASE_X_HD, "1000BASEX hdx"}, 305 { LLDP_MAU_TYPE_1000BASE_X_FD, "1000BASEX fdx"}, 306 { LLDP_MAU_TYPE_1000BASE_LX_HD, "1000BASELX hdx"}, 307 { LLDP_MAU_TYPE_1000BASE_LX_FD, "1000BASELX fdx"}, 308 { LLDP_MAU_TYPE_1000BASE_SX_HD, "1000BASESX hdx"}, 309 { LLDP_MAU_TYPE_1000BASE_SX_FD, "1000BASESX fdx"}, 310 { LLDP_MAU_TYPE_1000BASE_CX_HD, "1000BASECX hdx"}, 311 { LLDP_MAU_TYPE_1000BASE_CX_FD, "1000BASECX fdx"}, 312 { LLDP_MAU_TYPE_1000BASE_T_HD, "1000BASET hdx"}, 313 { LLDP_MAU_TYPE_1000BASE_T_FD, "1000BASET fdx"}, 314 { LLDP_MAU_TYPE_10GBASE_X, "10GBASEX"}, 315 { LLDP_MAU_TYPE_10GBASE_LX4, "10GBASELX4"}, 316 { LLDP_MAU_TYPE_10GBASE_R, "10GBASER"}, 317 { LLDP_MAU_TYPE_10GBASE_ER, "10GBASEER"}, 318 { LLDP_MAU_TYPE_10GBASE_LR, "10GBASELR"}, 319 { LLDP_MAU_TYPE_10GBASE_SR, "10GBASESR"}, 320 { LLDP_MAU_TYPE_10GBASE_W, "10GBASEW"}, 321 { LLDP_MAU_TYPE_10GBASE_EW, "10GBASEEW"}, 322 { LLDP_MAU_TYPE_10GBASE_LW, "10GBASELW"}, 323 { LLDP_MAU_TYPE_10GBASE_SW, "10GBASESW"}, 324 { 0, NULL} 325}; 326 327#define LLDP_8023_AUTONEGOTIATION_SUPPORT (1 << 0) 328#define LLDP_8023_AUTONEGOTIATION_STATUS (1 << 1) 329 330static const struct tok lldp_8023_autonegotiation_values[] = { 331 { LLDP_8023_AUTONEGOTIATION_SUPPORT, "supported"}, 332 { LLDP_8023_AUTONEGOTIATION_STATUS, "enabled"}, 333 { 0, NULL} 334}; 335 336#define LLDP_TIA_CAPABILITY_MED (1 << 0) 337#define LLDP_TIA_CAPABILITY_NETWORK_POLICY (1 << 1) 338#define LLDP_TIA_CAPABILITY_LOCATION_IDENTIFICATION (1 << 2) 339#define LLDP_TIA_CAPABILITY_EXTENDED_POWER_MDI_PSE (1 << 3) 340#define LLDP_TIA_CAPABILITY_EXTENDED_POWER_MDI_PD (1 << 4) 341#define LLDP_TIA_CAPABILITY_INVENTORY (1 << 5) 342 343static const struct tok lldp_tia_capabilities_values[] = { 344 { LLDP_TIA_CAPABILITY_MED, "LLDP-MED capabilities"}, 345 { LLDP_TIA_CAPABILITY_NETWORK_POLICY, "network policy"}, 346 { LLDP_TIA_CAPABILITY_LOCATION_IDENTIFICATION, "location identification"}, 347 { LLDP_TIA_CAPABILITY_EXTENDED_POWER_MDI_PSE, "extended power via MDI-PSE"}, 348 { LLDP_TIA_CAPABILITY_EXTENDED_POWER_MDI_PD, "extended power via MDI-PD"}, 349 { LLDP_TIA_CAPABILITY_INVENTORY, "Inventory"}, 350 { 0, NULL} 351}; 352 353#define LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_1 1 354#define LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_2 2 355#define LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_3 3 356#define LLDP_TIA_DEVICE_TYPE_NETWORK_CONNECTIVITY 4 357 358static const struct tok lldp_tia_device_type_values[] = { 359 { LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_1, "endpoint class 1"}, 360 { LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_2, "endpoint class 2"}, 361 { LLDP_TIA_DEVICE_TYPE_ENDPOINT_CLASS_3, "endpoint class 3"}, 362 { LLDP_TIA_DEVICE_TYPE_NETWORK_CONNECTIVITY, "network connectivity"}, 363 { 0, NULL} 364}; 365 366#define LLDP_TIA_APPLICATION_TYPE_VOICE 1 367#define LLDP_TIA_APPLICATION_TYPE_VOICE_SIGNALING 2 368#define LLDP_TIA_APPLICATION_TYPE_GUEST_VOICE 3 369#define LLDP_TIA_APPLICATION_TYPE_GUEST_VOICE_SIGNALING 4 370#define LLDP_TIA_APPLICATION_TYPE_SOFTPHONE_VOICE 5 371#define LLDP_TIA_APPLICATION_TYPE_VIDEO_CONFERENCING 6 372#define LLDP_TIA_APPLICATION_TYPE_STREAMING_VIDEO 7 373#define LLDP_TIA_APPLICATION_TYPE_VIDEO_SIGNALING 8 374 375static const struct tok lldp_tia_application_type_values[] = { 376 { LLDP_TIA_APPLICATION_TYPE_VOICE, "voice"}, 377 { LLDP_TIA_APPLICATION_TYPE_VOICE_SIGNALING, "voice signaling"}, 378 { LLDP_TIA_APPLICATION_TYPE_GUEST_VOICE, "guest voice"}, 379 { LLDP_TIA_APPLICATION_TYPE_GUEST_VOICE_SIGNALING, "guest voice signaling"}, 380 { LLDP_TIA_APPLICATION_TYPE_SOFTPHONE_VOICE, "softphone voice"}, 381 { LLDP_TIA_APPLICATION_TYPE_VIDEO_CONFERENCING, "video conferencing"}, 382 { LLDP_TIA_APPLICATION_TYPE_STREAMING_VIDEO, "streaming video"}, 383 { LLDP_TIA_APPLICATION_TYPE_VIDEO_SIGNALING, "video signaling"}, 384 { 0, NULL} 385}; 386 387#define LLDP_TIA_NETWORK_POLICY_U_BIT (1 << 5) 388#define LLDP_TIA_NETWORK_POLICY_T_BIT (1 << 6) 389#define LLDP_TIA_NETWORK_POLICY_X_BIT (1 << 7) 390 391static const struct tok lldp_tia_network_policy_bits_values[] = { 392 { LLDP_TIA_NETWORK_POLICY_U_BIT, "Unknown"}, 393 { LLDP_TIA_NETWORK_POLICY_T_BIT, "Tagged"}, 394 { LLDP_TIA_NETWORK_POLICY_X_BIT, "reserved"}, 395 { 0, NULL} 396}; 397 398#define LLDP_EXTRACT_NETWORK_POLICY_VLAN(x) (((x)&0x1ffe)>>1) 399#define LLDP_EXTRACT_NETWORK_POLICY_L2_PRIORITY(x) (((x)&0x01ff)>>6) 400#define LLDP_EXTRACT_NETWORK_POLICY_DSCP(x) ((x)&0x003f) 401 402#define LLDP_TIA_LOCATION_DATA_FORMAT_COORDINATE_BASED 1 403#define LLDP_TIA_LOCATION_DATA_FORMAT_CIVIC_ADDRESS 2 404#define LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN 3 405 406static const struct tok lldp_tia_location_data_format_values[] = { 407 { LLDP_TIA_LOCATION_DATA_FORMAT_COORDINATE_BASED, "coordinate-based LCI"}, 408 { LLDP_TIA_LOCATION_DATA_FORMAT_CIVIC_ADDRESS, "civic address LCI"}, 409 { LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN, "ECS ELIN"}, 410 { 0, NULL} 411}; 412 413#define LLDP_TIA_LOCATION_DATUM_WGS_84 1 414#define LLDP_TIA_LOCATION_DATUM_NAD_83_NAVD_88 2 415#define LLDP_TIA_LOCATION_DATUM_NAD_83_MLLW 3 416 417static const struct tok lldp_tia_location_datum_type_values[] = { 418 { LLDP_TIA_LOCATION_DATUM_WGS_84, "World Geodesic System 1984"}, 419 { LLDP_TIA_LOCATION_DATUM_NAD_83_NAVD_88, "North American Datum 1983 (NAVD88)"}, 420 { LLDP_TIA_LOCATION_DATUM_NAD_83_MLLW, "North American Datum 1983 (MLLW)"}, 421 { 0, NULL} 422}; 423 424#define LLDP_TIA_POWER_SOURCE_PSE 1 425#define LLDP_TIA_POWER_SOURCE_LOCAL 2 426#define LLDP_TIA_POWER_SOURCE_PSE_AND_LOCAL 3 427 428static const struct tok lldp_tia_power_source_values[] = { 429 { LLDP_TIA_POWER_SOURCE_PSE, "PSE - primary power source"}, 430 { LLDP_TIA_POWER_SOURCE_LOCAL, "local - backup power source"}, 431 { LLDP_TIA_POWER_SOURCE_PSE_AND_LOCAL, "PSE+local - reserved"}, 432 { 0, NULL} 433}; 434 435#define LLDP_TIA_POWER_PRIORITY_CRITICAL 1 436#define LLDP_TIA_POWER_PRIORITY_HIGH 2 437#define LLDP_TIA_POWER_PRIORITY_LOW 3 438 439static const struct tok lldp_tia_power_priority_values[] = { 440 { LLDP_TIA_POWER_PRIORITY_CRITICAL, "critical"}, 441 { LLDP_TIA_POWER_PRIORITY_HIGH, "high"}, 442 { LLDP_TIA_POWER_PRIORITY_LOW, "low"}, 443 { 0, NULL} 444}; 445 446#define LLDP_TIA_POWER_VAL_MAX 1024 447 448static const struct tok lldp_tia_inventory_values[] = { 449 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_HARDWARE_REV, "Hardware revision" }, 450 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_FIRMWARE_REV, "Firmware revision" }, 451 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SOFTWARE_REV, "Software revision" }, 452 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SERIAL_NUMBER, "Serial number" }, 453 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME, "Manufacturer name" }, 454 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME, "Model name" }, 455 { LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID, "Asset ID" }, 456 { 0, NULL} 457}; 458 459/* 460 * From RFC 3636 - ifMauAutoNegCapAdvertisedBits 461 */ 462#define LLDP_MAU_PMD_OTHER (1 << 15) 463#define LLDP_MAU_PMD_10BASE_T (1 << 14) 464#define LLDP_MAU_PMD_10BASE_T_FD (1 << 13) 465#define LLDP_MAU_PMD_100BASE_T4 (1 << 12) 466#define LLDP_MAU_PMD_100BASE_TX (1 << 11) 467#define LLDP_MAU_PMD_100BASE_TX_FD (1 << 10) 468#define LLDP_MAU_PMD_100BASE_T2 (1 << 9) 469#define LLDP_MAU_PMD_100BASE_T2_FD (1 << 8) 470#define LLDP_MAU_PMD_FDXPAUSE (1 << 7) 471#define LLDP_MAU_PMD_FDXAPAUSE (1 << 6) 472#define LLDP_MAU_PMD_FDXSPAUSE (1 << 5) 473#define LLDP_MAU_PMD_FDXBPAUSE (1 << 4) 474#define LLDP_MAU_PMD_1000BASE_X (1 << 3) 475#define LLDP_MAU_PMD_1000BASE_X_FD (1 << 2) 476#define LLDP_MAU_PMD_1000BASE_T (1 << 1) 477#define LLDP_MAU_PMD_1000BASE_T_FD (1 << 0) 478 479static const struct tok lldp_pmd_capability_values[] = { 480 { LLDP_MAU_PMD_10BASE_T, "10BASE-T hdx"}, 481 { LLDP_MAU_PMD_10BASE_T_FD, "10BASE-T fdx"}, 482 { LLDP_MAU_PMD_100BASE_T4, "100BASE-T4"}, 483 { LLDP_MAU_PMD_100BASE_TX, "100BASE-TX hdx"}, 484 { LLDP_MAU_PMD_100BASE_TX_FD, "100BASE-TX fdx"}, 485 { LLDP_MAU_PMD_100BASE_T2, "100BASE-T2 hdx"}, 486 { LLDP_MAU_PMD_100BASE_T2_FD, "100BASE-T2 fdx"}, 487 { LLDP_MAU_PMD_FDXPAUSE, "Pause for fdx links"}, 488 { LLDP_MAU_PMD_FDXAPAUSE, "Asym PAUSE for fdx"}, 489 { LLDP_MAU_PMD_FDXSPAUSE, "Sym PAUSE for fdx"}, 490 { LLDP_MAU_PMD_FDXBPAUSE, "Asym and Sym PAUSE for fdx"}, 491 { LLDP_MAU_PMD_1000BASE_X, "1000BASE-{X LX SX CX} hdx"}, 492 { LLDP_MAU_PMD_1000BASE_X_FD, "1000BASE-{X LX SX CX} fdx"}, 493 { LLDP_MAU_PMD_1000BASE_T, "1000BASE-T hdx"}, 494 { LLDP_MAU_PMD_1000BASE_T_FD, "1000BASE-T fdx"}, 495 { 0, NULL} 496}; 497 498#define LLDP_MDI_PORT_CLASS (1 << 0) 499#define LLDP_MDI_POWER_SUPPORT (1 << 1) 500#define LLDP_MDI_POWER_STATE (1 << 2) 501#define LLDP_MDI_PAIR_CONTROL_ABILITY (1 << 3) 502 503static const struct tok lldp_mdi_values[] = { 504 { LLDP_MDI_PORT_CLASS, "PSE"}, 505 { LLDP_MDI_POWER_SUPPORT, "supported"}, 506 { LLDP_MDI_POWER_STATE, "enabled"}, 507 { LLDP_MDI_PAIR_CONTROL_ABILITY, "can be controlled"}, 508 { 0, NULL} 509}; 510 511#define LLDP_MDI_PSE_PORT_POWER_PAIRS_SIGNAL 1 512#define LLDP_MDI_PSE_PORT_POWER_PAIRS_SPARE 2 513 514static const struct tok lldp_mdi_power_pairs_values[] = { 515 { LLDP_MDI_PSE_PORT_POWER_PAIRS_SIGNAL, "signal"}, 516 { LLDP_MDI_PSE_PORT_POWER_PAIRS_SPARE, "spare"}, 517 { 0, NULL} 518}; 519 520#define LLDP_MDI_POWER_CLASS0 1 521#define LLDP_MDI_POWER_CLASS1 2 522#define LLDP_MDI_POWER_CLASS2 3 523#define LLDP_MDI_POWER_CLASS3 4 524#define LLDP_MDI_POWER_CLASS4 5 525 526static const struct tok lldp_mdi_power_class_values[] = { 527 { LLDP_MDI_POWER_CLASS0, "class0"}, 528 { LLDP_MDI_POWER_CLASS1, "class1"}, 529 { LLDP_MDI_POWER_CLASS2, "class2"}, 530 { LLDP_MDI_POWER_CLASS3, "class3"}, 531 { LLDP_MDI_POWER_CLASS4, "class4"}, 532 { 0, NULL} 533}; 534 535#define LLDP_AGGREGATION_CAPABILTIY (1 << 0) 536#define LLDP_AGGREGATION_STATUS (1 << 1) 537 538static const struct tok lldp_aggregation_values[] = { 539 { LLDP_AGGREGATION_CAPABILTIY, "supported"}, 540 { LLDP_AGGREGATION_STATUS, "enabled"}, 541 { 0, NULL} 542}; 543 544/* 545 * Interface numbering subtypes. 546 */ 547#define LLDP_INTF_NUMB_IFX_SUBTYPE 2 548#define LLDP_INTF_NUMB_SYSPORT_SUBTYPE 3 549 550static const struct tok lldp_intf_numb_subtype_values[] = { 551 { LLDP_INTF_NUMB_IFX_SUBTYPE, "Interface Index" }, 552 { LLDP_INTF_NUMB_SYSPORT_SUBTYPE, "System Port Number" }, 553 { 0, NULL} 554}; 555 556#define LLDP_INTF_NUM_LEN 5 557 558/* 559 * Print IEEE private extensions. (802.1 annex F) 560 */ 561static int 562lldp_private_8021_print(const u_char *tptr) 563{ 564 int subtype, hexdump = FALSE; 565 566 subtype = *(tptr+3); 567 568 printf("\n\t %s Subtype (%u)", 569 tok2str(lldp_8021_subtype_values, "unknown", subtype), 570 subtype); 571 572 switch (subtype) { 573 case LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID: 574 printf("\n\t port vlan id (PVID): %u", 575 EXTRACT_16BITS(tptr+4)); 576 break; 577 case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID: 578 printf("\n\t port and protocol vlan id (PPVID): %u, flags [%s] (0x%02x)", 579 EXTRACT_16BITS(tptr+5), 580 bittok2str(lldp_8021_port_protocol_id_values, "none", *(tptr+4)), 581 *(tptr+4)); 582 break; 583 case LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME: 584 printf("\n\t vlan id (VID): %u", 585 EXTRACT_16BITS(tptr+4)); 586 printf("\n\t vlan name: "); 587 safeputs((const char *)tptr+7, *(tptr+6)); 588 break; 589 case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY: 590 printf("\n\t protocol identity: "); 591 safeputs((const char *)tptr+5, *(tptr+4)); 592 break; 593 594 default: 595 hexdump = TRUE; 596 break; 597 } 598 599 return hexdump; 600} 601 602/* 603 * Print IEEE private extensions. (802.3) 604 */ 605static int 606lldp_private_8023_print(const u_char *tptr) 607{ 608 int subtype, hexdump = FALSE; 609 610 subtype = *(tptr+3); 611 612 printf("\n\t %s Subtype (%u)", 613 tok2str(lldp_8023_subtype_values, "unknown", subtype), 614 subtype); 615 616 switch (subtype) { 617 case LLDP_PRIVATE_8023_SUBTYPE_MACPHY: 618 printf("\n\t autonegotiation [%s] (0x%02x)", 619 bittok2str(lldp_8023_autonegotiation_values, "none", *(tptr+4)), 620 *(tptr+4)); 621 printf("\n\t PMD autoneg capability [%s] (0x%04x)", 622 bittok2str(lldp_pmd_capability_values,"unknown", EXTRACT_16BITS(tptr+5)), 623 EXTRACT_16BITS(tptr+5)); 624 printf("\n\t MAU type %s (0x%04x)", 625 tok2str(lldp_mau_types_values, "unknown", EXTRACT_16BITS(tptr+7)), 626 EXTRACT_16BITS(tptr+7)); 627 break; 628 629 case LLDP_PRIVATE_8023_SUBTYPE_MDIPOWER: 630 printf("\n\t MDI power support [%s], power pair %s, power class %s", 631 bittok2str(lldp_mdi_values, "none", *(tptr+4)), 632 tok2str(lldp_mdi_power_pairs_values, "unknown", *(tptr+5)), 633 tok2str(lldp_mdi_power_class_values, "unknown", *(tptr+6))); 634 break; 635 636 case LLDP_PRIVATE_8023_SUBTYPE_LINKAGGR: 637 printf("\n\t aggregation status [%s], aggregation port ID %u", 638 bittok2str(lldp_aggregation_values, "none", *(tptr+4)), 639 EXTRACT_32BITS(tptr+5)); 640 break; 641 642 case LLDP_PRIVATE_8023_SUBTYPE_MTU: 643 printf("\n\t MTU size %u", EXTRACT_16BITS(tptr+4)); 644 break; 645 646 default: 647 hexdump = TRUE; 648 break; 649 } 650 651 return hexdump; 652} 653 654/* 655 * Extract 34bits of latitude/longitude coordinates. 656 */ 657static u_int64_t 658lldp_extract_latlon(const u_char *tptr) 659{ 660 u_int64_t latlon; 661 662 latlon = *tptr & 0x3; 663 latlon = (latlon << 32) | EXTRACT_32BITS(tptr+1); 664 665 return latlon; 666} 667 668/* 669 * Print private TIA extensions. 670 */ 671static int 672lldp_private_tia_print(const u_char *tptr, u_int tlv_len) 673{ 674 int subtype, hexdump = FALSE; 675 u_int8_t location_format; 676 u_int16_t power_val; 677 u_int8_t lci_len, ca_type, ca_len; 678 679 subtype = *(tptr+3); 680 681 printf("\n\t %s Subtype (%u)", 682 tok2str(lldp_tia_subtype_values, "unknown", subtype), 683 subtype); 684 685 switch (subtype) { 686 case LLDP_PRIVATE_TIA_SUBTYPE_CAPABILITIES: 687 printf("\n\t Media capabilities [%s] (0x%04x)", 688 bittok2str(lldp_tia_capabilities_values, "none", 689 EXTRACT_16BITS(tptr+4)), EXTRACT_16BITS(tptr+4)); 690 printf("\n\t Device type [%s] (0x%02x)", 691 tok2str(lldp_tia_device_type_values, "unknown", *(tptr+6)), 692 *(tptr+6)); 693 break; 694 695 case LLDP_PRIVATE_TIA_SUBTYPE_NETWORK_POLICY: 696 printf("\n\t Application type [%s] (0x%02x)", 697 tok2str(lldp_tia_application_type_values, "none", *(tptr+4)), 698 *(tptr+4)); 699 printf(", Flags [%s]", bittok2str( 700 lldp_tia_network_policy_bits_values, "none", *(tptr+5))); 701 printf("\n\t Vlan id %u", 702 LLDP_EXTRACT_NETWORK_POLICY_VLAN(EXTRACT_16BITS(tptr+5))); 703 printf(", L2 priority %u", 704 LLDP_EXTRACT_NETWORK_POLICY_L2_PRIORITY(EXTRACT_16BITS(tptr+6))); 705 printf(", DSCP value %u", 706 LLDP_EXTRACT_NETWORK_POLICY_DSCP(EXTRACT_16BITS(tptr+6))); 707 break; 708 709 case LLDP_PRIVATE_TIA_SUBTYPE_LOCAL_ID: 710 location_format = *(tptr+4); 711 printf("\n\t Location data format %s (0x%02x)", 712 tok2str(lldp_tia_location_data_format_values, "unknown", location_format), 713 location_format); 714 715 switch (location_format) { 716 case LLDP_TIA_LOCATION_DATA_FORMAT_COORDINATE_BASED: 717 printf("\n\t Latitude resolution %u, latitude value %" PRIu64, 718 (*(tptr+5)>>2), lldp_extract_latlon(tptr+5)); 719 printf("\n\t Longitude resolution %u, longitude value %" PRIu64, 720 (*(tptr+10)>>2), lldp_extract_latlon(tptr+10)); 721 printf("\n\t Altitude type %s (%u)", 722 tok2str(lldp_tia_location_altitude_type_values, "unknown",(*(tptr+15)>>4)), 723 (*(tptr+15)>>4)); 724 printf("\n\t Altitude resolution %u, altitude value 0x%x", 725 (EXTRACT_16BITS(tptr+15)>>6)&0x3f, 726 ((EXTRACT_32BITS(tptr+16)&0x3fffffff))); 727 printf("\n\t Datum %s (0x%02x)", 728 tok2str(lldp_tia_location_datum_type_values, "unknown", *(tptr+20)), 729 *(tptr+20)); 730 break; 731 732 case LLDP_TIA_LOCATION_DATA_FORMAT_CIVIC_ADDRESS: 733 lci_len = *(tptr+5); 734 printf("\n\t LCI length %u, LCI what %s (0x%02x), Country-code ", 735 lci_len, 736 tok2str(lldp_tia_location_lci_what_values, "unknown", *(tptr+6)), 737 *(tptr+6)); 738 739 /* Country code */ 740 safeputs((const char *)(tptr+7), 2); 741 742 lci_len = lci_len-3; 743 tptr = tptr + 9; 744 745 /* Decode each civic address element */ 746 while (lci_len > 0) { 747 ca_type = *(tptr); 748 ca_len = *(tptr+1); 749 750 tptr += 2; 751 lci_len -= 2; 752 753 printf("\n\t CA type \'%s\' (%u), length %u: ", 754 tok2str(lldp_tia_location_lci_catype_values, "unknown", ca_type), 755 ca_type, ca_len); 756 757 /* basic sanity check */ 758 if ( ca_type == 0 || ca_len == 0) { 759 return hexdump; 760 } 761 762 safeputs((const char *)tptr, ca_len); 763 tptr += ca_len; 764 lci_len -= ca_len; 765 } 766 break; 767 768 case LLDP_TIA_LOCATION_DATA_FORMAT_ECS_ELIN: 769 printf("\n\t ECS ELIN id "); 770 safeputs((const char *)tptr+5, tlv_len-5); 771 break; 772 773 default: 774 printf("\n\t Location ID "); 775 print_unknown_data(tptr+5, "\n\t ", tlv_len-5); 776 } 777 break; 778 779 case LLDP_PRIVATE_TIA_SUBTYPE_EXTENDED_POWER_MDI: 780 printf("\n\t Power type [%s]", 781 (*(tptr+4)&0xC0>>6) ? "PD device" : "PSE device"); 782 printf(", Power source [%s]", 783 tok2str(lldp_tia_power_source_values, "none", (*(tptr+4)&0x30)>>4)); 784 printf("\n\t Power priority [%s] (0x%02x)", 785 tok2str(lldp_tia_power_priority_values, "none", *(tptr+4)&0x0f), 786 *(tptr+4)&0x0f); 787 power_val = EXTRACT_16BITS(tptr+5); 788 if (power_val < LLDP_TIA_POWER_VAL_MAX) { 789 printf(", Power %.1f Watts", ((float)power_val)/10); 790 } else { 791 printf(", Power %u (Reserved)", power_val); 792 } 793 break; 794 795 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_HARDWARE_REV: 796 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_FIRMWARE_REV: 797 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SOFTWARE_REV: 798 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_SERIAL_NUMBER: 799 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MANUFACTURER_NAME: 800 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_MODEL_NAME: 801 case LLDP_PRIVATE_TIA_SUBTYPE_INVENTORY_ASSET_ID: 802 printf("\n\t %s ", 803 tok2str(lldp_tia_inventory_values, "unknown", subtype)); 804 safeputs((const char *)tptr+4, tlv_len-4); 805 break; 806 807 default: 808 hexdump = TRUE; 809 break; 810 } 811 812 return hexdump; 813} 814 815static char * 816lldp_network_addr_print(const u_char *tptr) { 817 818 u_int8_t af; 819 static char buf[BUFSIZE]; 820 const char * (*pfunc)(const u_char *); 821 822 af = *tptr; 823 switch (af) { 824 case AFNUM_INET: 825 pfunc = getname; 826 break; 827#ifdef INET6 828 case AFNUM_INET6: 829 pfunc = getname6; 830 break; 831#endif 832 case AFNUM_802: 833 pfunc = etheraddr_string; 834 break; 835 default: 836 pfunc = NULL; 837 break; 838 } 839 840 if (!pfunc) { 841 snprintf(buf, sizeof(buf), "AFI %s (%u), no AF printer !", 842 tok2str(af_values, "Unknown", af), af); 843 } else { 844 snprintf(buf, sizeof(buf), "AFI %s (%u): %s", 845 tok2str(af_values, "Unknown", af), af, (*pfunc)(tptr+1)); 846 } 847 848 return buf; 849} 850 851static int 852lldp_mgmt_addr_tlv_print(const u_char *pptr, u_int len) { 853 854 u_int8_t mgmt_addr_len, intf_num_subtype, oid_len; 855 const u_char *tptr; 856 u_int tlen; 857 858 tlen = len; 859 tptr = pptr; 860 861 mgmt_addr_len = *tptr++; 862 tlen--; 863 864 if (tlen < mgmt_addr_len) { 865 return 0; 866 } 867 868 printf("\n\t Management Address length %u, %s", 869 mgmt_addr_len, 870 lldp_network_addr_print(tptr)); 871 tptr += mgmt_addr_len; 872 tlen -= mgmt_addr_len; 873 874 if (tlen < LLDP_INTF_NUM_LEN) { 875 return 0; 876 } 877 878 intf_num_subtype = *tptr; 879 printf("\n\t %s Interface Numbering (%u): %u", 880 tok2str(lldp_intf_numb_subtype_values, "Unknown", intf_num_subtype), 881 intf_num_subtype, 882 EXTRACT_32BITS(tptr+1)); 883 884 tptr += LLDP_INTF_NUM_LEN; 885 tlen -= LLDP_INTF_NUM_LEN; 886 887 /* 888 * The OID is optional. 889 */ 890 if (tlen) { 891 oid_len = *tptr; 892 893 if (oid_len) { 894 printf("\n\t OID length %u", oid_len); 895 safeputs((const char *)tptr+1, oid_len); 896 } 897 } 898 899 return 1; 900} 901 902void 903lldp_print(register const u_char *pptr, register u_int len) { 904 905 u_int8_t subtype; 906 u_int16_t tlv, cap, ena_cap; 907 u_int oui, tlen, hexdump, tlv_type, tlv_len; 908 const u_char *tptr; 909 910 tptr = pptr; 911 tlen = len; 912 913 if (vflag) { 914 printf("LLDP, length %u", len); 915 } 916 917 while (tlen >= sizeof(tlv)) { 918 919 TCHECK2(*tptr, sizeof(tlv)); 920 921 tlv = EXTRACT_16BITS(tptr); 922 923 tlv_type = LLDP_EXTRACT_TYPE(tlv); 924 tlv_len = LLDP_EXTRACT_LEN(tlv); 925 hexdump = FALSE; 926 927 tlen -= sizeof(tlv); 928 tptr += sizeof(tlv); 929 930 if (vflag) { 931 printf("\n\t%s TLV (%u), length %u", 932 tok2str(lldp_tlv_values, "Unknown", tlv_type), 933 tlv_type, tlv_len); 934 } 935 936 /* infinite loop check */ 937 if (!tlv_type || !tlv_len) { 938 break; 939 } 940 941 TCHECK2(*tptr, tlv_len); 942 943 switch (tlv_type) { 944 case LLDP_TTL_TLV: 945 if (vflag) { 946 printf(": TTL %us", EXTRACT_16BITS(tptr)); 947 } 948 break; 949 950 case LLDP_SYSTEM_NAME_TLV: 951 952 /* 953 * The system name is also print in non-verbose mode 954 * similar to the CDP printer. 955 */ 956 if (vflag) { 957 printf(": "); 958 safeputs((const char *)tptr, tlv_len); 959 } else { 960 printf("LLDP, name "); 961 safeputs((const char *)tptr, tlv_len); 962 printf(", length %u", len); 963 } 964 break; 965 966 case LLDP_PORT_DESCR_TLV: 967 if (vflag) { 968 printf(": "); 969 safeputs((const char *)tptr, tlv_len); 970 } 971 break; 972 973 case LLDP_SYSTEM_DESCR_TLV: 974 if (vflag) { 975 printf("\n\t "); 976 safeputs((const char *)tptr, tlv_len); 977 } 978 break; 979 980 981 case LLDP_CHASSIS_ID_TLV: 982 if (vflag) { 983 subtype = *tptr; 984 printf("\n\t Subtype %s (%u): ", 985 tok2str(lldp_chassis_subtype_values, "Unknown", subtype), 986 subtype); 987 988 switch (subtype) { 989 case LLDP_CHASSIS_MAC_ADDR_SUBTYPE: 990 printf("%s", etheraddr_string(tptr+1)); 991 break; 992 993 case LLDP_CHASSIS_INTF_NAME_SUBTYPE: /* fall through */ 994 case LLDP_CHASSIS_LOCAL_SUBTYPE: 995 case LLDP_CHASSIS_CHASSIS_COMP_SUBTYPE: 996 case LLDP_CHASSIS_INTF_ALIAS_SUBTYPE: 997 case LLDP_CHASSIS_PORT_COMP_SUBTYPE: 998 safeputs((const char *)tptr+1, tlv_len-1); 999 break; 1000 1001 case LLDP_CHASSIS_NETWORK_ADDR_SUBTYPE: 1002 printf("%s", lldp_network_addr_print(tptr+1)); 1003 break; 1004 1005 default: 1006 hexdump = TRUE; 1007 break; 1008 } 1009 } 1010 break; 1011 1012 case LLDP_PORT_ID_TLV: 1013 if (vflag) { 1014 subtype = *tptr; 1015 printf("\n\t Subtype %s (%u): ", 1016 tok2str(lldp_port_subtype_values, "Unknown", subtype), 1017 subtype); 1018 1019 switch (subtype) { 1020 case LLDP_PORT_MAC_ADDR_SUBTYPE: 1021 printf("%s", etheraddr_string(tptr+1)); 1022 break; 1023 1024 case LLDP_PORT_INTF_NAME_SUBTYPE: /* fall through */ 1025 case LLDP_PORT_LOCAL_SUBTYPE: 1026 case LLDP_PORT_AGENT_CIRC_ID_SUBTYPE: 1027 case LLDP_PORT_INTF_ALIAS_SUBTYPE: 1028 case LLDP_PORT_PORT_COMP_SUBTYPE: 1029 safeputs((const char *)tptr+1, tlv_len-1); 1030 break; 1031 1032 case LLDP_PORT_NETWORK_ADDR_SUBTYPE: 1033 printf("%s", lldp_network_addr_print(tptr+1)); 1034 break; 1035 1036 default: 1037 hexdump = TRUE; 1038 break; 1039 } 1040 } 1041 break; 1042 1043 case LLDP_PRIVATE_TLV: 1044 if (vflag) { 1045 oui = EXTRACT_24BITS(tptr); 1046 printf(": OUI %s (0x%06x)", tok2str(oui_values, "Unknown", oui), oui); 1047 1048 switch (oui) { 1049 case OUI_IEEE_8021_PRIVATE: 1050 hexdump = lldp_private_8021_print(tptr); 1051 break; 1052 case OUI_IEEE_8023_PRIVATE: 1053 hexdump = lldp_private_8023_print(tptr); 1054 break; 1055 case OUI_TIA: 1056 hexdump = lldp_private_tia_print(tptr, tlv_len); 1057 break; 1058 default: 1059 hexdump = TRUE; 1060 break; 1061 } 1062 } 1063 break; 1064 1065 case LLDP_SYSTEM_CAP_TLV: 1066 if (vflag) { 1067 cap = EXTRACT_16BITS(tptr); 1068 ena_cap = EXTRACT_16BITS(tptr+2); 1069 printf("\n\t System Capabilities [%s] (0x%04x)", 1070 bittok2str(lldp_cap_values, "none", cap), cap); 1071 printf("\n\t Enabled Capabilities [%s] (0x%04x)", 1072 bittok2str(lldp_cap_values, "none", ena_cap), ena_cap); 1073 } 1074 break; 1075 1076 case LLDP_MGMT_ADDR_TLV: 1077 if (vflag) { 1078 if (!lldp_mgmt_addr_tlv_print(tptr, tlen)) { 1079 goto trunc; 1080 } 1081 } 1082 break; 1083 1084 default: 1085 hexdump = TRUE; 1086 break; 1087 } 1088 1089 /* do we also want to see a hex dump ? */ 1090 if (vflag > 1 || (vflag && hexdump)) { 1091 print_unknown_data(tptr,"\n\t ", tlv_len); 1092 } 1093 1094 tlen -= tlv_len; 1095 tptr += tlv_len; 1096 } 1097 return; 1098 trunc: 1099 printf("\n\t[|LLDP]"); 1100} 1101 1102/* 1103 * Local Variables: 1104 * c-style: whitesmith 1105 * c-basic-offset: 4 1106 * End: 1107 */ 1108