]> git.proxmox.com Git - mirror_frr.git/blob - zebra/if_netlink.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12339 from anlancs/fix/bgpd-null-show
[mirror_frr.git] / zebra / if_netlink.c
1 /*
2 * Interface looking up by netlink.
3 * Copyright (C) 1998 Kunihiro Ishiguro
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #ifdef GNU_LINUX
25
26 /* The following definition is to workaround an issue in the Linux kernel
27 * header files with redefinition of 'struct in6_addr' in both
28 * netinet/in.h and linux/in6.h.
29 * Reference - https://sourceware.org/ml/libc-alpha/2013-01/msg00599.html
30 */
31 #define _LINUX_IN6_H
32 #define _LINUX_IF_H
33 #define _LINUX_IP_H
34
35 #include <netinet/if_ether.h>
36 #include <linux/if_bridge.h>
37 #include <linux/if_link.h>
38 #include <linux/if_tunnel.h>
39 #include <net/if_arp.h>
40 #include <linux/sockios.h>
41 #include <linux/ethtool.h>
42
43 #include "linklist.h"
44 #include "if.h"
45 #include "log.h"
46 #include "prefix.h"
47 #include "connected.h"
48 #include "table.h"
49 #include "memory.h"
50 #include "rib.h"
51 #include "thread.h"
52 #include "privs.h"
53 #include "nexthop.h"
54 #include "vrf.h"
55 #include "vrf_int.h"
56 #include "mpls.h"
57 #include "lib_errors.h"
58
59 #include "vty.h"
60 #include "zebra/zserv.h"
61 #include "zebra/zebra_ns.h"
62 #include "zebra/zebra_vrf.h"
63 #include "zebra/rt.h"
64 #include "zebra/redistribute.h"
65 #include "zebra/interface.h"
66 #include "zebra/debug.h"
67 #include "zebra/rtadv.h"
68 #include "zebra/zebra_ptm.h"
69 #include "zebra/zebra_mpls.h"
70 #include "zebra/kernel_netlink.h"
71 #include "zebra/rt_netlink.h"
72 #include "zebra/if_netlink.h"
73 #include "zebra/zebra_errors.h"
74 #include "zebra/zebra_vxlan.h"
75 #include "zebra/zebra_evpn_mh.h"
76 #include "zebra/zebra_l2.h"
77 #include "zebra/netconf_netlink.h"
78 #include "zebra/zebra_trace.h"
79
80 extern struct zebra_privs_t zserv_privs;
81 uint8_t frr_protodown_r_bit = FRR_PROTODOWN_REASON_DEFAULT_BIT;
82
83 /* Note: on netlink systems, there should be a 1-to-1 mapping between interface
84 names and ifindex values. */
85 static void set_ifindex(struct interface *ifp, ifindex_t ifi_index,
86 struct zebra_ns *zns)
87 {
88 struct interface *oifp;
89
90 if (((oifp = if_lookup_by_index_per_ns(zns, ifi_index)) != NULL)
91 && (oifp != ifp)) {
92 if (ifi_index == IFINDEX_INTERNAL)
93 flog_err(
94 EC_LIB_INTERFACE,
95 "Netlink is setting interface %s ifindex to reserved internal value %u",
96 ifp->name, ifi_index);
97 else {
98 if (IS_ZEBRA_DEBUG_KERNEL)
99 zlog_debug(
100 "interface index %d was renamed from %s to %s",
101 ifi_index, oifp->name, ifp->name);
102 if (if_is_up(oifp))
103 flog_err(
104 EC_LIB_INTERFACE,
105 "interface rename detected on up interface: index %d was renamed from %s to %s, results are uncertain!",
106 ifi_index, oifp->name, ifp->name);
107 if_delete_update(&oifp);
108 }
109 }
110 if_set_index(ifp, ifi_index);
111 }
112
113 /* Utility function to parse hardware link-layer address and update ifp */
114 static void netlink_interface_update_hw_addr(struct rtattr **tb,
115 struct interface *ifp)
116 {
117 int i;
118
119 if (tb[IFLA_ADDRESS]) {
120 int hw_addr_len;
121
122 hw_addr_len = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
123
124 if (hw_addr_len > INTERFACE_HWADDR_MAX)
125 zlog_debug("Hardware address is too large: %d",
126 hw_addr_len);
127 else {
128 ifp->hw_addr_len = hw_addr_len;
129 memcpy(ifp->hw_addr, RTA_DATA(tb[IFLA_ADDRESS]),
130 hw_addr_len);
131
132 for (i = 0; i < hw_addr_len; i++)
133 if (ifp->hw_addr[i] != 0)
134 break;
135
136 if (i == hw_addr_len)
137 ifp->hw_addr_len = 0;
138 else
139 ifp->hw_addr_len = hw_addr_len;
140 }
141 }
142 }
143
144 static enum zebra_link_type netlink_to_zebra_link_type(unsigned int hwt)
145 {
146 switch (hwt) {
147 case ARPHRD_ETHER:
148 return ZEBRA_LLT_ETHER;
149 case ARPHRD_EETHER:
150 return ZEBRA_LLT_EETHER;
151 case ARPHRD_AX25:
152 return ZEBRA_LLT_AX25;
153 case ARPHRD_PRONET:
154 return ZEBRA_LLT_PRONET;
155 case ARPHRD_IEEE802:
156 return ZEBRA_LLT_IEEE802;
157 case ARPHRD_ARCNET:
158 return ZEBRA_LLT_ARCNET;
159 case ARPHRD_APPLETLK:
160 return ZEBRA_LLT_APPLETLK;
161 case ARPHRD_DLCI:
162 return ZEBRA_LLT_DLCI;
163 case ARPHRD_ATM:
164 return ZEBRA_LLT_ATM;
165 case ARPHRD_METRICOM:
166 return ZEBRA_LLT_METRICOM;
167 case ARPHRD_IEEE1394:
168 return ZEBRA_LLT_IEEE1394;
169 case ARPHRD_EUI64:
170 return ZEBRA_LLT_EUI64;
171 case ARPHRD_INFINIBAND:
172 return ZEBRA_LLT_INFINIBAND;
173 case ARPHRD_SLIP:
174 return ZEBRA_LLT_SLIP;
175 case ARPHRD_CSLIP:
176 return ZEBRA_LLT_CSLIP;
177 case ARPHRD_SLIP6:
178 return ZEBRA_LLT_SLIP6;
179 case ARPHRD_CSLIP6:
180 return ZEBRA_LLT_CSLIP6;
181 case ARPHRD_RSRVD:
182 return ZEBRA_LLT_RSRVD;
183 case ARPHRD_ADAPT:
184 return ZEBRA_LLT_ADAPT;
185 case ARPHRD_ROSE:
186 return ZEBRA_LLT_ROSE;
187 case ARPHRD_X25:
188 return ZEBRA_LLT_X25;
189 case ARPHRD_PPP:
190 return ZEBRA_LLT_PPP;
191 case ARPHRD_CISCO:
192 return ZEBRA_LLT_CHDLC;
193 case ARPHRD_LAPB:
194 return ZEBRA_LLT_LAPB;
195 case ARPHRD_RAWHDLC:
196 return ZEBRA_LLT_RAWHDLC;
197 case ARPHRD_TUNNEL:
198 return ZEBRA_LLT_IPIP;
199 case ARPHRD_TUNNEL6:
200 return ZEBRA_LLT_IPIP6;
201 case ARPHRD_FRAD:
202 return ZEBRA_LLT_FRAD;
203 case ARPHRD_SKIP:
204 return ZEBRA_LLT_SKIP;
205 case ARPHRD_LOOPBACK:
206 return ZEBRA_LLT_LOOPBACK;
207 case ARPHRD_LOCALTLK:
208 return ZEBRA_LLT_LOCALTLK;
209 case ARPHRD_FDDI:
210 return ZEBRA_LLT_FDDI;
211 case ARPHRD_SIT:
212 return ZEBRA_LLT_SIT;
213 case ARPHRD_IPDDP:
214 return ZEBRA_LLT_IPDDP;
215 case ARPHRD_IPGRE:
216 return ZEBRA_LLT_IPGRE;
217 case ARPHRD_PIMREG:
218 return ZEBRA_LLT_PIMREG;
219 case ARPHRD_HIPPI:
220 return ZEBRA_LLT_HIPPI;
221 case ARPHRD_ECONET:
222 return ZEBRA_LLT_ECONET;
223 case ARPHRD_IRDA:
224 return ZEBRA_LLT_IRDA;
225 case ARPHRD_FCPP:
226 return ZEBRA_LLT_FCPP;
227 case ARPHRD_FCAL:
228 return ZEBRA_LLT_FCAL;
229 case ARPHRD_FCPL:
230 return ZEBRA_LLT_FCPL;
231 case ARPHRD_FCFABRIC:
232 return ZEBRA_LLT_FCFABRIC;
233 case ARPHRD_IEEE802_TR:
234 return ZEBRA_LLT_IEEE802_TR;
235 case ARPHRD_IEEE80211:
236 return ZEBRA_LLT_IEEE80211;
237 #ifdef ARPHRD_IEEE802154
238 case ARPHRD_IEEE802154:
239 return ZEBRA_LLT_IEEE802154;
240 #endif
241 #ifdef ARPHRD_IP6GRE
242 case ARPHRD_IP6GRE:
243 return ZEBRA_LLT_IP6GRE;
244 #endif
245 #ifdef ARPHRD_IEEE802154_PHY
246 case ARPHRD_IEEE802154_PHY:
247 return ZEBRA_LLT_IEEE802154_PHY;
248 #endif
249
250 default:
251 return ZEBRA_LLT_UNKNOWN;
252 }
253 }
254
255 static inline void zebra_if_set_ziftype(struct interface *ifp,
256 enum zebra_iftype zif_type,
257 enum zebra_slave_iftype zif_slave_type)
258 {
259 struct zebra_if *zif;
260
261 zif = (struct zebra_if *)ifp->info;
262 zif->zif_slave_type = zif_slave_type;
263
264 if (zif->zif_type != zif_type) {
265 zif->zif_type = zif_type;
266 /* If the if_type has been set to bond initialize ES info
267 * against it. XXX - note that we don't handle the case where
268 * a zif changes from bond to non-bond; it is really
269 * an unexpected/error condition.
270 */
271 zebra_evpn_if_init(zif);
272 }
273 }
274
275 static void netlink_determine_zebra_iftype(const char *kind,
276 enum zebra_iftype *zif_type)
277 {
278 *zif_type = ZEBRA_IF_OTHER;
279
280 if (!kind)
281 return;
282
283 if (strcmp(kind, "vrf") == 0)
284 *zif_type = ZEBRA_IF_VRF;
285 else if (strcmp(kind, "bridge") == 0)
286 *zif_type = ZEBRA_IF_BRIDGE;
287 else if (strcmp(kind, "vlan") == 0)
288 *zif_type = ZEBRA_IF_VLAN;
289 else if (strcmp(kind, "vxlan") == 0)
290 *zif_type = ZEBRA_IF_VXLAN;
291 else if (strcmp(kind, "macvlan") == 0)
292 *zif_type = ZEBRA_IF_MACVLAN;
293 else if (strcmp(kind, "veth") == 0)
294 *zif_type = ZEBRA_IF_VETH;
295 else if (strcmp(kind, "bond") == 0)
296 *zif_type = ZEBRA_IF_BOND;
297 else if (strcmp(kind, "bond_slave") == 0)
298 *zif_type = ZEBRA_IF_BOND_SLAVE;
299 else if (strcmp(kind, "gre") == 0)
300 *zif_type = ZEBRA_IF_GRE;
301 }
302
303 static void netlink_vrf_change(struct nlmsghdr *h, struct rtattr *tb,
304 uint32_t ns_id, const char *name)
305 {
306 struct ifinfomsg *ifi;
307 struct rtattr *linkinfo[IFLA_INFO_MAX + 1];
308 struct rtattr *attr[IFLA_VRF_MAX + 1];
309 struct vrf *vrf = NULL;
310 struct zebra_vrf *zvrf;
311 uint32_t nl_table_id;
312
313 ifi = NLMSG_DATA(h);
314
315 netlink_parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb);
316
317 if (!linkinfo[IFLA_INFO_DATA]) {
318 if (IS_ZEBRA_DEBUG_KERNEL)
319 zlog_debug(
320 "%s: IFLA_INFO_DATA missing from VRF message: %s",
321 __func__, name);
322 return;
323 }
324
325 netlink_parse_rtattr_nested(attr, IFLA_VRF_MAX,
326 linkinfo[IFLA_INFO_DATA]);
327 if (!attr[IFLA_VRF_TABLE]) {
328 if (IS_ZEBRA_DEBUG_KERNEL)
329 zlog_debug(
330 "%s: IFLA_VRF_TABLE missing from VRF message: %s",
331 __func__, name);
332 return;
333 }
334
335 nl_table_id = *(uint32_t *)RTA_DATA(attr[IFLA_VRF_TABLE]);
336
337 if (h->nlmsg_type == RTM_NEWLINK) {
338 if (IS_ZEBRA_DEBUG_KERNEL)
339 zlog_debug("RTM_NEWLINK for VRF %s(%u) table %u", name,
340 ifi->ifi_index, nl_table_id);
341
342 if (!vrf_lookup_by_id((vrf_id_t)ifi->ifi_index)) {
343 vrf_id_t exist_id;
344
345 exist_id = vrf_lookup_by_table(nl_table_id, ns_id);
346 if (exist_id != VRF_DEFAULT) {
347 vrf = vrf_lookup_by_id(exist_id);
348
349 flog_err(
350 EC_ZEBRA_VRF_MISCONFIGURED,
351 "VRF %s id %u table id overlaps existing vrf %s, misconfiguration exiting",
352 name, ifi->ifi_index, vrf->name);
353 exit(-1);
354 }
355 }
356
357 vrf = vrf_update((vrf_id_t)ifi->ifi_index, name);
358 if (!vrf) {
359 flog_err(EC_LIB_INTERFACE, "VRF %s id %u not created",
360 name, ifi->ifi_index);
361 return;
362 }
363
364 /*
365 * This is the only place that we get the actual kernel table_id
366 * being used. We need it to set the table_id of the routes
367 * we are passing to the kernel.... And to throw some totally
368 * awesome parties. that too.
369 *
370 * At this point we *must* have a zvrf because the vrf_create
371 * callback creates one. We *must* set the table id
372 * before the vrf_enable because of( at the very least )
373 * static routes being delayed for installation until
374 * during the vrf_enable callbacks.
375 */
376 zvrf = (struct zebra_vrf *)vrf->info;
377 zvrf->table_id = nl_table_id;
378
379 /* Enable the created VRF. */
380 if (!vrf_enable(vrf)) {
381 flog_err(EC_LIB_INTERFACE,
382 "Failed to enable VRF %s id %u", name,
383 ifi->ifi_index);
384 return;
385 }
386
387 } else // h->nlmsg_type == RTM_DELLINK
388 {
389 if (IS_ZEBRA_DEBUG_KERNEL)
390 zlog_debug("RTM_DELLINK for VRF %s(%u)", name,
391 ifi->ifi_index);
392
393 vrf = vrf_lookup_by_id((vrf_id_t)ifi->ifi_index);
394
395 if (!vrf) {
396 flog_warn(EC_ZEBRA_VRF_NOT_FOUND, "%s: vrf not found",
397 __func__);
398 return;
399 }
400
401 vrf_delete(vrf);
402 }
403 }
404
405 static uint32_t get_iflink_speed(struct interface *interface, int *error)
406 {
407 struct ifreq ifdata;
408 struct ethtool_cmd ecmd;
409 int sd;
410 int rc;
411 const char *ifname = interface->name;
412
413 if (error)
414 *error = 0;
415 /* initialize struct */
416 memset(&ifdata, 0, sizeof(ifdata));
417
418 /* set interface name */
419 strlcpy(ifdata.ifr_name, ifname, sizeof(ifdata.ifr_name));
420
421 /* initialize ethtool interface */
422 memset(&ecmd, 0, sizeof(ecmd));
423 ecmd.cmd = ETHTOOL_GSET; /* ETHTOOL_GLINK */
424 ifdata.ifr_data = (caddr_t)&ecmd;
425
426 /* use ioctl to get speed of an interface */
427 frr_with_privs(&zserv_privs) {
428 sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP,
429 interface->vrf->vrf_id, NULL);
430 if (sd < 0) {
431 if (IS_ZEBRA_DEBUG_KERNEL)
432 zlog_debug("Failure to read interface %s speed: %d %s",
433 ifname, errno, safe_strerror(errno));
434 /* no vrf socket creation may probably mean vrf issue */
435 if (error)
436 *error = -1;
437 return 0;
438 }
439 /* Get the current link state for the interface */
440 rc = vrf_ioctl(interface->vrf->vrf_id, sd, SIOCETHTOOL,
441 (char *)&ifdata);
442 }
443 if (rc < 0) {
444 if (errno != EOPNOTSUPP && IS_ZEBRA_DEBUG_KERNEL)
445 zlog_debug(
446 "IOCTL failure to read interface %s speed: %d %s",
447 ifname, errno, safe_strerror(errno));
448 /* no device means interface unreachable */
449 if (errno == ENODEV && error)
450 *error = -1;
451 ecmd.speed_hi = 0;
452 ecmd.speed = 0;
453 }
454
455 close(sd);
456
457 return ((uint32_t)ecmd.speed_hi << 16) | ecmd.speed;
458 }
459
460 uint32_t kernel_get_speed(struct interface *ifp, int *error)
461 {
462 return get_iflink_speed(ifp, error);
463 }
464
465 static ssize_t
466 netlink_gre_set_msg_encoder(struct zebra_dplane_ctx *ctx, void *buf,
467 size_t buflen)
468 {
469 struct {
470 struct nlmsghdr n;
471 struct ifinfomsg ifi;
472 char buf[];
473 } *req = buf;
474 uint32_t link_idx;
475 unsigned int mtu;
476 struct rtattr *rta_info, *rta_data;
477 const struct zebra_l2info_gre *gre_info;
478
479 if (buflen < sizeof(*req))
480 return 0;
481 memset(req, 0, sizeof(*req));
482
483 req->n.nlmsg_type = RTM_NEWLINK;
484 req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
485 req->n.nlmsg_flags = NLM_F_REQUEST;
486
487 req->ifi.ifi_index = dplane_ctx_get_ifindex(ctx);
488
489 gre_info = dplane_ctx_gre_get_info(ctx);
490 if (!gre_info)
491 return 0;
492
493 req->ifi.ifi_change = 0xFFFFFFFF;
494 link_idx = dplane_ctx_gre_get_link_ifindex(ctx);
495 mtu = dplane_ctx_gre_get_mtu(ctx);
496
497 if (mtu && !nl_attr_put32(&req->n, buflen, IFLA_MTU, mtu))
498 return 0;
499
500 rta_info = nl_attr_nest(&req->n, buflen, IFLA_LINKINFO);
501 if (!rta_info)
502 return 0;
503
504 if (!nl_attr_put(&req->n, buflen, IFLA_INFO_KIND, "gre", 3))
505 return 0;
506
507 rta_data = nl_attr_nest(&req->n, buflen, IFLA_INFO_DATA);
508 if (!rta_data)
509 return 0;
510
511 if (!nl_attr_put32(&req->n, buflen, IFLA_GRE_LINK, link_idx))
512 return 0;
513
514 if (gre_info->vtep_ip.s_addr &&
515 !nl_attr_put32(&req->n, buflen, IFLA_GRE_LOCAL,
516 gre_info->vtep_ip.s_addr))
517 return 0;
518
519 if (gre_info->vtep_ip_remote.s_addr &&
520 !nl_attr_put32(&req->n, buflen, IFLA_GRE_REMOTE,
521 gre_info->vtep_ip_remote.s_addr))
522 return 0;
523
524 if (gre_info->ikey &&
525 !nl_attr_put32(&req->n, buflen, IFLA_GRE_IKEY,
526 gre_info->ikey))
527 return 0;
528 if (gre_info->okey &&
529 !nl_attr_put32(&req->n, buflen, IFLA_GRE_IKEY,
530 gre_info->okey))
531 return 0;
532
533 nl_attr_nest_end(&req->n, rta_data);
534 nl_attr_nest_end(&req->n, rta_info);
535
536 return NLMSG_ALIGN(req->n.nlmsg_len);
537 }
538
539 static int netlink_extract_bridge_info(struct rtattr *link_data,
540 struct zebra_l2info_bridge *bridge_info)
541 {
542 struct rtattr *attr[IFLA_BR_MAX + 1];
543
544 memset(bridge_info, 0, sizeof(*bridge_info));
545 netlink_parse_rtattr_nested(attr, IFLA_BR_MAX, link_data);
546 if (attr[IFLA_BR_VLAN_FILTERING])
547 bridge_info->vlan_aware =
548 *(uint8_t *)RTA_DATA(attr[IFLA_BR_VLAN_FILTERING]);
549 return 0;
550 }
551
552 static int netlink_extract_vlan_info(struct rtattr *link_data,
553 struct zebra_l2info_vlan *vlan_info)
554 {
555 struct rtattr *attr[IFLA_VLAN_MAX + 1];
556 vlanid_t vid_in_msg;
557
558 memset(vlan_info, 0, sizeof(*vlan_info));
559 netlink_parse_rtattr_nested(attr, IFLA_VLAN_MAX, link_data);
560 if (!attr[IFLA_VLAN_ID]) {
561 if (IS_ZEBRA_DEBUG_KERNEL)
562 zlog_debug("IFLA_VLAN_ID missing from VLAN IF message");
563 return -1;
564 }
565
566 vid_in_msg = *(vlanid_t *)RTA_DATA(attr[IFLA_VLAN_ID]);
567 vlan_info->vid = vid_in_msg;
568 return 0;
569 }
570
571 static int netlink_extract_gre_info(struct rtattr *link_data,
572 struct zebra_l2info_gre *gre_info)
573 {
574 struct rtattr *attr[IFLA_GRE_MAX + 1];
575
576 memset(gre_info, 0, sizeof(*gre_info));
577 memset(attr, 0, sizeof(attr));
578 netlink_parse_rtattr_nested(attr, IFLA_GRE_MAX, link_data);
579
580 if (!attr[IFLA_GRE_LOCAL]) {
581 if (IS_ZEBRA_DEBUG_KERNEL)
582 zlog_debug(
583 "IFLA_GRE_LOCAL missing from GRE IF message");
584 } else
585 gre_info->vtep_ip =
586 *(struct in_addr *)RTA_DATA(attr[IFLA_GRE_LOCAL]);
587 if (!attr[IFLA_GRE_REMOTE]) {
588 if (IS_ZEBRA_DEBUG_KERNEL)
589 zlog_debug(
590 "IFLA_GRE_REMOTE missing from GRE IF message");
591 } else
592 gre_info->vtep_ip_remote =
593 *(struct in_addr *)RTA_DATA(attr[IFLA_GRE_REMOTE]);
594
595 if (!attr[IFLA_GRE_LINK]) {
596 if (IS_ZEBRA_DEBUG_KERNEL)
597 zlog_debug("IFLA_GRE_LINK missing from GRE IF message");
598 } else {
599 gre_info->ifindex_link =
600 *(ifindex_t *)RTA_DATA(attr[IFLA_GRE_LINK]);
601 if (IS_ZEBRA_DEBUG_KERNEL)
602 zlog_debug("IFLA_GRE_LINK obtained is %u",
603 gre_info->ifindex_link);
604 }
605 if (attr[IFLA_GRE_IKEY])
606 gre_info->ikey = *(uint32_t *)RTA_DATA(attr[IFLA_GRE_IKEY]);
607 if (attr[IFLA_GRE_OKEY])
608 gre_info->okey = *(uint32_t *)RTA_DATA(attr[IFLA_GRE_OKEY]);
609 return 0;
610 }
611
612 static int netlink_extract_vxlan_info(struct rtattr *link_data,
613 struct zebra_l2info_vxlan *vxl_info)
614 {
615 struct rtattr *attr[IFLA_VXLAN_MAX + 1];
616 vni_t vni_in_msg;
617 struct in_addr vtep_ip_in_msg;
618 ifindex_t ifindex_link;
619
620 memset(vxl_info, 0, sizeof(*vxl_info));
621 netlink_parse_rtattr_nested(attr, IFLA_VXLAN_MAX, link_data);
622 if (!attr[IFLA_VXLAN_ID]) {
623 if (IS_ZEBRA_DEBUG_KERNEL)
624 zlog_debug(
625 "IFLA_VXLAN_ID missing from VXLAN IF message");
626 return -1;
627 }
628
629 vni_in_msg = *(vni_t *)RTA_DATA(attr[IFLA_VXLAN_ID]);
630 vxl_info->vni = vni_in_msg;
631 if (!attr[IFLA_VXLAN_LOCAL]) {
632 if (IS_ZEBRA_DEBUG_KERNEL)
633 zlog_debug(
634 "IFLA_VXLAN_LOCAL missing from VXLAN IF message");
635 } else {
636 vtep_ip_in_msg =
637 *(struct in_addr *)RTA_DATA(attr[IFLA_VXLAN_LOCAL]);
638 vxl_info->vtep_ip = vtep_ip_in_msg;
639 }
640
641 if (attr[IFLA_VXLAN_GROUP]) {
642 vxl_info->mcast_grp =
643 *(struct in_addr *)RTA_DATA(attr[IFLA_VXLAN_GROUP]);
644 }
645
646 if (!attr[IFLA_VXLAN_LINK]) {
647 if (IS_ZEBRA_DEBUG_KERNEL)
648 zlog_debug("IFLA_VXLAN_LINK missing from VXLAN IF message");
649 } else {
650 ifindex_link =
651 *(ifindex_t *)RTA_DATA(attr[IFLA_VXLAN_LINK]);
652 vxl_info->ifindex_link = ifindex_link;
653 }
654 return 0;
655 }
656
657 /*
658 * Extract and save L2 params (of interest) for an interface. When a
659 * bridge interface is added or updated, take further actions to map
660 * its members. Likewise, for VxLAN interface.
661 */
662 static void netlink_interface_update_l2info(struct interface *ifp,
663 struct rtattr *link_data, int add,
664 ns_id_t link_nsid)
665 {
666 if (!link_data)
667 return;
668
669 if (IS_ZEBRA_IF_BRIDGE(ifp)) {
670 struct zebra_l2info_bridge bridge_info;
671
672 netlink_extract_bridge_info(link_data, &bridge_info);
673 zebra_l2_bridge_add_update(ifp, &bridge_info, add);
674 } else if (IS_ZEBRA_IF_VLAN(ifp)) {
675 struct zebra_l2info_vlan vlan_info;
676
677 netlink_extract_vlan_info(link_data, &vlan_info);
678 zebra_l2_vlanif_update(ifp, &vlan_info);
679 zebra_evpn_acc_bd_svi_set(ifp->info, NULL,
680 !!if_is_operative(ifp));
681 } else if (IS_ZEBRA_IF_VXLAN(ifp)) {
682 struct zebra_l2info_vxlan vxlan_info;
683
684 netlink_extract_vxlan_info(link_data, &vxlan_info);
685 vxlan_info.link_nsid = link_nsid;
686 zebra_l2_vxlanif_add_update(ifp, &vxlan_info, add);
687 if (link_nsid != NS_UNKNOWN &&
688 vxlan_info.ifindex_link)
689 zebra_if_update_link(ifp, vxlan_info.ifindex_link,
690 link_nsid);
691 } else if (IS_ZEBRA_IF_GRE(ifp)) {
692 struct zebra_l2info_gre gre_info;
693
694 netlink_extract_gre_info(link_data, &gre_info);
695 gre_info.link_nsid = link_nsid;
696 zebra_l2_greif_add_update(ifp, &gre_info, add);
697 if (link_nsid != NS_UNKNOWN &&
698 gre_info.ifindex_link)
699 zebra_if_update_link(ifp, gre_info.ifindex_link,
700 link_nsid);
701 }
702 }
703
704 static int netlink_bridge_vxlan_update(struct interface *ifp,
705 struct rtattr *af_spec)
706 {
707 struct rtattr *aftb[IFLA_BRIDGE_MAX + 1];
708 struct bridge_vlan_info *vinfo;
709 vlanid_t access_vlan;
710
711 if (!af_spec)
712 return 0;
713
714 /* There is a 1-to-1 mapping of VLAN to VxLAN - hence
715 * only 1 access VLAN is accepted.
716 */
717 netlink_parse_rtattr_nested(aftb, IFLA_BRIDGE_MAX, af_spec);
718 if (!aftb[IFLA_BRIDGE_VLAN_INFO])
719 return 0;
720
721 vinfo = RTA_DATA(aftb[IFLA_BRIDGE_VLAN_INFO]);
722 if (!(vinfo->flags & BRIDGE_VLAN_INFO_PVID))
723 return 0;
724
725 access_vlan = (vlanid_t)vinfo->vid;
726 if (IS_ZEBRA_DEBUG_KERNEL)
727 zlog_debug("Access VLAN %u for VxLAN IF %s(%u)", access_vlan,
728 ifp->name, ifp->ifindex);
729 zebra_l2_vxlanif_update_access_vlan(ifp, access_vlan);
730 return 0;
731 }
732
733 static void netlink_bridge_vlan_update(struct interface *ifp,
734 struct rtattr *af_spec)
735 {
736 struct rtattr *i;
737 int rem;
738 uint16_t vid_range_start = 0;
739 struct zebra_if *zif;
740 bitfield_t old_vlan_bitmap;
741 struct bridge_vlan_info *vinfo;
742
743 zif = (struct zebra_if *)ifp->info;
744
745 /* cache the old bitmap addrs */
746 old_vlan_bitmap = zif->vlan_bitmap;
747 /* create a new bitmap space for re-eval */
748 bf_init(zif->vlan_bitmap, IF_VLAN_BITMAP_MAX);
749
750 if (af_spec) {
751 for (i = RTA_DATA(af_spec), rem = RTA_PAYLOAD(af_spec);
752 RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
753
754 if (i->rta_type != IFLA_BRIDGE_VLAN_INFO)
755 continue;
756
757 vinfo = RTA_DATA(i);
758
759 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
760 vid_range_start = vinfo->vid;
761 continue;
762 }
763
764 if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
765 vid_range_start = vinfo->vid;
766
767 zebra_vlan_bitmap_compute(ifp, vid_range_start,
768 vinfo->vid);
769 }
770 }
771
772 zebra_vlan_mbr_re_eval(ifp, old_vlan_bitmap);
773
774 bf_free(old_vlan_bitmap);
775 }
776
777 static int netlink_bridge_interface(struct nlmsghdr *h, int len, ns_id_t ns_id,
778 int startup)
779 {
780 char *name = NULL;
781 struct ifinfomsg *ifi;
782 struct rtattr *tb[IFLA_MAX + 1];
783 struct interface *ifp;
784 struct zebra_if *zif;
785 struct rtattr *af_spec;
786
787 /* Fetch name and ifindex */
788 ifi = NLMSG_DATA(h);
789 netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
790
791 if (tb[IFLA_IFNAME] == NULL)
792 return -1;
793 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
794
795 /* The interface should already be known, if not discard. */
796 ifp = if_lookup_by_index_per_ns(zebra_ns_lookup(ns_id), ifi->ifi_index);
797 if (!ifp) {
798 zlog_debug("Cannot find bridge IF %s(%u)", name,
799 ifi->ifi_index);
800 return 0;
801 }
802
803 /* We are only interested in the access VLAN i.e., AF_SPEC */
804 af_spec = tb[IFLA_AF_SPEC];
805
806 if (IS_ZEBRA_IF_VXLAN(ifp))
807 return netlink_bridge_vxlan_update(ifp, af_spec);
808
809 /* build vlan bitmap associated with this interface if that
810 * device type is interested in the vlans
811 */
812 zif = (struct zebra_if *)ifp->info;
813 if (bf_is_inited(zif->vlan_bitmap))
814 netlink_bridge_vlan_update(ifp, af_spec);
815
816 return 0;
817 }
818
819 static bool is_if_protodown_reason_only_frr(uint32_t rc_bitfield)
820 {
821 /* This shouldn't be possible */
822 assert(frr_protodown_r_bit < 32);
823 return (rc_bitfield == (((uint32_t)1) << frr_protodown_r_bit));
824 }
825
826 /*
827 * Process interface protodown dplane update.
828 *
829 * If the interface is an es bond member then it must follow EVPN's
830 * protodown setting.
831 */
832 static void netlink_proc_dplane_if_protodown(struct zebra_if *zif,
833 struct rtattr **tb)
834 {
835 bool protodown;
836 bool old_protodown;
837 uint32_t rc_bitfield = 0;
838 struct rtattr *pd_reason_info[IFLA_MAX + 1];
839
840 protodown = !!*(uint8_t *)RTA_DATA(tb[IFLA_PROTO_DOWN]);
841
842 if (tb[IFLA_PROTO_DOWN_REASON]) {
843 netlink_parse_rtattr_nested(pd_reason_info, IFLA_INFO_MAX,
844 tb[IFLA_PROTO_DOWN_REASON]);
845
846 if (pd_reason_info[IFLA_PROTO_DOWN_REASON_VALUE])
847 rc_bitfield = *(uint32_t *)RTA_DATA(
848 pd_reason_info[IFLA_PROTO_DOWN_REASON_VALUE]);
849 }
850
851 /*
852 * Set our reason code to note it wasn't us.
853 * If the reason we got from the kernel is ONLY frr though, don't
854 * set it.
855 */
856 COND_FLAG(zif->protodown_rc, ZEBRA_PROTODOWN_EXTERNAL,
857 protodown && rc_bitfield &&
858 !is_if_protodown_reason_only_frr(rc_bitfield));
859
860
861 old_protodown = !!ZEBRA_IF_IS_PROTODOWN(zif);
862 if (protodown == old_protodown)
863 return;
864
865 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
866 zlog_debug("interface %s dplane change, protdown %s",
867 zif->ifp->name, protodown ? "on" : "off");
868
869 /* Set protodown, respectively */
870 COND_FLAG(zif->flags, ZIF_FLAG_PROTODOWN, protodown);
871
872 if (zebra_evpn_is_es_bond_member(zif->ifp)) {
873 /* Check it's not already being sent to the dplane first */
874 if (protodown &&
875 CHECK_FLAG(zif->flags, ZIF_FLAG_SET_PROTODOWN)) {
876 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
877 zlog_debug(
878 "bond mbr %s protodown on recv'd but already sent protodown on to the dplane",
879 zif->ifp->name);
880 return;
881 }
882
883 if (!protodown &&
884 CHECK_FLAG(zif->flags, ZIF_FLAG_UNSET_PROTODOWN)) {
885 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
886 zlog_debug(
887 "bond mbr %s protodown off recv'd but already sent protodown off to the dplane",
888 zif->ifp->name);
889 return;
890 }
891
892 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
893 zlog_debug(
894 "bond mbr %s reinstate protodown %s in the dplane",
895 zif->ifp->name, old_protodown ? "on" : "off");
896
897 if (old_protodown)
898 SET_FLAG(zif->flags, ZIF_FLAG_SET_PROTODOWN);
899 else
900 SET_FLAG(zif->flags, ZIF_FLAG_UNSET_PROTODOWN);
901
902 dplane_intf_update(zif->ifp);
903 }
904 }
905
906 static uint8_t netlink_parse_lacp_bypass(struct rtattr **linkinfo)
907 {
908 uint8_t bypass = 0;
909 struct rtattr *mbrinfo[IFLA_BOND_SLAVE_MAX + 1];
910
911 netlink_parse_rtattr_nested(mbrinfo, IFLA_BOND_SLAVE_MAX,
912 linkinfo[IFLA_INFO_SLAVE_DATA]);
913 if (mbrinfo[IFLA_BOND_SLAVE_AD_RX_BYPASS])
914 bypass = *(uint8_t *)RTA_DATA(
915 mbrinfo[IFLA_BOND_SLAVE_AD_RX_BYPASS]);
916
917 return bypass;
918 }
919
920 /*
921 * Only called at startup to cleanup leftover protodown reasons we may
922 * have not cleaned up. We leave protodown set though.
923 */
924 static void if_sweep_protodown(struct zebra_if *zif)
925 {
926 bool protodown;
927
928 protodown = !!ZEBRA_IF_IS_PROTODOWN(zif);
929
930 if (!protodown)
931 return;
932
933 if (IS_ZEBRA_DEBUG_KERNEL)
934 zlog_debug("interface %s sweeping protodown %s reason 0x%x",
935 zif->ifp->name, protodown ? "on" : "off",
936 zif->protodown_rc);
937
938 /* Only clear our reason codes, leave external if it was set */
939 UNSET_FLAG(zif->protodown_rc, ZEBRA_PROTODOWN_ALL);
940 dplane_intf_update(zif->ifp);
941 }
942
943 /*
944 * Called from interface_lookup_netlink(). This function is only used
945 * during bootstrap.
946 */
947 static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
948 {
949 int len;
950 struct ifinfomsg *ifi;
951 struct rtattr *tb[IFLA_MAX + 1];
952 struct rtattr *linkinfo[IFLA_MAX + 1];
953 struct interface *ifp;
954 char *name = NULL;
955 char *kind = NULL;
956 char *desc = NULL;
957 char *slave_kind = NULL;
958 struct zebra_ns *zns = NULL;
959 vrf_id_t vrf_id = VRF_DEFAULT;
960 enum zebra_iftype zif_type = ZEBRA_IF_OTHER;
961 enum zebra_slave_iftype zif_slave_type = ZEBRA_IF_SLAVE_NONE;
962 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
963 ifindex_t link_ifindex = IFINDEX_INTERNAL;
964 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
965 struct zebra_if *zif;
966 ns_id_t link_nsid = ns_id;
967 uint8_t bypass = 0;
968
969 frrtrace(3, frr_zebra, netlink_interface, h, ns_id, startup);
970
971 zns = zebra_ns_lookup(ns_id);
972 ifi = NLMSG_DATA(h);
973
974 if (h->nlmsg_type != RTM_NEWLINK)
975 return 0;
976
977 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
978 if (len < 0) {
979 zlog_err(
980 "%s: Message received from netlink is of a broken size: %d %zu",
981 __func__, h->nlmsg_len,
982 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
983 return -1;
984 }
985
986 /* We are interested in some AF_BRIDGE notifications. */
987 if (ifi->ifi_family == AF_BRIDGE)
988 return netlink_bridge_interface(h, len, ns_id, startup);
989
990 /* Looking up interface name. */
991 memset(linkinfo, 0, sizeof(linkinfo));
992 netlink_parse_rtattr_flags(tb, IFLA_MAX, IFLA_RTA(ifi), len,
993 NLA_F_NESTED);
994
995 /* check for wireless messages to ignore */
996 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
997 if (IS_ZEBRA_DEBUG_KERNEL)
998 zlog_debug("%s: ignoring IFLA_WIRELESS message",
999 __func__);
1000 return 0;
1001 }
1002
1003 if (tb[IFLA_IFNAME] == NULL)
1004 return -1;
1005 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
1006
1007 if (tb[IFLA_IFALIAS])
1008 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
1009
1010 if (tb[IFLA_LINKINFO]) {
1011 netlink_parse_rtattr_nested(linkinfo, IFLA_INFO_MAX,
1012 tb[IFLA_LINKINFO]);
1013
1014 if (linkinfo[IFLA_INFO_KIND])
1015 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
1016
1017 if (linkinfo[IFLA_INFO_SLAVE_KIND])
1018 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
1019
1020 if ((slave_kind != NULL) && strcmp(slave_kind, "bond") == 0)
1021 netlink_determine_zebra_iftype("bond_slave", &zif_type);
1022 else
1023 netlink_determine_zebra_iftype(kind, &zif_type);
1024 }
1025
1026 /* If VRF, create the VRF structure itself. */
1027 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
1028 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
1029 vrf_id = (vrf_id_t)ifi->ifi_index;
1030 }
1031
1032 if (tb[IFLA_MASTER]) {
1033 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
1034 && !vrf_is_backend_netns()) {
1035 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
1036 vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
1037 } else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
1038 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
1039 bridge_ifindex =
1040 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1041 } else if (slave_kind && (strcmp(slave_kind, "bond") == 0)) {
1042 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
1043 bond_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1044 bypass = netlink_parse_lacp_bypass(linkinfo);
1045 } else
1046 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
1047 }
1048 if (vrf_is_backend_netns())
1049 vrf_id = (vrf_id_t)ns_id;
1050
1051 /* If linking to another interface, note it. */
1052 if (tb[IFLA_LINK])
1053 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
1054
1055 if (tb[IFLA_LINK_NETNSID]) {
1056 link_nsid = *(ns_id_t *)RTA_DATA(tb[IFLA_LINK_NETNSID]);
1057 link_nsid = ns_id_get_absolute(ns_id, link_nsid);
1058 }
1059
1060 ifp = if_get_by_name(name, vrf_id, NULL);
1061 set_ifindex(ifp, ifi->ifi_index, zns); /* add it to ns struct */
1062
1063 ifp->flags = ifi->ifi_flags & 0x0000fffff;
1064 ifp->mtu6 = ifp->mtu = *(uint32_t *)RTA_DATA(tb[IFLA_MTU]);
1065 ifp->metric = 0;
1066 ifp->speed = get_iflink_speed(ifp, NULL);
1067 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
1068
1069 /* Set zebra interface type */
1070 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
1071 if (IS_ZEBRA_IF_VRF(ifp))
1072 SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
1073
1074 /*
1075 * Just set the @link/lower-device ifindex. During nldump interfaces are
1076 * not ordered in any fashion so we may end up getting upper devices
1077 * before lower devices. We will setup the real linkage once the dump
1078 * is complete.
1079 */
1080 zif = (struct zebra_if *)ifp->info;
1081 zif->link_ifindex = link_ifindex;
1082
1083 if (desc) {
1084 XFREE(MTYPE_ZIF_DESC, zif->desc);
1085 zif->desc = XSTRDUP(MTYPE_ZIF_DESC, desc);
1086 }
1087
1088 /* Hardware type and address. */
1089 ifp->ll_type = netlink_to_zebra_link_type(ifi->ifi_type);
1090
1091 netlink_interface_update_hw_addr(tb, ifp);
1092
1093 if_add_update(ifp);
1094
1095 /* Extract and save L2 interface information, take additional actions.
1096 */
1097 netlink_interface_update_l2info(ifp, linkinfo[IFLA_INFO_DATA],
1098 1, link_nsid);
1099 if (IS_ZEBRA_IF_BOND(ifp))
1100 zebra_l2if_update_bond(ifp, true);
1101 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
1102 zebra_l2if_update_bridge_slave(ifp, bridge_ifindex, ns_id,
1103 ZEBRA_BRIDGE_NO_ACTION);
1104 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
1105 zebra_l2if_update_bond_slave(ifp, bond_ifindex, !!bypass);
1106
1107 if (tb[IFLA_PROTO_DOWN]) {
1108 netlink_proc_dplane_if_protodown(zif, tb);
1109 if_sweep_protodown(zif);
1110 }
1111
1112 return 0;
1113 }
1114
1115 /* Request for specific interface or address information from the kernel */
1116 static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
1117 int type, uint32_t filter_mask)
1118 {
1119 struct {
1120 struct nlmsghdr n;
1121 struct ifinfomsg ifm;
1122 char buf[256];
1123 } req;
1124
1125 frrtrace(4, frr_zebra, netlink_request_intf_addr, netlink_cmd, family,
1126 type, filter_mask);
1127
1128 /* Form the request, specifying filter (rtattr) if needed. */
1129 memset(&req, 0, sizeof(req));
1130 req.n.nlmsg_type = type;
1131 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
1132 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
1133 req.ifm.ifi_family = family;
1134
1135 /* Include filter, if specified. */
1136 if (filter_mask)
1137 nl_attr_put32(&req.n, sizeof(req), IFLA_EXT_MASK, filter_mask);
1138
1139 return netlink_request(netlink_cmd, &req);
1140 }
1141
1142 enum netlink_msg_status
1143 netlink_put_gre_set_msg(struct nl_batch *bth, struct zebra_dplane_ctx *ctx)
1144 {
1145 enum dplane_op_e op;
1146 enum netlink_msg_status ret;
1147
1148 op = dplane_ctx_get_op(ctx);
1149 assert(op == DPLANE_OP_GRE_SET);
1150
1151 ret = netlink_batch_add_msg(bth, ctx, netlink_gre_set_msg_encoder, false);
1152
1153 return ret;
1154 }
1155
1156 /* Interface lookup by netlink socket. */
1157 int interface_lookup_netlink(struct zebra_ns *zns)
1158 {
1159 int ret;
1160 struct zebra_dplane_info dp_info;
1161 struct nlsock *netlink_cmd = &zns->netlink_cmd;
1162
1163 /* Capture key info from ns struct */
1164 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
1165
1166 /* Get interface information. */
1167 ret = netlink_request_intf_addr(netlink_cmd, AF_PACKET, RTM_GETLINK, 0);
1168 if (ret < 0)
1169 return ret;
1170 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
1171 true);
1172 if (ret < 0)
1173 return ret;
1174
1175 /* Get interface information - for bridge interfaces. */
1176 ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
1177 RTEXT_FILTER_BRVLAN);
1178 if (ret < 0)
1179 return ret;
1180 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
1181 true);
1182 if (ret < 0)
1183 return ret;
1184
1185 /*
1186 * So netlink_tunneldump_read will initiate a request
1187 * per tunnel to get data. If we are on a kernel that
1188 * does not support this then we will get X error messages
1189 * (one per tunnel request )back which netlink_parse_info will
1190 * stop after the first one. So we need to read equivalent
1191 * error messages per tunnel then we can continue.
1192 * if we do not gather all the read failures then
1193 * later requests will not work right.
1194 */
1195 ret = netlink_tunneldump_read(zns);
1196 if (ret < 0)
1197 return ret;
1198
1199 /* fixup linkages */
1200 zebra_if_update_all_links(zns);
1201 return 0;
1202 }
1203
1204 /**
1205 * interface_addr_lookup_netlink() - Look up interface addresses
1206 *
1207 * @zns: Zebra netlink socket
1208 * Return: Result status
1209 */
1210 static int interface_addr_lookup_netlink(struct zebra_ns *zns)
1211 {
1212 int ret;
1213 struct zebra_dplane_info dp_info;
1214 struct nlsock *netlink_cmd = &zns->netlink_cmd;
1215
1216 /* Capture key info from ns struct */
1217 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
1218
1219 /* Get IPv4 address of the interfaces. */
1220 ret = netlink_request_intf_addr(netlink_cmd, AF_INET, RTM_GETADDR, 0);
1221 if (ret < 0)
1222 return ret;
1223 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
1224 0, true);
1225 if (ret < 0)
1226 return ret;
1227
1228 /* Get IPv6 address of the interfaces. */
1229 ret = netlink_request_intf_addr(netlink_cmd, AF_INET6, RTM_GETADDR, 0);
1230 if (ret < 0)
1231 return ret;
1232 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
1233 0, true);
1234 if (ret < 0)
1235 return ret;
1236
1237 return 0;
1238 }
1239
1240 int kernel_interface_set_master(struct interface *master,
1241 struct interface *slave)
1242 {
1243 struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT);
1244
1245 struct {
1246 struct nlmsghdr n;
1247 struct ifinfomsg ifa;
1248 char buf[NL_PKT_BUF_SIZE];
1249 } req;
1250
1251 memset(&req, 0, sizeof(req));
1252
1253 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
1254 req.n.nlmsg_flags = NLM_F_REQUEST;
1255 req.n.nlmsg_type = RTM_SETLINK;
1256 req.n.nlmsg_pid = zns->netlink_cmd.snl.nl_pid;
1257
1258 req.ifa.ifi_index = slave->ifindex;
1259
1260 nl_attr_put32(&req.n, sizeof(req), IFLA_MASTER, master->ifindex);
1261 nl_attr_put32(&req.n, sizeof(req), IFLA_LINK, slave->ifindex);
1262
1263 return netlink_talk(netlink_talk_filter, &req.n, &zns->netlink_cmd, zns,
1264 false);
1265 }
1266
1267 /* Interface address modification. */
1268 static ssize_t netlink_address_msg_encoder(struct zebra_dplane_ctx *ctx,
1269 void *buf, size_t buflen)
1270 {
1271 int bytelen;
1272 const struct prefix *p;
1273 int cmd;
1274 const char *label;
1275
1276 struct {
1277 struct nlmsghdr n;
1278 struct ifaddrmsg ifa;
1279 char buf[0];
1280 } *req = buf;
1281
1282 if (buflen < sizeof(*req))
1283 return 0;
1284
1285 p = dplane_ctx_get_intf_addr(ctx);
1286 memset(req, 0, sizeof(*req));
1287
1288 bytelen = (p->family == AF_INET ? 4 : 16);
1289
1290 req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1291 req->n.nlmsg_flags = NLM_F_REQUEST;
1292
1293 if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_INSTALL)
1294 cmd = RTM_NEWADDR;
1295 else
1296 cmd = RTM_DELADDR;
1297
1298 req->n.nlmsg_type = cmd;
1299 req->ifa.ifa_family = p->family;
1300
1301 req->ifa.ifa_index = dplane_ctx_get_ifindex(ctx);
1302
1303 if (!nl_attr_put(&req->n, buflen, IFA_LOCAL, &p->u.prefix, bytelen))
1304 return 0;
1305
1306 if (p->family == AF_INET) {
1307 if (dplane_ctx_intf_is_connected(ctx)) {
1308 p = dplane_ctx_get_intf_dest(ctx);
1309 if (!nl_attr_put(&req->n, buflen, IFA_ADDRESS,
1310 &p->u.prefix, bytelen))
1311 return 0;
1312 } else if (cmd == RTM_NEWADDR) {
1313 struct in_addr broad = {
1314 .s_addr = ipv4_broadcast_addr(p->u.prefix4.s_addr,
1315 p->prefixlen)
1316 };
1317 if (!nl_attr_put(&req->n, buflen, IFA_BROADCAST, &broad,
1318 bytelen))
1319 return 0;
1320 }
1321 }
1322
1323 /* p is now either address or destination/bcast addr */
1324 req->ifa.ifa_prefixlen = p->prefixlen;
1325
1326 if (dplane_ctx_intf_is_secondary(ctx))
1327 SET_FLAG(req->ifa.ifa_flags, IFA_F_SECONDARY);
1328
1329 if (dplane_ctx_intf_has_label(ctx)) {
1330 label = dplane_ctx_get_intf_label(ctx);
1331 if (!nl_attr_put(&req->n, buflen, IFA_LABEL, label,
1332 strlen(label) + 1))
1333 return 0;
1334 }
1335
1336 return NLMSG_ALIGN(req->n.nlmsg_len);
1337 }
1338
1339 enum netlink_msg_status
1340 netlink_put_address_update_msg(struct nl_batch *bth,
1341 struct zebra_dplane_ctx *ctx)
1342 {
1343 return netlink_batch_add_msg(bth, ctx, netlink_address_msg_encoder,
1344 false);
1345 }
1346
1347 static ssize_t netlink_intf_msg_encoder(struct zebra_dplane_ctx *ctx, void *buf,
1348 size_t buflen)
1349 {
1350 enum dplane_op_e op;
1351 int cmd = 0;
1352
1353 op = dplane_ctx_get_op(ctx);
1354
1355 switch (op) {
1356 case DPLANE_OP_INTF_UPDATE:
1357 cmd = RTM_SETLINK;
1358 break;
1359 case DPLANE_OP_INTF_INSTALL:
1360 cmd = RTM_NEWLINK;
1361 break;
1362 case DPLANE_OP_INTF_DELETE:
1363 cmd = RTM_DELLINK;
1364 break;
1365 default:
1366 flog_err(
1367 EC_ZEBRA_NHG_FIB_UPDATE,
1368 "Context received for kernel interface update with incorrect OP code (%u)",
1369 op);
1370 return -1;
1371 }
1372
1373 return netlink_intf_msg_encode(cmd, ctx, buf, buflen);
1374 }
1375
1376 enum netlink_msg_status
1377 netlink_put_intf_update_msg(struct nl_batch *bth, struct zebra_dplane_ctx *ctx)
1378 {
1379 return netlink_batch_add_msg(bth, ctx, netlink_intf_msg_encoder, false);
1380 }
1381
1382 int netlink_interface_addr(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1383 {
1384 int len;
1385 struct ifaddrmsg *ifa;
1386 struct rtattr *tb[IFA_MAX + 1];
1387 struct interface *ifp;
1388 void *addr;
1389 void *broad;
1390 uint8_t flags = 0;
1391 char *label = NULL;
1392 struct zebra_ns *zns;
1393 uint32_t metric = METRIC_MAX;
1394 uint32_t kernel_flags = 0;
1395
1396 frrtrace(3, frr_zebra, netlink_interface_addr, h, ns_id, startup);
1397
1398 zns = zebra_ns_lookup(ns_id);
1399 ifa = NLMSG_DATA(h);
1400
1401 if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {
1402 flog_warn(
1403 EC_ZEBRA_UNKNOWN_FAMILY,
1404 "Invalid address family: %u received from kernel interface addr change: %s",
1405 ifa->ifa_family, nl_msg_type_to_str(h->nlmsg_type));
1406 return 0;
1407 }
1408
1409 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
1410 return 0;
1411
1412 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1413 if (len < 0) {
1414 zlog_err(
1415 "%s: Message received from netlink is of a broken size: %d %zu",
1416 __func__, h->nlmsg_len,
1417 (size_t)NLMSG_LENGTH(sizeof(struct ifaddrmsg)));
1418 return -1;
1419 }
1420
1421 netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
1422
1423 ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
1424 if (ifp == NULL) {
1425 if (startup) {
1426 /* During startup, failure to lookup the referenced
1427 * interface should not be an error, so we have
1428 * downgraded this condition to warning, and we permit
1429 * the startup interface state retrieval to continue.
1430 */
1431 flog_warn(EC_LIB_INTERFACE,
1432 "%s: can't find interface by index %d",
1433 __func__, ifa->ifa_index);
1434 return 0;
1435 } else {
1436 flog_err(EC_LIB_INTERFACE,
1437 "%s: can't find interface by index %d",
1438 __func__, ifa->ifa_index);
1439 return -1;
1440 }
1441 }
1442
1443 /* Flags passed through */
1444 if (tb[IFA_FLAGS])
1445 kernel_flags = *(int *)RTA_DATA(tb[IFA_FLAGS]);
1446 else
1447 kernel_flags = ifa->ifa_flags;
1448
1449 if (IS_ZEBRA_DEBUG_KERNEL) /* remove this line to see initial ifcfg */
1450 {
1451 char buf[BUFSIZ];
1452 zlog_debug("%s %s %s flags 0x%x:", __func__,
1453 nl_msg_type_to_str(h->nlmsg_type), ifp->name,
1454 kernel_flags);
1455 if (tb[IFA_LOCAL])
1456 zlog_debug(" IFA_LOCAL %s/%d",
1457 inet_ntop(ifa->ifa_family,
1458 RTA_DATA(tb[IFA_LOCAL]), buf,
1459 BUFSIZ),
1460 ifa->ifa_prefixlen);
1461 if (tb[IFA_ADDRESS])
1462 zlog_debug(" IFA_ADDRESS %s/%d",
1463 inet_ntop(ifa->ifa_family,
1464 RTA_DATA(tb[IFA_ADDRESS]), buf,
1465 BUFSIZ),
1466 ifa->ifa_prefixlen);
1467 if (tb[IFA_BROADCAST])
1468 zlog_debug(" IFA_BROADCAST %s/%d",
1469 inet_ntop(ifa->ifa_family,
1470 RTA_DATA(tb[IFA_BROADCAST]), buf,
1471 BUFSIZ),
1472 ifa->ifa_prefixlen);
1473 if (tb[IFA_LABEL] && strcmp(ifp->name, RTA_DATA(tb[IFA_LABEL])))
1474 zlog_debug(" IFA_LABEL %s",
1475 (char *)RTA_DATA(tb[IFA_LABEL]));
1476
1477 if (tb[IFA_CACHEINFO]) {
1478 struct ifa_cacheinfo *ci = RTA_DATA(tb[IFA_CACHEINFO]);
1479 zlog_debug(" IFA_CACHEINFO pref %d, valid %d",
1480 ci->ifa_prefered, ci->ifa_valid);
1481 }
1482 }
1483
1484 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
1485 if (tb[IFA_LOCAL] == NULL)
1486 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
1487 if (tb[IFA_ADDRESS] == NULL)
1488 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
1489
1490 /* local interface address */
1491 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
1492
1493 /* is there a peer address? */
1494 if (tb[IFA_ADDRESS]
1495 && memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]),
1496 RTA_PAYLOAD(tb[IFA_ADDRESS]))) {
1497 broad = RTA_DATA(tb[IFA_ADDRESS]);
1498 SET_FLAG(flags, ZEBRA_IFA_PEER);
1499 } else
1500 /* seeking a broadcast address */
1501 broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST])
1502 : NULL);
1503
1504 /* addr is primary key, SOL if we don't have one */
1505 if (addr == NULL) {
1506 zlog_debug("%s: Local Interface Address is NULL for %s",
1507 __func__, ifp->name);
1508 return -1;
1509 }
1510
1511 /* Flags. */
1512 if (kernel_flags & IFA_F_SECONDARY)
1513 SET_FLAG(flags, ZEBRA_IFA_SECONDARY);
1514
1515 /* Label */
1516 if (tb[IFA_LABEL])
1517 label = (char *)RTA_DATA(tb[IFA_LABEL]);
1518
1519 if (label && strcmp(ifp->name, label) == 0)
1520 label = NULL;
1521
1522 if (tb[IFA_RT_PRIORITY])
1523 metric = *(uint32_t *)RTA_DATA(tb[IFA_RT_PRIORITY]);
1524
1525 /* Register interface address to the interface. */
1526 if (ifa->ifa_family == AF_INET) {
1527 if (ifa->ifa_prefixlen > IPV4_MAX_BITLEN) {
1528 zlog_err(
1529 "Invalid prefix length: %u received from kernel interface addr change: %s",
1530 ifa->ifa_prefixlen,
1531 nl_msg_type_to_str(h->nlmsg_type));
1532 return -1;
1533 }
1534
1535 if (h->nlmsg_type == RTM_NEWADDR)
1536 connected_add_ipv4(ifp, flags, (struct in_addr *)addr,
1537 ifa->ifa_prefixlen,
1538 (struct in_addr *)broad, label,
1539 metric);
1540 else if (CHECK_FLAG(flags, ZEBRA_IFA_PEER)) {
1541 /* Delete with a peer address */
1542 connected_delete_ipv4(
1543 ifp, flags, (struct in_addr *)addr,
1544 ifa->ifa_prefixlen, broad);
1545 } else
1546 connected_delete_ipv4(
1547 ifp, flags, (struct in_addr *)addr,
1548 ifa->ifa_prefixlen, NULL);
1549 }
1550
1551 if (ifa->ifa_family == AF_INET6) {
1552 if (ifa->ifa_prefixlen > IPV6_MAX_BITLEN) {
1553 zlog_err(
1554 "Invalid prefix length: %u received from kernel interface addr change: %s",
1555 ifa->ifa_prefixlen,
1556 nl_msg_type_to_str(h->nlmsg_type));
1557 return -1;
1558 }
1559 if (h->nlmsg_type == RTM_NEWADDR) {
1560 /* Only consider valid addresses; we'll not get a
1561 * notification from
1562 * the kernel till IPv6 DAD has completed, but at init
1563 * time, Quagga
1564 * does query for and will receive all addresses.
1565 */
1566 if (!(kernel_flags
1567 & (IFA_F_DADFAILED | IFA_F_TENTATIVE)))
1568 connected_add_ipv6(ifp, flags,
1569 (struct in6_addr *)addr,
1570 (struct in6_addr *)broad,
1571 ifa->ifa_prefixlen, label,
1572 metric);
1573 } else
1574 connected_delete_ipv6(ifp, (struct in6_addr *)addr,
1575 NULL, ifa->ifa_prefixlen);
1576 }
1577
1578 /*
1579 * Linux kernel does not send route delete on interface down/addr del
1580 * so we have to re-process routes it owns (i.e. kernel routes)
1581 */
1582 if (h->nlmsg_type != RTM_NEWADDR)
1583 rib_update(RIB_UPDATE_KERNEL);
1584
1585 return 0;
1586 }
1587
1588 /*
1589 * Parse and validate an incoming interface address change message,
1590 * generating a dplane context object.
1591 * This runs in the dplane pthread; the context is enqueued to the
1592 * main pthread for processing.
1593 */
1594 int netlink_interface_addr_dplane(struct nlmsghdr *h, ns_id_t ns_id,
1595 int startup /*ignored*/)
1596 {
1597 int len;
1598 struct ifaddrmsg *ifa;
1599 struct rtattr *tb[IFA_MAX + 1];
1600 void *addr;
1601 void *broad;
1602 char *label = NULL;
1603 uint32_t metric = METRIC_MAX;
1604 uint32_t kernel_flags = 0;
1605 struct zebra_dplane_ctx *ctx;
1606 struct prefix p;
1607
1608 ifa = NLMSG_DATA(h);
1609
1610 /* Validate message types */
1611 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
1612 return 0;
1613
1614 if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {
1615 if (IS_ZEBRA_DEBUG_KERNEL)
1616 zlog_debug("%s: %s: Invalid address family: %u",
1617 __func__, nl_msg_type_to_str(h->nlmsg_type),
1618 ifa->ifa_family);
1619 return 0;
1620 }
1621
1622 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1623 if (len < 0) {
1624 if (IS_ZEBRA_DEBUG_KERNEL)
1625 zlog_debug("%s: %s: netlink msg bad size: %d %zu",
1626 __func__, nl_msg_type_to_str(h->nlmsg_type),
1627 h->nlmsg_len,
1628 (size_t)NLMSG_LENGTH(
1629 sizeof(struct ifaddrmsg)));
1630 return -1;
1631 }
1632
1633 netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
1634
1635 /* Flags passed through */
1636 if (tb[IFA_FLAGS])
1637 kernel_flags = *(int *)RTA_DATA(tb[IFA_FLAGS]);
1638 else
1639 kernel_flags = ifa->ifa_flags;
1640
1641 if (IS_ZEBRA_DEBUG_KERNEL) { /* remove this line to see initial ifcfg */
1642 char buf[PREFIX_STRLEN];
1643
1644 zlog_debug("%s: %s nsid %u ifindex %u flags 0x%x:", __func__,
1645 nl_msg_type_to_str(h->nlmsg_type), ns_id,
1646 ifa->ifa_index, kernel_flags);
1647 if (tb[IFA_LOCAL])
1648 zlog_debug(" IFA_LOCAL %s/%d",
1649 inet_ntop(ifa->ifa_family,
1650 RTA_DATA(tb[IFA_LOCAL]), buf,
1651 sizeof(buf)),
1652 ifa->ifa_prefixlen);
1653 if (tb[IFA_ADDRESS])
1654 zlog_debug(" IFA_ADDRESS %s/%d",
1655 inet_ntop(ifa->ifa_family,
1656 RTA_DATA(tb[IFA_ADDRESS]), buf,
1657 sizeof(buf)),
1658 ifa->ifa_prefixlen);
1659 if (tb[IFA_BROADCAST])
1660 zlog_debug(" IFA_BROADCAST %s/%d",
1661 inet_ntop(ifa->ifa_family,
1662 RTA_DATA(tb[IFA_BROADCAST]), buf,
1663 sizeof(buf)),
1664 ifa->ifa_prefixlen);
1665 if (tb[IFA_LABEL])
1666 zlog_debug(" IFA_LABEL %s",
1667 (const char *)RTA_DATA(tb[IFA_LABEL]));
1668
1669 if (tb[IFA_CACHEINFO]) {
1670 struct ifa_cacheinfo *ci = RTA_DATA(tb[IFA_CACHEINFO]);
1671
1672 zlog_debug(" IFA_CACHEINFO pref %d, valid %d",
1673 ci->ifa_prefered, ci->ifa_valid);
1674 }
1675 }
1676
1677 /* Validate prefix length */
1678
1679 if (ifa->ifa_family == AF_INET
1680 && ifa->ifa_prefixlen > IPV4_MAX_BITLEN) {
1681 if (IS_ZEBRA_DEBUG_KERNEL)
1682 zlog_debug("%s: %s: Invalid prefix length: %u",
1683 __func__, nl_msg_type_to_str(h->nlmsg_type),
1684 ifa->ifa_prefixlen);
1685 return -1;
1686 }
1687
1688 if (ifa->ifa_family == AF_INET6) {
1689 if (ifa->ifa_prefixlen > IPV6_MAX_BITLEN) {
1690 if (IS_ZEBRA_DEBUG_KERNEL)
1691 zlog_debug("%s: %s: Invalid prefix length: %u",
1692 __func__,
1693 nl_msg_type_to_str(h->nlmsg_type),
1694 ifa->ifa_prefixlen);
1695 return -1;
1696 }
1697
1698 /* Only consider valid addresses; we'll not get a kernel
1699 * notification till IPv6 DAD has completed, but at init
1700 * time, FRR does query for and will receive all addresses.
1701 */
1702 if (h->nlmsg_type == RTM_NEWADDR
1703 && (kernel_flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))) {
1704 if (IS_ZEBRA_DEBUG_KERNEL)
1705 zlog_debug("%s: %s: Invalid/tentative addr",
1706 __func__,
1707 nl_msg_type_to_str(h->nlmsg_type));
1708 return 0;
1709 }
1710 }
1711
1712 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
1713 if (tb[IFA_LOCAL] == NULL)
1714 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
1715 if (tb[IFA_ADDRESS] == NULL)
1716 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
1717
1718 /* local interface address */
1719 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
1720
1721 /* addr is primary key, SOL if we don't have one */
1722 if (addr == NULL) {
1723 if (IS_ZEBRA_DEBUG_KERNEL)
1724 zlog_debug("%s: %s: No local interface address",
1725 __func__, nl_msg_type_to_str(h->nlmsg_type));
1726 return -1;
1727 }
1728
1729 /* Allocate a context object, now that validation is done. */
1730 ctx = dplane_ctx_alloc();
1731 if (h->nlmsg_type == RTM_NEWADDR)
1732 dplane_ctx_set_op(ctx, DPLANE_OP_INTF_ADDR_ADD);
1733 else
1734 dplane_ctx_set_op(ctx, DPLANE_OP_INTF_ADDR_DEL);
1735
1736 dplane_ctx_set_ifindex(ctx, ifa->ifa_index);
1737 dplane_ctx_set_ns_id(ctx, ns_id);
1738
1739 /* Convert addr to prefix */
1740 memset(&p, 0, sizeof(p));
1741 p.family = ifa->ifa_family;
1742 p.prefixlen = ifa->ifa_prefixlen;
1743 if (p.family == AF_INET)
1744 p.u.prefix4 = *(struct in_addr *)addr;
1745 else
1746 p.u.prefix6 = *(struct in6_addr *)addr;
1747
1748 dplane_ctx_set_intf_addr(ctx, &p);
1749
1750 /* is there a peer address? */
1751 if (tb[IFA_ADDRESS]
1752 && memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]),
1753 RTA_PAYLOAD(tb[IFA_ADDRESS]))) {
1754 broad = RTA_DATA(tb[IFA_ADDRESS]);
1755 dplane_ctx_intf_set_connected(ctx);
1756 } else if (tb[IFA_BROADCAST]) {
1757 /* seeking a broadcast address */
1758 broad = RTA_DATA(tb[IFA_BROADCAST]);
1759 dplane_ctx_intf_set_broadcast(ctx);
1760 } else
1761 broad = NULL;
1762
1763 if (broad) {
1764 /* Convert addr to prefix */
1765 memset(&p, 0, sizeof(p));
1766 p.family = ifa->ifa_family;
1767 p.prefixlen = ifa->ifa_prefixlen;
1768 if (p.family == AF_INET)
1769 p.u.prefix4 = *(struct in_addr *)broad;
1770 else
1771 p.u.prefix6 = *(struct in6_addr *)broad;
1772
1773 dplane_ctx_set_intf_dest(ctx, &p);
1774 }
1775
1776 /* Flags. */
1777 if (kernel_flags & IFA_F_SECONDARY)
1778 dplane_ctx_intf_set_secondary(ctx);
1779
1780 /* Label */
1781 if (tb[IFA_LABEL]) {
1782 label = (char *)RTA_DATA(tb[IFA_LABEL]);
1783 dplane_ctx_set_intf_label(ctx, label);
1784 }
1785
1786 if (tb[IFA_RT_PRIORITY])
1787 metric = *(uint32_t *)RTA_DATA(tb[IFA_RT_PRIORITY]);
1788
1789 dplane_ctx_set_intf_metric(ctx, metric);
1790
1791 /* Enqueue ctx for main pthread to process */
1792 dplane_provider_enqueue_to_zebra(ctx);
1793
1794 return 0;
1795 }
1796
1797 int netlink_link_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1798 {
1799 int len;
1800 struct ifinfomsg *ifi;
1801 struct rtattr *tb[IFLA_MAX + 1];
1802 struct rtattr *linkinfo[IFLA_MAX + 1];
1803 struct interface *ifp;
1804 char *name = NULL;
1805 char *kind = NULL;
1806 char *desc = NULL;
1807 char *slave_kind = NULL;
1808 struct zebra_ns *zns;
1809 vrf_id_t vrf_id = VRF_DEFAULT;
1810 enum zebra_iftype zif_type = ZEBRA_IF_OTHER;
1811 enum zebra_slave_iftype zif_slave_type = ZEBRA_IF_SLAVE_NONE;
1812 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
1813 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
1814 ifindex_t link_ifindex = IFINDEX_INTERNAL;
1815 uint8_t old_hw_addr[INTERFACE_HWADDR_MAX];
1816 struct zebra_if *zif;
1817 ns_id_t link_nsid = ns_id;
1818 ifindex_t master_infindex = IFINDEX_INTERNAL;
1819 uint8_t bypass = 0;
1820
1821 zns = zebra_ns_lookup(ns_id);
1822 ifi = NLMSG_DATA(h);
1823
1824 /* assume if not default zns, then new VRF */
1825 if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)) {
1826 /* If this is not link add/delete message so print warning. */
1827 zlog_debug("%s: wrong kernel message %s", __func__,
1828 nl_msg_type_to_str(h->nlmsg_type));
1829 return 0;
1830 }
1831
1832 if (!(ifi->ifi_family == AF_UNSPEC || ifi->ifi_family == AF_BRIDGE
1833 || ifi->ifi_family == AF_INET6)) {
1834 flog_warn(
1835 EC_ZEBRA_UNKNOWN_FAMILY,
1836 "Invalid address family: %u received from kernel link change: %s",
1837 ifi->ifi_family, nl_msg_type_to_str(h->nlmsg_type));
1838 return 0;
1839 }
1840
1841 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
1842 if (len < 0) {
1843 zlog_err(
1844 "%s: Message received from netlink is of a broken size %d %zu",
1845 __func__, h->nlmsg_len,
1846 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
1847 return -1;
1848 }
1849
1850 /* We are interested in some AF_BRIDGE notifications. */
1851 if (ifi->ifi_family == AF_BRIDGE)
1852 return netlink_bridge_interface(h, len, ns_id, startup);
1853
1854 /* Looking up interface name. */
1855 memset(linkinfo, 0, sizeof(linkinfo));
1856 netlink_parse_rtattr_flags(tb, IFLA_MAX, IFLA_RTA(ifi), len,
1857 NLA_F_NESTED);
1858
1859 /* check for wireless messages to ignore */
1860 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
1861 if (IS_ZEBRA_DEBUG_KERNEL)
1862 zlog_debug("%s: ignoring IFLA_WIRELESS message",
1863 __func__);
1864 return 0;
1865 }
1866
1867 if (tb[IFLA_IFNAME] == NULL)
1868 return -1;
1869 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
1870
1871 /* Must be valid string. */
1872 len = RTA_PAYLOAD(tb[IFLA_IFNAME]);
1873 if (len < 2 || name[len - 1] != '\0') {
1874 if (IS_ZEBRA_DEBUG_KERNEL)
1875 zlog_debug("%s: invalid intf name", __func__);
1876 return -1;
1877 }
1878
1879 if (tb[IFLA_LINKINFO]) {
1880 netlink_parse_rtattr_nested(linkinfo, IFLA_INFO_MAX,
1881 tb[IFLA_LINKINFO]);
1882
1883 if (linkinfo[IFLA_INFO_KIND])
1884 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
1885
1886 if (linkinfo[IFLA_INFO_SLAVE_KIND])
1887 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
1888
1889 netlink_determine_zebra_iftype(kind, &zif_type);
1890 }
1891
1892 /* If linking to another interface, note it. */
1893 if (tb[IFLA_LINK])
1894 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
1895
1896 if (tb[IFLA_LINK_NETNSID]) {
1897 link_nsid = *(ns_id_t *)RTA_DATA(tb[IFLA_LINK_NETNSID]);
1898 link_nsid = ns_id_get_absolute(ns_id, link_nsid);
1899 }
1900 if (tb[IFLA_IFALIAS]) {
1901 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
1902 }
1903
1904 /* See if interface is present. */
1905 ifp = if_lookup_by_name_per_ns(zns, name);
1906
1907 if (h->nlmsg_type == RTM_NEWLINK) {
1908 /* If VRF, create or update the VRF structure itself. */
1909 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
1910 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
1911 vrf_id = (vrf_id_t)ifi->ifi_index;
1912 }
1913
1914 if (tb[IFLA_MASTER]) {
1915 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
1916 && !vrf_is_backend_netns()) {
1917 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
1918 master_infindex = vrf_id =
1919 *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
1920 } else if (slave_kind
1921 && (strcmp(slave_kind, "bridge") == 0)) {
1922 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
1923 master_infindex = bridge_ifindex =
1924 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1925 } else if (slave_kind
1926 && (strcmp(slave_kind, "bond") == 0)) {
1927 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
1928 master_infindex = bond_ifindex =
1929 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1930 bypass = netlink_parse_lacp_bypass(linkinfo);
1931 } else
1932 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
1933 }
1934 if (vrf_is_backend_netns())
1935 vrf_id = (vrf_id_t)ns_id;
1936 if (ifp == NULL
1937 || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
1938 /* Add interface notification from kernel */
1939 if (IS_ZEBRA_DEBUG_KERNEL)
1940 zlog_debug(
1941 "RTM_NEWLINK ADD for %s(%u) vrf_id %u type %d sl_type %d master %u flags 0x%x",
1942 name, ifi->ifi_index, vrf_id, zif_type,
1943 zif_slave_type, master_infindex,
1944 ifi->ifi_flags);
1945
1946 if (ifp == NULL) {
1947 /* unknown interface */
1948 ifp = if_get_by_name(name, vrf_id, NULL);
1949 } else {
1950 /* pre-configured interface, learnt now */
1951 if (ifp->vrf->vrf_id != vrf_id)
1952 if_update_to_new_vrf(ifp, vrf_id);
1953 }
1954
1955 /* Update interface information. */
1956 set_ifindex(ifp, ifi->ifi_index, zns);
1957 ifp->flags = ifi->ifi_flags & 0x0000fffff;
1958 if (!tb[IFLA_MTU]) {
1959 zlog_debug(
1960 "RTM_NEWLINK for interface %s(%u) without MTU set",
1961 name, ifi->ifi_index);
1962 return 0;
1963 }
1964 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
1965 ifp->metric = 0;
1966 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
1967
1968 /* Set interface type */
1969 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
1970 if (IS_ZEBRA_IF_VRF(ifp))
1971 SET_FLAG(ifp->status,
1972 ZEBRA_INTERFACE_VRF_LOOPBACK);
1973
1974 /* Update link. */
1975 zebra_if_update_link(ifp, link_ifindex, link_nsid);
1976
1977 ifp->ll_type =
1978 netlink_to_zebra_link_type(ifi->ifi_type);
1979 netlink_interface_update_hw_addr(tb, ifp);
1980
1981 /* Inform clients, install any configured addresses. */
1982 if_add_update(ifp);
1983
1984 /* Extract and save L2 interface information, take
1985 * additional actions. */
1986 netlink_interface_update_l2info(
1987 ifp, linkinfo[IFLA_INFO_DATA],
1988 1, link_nsid);
1989 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
1990 zebra_l2if_update_bridge_slave(
1991 ifp, bridge_ifindex, ns_id,
1992 ZEBRA_BRIDGE_NO_ACTION);
1993 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
1994 zebra_l2if_update_bond_slave(ifp, bond_ifindex,
1995 !!bypass);
1996
1997 if (tb[IFLA_PROTO_DOWN])
1998 netlink_proc_dplane_if_protodown(ifp->info, tb);
1999
2000 } else if (ifp->vrf->vrf_id != vrf_id) {
2001 /* VRF change for an interface. */
2002 if (IS_ZEBRA_DEBUG_KERNEL)
2003 zlog_debug(
2004 "RTM_NEWLINK vrf-change for %s(%u) vrf_id %u -> %u flags 0x%x",
2005 name, ifp->ifindex, ifp->vrf->vrf_id,
2006 vrf_id, ifi->ifi_flags);
2007
2008 if_handle_vrf_change(ifp, vrf_id);
2009 } else {
2010 bool was_bridge_slave, was_bond_slave;
2011 uint8_t chgflags = ZEBRA_BRIDGE_NO_ACTION;
2012 zif = ifp->info;
2013
2014 /* Interface update. */
2015 if (IS_ZEBRA_DEBUG_KERNEL)
2016 zlog_debug(
2017 "RTM_NEWLINK update for %s(%u) sl_type %d master %u flags 0x%x",
2018 name, ifp->ifindex, zif_slave_type,
2019 master_infindex, ifi->ifi_flags);
2020
2021 set_ifindex(ifp, ifi->ifi_index, zns);
2022 if (!tb[IFLA_MTU]) {
2023 zlog_debug(
2024 "RTM_NEWLINK for interface %s(%u) without MTU set",
2025 name, ifi->ifi_index);
2026 return 0;
2027 }
2028 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
2029 ifp->metric = 0;
2030
2031 /* Update interface type - NOTE: Only slave_type can
2032 * change. */
2033 was_bridge_slave = IS_ZEBRA_IF_BRIDGE_SLAVE(ifp);
2034 was_bond_slave = IS_ZEBRA_IF_BOND_SLAVE(ifp);
2035 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
2036
2037 memcpy(old_hw_addr, ifp->hw_addr, INTERFACE_HWADDR_MAX);
2038
2039 /* Update link. */
2040 zebra_if_update_link(ifp, link_ifindex, link_nsid);
2041
2042 ifp->ll_type =
2043 netlink_to_zebra_link_type(ifi->ifi_type);
2044 netlink_interface_update_hw_addr(tb, ifp);
2045
2046 if (tb[IFLA_PROTO_DOWN])
2047 netlink_proc_dplane_if_protodown(ifp->info, tb);
2048
2049 if (if_is_no_ptm_operative(ifp)) {
2050 bool is_up = if_is_operative(ifp);
2051 ifp->flags = ifi->ifi_flags & 0x0000fffff;
2052 if (!if_is_no_ptm_operative(ifp) ||
2053 CHECK_FLAG(zif->flags,
2054 ZIF_FLAG_PROTODOWN)) {
2055 if (IS_ZEBRA_DEBUG_KERNEL)
2056 zlog_debug(
2057 "Intf %s(%u) has gone DOWN",
2058 name, ifp->ifindex);
2059 if_down(ifp);
2060 rib_update(RIB_UPDATE_KERNEL);
2061 } else if (if_is_operative(ifp)) {
2062 bool mac_updated = false;
2063
2064 /* Must notify client daemons of new
2065 * interface status. */
2066 if (IS_ZEBRA_DEBUG_KERNEL)
2067 zlog_debug(
2068 "Intf %s(%u) PTM up, notifying clients",
2069 name, ifp->ifindex);
2070 if_up(ifp, !is_up);
2071
2072 /* Update EVPN VNI when SVI MAC change
2073 */
2074 if (memcmp(old_hw_addr, ifp->hw_addr,
2075 INTERFACE_HWADDR_MAX))
2076 mac_updated = true;
2077 if (IS_ZEBRA_IF_VLAN(ifp)
2078 && mac_updated) {
2079 struct interface *link_if;
2080
2081 link_if =
2082 if_lookup_by_index_per_ns(
2083 zebra_ns_lookup(NS_DEFAULT),
2084 link_ifindex);
2085 if (link_if)
2086 zebra_vxlan_svi_up(ifp,
2087 link_if);
2088 } else if (mac_updated
2089 && IS_ZEBRA_IF_BRIDGE(ifp)) {
2090 zlog_debug(
2091 "Intf %s(%u) bridge changed MAC address",
2092 name, ifp->ifindex);
2093 chgflags =
2094 ZEBRA_BRIDGE_MASTER_MAC_CHANGE;
2095 }
2096 }
2097 } else {
2098 ifp->flags = ifi->ifi_flags & 0x0000fffff;
2099 if (if_is_operative(ifp) &&
2100 !CHECK_FLAG(zif->flags,
2101 ZIF_FLAG_PROTODOWN)) {
2102 if (IS_ZEBRA_DEBUG_KERNEL)
2103 zlog_debug(
2104 "Intf %s(%u) has come UP",
2105 name, ifp->ifindex);
2106 if_up(ifp, true);
2107 if (IS_ZEBRA_IF_BRIDGE(ifp))
2108 chgflags =
2109 ZEBRA_BRIDGE_MASTER_UP;
2110 } else {
2111 if (IS_ZEBRA_DEBUG_KERNEL)
2112 zlog_debug(
2113 "Intf %s(%u) has gone DOWN",
2114 name, ifp->ifindex);
2115 if_down(ifp);
2116 rib_update(RIB_UPDATE_KERNEL);
2117 }
2118 }
2119
2120 /* Extract and save L2 interface information, take
2121 * additional actions. */
2122 netlink_interface_update_l2info(
2123 ifp, linkinfo[IFLA_INFO_DATA],
2124 0, link_nsid);
2125 if (IS_ZEBRA_IF_BRIDGE(ifp))
2126 zebra_l2if_update_bridge(ifp, chgflags);
2127 if (IS_ZEBRA_IF_BOND(ifp))
2128 zebra_l2if_update_bond(ifp, true);
2129 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) || was_bridge_slave)
2130 zebra_l2if_update_bridge_slave(
2131 ifp, bridge_ifindex, ns_id, chgflags);
2132 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp) || was_bond_slave)
2133 zebra_l2if_update_bond_slave(ifp, bond_ifindex,
2134 !!bypass);
2135 }
2136
2137 zif = ifp->info;
2138 if (zif) {
2139 XFREE(MTYPE_ZIF_DESC, zif->desc);
2140 if (desc)
2141 zif->desc = XSTRDUP(MTYPE_ZIF_DESC, desc);
2142 }
2143 } else {
2144 /* Delete interface notification from kernel */
2145 if (ifp == NULL) {
2146 if (IS_ZEBRA_DEBUG_KERNEL)
2147 zlog_debug(
2148 "RTM_DELLINK for unknown interface %s(%u)",
2149 name, ifi->ifi_index);
2150 return 0;
2151 }
2152
2153 if (IS_ZEBRA_DEBUG_KERNEL)
2154 zlog_debug("RTM_DELLINK for %s(%u)", name,
2155 ifp->ifindex);
2156
2157 UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
2158
2159 if (IS_ZEBRA_IF_BOND(ifp))
2160 zebra_l2if_update_bond(ifp, false);
2161 if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
2162 zebra_l2if_update_bond_slave(ifp, bond_ifindex, false);
2163 /* Special handling for bridge or VxLAN interfaces. */
2164 if (IS_ZEBRA_IF_BRIDGE(ifp))
2165 zebra_l2_bridge_del(ifp);
2166 else if (IS_ZEBRA_IF_VXLAN(ifp))
2167 zebra_l2_vxlanif_del(ifp);
2168
2169 if_delete_update(&ifp);
2170
2171 /* If VRF, delete the VRF structure itself. */
2172 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns())
2173 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
2174 }
2175
2176 return 0;
2177 }
2178
2179 /**
2180 * Interface encoding helper function.
2181 *
2182 * \param[in] cmd netlink command.
2183 * \param[in] ctx dataplane context (information snapshot).
2184 * \param[out] buf buffer to hold the packet.
2185 * \param[in] buflen amount of buffer bytes.
2186 */
2187
2188 ssize_t netlink_intf_msg_encode(uint16_t cmd,
2189 const struct zebra_dplane_ctx *ctx, void *buf,
2190 size_t buflen)
2191 {
2192 struct {
2193 struct nlmsghdr n;
2194 struct ifinfomsg ifa;
2195 char buf[];
2196 } *req = buf;
2197
2198 struct rtattr *nest_protodown_reason;
2199 ifindex_t ifindex = dplane_ctx_get_ifindex(ctx);
2200 bool down = dplane_ctx_intf_is_protodown(ctx);
2201 bool pd_reason_val = dplane_ctx_get_intf_pd_reason_val(ctx);
2202 struct nlsock *nl =
2203 kernel_netlink_nlsock_lookup(dplane_ctx_get_ns_sock(ctx));
2204
2205 if (buflen < sizeof(*req))
2206 return 0;
2207
2208 memset(req, 0, sizeof(*req));
2209
2210 if (cmd != RTM_SETLINK)
2211 flog_err(
2212 EC_ZEBRA_INTF_UPDATE_FAILURE,
2213 "Only RTM_SETLINK message type currently supported in dplane pthread");
2214
2215 req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
2216 req->n.nlmsg_flags = NLM_F_REQUEST;
2217 req->n.nlmsg_type = cmd;
2218 req->n.nlmsg_pid = nl->snl.nl_pid;
2219
2220 req->ifa.ifi_index = ifindex;
2221
2222 nl_attr_put8(&req->n, buflen, IFLA_PROTO_DOWN, down);
2223 nl_attr_put32(&req->n, buflen, IFLA_LINK, ifindex);
2224
2225 /* Reason info nest */
2226 nest_protodown_reason =
2227 nl_attr_nest(&req->n, buflen, IFLA_PROTO_DOWN_REASON);
2228
2229 if (!nest_protodown_reason)
2230 return -1;
2231
2232 nl_attr_put32(&req->n, buflen, IFLA_PROTO_DOWN_REASON_MASK,
2233 (1 << frr_protodown_r_bit));
2234 nl_attr_put32(&req->n, buflen, IFLA_PROTO_DOWN_REASON_VALUE,
2235 ((int)pd_reason_val) << frr_protodown_r_bit);
2236
2237 nl_attr_nest_end(&req->n, nest_protodown_reason);
2238
2239 if (IS_ZEBRA_DEBUG_KERNEL)
2240 zlog_debug("%s: %s, protodown=%d reason_val=%d ifindex=%u",
2241 __func__, nl_msg_type_to_str(cmd), down,
2242 pd_reason_val, ifindex);
2243
2244 return NLMSG_ALIGN(req->n.nlmsg_len);
2245 }
2246
2247 /* Interface information read by netlink. */
2248 void interface_list(struct zebra_ns *zns)
2249 {
2250 interface_lookup_netlink(zns);
2251 /* We add routes for interface address,
2252 * so we need to get the nexthop info
2253 * from the kernel before we can do that
2254 */
2255 netlink_nexthop_read(zns);
2256
2257 interface_addr_lookup_netlink(zns);
2258 }
2259
2260 void if_netlink_set_frr_protodown_r_bit(uint8_t bit)
2261 {
2262 if (IS_ZEBRA_DEBUG_KERNEL)
2263 zlog_debug(
2264 "Protodown reason bit index changed: bit-index %u -> bit-index %u",
2265 frr_protodown_r_bit, bit);
2266
2267 frr_protodown_r_bit = bit;
2268 }
2269
2270 void if_netlink_unset_frr_protodown_r_bit(void)
2271 {
2272 if (IS_ZEBRA_DEBUG_KERNEL)
2273 zlog_debug(
2274 "Protodown reason bit index changed: bit-index %u -> bit-index %u",
2275 frr_protodown_r_bit, FRR_PROTODOWN_REASON_DEFAULT_BIT);
2276
2277 frr_protodown_r_bit = FRR_PROTODOWN_REASON_DEFAULT_BIT;
2278 }
2279
2280
2281 bool if_netlink_frr_protodown_r_bit_is_set(void)
2282 {
2283 return (frr_protodown_r_bit != FRR_PROTODOWN_REASON_DEFAULT_BIT);
2284 }
2285
2286 uint8_t if_netlink_get_frr_protodown_r_bit(void)
2287 {
2288 return frr_protodown_r_bit;
2289 }
2290
2291 /**
2292 * netlink_request_tunneldump() - Request all tunnels from the linux kernel
2293 *
2294 * @zns: Zebra namespace
2295 * @family: AF_* netlink family
2296 * @type: RTM_* (RTM_GETTUNNEL) route type
2297 *
2298 * Return: Result status
2299 */
2300 static int netlink_request_tunneldump(struct zebra_ns *zns, int family,
2301 int ifindex)
2302 {
2303 struct {
2304 struct nlmsghdr n;
2305 struct tunnel_msg tmsg;
2306 char buf[256];
2307 } req;
2308
2309 /* Form the request */
2310 memset(&req, 0, sizeof(req));
2311 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tunnel_msg));
2312 req.n.nlmsg_type = RTM_GETTUNNEL;
2313 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2314 req.tmsg.family = family;
2315 req.tmsg.ifindex = ifindex;
2316
2317 return netlink_request(&zns->netlink_cmd, &req);
2318 }
2319
2320 /*
2321 * Currently we only ask for vxlan l3svd vni information.
2322 * In the future this can be expanded.
2323 */
2324 int netlink_tunneldump_read(struct zebra_ns *zns)
2325 {
2326 int ret = 0;
2327 struct zebra_dplane_info dp_info;
2328 struct route_node *rn;
2329 struct interface *tmp_if = NULL;
2330 struct zebra_if *zif;
2331 struct nlsock *netlink_cmd = &zns->netlink_cmd;
2332
2333 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
2334
2335 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
2336 tmp_if = (struct interface *)rn->info;
2337 if (!tmp_if)
2338 continue;
2339 zif = tmp_if->info;
2340 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
2341 continue;
2342
2343 ret = netlink_request_tunneldump(zns, PF_BRIDGE,
2344 tmp_if->ifindex);
2345 if (ret < 0)
2346 return ret;
2347
2348 ret = netlink_parse_info(netlink_interface, netlink_cmd,
2349 &dp_info, 0, true);
2350
2351 if (ret < 0)
2352 return ret;
2353 }
2354
2355 return 0;
2356 }
2357 #endif /* GNU_LINUX */
FRRouting mirror