Debian Codegraph @

src/network/networkctl-link-info.c

raw
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 }