src/network/networkctl.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2014 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <getopt.h>
  21 #include <net/if.h>
  22 #include <stdbool.h>
  23
  24 #include "sd-device.h"
  25 #include "sd-hwdb.h"
  26 #include "sd-lldp.h"
  27 #include "sd-netlink.h"
  28 #include "sd-network.h"
  29
  30 #include "alloc-util.h"
  31 #include "arphrd-list.h"
  32 #include "device-util.h"
  33 #include "ether-addr-util.h"
  34 #include "fd-util.h"
  35 #include "hwdb-util.h"
  36 #include "lldp.h"
  37 #include "local-addresses.h"
  38 #include "locale-util.h"
  39 #include "netlink-util.h"
  40 #include "pager.h"
  41 #include "parse-util.h"
  42 #include "socket-util.h"
  43 #include "sparse-endian.h"
  44 #include "stdio-util.h"
  45 #include "string-table.h"
  46 #include "string-util.h"
  47 #include "strv.h"
  48 #include "terminal-util.h"
  49 #include "util.h"
  50 #include "verbs.h"
  51
  52 static bool arg_no_pager = false;
  53 static bool arg_legend = true;
  54 static bool arg_all = false;
  55
  56 static void pager_open_if_enabled(void) {
  57
  58         if (arg_no_pager)
  59                 return;
  60
  61         pager_open(false);
  62 }
  63
  64 static int link_get_type_string(unsigned short iftype, sd_device *d, char **ret) {
  65         const char *t;
  66         char *p;
  67
  68         assert(ret);
  69
  70         if (iftype == ARPHRD_ETHER && d) {
  71                 const char *devtype = NULL, *id = NULL;
  72                 /* WLANs have iftype ARPHRD_ETHER, but we want
  73                  * to show a more useful type string for
  74                  * them */
  75
  76                 (void) sd_device_get_devtype(d, &devtype);
  77
  78                 if (streq_ptr(devtype, "wlan"))
  79                         id = "wlan";
  80                 else if (streq_ptr(devtype, "wwan"))
  81                         id = "wwan";
  82
  83                 if (id) {
  84                         p = strdup(id);
  85                         if (!p)
  86                                 return -ENOMEM;
  87
  88                         *ret = p;
  89                         return 1;
  90                 }
  91         }
  92
  93         t = arphrd_to_name(iftype);
  94         if (!t) {
  95                 *ret = NULL;
  96                 return 0;
  97         }
  98
  99         p = strdup(t);
 100         if (!p)
 101                 return -ENOMEM;
 102
 103         ascii_strlower(p);
 104         *ret = p;
 105
 106         return 0;
 107 }
 108
 109 static void operational_state_to_color(const char *state, const char **on, const char **off) {
 110         assert(on);
 111         assert(off);
 112
 113         if (streq_ptr(state, "routable")) {
 114                 *on = ansi_highlight_green();
 115                 *off = ansi_normal();
 116         } else if (streq_ptr(state, "degraded")) {
 117                 *on = ansi_highlight_yellow();
 118                 *off = ansi_normal();
 119         } else
 120                 *on = *off = "";
 121 }
 122
 123 static void setup_state_to_color(const char *state, const char **on, const char **off) {
 124         assert(on);
 125         assert(off);
 126
 127         if (streq_ptr(state, "configured")) {
 128                 *on = ansi_highlight_green();
 129                 *off = ansi_normal();
 130         } else if (streq_ptr(state, "configuring")) {
 131                 *on = ansi_highlight_yellow();
 132                 *off = ansi_normal();
 133         } else if (streq_ptr(state, "failed") || streq_ptr(state, "linger")) {
 134                 *on = ansi_highlight_red();
 135                 *off = ansi_normal();
 136         } else
 137                 *on = *off = "";
 138 }
 139
 140 typedef struct LinkInfo {
 141         char name[IFNAMSIZ+1];
 142         int ifindex;
 143         unsigned short iftype;
 144         struct ether_addr mac_address;
 145         uint32_t mtu;
 146
 147         bool has_mac_address:1;
 148         bool has_mtu:1;
 149 } LinkInfo;
 150
 151 static int link_info_compare(const void *a, const void *b) {
 152         const LinkInfo *x = a, *y = b;
 153
 154         return x->ifindex - y->ifindex;
 155 }
 156
 157 static int decode_link(sd_netlink_message *m, LinkInfo *info) {
 158         static const struct ether_addr null_address = {};
 159         const char *name;
 160         uint16_t type;
 161         int r;
 162
 163         assert(m);
 164         assert(info);
 165
 166         r = sd_netlink_message_get_type(m, &type);
 167         if (r < 0)
 168                 return r;
 169
 170         if (type != RTM_NEWLINK)
 171                 return 0;
 172
 173         r = sd_rtnl_message_link_get_ifindex(m, &info->ifindex);
 174         if (r < 0)
 175                 return r;
 176
 177         r = sd_netlink_message_read_string(m, IFLA_IFNAME, &name);
 178         if (r < 0)
 179                 return r;
 180
 181         r = sd_rtnl_message_link_get_type(m, &info->iftype);
 182         if (r < 0)
 183                 return r;
 184
 185         strncpy(info->name, name, sizeof(info->name));
 186
 187         info->has_mac_address =
 188                 sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &info->mac_address) >= 0 &&
 189                 memcmp(&info->mac_address, &null_address, sizeof(struct ether_addr)) != 0;
 190
 191         info->has_mtu =
 192                 sd_netlink_message_read_u32(m, IFLA_MTU, &info->mtu) &&
 193                 info->mtu > 0;
 194
 195         return 1;
 196 }
 197
 198 static int acquire_link_info_strv(sd_netlink *rtnl, char **l, LinkInfo **ret) {
 199         _cleanup_free_ LinkInfo *links = NULL;
 200         char **i;
 201         size_t c = 0;
 202         int r;
 203
 204         assert(rtnl);
 205         assert(ret);
 206
 207         links = new(LinkInfo, strv_length(l));
 208         if (!links)
 209                 return log_oom();
 210
 211         STRV_FOREACH(i, l) {
 212                 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
 213                 int ifindex;
 214
 215                 if (parse_ifindex(*i, &ifindex) >= 0)
 216                         r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, ifindex);
 217                 else {
 218                         r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0);
 219                         if (r < 0)
 220                                 return rtnl_log_create_error(r);
 221
 222                         r = sd_netlink_message_append_string(req, IFLA_IFNAME, *i);
 223                 }
 224                 if (r < 0)
 225                         return rtnl_log_create_error(r);
 226
 227                 r = sd_netlink_call(rtnl, req, 0, &reply);
 228                 if (r < 0)
 229                         return log_error_errno(r, "Failed to request link: %m");
 230
 231                 r = decode_link(reply, links + c);
 232                 if (r < 0)
 233                         return r;
 234                 if (r > 0)
 235                         c++;
 236         }
 237
 238         qsort_safe(links, c, sizeof(LinkInfo), link_info_compare);
 239
 240         *ret = links;
 241         links = NULL;
 242
 243         return (int) c;
 244 }
 245
 246 static int acquire_link_info_all(sd_netlink *rtnl, LinkInfo **ret) {
 247         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
 248         _cleanup_free_ LinkInfo *links = NULL;
 249         size_t allocated = 0, c = 0;
 250         sd_netlink_message *i;
 251         int r;
 252
 253         assert(rtnl);
 254         assert(ret);
 255
 256         r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0);
 257         if (r < 0)
 258                 return rtnl_log_create_error(r);
 259
 260         r = sd_netlink_message_request_dump(req, true);
 261         if (r < 0)
 262                 return rtnl_log_create_error(r);
 263
 264         r = sd_netlink_call(rtnl, req, 0, &reply);
 265         if (r < 0)
 266                 return log_error_errno(r, "Failed to enumerate links: %m");
 267
 268         for (i = reply; i; i = sd_netlink_message_next(i)) {
 269                 if (!GREEDY_REALLOC(links, allocated, c+1))
 270                         return -ENOMEM;
 271
 272                 r = decode_link(i, links + c);
 273                 if (r < 0)
 274                         return r;
 275                 if (r > 0)
 276                         c++;
 277         }
 278
 279         qsort_safe(links, c, sizeof(LinkInfo), link_info_compare);
 280
 281         *ret = links;
 282         links = NULL;
 283
 284         return (int) c;
 285 }
 286
 287 static int list_links(int argc, char *argv[], void *userdata) {
 288         _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
 289         _cleanup_free_ LinkInfo *links = NULL;
 290         int c, i, r;
 291
 292         r = sd_netlink_open(&rtnl);
 293         if (r < 0)
 294                 return log_error_errno(r, "Failed to connect to netlink: %m");
 295
 296         if (argc > 1)
 297                 c = acquire_link_info_strv(rtnl, argv + 1, &links);
 298         else
 299                 c = acquire_link_info_all(rtnl, &links);
 300         if (c < 0)
 301                 return c;
 302
 303         pager_open_if_enabled();
 304
 305         if (arg_legend)
 306                 printf("%3s %-16s %-18s %-11s %-10s\n",
 307                        "IDX",
 308                        "LINK",
 309                        "TYPE",
 310                        "OPERATIONAL",
 311                        "SETUP");
 312
 313         for (i = 0; i < c; i++) {
 314                 _cleanup_free_ char *setup_state = NULL, *operational_state = NULL;
 315                 _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 316                 const char *on_color_operational, *off_color_operational,
 317                            *on_color_setup, *off_color_setup;
 318                 char devid[2 + DECIMAL_STR_MAX(int)];
 319                 _cleanup_free_ char *t = NULL;
 320
 321                 sd_network_link_get_operational_state(links[i].ifindex, &operational_state);
 322                 operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
 323
 324                 sd_network_link_get_setup_state(links[i].ifindex, &setup_state);
 325                 setup_state_to_color(setup_state, &on_color_setup, &off_color_setup);
 326
 327                 xsprintf(devid, "n%i", links[i].ifindex);
 328                 (void) sd_device_new_from_device_id(&d, devid);
 329
 330                 link_get_type_string(links[i].iftype, d, &t);
 331
 332                 printf("%3i %-16s %-18s %s%-11s%s %s%-10s%s\n",
 333                        links[i].ifindex, links[i].name, strna(t),
 334                        on_color_operational, strna(operational_state), off_color_operational,
 335                        on_color_setup, strna(setup_state), off_color_setup);
 336         }
 337
 338         if (arg_legend)
 339                 printf("\n%i links listed.\n", c);
 340
 341         return 0;
 342 }
 343
 344 /* IEEE Organizationally Unique Identifier vendor string */
 345 static int ieee_oui(sd_hwdb *hwdb, const struct ether_addr *mac, char **ret) {
 346         const char *description;
 347         char modalias[strlen("OUI:XXYYXXYYXXYY") + 1], *desc;
 348         int r;
 349
 350         assert(ret);
 351
 352         if (!hwdb)
 353                 return -EINVAL;
 354
 355         if (!mac)
 356                 return -EINVAL;
 357
 358         /* skip commonly misused 00:00:00 (Xerox) prefix */
 359         if (memcmp(mac, "\0\0\0", 3) == 0)
 360                 return -EINVAL;
 361
 362         xsprintf(modalias, "OUI:" ETHER_ADDR_FORMAT_STR,
 363                  ETHER_ADDR_FORMAT_VAL(*mac));
 364
 365         r = sd_hwdb_get(hwdb, modalias, "ID_OUI_FROM_DATABASE", &description);
 366         if (r < 0)
 367                 return r;
 368
 369         desc = strdup(description);
 370         if (!desc)
 371                 return -ENOMEM;
 372
 373         *ret = desc;
 374
 375         return 0;
 376 }
 377
 378 static int get_gateway_description(
 379                 sd_netlink *rtnl,
 380                 sd_hwdb *hwdb,
 381                 int ifindex,
 382                 int family,
 383                 union in_addr_union *gateway,
 384                 char **gateway_description) {
 385         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
 386         sd_netlink_message *m;
 387         int r;
 388
 389         assert(rtnl);
 390         assert(ifindex >= 0);
 391         assert(family == AF_INET || family == AF_INET6);
 392         assert(gateway);
 393         assert(gateway_description);
 394
 395         r = sd_rtnl_message_new_neigh(rtnl, &req, RTM_GETNEIGH, ifindex, family);
 396         if (r < 0)
 397                 return r;
 398
 399         r = sd_netlink_message_request_dump(req, true);
 400         if (r < 0)
 401                 return r;
 402
 403         r = sd_netlink_call(rtnl, req, 0, &reply);
 404         if (r < 0)
 405                 return r;
 406
 407         for (m = reply; m; m = sd_netlink_message_next(m)) {
 408                 union in_addr_union gw = {};
 409                 struct ether_addr mac = {};
 410                 uint16_t type;
 411                 int ifi, fam;
 412
 413                 r = sd_netlink_message_get_errno(m);
 414                 if (r < 0) {
 415                         log_error_errno(r, "got error: %m");
 416                         continue;
 417                 }
 418
 419                 r = sd_netlink_message_get_type(m, &type);
 420                 if (r < 0) {
 421                         log_error_errno(r, "could not get type: %m");
 422                         continue;
 423                 }
 424
 425                 if (type != RTM_NEWNEIGH) {
 426                         log_error("type is not RTM_NEWNEIGH");
 427                         continue;
 428                 }
 429
 430                 r = sd_rtnl_message_neigh_get_family(m, &fam);
 431                 if (r < 0) {
 432                         log_error_errno(r, "could not get family: %m");
 433                         continue;
 434                 }
 435
 436                 if (fam != family) {
 437                         log_error("family is not correct");
 438                         continue;
 439                 }
 440
 441                 r = sd_rtnl_message_neigh_get_ifindex(m, &ifi);
 442                 if (r < 0) {
 443                         log_error_errno(r, "could not get ifindex: %m");
 444                         continue;
 445                 }
 446
 447                 if (ifindex > 0 && ifi != ifindex)
 448                         continue;
 449
 450                 switch (fam) {
 451                 case AF_INET:
 452                         r = sd_netlink_message_read_in_addr(m, NDA_DST, &gw.in);
 453                         if (r < 0)
 454                                 continue;
 455
 456                         break;
 457                 case AF_INET6:
 458                         r = sd_netlink_message_read_in6_addr(m, NDA_DST, &gw.in6);
 459                         if (r < 0)
 460                                 continue;
 461
 462                         break;
 463                 default:
 464                         continue;
 465                 }
 466
 467                 if (!in_addr_equal(fam, &gw, gateway))
 468                         continue;
 469
 470                 r = sd_netlink_message_read_ether_addr(m, NDA_LLADDR, &mac);
 471                 if (r < 0)
 472                         continue;
 473
 474                 r = ieee_oui(hwdb, &mac, gateway_description);
 475                 if (r < 0)
 476                         continue;
 477
 478                 return 0;
 479         }
 480
 481         return -ENODATA;
 482 }
 483
 484 static int dump_gateways(
 485                 sd_netlink *rtnl,
 486                 sd_hwdb *hwdb,
 487                 const char *prefix,
 488                 int ifindex) {
 489         _cleanup_free_ struct local_address *local = NULL;
 490         int r, n, i;
 491
 492         n = local_gateways(rtnl, ifindex, AF_UNSPEC, &local);
 493         if (n < 0)
 494                 return n;
 495
 496         for (i = 0; i < n; i++) {
 497                 _cleanup_free_ char *gateway = NULL, *description = NULL;
 498
 499                 r = in_addr_to_string(local[i].family, &local[i].address, &gateway);
 500                 if (r < 0)
 501                         return r;
 502
 503                 r = get_gateway_description(rtnl, hwdb, local[i].ifindex, local[i].family, &local[i].address, &description);
 504                 if (r < 0)
 505                         log_debug_errno(r, "Could not get description of gateway: %m");
 506
 507                 printf("%*s%s",
 508                        (int) strlen(prefix),
 509                        i == 0 ? prefix : "",
 510                        gateway);
 511
 512                 if (description)
 513                         printf(" (%s)", description);
 514
 515                 /* Show interface name for the entry if we show
 516                  * entries for all interfaces */
 517                 if (ifindex <= 0) {
 518                         char name[IF_NAMESIZE+1];
 519
 520                         if (if_indextoname(local[i].ifindex, name)) {
 521                                 fputs(" on ", stdout);
 522                                 fputs(name, stdout);
 523                         } else
 524                                 printf(" on %%%i", local[i].ifindex);
 525                 }
 526
 527                 fputc('\n', stdout);
 528         }
 529
 530         return 0;
 531 }
 532
 533 static int dump_addresses(
 534                 sd_netlink *rtnl,
 535                 const char *prefix,
 536                 int ifindex) {
 537
 538         _cleanup_free_ struct local_address *local = NULL;
 539         int r, n, i;
 540
 541         n = local_addresses(rtnl, ifindex, AF_UNSPEC, &local);
 542         if (n < 0)
 543                 return n;
 544
 545         for (i = 0; i < n; i++) {
 546                 _cleanup_free_ char *pretty = NULL;
 547
 548                 r = in_addr_to_string(local[i].family, &local[i].address, &pretty);
 549                 if (r < 0)
 550                         return r;
 551
 552                 printf("%*s%s",
 553                        (int) strlen(prefix),
 554                        i == 0 ? prefix : "",
 555                        pretty);
 556
 557                 if (ifindex <= 0) {
 558                         char name[IF_NAMESIZE+1];
 559
 560                         if (if_indextoname(local[i].ifindex, name)) {
 561                                 fputs(" on ", stdout);
 562                                 fputs(name, stdout);
 563                         } else
 564                                 printf(" on %%%i", local[i].ifindex);
 565                 }
 566
 567                 fputc('\n', stdout);
 568         }
 569
 570         return 0;
 571 }
 572
 573 static void dump_list(const char *prefix, char **l) {
 574         char **i;
 575
 576         if (strv_isempty(l))
 577                 return;
 578
 579         STRV_FOREACH(i, l) {
 580                 printf("%*s%s\n",
 581                        (int) strlen(prefix),
 582                        i == l ? prefix : "",
 583                        *i);
 584         }
 585 }
 586
 587 static int link_status_one(
 588                 sd_netlink *rtnl,
 589                 sd_hwdb *hwdb,
 590                 const LinkInfo *info) {
 591
 592         _cleanup_strv_free_ char **dns = NULL, **ntp = NULL, **search_domains = NULL, **route_domains = NULL;
 593         _cleanup_free_ char *setup_state = NULL, *operational_state = NULL, *tz = NULL;
 594         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 595         char devid[2 + DECIMAL_STR_MAX(int)];
 596         _cleanup_free_ char *t = NULL, *network = NULL;
 597         const char *driver = NULL, *path = NULL, *vendor = NULL, *model = NULL, *link = NULL;
 598         const char *on_color_operational, *off_color_operational,
 599                    *on_color_setup, *off_color_setup;
 600         _cleanup_strv_free_ char **carrier_bound_to = NULL;
 601         _cleanup_strv_free_ char **carrier_bound_by = NULL;
 602         int r;
 603
 604         assert(rtnl);
 605         assert(info);
 606
 607         (void) sd_network_link_get_operational_state(info->ifindex, &operational_state);
 608         operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
 609
 610         (void) sd_network_link_get_setup_state(info->ifindex, &setup_state);
 611         setup_state_to_color(setup_state, &on_color_setup, &off_color_setup);
 612
 613         (void) sd_network_link_get_dns(info->ifindex, &dns);
 614         (void) sd_network_link_get_search_domains(info->ifindex, &search_domains);
 615         (void) sd_network_link_get_route_domains(info->ifindex, &route_domains);
 616         (void) sd_network_link_get_ntp(info->ifindex, &ntp);
 617
 618         xsprintf(devid, "n%i", info->ifindex);
 619
 620         (void) sd_device_new_from_device_id(&d, devid);
 621
 622         if (d) {
 623                 (void) sd_device_get_property_value(d, "ID_NET_LINK_FILE", &link);
 624                 (void) sd_device_get_property_value(d, "ID_NET_DRIVER", &driver);
 625                 (void) sd_device_get_property_value(d, "ID_PATH", &path);
 626
 627                 r = sd_device_get_property_value(d, "ID_VENDOR_FROM_DATABASE", &vendor);
 628                 if (r < 0)
 629                         (void) sd_device_get_property_value(d, "ID_VENDOR", &vendor);
 630
 631                 r = sd_device_get_property_value(d, "ID_MODEL_FROM_DATABASE", &model);
 632                 if (r < 0)
 633                         (void) sd_device_get_property_value(d, "ID_MODEL", &model);
 634         }
 635
 636         link_get_type_string(info->iftype, d, &t);
 637
 638         sd_network_link_get_network_file(info->ifindex, &network);
 639
 640         sd_network_link_get_carrier_bound_to(info->ifindex, &carrier_bound_to);
 641         sd_network_link_get_carrier_bound_by(info->ifindex, &carrier_bound_by);
 642
 643         printf("%s%s%s %i: %s\n", on_color_operational, draw_special_char(DRAW_BLACK_CIRCLE), off_color_operational, info->ifindex, info->name);
 644
 645         printf("       Link File: %s\n"
 646                "    Network File: %s\n"
 647                "            Type: %s\n"
 648                "           State: %s%s%s (%s%s%s)\n",
 649                strna(link),
 650                strna(network),
 651                strna(t),
 652                on_color_operational, strna(operational_state), off_color_operational,
 653                on_color_setup, strna(setup_state), off_color_setup);
 654
 655         if (path)
 656                 printf("            Path: %s\n", path);
 657         if (driver)
 658                 printf("          Driver: %s\n", driver);
 659         if (vendor)
 660                 printf("          Vendor: %s\n", vendor);
 661         if (model)
 662                 printf("           Model: %s\n", model);
 663
 664         if (info->has_mac_address) {
 665                 _cleanup_free_ char *description = NULL;
 666                 char ea[ETHER_ADDR_TO_STRING_MAX];
 667
 668                 ieee_oui(hwdb, &info->mac_address, &description);
 669
 670                 if (description)
 671                         printf("      HW Address: %s (%s)\n", ether_addr_to_string(&info->mac_address, ea), description);
 672                 else
 673                         printf("      HW Address: %s\n", ether_addr_to_string(&info->mac_address, ea));
 674         }
 675
 676         if (info->has_mtu)
 677                 printf("             MTU: %u\n", info->mtu);
 678
 679         dump_addresses(rtnl, "         Address: ", info->ifindex);
 680         dump_gateways(rtnl, hwdb, "         Gateway: ", info->ifindex);
 681
 682         dump_list("             DNS: ", dns);
 683         dump_list("  Search Domains: ", search_domains);
 684         dump_list("   Route Domains: ", route_domains);
 685
 686         dump_list("             NTP: ", ntp);
 687
 688         dump_list("Carrier Bound To: ", carrier_bound_to);
 689         dump_list("Carrier Bound By: ", carrier_bound_by);
 690
 691         (void) sd_network_link_get_timezone(info->ifindex, &tz);
 692         if (tz)
 693                 printf("       Time Zone: %s", tz);
 694
 695         return 0;
 696 }
 697
 698 static int system_status(sd_netlink *rtnl, sd_hwdb *hwdb) {
 699         _cleanup_free_ char *operational_state = NULL;
 700         _cleanup_strv_free_ char **dns = NULL, **ntp = NULL, **search_domains = NULL, **route_domains = NULL;
 701         const char *on_color_operational, *off_color_operational;
 702
 703         assert(rtnl);
 704
 705         sd_network_get_operational_state(&operational_state);
 706         operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
 707
 708         printf("%s%s%s        State: %s%s%s\n",
 709                on_color_operational, draw_special_char(DRAW_BLACK_CIRCLE), off_color_operational,
 710                on_color_operational, strna(operational_state), off_color_operational);
 711
 712         dump_addresses(rtnl, "       Address: ", 0);
 713         dump_gateways(rtnl, hwdb, "       Gateway: ", 0);
 714
 715         sd_network_get_dns(&dns);
 716         dump_list("           DNS: ", dns);
 717
 718         sd_network_get_search_domains(&search_domains);
 719         dump_list("Search Domains: ", search_domains);
 720
 721         sd_network_get_route_domains(&route_domains);
 722         dump_list(" Route Domains: ", route_domains);
 723
 724         sd_network_get_ntp(&ntp);
 725         dump_list("           NTP: ", ntp);
 726
 727         return 0;
 728 }
 729
 730 static int link_status(int argc, char *argv[], void *userdata) {
 731         _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
 732         _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
 733         _cleanup_free_ LinkInfo *links = NULL;
 734         int r, c, i;
 735
 736         pager_open_if_enabled();
 737
 738         r = sd_netlink_open(&rtnl);
 739         if (r < 0)
 740                 return log_error_errno(r, "Failed to connect to netlink: %m");
 741
 742         r = sd_hwdb_new(&hwdb);
 743         if (r < 0)
 744                 log_debug_errno(r, "Failed to open hardware database: %m");
 745
 746         if (arg_all)
 747                 c = acquire_link_info_all(rtnl, &links);
 748         else if (argc <= 1)
 749                 return system_status(rtnl, hwdb);
 750         else
 751                 c = acquire_link_info_strv(rtnl, argv + 1, &links);
 752         if (c < 0)
 753                 return c;
 754
 755         for (i = 0; i < c; i++) {
 756                 if (i > 0)
 757                         fputc('\n', stdout);
 758
 759                 link_status_one(rtnl, hwdb, links + i);
 760         }
 761
 762         return 0;
 763 }
 764
 765 static char *lldp_capabilities_to_string(uint16_t x) {
 766         static const char characters[] = {
 767                 'o', 'p', 'b', 'w', 'r', 't', 'd', 'a', 'c', 's', 'm',
 768         };
 769         char *ret;
 770         unsigned i;
 771
 772         ret = new(char, ELEMENTSOF(characters) + 1);
 773         if (!ret)
 774                 return NULL;
 775
 776         for (i = 0; i < ELEMENTSOF(characters); i++)
 777                 ret[i] = (x & (1U << i)) ? characters[i] : '.';
 778
 779         ret[i] = 0;
 780         return ret;
 781 }
 782
 783 static int link_lldp_status(int argc, char *argv[], void *userdata) {
 784         _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
 785         _cleanup_free_ LinkInfo *links = NULL;
 786         int i, r, c, m = 0;
 787
 788         r = sd_netlink_open(&rtnl);
 789         if (r < 0)
 790                 return log_error_errno(r, "Failed to connect to netlink: %m");
 791
 792         if (argc > 1)
 793                 c = acquire_link_info_strv(rtnl, argv + 1, &links);
 794         else
 795                 c = acquire_link_info_all(rtnl, &links);
 796         if (c < 0)
 797                 return c;
 798
 799         pager_open_if_enabled();
 800
 801         if (arg_legend)
 802                 printf("%-16s %-17s %-16s %-11s %-17s %-16s\n",
 803                        "LINK",
 804                        "CHASSIS ID",
 805                        "SYSTEM NAME",
 806                        "CAPS",
 807                        "PORT ID",
 808                        "PORT DESCRIPTION");
 809
 810         for (i = 0; i < c; i++) {
 811                 _cleanup_fclose_ FILE *f = NULL;
 812                 _cleanup_free_ char *p = NULL;
 813
 814                 if (asprintf(&p, "/run/systemd/netif/lldp/%i", links[i].ifindex) < 0)
 815                         return log_oom();
 816
 817                 f = fopen(p, "re");
 818                 if (!f) {
 819                         if (errno == ENOENT)
 820                                 continue;
 821
 822                         log_warning_errno(errno, "Failed to open %s, ignoring: %m", p);
 823                         continue;
 824                 }
 825
 826                 for (;;) {
 827                         const char *chassis_id = NULL, *port_id = NULL, *system_name = NULL, *port_description = NULL, *capabilities = NULL;
 828                         _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
 829                         _cleanup_free_ void *raw = NULL;
 830                         uint16_t cc;
 831                         le64_t u;
 832                         size_t l;
 833
 834                         l = fread(&u, 1, sizeof(u), f);
 835                         if (l == 0 && feof(f)) /* EOF */
 836                                 break;
 837                         if (l != sizeof(u)) {
 838                                 log_warning("Premature end of file, ignoring.");
 839                                 break;
 840                         }
 841
 842                         raw = new(uint8_t, le64toh(u));
 843                         if (!raw)
 844                                 return log_oom();
 845
 846                         if (fread(raw, 1, le64toh(u), f) != le64toh(u)) {
 847                                 log_warning("Premature end of file, ignoring.");
 848                                 break;
 849                         }
 850
 851                         r = sd_lldp_neighbor_from_raw(&n, raw, le64toh(u));
 852                         if (r < 0) {
 853                                 log_warning_errno(r, "Failed to parse LLDP data, ignoring: %m");
 854                                 break;
 855                         }
 856
 857                         (void) sd_lldp_neighbor_get_chassis_id_as_string(n, &chassis_id);
 858                         (void) sd_lldp_neighbor_get_port_id_as_string(n, &port_id);
 859                         (void) sd_lldp_neighbor_get_system_name(n, &system_name);
 860                         (void) sd_lldp_neighbor_get_port_description(n, &port_description);
 861
 862                         if (sd_lldp_neighbor_get_enabled_capabilities(n, &cc) >= 0)
 863                                 capabilities = lldp_capabilities_to_string(cc);
 864
 865                         printf("%-16s %-17s %-16s %-11s %-17s %-16s\n",
 866                                links[i].name,
 867                                strna(chassis_id),
 868                                strna(system_name),
 869                                strna(capabilities),
 870                                strna(port_id),
 871                                strna(port_description));
 872
 873                         m++;
 874                 }
 875         }
 876
 877         if (arg_legend)
 878                 printf("\nCapability Flags:\n"
 879                        "o - Other; p - Repeater;  b - Bridge; w - WLAN Access Point; r - Router;\n"
 880                        "t - Telephone; d - DOCSIS cable device; a - Station; c - Customer VLAN;\n"
 881                        "s - Service VLAN, m - Two-port MAC Relay (TPMR)\n\n"
 882                        "%i neighbors listed.\n", m);
 883
 884         return 0;
 885 }
 886
 887 static void help(void) {
 888         printf("%s [OPTIONS...]\n\n"
 889                "Query and control the networking subsystem.\n\n"
 890                "  -h --help             Show this help\n"
 891                "     --version          Show package version\n"
 892                "     --no-pager         Do not pipe output into a pager\n"
 893                "     --no-legend        Do not show the headers and footers\n"
 894                "  -a --all              Show status for all links\n\n"
 895                "Commands:\n"
 896                "  list [LINK...]        List links\n"
 897                "  status [LINK...]      Show link status\n"
 898                "  lldp [LINK...]        Show lldp neighbors\n"
 899                , program_invocation_short_name);
 900 }
 901
 902 static int parse_argv(int argc, char *argv[]) {
 903
 904         enum {
 905                 ARG_VERSION = 0x100,
 906                 ARG_NO_PAGER,
 907                 ARG_NO_LEGEND,
 908         };
 909
 910         static const struct option options[] = {
 911                 { "help",      no_argument,       NULL, 'h'           },
 912                 { "version",   no_argument,       NULL, ARG_VERSION   },
 913                 { "no-pager",  no_argument,       NULL, ARG_NO_PAGER  },
 914                 { "no-legend", no_argument,       NULL, ARG_NO_LEGEND },
 915                 { "all",       no_argument,       NULL, 'a'           },
 916                 {}
 917         };
 918
 919         int c;
 920
 921         assert(argc >= 0);
 922         assert(argv);
 923
 924         while ((c = getopt_long(argc, argv, "ha", options, NULL)) >= 0) {
 925
 926                 switch (c) {
 927
 928                 case 'h':
 929                         help();
 930                         return 0;
 931
 932                 case ARG_VERSION:
 933                         return version();
 934
 935                 case ARG_NO_PAGER:
 936                         arg_no_pager = true;
 937                         break;
 938
 939                 case ARG_NO_LEGEND:
 940                         arg_legend = false;
 941                         break;
 942
 943                 case 'a':
 944                         arg_all = true;
 945                         break;
 946
 947                 case '?':
 948                         return -EINVAL;
 949
 950                 default:
 951                         assert_not_reached("Unhandled option");
 952                 }
 953         }
 954
 955         return 1;
 956 }
 957
 958 static int networkctl_main(int argc, char *argv[]) {
 959         const Verb verbs[] = {
 960                 { "list",   VERB_ANY, VERB_ANY, VERB_DEFAULT, list_links       },
 961                 { "status", VERB_ANY, VERB_ANY, 0,            link_status      },
 962                 { "lldp",   VERB_ANY, VERB_ANY, 0,            link_lldp_status },
 963                 {}
 964         };
 965
 966         return dispatch_verb(argc, argv, verbs, NULL);
 967 }
 968
 969 int main(int argc, char* argv[]) {
 970         int r;
 971
 972         log_parse_environment();
 973         log_open();
 974
 975         r = parse_argv(argc, argv);
 976         if (r <= 0)
 977                 goto finish;
 978
 979         r = networkctl_main(argc, argv);
 980
 981 finish:
 982         pager_close();
 983
 984         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 985 }