#include <arpa/inet.h>

#include <getopt.h>

#include <linux/if_addrlabel.h>

#include <net/if.h>

#include <stdbool.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <unistd.h>

#include <linux/if_bridge.h>

#include <linux/if_tunnel.h>

#include "sd-bus.h"

#include "sd-device.h"

#include "sd-dhcp-client.h"

#include "sd-hwdb.h"

#include "sd-lldp.h"

#include "sd-netlink.h"

#include "sd-network.h"

#include "alloc-util.h"

#include "bond-util.h"

#include "bridge-util.h"

#include "bus-common-errors.h"

#include "bus-error.h"

#include "bus-locator.h"

#include "device-util.h"

#include "escape.h"

#include "ether-addr-util.h"

#include "ethtool-util.h"

#include "fd-util.h"

#include "format-table.h"

#include "format-util.h"

#include "geneve-util.h"

#include "glob-util.h"

#include "hwdb-util.h"

#include "ipvlan-util.h"

#include "local-addresses.h"

#include "locale-util.h"

#include "logs-show.h"

#include "macro.h"

#include "macvlan-util.h"

#include "main-func.h"

#include "netlink-util.h"

#include "network-internal.h"

#include "network-util.h"

#include "pager.h"

#include "parse-argument.h"

#include "parse-util.h"

#include "pretty-print.h"

#include "set.h"

#include "socket-netlink.h"

#include "socket-util.h"

#include "sort-util.h"

#include "sparse-endian.h"

#include "stdio-util.h"

#include "string-table.h"

#include "string-util.h"

#include "strv.h"

#include "strxcpyx.h"

#include "terminal-util.h"

#include "unit-def.h"

#include "verbs.h"

#include "wifi-util.h"

#define NETDEV_KIND_MAX 64

#define RCVBUF_SIZE (128*1024)

static PagerFlags arg_pager_flags = 0;

static bool arg_legend = true;

static bool arg_all = false;

static bool arg_stats = false;

static bool arg_full = false;

static unsigned arg_lines = 10;

static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;

static int get_description(JsonVariant **ret) {

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;

const char *text = NULL;

int r;

r = sd_bus_open_system(&bus);

if (r < 0)

return log_error_errno(r, "Failed to connect system bus: %m");

r = bus_call_method(bus, bus_network_mgr, "Describe", &error, &reply, NULL);

if (r < 0)

return log_error_errno(r, "Failed to get description: %s", bus_error_message(&error, r));

r = sd_bus_message_read(reply, "s", &text);

if (r < 0)

return bus_log_parse_error(r);

r = json_parse(text, 0, ret, NULL, NULL);

if (r < 0)

return log_error_errno(r, "Failed to parse JSON: %m");

return 0;

}

static int dump_manager_description(void) {

_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;

int r;

r = get_description(&v);

if (r < 0)

return r;

json_variant_dump(v, arg_json_format_flags, NULL, NULL);

return 0;

}

static int dump_link_description(char **patterns) {

_cleanup_(json_variant_unrefp) JsonVariant *v = NULL;

_cleanup_free_ bool *matched_patterns = NULL;

JsonVariant *i;

size_t c = 0;

int r;

r = get_description(&v);

if (r < 0)

return r;

matched_patterns = new0(bool, strv_length(patterns));

if (!matched_patterns)

return log_oom();

JSON_VARIANT_ARRAY_FOREACH(i, json_variant_by_key(v, "Interfaces")) {

char ifindex_str[DECIMAL_STR_MAX(intmax_t)];

const char *name;

intmax_t index;

size_t pos;

name = json_variant_string(json_variant_by_key(i, "Name"));

index = json_variant_integer(json_variant_by_key(i, "Index"));

xsprintf(ifindex_str, "%ji", index);

if (!strv_fnmatch_full(patterns, ifindex_str, 0, &pos) &&

!strv_fnmatch_full(patterns, name, 0, &pos)) {

bool match = false;

JsonVariant *a;

JSON_VARIANT_ARRAY_FOREACH(a, json_variant_by_key(i, "AlternativeNames"))

if (strv_fnmatch_full(patterns, json_variant_string(a), 0, &pos)) {

match = true;

break;

}

if (!match)

continue;

}

matched_patterns[pos] = true;

json_variant_dump(i, arg_json_format_flags, NULL, NULL);

c++;

}

/* Look if we matched all our arguments that are not globs. It is OK for a glob to match

for (size_t pos = 0; pos < strv_length(patterns); pos++) {

if (matched_patterns[pos])

continue;

if (string_is_glob(patterns[pos]))

log_debug("Pattern \"%s\" doesn't match any interface, ignoring.",

patterns[pos]);

else

return log_error_errno(SYNTHETIC_ERRNO(ENODEV),

"Interface \"%s\" not found.", patterns[pos]);

}

if (c == 0)

log_warning("No interfaces matched.");

return 0;

}

static void operational_state_to_color(const char *name, const char *state, const char **on, const char **off) {

if (STRPTR_IN_SET(state, "routable", "enslaved") ||

(streq_ptr(name, "lo") && streq_ptr(state, "carrier"))) {

if (on)

*on = ansi_highlight_green();

if (off)

*off = ansi_normal();

} else if (streq_ptr(state, "degraded")) {

if (on)

*on = ansi_highlight_yellow();

if (off)

*off = ansi_normal();

} else {

if (on)

*on = "";

if (off)

*off = "";

}

}

static void setup_state_to_color(const char *state, const char **on, const char **off) {

if (streq_ptr(state, "configured")) {

if (on)

*on = ansi_highlight_green();

if (off)

*off = ansi_normal();

} else if (streq_ptr(state, "configuring")) {

if (on)

*on = ansi_highlight_yellow();

if (off)

*off = ansi_normal();

} else if (STRPTR_IN_SET(state, "failed", "linger")) {

if (on)

*on = ansi_highlight_red();

if (off)

*off = ansi_normal();

} else {

if (on)

*on = "";

if (off)

*off = "";

}

}

static void online_state_to_color(const char *state, const char **on, const char **off) {

if (streq_ptr(state, "online")) {

if (on)

*on = ansi_highlight_green();

if (off)

*off = ansi_normal();

} else if (streq_ptr(state, "partial")) {

if (on)

*on = ansi_highlight_yellow();

if (off)

*off = ansi_normal();

} else {

if (on)

*on = "";

if (off)

*off = "";

}

}

typedef struct VxLanInfo {

} VxLanInfo;

typedef struct LinkInfo {

} LinkInfo;

static int link_info_compare(const LinkInfo *a, const LinkInfo *b) {

return CMP(a->ifindex, b->ifindex);

}

static LinkInfo* link_info_array_free(LinkInfo *array) {

for (unsigned i = 0; array && array[i].needs_freeing; i++) {

sd_device_unref(array[i].sd_device);

free(array[i].ssid);

free(array[i].qdisc);

strv_free(array[i].alternative_names);

}

return mfree(array);

}

DEFINE_TRIVIAL_CLEANUP_FUNC(LinkInfo*, link_info_array_free);

static int decode_netdev(sd_netlink_message *m, LinkInfo *info) {

const char *received_kind;

int r;

assert(m);

assert(info);

r = sd_netlink_message_enter_container(m, IFLA_LINKINFO);

if (r < 0)

return r;

r = sd_netlink_message_read_string(m, IFLA_INFO_KIND, &received_kind);

if (r < 0)

return r;

r = sd_netlink_message_enter_container(m, IFLA_INFO_DATA);

if (r < 0)

return r;

if (streq(received_kind, "bridge")) {

(void) sd_netlink_message_read_u32(m, IFLA_BR_FORWARD_DELAY, &info->forward_delay);

(void) sd_netlink_message_read_u32(m, IFLA_BR_HELLO_TIME, &info->hello_time);

(void) sd_netlink_message_read_u32(m, IFLA_BR_MAX_AGE, &info->max_age);

(void) sd_netlink_message_read_u32(m, IFLA_BR_AGEING_TIME, &info->ageing_time);

(void) sd_netlink_message_read_u32(m, IFLA_BR_STP_STATE, &info->stp_state);

(void) sd_netlink_message_read_u32(m, IFLA_BRPORT_COST, &info->cost);

(void) sd_netlink_message_read_u16(m, IFLA_BR_PRIORITY, &info->priority);

(void) sd_netlink_message_read_u8(m, IFLA_BR_MCAST_IGMP_VERSION, &info->mcast_igmp_version);

(void) sd_netlink_message_read_u8(m, IFLA_BRPORT_STATE, &info->port_state);

} if (streq(received_kind, "bond")) {

(void) sd_netlink_message_read_u8(m, IFLA_BOND_MODE, &info->mode);

(void) sd_netlink_message_read_u32(m, IFLA_BOND_MIIMON, &info->miimon);

(void) sd_netlink_message_read_u32(m, IFLA_BOND_DOWNDELAY, &info->downdelay);

(void) sd_netlink_message_read_u32(m, IFLA_BOND_UPDELAY, &info->updelay);

} else if (streq(received_kind, "vxlan")) {

(void) sd_netlink_message_read_u32(m, IFLA_VXLAN_ID, &info->vxlan_info.vni);

r = sd_netlink_message_read_in_addr(m, IFLA_VXLAN_GROUP, &info->vxlan_info.group.in);

if (r >= 0)

info->vxlan_info.group_family = AF_INET;

else {

r = sd_netlink_message_read_in6_addr(m, IFLA_VXLAN_GROUP6, &info->vxlan_info.group.in6);

if (r >= 0)

info->vxlan_info.group_family = AF_INET6;

}

r = sd_netlink_message_read_in_addr(m, IFLA_VXLAN_LOCAL, &info->vxlan_info.local.in);

if (r >= 0)

info->vxlan_info.local_family = AF_INET;

else {

r = sd_netlink_message_read_in6_addr(m, IFLA_VXLAN_LOCAL6, &info->vxlan_info.local.in6);

if (r >= 0)

info->vxlan_info.local_family = AF_INET6;

}

(void) sd_netlink_message_read_u32(m, IFLA_VXLAN_LINK, &info->vxlan_info.link);

(void) sd_netlink_message_read_u16(m, IFLA_VXLAN_PORT, &info->vxlan_info.dest_port);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_PROXY, &info->vxlan_info.proxy);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_LEARNING, &info->vxlan_info.learning);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_RSC, &info->vxlan_info.rsc);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_L3MISS, &info->vxlan_info.l3miss);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_L2MISS, &info->vxlan_info.l2miss);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_TOS, &info->vxlan_info.tos);

(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_TTL, &info->vxlan_info.ttl);

} else if (streq(received_kind, "vlan"))

(void) sd_netlink_message_read_u16(m, IFLA_VLAN_ID, &info->vlan_id);

else if (STR_IN_SET(received_kind, "ipip", "sit")) {

(void) sd_netlink_message_read_in_addr(m, IFLA_IPTUN_LOCAL, &info->local.in);

(void) sd_netlink_message_read_in_addr(m, IFLA_IPTUN_REMOTE, &info->remote.in);

} else if (streq(received_kind, "geneve")) {

(void) sd_netlink_message_read_u32(m, IFLA_GENEVE_ID, &info->vni);

r = sd_netlink_message_read_in_addr(m, IFLA_GENEVE_REMOTE, &info->remote.in);

if (r >= 0)

info->has_tunnel_ipv4 = true;

else

(void) sd_netlink_message_read_in6_addr(m, IFLA_GENEVE_REMOTE6, &info->remote.in6);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TTL, &info->ttl);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TTL_INHERIT, &info->inherit);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TOS, &info->tos);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_DF, &info->df);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_CSUM, &info->csum);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_TX, &info->csum6_tx);

(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_RX, &info->csum6_rx);

(void) sd_netlink_message_read_u16(m, IFLA_GENEVE_PORT, &info->tunnel_port);

(void) sd_netlink_message_read_u32(m, IFLA_GENEVE_LABEL, &info->label);

} else if (STR_IN_SET(received_kind, "gre", "gretap", "erspan")) {

(void) sd_netlink_message_read_in_addr(m, IFLA_GRE_LOCAL, &info->local.in);

(void) sd_netlink_message_read_in_addr(m, IFLA_GRE_REMOTE, &info->remote.in);

} else if (STR_IN_SET(received_kind, "ip6gre", "ip6gretap", "ip6erspan")) {

(void) sd_netlink_message_read_in6_addr(m, IFLA_GRE_LOCAL, &info->local.in6);

(void) sd_netlink_message_read_in6_addr(m, IFLA_GRE_REMOTE, &info->remote.in6);

} else if (streq(received_kind, "vti")) {

(void) sd_netlink_message_read_in_addr(m, IFLA_VTI_LOCAL, &info->local.in);

(void) sd_netlink_message_read_in_addr(m, IFLA_VTI_REMOTE, &info->remote.in);

} else if (streq(received_kind, "vti6")) {

(void) sd_netlink_message_read_in6_addr(m, IFLA_VTI_LOCAL, &info->local.in6);

(void) sd_netlink_message_read_in6_addr(m, IFLA_VTI_REMOTE, &info->remote.in6);

} else if (STR_IN_SET(received_kind, "macvlan", "macvtap"))

(void) sd_netlink_message_read_u32(m, IFLA_MACVLAN_MODE, &info->macvlan_mode);

else if (streq(received_kind, "ipvlan")) {

(void) sd_netlink_message_read_u16(m, IFLA_IPVLAN_MODE, &info->ipvlan_mode);

(void) sd_netlink_message_read_u16(m, IFLA_IPVLAN_FLAGS, &info->ipvlan_flags);

}

strncpy(info->netdev_kind, received_kind, IFNAMSIZ);

(void) sd_netlink_message_exit_container(m);

(void) sd_netlink_message_exit_container(m);

return 0;

}

static int decode_link(sd_netlink_message *m, LinkInfo *info, char **patterns, bool matched_patterns[]) {

_cleanup_strv_free_ char **altnames = NULL;

const char *name, *qdisc;

int ifindex, r;

uint16_t type;

assert(m);

assert(info);

r = sd_netlink_message_get_type(m, &type);

if (r < 0)

return r;

if (type != RTM_NEWLINK)

return 0;

r = sd_rtnl_message_link_get_ifindex(m, &ifindex);

if (r < 0)

return r;

r = sd_netlink_message_read_string(m, IFLA_IFNAME, &name);

if (r < 0)

return r;

r = sd_netlink_message_read_strv(m, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames);

if (r < 0 && r != -ENODATA)

return r;

if (patterns) {

char str[DECIMAL_STR_MAX(int)];

size_t pos;

assert(matched_patterns);

xsprintf(str, "%i", ifindex);

if (!strv_fnmatch_full(patterns, str, 0, &pos) &&

!strv_fnmatch_full(patterns, name, 0, &pos)) {

bool match = false;

char **p;

STRV_FOREACH(p, altnames)

if (strv_fnmatch_full(patterns, *p, 0, &pos)) {

match = true;

break;

}

if (!match)

return 0;

}

matched_patterns[pos] = true;

}

r = sd_rtnl_message_link_get_type(m, &info->iftype);

if (r < 0)

return r;

strscpy(info->name, sizeof info->name, name);

info->ifindex = ifindex;

info->alternative_names = TAKE_PTR(altnames);

info->has_mac_address =

netlink_message_read_hw_addr(m, IFLA_ADDRESS, &info->hw_address) >= 0 &&

!hw_addr_is_null(&info->hw_address);

info->has_permanent_mac_address =

ethtool_get_permanent_macaddr(NULL, info->name, &info->permanent_mac_address) >= 0 &&

!ether_addr_is_null(&info->permanent_mac_address) &&

(info->hw_address.length != sizeof(struct ether_addr) ||

memcmp(&info->permanent_mac_address, info->hw_address.bytes, sizeof(struct ether_addr)) != 0);

(void) sd_netlink_message_read_u32(m, IFLA_MTU, &info->mtu);

(void) sd_netlink_message_read_u32(m, IFLA_MIN_MTU, &info->min_mtu);

(void) sd_netlink_message_read_u32(m, IFLA_MAX_MTU, &info->max_mtu);

info->has_rx_queues =

sd_netlink_message_read_u32(m, IFLA_NUM_RX_QUEUES, &info->rx_queues) >= 0 &&

info->rx_queues > 0;

info->has_tx_queues =

sd_netlink_message_read_u32(m, IFLA_NUM_TX_QUEUES, &info->tx_queues) >= 0 &&

info->tx_queues > 0;

if (sd_netlink_message_read(m, IFLA_STATS64, sizeof info->stats64, &info->stats64) >= 0)

info->has_stats64 = true;

else if (sd_netlink_message_read(m, IFLA_STATS, sizeof info->stats, &info->stats) >= 0)

info->has_stats = true;

r = sd_netlink_message_read_string(m, IFLA_QDISC, &qdisc);

if (r >= 0) {

info->qdisc = strdup(qdisc);

if (!info->qdisc)

return log_oom();

}

(void) sd_netlink_message_read_u32(m, IFLA_MASTER, &info->master);

r = sd_netlink_message_enter_container(m, IFLA_AF_SPEC);

if (r >= 0) {

r = sd_netlink_message_enter_container(m, AF_INET6);

if (r >= 0) {

r = sd_netlink_message_read_u8(m, IFLA_INET6_ADDR_GEN_MODE, &info->addr_gen_mode);

if (r >= 0 && IN_SET(info->addr_gen_mode,

IN6_ADDR_GEN_MODE_EUI64,

IN6_ADDR_GEN_MODE_NONE,

IN6_ADDR_GEN_MODE_STABLE_PRIVACY,

IN6_ADDR_GEN_MODE_RANDOM))

info->has_ipv6_address_generation_mode = true;

(void) sd_netlink_message_exit_container(m);

}

(void) sd_netlink_message_exit_container(m);

}

/* fill kind info */

(void) decode_netdev(m, info);

return 1;

}

static int link_get_property(

const char *propname) {

_cleanup_free_ char *path = NULL, *ifindex_str = NULL;

int r;

if (asprintf(&ifindex_str, "%i", link->ifindex) < 0)

return -ENOMEM;

r = sd_bus_path_encode("/org/freedesktop/network1/link", ifindex_str, &path);

if (r < 0)

return r;

return sd_bus_call_method(

bus,

"org.freedesktop.network1",

path,

"org.freedesktop.DBus.Properties",

"Get",

error,

reply,

"ss",

iface,

propname);

}

static int acquire_link_bitrates(sd_bus *bus, LinkInfo *link) {

_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;

_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;

int r;

r = link_get_property(bus, link, &error, &reply, "org.freedesktop.network1.Link", "BitRates");

if (r < 0) {

bool quiet = sd_bus_error_has_names(&error, SD_BUS_ERROR_UNKNOWN_PROPERTY,

BUS_ERROR_SPEED_METER_INACTIVE);

return log_full_errno(quiet ? LOG_DEBUG : LOG_WARNING,

r, "Failed to query link bit rates: %s", bus_error_message(&error, r));

}

r = sd_bus_message_enter_container(reply, 'v', "(tt)");

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_read(reply, "(tt)", &link->tx_bitrate, &link->rx_bitrate);

if (r < 0)

return bus_log_parse_error(r);

r = sd_bus_message_exit_container(reply);

if (r < 0)

return bus_log_parse_error(r);

link->has_bitrates = link->tx_bitrate != UINT64_MAX && link->rx_bitrate != UINT64_MAX;

return 0;

}

static void acquire_ether_link_info(int *fd, LinkInfo *link) {

if (ethtool_get_link_info(fd, link->name,

&link->autonegotiation,

&link->speed,

&link->duplex,

&link->port) >= 0)

link->has_ethtool_link_info = true;

}

static void acquire_wlan_link_info(LinkInfo *link) {

_cleanup_(sd_netlink_unrefp) sd_netlink *genl = NULL;

const char *type = NULL;

int r, k = 0;

if (link->sd_device)

(void) sd_device_get_devtype(link->sd_device, &type);

if (!streq_ptr(type, "wlan"))

return;

r = sd_genl_socket_open(&genl);

if (r < 0) {

log_debug_errno(r, "Failed to open generic netlink socket: %m");

return;

}

(void) sd_netlink_inc_rcvbuf(genl, RCVBUF_SIZE);

r = wifi_get_interface(genl, link->ifindex, &link->wlan_iftype, &link->ssid);

if (r < 0)

log_debug_errno(r, "%s: failed to query ssid: %m", link->name);

if (link->wlan_iftype == NL80211_IFTYPE_STATION) {

k = wifi_get_station(genl, link->ifindex, &link->bssid);

if (k < 0)

log_debug_errno(k, "%s: failed to query bssid: %m", link->name);

}

link->has_wlan_link_info = r > 0 || k > 0;

}

static int acquire_link_info(sd_bus *bus, sd_netlink *rtnl, char **patterns, LinkInfo **ret) {

_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;

_cleanup_(link_info_array_freep) LinkInfo *links = NULL;

_cleanup_close_ int fd = -1;

size_t c = 0;

int r;

assert(rtnl);

assert(ret);

r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0);

if (r < 0)

return rtnl_log_create_error(r);

r = sd_netlink_message_request_dump(req, true);

if (r < 0)

return rtnl_log_create_error(r);

r = sd_netlink_call(rtnl, req, 0, &reply);

if (r < 0)

return log_error_errno(r, "Failed to enumerate links: %m");

_cleanup_free_ bool *matched_patterns = NULL;

if (patterns) {

matched_patterns = new0(bool, strv_length(patterns));

if (!matched_patterns)

return log_oom();

}

for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i)) {

if (!GREEDY_REALLOC0(links, c + 2)) /* We keep one trailing one as marker */

return -ENOMEM;

r = decode_link(i, links + c, patterns, matched_patterns);

if (r < 0)

return r;

if (r == 0)

continue;

links[c].needs_freeing = true;

(void) sd_device_new_from_ifindex(&links[c].sd_device, links[c].ifindex);

acquire_ether_link_info(&fd, &links[c]);

acquire_wlan_link_info(&links[c]);

c++;

}

/* Look if we matched all our arguments that are not globs. It

for (size_t pos = 0; pos < strv_length(patterns); pos++) {

if (matched_patterns[pos])

continue;

if (string_is_glob(patterns[pos]))

log_debug("Pattern \"%s\" doesn't match any interface, ignoring.",

patterns[pos]);

else

return log_error_errno(SYNTHETIC_ERRNO(ENODEV),

"Interface \"%s\" not found.", patterns[pos]);

}

typesafe_qsort(links, c, link_info_compare);

if (bus)

for (size_t j = 0; j < c; j++)

(void) acquire_link_bitrates(bus, links + j);

*ret = TAKE_PTR(links);

if (patterns && c == 0)

log_warning("No interfaces matched.");

return (int) c;

}

static int list_links(int argc, char *argv[], void *userdata) {

_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;

_cleanup_(link_info_array_freep) LinkInfo *links = NULL;

_cleanup_(table_unrefp) Table *table = NULL;

TableCell *cell;

int c, r;

if (arg_json_format_flags != JSON_FORMAT_OFF) {

if (arg_all || argc <= 1)

return dump_manager_description();

else

return dump_link_description(strv_skip(argv, 1));

}

r = sd_netlink_open(&rtnl);

if (r < 0)

return log_error_errno(r, "Failed to connect to netlink: %m");

c = acquire_link_info(NULL, rtnl, argc > 1 ? argv + 1 : NULL, &links);

if (c < 0)

return c;

(void) pager_open(arg_pager_flags);

table = table_new("idx", "link", "type", "operational", "setup");

if (!table)

return log_oom();

if (arg_full)

table_set_width(table, 0);

table_set_header(table, arg_legend);

if (table_set_empty_string(table, "n/a") < 0)

return log_oom();

assert_se(cell = table_get_cell(table, 0, 0));

(void) table_set_minimum_width(table, cell, 3);

(void) table_set_weight(table, cell, 0);

(void) table_set_ellipsize_percent(table, cell, 100);

(void) table_set_align_percent(table, cell, 100);

assert_se(cell = table_get_cell(table, 0, 1));

(void) table_set_ellipsize_percent(table, cell, 100);

for (int i = 0; i < c; i++) {

_cleanup_free_ char *setup_state = NULL, *operational_state = NULL;

const char *on_color_operational, *on_color_setup;

_cleanup_free_ char *t = NULL;

(void) sd_network_link_get_operational_state(links[i].ifindex, &operational_state);

operational_state_to_color(links[i].name, operational_state, &on_color_operational, NULL);

r = sd_network_link_get_setup_state(links[i].ifindex, &setup_state);

if (r == -ENODATA) /* If there's no info available about this iface, it's unmanaged by networkd */

setup_state = strdup("unmanaged");

setup_state_to_color(setup_state, &on_color_setup, NULL);

r = link_get_type_string(links[i].sd_device, links[i].iftype, &t);

if (r == -ENOMEM)

return log_oom();

r = table_add_many(table,

TABLE_INT, links[i].ifindex,

TABLE_STRING, links[i].name,

TABLE_STRING, t,

TABLE_STRING, operational_state,

TABLE_SET_COLOR, on_color_operational,

TABLE_STRING, setup_state,

TABLE_SET_COLOR, on_color_setup);

if (r < 0)

return table_log_add_error(r);

}

r = table_print(table, NULL);

if (r < 0)

return table_log_print_error(r);

if (arg_legend)

printf("\n%i links listed.\n", c);

return 0;

}

static int ieee_oui(sd_hwdb *hwdb, const struct ether_addr *mac, char **ret) {

const char *description;

char modalias[STRLEN("OUI:XXYYXXYYXXYY") + 1], *desc;

int r;

assert(ret);

if (!hwdb)

return -EINVAL;

if (!mac)

return -EINVAL;

/* skip commonly misused 00:00:00 (Xerox) prefix */

if (memcmp(mac, "\0\0\0", 3) == 0)

return -EINVAL;

xsprintf(modalias, "OUI:" ETHER_ADDR_FORMAT_STR,

ETHER_ADDR_FORMAT_VAL(*mac));

r = sd_hwdb_get(hwdb, modalias, "ID_OUI_FROM_DATABASE", &description);

if (r < 0)

return r;

desc = strdup(description);

if (!desc)

return -ENOMEM;

*ret = desc;

return 0;

}

static int get_gateway_description(

char **gateway_description) {

_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;

int r;

assert(rtnl);

assert(ifindex >= 0);

assert(IN_SET(family, AF_INET, AF_INET6));

assert(gateway);

assert(gateway_description);

r = sd_rtnl_message_new_neigh(rtnl, &req, RTM_GETNEIGH, ifindex, family);

if (r < 0)

return r;

r = sd_netlink_message_request_dump(req, true);

if (r < 0)

return r;

r = sd_netlink_call(rtnl, req, 0, &reply);

if (r < 0)

return r;

for (sd_netlink_message *m = reply; m; m = sd_netlink_message_next(m)) {

union in_addr_union gw = IN_ADDR_NULL;

struct ether_addr mac = ETHER_ADDR_NULL;

uint16_t type;

int ifi, fam;

r = sd_netlink_message_get_errno(m);

if (r < 0) {

log_error_errno(r, "got error: %m");

continue;

}

r = sd_netlink_message_get_type(m, &type);

if (r < 0) {

log_error_errno(r, "could not get type: %m");

continue;

}

if (type != RTM_NEWNEIGH) {

log_error("type is not RTM_NEWNEIGH");

continue;

}

r = sd_rtnl_message_neigh_get_family(m, &fam);

if (r < 0) {

log_error_errno(r, "could not get family: %m");

continue;

}

if (fam != family) {

log_error("family is not correct");

continue;

}

r = sd_rtnl_message_neigh_get_ifindex(m, &ifi);

if (r < 0) {

log_error_errno(r, "could not get ifindex: %m");

continue;

}

if (ifindex > 0 && ifi != ifindex)

continue;

switch (fam) {

case AF_INET:

r = sd_netlink_message_read_in_addr(m, NDA_DST, &gw.in);

if (r < 0)

continue;

break;

case AF_INET6:

r = sd_netlink_message_read_in6_addr(m, NDA_DST, &gw.in6);

if (r < 0)

continue;

break;

default:

continue;

}

if (!in_addr_equal(fam, &gw, gateway))

continue;

r = sd_netlink_message_read(m, NDA_LLADDR, sizeof(mac), &mac);