src/client/display.c

   1 /* -*- mode: c; c-file-style: "openbsd" -*- */
   2 /*
   3  * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <ctype.h>
  22 #include <time.h>
  23 #include <errno.h>
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <sys/un.h>
  27 #include <arpa/inet.h>
  28 #include <string.h>
  29
  30 #include "../log.h"
  31 #include "client.h"
  32
  33 static void
  34 display_cap(struct writer * w, lldpctl_atom_t *chassis, u_int8_t bit, char *symbol)
  35 {
  36         if (lldpctl_atom_get_int(chassis, lldpctl_k_chassis_cap_available) & bit) {
  37                 tag_start(w, "capability", "Capability");
  38                 tag_attr (w, "type", "", symbol );
  39                 tag_attr (w, "enabled", "",
  40                     (lldpctl_atom_get_int(chassis, lldpctl_k_chassis_cap_enabled) & bit)?
  41                     "on":"off");
  42                 tag_end  (w);
  43         }
  44 }
  45
  46 static void
  47 display_med_capability(struct writer *w, long int available, int cap,
  48     const char *symbol)
  49 {
  50         if (available & cap) {
  51                 tag_start(w, "capability", "Capability");
  52                 tag_attr(w, "type", "", symbol);
  53                 tag_attr(w, "available", "", "yes");
  54                 tag_end(w);
  55         }
  56 }
  57
  58 static void
  59 display_med(struct writer *w, lldpctl_atom_t *port, lldpctl_atom_t *chassis)
  60 {
  61         lldpctl_atom_t *medpolicies, *medpolicy;
  62         lldpctl_atom_t *medlocations, *medlocation;
  63         lldpctl_atom_t *caelements, *caelement;
  64         lldpctl_atom_t *medpower;
  65         long int cap = lldpctl_atom_get_int(chassis, lldpctl_k_chassis_med_cap);
  66         const char *type;
  67
  68         if (lldpctl_atom_get_int(chassis, lldpctl_k_chassis_med_type) <= 0)
  69                 return;
  70
  71         tag_start(w, "lldp-med", "LLDP-MED");
  72
  73         tag_datatag(w, "device-type", "Device Type",
  74             lldpctl_atom_get_str(chassis, lldpctl_k_chassis_med_type));
  75
  76         display_med_capability(w, cap, LLDP_MED_CAP_CAP, "Capabilities");
  77         display_med_capability(w, cap, LLDP_MED_CAP_POLICY, "Policy");
  78         display_med_capability(w, cap, LLDP_MED_CAP_LOCATION, "Location");
  79         display_med_capability(w, cap, LLDP_MED_CAP_MDI_PSE, "MDI/PSE");
  80         display_med_capability(w, cap, LLDP_MED_CAP_MDI_PD, "MDI/PD");
  81         display_med_capability(w, cap, LLDP_MED_CAP_IV, "Inventory");
  82
  83         /* LLDP MED policies */
  84         medpolicies = lldpctl_atom_get(port, lldpctl_k_port_med_policies);
  85         lldpctl_atom_foreach(medpolicies, medpolicy) {
  86                 if (lldpctl_atom_get_int(medpolicy,
  87                         lldpctl_k_med_policy_type) <= 0) continue;
  88
  89                 tag_start(w, "policy", "LLDP-MED Network Policy for");
  90                 tag_attr(w, "apptype", "", lldpctl_atom_get_str(medpolicy, lldpctl_k_med_policy_type));
  91                 tag_attr(w, "defined", "Defined",
  92                     (lldpctl_atom_get_int(medpolicy,
  93                         lldpctl_k_med_policy_unknown) > 0)?"no":"yes");
  94
  95                 if (lldpctl_atom_get_int(medpolicy,
  96                         lldpctl_k_med_policy_tagged) > 0) {
  97                         int vid = lldpctl_atom_get_int(medpolicy,
  98                             lldpctl_k_med_policy_vid);
  99                         tag_start(w, "vlan", "VLAN");
 100                         if (vid == 0) {
 101                                 tag_attr(w, "vid", "", "priority");
 102                         } else if (vid == 4095) {
 103                                 tag_attr(w, "vid", "", "reserved");
 104                         } else {
 105                                 tag_attr(w, "vid", "",
 106                                     lldpctl_atom_get_str(medpolicy,
 107                                         lldpctl_k_med_policy_vid));
 108                         }
 109                         tag_end(w);
 110                 }
 111
 112                 tag_datatag(w, "priority", "Priority",
 113                     lldpctl_atom_get_str(medpolicy,
 114                         lldpctl_k_med_policy_priority));
 115                 /* Also give a numeric value */
 116                 int pcp = lldpctl_atom_get_int(medpolicy,
 117                     lldpctl_k_med_policy_priority);
 118                 char spcp[2] = { pcp + '0', '\0' };
 119                 tag_datatag(w, "pcp", "PCP", spcp);
 120                 tag_datatag(w, "dscp", "DSCP Value",
 121                     lldpctl_atom_get_str(medpolicy,
 122                         lldpctl_k_med_policy_dscp));
 123
 124                 tag_end(w);
 125         }
 126         lldpctl_atom_dec_ref(medpolicies);
 127
 128         /* LLDP MED locations */
 129         medlocations = lldpctl_atom_get(port, lldpctl_k_port_med_locations);
 130         lldpctl_atom_foreach(medlocations, medlocation) {
 131                 int format = lldpctl_atom_get_int(medlocation,
 132                     lldpctl_k_med_location_format);
 133                 if (format <= 0) continue;
 134                 tag_start(w, "location", "LLDP-MED Location Identification");
 135                 tag_attr(w, "type", "Type",
 136                     lldpctl_atom_get_str(medlocation,
 137                         lldpctl_k_med_location_format));
 138
 139                 switch (format) {
 140                 case LLDP_MED_LOCFORMAT_COORD:
 141                         tag_attr(w, "geoid", "Geoid",
 142                             lldpctl_atom_get_str(medlocation,
 143                                 lldpctl_k_med_location_geoid));
 144                         tag_datatag(w, "lat", "Latitude",
 145                             lldpctl_atom_get_str(medlocation,
 146                                 lldpctl_k_med_location_latitude));
 147                         tag_datatag(w, "lon", "Longitude",
 148                             lldpctl_atom_get_str(medlocation,
 149                                 lldpctl_k_med_location_longitude));
 150                         tag_start(w, "altitude", "Altitude");
 151                         tag_attr(w, "unit", "", lldpctl_atom_get_str(medlocation,
 152                                 lldpctl_k_med_location_altitude_unit));
 153                         tag_data(w, lldpctl_atom_get_str(medlocation,
 154                                 lldpctl_k_med_location_altitude));
 155                         tag_end(w);
 156                         break;
 157                 case LLDP_MED_LOCFORMAT_CIVIC:
 158                         tag_datatag(w, "country", "Country",
 159                             lldpctl_atom_get_str(medlocation,
 160                                 lldpctl_k_med_location_country));
 161                         caelements = lldpctl_atom_get(medlocation,
 162                             lldpctl_k_med_location_ca_elements);
 163                         lldpctl_atom_foreach(caelements, caelement) {
 164                                 type = lldpctl_atom_get_str(caelement,
 165                                     lldpctl_k_med_civicaddress_type);
 166                                 tag_datatag(w, totag(type), type,
 167                                     lldpctl_atom_get_str(caelement,
 168                                         lldpctl_k_med_civicaddress_value));
 169                         }
 170                         lldpctl_atom_dec_ref(caelements);
 171                         break;
 172                 case LLDP_MED_LOCFORMAT_ELIN:
 173                         tag_datatag(w, "ecs", "ECS ELIN",
 174                             lldpctl_atom_get_str(medlocation,
 175                                 lldpctl_k_med_location_elin));
 176                         break;
 177                 }
 178
 179                 tag_end(w);
 180         }
 181         lldpctl_atom_dec_ref(medlocations);
 182
 183         /* LLDP MED power */
 184         medpower = lldpctl_atom_get(port, lldpctl_k_port_med_power);
 185         if (lldpctl_atom_get_int(medpower, lldpctl_k_med_power_type) > 0) {
 186                 tag_start(w, "poe", "Extended Power-over-Ethernet");
 187
 188                 tag_datatag(w, "device-type", "Power Type & Source",
 189                     lldpctl_atom_get_str(medpower, lldpctl_k_med_power_type));
 190                 tag_datatag(w, "source", "Power Source",
 191                     lldpctl_atom_get_str(medpower, lldpctl_k_med_power_source));
 192                 tag_datatag(w, "priority", "Power priority",
 193                     lldpctl_atom_get_str(medpower, lldpctl_k_med_power_priority));
 194                 tag_datatag(w, "power", "Power Value",
 195                     lldpctl_atom_get_str(medpower, lldpctl_k_med_power_val));
 196
 197                 tag_end(w);
 198         }
 199         lldpctl_atom_dec_ref(medpower);
 200
 201         /* LLDP MED inventory */
 202         do {
 203                 const char *hw = lldpctl_atom_get_str(chassis,
 204                     lldpctl_k_chassis_med_inventory_hw);
 205                 const char *sw = lldpctl_atom_get_str(chassis,
 206                     lldpctl_k_chassis_med_inventory_sw);
 207                 const char *fw = lldpctl_atom_get_str(chassis,
 208                     lldpctl_k_chassis_med_inventory_fw);
 209                 const char *sn = lldpctl_atom_get_str(chassis,
 210                     lldpctl_k_chassis_med_inventory_sn);
 211                 const char *manuf = lldpctl_atom_get_str(chassis,
 212                     lldpctl_k_chassis_med_inventory_manuf);
 213                 const char *model = lldpctl_atom_get_str(chassis,
 214                     lldpctl_k_chassis_med_inventory_model);
 215                 const char *asset = lldpctl_atom_get_str(chassis,
 216                     lldpctl_k_chassis_med_inventory_asset);
 217                 if (!(hw || sw || fw || sn ||
 218                         manuf || model || asset)) break;
 219
 220                 tag_start(w, "inventory", "Inventory");
 221                 tag_datatag(w, "hardware", "Hardware Revision", hw);
 222                 tag_datatag(w, "software", "Software Revision", sw);
 223                 tag_datatag(w, "firmware", "Firmware Revision", fw);
 224                 tag_datatag(w, "serial", "Serial Number", sn);
 225                 tag_datatag(w, "manufacturer", "Manufacturer", manuf);
 226                 tag_datatag(w, "model", "Model", model);
 227                 tag_datatag(w, "asset", "Asset ID", asset);
 228                 tag_end(w);
 229         } while(0);
 230
 231         tag_end(w);
 232 }
 233
 234 static void
 235 display_chassis(struct writer* w, lldpctl_atom_t* chassis, int details)
 236 {
 237         lldpctl_atom_t *mgmts, *mgmt;
 238
 239         tag_start(w, "chassis", "Chassis");
 240         tag_start(w, "id", "ChassisID");
 241         tag_attr (w, "type", "",
 242             lldpctl_atom_get_str(chassis,
 243                 lldpctl_k_chassis_id_subtype));
 244         tag_data(w, lldpctl_atom_get_str(chassis,
 245                 lldpctl_k_chassis_id));
 246         tag_end(w);
 247         tag_datatag(w, "name", "SysName",
 248             lldpctl_atom_get_str(chassis, lldpctl_k_chassis_name));
 249         if (details == DISPLAY_BRIEF) {
 250                 tag_end(w);
 251                 return;
 252         }
 253         tag_datatag(w, "descr", "SysDescr",
 254             lldpctl_atom_get_str(chassis, lldpctl_k_chassis_descr));
 255         if (details)
 256                 tag_datatag(w, "ttl", "TTL",
 257                     lldpctl_atom_get_str(chassis, lldpctl_k_chassis_ttl));
 258
 259         /* Management addresses */
 260         mgmts = lldpctl_atom_get(chassis, lldpctl_k_chassis_mgmt);
 261         lldpctl_atom_foreach(mgmts, mgmt) {
 262                 tag_datatag(w, "mgmt-ip", "MgmtIP",
 263                     lldpctl_atom_get_str(mgmt, lldpctl_k_mgmt_ip));
 264         }
 265         lldpctl_atom_dec_ref(mgmts);
 266
 267         /* Capabilities */
 268         display_cap(w, chassis, LLDP_CAP_OTHER, "Other");
 269         display_cap(w, chassis, LLDP_CAP_REPEATER, "Repeater");
 270         display_cap(w, chassis, LLDP_CAP_BRIDGE, "Bridge");
 271         display_cap(w, chassis, LLDP_CAP_ROUTER, "Router");
 272         display_cap(w, chassis, LLDP_CAP_WLAN, "Wlan");
 273         display_cap(w, chassis, LLDP_CAP_TELEPHONE, "Tel");
 274         display_cap(w, chassis, LLDP_CAP_DOCSIS, "Docsis");
 275         display_cap(w, chassis, LLDP_CAP_STATION, "Station");
 276
 277         tag_end(w);
 278 }
 279
 280 static void
 281 display_custom_tlvs(struct writer* w, lldpctl_atom_t* neighbor)
 282 {
 283         lldpctl_atom_t *custom_list, *custom;
 284         int have_custom_tlvs = 0;
 285         size_t i, len, slen;
 286         const uint8_t *oui, *oui_info;
 287         char buf[1600]; /* should be enough for printing */
 288
 289         custom_list = lldpctl_atom_get(neighbor, lldpctl_k_custom_tlvs);
 290         lldpctl_atom_foreach(custom_list, custom) {
 291                 /* This tag gets added only once, if there are any custom TLVs */
 292                 if (!have_custom_tlvs) {
 293                         tag_start(w, "unknown-tlvs", "Unknown TLVs");
 294                         have_custom_tlvs++;
 295                 }
 296                 len = 0;
 297                 oui = lldpctl_atom_get_buffer(custom, lldpctl_k_custom_tlv_oui, &len);
 298                 len = 0;
 299                 oui_info = lldpctl_atom_get_buffer(custom, lldpctl_k_custom_tlv_oui_info_string, &len);
 300                 if (!oui)
 301                         continue;
 302                 tag_start(w, "unknown-tlv", "TLV");
 303
 304                 /* Add OUI as attribute */
 305                 snprintf(buf, sizeof(buf), "%02X,%02X,%02X", oui[0], oui[1], oui[2]);
 306                 tag_attr(w, "oui", "OUI", buf);
 307                 snprintf(buf, sizeof(buf), "%d",
 308                          (int)lldpctl_atom_get_int(custom, lldpctl_k_custom_tlv_oui_subtype));
 309                 tag_attr(w, "subtype", "SubType", buf);
 310                 snprintf(buf, sizeof(buf), "%d", (int)len);
 311                 tag_attr(w, "len", "Len", buf);
 312                 if (len > 0) {
 313                         for (slen=0, i=0; i < len; ++i)
 314                                 slen += snprintf(buf + slen, sizeof(buf) > slen ? sizeof(buf) - slen : 0,
 315                                                  "%02X%s", oui_info[i], ((i < len - 1) ? "," : ""));
 316                         tag_data(w, buf);
 317                 }
 318                 tag_end(w);
 319         }
 320         lldpctl_atom_dec_ref(custom_list);
 321
 322         if (have_custom_tlvs)
 323                 tag_end(w);
 324 }
 325
 326
 327 static void
 328 display_autoneg(struct writer * w, int advertised, int bithd, int bitfd, char *desc)
 329 {
 330         if (!((advertised & bithd) ||
 331                 (advertised & bitfd)))
 332                 return;
 333
 334         tag_start(w, "advertised", "Adv");
 335         tag_attr(w, "type", "", desc);
 336         if (bitfd != bithd) {
 337                 tag_attr(w, "hd", "HD", (advertised & bithd)?"yes":"no");
 338                 tag_attr(w, "fd", "FD", (advertised & bitfd)?"yes":"no");
 339         }
 340         tag_end (w);
 341 }
 342
 343 static void
 344 display_port(struct writer *w, lldpctl_atom_t *port, int details)
 345 {
 346         tag_start(w, "port", "Port");
 347         tag_start(w, "id", "PortID");
 348         tag_attr (w, "type", "",
 349             lldpctl_atom_get_str(port, lldpctl_k_port_id_subtype));
 350         tag_data(w, lldpctl_atom_get_str(port, lldpctl_k_port_id));
 351         tag_end(w);
 352
 353         tag_datatag(w, "descr", "PortDescr",
 354             lldpctl_atom_get_str(port, lldpctl_k_port_descr));
 355
 356         /* Dot3 */
 357         if (details == DISPLAY_DETAILS) {
 358                 tag_datatag(w, "mfs", "MFS",
 359                     lldpctl_atom_get_str(port, lldpctl_k_port_dot3_mfs));
 360                 tag_datatag(w, "aggregation", "Port is aggregated. PortAggregID",
 361                     lldpctl_atom_get_str(port, lldpctl_k_port_dot3_aggregid));
 362
 363                 long int autoneg_support, autoneg_enabled, autoneg_advertised;
 364                 autoneg_support = lldpctl_atom_get_int(port,
 365                     lldpctl_k_port_dot3_autoneg_support);
 366                 autoneg_enabled = lldpctl_atom_get_int(port,
 367                     lldpctl_k_port_dot3_autoneg_enabled);
 368                 autoneg_advertised = lldpctl_atom_get_int(port,
 369                     lldpctl_k_port_dot3_autoneg_advertised);
 370                 if (autoneg_support > 0 || autoneg_enabled > 0) {
 371                         tag_start(w, "auto-negotiation", "PMD autoneg");
 372                         tag_attr (w, "supported", "supported",
 373                             (autoneg_support > 0)?"yes":"no");
 374                         tag_attr (w, "enabled", "enabled",
 375                             (autoneg_enabled > 0)?"yes":"no");
 376
 377                         if (autoneg_enabled > 0) {
 378                                 if (autoneg_advertised < 0)
 379                                         autoneg_advertised = 0;
 380                                 display_autoneg(w, autoneg_advertised,
 381                                     LLDP_DOT3_LINK_AUTONEG_10BASE_T,
 382                                     LLDP_DOT3_LINK_AUTONEG_10BASET_FD,
 383                                     "10Base-T");
 384                                 display_autoneg(w, autoneg_advertised,
 385                                     LLDP_DOT3_LINK_AUTONEG_100BASE_TX,
 386                                     LLDP_DOT3_LINK_AUTONEG_100BASE_TXFD,
 387                                     "100Base-TX");
 388                                 display_autoneg(w, autoneg_advertised,
 389                                     LLDP_DOT3_LINK_AUTONEG_100BASE_T2,
 390                                     LLDP_DOT3_LINK_AUTONEG_100BASE_T2FD,
 391                                     "100Base-T2");
 392                                 display_autoneg(w, autoneg_advertised,
 393                                     LLDP_DOT3_LINK_AUTONEG_100BASE_T4,
 394                                     LLDP_DOT3_LINK_AUTONEG_100BASE_T4,
 395                                     "100Base-T4");
 396                                 display_autoneg(w, autoneg_advertised,
 397                                     LLDP_DOT3_LINK_AUTONEG_1000BASE_X,
 398                                     LLDP_DOT3_LINK_AUTONEG_1000BASE_XFD,
 399                                     "1000Base-X");
 400                                 display_autoneg(w, autoneg_advertised,
 401                                     LLDP_DOT3_LINK_AUTONEG_1000BASE_T,
 402                                     LLDP_DOT3_LINK_AUTONEG_1000BASE_TFD,
 403                                     "1000Base-T");
 404                         }
 405                         tag_datatag(w, "current", "MAU oper type",
 406                             lldpctl_atom_get_str(port, lldpctl_k_port_dot3_mautype));
 407                         tag_end(w);
 408                 }
 409
 410                 lldpctl_atom_t *dot3_power = lldpctl_atom_get(port,
 411                     lldpctl_k_port_dot3_power);
 412                 int devicetype = lldpctl_atom_get_int(dot3_power,
 413                     lldpctl_k_dot3_power_devicetype);
 414                 if (devicetype > 0) {
 415                         tag_start(w, "power", "MDI Power");
 416                         tag_attr(w, "supported", "supported",
 417                             (lldpctl_atom_get_int(dot3_power,
 418                                 lldpctl_k_dot3_power_supported) > 0)?"yes":"no");
 419                         tag_attr(w, "enabled", "enabled",
 420                             (lldpctl_atom_get_int(dot3_power,
 421                                 lldpctl_k_dot3_power_enabled) > 0)?"yes":"no");
 422                         tag_attr(w, "paircontrol", "pair control",
 423                             (lldpctl_atom_get_int(dot3_power,
 424                                 lldpctl_k_dot3_power_paircontrol) > 0)?"yes":"no");
 425                         tag_start(w, "device-type", "Device type");
 426                         tag_data(w, lldpctl_atom_get_str(dot3_power,
 427                                 lldpctl_k_dot3_power_devicetype));;
 428                         tag_end(w);
 429                         tag_start(w, "pairs", "Power pairs");
 430                         tag_data(w, lldpctl_atom_get_str(dot3_power,
 431                                 lldpctl_k_dot3_power_pairs));
 432                         tag_end(w);
 433                         tag_start(w, "class", "Class");
 434                         tag_data(w, lldpctl_atom_get_str(dot3_power,
 435                                 lldpctl_k_dot3_power_class));
 436                         tag_end(w);
 437
 438                         /* 802.3at */
 439                         if (lldpctl_atom_get_int(dot3_power,
 440                                 lldpctl_k_dot3_power_type) > LLDP_DOT3_POWER_8023AT_OFF) {
 441                                 tag_start(w, "power-type", "Power type");
 442                                 tag_data(w, lldpctl_atom_get_str(dot3_power,
 443                                         lldpctl_k_dot3_power_type));
 444                                 tag_end(w);
 445
 446                                 tag_start(w, "source", "Power Source");
 447                                 tag_data(w, lldpctl_atom_get_str(dot3_power,
 448                                         lldpctl_k_dot3_power_source));
 449                                 tag_end(w);
 450
 451                                 tag_start(w, "priority", "Power Priority");
 452                                 tag_data(w, lldpctl_atom_get_str(dot3_power,
 453                                         lldpctl_k_dot3_power_priority));
 454                                 tag_end(w);
 455
 456                                 tag_start(w, "requested", "PD requested power Value");
 457                                 tag_data(w, lldpctl_atom_get_str(dot3_power,
 458                                         lldpctl_k_dot3_power_requested));
 459                                 tag_end(w);
 460
 461                                 tag_start(w, "allocated", "PSE allocated power Value");
 462                                 tag_data(w, lldpctl_atom_get_str(dot3_power,
 463                                         lldpctl_k_dot3_power_allocated));
 464                                 tag_end(w);
 465                         }
 466
 467                         tag_end(w);
 468                 }
 469                 lldpctl_atom_dec_ref(dot3_power);
 470         }
 471
 472         tag_end(w);
 473 }
 474
 475 static void
 476 display_vlans(struct writer *w, lldpctl_atom_t *port)
 477 {
 478         lldpctl_atom_t *vlans, *vlan;
 479         int foundpvid = 0;
 480         int pvid, vid;
 481
 482         pvid = lldpctl_atom_get_int(port,
 483             lldpctl_k_port_vlan_pvid);
 484
 485         vlans = lldpctl_atom_get(port, lldpctl_k_port_vlans);
 486         lldpctl_atom_foreach(vlans, vlan) {
 487                 vid = lldpctl_atom_get_int(vlan,
 488                     lldpctl_k_vlan_id);
 489                 if (pvid == vid)
 490                         foundpvid = 1;
 491
 492                 tag_start(w, "vlan", "VLAN");
 493                 tag_attr(w, "vlan-id", "",
 494                     lldpctl_atom_get_str(vlan, lldpctl_k_vlan_id));
 495                 if (pvid == vid)
 496                         tag_attr(w, "pvid", "pvid", "yes");
 497                 tag_data(w, lldpctl_atom_get_str(vlan,
 498                         lldpctl_k_vlan_name));
 499                 tag_end(w);
 500         }
 501         lldpctl_atom_dec_ref(vlans);
 502
 503         if (!foundpvid && pvid > 0) {
 504                 tag_start(w, "vlan", "VLAN");
 505                 tag_attr(w, "vlan-id", "",
 506                     lldpctl_atom_get_str(port,
 507                         lldpctl_k_port_vlan_pvid));
 508                 tag_attr(w, "pvid", "pvid", "yes");
 509                 tag_end(w);
 510         }
 511 }
 512
 513 static void
 514 display_ppvids(struct writer *w, lldpctl_atom_t *port)
 515 {
 516         lldpctl_atom_t *ppvids, *ppvid;
 517         ppvids = lldpctl_atom_get(port, lldpctl_k_port_ppvids);
 518         lldpctl_atom_foreach(ppvids, ppvid) {
 519                 int status = lldpctl_atom_get_int(ppvid,
 520                     lldpctl_k_ppvid_status);
 521                 tag_start(w, "ppvid", "PPVID");
 522                 if (lldpctl_atom_get_int(ppvid,
 523                         lldpctl_k_ppvid_id) > 0)
 524                         tag_attr(w, "value", "",
 525                             lldpctl_atom_get_str(ppvid,
 526                                 lldpctl_k_ppvid_id));
 527                 tag_attr(w, "supported", "supported",
 528                          (status & LLDP_PPVID_CAP_SUPPORTED)?"yes":"no");
 529                 tag_attr(w, "enabled", "enabled",
 530                          (status & LLDP_PPVID_CAP_ENABLED)?"yes":"no");
 531                 tag_end(w);
 532         }
 533         lldpctl_atom_dec_ref(ppvids);
 534 }
 535
 536 static void
 537 display_pids(struct writer *w, lldpctl_atom_t *port)
 538 {
 539         lldpctl_atom_t *pids, *pid;
 540         pids = lldpctl_atom_get(port, lldpctl_k_port_pis);
 541         lldpctl_atom_foreach(pids, pid) {
 542                 const char *pi = lldpctl_atom_get_str(pid, lldpctl_k_pi_id);
 543                 if (pi && strlen(pi) > 0)
 544                         tag_datatag(w, "pi", "PI", pi);
 545         }
 546         lldpctl_atom_dec_ref(pids);
 547 }
 548
 549 static const char*
 550 display_age(time_t lastchange)
 551 {
 552         static char sage[30];
 553         int age = (int)(time(NULL) - lastchange);
 554         if (snprintf(sage, sizeof(sage),
 555                 "%d day%s, %02d:%02d:%02d",
 556                 age / (60*60*24),
 557                 (age / (60*60*24) > 1)?"s":"",
 558                 (age / (60*60)) % 24,
 559                 (age / 60) % 60,
 560                 age % 60) >= sizeof(sage))
 561                 return "too much";
 562         else
 563                 return sage;
 564 }
 565
 566 void
 567 display_local_chassis(lldpctl_conn_t *conn, struct writer *w,
 568     struct cmd_env *env, int details)
 569 {
 570         tag_start(w, "local-chassis", "Local chassis");
 571
 572         lldpctl_atom_t *chassis = lldpctl_get_local_chassis(conn);
 573         display_chassis(w, chassis, details);
 574         if (details == DISPLAY_DETAILS) {
 575                 display_med(w, NULL, chassis);
 576         }
 577         lldpctl_atom_dec_ref(chassis);
 578
 579         tag_end(w);
 580 }
 581
 582 void
 583 display_interface(lldpctl_conn_t *conn, struct writer *w, int hidden,
 584     lldpctl_atom_t *iface, lldpctl_atom_t *neighbor, int details, int protocol)
 585 {
 586         if (!hidden &&
 587             lldpctl_atom_get_int(neighbor, lldpctl_k_port_hidden))
 588                 return;
 589
 590         /* user might have specified protocol to filter on display */
 591         if ((protocol != LLDPD_MODE_MAX) &&
 592             (protocol != lldpctl_atom_get_int(neighbor, lldpctl_k_port_protocol)))
 593             return;
 594
 595         lldpctl_atom_t *chassis = lldpctl_atom_get(neighbor, lldpctl_k_port_chassis);
 596
 597         tag_start(w, "interface", "Interface");
 598         tag_attr(w, "name", "",
 599             lldpctl_atom_get_str(iface, lldpctl_k_interface_name));
 600         tag_attr(w, "via" , "via",
 601             lldpctl_atom_get_str(neighbor, lldpctl_k_port_protocol));
 602         if (details > DISPLAY_BRIEF) {
 603                 tag_attr(w, "rid" , "RID",
 604                     lldpctl_atom_get_str(chassis, lldpctl_k_chassis_index));
 605                 tag_attr(w, "age" , "Time",
 606                     display_age(lldpctl_atom_get_int(neighbor, lldpctl_k_port_age)));
 607         }
 608
 609         display_chassis(w, chassis, details);
 610         display_port(w, neighbor, details);
 611         if (details == DISPLAY_DETAILS) {
 612                 display_vlans(w, neighbor);
 613                 display_ppvids(w, neighbor);
 614                 display_pids(w, neighbor);
 615                 display_med(w, neighbor, chassis);
 616         }
 617
 618         lldpctl_atom_dec_ref(chassis);
 619
 620         display_custom_tlvs(w, neighbor);
 621
 622         tag_end(w);
 623 }
 624
 625 /**
 626  * Display information about interfaces.
 627  *
 628  * @param conn       Connection to lldpd.
 629  * @param w          Writer.
 630  * @param hidden     Whatever to show hidden ports.
 631  * @param env        Environment from which we may find the list of ports.
 632  * @param details    Level of details we need (DISPLAY_*).
 633  */
 634 void
 635 display_interfaces(lldpctl_conn_t *conn, struct writer *w,
 636     struct cmd_env *env,
 637     int hidden, int details)
 638 {
 639         lldpctl_atom_t *iface;
 640         int protocol = LLDPD_MODE_MAX;
 641         const char *proto_str;
 642
 643         /* user might have specified protocol to filter display results */
 644         proto_str = cmdenv_get(env, "protocol");
 645
 646         if (proto_str) {
 647                 log_debug("display", "filter protocol: %s ", proto_str);
 648
 649                 protocol = 0;
 650                 for (lldpctl_map_t *protocol_map =
 651                          lldpctl_key_get_map(lldpctl_k_port_protocol);
 652                      protocol_map->string;
 653                      protocol_map++) {
 654                         if (!strcasecmp(proto_str, protocol_map->string)) {
 655                                 protocol = protocol_map->value;
 656                                 break;
 657                         }
 658                 }
 659         }
 660
 661         tag_start(w, "lldp", "LLDP neighbors");
 662         while ((iface = cmd_iterate_on_interfaces(conn, env))) {
 663                 lldpctl_atom_t *port;
 664                 lldpctl_atom_t *neighbors;
 665                 lldpctl_atom_t *neighbor;
 666                 port      = lldpctl_get_port(iface);
 667                 neighbors = lldpctl_atom_get(port, lldpctl_k_port_neighbors);
 668                 lldpctl_atom_foreach(neighbors, neighbor) {
 669                         display_interface(conn, w, hidden, iface, neighbor, details, protocol);
 670                 }
 671                 lldpctl_atom_dec_ref(neighbors);
 672                 lldpctl_atom_dec_ref(port);
 673         }
 674         tag_end(w);
 675 }
 676
 677 void
 678 display_stat(struct writer *w, const char *tag, const char *descr,
 679         long unsigned int cnt)
 680 {
 681         char buf[20] = {};
 682
 683         tag_start(w, tag, descr);
 684         snprintf(buf, sizeof(buf), "%lu", cnt);
 685         tag_attr(w, tag, "", buf);
 686         tag_end(w);
 687 }
 688
 689 void
 690 display_interface_stats(lldpctl_conn_t *conn, struct writer *w,
 691                 lldpctl_atom_t *port)
 692 {
 693         tag_start(w, "interface", "Interface");
 694         tag_attr(w, "name", "",
 695             lldpctl_atom_get_str(port, lldpctl_k_port_name));
 696
 697         display_stat(w, "tx", "Transmitted",
 698                         lldpctl_atom_get_int(port, lldpctl_k_tx_cnt));
 699         display_stat(w, "rx", "Received",
 700                         lldpctl_atom_get_int(port, lldpctl_k_rx_cnt));
 701
 702         display_stat(w, "rx_discarded_cnt", "Discarded",
 703                         lldpctl_atom_get_int(port,
 704                         lldpctl_k_rx_discarded_cnt));
 705
 706         display_stat(w, "rx_unrecognized_cnt", "Unrecognized",
 707                         lldpctl_atom_get_int(port,
 708                         lldpctl_k_rx_unrecognized_cnt));
 709
 710         display_stat(w, "ageout_cnt", "Ageout",
 711                         lldpctl_atom_get_int(port,
 712                         lldpctl_k_ageout_cnt));
 713
 714         display_stat(w, "insert_cnt", "Inserted",
 715                         lldpctl_atom_get_int(port,
 716                         lldpctl_k_insert_cnt));
 717
 718         display_stat(w, "delete_cnt", "Deleted",
 719                         lldpctl_atom_get_int(port,
 720                         lldpctl_k_delete_cnt));
 721
 722         tag_end(w);
 723 }
 724
 725 /**
 726  * Display interface stats
 727  *
 728  * @param conn       Connection to lldpd.
 729  * @param w          Writer.
 730  * @param env        Environment from which we may find the list of ports.
 731  */
 732 void
 733 display_interfaces_stats(lldpctl_conn_t *conn, struct writer *w,
 734     struct cmd_env *env)
 735 {
 736         lldpctl_atom_t *iface;
 737         int summary = 0;
 738         u_int64_t h_tx_cnt = 0;
 739         u_int64_t h_rx_cnt = 0;
 740         u_int64_t h_rx_discarded_cnt = 0;
 741         u_int64_t h_rx_unrecognized_cnt = 0;
 742         u_int64_t h_ageout_cnt = 0;
 743         u_int64_t h_insert_cnt = 0;
 744         u_int64_t h_delete_cnt = 0;
 745
 746         if (cmdenv_get(env, "summary"))
 747                 summary = 1;
 748
 749         tag_start(w, "lldp", (summary ? "LLDP Global statistics" :
 750                 "LLDP statistics"));
 751         while ((iface = cmd_iterate_on_interfaces(conn, env))) {
 752                 lldpctl_atom_t *port;
 753                 port      = lldpctl_get_port(iface);
 754                 if (!summary)
 755                         display_interface_stats(conn, w, port);
 756                 else {
 757                         h_tx_cnt += lldpctl_atom_get_int(port,
 758                                         lldpctl_k_tx_cnt);
 759                         h_rx_cnt += lldpctl_atom_get_int(port,
 760                                         lldpctl_k_rx_cnt);
 761                         h_rx_discarded_cnt += lldpctl_atom_get_int(port,
 762                                         lldpctl_k_rx_discarded_cnt);
 763                         h_rx_unrecognized_cnt += lldpctl_atom_get_int(port,
 764                                         lldpctl_k_rx_unrecognized_cnt);
 765                         h_ageout_cnt += lldpctl_atom_get_int(port,
 766                                                 lldpctl_k_ageout_cnt);
 767                         h_insert_cnt += lldpctl_atom_get_int(port,
 768                                                 lldpctl_k_insert_cnt);
 769                         h_delete_cnt += lldpctl_atom_get_int(port,
 770                                                 lldpctl_k_delete_cnt);
 771                 }
 772                 lldpctl_atom_dec_ref(port);
 773         }
 774
 775         if (summary) {
 776                 tag_start(w, "summary", "Summary of stats");
 777                 display_stat(w, "tx", "Transmitted", h_tx_cnt);
 778                 display_stat(w, "rx", "Received", h_rx_cnt);
 779                 display_stat(w, "rx_discarded_cnt", "Discarded",
 780                         h_rx_discarded_cnt);
 781
 782                 display_stat(w, "rx_unrecognized_cnt", "Unrecognized",
 783                         h_rx_unrecognized_cnt);
 784
 785                 display_stat(w, "ageout_cnt", "Ageout", h_ageout_cnt);
 786
 787                 display_stat(w, "insert_cnt", "Inserted", h_insert_cnt);
 788
 789                 display_stat(w, "delete_cnt", "Deleted", h_delete_cnt);
 790                 tag_end(w);
 791         }
 792         tag_end(w);
 793 }
 794
 795 static const char *
 796 N(const char *str) {
 797         if (str == NULL || strlen(str) == 0) return "(none)";
 798         return str;
 799 }
 800
 801 void
 802 display_configuration(lldpctl_conn_t *conn, struct writer *w)
 803 {
 804         lldpctl_atom_t *configuration;
 805
 806         configuration = lldpctl_get_configuration(conn);
 807         if (!configuration) {
 808                 log_warnx("lldpctl", "not able to get configuration. %s",
 809                     lldpctl_last_strerror(conn));
 810                 return;
 811         }
 812
 813         tag_start(w, "configuration", "Global configuration");
 814         tag_start(w, "config", "Configuration");
 815
 816         tag_datatag(w, "tx-delay", "Transmit delay",
 817             lldpctl_atom_get_str(configuration, lldpctl_k_config_tx_interval));
 818         tag_datatag(w, "tx-hold", "Transmit hold",
 819             lldpctl_atom_get_str(configuration, lldpctl_k_config_tx_hold));
 820         tag_datatag(w, "rx-only", "Receive mode",
 821             lldpctl_atom_get_int(configuration, lldpctl_k_config_receiveonly)?
 822             "yes":"no");
 823         tag_datatag(w, "mgmt-pattern", "Pattern for management addresses",
 824             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_mgmt_pattern)));
 825         tag_datatag(w, "iface-pattern", "Interface pattern",
 826             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_iface_pattern)));
 827         tag_datatag(w, "cid-pattern", "Interface pattern for chassis ID",
 828             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_cid_pattern)));
 829         tag_datatag(w, "description", "Override description with",
 830             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_description)));
 831         tag_datatag(w, "platform", "Override platform with",
 832             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_platform)));
 833         tag_datatag(w, "hostname", "Override system name with",
 834             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_hostname)));
 835         tag_datatag(w, "advertise-version", "Advertise version",
 836             lldpctl_atom_get_int(configuration, lldpctl_k_config_advertise_version)?
 837             "yes":"no");
 838         tag_datatag(w, "ifdescr-update", "Update interface descriptions",
 839             lldpctl_atom_get_int(configuration, lldpctl_k_config_ifdescr_update)?
 840             "yes":"no");
 841         tag_datatag(w, "iface-promisc", "Promiscuous mode on managed interfaces",
 842             lldpctl_atom_get_int(configuration, lldpctl_k_config_iface_promisc)?
 843             "yes":"no");
 844         tag_datatag(w, "lldpmed-no-inventory", "Disable LLDP-MED inventory",
 845             (lldpctl_atom_get_int(configuration, lldpctl_k_config_lldpmed_noinventory) == 0)?
 846             "no":"yes");
 847         tag_datatag(w, "lldpmed-faststart", "LLDP-MED fast start mechanism",
 848             (lldpctl_atom_get_int(configuration, lldpctl_k_config_fast_start_enabled) == 0)?
 849             "no":"yes");
 850         tag_datatag(w, "lldpmed-faststart-interval", "LLDP-MED fast start interval",
 851             N(lldpctl_atom_get_str(configuration, lldpctl_k_config_fast_start_interval)));
 852         tag_datatag(w, "bond-slave-src-mac-type",
 853                 "Source MAC for LLDP frames on bond slaves",
 854                 lldpctl_atom_get_str(configuration,
 855                         lldpctl_k_config_bond_slave_src_mac_type));
 856         tag_datatag(w, "lldp-portid-type",
 857                 "Port ID TLV subtype for LLDP frames",
 858                 lldpctl_atom_get_str(configuration,
 859                         lldpctl_k_config_lldp_portid_type));
 860         tag_datatag(w, "lldp-agent-type",
 861                 "Agent type",
 862                 lldpctl_atom_get_str(configuration,
 863                         lldpctl_k_config_lldp_agent_type));
 864
 865         tag_end(w);
 866         tag_end(w);
 867
 868         lldpctl_atom_dec_ref(configuration);
 869 }