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                 (void) 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                 r = sd_network_link_get_setup_state(links[i].ifindex, &setup_state);
 325                 if (r == -ENODATA) /* If there's no info available about this iface, it's unmanaged by networkd */
 326                         setup_state = strdup("unmanaged");
 327                 setup_state_to_color(setup_state, &on_color_setup, &off_color_setup);
 328
 329                 xsprintf(devid, "n%i", links[i].ifindex);
 330                 (void) sd_device_new_from_device_id(&d, devid);
 331
 332                 (void) link_get_type_string(links[i].iftype, d, &t);
 333
 334                 printf("%3i %-16s %-18s %s%-11s%s %s%-10s%s\n",
 335                        links[i].ifindex, links[i].name, strna(t),
 336                        on_color_operational, strna(operational_state), off_color_operational,
 337                        on_color_setup, strna(setup_state), off_color_setup);
 338         }
 339
 340         if (arg_legend)
 341                 printf("\n%i links listed.\n", c);
 342
 343         return 0;
 344 }
 345
 346 /* IEEE Organizationally Unique Identifier vendor string */
 347 static int ieee_oui(sd_hwdb *hwdb, const struct ether_addr *mac, char **ret) {
 348         const char *description;
 349         char modalias[strlen("OUI:XXYYXXYYXXYY") + 1], *desc;
 350         int r;
 351
 352         assert(ret);
 353
 354         if (!hwdb)
 355                 return -EINVAL;
 356
 357         if (!mac)
 358                 return -EINVAL;
 359
 360         /* skip commonly misused 00:00:00 (Xerox) prefix */
 361         if (memcmp(mac, "\0\0\0", 3) == 0)
 362                 return -EINVAL;
 363
 364         xsprintf(modalias, "OUI:" ETHER_ADDR_FORMAT_STR,
 365                  ETHER_ADDR_FORMAT_VAL(*mac));
 366
 367         r = sd_hwdb_get(hwdb, modalias, "ID_OUI_FROM_DATABASE", &description);
 368         if (r < 0)
 369                 return r;
 370
 371         desc = strdup(description);
 372         if (!desc)
 373                 return -ENOMEM;
 374
 375         *ret = desc;
 376
 377         return 0;
 378 }
 379
 380 static int get_gateway_description(
 381                 sd_netlink *rtnl,
 382                 sd_hwdb *hwdb,
 383                 int ifindex,
 384                 int family,
 385                 union in_addr_union *gateway,
 386                 char **gateway_description) {
 387         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
 388         sd_netlink_message *m;
 389         int r;
 390
 391         assert(rtnl);
 392         assert(ifindex >= 0);
 393         assert(family == AF_INET || family == AF_INET6);
 394         assert(gateway);
 395         assert(gateway_description);
 396
 397         r = sd_rtnl_message_new_neigh(rtnl, &req, RTM_GETNEIGH, ifindex, family);
 398         if (r < 0)
 399                 return r;
 400
 401         r = sd_netlink_message_request_dump(req, true);
 402         if (r < 0)
 403                 return r;
 404
 405         r = sd_netlink_call(rtnl, req, 0, &reply);
 406         if (r < 0)
 407                 return r;
 408
 409         for (m = reply; m; m = sd_netlink_message_next(m)) {
 410                 union in_addr_union gw = {};
 411                 struct ether_addr mac = {};
 412                 uint16_t type;
 413                 int ifi, fam;
 414
 415                 r = sd_netlink_message_get_errno(m);
 416                 if (r < 0) {
 417                         log_error_errno(r, "got error: %m");
 418                         continue;
 419                 }
 420
 421                 r = sd_netlink_message_get_type(m, &type);
 422                 if (r < 0) {
 423                         log_error_errno(r, "could not get type: %m");
 424                         continue;
 425                 }
 426
 427                 if (type != RTM_NEWNEIGH) {
 428                         log_error("type is not RTM_NEWNEIGH");
 429                         continue;
 430                 }
 431
 432                 r = sd_rtnl_message_neigh_get_family(m, &fam);
 433                 if (r < 0) {
 434                         log_error_errno(r, "could not get family: %m");
 435                         continue;
 436                 }
 437
 438                 if (fam != family) {
 439                         log_error("family is not correct");
 440                         continue;
 441                 }
 442
 443                 r = sd_rtnl_message_neigh_get_ifindex(m, &ifi);
 444                 if (r < 0) {
 445                         log_error_errno(r, "could not get ifindex: %m");
 446                         continue;
 447                 }
 448
 449                 if (ifindex > 0 && ifi != ifindex)
 450                         continue;
 451
 452                 switch (fam) {
 453                 case AF_INET:
 454                         r = sd_netlink_message_read_in_addr(m, NDA_DST, &gw.in);
 455                         if (r < 0)
 456                                 continue;
 457
 458                         break;
 459                 case AF_INET6:
 460                         r = sd_netlink_message_read_in6_addr(m, NDA_DST, &gw.in6);
 461                         if (r < 0)
 462                                 continue;
 463
 464                         break;
 465                 default:
 466                         continue;
 467                 }
 468
 469                 if (!in_addr_equal(fam, &gw, gateway))
 470                         continue;
 471
 472                 r = sd_netlink_message_read_ether_addr(m, NDA_LLADDR, &mac);
 473                 if (r < 0)
 474                         continue;
 475
 476                 r = ieee_oui(hwdb, &mac, gateway_description);
 477                 if (r < 0)
 478                         continue;
 479
 480                 return 0;
 481         }
 482
 483         return -ENODATA;
 484 }
 485
 486 static int dump_gateways(
 487                 sd_netlink *rtnl,
 488                 sd_hwdb *hwdb,
 489                 const char *prefix,
 490                 int ifindex) {
 491         _cleanup_free_ struct local_address *local = NULL;
 492         int r, n, i;
 493
 494         assert(rtnl);
 495         assert(prefix);
 496
 497         n = local_gateways(rtnl, ifindex, AF_UNSPEC, &local);
 498         if (n < 0)
 499                 return n;
 500
 501         for (i = 0; i < n; i++) {
 502                 _cleanup_free_ char *gateway = NULL, *description = NULL;
 503
 504                 r = in_addr_to_string(local[i].family, &local[i].address, &gateway);
 505                 if (r < 0)
 506                         return r;
 507
 508                 r = get_gateway_description(rtnl, hwdb, local[i].ifindex, local[i].family, &local[i].address, &description);
 509                 if (r < 0)
 510                         log_debug_errno(r, "Could not get description of gateway: %m");
 511
 512                 printf("%*s%s",
 513                        (int) strlen(prefix),
 514                        i == 0 ? prefix : "",
 515                        gateway);
 516
 517                 if (description)
 518                         printf(" (%s)", description);
 519
 520                 /* Show interface name for the entry if we show
 521                  * entries for all interfaces */
 522                 if (ifindex <= 0) {
 523                         char name[IF_NAMESIZE+1];
 524
 525                         if (if_indextoname(local[i].ifindex, name)) {
 526                                 fputs(" on ", stdout);
 527                                 fputs(name, stdout);
 528                         } else
 529                                 printf(" on %%%i", local[i].ifindex);
 530                 }
 531
 532                 fputc('\n', stdout);
 533         }
 534
 535         return 0;
 536 }
 537
 538 static int dump_addresses(
 539                 sd_netlink *rtnl,
 540                 const char *prefix,
 541                 int ifindex) {
 542
 543         _cleanup_free_ struct local_address *local = NULL;
 544         int r, n, i;
 545
 546         assert(rtnl);
 547         assert(prefix);
 548
 549         n = local_addresses(rtnl, ifindex, AF_UNSPEC, &local);
 550         if (n < 0)
 551                 return n;
 552
 553         for (i = 0; i < n; i++) {
 554                 _cleanup_free_ char *pretty = NULL;
 555
 556                 r = in_addr_to_string(local[i].family, &local[i].address, &pretty);
 557                 if (r < 0)
 558                         return r;
 559
 560                 printf("%*s%s",
 561                        (int) strlen(prefix),
 562                        i == 0 ? prefix : "",
 563                        pretty);
 564
 565                 if (ifindex <= 0) {
 566                         char name[IF_NAMESIZE+1];
 567
 568                         if (if_indextoname(local[i].ifindex, name)) {
 569                                 fputs(" on ", stdout);
 570                                 fputs(name, stdout);
 571                         } else
 572                                 printf(" on %%%i", local[i].ifindex);
 573                 }
 574
 575                 fputc('\n', stdout);
 576         }
 577
 578         return 0;
 579 }
 580
 581 static int open_lldp_neighbors(int ifindex, FILE **ret) {
 582         _cleanup_free_ char *p = NULL;
 583         FILE *f;
 584
 585         if (asprintf(&p, "/run/systemd/netif/lldp/%i", ifindex) < 0)
 586                 return -ENOMEM;
 587
 588         f = fopen(p, "re");
 589         if (!f)
 590                 return -errno;
 591
 592         *ret = f;
 593         return 0;
 594 }
 595
 596 static int next_lldp_neighbor(FILE *f, sd_lldp_neighbor **ret) {
 597         _cleanup_free_ void *raw = NULL;
 598         size_t l;
 599         le64_t u;
 600         int r;
 601
 602         assert(f);
 603         assert(ret);
 604
 605         l = fread(&u, 1, sizeof(u), f);
 606         if (l == 0 && feof(f))
 607                 return 0;
 608         if (l != sizeof(u))
 609                 return -EBADMSG;
 610
 611         raw = new(uint8_t, le64toh(u));
 612         if (!raw)
 613                 return -ENOMEM;
 614
 615         if (fread(raw, 1, le64toh(u), f) != le64toh(u))
 616                 return -EBADMSG;
 617
 618         r = sd_lldp_neighbor_from_raw(ret, raw, le64toh(u));
 619         if (r < 0)
 620                 return r;
 621
 622         return 1;
 623 }
 624
 625 static int dump_lldp_neighbors(const char *prefix, int ifindex) {
 626         _cleanup_fclose_ FILE *f = NULL;
 627         int r, c = 0;
 628
 629         assert(prefix);
 630         assert(ifindex > 0);
 631
 632         r = open_lldp_neighbors(ifindex, &f);
 633         if (r < 0)
 634                 return r;
 635
 636         for (;;) {
 637                 const char *system_name = NULL, *port_id = NULL, *port_description = NULL;
 638                 _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
 639
 640                 r = next_lldp_neighbor(f, &n);
 641                 if (r < 0)
 642                         return r;
 643                 if (r == 0)
 644                         break;
 645
 646                 printf("%*s",
 647                        (int) strlen(prefix),
 648                        c == 0 ? prefix : "");
 649
 650                 (void) sd_lldp_neighbor_get_system_name(n, &system_name);
 651                 (void) sd_lldp_neighbor_get_port_id_as_string(n, &port_id);
 652                 (void) sd_lldp_neighbor_get_port_description(n, &port_description);
 653
 654                 printf("%s on port %s", strna(system_name), strna(port_id));
 655
 656                 if (!isempty(port_description))
 657                         printf(" (%s)", port_description);
 658
 659                 putchar('\n');
 660
 661                 c++;
 662         }
 663
 664         return c;
 665 }
 666
 667 static void dump_ifindexes(const char *prefix, const int *ifindexes) {
 668         unsigned c;
 669
 670         assert(prefix);
 671
 672         if (!ifindexes || ifindexes[0] <= 0)
 673                 return;
 674
 675         for (c = 0; ifindexes[c] > 0; c++) {
 676                 char name[IF_NAMESIZE+1];
 677
 678                 printf("%*s",
 679                        (int) strlen(prefix),
 680                        c == 0 ? prefix : "");
 681
 682                 if (if_indextoname(ifindexes[c], name))
 683                         fputs(name, stdout);
 684                 else
 685                         printf("%i", ifindexes[c]);
 686
 687                 fputc('\n', stdout);
 688         }
 689 }
 690
 691 static void dump_list(const char *prefix, char **l) {
 692         char **i;
 693
 694         if (strv_isempty(l))
 695                 return;
 696
 697         STRV_FOREACH(i, l) {
 698                 printf("%*s%s\n",
 699                        (int) strlen(prefix),
 700                        i == l ? prefix : "",
 701                        *i);
 702         }
 703 }
 704
 705 static int link_status_one(
 706                 sd_netlink *rtnl,
 707                 sd_hwdb *hwdb,
 708                 const LinkInfo *info) {
 709
 710         _cleanup_strv_free_ char **dns = NULL, **ntp = NULL, **search_domains = NULL, **route_domains = NULL;
 711         _cleanup_free_ char *setup_state = NULL, *operational_state = NULL, *tz = NULL;
 712         _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 713         char devid[2 + DECIMAL_STR_MAX(int)];
 714         _cleanup_free_ char *t = NULL, *network = NULL;
 715         const char *driver = NULL, *path = NULL, *vendor = NULL, *model = NULL, *link = NULL;
 716         const char *on_color_operational, *off_color_operational,
 717                    *on_color_setup, *off_color_setup;
 718         _cleanup_free_ int *carrier_bound_to = NULL, *carrier_bound_by = NULL;
 719         int r;
 720
 721         assert(rtnl);
 722         assert(info);
 723
 724         (void) sd_network_link_get_operational_state(info->ifindex, &operational_state);
 725         operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
 726
 727         r = sd_network_link_get_setup_state(info->ifindex, &setup_state);
 728         if (r == -ENODATA) /* If there's no info available about this iface, it's unmanaged by networkd */
 729                 setup_state = strdup("unmanaged");
 730         setup_state_to_color(setup_state, &on_color_setup, &off_color_setup);
 731
 732         (void) sd_network_link_get_dns(info->ifindex, &dns);
 733         (void) sd_network_link_get_search_domains(info->ifindex, &search_domains);
 734         (void) sd_network_link_get_route_domains(info->ifindex, &route_domains);
 735         (void) sd_network_link_get_ntp(info->ifindex, &ntp);
 736
 737         xsprintf(devid, "n%i", info->ifindex);
 738
 739         (void) sd_device_new_from_device_id(&d, devid);
 740
 741         if (d) {
 742                 (void) sd_device_get_property_value(d, "ID_NET_LINK_FILE", &link);
 743                 (void) sd_device_get_property_value(d, "ID_NET_DRIVER", &driver);
 744                 (void) sd_device_get_property_value(d, "ID_PATH", &path);
 745
 746                 r = sd_device_get_property_value(d, "ID_VENDOR_FROM_DATABASE", &vendor);
 747                 if (r < 0)
 748                         (void) sd_device_get_property_value(d, "ID_VENDOR", &vendor);
 749
 750                 r = sd_device_get_property_value(d, "ID_MODEL_FROM_DATABASE", &model);
 751                 if (r < 0)
 752                         (void) sd_device_get_property_value(d, "ID_MODEL", &model);
 753         }
 754
 755         (void) link_get_type_string(info->iftype, d, &t);
 756
 757         (void) sd_network_link_get_network_file(info->ifindex, &network);
 758
 759         (void) sd_network_link_get_carrier_bound_to(info->ifindex, &carrier_bound_to);
 760         (void) sd_network_link_get_carrier_bound_by(info->ifindex, &carrier_bound_by);
 761
 762         printf("%s%s%s %i: %s\n", on_color_operational, draw_special_char(DRAW_BLACK_CIRCLE), off_color_operational, info->ifindex, info->name);
 763
 764         printf("       Link File: %s\n"
 765                "    Network File: %s\n"
 766                "            Type: %s\n"
 767                "           State: %s%s%s (%s%s%s)\n",
 768                strna(link),
 769                strna(network),
 770                strna(t),
 771                on_color_operational, strna(operational_state), off_color_operational,
 772                on_color_setup, strna(setup_state), off_color_setup);
 773
 774         if (path)
 775                 printf("            Path: %s\n", path);
 776         if (driver)
 777                 printf("          Driver: %s\n", driver);
 778         if (vendor)
 779                 printf("          Vendor: %s\n", vendor);
 780         if (model)
 781                 printf("           Model: %s\n", model);
 782
 783         if (info->has_mac_address) {
 784                 _cleanup_free_ char *description = NULL;
 785                 char ea[ETHER_ADDR_TO_STRING_MAX];
 786
 787                 (void) ieee_oui(hwdb, &info->mac_address, &description);
 788
 789                 if (description)
 790                         printf("      HW Address: %s (%s)\n", ether_addr_to_string(&info->mac_address, ea), description);
 791                 else
 792                         printf("      HW Address: %s\n", ether_addr_to_string(&info->mac_address, ea));
 793         }
 794
 795         if (info->has_mtu)
 796                 printf("             MTU: %u\n", info->mtu);
 797
 798         (void) dump_addresses(rtnl, "         Address: ", info->ifindex);
 799         (void) dump_gateways(rtnl, hwdb, "         Gateway: ", info->ifindex);
 800
 801         dump_list("             DNS: ", dns);
 802         dump_list("  Search Domains: ", search_domains);
 803         dump_list("   Route Domains: ", route_domains);
 804
 805         dump_list("             NTP: ", ntp);
 806
 807         dump_ifindexes("Carrier Bound To: ", carrier_bound_to);
 808         dump_ifindexes("Carrier Bound By: ", carrier_bound_by);
 809
 810         (void) sd_network_link_get_timezone(info->ifindex, &tz);
 811         if (tz)
 812                 printf("       Time Zone: %s\n", tz);
 813
 814         (void) dump_lldp_neighbors("    Connected To: ", info->ifindex);
 815
 816         return 0;
 817 }
 818
 819 static int system_status(sd_netlink *rtnl, sd_hwdb *hwdb) {
 820         _cleanup_free_ char *operational_state = NULL;
 821         _cleanup_strv_free_ char **dns = NULL, **ntp = NULL, **search_domains = NULL, **route_domains = NULL;
 822         const char *on_color_operational, *off_color_operational;
 823
 824         assert(rtnl);
 825
 826         (void) sd_network_get_operational_state(&operational_state);
 827         operational_state_to_color(operational_state, &on_color_operational, &off_color_operational);
 828
 829         printf("%s%s%s        State: %s%s%s\n",
 830                on_color_operational, draw_special_char(DRAW_BLACK_CIRCLE), off_color_operational,
 831                on_color_operational, strna(operational_state), off_color_operational);
 832
 833         (void) dump_addresses(rtnl, "       Address: ", 0);
 834         (void) dump_gateways(rtnl, hwdb, "       Gateway: ", 0);
 835
 836         (void) sd_network_get_dns(&dns);
 837         dump_list("           DNS: ", dns);
 838
 839         (void) sd_network_get_search_domains(&search_domains);
 840         dump_list("Search Domains: ", search_domains);
 841
 842         (void) sd_network_get_route_domains(&route_domains);
 843         dump_list(" Route Domains: ", route_domains);
 844
 845         (void) sd_network_get_ntp(&ntp);
 846         dump_list("           NTP: ", ntp);
 847
 848         return 0;
 849 }
 850
 851 static int link_status(int argc, char *argv[], void *userdata) {
 852         _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
 853         _cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
 854         _cleanup_free_ LinkInfo *links = NULL;
 855         int r, c, i;
 856
 857         pager_open_if_enabled();
 858
 859         r = sd_netlink_open(&rtnl);
 860         if (r < 0)
 861                 return log_error_errno(r, "Failed to connect to netlink: %m");
 862
 863         r = sd_hwdb_new(&hwdb);
 864         if (r < 0)
 865                 log_debug_errno(r, "Failed to open hardware database: %m");
 866
 867         if (arg_all)
 868                 c = acquire_link_info_all(rtnl, &links);
 869         else if (argc <= 1)
 870                 return system_status(rtnl, hwdb);
 871         else
 872                 c = acquire_link_info_strv(rtnl, argv + 1, &links);
 873         if (c < 0)
 874                 return c;
 875
 876         for (i = 0; i < c; i++) {
 877                 if (i > 0)
 878                         fputc('\n', stdout);
 879
 880                 link_status_one(rtnl, hwdb, links + i);
 881         }
 882
 883         return 0;
 884 }
 885
 886 static char *lldp_capabilities_to_string(uint16_t x) {
 887         static const char characters[] = {
 888                 'o', 'p', 'b', 'w', 'r', 't', 'd', 'a', 'c', 's', 'm',
 889         };
 890         char *ret;
 891         unsigned i;
 892
 893         ret = new(char, ELEMENTSOF(characters) + 1);
 894         if (!ret)
 895                 return NULL;
 896
 897         for (i = 0; i < ELEMENTSOF(characters); i++)
 898                 ret[i] = (x & (1U << i)) ? characters[i] : '.';
 899
 900         ret[i] = 0;
 901         return ret;
 902 }
 903
 904 static void lldp_capabilities_legend(uint16_t x) {
 905         unsigned w, i, cols = columns();
 906         static const char* const table[] = {
 907                 "o - Other",
 908                 "p - Repeater",
 909                 "b - Bridge",
 910                 "w - WLAN Access Point",
 911                 "r - Router",
 912                 "t - Telephone",
 913                 "d - DOCSIS cable device",
 914                 "a - Station",
 915                 "c - Customer VLAN",
 916                 "s - Service VLAN",
 917                 "m - Two-port MAC Relay (TPMR)",
 918         };
 919
 920         if (x == 0)
 921                 return;
 922
 923         printf("\nCapability Flags:\n");
 924         for (w = 0, i = 0; i < ELEMENTSOF(table); i++)
 925                 if (x & (1U << i) || arg_all) {
 926                         bool newline;
 927
 928                         newline = w + strlen(table[i]) + (w == 0 ? 0 : 2) > cols;
 929                         if (newline)
 930                                 w = 0;
 931                         w += printf("%s%s%s", newline ? "\n" : "", w == 0 ? "" : "; ", table[i]);
 932                 }
 933         puts("");
 934 }
 935
 936 static int link_lldp_status(int argc, char *argv[], void *userdata) {
 937         _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
 938         _cleanup_free_ LinkInfo *links = NULL;
 939         int i, r, c, m = 0;
 940         uint16_t all = 0;
 941
 942         r = sd_netlink_open(&rtnl);
 943         if (r < 0)
 944                 return log_error_errno(r, "Failed to connect to netlink: %m");
 945
 946         if (argc > 1)
 947                 c = acquire_link_info_strv(rtnl, argv + 1, &links);
 948         else
 949                 c = acquire_link_info_all(rtnl, &links);
 950         if (c < 0)
 951                 return c;
 952
 953         pager_open_if_enabled();
 954
 955         if (arg_legend)
 956                 printf("%-16s %-17s %-16s %-11s %-17s %-16s\n",
 957                        "LINK",
 958                        "CHASSIS ID",
 959                        "SYSTEM NAME",
 960                        "CAPS",
 961                        "PORT ID",
 962                        "PORT DESCRIPTION");
 963
 964         for (i = 0; i < c; i++) {
 965                 _cleanup_fclose_ FILE *f = NULL;
 966
 967                 r = open_lldp_neighbors(links[i].ifindex, &f);
 968                 if (r == -ENOENT)
 969                         continue;
 970                 if (r < 0) {
 971                         log_warning_errno(r, "Failed to open LLDP data for %i, ignoring: %m", links[i].ifindex);
 972                         continue;
 973                 }
 974
 975                 for (;;) {
 976                         _cleanup_free_ char *cid = NULL, *pid = NULL, *sname = NULL, *pdesc = NULL;
 977                         const char *chassis_id = NULL, *port_id = NULL, *system_name = NULL, *port_description = NULL, *capabilities = NULL;
 978                         _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
 979                         uint16_t cc;
 980
 981                         r = next_lldp_neighbor(f, &n);
 982                         if (r < 0) {
 983                                 log_warning_errno(r, "Failed to read neighbor data: %m");
 984                                 break;
 985                         }
 986                         if (r == 0)
 987                                 break;
 988
 989                         (void) sd_lldp_neighbor_get_chassis_id_as_string(n, &chassis_id);
 990                         (void) sd_lldp_neighbor_get_port_id_as_string(n, &port_id);
 991                         (void) sd_lldp_neighbor_get_system_name(n, &system_name);
 992                         (void) sd_lldp_neighbor_get_port_description(n, &port_description);
 993
 994                         if (chassis_id) {
 995                                 cid = ellipsize(chassis_id, 17, 100);
 996                                 if (cid)
 997                                         chassis_id = cid;
 998                         }
 999
1000                         if (port_id) {
1001                                 pid = ellipsize(port_id, 17, 100);
1002                                 if (pid)
1003                                         port_id = pid;
1004                         }
1005
1006                         if (system_name) {
1007                                 sname = ellipsize(system_name, 16, 100);
1008                                 if (sname)
1009                                         system_name = sname;
1010                         }
1011
1012                         if (port_description) {
1013                                 pdesc = ellipsize(port_description, 16, 100);
1014                                 if (pdesc)
1015                                         port_description = pdesc;
1016                         }
1017
1018                         if (sd_lldp_neighbor_get_enabled_capabilities(n, &cc) >= 0) {
1019                                 capabilities = lldp_capabilities_to_string(cc);
1020                                 all |= cc;
1021                         }
1022
1023                         printf("%-16s %-17s %-16s %-11s %-17s %-16s\n",
1024                                links[i].name,
1025                                strna(chassis_id),
1026                                strna(system_name),
1027                                strna(capabilities),
1028                                strna(port_id),
1029                                strna(port_description));
1030
1031                         m++;
1032                 }
1033         }
1034
1035         if (arg_legend) {
1036                 lldp_capabilities_legend(all);
1037                 printf("\n%i neighbors listed.\n", m);
1038         }
1039
1040         return 0;
1041 }
1042
1043 static void help(void) {
1044         printf("%s [OPTIONS...]\n\n"
1045                "Query and control the networking subsystem.\n\n"
1046                "  -h --help             Show this help\n"
1047                "     --version          Show package version\n"
1048                "     --no-pager         Do not pipe output into a pager\n"
1049                "     --no-legend        Do not show the headers and footers\n"
1050                "  -a --all              Show status for all links\n\n"
1051                "Commands:\n"
1052                "  list [LINK...]        List links\n"
1053                "  status [LINK...]      Show link status\n"
1054                "  lldp [LINK...]        Show LLDP neighbors\n"
1055                , program_invocation_short_name);
1056 }
1057
1058 static int parse_argv(int argc, char *argv[]) {
1059
1060         enum {
1061                 ARG_VERSION = 0x100,
1062                 ARG_NO_PAGER,
1063                 ARG_NO_LEGEND,
1064         };
1065
1066         static const struct option options[] = {
1067                 { "help",      no_argument,       NULL, 'h'           },
1068                 { "version",   no_argument,       NULL, ARG_VERSION   },
1069                 { "no-pager",  no_argument,       NULL, ARG_NO_PAGER  },
1070                 { "no-legend", no_argument,       NULL, ARG_NO_LEGEND },
1071                 { "all",       no_argument,       NULL, 'a'           },
1072                 {}
1073         };
1074
1075         int c;
1076
1077         assert(argc >= 0);
1078         assert(argv);
1079
1080         while ((c = getopt_long(argc, argv, "ha", options, NULL)) >= 0) {
1081
1082                 switch (c) {
1083
1084                 case 'h':
1085                         help();
1086                         return 0;
1087
1088                 case ARG_VERSION:
1089                         return version();
1090
1091                 case ARG_NO_PAGER:
1092                         arg_no_pager = true;
1093                         break;
1094
1095                 case ARG_NO_LEGEND:
1096                         arg_legend = false;
1097                         break;
1098
1099                 case 'a':
1100                         arg_all = true;
1101                         break;
1102
1103                 case '?':
1104                         return -EINVAL;
1105
1106                 default:
1107                         assert_not_reached("Unhandled option");
1108                 }
1109         }
1110
1111         return 1;
1112 }
1113
1114 static int networkctl_main(int argc, char *argv[]) {
1115         const Verb verbs[] = {
1116                 { "list",   VERB_ANY, VERB_ANY, VERB_DEFAULT, list_links       },
1117                 { "status", VERB_ANY, VERB_ANY, 0,            link_status      },
1118                 { "lldp",   VERB_ANY, VERB_ANY, 0,            link_lldp_status },
1119                 {}
1120         };
1121
1122         return dispatch_verb(argc, argv, verbs, NULL);
1123 }
1124
1125 static void warn_networkd_missing(void) {
1126
1127         if (access("/run/systemd/netif/state", F_OK) >= 0)
1128                 return;
1129
1130         fprintf(stderr, "WARNING: systemd-networkd is not running, output will be incomplete.\n\n");
1131 }
1132
1133 int main(int argc, char* argv[]) {
1134         int r;
1135
1136         log_parse_environment();
1137         log_open();
1138
1139         r = parse_argv(argc, argv);
1140         if (r <= 0)
1141                 goto finish;
1142
1143         warn_networkd_missing();
1144
1145         r = networkctl_main(argc, argv);
1146
1147 finish:
1148         pager_close();
1149
1150         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1151 }