| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#include <linux/if_tunnel.h> |
| 4 |
|
| 5 |
#include "sd-json.h" |
| 6 |
#include "sd-netlink.h" |
| 7 |
|
| 8 |
#include "alloc-util.h" |
| 9 |
#include "device-util.h" |
| 10 |
#include "fd-util.h" |
| 11 |
#include "glob-util.h" |
| 12 |
#include "netlink-util.h" |
| 13 |
#include "networkctl-link-info.h" |
| 14 |
#include "networkctl-link-info-json.h" |
| 15 |
#include "sort-util.h" |
| 16 |
#include "stdio-util.h" |
| 17 |
#include "string-util.h" |
| 18 |
#include "strv.h" |
| 19 |
#include "strxcpyx.h" |
| 20 |
#include "wifi-util.h" |
| 21 |
|
| 22 |
/* use 128 kB for receive socket kernel queue, we shouldn't need more here */ |
| 23 |
#define RCVBUF_SIZE (128*1024) |
| 24 |
|
| 25 |
LinkInfo* link_info_array_free(LinkInfo *array) { |
| 26 |
for (unsigned i = 0; array && array[i].needs_freeing; i++) { |
| 27 |
sd_device_unref(array[i].sd_device); |
| 28 |
sd_json_variant_unref(array[i].description); |
| 29 |
sd_dhcp_message_unref(array[i].dhcp_message); |
| 30 |
free(array[i].netdev_kind); |
| 31 |
free(array[i].ssid); |
| 32 |
free(array[i].qdisc); |
| 33 |
strv_free(array[i].alternative_names); |
| 34 |
} |
| 35 |
|
| 36 |
return mfree(array); |
| 37 |
} |
| 38 |
|
| 39 |
static int link_info_compare(const LinkInfo *a, const LinkInfo *b) { |
| 40 |
return CMP(a->ifindex, b->ifindex); |
| 41 |
} |
| 42 |
|
| 43 |
static int decode_netdev(sd_netlink_message *m, LinkInfo *info) { |
| 44 |
int r; |
| 45 |
|
| 46 |
assert(m); |
| 47 |
assert(info); |
| 48 |
|
| 49 |
r = sd_netlink_message_enter_container(m, IFLA_LINKINFO); |
| 50 |
if (r < 0) |
| 51 |
return r; |
| 52 |
|
| 53 |
r = sd_netlink_message_read_string_strdup(m, IFLA_INFO_KIND, &info->netdev_kind); |
| 54 |
if (r < 0) { |
| 55 |
(void) sd_netlink_message_exit_container(m); |
| 56 |
return r; |
| 57 |
} |
| 58 |
|
| 59 |
r = sd_netlink_message_enter_container(m, IFLA_INFO_DATA); |
| 60 |
if (r < 0) |
| 61 |
return r; |
| 62 |
|
| 63 |
if (streq(info->netdev_kind, "bridge")) { |
| 64 |
(void) sd_netlink_message_read_u32(m, IFLA_BR_FORWARD_DELAY, &info->forward_delay); |
| 65 |
(void) sd_netlink_message_read_u32(m, IFLA_BR_HELLO_TIME, &info->hello_time); |
| 66 |
(void) sd_netlink_message_read_u32(m, IFLA_BR_MAX_AGE, &info->max_age); |
| 67 |
(void) sd_netlink_message_read_u32(m, IFLA_BR_AGEING_TIME, &info->ageing_time); |
| 68 |
(void) sd_netlink_message_read_u32(m, IFLA_BR_STP_STATE, &info->stp_state); |
| 69 |
(void) sd_netlink_message_read_u32(m, IFLA_BRPORT_COST, &info->cost); |
| 70 |
(void) sd_netlink_message_read_u16(m, IFLA_BR_PRIORITY, &info->priority); |
| 71 |
(void) sd_netlink_message_read_u8(m, IFLA_BR_MCAST_IGMP_VERSION, &info->mcast_igmp_version); |
| 72 |
(void) sd_netlink_message_read_u8(m, IFLA_BRPORT_STATE, &info->port_state); |
| 73 |
if (sd_netlink_message_read_u32(m, IFLA_BR_FDB_MAX_LEARNED, &info->fdb_max_learned) >= 0 && |
| 74 |
sd_netlink_message_read_u32(m, IFLA_BR_FDB_N_LEARNED, &info->fdb_n_learned) >= 0) |
| 75 |
info->has_fdb_learned = true; |
| 76 |
} if (streq(info->netdev_kind, "bond")) { |
| 77 |
(void) sd_netlink_message_read_u8(m, IFLA_BOND_MODE, &info->mode); |
| 78 |
(void) sd_netlink_message_read_u32(m, IFLA_BOND_MIIMON, &info->miimon); |
| 79 |
(void) sd_netlink_message_read_u32(m, IFLA_BOND_DOWNDELAY, &info->downdelay); |
| 80 |
(void) sd_netlink_message_read_u32(m, IFLA_BOND_UPDELAY, &info->updelay); |
| 81 |
} else if (streq(info->netdev_kind, "vxlan")) { |
| 82 |
(void) sd_netlink_message_read_u32(m, IFLA_VXLAN_ID, &info->vxlan_info.vni); |
| 83 |
|
| 84 |
r = sd_netlink_message_read_in_addr(m, IFLA_VXLAN_GROUP, &info->vxlan_info.group.in); |
| 85 |
if (r >= 0) |
| 86 |
info->vxlan_info.group_family = AF_INET; |
| 87 |
else { |
| 88 |
r = sd_netlink_message_read_in6_addr(m, IFLA_VXLAN_GROUP6, &info->vxlan_info.group.in6); |
| 89 |
if (r >= 0) |
| 90 |
info->vxlan_info.group_family = AF_INET6; |
| 91 |
} |
| 92 |
|
| 93 |
r = sd_netlink_message_read_in_addr(m, IFLA_VXLAN_LOCAL, &info->vxlan_info.local.in); |
| 94 |
if (r >= 0) |
| 95 |
info->vxlan_info.local_family = AF_INET; |
| 96 |
else { |
| 97 |
r = sd_netlink_message_read_in6_addr(m, IFLA_VXLAN_LOCAL6, &info->vxlan_info.local.in6); |
| 98 |
if (r >= 0) |
| 99 |
info->vxlan_info.local_family = AF_INET6; |
| 100 |
} |
| 101 |
|
| 102 |
(void) sd_netlink_message_read_u32(m, IFLA_VXLAN_LINK, &info->vxlan_info.link); |
| 103 |
(void) sd_netlink_message_read_u16(m, IFLA_VXLAN_PORT, &info->vxlan_info.dest_port); |
| 104 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_PROXY, &info->vxlan_info.proxy); |
| 105 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_LEARNING, &info->vxlan_info.learning); |
| 106 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_RSC, &info->vxlan_info.rsc); |
| 107 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_L3MISS, &info->vxlan_info.l3miss); |
| 108 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_L2MISS, &info->vxlan_info.l2miss); |
| 109 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_TOS, &info->vxlan_info.tos); |
| 110 |
(void) sd_netlink_message_read_u8(m, IFLA_VXLAN_TTL, &info->vxlan_info.ttl); |
| 111 |
} else if (streq(info->netdev_kind, "vlan")) { |
| 112 |
(void) sd_netlink_message_read_u16(m, IFLA_VLAN_ID, &info->vlan_id); |
| 113 |
} else if (STR_IN_SET(info->netdev_kind, "ipip", "sit")) { |
| 114 |
(void) sd_netlink_message_read_in_addr(m, IFLA_IPTUN_LOCAL, &info->local.in); |
| 115 |
(void) sd_netlink_message_read_in_addr(m, IFLA_IPTUN_REMOTE, &info->remote.in); |
| 116 |
} else if (streq(info->netdev_kind, "geneve")) { |
| 117 |
(void) sd_netlink_message_read_u32(m, IFLA_GENEVE_ID, &info->vni); |
| 118 |
|
| 119 |
r = sd_netlink_message_read_in_addr(m, IFLA_GENEVE_REMOTE, &info->remote.in); |
| 120 |
if (r >= 0) |
| 121 |
info->has_tunnel_ipv4 = true; |
| 122 |
else |
| 123 |
(void) sd_netlink_message_read_in6_addr(m, IFLA_GENEVE_REMOTE6, &info->remote.in6); |
| 124 |
|
| 125 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TTL, &info->ttl); |
| 126 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TTL_INHERIT, &info->inherit); |
| 127 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_TOS, &info->tos); |
| 128 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_DF, &info->df); |
| 129 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_CSUM, &info->csum); |
| 130 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_TX, &info->csum6_tx); |
| 131 |
(void) sd_netlink_message_read_u8(m, IFLA_GENEVE_UDP_ZERO_CSUM6_RX, &info->csum6_rx); |
| 132 |
(void) sd_netlink_message_read_u16(m, IFLA_GENEVE_PORT, &info->tunnel_port); |
| 133 |
(void) sd_netlink_message_read_u32(m, IFLA_GENEVE_LABEL, &info->label); |
| 134 |
} else if (STR_IN_SET(info->netdev_kind, "gre", "gretap", "erspan")) { |
| 135 |
(void) sd_netlink_message_read_in_addr(m, IFLA_GRE_LOCAL, &info->local.in); |
| 136 |
(void) sd_netlink_message_read_in_addr(m, IFLA_GRE_REMOTE, &info->remote.in); |
| 137 |
} else if (STR_IN_SET(info->netdev_kind, "ip6gre", "ip6gretap", "ip6erspan")) { |
| 138 |
(void) sd_netlink_message_read_in6_addr(m, IFLA_GRE_LOCAL, &info->local.in6); |
| 139 |
(void) sd_netlink_message_read_in6_addr(m, IFLA_GRE_REMOTE, &info->remote.in6); |
| 140 |
} else if (streq(info->netdev_kind, "vti")) { |
| 141 |
(void) sd_netlink_message_read_in_addr(m, IFLA_VTI_LOCAL, &info->local.in); |
| 142 |
(void) sd_netlink_message_read_in_addr(m, IFLA_VTI_REMOTE, &info->remote.in); |
| 143 |
} else if (streq(info->netdev_kind, "vti6")) { |
| 144 |
(void) sd_netlink_message_read_in6_addr(m, IFLA_VTI_LOCAL, &info->local.in6); |
| 145 |
(void) sd_netlink_message_read_in6_addr(m, IFLA_VTI_REMOTE, &info->remote.in6); |
| 146 |
} else if (STR_IN_SET(info->netdev_kind, "macvlan", "macvtap")) { |
| 147 |
(void) sd_netlink_message_read_u32(m, IFLA_MACVLAN_MODE, &info->macvlan_mode); |
| 148 |
} else if (streq(info->netdev_kind, "ipvlan")) { |
| 149 |
(void) sd_netlink_message_read_u16(m, IFLA_IPVLAN_MODE, &info->ipvlan_mode); |
| 150 |
(void) sd_netlink_message_read_u16(m, IFLA_IPVLAN_FLAGS, &info->ipvlan_flags); |
| 151 |
} |
| 152 |
|
| 153 |
(void) sd_netlink_message_exit_container(m); |
| 154 |
(void) sd_netlink_message_exit_container(m); |
| 155 |
|
| 156 |
return 0; |
| 157 |
} |
| 158 |
|
| 159 |
static int decode_link( |
| 160 |
sd_netlink_message *m, |
| 161 |
LinkInfo *info, |
| 162 |
char * const *patterns, |
| 163 |
bool matched_patterns[]) { |
| 164 |
|
| 165 |
_cleanup_strv_free_ char **altnames = NULL; |
| 166 |
const char *name, *qdisc; |
| 167 |
int ifindex, r; |
| 168 |
uint16_t type; |
| 169 |
|
| 170 |
assert(m); |
| 171 |
assert(info); |
| 172 |
|
| 173 |
r = sd_netlink_message_get_type(m, &type); |
| 174 |
if (r < 0) |
| 175 |
return r; |
| 176 |
|
| 177 |
if (type != RTM_NEWLINK) |
| 178 |
return 0; |
| 179 |
|
| 180 |
r = sd_rtnl_message_link_get_ifindex(m, &ifindex); |
| 181 |
if (r < 0) |
| 182 |
return r; |
| 183 |
|
| 184 |
r = sd_netlink_message_read_string(m, IFLA_IFNAME, &name); |
| 185 |
if (r < 0) |
| 186 |
return r; |
| 187 |
|
| 188 |
r = sd_netlink_message_read_strv(m, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames); |
| 189 |
if (r < 0 && r != -ENODATA) |
| 190 |
return r; |
| 191 |
|
| 192 |
if (patterns) { |
| 193 |
char str[DECIMAL_STR_MAX(int)]; |
| 194 |
size_t pos; |
| 195 |
|
| 196 |
assert(matched_patterns); |
| 197 |
|
| 198 |
xsprintf(str, "%i", ifindex); |
| 199 |
if (!strv_fnmatch_full(patterns, str, 0, &pos) && |
| 200 |
!strv_fnmatch_full(patterns, name, 0, &pos)) { |
| 201 |
bool match = false; |
| 202 |
|
| 203 |
STRV_FOREACH(p, altnames) |
| 204 |
if (strv_fnmatch_full(patterns, *p, 0, &pos)) { |
| 205 |
match = true; |
| 206 |
break; |
| 207 |
} |
| 208 |
if (!match) |
| 209 |
return 0; |
| 210 |
} |
| 211 |
|
| 212 |
matched_patterns[pos] = true; |
| 213 |
} |
| 214 |
|
| 215 |
r = sd_rtnl_message_link_get_type(m, &info->iftype); |
| 216 |
if (r < 0) |
| 217 |
return r; |
| 218 |
|
| 219 |
strscpy(info->name, sizeof info->name, name); |
| 220 |
info->ifindex = ifindex; |
| 221 |
info->alternative_names = TAKE_PTR(altnames); |
| 222 |
|
| 223 |
info->has_hw_address = |
| 224 |
netlink_message_read_hw_addr(m, IFLA_ADDRESS, &info->hw_address) >= 0 && |
| 225 |
info->hw_address.length > 0; |
| 226 |
|
| 227 |
info->has_permanent_hw_address = |
| 228 |
(netlink_message_read_hw_addr(m, IFLA_PERM_ADDRESS, &info->permanent_hw_address) >= 0 || |
| 229 |
ethtool_get_permanent_hw_addr(NULL, info->name, &info->permanent_hw_address) >= 0) && |
| 230 |
!hw_addr_is_null(&info->permanent_hw_address) && |
| 231 |
!hw_addr_equal(&info->permanent_hw_address, &info->hw_address); |
| 232 |
|
| 233 |
(void) sd_netlink_message_read_u32(m, IFLA_MTU, &info->mtu); |
| 234 |
(void) sd_netlink_message_read_u32(m, IFLA_MIN_MTU, &info->min_mtu); |
| 235 |
(void) sd_netlink_message_read_u32(m, IFLA_MAX_MTU, &info->max_mtu); |
| 236 |
|
| 237 |
info->has_rx_queues = |
| 238 |
sd_netlink_message_read_u32(m, IFLA_NUM_RX_QUEUES, &info->rx_queues) >= 0 && |
| 239 |
info->rx_queues > 0; |
| 240 |
|
| 241 |
info->has_tx_queues = |
| 242 |
sd_netlink_message_read_u32(m, IFLA_NUM_TX_QUEUES, &info->tx_queues) >= 0 && |
| 243 |
info->tx_queues > 0; |
| 244 |
|
| 245 |
if (sd_netlink_message_read(m, IFLA_STATS64, sizeof info->stats64, &info->stats64) >= 0) |
| 246 |
info->has_stats64 = true; |
| 247 |
else if (sd_netlink_message_read(m, IFLA_STATS, sizeof info->stats, &info->stats) >= 0) |
| 248 |
info->has_stats = true; |
| 249 |
|
| 250 |
r = sd_netlink_message_read_string(m, IFLA_QDISC, &qdisc); |
| 251 |
if (r >= 0) { |
| 252 |
info->qdisc = strdup(qdisc); |
| 253 |
if (!info->qdisc) |
| 254 |
return log_oom(); |
| 255 |
} |
| 256 |
|
| 257 |
(void) sd_netlink_message_read_u32(m, IFLA_MASTER, &info->master); |
| 258 |
|
| 259 |
r = sd_netlink_message_enter_container(m, IFLA_AF_SPEC); |
| 260 |
if (r >= 0) { |
| 261 |
r = sd_netlink_message_enter_container(m, AF_INET6); |
| 262 |
if (r >= 0) { |
| 263 |
r = sd_netlink_message_read_u8(m, IFLA_INET6_ADDR_GEN_MODE, &info->addr_gen_mode); |
| 264 |
if (r >= 0 && IN_SET(info->addr_gen_mode, |
| 265 |
IN6_ADDR_GEN_MODE_EUI64, |
| 266 |
IN6_ADDR_GEN_MODE_NONE, |
| 267 |
IN6_ADDR_GEN_MODE_STABLE_PRIVACY, |
| 268 |
IN6_ADDR_GEN_MODE_RANDOM)) |
| 269 |
info->has_ipv6_address_generation_mode = true; |
| 270 |
|
| 271 |
(void) sd_netlink_message_exit_container(m); |
| 272 |
} |
| 273 |
(void) sd_netlink_message_exit_container(m); |
| 274 |
} |
| 275 |
|
| 276 |
/* fill kind info */ |
| 277 |
(void) decode_netdev(m, info); |
| 278 |
|
| 279 |
return 1; |
| 280 |
} |
| 281 |
|
| 282 |
static void acquire_ether_link_info(int *fd, LinkInfo *link) { |
| 283 |
assert(fd); |
| 284 |
assert(link); |
| 285 |
|
| 286 |
if (ethtool_get_link_info(fd, |
| 287 |
link->name, |
| 288 |
&link->autonegotiation, |
| 289 |
&link->speed, |
| 290 |
&link->duplex, |
| 291 |
&link->port) >= 0) |
| 292 |
link->has_ethtool_link_info = true; |
| 293 |
} |
| 294 |
|
| 295 |
static void acquire_wlan_link_info(LinkInfo *link) { |
| 296 |
_cleanup_(sd_netlink_unrefp) sd_netlink *genl = NULL; |
| 297 |
int r, k = 0; |
| 298 |
|
| 299 |
assert(link); |
| 300 |
|
| 301 |
if (!link->sd_device) |
| 302 |
return; |
| 303 |
|
| 304 |
if (device_is_devtype(link->sd_device, "wlan") <= 0) |
| 305 |
return; |
| 306 |
|
| 307 |
r = sd_genl_socket_open(&genl); |
| 308 |
if (r < 0) { |
| 309 |
log_debug_errno(r, "Failed to open generic netlink socket: %m"); |
| 310 |
return; |
| 311 |
} |
| 312 |
|
| 313 |
(void) sd_netlink_increase_rxbuf(genl, RCVBUF_SIZE); |
| 314 |
|
| 315 |
r = wifi_get_interface(genl, link->ifindex, &link->wlan_iftype, &link->ssid); |
| 316 |
if (r < 0) |
| 317 |
log_debug_errno(r, "%s: failed to query ssid: %m", link->name); |
| 318 |
|
| 319 |
if (link->wlan_iftype == NL80211_IFTYPE_STATION) { |
| 320 |
k = wifi_get_station(genl, link->ifindex, &link->bssid); |
| 321 |
if (k < 0) |
| 322 |
log_debug_errno(k, "%s: failed to query bssid: %m", link->name); |
| 323 |
} |
| 324 |
|
| 325 |
link->has_wlan_link_info = r > 0 || k > 0; |
| 326 |
} |
| 327 |
|
| 328 |
int acquire_link_info(sd_varlink *vl, sd_netlink *rtnl, char * const *patterns, LinkInfo **ret) { |
| 329 |
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL; |
| 330 |
_cleanup_(link_info_array_freep) LinkInfo *links = NULL; |
| 331 |
_cleanup_free_ bool *matched_patterns = NULL; |
| 332 |
_cleanup_close_ int fd = -EBADF; |
| 333 |
size_t c = 0; |
| 334 |
int r; |
| 335 |
|
| 336 |
assert(rtnl); |
| 337 |
assert(ret); |
| 338 |
|
| 339 |
r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0); |
| 340 |
if (r < 0) |
| 341 |
return rtnl_log_create_error(r); |
| 342 |
|
| 343 |
r = sd_netlink_message_set_request_dump(req, true); |
| 344 |
if (r < 0) |
| 345 |
return rtnl_log_create_error(r); |
| 346 |
|
| 347 |
r = sd_netlink_call(rtnl, req, 0, &reply); |
| 348 |
if (r < 0) |
| 349 |
return log_error_errno(r, "Failed to enumerate links: %m"); |
| 350 |
|
| 351 |
if (patterns) { |
| 352 |
matched_patterns = new0(bool, strv_length(patterns)); |
| 353 |
if (!matched_patterns) |
| 354 |
return log_oom(); |
| 355 |
} |
| 356 |
|
| 357 |
for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i)) { |
| 358 |
if (!GREEDY_REALLOC0(links, c + 2)) /* We keep one trailing one as marker */ |
| 359 |
return -ENOMEM; |
| 360 |
|
| 361 |
r = decode_link(i, links + c, patterns, matched_patterns); |
| 362 |
if (r < 0) |
| 363 |
return r; |
| 364 |
if (r == 0) |
| 365 |
continue; |
| 366 |
|
| 367 |
links[c].needs_freeing = true; |
| 368 |
|
| 369 |
(void) sd_device_new_from_ifindex(&links[c].sd_device, links[c].ifindex); |
| 370 |
|
| 371 |
acquire_ether_link_info(&fd, &links[c]); |
| 372 |
acquire_wlan_link_info(&links[c]); |
| 373 |
|
| 374 |
(void) link_info_parse_description(&links[c], vl); |
| 375 |
|
| 376 |
c++; |
| 377 |
} |
| 378 |
|
| 379 |
/* Look if we matched all our arguments that are not globs. It |
| 380 |
* is OK for a glob to match nothing, but not for an exact argument. */ |
| 381 |
for (size_t pos = 0; pos < strv_length(patterns); pos++) { |
| 382 |
if (matched_patterns[pos]) |
| 383 |
continue; |
| 384 |
|
| 385 |
if (string_is_glob(patterns[pos])) |
| 386 |
log_debug("Pattern \"%s\" doesn't match any interface, ignoring.", |
| 387 |
patterns[pos]); |
| 388 |
else |
| 389 |
return log_error_errno(SYNTHETIC_ERRNO(ENODEV), |
| 390 |
"Interface \"%s\" not found.", patterns[pos]); |
| 391 |
} |
| 392 |
|
| 393 |
typesafe_qsort(links, c, link_info_compare); |
| 394 |
|
| 395 |
*ret = TAKE_PTR(links); |
| 396 |
|
| 397 |
if (patterns && c == 0) |
| 398 |
log_warning("No interfaces matched."); |
| 399 |
|
| 400 |
return (int) c; |
| 401 |
} |