]> 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 #12824 from donaldsharp/coverity_evpn
[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->bridge.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 uint8_t svd = 0;
616 struct rtattr *attr[IFLA_VXLAN_MAX + 1];
617 vni_t vni_in_msg;
618 struct in_addr vtep_ip_in_msg;
619 ifindex_t ifindex_link;
620
621 memset(vxl_info, 0, sizeof(*vxl_info));
622 netlink_parse_rtattr_nested(attr, IFLA_VXLAN_MAX, link_data);
623 if (attr[IFLA_VXLAN_COLLECT_METADATA]) {
624 svd = *(uint8_t *)RTA_DATA(attr[IFLA_VXLAN_COLLECT_METADATA]);
625 if (IS_ZEBRA_DEBUG_KERNEL)
626 zlog_debug(
627 "IFLA_VXLAN_COLLECT_METADATA=%u in VXLAN IF message",
628 svd);
629 }
630
631 if (!svd) {
632 /*
633 * In case of svd we will not get vni info directly from the
634 * device
635 */
636 if (!attr[IFLA_VXLAN_ID]) {
637 if (IS_ZEBRA_DEBUG_KERNEL)
638 zlog_debug(
639 "IFLA_VXLAN_ID missing from VXLAN IF message");
640 return -1;
641 }
642
643 vxl_info->vni_info.iftype = ZEBRA_VXLAN_IF_VNI;
644 vni_in_msg = *(vni_t *)RTA_DATA(attr[IFLA_VXLAN_ID]);
645 vxl_info->vni_info.vni.vni = vni_in_msg;
646 } else {
647 vxl_info->vni_info.iftype = ZEBRA_VXLAN_IF_SVD;
648 }
649
650 if (!attr[IFLA_VXLAN_LOCAL]) {
651 if (IS_ZEBRA_DEBUG_KERNEL)
652 zlog_debug(
653 "IFLA_VXLAN_LOCAL missing from VXLAN IF message");
654 } else {
655 vtep_ip_in_msg =
656 *(struct in_addr *)RTA_DATA(attr[IFLA_VXLAN_LOCAL]);
657 vxl_info->vtep_ip = vtep_ip_in_msg;
658 }
659
660 if (attr[IFLA_VXLAN_GROUP]) {
661 if (!svd)
662 vxl_info->vni_info.vni.mcast_grp =
663 *(struct in_addr *)RTA_DATA(
664 attr[IFLA_VXLAN_GROUP]);
665 }
666
667 if (!attr[IFLA_VXLAN_LINK]) {
668 if (IS_ZEBRA_DEBUG_KERNEL)
669 zlog_debug("IFLA_VXLAN_LINK missing from VXLAN IF message");
670 } else {
671 ifindex_link =
672 *(ifindex_t *)RTA_DATA(attr[IFLA_VXLAN_LINK]);
673 vxl_info->ifindex_link = ifindex_link;
674 }
675 return 0;
676 }
677
678 /*
679 * Extract and save L2 params (of interest) for an interface. When a
680 * bridge interface is added or updated, take further actions to map
681 * its members. Likewise, for VxLAN interface.
682 */
683 static void netlink_interface_update_l2info(struct interface *ifp,
684 struct rtattr *link_data, int add,
685 ns_id_t link_nsid)
686 {
687 if (!link_data)
688 return;
689
690 if (IS_ZEBRA_IF_BRIDGE(ifp)) {
691 struct zebra_l2info_bridge bridge_info;
692
693 netlink_extract_bridge_info(link_data, &bridge_info);
694 zebra_l2_bridge_add_update(ifp, &bridge_info, add);
695 } else if (IS_ZEBRA_IF_VLAN(ifp)) {
696 struct zebra_l2info_vlan vlan_info;
697
698 netlink_extract_vlan_info(link_data, &vlan_info);
699 zebra_l2_vlanif_update(ifp, &vlan_info);
700 zebra_evpn_acc_bd_svi_set(ifp->info, NULL,
701 !!if_is_operative(ifp));
702 } else if (IS_ZEBRA_IF_VXLAN(ifp)) {
703 struct zebra_l2info_vxlan vxlan_info;
704
705 netlink_extract_vxlan_info(link_data, &vxlan_info);
706 vxlan_info.link_nsid = link_nsid;
707 zebra_l2_vxlanif_add_update(ifp, &vxlan_info, add);
708 if (link_nsid != NS_UNKNOWN &&
709 vxlan_info.ifindex_link)
710 zebra_if_update_link(ifp, vxlan_info.ifindex_link,
711 link_nsid);
712 } else if (IS_ZEBRA_IF_GRE(ifp)) {
713 struct zebra_l2info_gre gre_info;
714
715 netlink_extract_gre_info(link_data, &gre_info);
716 gre_info.link_nsid = link_nsid;
717 zebra_l2_greif_add_update(ifp, &gre_info, add);
718 if (link_nsid != NS_UNKNOWN &&
719 gre_info.ifindex_link)
720 zebra_if_update_link(ifp, gre_info.ifindex_link,
721 link_nsid);
722 }
723 }
724
725 static int netlink_bridge_vxlan_vlan_vni_map_update(struct interface *ifp,
726 struct rtattr *af_spec)
727 {
728 int rem;
729 vni_t vni_id;
730 vlanid_t vid;
731 uint16_t flags;
732 struct rtattr *i;
733 struct zebra_vxlan_vni vni;
734 struct zebra_vxlan_vni *vnip;
735 struct hash *vni_table = NULL;
736 struct zebra_vxlan_vni vni_end;
737 struct zebra_vxlan_vni vni_start;
738 struct rtattr *aftb[IFLA_BRIDGE_VLAN_TUNNEL_MAX + 1];
739
740 memset(&vni_start, 0, sizeof(vni_start));
741 memset(&vni_end, 0, sizeof(vni_end));
742
743 for (i = RTA_DATA(af_spec), rem = RTA_PAYLOAD(af_spec); RTA_OK(i, rem);
744 i = RTA_NEXT(i, rem)) {
745
746 if (i->rta_type != IFLA_BRIDGE_VLAN_TUNNEL_INFO)
747 continue;
748
749 memset(aftb, 0, sizeof(aftb));
750 netlink_parse_rtattr_nested(aftb, IFLA_BRIDGE_VLAN_TUNNEL_MAX,
751 i);
752 if (!aftb[IFLA_BRIDGE_VLAN_TUNNEL_ID] ||
753 !aftb[IFLA_BRIDGE_VLAN_TUNNEL_VID])
754 /* vlan-vni info missing */
755 return 0;
756
757 flags = 0;
758 memset(&vni, 0, sizeof(vni));
759
760 vni.vni = *(vni_t *)RTA_DATA(aftb[IFLA_BRIDGE_VLAN_TUNNEL_ID]);
761 vni.access_vlan = *(vlanid_t *)RTA_DATA(
762 aftb[IFLA_BRIDGE_VLAN_TUNNEL_VID]);
763
764 if (aftb[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS])
765 flags = *(uint16_t *)RTA_DATA(
766 aftb[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS]);
767
768 if (flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
769 vni_start = vni;
770 continue;
771 }
772
773 if (flags & BRIDGE_VLAN_INFO_RANGE_END)
774 vni_end = vni;
775
776 if (!(flags & BRIDGE_VLAN_INFO_RANGE_END)) {
777 vni_start = vni;
778 vni_end = vni;
779 }
780
781 if (IS_ZEBRA_DEBUG_KERNEL)
782 zlog_debug(
783 "Vlan-Vni(%d:%d-%d:%d) update for VxLAN IF %s(%u)",
784 vni_start.access_vlan, vni_end.access_vlan,
785 vni_start.vni, vni_end.vni, ifp->name,
786 ifp->ifindex);
787
788 if (!vni_table) {
789 vni_table = zebra_vxlan_vni_table_create();
790 if (!vni_table)
791 return 0;
792 }
793
794 for (vid = vni_start.access_vlan, vni_id = vni_start.vni;
795 vid <= vni_end.access_vlan; vid++, vni_id++) {
796
797 memset(&vni, 0, sizeof(vni));
798 vni.vni = vni_id;
799 vni.access_vlan = vid;
800 vnip = hash_get(vni_table, &vni, zebra_vxlan_vni_alloc);
801 if (!vnip)
802 return 0;
803 }
804
805 memset(&vni_start, 0, sizeof(vni_start));
806 memset(&vni_end, 0, sizeof(vni_end));
807 }
808
809 if (vni_table)
810 zebra_vxlan_if_vni_table_add_update(ifp, vni_table);
811
812 return 0;
813 }
814
815 static int netlink_bridge_vxlan_update(struct interface *ifp,
816 struct rtattr *af_spec)
817 {
818 struct rtattr *aftb[IFLA_BRIDGE_MAX + 1];
819 struct bridge_vlan_info *vinfo;
820 struct zebra_if *zif;
821 vlanid_t access_vlan;
822
823 if (!af_spec)
824 return 0;
825
826 zif = (struct zebra_if *)ifp->info;
827
828 /* Single vxlan devices has vni-vlan range to update */
829 if (IS_ZEBRA_VXLAN_IF_SVD(zif))
830 return netlink_bridge_vxlan_vlan_vni_map_update(ifp, af_spec);
831
832 /* There is a 1-to-1 mapping of VLAN to VxLAN - hence
833 * only 1 access VLAN is accepted.
834 */
835 netlink_parse_rtattr_nested(aftb, IFLA_BRIDGE_MAX, af_spec);
836 if (!aftb[IFLA_BRIDGE_VLAN_INFO])
837 return 0;
838
839 vinfo = RTA_DATA(aftb[IFLA_BRIDGE_VLAN_INFO]);
840 if (!(vinfo->flags & BRIDGE_VLAN_INFO_PVID))
841 return 0;
842
843 access_vlan = (vlanid_t)vinfo->vid;
844 if (IS_ZEBRA_DEBUG_KERNEL)
845 zlog_debug("Access VLAN %u for VxLAN IF %s(%u)", access_vlan,
846 ifp->name, ifp->ifindex);
847 zebra_l2_vxlanif_update_access_vlan(ifp, access_vlan);
848 return 0;
849 }
850
851 static void netlink_bridge_vlan_update(struct interface *ifp,
852 struct rtattr *af_spec)
853 {
854 struct rtattr *i;
855 int rem;
856 uint16_t vid_range_start = 0;
857 struct zebra_if *zif;
858 bitfield_t old_vlan_bitmap;
859 struct bridge_vlan_info *vinfo;
860
861 zif = (struct zebra_if *)ifp->info;
862
863 /* cache the old bitmap addrs */
864 old_vlan_bitmap = zif->vlan_bitmap;
865 /* create a new bitmap space for re-eval */
866 bf_init(zif->vlan_bitmap, IF_VLAN_BITMAP_MAX);
867
868 if (af_spec) {
869 for (i = RTA_DATA(af_spec), rem = RTA_PAYLOAD(af_spec);
870 RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {
871
872 if (i->rta_type != IFLA_BRIDGE_VLAN_INFO)
873 continue;
874
875 vinfo = RTA_DATA(i);
876
877 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
878 vid_range_start = vinfo->vid;
879 continue;
880 }
881
882 if (!(vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END))
883 vid_range_start = vinfo->vid;
884
885 zebra_vlan_bitmap_compute(ifp, vid_range_start,
886 vinfo->vid);
887 }
888 }
889
890 zebra_vlan_mbr_re_eval(ifp, old_vlan_bitmap);
891
892 bf_free(old_vlan_bitmap);
893 }
894
895 static int netlink_bridge_interface(struct nlmsghdr *h, int len, ns_id_t ns_id,
896 int startup)
897 {
898 char *name = NULL;
899 struct ifinfomsg *ifi;
900 struct rtattr *tb[IFLA_MAX + 1];
901 struct interface *ifp;
902 struct zebra_if *zif;
903 struct rtattr *af_spec;
904
905 /* Fetch name and ifindex */
906 ifi = NLMSG_DATA(h);
907 netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
908
909 if (tb[IFLA_IFNAME] == NULL)
910 return -1;
911 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
912
913 /* The interface should already be known, if not discard. */
914 ifp = if_lookup_by_index_per_ns(zebra_ns_lookup(ns_id), ifi->ifi_index);
915 if (!ifp) {
916 zlog_debug("Cannot find bridge IF %s(%u)", name,
917 ifi->ifi_index);
918 return 0;
919 }
920
921 /* We are only interested in the access VLAN i.e., AF_SPEC */
922 af_spec = tb[IFLA_AF_SPEC];
923
924 if (IS_ZEBRA_IF_VXLAN(ifp))
925 return netlink_bridge_vxlan_update(ifp, af_spec);
926
927 /* build vlan bitmap associated with this interface if that
928 * device type is interested in the vlans
929 */
930 zif = (struct zebra_if *)ifp->info;
931 if (bf_is_inited(zif->vlan_bitmap))
932 netlink_bridge_vlan_update(ifp, af_spec);
933
934 return 0;
935 }
936
937 static bool is_if_protodown_reason_only_frr(uint32_t rc_bitfield)
938 {
939 /* This shouldn't be possible */
940 assert(frr_protodown_r_bit < 32);
941 return (rc_bitfield == (((uint32_t)1) << frr_protodown_r_bit));
942 }
943
944 /*
945 * Process interface protodown dplane update.
946 *
947 * If the interface is an es bond member then it must follow EVPN's
948 * protodown setting.
949 */
950 static void netlink_proc_dplane_if_protodown(struct zebra_if *zif,
951 struct rtattr **tb)
952 {
953 bool protodown;
954 bool old_protodown;
955 uint32_t rc_bitfield = 0;
956 struct rtattr *pd_reason_info[IFLA_MAX + 1];
957
958 protodown = !!*(uint8_t *)RTA_DATA(tb[IFLA_PROTO_DOWN]);
959
960 if (tb[IFLA_PROTO_DOWN_REASON]) {
961 netlink_parse_rtattr_nested(pd_reason_info, IFLA_INFO_MAX,
962 tb[IFLA_PROTO_DOWN_REASON]);
963
964 if (pd_reason_info[IFLA_PROTO_DOWN_REASON_VALUE])
965 rc_bitfield = *(uint32_t *)RTA_DATA(
966 pd_reason_info[IFLA_PROTO_DOWN_REASON_VALUE]);
967 }
968
969 /*
970 * Set our reason code to note it wasn't us.
971 * If the reason we got from the kernel is ONLY frr though, don't
972 * set it.
973 */
974 COND_FLAG(zif->protodown_rc, ZEBRA_PROTODOWN_EXTERNAL,
975 protodown && rc_bitfield &&
976 !is_if_protodown_reason_only_frr(rc_bitfield));
977
978
979 old_protodown = !!ZEBRA_IF_IS_PROTODOWN(zif);
980 if (protodown == old_protodown)
981 return;
982
983 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
984 zlog_debug("interface %s dplane change, protdown %s",
985 zif->ifp->name, protodown ? "on" : "off");
986
987 /* Set protodown, respectively */
988 COND_FLAG(zif->flags, ZIF_FLAG_PROTODOWN, protodown);
989
990 if (zebra_evpn_is_es_bond_member(zif->ifp)) {
991 /* Check it's not already being sent to the dplane first */
992 if (protodown &&
993 CHECK_FLAG(zif->flags, ZIF_FLAG_SET_PROTODOWN)) {
994 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
995 zlog_debug(
996 "bond mbr %s protodown on recv'd but already sent protodown on to the dplane",
997 zif->ifp->name);
998 return;
999 }
1000
1001 if (!protodown &&
1002 CHECK_FLAG(zif->flags, ZIF_FLAG_UNSET_PROTODOWN)) {
1003 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
1004 zlog_debug(
1005 "bond mbr %s protodown off recv'd but already sent protodown off to the dplane",
1006 zif->ifp->name);
1007 return;
1008 }
1009
1010 if (IS_ZEBRA_DEBUG_EVPN_MH_ES || IS_ZEBRA_DEBUG_KERNEL)
1011 zlog_debug(
1012 "bond mbr %s reinstate protodown %s in the dplane",
1013 zif->ifp->name, old_protodown ? "on" : "off");
1014
1015 if (old_protodown)
1016 SET_FLAG(zif->flags, ZIF_FLAG_SET_PROTODOWN);
1017 else
1018 SET_FLAG(zif->flags, ZIF_FLAG_UNSET_PROTODOWN);
1019
1020 dplane_intf_update(zif->ifp);
1021 }
1022 }
1023
1024 static uint8_t netlink_parse_lacp_bypass(struct rtattr **linkinfo)
1025 {
1026 uint8_t bypass = 0;
1027 struct rtattr *mbrinfo[IFLA_BOND_SLAVE_MAX + 1];
1028
1029 netlink_parse_rtattr_nested(mbrinfo, IFLA_BOND_SLAVE_MAX,
1030 linkinfo[IFLA_INFO_SLAVE_DATA]);
1031 if (mbrinfo[IFLA_BOND_SLAVE_AD_RX_BYPASS])
1032 bypass = *(uint8_t *)RTA_DATA(
1033 mbrinfo[IFLA_BOND_SLAVE_AD_RX_BYPASS]);
1034
1035 return bypass;
1036 }
1037
1038 /*
1039 * Only called at startup to cleanup leftover protodown reasons we may
1040 * have not cleaned up. We leave protodown set though.
1041 */
1042 static void if_sweep_protodown(struct zebra_if *zif)
1043 {
1044 bool protodown;
1045
1046 protodown = !!ZEBRA_IF_IS_PROTODOWN(zif);
1047
1048 if (!protodown)
1049 return;
1050
1051 if (IS_ZEBRA_DEBUG_KERNEL)
1052 zlog_debug("interface %s sweeping protodown %s reason 0x%x",
1053 zif->ifp->name, protodown ? "on" : "off",
1054 zif->protodown_rc);
1055
1056 /* Only clear our reason codes, leave external if it was set */
1057 UNSET_FLAG(zif->protodown_rc, ZEBRA_PROTODOWN_ALL);
1058 dplane_intf_update(zif->ifp);
1059 }
1060
1061 /*
1062 * Called from interface_lookup_netlink(). This function is only used
1063 * during bootstrap.
1064 */
1065 static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1066 {
1067 int len;
1068 struct ifinfomsg *ifi;
1069 struct rtattr *tb[IFLA_MAX + 1];
1070 struct rtattr *linkinfo[IFLA_MAX + 1];
1071 struct interface *ifp;
1072 char *name = NULL;
1073 char *kind = NULL;
1074 char *desc = NULL;
1075 char *slave_kind = NULL;
1076 struct zebra_ns *zns = NULL;
1077 vrf_id_t vrf_id = VRF_DEFAULT;
1078 enum zebra_iftype zif_type = ZEBRA_IF_OTHER;
1079 enum zebra_slave_iftype zif_slave_type = ZEBRA_IF_SLAVE_NONE;
1080 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
1081 ifindex_t link_ifindex = IFINDEX_INTERNAL;
1082 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
1083 struct zebra_if *zif;
1084 ns_id_t link_nsid = ns_id;
1085 uint8_t bypass = 0;
1086
1087 frrtrace(3, frr_zebra, netlink_interface, h, ns_id, startup);
1088
1089 zns = zebra_ns_lookup(ns_id);
1090 ifi = NLMSG_DATA(h);
1091
1092 if (h->nlmsg_type != RTM_NEWLINK)
1093 return 0;
1094
1095 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
1096 if (len < 0) {
1097 zlog_err(
1098 "%s: Message received from netlink is of a broken size: %d %zu",
1099 __func__, h->nlmsg_len,
1100 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
1101 return -1;
1102 }
1103
1104 /* We are interested in some AF_BRIDGE notifications. */
1105 if (ifi->ifi_family == AF_BRIDGE)
1106 return netlink_bridge_interface(h, len, ns_id, startup);
1107
1108 /* Looking up interface name. */
1109 memset(linkinfo, 0, sizeof(linkinfo));
1110 netlink_parse_rtattr_flags(tb, IFLA_MAX, IFLA_RTA(ifi), len,
1111 NLA_F_NESTED);
1112
1113 /* check for wireless messages to ignore */
1114 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
1115 if (IS_ZEBRA_DEBUG_KERNEL)
1116 zlog_debug("%s: ignoring IFLA_WIRELESS message",
1117 __func__);
1118 return 0;
1119 }
1120
1121 if (tb[IFLA_IFNAME] == NULL)
1122 return -1;
1123 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
1124
1125 if (tb[IFLA_IFALIAS])
1126 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
1127
1128 if (tb[IFLA_LINKINFO]) {
1129 netlink_parse_rtattr_nested(linkinfo, IFLA_INFO_MAX,
1130 tb[IFLA_LINKINFO]);
1131
1132 if (linkinfo[IFLA_INFO_KIND])
1133 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
1134
1135 if (linkinfo[IFLA_INFO_SLAVE_KIND])
1136 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
1137
1138 if ((slave_kind != NULL) && strcmp(slave_kind, "bond") == 0)
1139 netlink_determine_zebra_iftype("bond_slave", &zif_type);
1140 else
1141 netlink_determine_zebra_iftype(kind, &zif_type);
1142 }
1143
1144 /* If VRF, create the VRF structure itself. */
1145 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
1146 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
1147 vrf_id = (vrf_id_t)ifi->ifi_index;
1148 }
1149
1150 if (tb[IFLA_MASTER]) {
1151 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
1152 && !vrf_is_backend_netns()) {
1153 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
1154 vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
1155 } else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
1156 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
1157 bridge_ifindex =
1158 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1159 } else if (slave_kind && (strcmp(slave_kind, "bond") == 0)) {
1160 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
1161 bond_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
1162 bypass = netlink_parse_lacp_bypass(linkinfo);
1163 } else
1164 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
1165 }
1166 if (vrf_is_backend_netns())
1167 vrf_id = (vrf_id_t)ns_id;
1168
1169 /* If linking to another interface, note it. */
1170 if (tb[IFLA_LINK])
1171 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
1172
1173 if (tb[IFLA_LINK_NETNSID]) {
1174 link_nsid = *(ns_id_t *)RTA_DATA(tb[IFLA_LINK_NETNSID]);
1175 link_nsid = ns_id_get_absolute(ns_id, link_nsid);
1176 }
1177
1178 ifp = if_get_by_name(name, vrf_id, NULL);
1179 set_ifindex(ifp, ifi->ifi_index, zns); /* add it to ns struct */
1180
1181 ifp->flags = ifi->ifi_flags & 0x0000fffff;
1182 ifp->mtu6 = ifp->mtu = *(uint32_t *)RTA_DATA(tb[IFLA_MTU]);
1183 ifp->metric = 0;
1184 ifp->speed = get_iflink_speed(ifp, NULL);
1185 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
1186
1187 /* Set zebra interface type */
1188 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
1189 if (IS_ZEBRA_IF_VRF(ifp))
1190 SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
1191
1192 /*
1193 * Just set the @link/lower-device ifindex. During nldump interfaces are
1194 * not ordered in any fashion so we may end up getting upper devices
1195 * before lower devices. We will setup the real linkage once the dump
1196 * is complete.
1197 */
1198 zif = (struct zebra_if *)ifp->info;
1199 zif->link_ifindex = link_ifindex;
1200
1201 if (desc) {
1202 XFREE(MTYPE_ZIF_DESC, zif->desc);
1203 zif->desc = XSTRDUP(MTYPE_ZIF_DESC, desc);
1204 }
1205
1206 /* Hardware type and address. */
1207 ifp->ll_type = netlink_to_zebra_link_type(ifi->ifi_type);
1208
1209 netlink_interface_update_hw_addr(tb, ifp);
1210
1211 if_add_update(ifp);
1212
1213 /* Extract and save L2 interface information, take additional actions.
1214 */
1215 netlink_interface_update_l2info(ifp, linkinfo[IFLA_INFO_DATA],
1216 1, link_nsid);
1217 if (IS_ZEBRA_IF_BOND(ifp))
1218 zebra_l2if_update_bond(ifp, true);
1219 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
1220 zebra_l2if_update_bridge_slave(ifp, bridge_ifindex, ns_id,
1221 ZEBRA_BRIDGE_NO_ACTION);
1222 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
1223 zebra_l2if_update_bond_slave(ifp, bond_ifindex, !!bypass);
1224
1225 if (tb[IFLA_PROTO_DOWN]) {
1226 netlink_proc_dplane_if_protodown(zif, tb);
1227 if_sweep_protodown(zif);
1228 }
1229
1230 return 0;
1231 }
1232
1233 /* Request for specific interface or address information from the kernel */
1234 static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
1235 int type, uint32_t filter_mask)
1236 {
1237 struct {
1238 struct nlmsghdr n;
1239 struct ifinfomsg ifm;
1240 char buf[256];
1241 } req;
1242
1243 frrtrace(4, frr_zebra, netlink_request_intf_addr, netlink_cmd, family,
1244 type, filter_mask);
1245
1246 /* Form the request, specifying filter (rtattr) if needed. */
1247 memset(&req, 0, sizeof(req));
1248 req.n.nlmsg_type = type;
1249 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
1250 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
1251 req.ifm.ifi_family = family;
1252
1253 /* Include filter, if specified. */
1254 if (filter_mask)
1255 nl_attr_put32(&req.n, sizeof(req), IFLA_EXT_MASK, filter_mask);
1256
1257 return netlink_request(netlink_cmd, &req);
1258 }
1259
1260 enum netlink_msg_status
1261 netlink_put_gre_set_msg(struct nl_batch *bth, struct zebra_dplane_ctx *ctx)
1262 {
1263 enum dplane_op_e op;
1264 enum netlink_msg_status ret;
1265
1266 op = dplane_ctx_get_op(ctx);
1267 assert(op == DPLANE_OP_GRE_SET);
1268
1269 ret = netlink_batch_add_msg(bth, ctx, netlink_gre_set_msg_encoder, false);
1270
1271 return ret;
1272 }
1273
1274 /* Interface lookup by netlink socket. */
1275 int interface_lookup_netlink(struct zebra_ns *zns)
1276 {
1277 int ret;
1278 struct zebra_dplane_info dp_info;
1279 struct nlsock *netlink_cmd = &zns->netlink_cmd;
1280
1281 /* Capture key info from ns struct */
1282 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
1283
1284 /* Get interface information. */
1285 ret = netlink_request_intf_addr(netlink_cmd, AF_PACKET, RTM_GETLINK, 0);
1286 if (ret < 0)
1287 return ret;
1288 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
1289 true);
1290 if (ret < 0)
1291 return ret;
1292
1293 /* Get interface information - for bridge interfaces. */
1294 ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
1295 RTEXT_FILTER_BRVLAN);
1296 if (ret < 0)
1297 return ret;
1298 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
1299 true);
1300 if (ret < 0)
1301 return ret;
1302
1303 /*
1304 * So netlink_tunneldump_read will initiate a request
1305 * per tunnel to get data. If we are on a kernel that
1306 * does not support this then we will get X error messages
1307 * (one per tunnel request )back which netlink_parse_info will
1308 * stop after the first one. So we need to read equivalent
1309 * error messages per tunnel then we can continue.
1310 * if we do not gather all the read failures then
1311 * later requests will not work right.
1312 */
1313 ret = netlink_tunneldump_read(zns);
1314 if (ret < 0)
1315 return ret;
1316
1317 /* fixup linkages */
1318 zebra_if_update_all_links(zns);
1319 return 0;
1320 }
1321
1322 /**
1323 * interface_addr_lookup_netlink() - Look up interface addresses
1324 *
1325 * @zns: Zebra netlink socket
1326 * Return: Result status
1327 */
1328 static int interface_addr_lookup_netlink(struct zebra_ns *zns)
1329 {
1330 int ret;
1331 struct zebra_dplane_info dp_info;
1332 struct nlsock *netlink_cmd = &zns->netlink_cmd;
1333
1334 /* Capture key info from ns struct */
1335 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
1336
1337 /* Get IPv4 address of the interfaces. */
1338 ret = netlink_request_intf_addr(netlink_cmd, AF_INET, RTM_GETADDR, 0);
1339 if (ret < 0)
1340 return ret;
1341 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
1342 0, true);
1343 if (ret < 0)
1344 return ret;
1345
1346 /* Get IPv6 address of the interfaces. */
1347 ret = netlink_request_intf_addr(netlink_cmd, AF_INET6, RTM_GETADDR, 0);
1348 if (ret < 0)
1349 return ret;
1350 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
1351 0, true);
1352 if (ret < 0)
1353 return ret;
1354
1355 return 0;
1356 }
1357
1358 int kernel_interface_set_master(struct interface *master,
1359 struct interface *slave)
1360 {
1361 struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT);
1362
1363 struct {
1364 struct nlmsghdr n;
1365 struct ifinfomsg ifa;
1366 char buf[NL_PKT_BUF_SIZE];
1367 } req;
1368
1369 memset(&req, 0, sizeof(req));
1370
1371 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
1372 req.n.nlmsg_flags = NLM_F_REQUEST;
1373 req.n.nlmsg_type = RTM_SETLINK;
1374 req.n.nlmsg_pid = zns->netlink_cmd.snl.nl_pid;
1375
1376 req.ifa.ifi_index = slave->ifindex;
1377
1378 nl_attr_put32(&req.n, sizeof(req), IFLA_MASTER, master->ifindex);
1379 nl_attr_put32(&req.n, sizeof(req), IFLA_LINK, slave->ifindex);
1380
1381 return netlink_talk(netlink_talk_filter, &req.n, &zns->netlink_cmd, zns,
1382 false);
1383 }
1384
1385 /* Interface address modification. */
1386 static ssize_t netlink_address_msg_encoder(struct zebra_dplane_ctx *ctx,
1387 void *buf, size_t buflen)
1388 {
1389 int bytelen;
1390 const struct prefix *p;
1391 int cmd;
1392 const char *label;
1393
1394 struct {
1395 struct nlmsghdr n;
1396 struct ifaddrmsg ifa;
1397 char buf[0];
1398 } *req = buf;
1399
1400 if (buflen < sizeof(*req))
1401 return 0;
1402
1403 p = dplane_ctx_get_intf_addr(ctx);
1404 memset(req, 0, sizeof(*req));
1405
1406 bytelen = (p->family == AF_INET ? 4 : 16);
1407
1408 req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1409 req->n.nlmsg_flags = NLM_F_REQUEST;
1410
1411 if (dplane_ctx_get_op(ctx) == DPLANE_OP_ADDR_INSTALL)
1412 cmd = RTM_NEWADDR;
1413 else
1414 cmd = RTM_DELADDR;
1415
1416 req->n.nlmsg_type = cmd;
1417 req->ifa.ifa_family = p->family;
1418
1419 req->ifa.ifa_index = dplane_ctx_get_ifindex(ctx);
1420
1421 if (!nl_attr_put(&req->n, buflen, IFA_LOCAL, &p->u.prefix, bytelen))
1422 return 0;
1423
1424 if (p->family == AF_INET) {
1425 if (dplane_ctx_intf_is_connected(ctx)) {
1426 p = dplane_ctx_get_intf_dest(ctx);
1427 if (!nl_attr_put(&req->n, buflen, IFA_ADDRESS,
1428 &p->u.prefix, bytelen))
1429 return 0;
1430 } else if (cmd == RTM_NEWADDR) {
1431 struct in_addr broad = {
1432 .s_addr = ipv4_broadcast_addr(p->u.prefix4.s_addr,
1433 p->prefixlen)
1434 };
1435 if (!nl_attr_put(&req->n, buflen, IFA_BROADCAST, &broad,
1436 bytelen))
1437 return 0;
1438 }
1439 }
1440
1441 /* p is now either address or destination/bcast addr */
1442 req->ifa.ifa_prefixlen = p->prefixlen;
1443
1444 if (dplane_ctx_intf_is_secondary(ctx))
1445 SET_FLAG(req->ifa.ifa_flags, IFA_F_SECONDARY);
1446
1447 if (dplane_ctx_intf_has_label(ctx)) {
1448 label = dplane_ctx_get_intf_label(ctx);
1449 if (!nl_attr_put(&req->n, buflen, IFA_LABEL, label,
1450 strlen(label) + 1))
1451 return 0;
1452 }
1453
1454 return NLMSG_ALIGN(req->n.nlmsg_len);
1455 }
1456
1457 enum netlink_msg_status
1458 netlink_put_address_update_msg(struct nl_batch *bth,
1459 struct zebra_dplane_ctx *ctx)
1460 {
1461 return netlink_batch_add_msg(bth, ctx, netlink_address_msg_encoder,
1462 false);
1463 }
1464
1465 static ssize_t netlink_intf_msg_encoder(struct zebra_dplane_ctx *ctx, void *buf,
1466 size_t buflen)
1467 {
1468 enum dplane_op_e op;
1469 int cmd = 0;
1470
1471 op = dplane_ctx_get_op(ctx);
1472
1473 switch (op) {
1474 case DPLANE_OP_INTF_UPDATE:
1475 cmd = RTM_SETLINK;
1476 break;
1477 case DPLANE_OP_INTF_INSTALL:
1478 cmd = RTM_NEWLINK;
1479 break;
1480 case DPLANE_OP_INTF_DELETE:
1481 cmd = RTM_DELLINK;
1482 break;
1483 case DPLANE_OP_NONE:
1484 case DPLANE_OP_ROUTE_INSTALL:
1485 case DPLANE_OP_ROUTE_UPDATE:
1486 case DPLANE_OP_ROUTE_DELETE:
1487 case DPLANE_OP_ROUTE_NOTIFY:
1488 case DPLANE_OP_NH_INSTALL:
1489 case DPLANE_OP_NH_UPDATE:
1490 case DPLANE_OP_NH_DELETE:
1491 case DPLANE_OP_LSP_INSTALL:
1492 case DPLANE_OP_LSP_DELETE:
1493 case DPLANE_OP_LSP_NOTIFY:
1494 case DPLANE_OP_LSP_UPDATE:
1495 case DPLANE_OP_PW_INSTALL:
1496 case DPLANE_OP_PW_UNINSTALL:
1497 case DPLANE_OP_SYS_ROUTE_ADD:
1498 case DPLANE_OP_SYS_ROUTE_DELETE:
1499 case DPLANE_OP_ADDR_INSTALL:
1500 case DPLANE_OP_ADDR_UNINSTALL:
1501 case DPLANE_OP_MAC_INSTALL:
1502 case DPLANE_OP_MAC_DELETE:
1503 case DPLANE_OP_NEIGH_INSTALL:
1504 case DPLANE_OP_NEIGH_UPDATE:
1505 case DPLANE_OP_NEIGH_DELETE:
1506 case DPLANE_OP_NEIGH_DISCOVER:
1507 case DPLANE_OP_VTEP_ADD:
1508 case DPLANE_OP_VTEP_DELETE:
1509 case DPLANE_OP_RULE_ADD:
1510 case DPLANE_OP_RULE_DELETE:
1511 case DPLANE_OP_RULE_UPDATE:
1512 case DPLANE_OP_BR_PORT_UPDATE:
1513 case DPLANE_OP_IPTABLE_ADD:
1514 case DPLANE_OP_IPTABLE_DELETE:
1515 case DPLANE_OP_IPSET_ADD:
1516 case DPLANE_OP_IPSET_ENTRY_ADD:
1517 case DPLANE_OP_IPSET_ENTRY_DELETE:
1518 case DPLANE_OP_IPSET_DELETE:
1519 case DPLANE_OP_NEIGH_IP_INSTALL:
1520 case DPLANE_OP_NEIGH_IP_DELETE:
1521 case DPLANE_OP_NEIGH_TABLE_UPDATE:
1522 case DPLANE_OP_GRE_SET:
1523 case DPLANE_OP_INTF_ADDR_ADD:
1524 case DPLANE_OP_INTF_ADDR_DEL:
1525 case DPLANE_OP_INTF_NETCONFIG:
1526 case DPLANE_OP_TC_QDISC_INSTALL:
1527 case DPLANE_OP_TC_QDISC_UNINSTALL:
1528 case DPLANE_OP_TC_CLASS_ADD:
1529 case DPLANE_OP_TC_CLASS_DELETE:
1530 case DPLANE_OP_TC_CLASS_UPDATE:
1531 case DPLANE_OP_TC_FILTER_ADD:
1532 case DPLANE_OP_TC_FILTER_DELETE:
1533 case DPLANE_OP_TC_FILTER_UPDATE:
1534 flog_err(
1535 EC_ZEBRA_NHG_FIB_UPDATE,
1536 "Context received for kernel interface update with incorrect OP code (%u)",
1537 op);
1538 return -1;
1539 }
1540
1541 return netlink_intf_msg_encode(cmd, ctx, buf, buflen);
1542 }
1543
1544 enum netlink_msg_status
1545 netlink_put_intf_update_msg(struct nl_batch *bth, struct zebra_dplane_ctx *ctx)
1546 {
1547 return netlink_batch_add_msg(bth, ctx, netlink_intf_msg_encoder, false);
1548 }
1549
1550 int netlink_interface_addr(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1551 {
1552 int len;
1553 struct ifaddrmsg *ifa;
1554 struct rtattr *tb[IFA_MAX + 1];
1555 struct interface *ifp;
1556 void *addr;
1557 void *broad;
1558 uint8_t flags = 0;
1559 char *label = NULL;
1560 struct zebra_ns *zns;
1561 uint32_t metric = METRIC_MAX;
1562 uint32_t kernel_flags = 0;
1563
1564 frrtrace(3, frr_zebra, netlink_interface_addr, h, ns_id, startup);
1565
1566 zns = zebra_ns_lookup(ns_id);
1567 ifa = NLMSG_DATA(h);
1568
1569 if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {
1570 flog_warn(
1571 EC_ZEBRA_UNKNOWN_FAMILY,
1572 "Invalid address family: %u received from kernel interface addr change: %s",
1573 ifa->ifa_family, nl_msg_type_to_str(h->nlmsg_type));
1574 return 0;
1575 }
1576
1577 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
1578 return 0;
1579
1580 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1581 if (len < 0) {
1582 zlog_err(
1583 "%s: Message received from netlink is of a broken size: %d %zu",
1584 __func__, h->nlmsg_len,
1585 (size_t)NLMSG_LENGTH(sizeof(struct ifaddrmsg)));
1586 return -1;
1587 }
1588
1589 netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
1590
1591 ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
1592 if (ifp == NULL) {
1593 if (startup) {
1594 /* During startup, failure to lookup the referenced
1595 * interface should not be an error, so we have
1596 * downgraded this condition to warning, and we permit
1597 * the startup interface state retrieval to continue.
1598 */
1599 flog_warn(EC_LIB_INTERFACE,
1600 "%s: can't find interface by index %d",
1601 __func__, ifa->ifa_index);
1602 return 0;
1603 } else {
1604 flog_err(EC_LIB_INTERFACE,
1605 "%s: can't find interface by index %d",
1606 __func__, ifa->ifa_index);
1607 return -1;
1608 }
1609 }
1610
1611 /* Flags passed through */
1612 if (tb[IFA_FLAGS])
1613 kernel_flags = *(int *)RTA_DATA(tb[IFA_FLAGS]);
1614 else
1615 kernel_flags = ifa->ifa_flags;
1616
1617 if (IS_ZEBRA_DEBUG_KERNEL) /* remove this line to see initial ifcfg */
1618 {
1619 char buf[BUFSIZ];
1620 zlog_debug("%s %s %s flags 0x%x:", __func__,
1621 nl_msg_type_to_str(h->nlmsg_type), ifp->name,
1622 kernel_flags);
1623 if (tb[IFA_LOCAL])
1624 zlog_debug(" IFA_LOCAL %s/%d",
1625 inet_ntop(ifa->ifa_family,
1626 RTA_DATA(tb[IFA_LOCAL]), buf,
1627 BUFSIZ),
1628 ifa->ifa_prefixlen);
1629 if (tb[IFA_ADDRESS])
1630 zlog_debug(" IFA_ADDRESS %s/%d",
1631 inet_ntop(ifa->ifa_family,
1632 RTA_DATA(tb[IFA_ADDRESS]), buf,
1633 BUFSIZ),
1634 ifa->ifa_prefixlen);
1635 if (tb[IFA_BROADCAST])
1636 zlog_debug(" IFA_BROADCAST %s/%d",
1637 inet_ntop(ifa->ifa_family,
1638 RTA_DATA(tb[IFA_BROADCAST]), buf,
1639 BUFSIZ),
1640 ifa->ifa_prefixlen);
1641 if (tb[IFA_LABEL] && strcmp(ifp->name, RTA_DATA(tb[IFA_LABEL])))
1642 zlog_debug(" IFA_LABEL %s",
1643 (char *)RTA_DATA(tb[IFA_LABEL]));
1644
1645 if (tb[IFA_CACHEINFO]) {
1646 struct ifa_cacheinfo *ci = RTA_DATA(tb[IFA_CACHEINFO]);
1647 zlog_debug(" IFA_CACHEINFO pref %d, valid %d",
1648 ci->ifa_prefered, ci->ifa_valid);
1649 }
1650 }
1651
1652 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
1653 if (tb[IFA_LOCAL] == NULL)
1654 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
1655 if (tb[IFA_ADDRESS] == NULL)
1656 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
1657
1658 /* local interface address */
1659 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
1660
1661 /* is there a peer address? */
1662 if (tb[IFA_ADDRESS]
1663 && memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]),
1664 RTA_PAYLOAD(tb[IFA_ADDRESS]))) {
1665 broad = RTA_DATA(tb[IFA_ADDRESS]);
1666 SET_FLAG(flags, ZEBRA_IFA_PEER);
1667 } else
1668 /* seeking a broadcast address */
1669 broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST])
1670 : NULL);
1671
1672 /* addr is primary key, SOL if we don't have one */
1673 if (addr == NULL) {
1674 zlog_debug("%s: Local Interface Address is NULL for %s",
1675 __func__, ifp->name);
1676 return -1;
1677 }
1678
1679 /* Flags. */
1680 if (kernel_flags & IFA_F_SECONDARY)
1681 SET_FLAG(flags, ZEBRA_IFA_SECONDARY);
1682
1683 /* Label */
1684 if (tb[IFA_LABEL])
1685 label = (char *)RTA_DATA(tb[IFA_LABEL]);
1686
1687 if (label && strcmp(ifp->name, label) == 0)
1688 label = NULL;
1689
1690 if (tb[IFA_RT_PRIORITY])
1691 metric = *(uint32_t *)RTA_DATA(tb[IFA_RT_PRIORITY]);
1692
1693 /* Register interface address to the interface. */
1694 if (ifa->ifa_family == AF_INET) {
1695 if (ifa->ifa_prefixlen > IPV4_MAX_BITLEN) {
1696 zlog_err(
1697 "Invalid prefix length: %u received from kernel interface addr change: %s",
1698 ifa->ifa_prefixlen,
1699 nl_msg_type_to_str(h->nlmsg_type));
1700 return -1;
1701 }
1702
1703 if (h->nlmsg_type == RTM_NEWADDR)
1704 connected_add_ipv4(ifp, flags, (struct in_addr *)addr,
1705 ifa->ifa_prefixlen,
1706 (struct in_addr *)broad, label,
1707 metric);
1708 else if (CHECK_FLAG(flags, ZEBRA_IFA_PEER)) {
1709 /* Delete with a peer address */
1710 connected_delete_ipv4(
1711 ifp, flags, (struct in_addr *)addr,
1712 ifa->ifa_prefixlen, broad);
1713 } else
1714 connected_delete_ipv4(
1715 ifp, flags, (struct in_addr *)addr,
1716 ifa->ifa_prefixlen, NULL);
1717 }
1718
1719 if (ifa->ifa_family == AF_INET6) {
1720 if (ifa->ifa_prefixlen > IPV6_MAX_BITLEN) {
1721 zlog_err(
1722 "Invalid prefix length: %u received from kernel interface addr change: %s",
1723 ifa->ifa_prefixlen,
1724 nl_msg_type_to_str(h->nlmsg_type));
1725 return -1;
1726 }
1727 if (h->nlmsg_type == RTM_NEWADDR) {
1728 /* Only consider valid addresses; we'll not get a
1729 * notification from
1730 * the kernel till IPv6 DAD has completed, but at init
1731 * time, Quagga
1732 * does query for and will receive all addresses.
1733 */
1734 if (!(kernel_flags
1735 & (IFA_F_DADFAILED | IFA_F_TENTATIVE)))
1736 connected_add_ipv6(ifp, flags,
1737 (struct in6_addr *)addr,
1738 (struct in6_addr *)broad,
1739 ifa->ifa_prefixlen, label,
1740 metric);
1741 } else
1742 connected_delete_ipv6(ifp, (struct in6_addr *)addr,
1743 NULL, ifa->ifa_prefixlen);
1744 }
1745
1746 /*
1747 * Linux kernel does not send route delete on interface down/addr del
1748 * so we have to re-process routes it owns (i.e. kernel routes)
1749 */
1750 if (h->nlmsg_type != RTM_NEWADDR)
1751 rib_update(RIB_UPDATE_KERNEL);
1752
1753 return 0;
1754 }
1755
1756 /*
1757 * Parse and validate an incoming interface address change message,
1758 * generating a dplane context object.
1759 * This runs in the dplane pthread; the context is enqueued to the
1760 * main pthread for processing.
1761 */
1762 int netlink_interface_addr_dplane(struct nlmsghdr *h, ns_id_t ns_id,
1763 int startup /*ignored*/)
1764 {
1765 int len;
1766 struct ifaddrmsg *ifa;
1767 struct rtattr *tb[IFA_MAX + 1];
1768 void *addr;
1769 void *broad;
1770 char *label = NULL;
1771 uint32_t metric = METRIC_MAX;
1772 uint32_t kernel_flags = 0;
1773 struct zebra_dplane_ctx *ctx;
1774 struct prefix p;
1775
1776 ifa = NLMSG_DATA(h);
1777
1778 /* Validate message types */
1779 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
1780 return 0;
1781
1782 if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {
1783 if (IS_ZEBRA_DEBUG_KERNEL)
1784 zlog_debug("%s: %s: Invalid address family: %u",
1785 __func__, nl_msg_type_to_str(h->nlmsg_type),
1786 ifa->ifa_family);
1787 return 0;
1788 }
1789
1790 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
1791 if (len < 0) {
1792 if (IS_ZEBRA_DEBUG_KERNEL)
1793 zlog_debug("%s: %s: netlink msg bad size: %d %zu",
1794 __func__, nl_msg_type_to_str(h->nlmsg_type),
1795 h->nlmsg_len,
1796 (size_t)NLMSG_LENGTH(
1797 sizeof(struct ifaddrmsg)));
1798 return -1;
1799 }
1800
1801 netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
1802
1803 /* Flags passed through */
1804 if (tb[IFA_FLAGS])
1805 kernel_flags = *(int *)RTA_DATA(tb[IFA_FLAGS]);
1806 else
1807 kernel_flags = ifa->ifa_flags;
1808
1809 if (IS_ZEBRA_DEBUG_KERNEL) { /* remove this line to see initial ifcfg */
1810 char buf[PREFIX_STRLEN];
1811
1812 zlog_debug("%s: %s nsid %u ifindex %u flags 0x%x:", __func__,
1813 nl_msg_type_to_str(h->nlmsg_type), ns_id,
1814 ifa->ifa_index, kernel_flags);
1815 if (tb[IFA_LOCAL])
1816 zlog_debug(" IFA_LOCAL %s/%d",
1817 inet_ntop(ifa->ifa_family,
1818 RTA_DATA(tb[IFA_LOCAL]), buf,
1819 sizeof(buf)),
1820 ifa->ifa_prefixlen);
1821 if (tb[IFA_ADDRESS])
1822 zlog_debug(" IFA_ADDRESS %s/%d",
1823 inet_ntop(ifa->ifa_family,
1824 RTA_DATA(tb[IFA_ADDRESS]), buf,
1825 sizeof(buf)),
1826 ifa->ifa_prefixlen);
1827 if (tb[IFA_BROADCAST])
1828 zlog_debug(" IFA_BROADCAST %s/%d",
1829 inet_ntop(ifa->ifa_family,
1830 RTA_DATA(tb[IFA_BROADCAST]), buf,
1831 sizeof(buf)),
1832 ifa->ifa_prefixlen);
1833 if (tb[IFA_LABEL])
1834 zlog_debug(" IFA_LABEL %s",
1835 (const char *)RTA_DATA(tb[IFA_LABEL]));
1836
1837 if (tb[IFA_CACHEINFO]) {
1838 struct ifa_cacheinfo *ci = RTA_DATA(tb[IFA_CACHEINFO]);
1839
1840 zlog_debug(" IFA_CACHEINFO pref %d, valid %d",
1841 ci->ifa_prefered, ci->ifa_valid);
1842 }
1843 }
1844
1845 /* Validate prefix length */
1846
1847 if (ifa->ifa_family == AF_INET
1848 && ifa->ifa_prefixlen > IPV4_MAX_BITLEN) {
1849 if (IS_ZEBRA_DEBUG_KERNEL)
1850 zlog_debug("%s: %s: Invalid prefix length: %u",
1851 __func__, nl_msg_type_to_str(h->nlmsg_type),
1852 ifa->ifa_prefixlen);
1853 return -1;
1854 }
1855
1856 if (ifa->ifa_family == AF_INET6) {
1857 if (ifa->ifa_prefixlen > IPV6_MAX_BITLEN) {
1858 if (IS_ZEBRA_DEBUG_KERNEL)
1859 zlog_debug("%s: %s: Invalid prefix length: %u",
1860 __func__,
1861 nl_msg_type_to_str(h->nlmsg_type),
1862 ifa->ifa_prefixlen);
1863 return -1;
1864 }
1865
1866 /* Only consider valid addresses; we'll not get a kernel
1867 * notification till IPv6 DAD has completed, but at init
1868 * time, FRR does query for and will receive all addresses.
1869 */
1870 if (h->nlmsg_type == RTM_NEWADDR
1871 && (kernel_flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))) {
1872 if (IS_ZEBRA_DEBUG_KERNEL)
1873 zlog_debug("%s: %s: Invalid/tentative addr",
1874 __func__,
1875 nl_msg_type_to_str(h->nlmsg_type));
1876 return 0;
1877 }
1878 }
1879
1880 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
1881 if (tb[IFA_LOCAL] == NULL)
1882 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
1883 if (tb[IFA_ADDRESS] == NULL)
1884 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
1885
1886 /* local interface address */
1887 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
1888
1889 /* addr is primary key, SOL if we don't have one */
1890 if (addr == NULL) {
1891 if (IS_ZEBRA_DEBUG_KERNEL)
1892 zlog_debug("%s: %s: No local interface address",
1893 __func__, nl_msg_type_to_str(h->nlmsg_type));
1894 return -1;
1895 }
1896
1897 /* Allocate a context object, now that validation is done. */
1898 ctx = dplane_ctx_alloc();
1899 if (h->nlmsg_type == RTM_NEWADDR)
1900 dplane_ctx_set_op(ctx, DPLANE_OP_INTF_ADDR_ADD);
1901 else
1902 dplane_ctx_set_op(ctx, DPLANE_OP_INTF_ADDR_DEL);
1903
1904 dplane_ctx_set_ifindex(ctx, ifa->ifa_index);
1905 dplane_ctx_set_ns_id(ctx, ns_id);
1906
1907 /* Convert addr to prefix */
1908 memset(&p, 0, sizeof(p));
1909 p.family = ifa->ifa_family;
1910 p.prefixlen = ifa->ifa_prefixlen;
1911 if (p.family == AF_INET)
1912 p.u.prefix4 = *(struct in_addr *)addr;
1913 else
1914 p.u.prefix6 = *(struct in6_addr *)addr;
1915
1916 dplane_ctx_set_intf_addr(ctx, &p);
1917
1918 /* is there a peer address? */
1919 if (tb[IFA_ADDRESS]
1920 && memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]),
1921 RTA_PAYLOAD(tb[IFA_ADDRESS]))) {
1922 broad = RTA_DATA(tb[IFA_ADDRESS]);
1923 dplane_ctx_intf_set_connected(ctx);
1924 } else if (tb[IFA_BROADCAST]) {
1925 /* seeking a broadcast address */
1926 broad = RTA_DATA(tb[IFA_BROADCAST]);
1927 dplane_ctx_intf_set_broadcast(ctx);
1928 } else
1929 broad = NULL;
1930
1931 if (broad) {
1932 /* Convert addr to prefix */
1933 memset(&p, 0, sizeof(p));
1934 p.family = ifa->ifa_family;
1935 p.prefixlen = ifa->ifa_prefixlen;
1936 if (p.family == AF_INET)
1937 p.u.prefix4 = *(struct in_addr *)broad;
1938 else
1939 p.u.prefix6 = *(struct in6_addr *)broad;
1940
1941 dplane_ctx_set_intf_dest(ctx, &p);
1942 }
1943
1944 /* Flags. */
1945 if (kernel_flags & IFA_F_SECONDARY)
1946 dplane_ctx_intf_set_secondary(ctx);
1947
1948 /* Label */
1949 if (tb[IFA_LABEL]) {
1950 label = (char *)RTA_DATA(tb[IFA_LABEL]);
1951 dplane_ctx_set_intf_label(ctx, label);
1952 }
1953
1954 if (tb[IFA_RT_PRIORITY])
1955 metric = *(uint32_t *)RTA_DATA(tb[IFA_RT_PRIORITY]);
1956
1957 dplane_ctx_set_intf_metric(ctx, metric);
1958
1959 /* Enqueue ctx for main pthread to process */
1960 dplane_provider_enqueue_to_zebra(ctx);
1961
1962 return 0;
1963 }
1964
1965 int netlink_link_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1966 {
1967 int len;
1968 struct ifinfomsg *ifi;
1969 struct rtattr *tb[IFLA_MAX + 1];
1970 struct rtattr *linkinfo[IFLA_MAX + 1];
1971 struct interface *ifp;
1972 char *name = NULL;
1973 char *kind = NULL;
1974 char *desc = NULL;
1975 char *slave_kind = NULL;
1976 struct zebra_ns *zns;
1977 vrf_id_t vrf_id = VRF_DEFAULT;
1978 enum zebra_iftype zif_type = ZEBRA_IF_OTHER;
1979 enum zebra_slave_iftype zif_slave_type = ZEBRA_IF_SLAVE_NONE;
1980 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
1981 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
1982 ifindex_t link_ifindex = IFINDEX_INTERNAL;
1983 uint8_t old_hw_addr[INTERFACE_HWADDR_MAX];
1984 struct zebra_if *zif;
1985 ns_id_t link_nsid = ns_id;
1986 ifindex_t master_infindex = IFINDEX_INTERNAL;
1987 uint8_t bypass = 0;
1988
1989 zns = zebra_ns_lookup(ns_id);
1990 ifi = NLMSG_DATA(h);
1991
1992 /* assume if not default zns, then new VRF */
1993 if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)) {
1994 /* If this is not link add/delete message so print warning. */
1995 zlog_debug("%s: wrong kernel message %s", __func__,
1996 nl_msg_type_to_str(h->nlmsg_type));
1997 return 0;
1998 }
1999
2000 if (!(ifi->ifi_family == AF_UNSPEC || ifi->ifi_family == AF_BRIDGE
2001 || ifi->ifi_family == AF_INET6)) {
2002 flog_warn(
2003 EC_ZEBRA_UNKNOWN_FAMILY,
2004 "Invalid address family: %u received from kernel link change: %s",
2005 ifi->ifi_family, nl_msg_type_to_str(h->nlmsg_type));
2006 return 0;
2007 }
2008
2009 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
2010 if (len < 0) {
2011 zlog_err(
2012 "%s: Message received from netlink is of a broken size %d %zu",
2013 __func__, h->nlmsg_len,
2014 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
2015 return -1;
2016 }
2017
2018 /* We are interested in some AF_BRIDGE notifications. */
2019 if (ifi->ifi_family == AF_BRIDGE)
2020 return netlink_bridge_interface(h, len, ns_id, startup);
2021
2022 /* Looking up interface name. */
2023 memset(linkinfo, 0, sizeof(linkinfo));
2024 netlink_parse_rtattr_flags(tb, IFLA_MAX, IFLA_RTA(ifi), len,
2025 NLA_F_NESTED);
2026
2027 /* check for wireless messages to ignore */
2028 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
2029 if (IS_ZEBRA_DEBUG_KERNEL)
2030 zlog_debug("%s: ignoring IFLA_WIRELESS message",
2031 __func__);
2032 return 0;
2033 }
2034
2035 if (tb[IFLA_IFNAME] == NULL)
2036 return -1;
2037 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
2038
2039 /* Must be valid string. */
2040 len = RTA_PAYLOAD(tb[IFLA_IFNAME]);
2041 if (len < 2 || name[len - 1] != '\0') {
2042 if (IS_ZEBRA_DEBUG_KERNEL)
2043 zlog_debug("%s: invalid intf name", __func__);
2044 return -1;
2045 }
2046
2047 if (tb[IFLA_LINKINFO]) {
2048 netlink_parse_rtattr_nested(linkinfo, IFLA_INFO_MAX,
2049 tb[IFLA_LINKINFO]);
2050
2051 if (linkinfo[IFLA_INFO_KIND])
2052 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
2053
2054 if (linkinfo[IFLA_INFO_SLAVE_KIND])
2055 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
2056
2057 netlink_determine_zebra_iftype(kind, &zif_type);
2058 }
2059
2060 /* If linking to another interface, note it. */
2061 if (tb[IFLA_LINK])
2062 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
2063
2064 if (tb[IFLA_LINK_NETNSID]) {
2065 link_nsid = *(ns_id_t *)RTA_DATA(tb[IFLA_LINK_NETNSID]);
2066 link_nsid = ns_id_get_absolute(ns_id, link_nsid);
2067 }
2068 if (tb[IFLA_IFALIAS]) {
2069 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
2070 }
2071
2072 /* See if interface is present. */
2073 ifp = if_lookup_by_name_per_ns(zns, name);
2074
2075 if (h->nlmsg_type == RTM_NEWLINK) {
2076 /* If VRF, create or update the VRF structure itself. */
2077 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
2078 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
2079 vrf_id = (vrf_id_t)ifi->ifi_index;
2080 }
2081
2082 if (tb[IFLA_MASTER]) {
2083 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
2084 && !vrf_is_backend_netns()) {
2085 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
2086 master_infindex = vrf_id =
2087 *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
2088 } else if (slave_kind
2089 && (strcmp(slave_kind, "bridge") == 0)) {
2090 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
2091 master_infindex = bridge_ifindex =
2092 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
2093 } else if (slave_kind
2094 && (strcmp(slave_kind, "bond") == 0)) {
2095 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
2096 master_infindex = bond_ifindex =
2097 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
2098 bypass = netlink_parse_lacp_bypass(linkinfo);
2099 } else
2100 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
2101 }
2102 if (vrf_is_backend_netns())
2103 vrf_id = (vrf_id_t)ns_id;
2104 if (ifp == NULL
2105 || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
2106 /* Add interface notification from kernel */
2107 if (IS_ZEBRA_DEBUG_KERNEL)
2108 zlog_debug(
2109 "RTM_NEWLINK ADD for %s(%u) vrf_id %u type %d sl_type %d master %u flags 0x%x",
2110 name, ifi->ifi_index, vrf_id, zif_type,
2111 zif_slave_type, master_infindex,
2112 ifi->ifi_flags);
2113
2114 if (ifp == NULL) {
2115 /* unknown interface */
2116 ifp = if_get_by_name(name, vrf_id, NULL);
2117 } else {
2118 /* pre-configured interface, learnt now */
2119 if (ifp->vrf->vrf_id != vrf_id)
2120 if_update_to_new_vrf(ifp, vrf_id);
2121 }
2122
2123 /* Update interface information. */
2124 set_ifindex(ifp, ifi->ifi_index, zns);
2125 ifp->flags = ifi->ifi_flags & 0x0000fffff;
2126 if (!tb[IFLA_MTU]) {
2127 zlog_debug(
2128 "RTM_NEWLINK for interface %s(%u) without MTU set",
2129 name, ifi->ifi_index);
2130 return 0;
2131 }
2132 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
2133 ifp->metric = 0;
2134 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
2135
2136 /* Set interface type */
2137 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
2138 if (IS_ZEBRA_IF_VRF(ifp))
2139 SET_FLAG(ifp->status,
2140 ZEBRA_INTERFACE_VRF_LOOPBACK);
2141
2142 /* Update link. */
2143 zebra_if_update_link(ifp, link_ifindex, link_nsid);
2144
2145 ifp->ll_type =
2146 netlink_to_zebra_link_type(ifi->ifi_type);
2147 netlink_interface_update_hw_addr(tb, ifp);
2148
2149 /* Inform clients, install any configured addresses. */
2150 if_add_update(ifp);
2151
2152 /* Extract and save L2 interface information, take
2153 * additional actions. */
2154 netlink_interface_update_l2info(
2155 ifp, linkinfo[IFLA_INFO_DATA],
2156 1, link_nsid);
2157 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
2158 zebra_l2if_update_bridge_slave(
2159 ifp, bridge_ifindex, ns_id,
2160 ZEBRA_BRIDGE_NO_ACTION);
2161 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
2162 zebra_l2if_update_bond_slave(ifp, bond_ifindex,
2163 !!bypass);
2164
2165 if (tb[IFLA_PROTO_DOWN])
2166 netlink_proc_dplane_if_protodown(ifp->info, tb);
2167 if (IS_ZEBRA_IF_BRIDGE(ifp)) {
2168 zif = ifp->info;
2169 if (IS_ZEBRA_DEBUG_KERNEL)
2170 zlog_debug(
2171 "RTM_NEWLINK ADD for %s(%u), vlan-aware %d",
2172 name, ifp->ifindex,
2173 IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(
2174 zif));
2175 }
2176 } else if (ifp->vrf->vrf_id != vrf_id) {
2177 /* VRF change for an interface. */
2178 if (IS_ZEBRA_DEBUG_KERNEL)
2179 zlog_debug(
2180 "RTM_NEWLINK vrf-change for %s(%u) vrf_id %u -> %u flags 0x%x",
2181 name, ifp->ifindex, ifp->vrf->vrf_id,
2182 vrf_id, ifi->ifi_flags);
2183
2184 if_handle_vrf_change(ifp, vrf_id);
2185 } else {
2186 bool was_bridge_slave, was_bond_slave;
2187 uint8_t chgflags = ZEBRA_BRIDGE_NO_ACTION;
2188 zif = ifp->info;
2189
2190 /* Interface update. */
2191 if (IS_ZEBRA_DEBUG_KERNEL)
2192 zlog_debug(
2193 "RTM_NEWLINK update for %s(%u) sl_type %d master %u flags 0x%x",
2194 name, ifp->ifindex, zif_slave_type,
2195 master_infindex, ifi->ifi_flags);
2196
2197 set_ifindex(ifp, ifi->ifi_index, zns);
2198 if (!tb[IFLA_MTU]) {
2199 zlog_debug(
2200 "RTM_NEWLINK for interface %s(%u) without MTU set",
2201 name, ifi->ifi_index);
2202 return 0;
2203 }
2204 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
2205 ifp->metric = 0;
2206
2207 /* Update interface type - NOTE: Only slave_type can
2208 * change. */
2209 was_bridge_slave = IS_ZEBRA_IF_BRIDGE_SLAVE(ifp);
2210 was_bond_slave = IS_ZEBRA_IF_BOND_SLAVE(ifp);
2211 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
2212
2213 memcpy(old_hw_addr, ifp->hw_addr, INTERFACE_HWADDR_MAX);
2214
2215 /* Update link. */
2216 zebra_if_update_link(ifp, link_ifindex, link_nsid);
2217
2218 ifp->ll_type =
2219 netlink_to_zebra_link_type(ifi->ifi_type);
2220 netlink_interface_update_hw_addr(tb, ifp);
2221
2222 if (tb[IFLA_PROTO_DOWN])
2223 netlink_proc_dplane_if_protodown(ifp->info, tb);
2224
2225 if (if_is_no_ptm_operative(ifp)) {
2226 bool is_up = if_is_operative(ifp);
2227 ifp->flags = ifi->ifi_flags & 0x0000fffff;
2228 if (!if_is_no_ptm_operative(ifp) ||
2229 CHECK_FLAG(zif->flags,
2230 ZIF_FLAG_PROTODOWN)) {
2231 if (IS_ZEBRA_DEBUG_KERNEL)
2232 zlog_debug(
2233 "Intf %s(%u) has gone DOWN",
2234 name, ifp->ifindex);
2235 if_down(ifp);
2236 rib_update(RIB_UPDATE_KERNEL);
2237 } else if (if_is_operative(ifp)) {
2238 bool mac_updated = false;
2239
2240 /* Must notify client daemons of new
2241 * interface status. */
2242 if (IS_ZEBRA_DEBUG_KERNEL)
2243 zlog_debug(
2244 "Intf %s(%u) PTM up, notifying clients",
2245 name, ifp->ifindex);
2246 if_up(ifp, !is_up);
2247
2248 /* Update EVPN VNI when SVI MAC change
2249 */
2250 if (memcmp(old_hw_addr, ifp->hw_addr,
2251 INTERFACE_HWADDR_MAX))
2252 mac_updated = true;
2253 if (IS_ZEBRA_IF_VLAN(ifp)
2254 && mac_updated) {
2255 struct interface *link_if;
2256
2257 link_if =
2258 if_lookup_by_index_per_ns(
2259 zebra_ns_lookup(NS_DEFAULT),
2260 link_ifindex);
2261 if (link_if)
2262 zebra_vxlan_svi_up(ifp,
2263 link_if);
2264 } else if (mac_updated
2265 && IS_ZEBRA_IF_BRIDGE(ifp)) {
2266 zlog_debug(
2267 "Intf %s(%u) bridge changed MAC address",
2268 name, ifp->ifindex);
2269 chgflags =
2270 ZEBRA_BRIDGE_MASTER_MAC_CHANGE;
2271 }
2272 }
2273 } else {
2274 ifp->flags = ifi->ifi_flags & 0x0000fffff;
2275 if (if_is_operative(ifp) &&
2276 !CHECK_FLAG(zif->flags,
2277 ZIF_FLAG_PROTODOWN)) {
2278 if (IS_ZEBRA_DEBUG_KERNEL)
2279 zlog_debug(
2280 "Intf %s(%u) has come UP",
2281 name, ifp->ifindex);
2282 if_up(ifp, true);
2283 if (IS_ZEBRA_IF_BRIDGE(ifp))
2284 chgflags =
2285 ZEBRA_BRIDGE_MASTER_UP;
2286 } else {
2287 if (IS_ZEBRA_DEBUG_KERNEL)
2288 zlog_debug(
2289 "Intf %s(%u) has gone DOWN",
2290 name, ifp->ifindex);
2291 if_down(ifp);
2292 rib_update(RIB_UPDATE_KERNEL);
2293 }
2294 }
2295
2296 /* Extract and save L2 interface information, take
2297 * additional actions. */
2298 netlink_interface_update_l2info(
2299 ifp, linkinfo[IFLA_INFO_DATA],
2300 0, link_nsid);
2301 if (IS_ZEBRA_IF_BRIDGE(ifp))
2302 zebra_l2if_update_bridge(ifp, chgflags);
2303 if (IS_ZEBRA_IF_BOND(ifp))
2304 zebra_l2if_update_bond(ifp, true);
2305 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) || was_bridge_slave)
2306 zebra_l2if_update_bridge_slave(
2307 ifp, bridge_ifindex, ns_id, chgflags);
2308 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp) || was_bond_slave)
2309 zebra_l2if_update_bond_slave(ifp, bond_ifindex,
2310 !!bypass);
2311 if (IS_ZEBRA_IF_BRIDGE(ifp)) {
2312 if (IS_ZEBRA_DEBUG_KERNEL)
2313 zlog_debug(
2314 "RTM_NEWLINK update for %s(%u), vlan-aware %d",
2315 name, ifp->ifindex,
2316 IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(
2317 zif));
2318 }
2319 }
2320
2321 zif = ifp->info;
2322 if (zif) {
2323 XFREE(MTYPE_ZIF_DESC, zif->desc);
2324 if (desc)
2325 zif->desc = XSTRDUP(MTYPE_ZIF_DESC, desc);
2326 }
2327 } else {
2328 /* Delete interface notification from kernel */
2329 if (ifp == NULL) {
2330 if (IS_ZEBRA_DEBUG_KERNEL)
2331 zlog_debug(
2332 "RTM_DELLINK for unknown interface %s(%u)",
2333 name, ifi->ifi_index);
2334 return 0;
2335 }
2336
2337 if (IS_ZEBRA_DEBUG_KERNEL)
2338 zlog_debug("RTM_DELLINK for %s(%u)", name,
2339 ifp->ifindex);
2340
2341 UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
2342
2343 if (IS_ZEBRA_IF_BOND(ifp))
2344 zebra_l2if_update_bond(ifp, false);
2345 if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
2346 zebra_l2if_update_bond_slave(ifp, bond_ifindex, false);
2347 /* Special handling for bridge or VxLAN interfaces. */
2348 if (IS_ZEBRA_IF_BRIDGE(ifp))
2349 zebra_l2_bridge_del(ifp);
2350 else if (IS_ZEBRA_IF_VXLAN(ifp))
2351 zebra_l2_vxlanif_del(ifp);
2352
2353 if_delete_update(&ifp);
2354
2355 /* If VRF, delete the VRF structure itself. */
2356 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns())
2357 netlink_vrf_change(h, tb[IFLA_LINKINFO], ns_id, name);
2358 }
2359
2360 return 0;
2361 }
2362
2363 /**
2364 * Interface encoding helper function.
2365 *
2366 * \param[in] cmd netlink command.
2367 * \param[in] ctx dataplane context (information snapshot).
2368 * \param[out] buf buffer to hold the packet.
2369 * \param[in] buflen amount of buffer bytes.
2370 */
2371
2372 ssize_t netlink_intf_msg_encode(uint16_t cmd,
2373 const struct zebra_dplane_ctx *ctx, void *buf,
2374 size_t buflen)
2375 {
2376 struct {
2377 struct nlmsghdr n;
2378 struct ifinfomsg ifa;
2379 char buf[];
2380 } *req = buf;
2381
2382 struct rtattr *nest_protodown_reason;
2383 ifindex_t ifindex = dplane_ctx_get_ifindex(ctx);
2384 bool down = dplane_ctx_intf_is_protodown(ctx);
2385 bool pd_reason_val = dplane_ctx_get_intf_pd_reason_val(ctx);
2386 struct nlsock *nl =
2387 kernel_netlink_nlsock_lookup(dplane_ctx_get_ns_sock(ctx));
2388
2389 if (buflen < sizeof(*req))
2390 return 0;
2391
2392 memset(req, 0, sizeof(*req));
2393
2394 if (cmd != RTM_SETLINK)
2395 flog_err(
2396 EC_ZEBRA_INTF_UPDATE_FAILURE,
2397 "Only RTM_SETLINK message type currently supported in dplane pthread");
2398
2399 req->n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
2400 req->n.nlmsg_flags = NLM_F_REQUEST;
2401 req->n.nlmsg_type = cmd;
2402 req->n.nlmsg_pid = nl->snl.nl_pid;
2403
2404 req->ifa.ifi_index = ifindex;
2405
2406 nl_attr_put8(&req->n, buflen, IFLA_PROTO_DOWN, down);
2407 nl_attr_put32(&req->n, buflen, IFLA_LINK, ifindex);
2408
2409 /* Reason info nest */
2410 nest_protodown_reason =
2411 nl_attr_nest(&req->n, buflen, IFLA_PROTO_DOWN_REASON);
2412
2413 if (!nest_protodown_reason)
2414 return -1;
2415
2416 nl_attr_put32(&req->n, buflen, IFLA_PROTO_DOWN_REASON_MASK,
2417 (1 << frr_protodown_r_bit));
2418 nl_attr_put32(&req->n, buflen, IFLA_PROTO_DOWN_REASON_VALUE,
2419 ((int)pd_reason_val) << frr_protodown_r_bit);
2420
2421 nl_attr_nest_end(&req->n, nest_protodown_reason);
2422
2423 if (IS_ZEBRA_DEBUG_KERNEL)
2424 zlog_debug("%s: %s, protodown=%d reason_val=%d ifindex=%u",
2425 __func__, nl_msg_type_to_str(cmd), down,
2426 pd_reason_val, ifindex);
2427
2428 return NLMSG_ALIGN(req->n.nlmsg_len);
2429 }
2430
2431 /* Interface information read by netlink. */
2432 void interface_list(struct zebra_ns *zns)
2433 {
2434 interface_lookup_netlink(zns);
2435 /* We add routes for interface address,
2436 * so we need to get the nexthop info
2437 * from the kernel before we can do that
2438 */
2439 netlink_nexthop_read(zns);
2440
2441 interface_addr_lookup_netlink(zns);
2442 }
2443
2444 void if_netlink_set_frr_protodown_r_bit(uint8_t bit)
2445 {
2446 if (IS_ZEBRA_DEBUG_KERNEL)
2447 zlog_debug(
2448 "Protodown reason bit index changed: bit-index %u -> bit-index %u",
2449 frr_protodown_r_bit, bit);
2450
2451 frr_protodown_r_bit = bit;
2452 }
2453
2454 void if_netlink_unset_frr_protodown_r_bit(void)
2455 {
2456 if (IS_ZEBRA_DEBUG_KERNEL)
2457 zlog_debug(
2458 "Protodown reason bit index changed: bit-index %u -> bit-index %u",
2459 frr_protodown_r_bit, FRR_PROTODOWN_REASON_DEFAULT_BIT);
2460
2461 frr_protodown_r_bit = FRR_PROTODOWN_REASON_DEFAULT_BIT;
2462 }
2463
2464
2465 bool if_netlink_frr_protodown_r_bit_is_set(void)
2466 {
2467 return (frr_protodown_r_bit != FRR_PROTODOWN_REASON_DEFAULT_BIT);
2468 }
2469
2470 uint8_t if_netlink_get_frr_protodown_r_bit(void)
2471 {
2472 return frr_protodown_r_bit;
2473 }
2474
2475 /**
2476 * netlink_request_tunneldump() - Request all tunnels from the linux kernel
2477 *
2478 * @zns: Zebra namespace
2479 * @family: AF_* netlink family
2480 * @type: RTM_* (RTM_GETTUNNEL) route type
2481 *
2482 * Return: Result status
2483 */
2484 static int netlink_request_tunneldump(struct zebra_ns *zns, int family,
2485 int ifindex)
2486 {
2487 struct {
2488 struct nlmsghdr n;
2489 struct tunnel_msg tmsg;
2490 char buf[256];
2491 } req;
2492
2493 /* Form the request */
2494 memset(&req, 0, sizeof(req));
2495 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct tunnel_msg));
2496 req.n.nlmsg_type = RTM_GETTUNNEL;
2497 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2498 req.tmsg.family = family;
2499 req.tmsg.ifindex = ifindex;
2500
2501 return netlink_request(&zns->netlink_cmd, &req);
2502 }
2503
2504 /*
2505 * Currently we only ask for vxlan l3svd vni information.
2506 * In the future this can be expanded.
2507 */
2508 int netlink_tunneldump_read(struct zebra_ns *zns)
2509 {
2510 int ret = 0;
2511 struct zebra_dplane_info dp_info;
2512 struct route_node *rn;
2513 struct interface *tmp_if = NULL;
2514 struct zebra_if *zif;
2515 struct nlsock *netlink_cmd = &zns->netlink_cmd;
2516
2517 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
2518
2519 for (rn = route_top(zns->if_table); rn; rn = route_next(rn)) {
2520 tmp_if = (struct interface *)rn->info;
2521 if (!tmp_if)
2522 continue;
2523 zif = tmp_if->info;
2524 if (!zif || zif->zif_type != ZEBRA_IF_VXLAN)
2525 continue;
2526
2527 ret = netlink_request_tunneldump(zns, PF_BRIDGE,
2528 tmp_if->ifindex);
2529 if (ret < 0)
2530 return ret;
2531
2532 ret = netlink_parse_info(netlink_interface, netlink_cmd,
2533 &dp_info, 0, true);
2534
2535 if (ret < 0)
2536 return ret;
2537 }
2538
2539 return 0;
2540 }
2541
2542 static const char *port_state2str(uint8_t state)
2543 {
2544 switch (state) {
2545 case BR_STATE_DISABLED:
2546 return "DISABLED";
2547 case BR_STATE_LISTENING:
2548 return "LISTENING";
2549 case BR_STATE_LEARNING:
2550 return "LEARNING";
2551 case BR_STATE_FORWARDING:
2552 return "FORWARDING";
2553 case BR_STATE_BLOCKING:
2554 return "BLOCKING";
2555 }
2556
2557 return "UNKNOWN";
2558 }
2559
2560 static void vxlan_vni_state_change(struct zebra_if *zif, uint16_t id,
2561 uint8_t state)
2562 {
2563 struct zebra_vxlan_vni *vnip;
2564
2565 vnip = zebra_vxlan_if_vlanid_vni_find(zif, id);
2566
2567 if (!vnip) {
2568 if (IS_ZEBRA_DEBUG_VXLAN)
2569 zlog_debug(
2570 "Cannot find VNI for VID (%u) IF %s for vlan state update",
2571 id, zif->ifp->name);
2572
2573 return;
2574 }
2575
2576 switch (state) {
2577 case BR_STATE_FORWARDING:
2578 zebra_vxlan_if_vni_up(zif->ifp, vnip);
2579 break;
2580 case BR_STATE_BLOCKING:
2581 zebra_vxlan_if_vni_down(zif->ifp, vnip);
2582 break;
2583 case BR_STATE_DISABLED:
2584 case BR_STATE_LISTENING:
2585 case BR_STATE_LEARNING:
2586 default:
2587 /* Not used for anything at the moment */
2588 break;
2589 }
2590 }
2591
2592 static void vlan_id_range_state_change(struct interface *ifp, uint16_t id_start,
2593 uint16_t id_end, uint8_t state)
2594 {
2595 struct zebra_if *zif;
2596
2597 zif = (struct zebra_if *)ifp->info;
2598
2599 if (!zif)
2600 return;
2601
2602 for (uint16_t i = id_start; i <= id_end; i++)
2603 vxlan_vni_state_change(zif, i, state);
2604 }
2605
2606 /**
2607 * netlink_vlan_change() - Read in change about vlans from the kernel
2608 *
2609 * @h: Netlink message header
2610 * @ns_id: Namspace id
2611 * @startup: Are we reading under startup conditions?
2612 *
2613 * Return: Result status
2614 */
2615 int netlink_vlan_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
2616 {
2617 int len, rem;
2618 struct interface *ifp;
2619 struct br_vlan_msg *bvm;
2620 struct bridge_vlan_info *vinfo;
2621 struct rtattr *vtb[BRIDGE_VLANDB_ENTRY_MAX + 1] = {};
2622 struct rtattr *attr;
2623 uint8_t state;
2624 uint32_t vrange;
2625 int type;
2626
2627 /* We only care about state changes for now */
2628 if (!(h->nlmsg_type == RTM_NEWVLAN))
2629 return 0;
2630
2631 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct br_vlan_msg));
2632 if (len < 0) {
2633 zlog_warn(
2634 "%s: Message received from netlink is of a broken size %d %zu",
2635 __func__, h->nlmsg_len,
2636 (size_t)NLMSG_LENGTH(sizeof(struct br_vlan_msg)));
2637 return -1;
2638 }
2639
2640 bvm = NLMSG_DATA(h);
2641
2642 if (bvm->family != AF_BRIDGE)
2643 return 0;
2644
2645 ifp = if_lookup_by_index_per_ns(zebra_ns_lookup(ns_id), bvm->ifindex);
2646 if (!ifp) {
2647 zlog_debug("Cannot find bridge-vlan IF (%u) for vlan update",
2648 bvm->ifindex);
2649 return 0;
2650 }
2651
2652 if (!IS_ZEBRA_IF_VXLAN(ifp)) {
2653 if (IS_ZEBRA_DEBUG_KERNEL)
2654 zlog_debug("Ignoring non-vxlan IF (%s) for vlan update",
2655 ifp->name);
2656
2657 return 0;
2658 }
2659
2660 if (IS_ZEBRA_DEBUG_KERNEL || IS_ZEBRA_DEBUG_VXLAN)
2661 zlog_debug("%s %s IF %s NS %u",
2662 nl_msg_type_to_str(h->nlmsg_type),
2663 nl_family_to_str(bvm->family), ifp->name, ns_id);
2664
2665 /* Loop over "ALL" BRIDGE_VLANDB_ENTRY */
2666 rem = len;
2667 for (attr = BRVLAN_RTA(bvm); RTA_OK(attr, rem);
2668 attr = RTA_NEXT(attr, rem)) {
2669 vinfo = NULL;
2670 vrange = 0;
2671
2672 type = attr->rta_type & NLA_TYPE_MASK;
2673
2674 if (type != BRIDGE_VLANDB_ENTRY)
2675 continue;
2676
2677 /* Parse nested entry data */
2678 netlink_parse_rtattr_nested(vtb, BRIDGE_VLANDB_ENTRY_MAX, attr);
2679
2680 /* It must have info for the ID */
2681 if (!vtb[BRIDGE_VLANDB_ENTRY_INFO])
2682 continue;
2683
2684 vinfo = (struct bridge_vlan_info *)RTA_DATA(
2685 vtb[BRIDGE_VLANDB_ENTRY_INFO]);
2686
2687 /*
2688 * We only care about state info, if there is none, just ignore
2689 * it.
2690 */
2691 if (!vtb[BRIDGE_VLANDB_ENTRY_STATE])
2692 continue;
2693
2694 state = *(uint8_t *)RTA_DATA(vtb[BRIDGE_VLANDB_ENTRY_STATE]);
2695
2696 if (vtb[BRIDGE_VLANDB_ENTRY_RANGE])
2697 vrange = *(uint32_t *)RTA_DATA(
2698 vtb[BRIDGE_VLANDB_ENTRY_RANGE]);
2699
2700 if (IS_ZEBRA_DEBUG_KERNEL || IS_ZEBRA_DEBUG_VXLAN) {
2701 if (vrange)
2702 zlog_debug("VLANDB_ENTRY: VID (%u-%u) state=%s",
2703 vinfo->vid, vrange,
2704 port_state2str(state));
2705 else
2706 zlog_debug("VLANDB_ENTRY: VID (%u) state=%s",
2707 vinfo->vid, port_state2str(state));
2708 }
2709
2710 vlan_id_range_state_change(
2711 ifp, vinfo->vid, (vrange ? vrange : vinfo->vid), state);
2712 }
2713
2714 return 0;
2715 }
2716
2717 /**
2718 * netlink_request_vlan() - Request vlan information from the kernel
2719 * @zns: Zebra namespace
2720 * @family: AF_* netlink family
2721 * @type: RTM_* type
2722 *
2723 * Return: Result status
2724 */
2725 static int netlink_request_vlan(struct zebra_ns *zns, int family, int type)
2726 {
2727 struct {
2728 struct nlmsghdr n;
2729 struct br_vlan_msg bvm;
2730 char buf[256];
2731 } req;
2732
2733 /* Form the request, specifying filter (rtattr) if needed. */
2734 memset(&req, 0, sizeof(req));
2735 req.n.nlmsg_type = type;
2736 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2737 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct br_vlan_msg));
2738 req.bvm.family = family;
2739
2740 nl_attr_put32(&req.n, sizeof(req), BRIDGE_VLANDB_DUMP_FLAGS,
2741 BRIDGE_VLANDB_DUMPF_STATS);
2742
2743 return netlink_request(&zns->netlink_cmd, &req);
2744 }
2745
2746 /**
2747 * netlink_vlan_read() - Vlan read function using netlink interface
2748 *
2749 * @zns: Zebra name space
2750 *
2751 * Return: Result status
2752 * Only called at bootstrap time.
2753 */
2754 int netlink_vlan_read(struct zebra_ns *zns)
2755 {
2756 int ret;
2757 struct zebra_dplane_info dp_info;
2758
2759 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
2760
2761 /* Get bridg vlan info */
2762 ret = netlink_request_vlan(zns, PF_BRIDGE, RTM_GETVLAN);
2763 if (ret < 0)
2764 return ret;
2765
2766 ret = netlink_parse_info(netlink_vlan_change, &zns->netlink_cmd,
2767 &dp_info, 0, 1);
2768
2769 return ret;
2770 }
2771
2772 #endif /* GNU_LINUX */
FRRouting mirror