]> git.proxmox.com Git - mirror_frr.git/blame - zebra/if_netlink.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: ZEBRA_NUM_OF -> array_size
[mirror_frr.git] / zebra / if_netlink.c
CommitLineData
718e3744 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 *
896014f4
DL		 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
718e3744 20 */
21
22#include <zebra.h>
6675513d 23
ddfeb486
DL		 24#ifdef GNU_LINUX
25
6675513d 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
ba85366a 33#include <netinet/if_ether.h>
6675513d 34#include <linux/if_bridge.h>
ba777396 35#include <linux/if_link.h>
1fdc9eae 36#include <net/if_arp.h>
535fe877
DS		 37#include <linux/sockios.h>
38#include <linux/ethtool.h>
1fdc9eae 39
40#include "linklist.h"
41#include "if.h"
42#include "log.h"
43#include "prefix.h"
44#include "connected.h"
45#include "table.h"
46#include "memory.h"
47#include "zebra_memory.h"
48#include "rib.h"
49#include "thread.h"
50#include "privs.h"
51#include "nexthop.h"
52#include "vrf.h"
7922fc65 53#include "vrf_int.h"
1fdc9eae 54#include "mpls.h"
174482ef 55#include "lib_errors.h"
718e3744 56
5e6a74d8 57#include "vty.h"
7dbeea9d 58#include "zebra/zserv.h"
1fdc9eae 59#include "zebra/zebra_ns.h"
60#include "zebra/zebra_vrf.h"
61#include "zebra/rt.h"
62#include "zebra/redistribute.h"
63#include "zebra/interface.h"
64#include "zebra/debug.h"
65#include "zebra/rtadv.h"
66#include "zebra/zebra_ptm.h"
67#include "zebra/zebra_mpls.h"
68#include "zebra/kernel_netlink.h"
69#include "zebra/if_netlink.h"
9df414fe 70#include "zebra/zebra_errors.h"
97c4e1d0 71#include "zebra/zebra_vxlan.h"
1fdc9eae 72
0268f30e 73extern struct zebra_privs_t zserv_privs;
1fdc9eae 74
75/* Note: on netlink systems, there should be a 1-to-1 mapping between interface
76 names and ifindex values. */
d62a17ae 77static void set_ifindex(struct interface *ifp, ifindex_t ifi_index,
78 struct zebra_ns *zns)
1fdc9eae 79{
d62a17ae 80 struct interface *oifp;
81
82 if (((oifp = if_lookup_by_index_per_ns(zns, ifi_index)) != NULL)
83 && (oifp != ifp)) {
84 if (ifi_index == IFINDEX_INTERNAL)
af4c2728 85 flog_err(
450971aa 86 EC_LIB_INTERFACE,
4d43f68a 87 "Netlink is setting interface %s ifindex to reserved internal value %u",
d62a17ae 88 ifp->name, ifi_index);
89 else {
90 if (IS_ZEBRA_DEBUG_KERNEL)
91 zlog_debug(
92 "interface index %d was renamed from %s to %s",
93 ifi_index, oifp->name, ifp->name);
94 if (if_is_up(oifp))
af4c2728 95 flog_err(
450971aa 96 EC_LIB_INTERFACE,
4d43f68a 97 "interface rename detected on up interface: index %d was renamed from %s to %s, results are uncertain!",
d62a17ae 98 ifi_index, oifp->name, ifp->name);
99 if_delete_update(oifp);
100 }
101 }
ff880b78 102 if_set_index(ifp, ifi_index);
1fdc9eae 103}
104
105/* Utility function to parse hardware link-layer address and update ifp */
d62a17ae 106static void netlink_interface_update_hw_addr(struct rtattr **tb,
107 struct interface *ifp)
1fdc9eae 108{
d62a17ae 109 int i;
110
111 if (tb[IFLA_ADDRESS]) {
112 int hw_addr_len;
113
114 hw_addr_len = RTA_PAYLOAD(tb[IFLA_ADDRESS]);
115
116 if (hw_addr_len > INTERFACE_HWADDR_MAX)
9df414fe
QY		 117 zlog_debug("Hardware address is too large: %d",
118 hw_addr_len);
d62a17ae 119 else {
120 ifp->hw_addr_len = hw_addr_len;
121 memcpy(ifp->hw_addr, RTA_DATA(tb[IFLA_ADDRESS]),
122 hw_addr_len);
123
124 for (i = 0; i < hw_addr_len; i++)
125 if (ifp->hw_addr[i] != 0)
126 break;
127
128 if (i == hw_addr_len)
129 ifp->hw_addr_len = 0;
130 else
131 ifp->hw_addr_len = hw_addr_len;
132 }
133 }
1fdc9eae 134}
135
d62a17ae 136static enum zebra_link_type netlink_to_zebra_link_type(unsigned int hwt)
1fdc9eae 137{
d62a17ae 138 switch (hwt) {
139 case ARPHRD_ETHER:
140 return ZEBRA_LLT_ETHER;
141 case ARPHRD_EETHER:
142 return ZEBRA_LLT_EETHER;
143 case ARPHRD_AX25:
144 return ZEBRA_LLT_AX25;
145 case ARPHRD_PRONET:
146 return ZEBRA_LLT_PRONET;
147 case ARPHRD_IEEE802:
148 return ZEBRA_LLT_IEEE802;
149 case ARPHRD_ARCNET:
150 return ZEBRA_LLT_ARCNET;
151 case ARPHRD_APPLETLK:
152 return ZEBRA_LLT_APPLETLK;
153 case ARPHRD_DLCI:
154 return ZEBRA_LLT_DLCI;
155 case ARPHRD_ATM:
156 return ZEBRA_LLT_ATM;
157 case ARPHRD_METRICOM:
158 return ZEBRA_LLT_METRICOM;
159 case ARPHRD_IEEE1394:
160 return ZEBRA_LLT_IEEE1394;
161 case ARPHRD_EUI64:
162 return ZEBRA_LLT_EUI64;
163 case ARPHRD_INFINIBAND:
164 return ZEBRA_LLT_INFINIBAND;
165 case ARPHRD_SLIP:
166 return ZEBRA_LLT_SLIP;
167 case ARPHRD_CSLIP:
168 return ZEBRA_LLT_CSLIP;
169 case ARPHRD_SLIP6:
170 return ZEBRA_LLT_SLIP6;
171 case ARPHRD_CSLIP6:
172 return ZEBRA_LLT_CSLIP6;
173 case ARPHRD_RSRVD:
174 return ZEBRA_LLT_RSRVD;
175 case ARPHRD_ADAPT:
176 return ZEBRA_LLT_ADAPT;
177 case ARPHRD_ROSE:
178 return ZEBRA_LLT_ROSE;
179 case ARPHRD_X25:
180 return ZEBRA_LLT_X25;
181 case ARPHRD_PPP:
182 return ZEBRA_LLT_PPP;
183 case ARPHRD_CISCO:
184 return ZEBRA_LLT_CHDLC;
185 case ARPHRD_LAPB:
186 return ZEBRA_LLT_LAPB;
187 case ARPHRD_RAWHDLC:
188 return ZEBRA_LLT_RAWHDLC;
189 case ARPHRD_TUNNEL:
190 return ZEBRA_LLT_IPIP;
191 case ARPHRD_TUNNEL6:
192 return ZEBRA_LLT_IPIP6;
193 case ARPHRD_FRAD:
194 return ZEBRA_LLT_FRAD;
195 case ARPHRD_SKIP:
196 return ZEBRA_LLT_SKIP;
197 case ARPHRD_LOOPBACK:
198 return ZEBRA_LLT_LOOPBACK;
199 case ARPHRD_LOCALTLK:
200 return ZEBRA_LLT_LOCALTLK;
201 case ARPHRD_FDDI:
202 return ZEBRA_LLT_FDDI;
203 case ARPHRD_SIT:
204 return ZEBRA_LLT_SIT;
205 case ARPHRD_IPDDP:
206 return ZEBRA_LLT_IPDDP;
207 case ARPHRD_IPGRE:
208 return ZEBRA_LLT_IPGRE;
209 case ARPHRD_PIMREG:
210 return ZEBRA_LLT_PIMREG;
211 case ARPHRD_HIPPI:
212 return ZEBRA_LLT_HIPPI;
213 case ARPHRD_ECONET:
214 return ZEBRA_LLT_ECONET;
215 case ARPHRD_IRDA:
216 return ZEBRA_LLT_IRDA;
217 case ARPHRD_FCPP:
218 return ZEBRA_LLT_FCPP;
219 case ARPHRD_FCAL:
220 return ZEBRA_LLT_FCAL;
221 case ARPHRD_FCPL:
222 return ZEBRA_LLT_FCPL;
223 case ARPHRD_FCFABRIC:
224 return ZEBRA_LLT_FCFABRIC;
225 case ARPHRD_IEEE802_TR:
226 return ZEBRA_LLT_IEEE802_TR;
227 case ARPHRD_IEEE80211:
228 return ZEBRA_LLT_IEEE80211;
4268e09e 229#ifdef ARPHRD_IEEE802154
d62a17ae 230 case ARPHRD_IEEE802154:
231 return ZEBRA_LLT_IEEE802154;
4268e09e 232#endif
1fdc9eae 233#ifdef ARPHRD_IP6GRE
d62a17ae 234 case ARPHRD_IP6GRE:
235 return ZEBRA_LLT_IP6GRE;
1fdc9eae 236#endif
237#ifdef ARPHRD_IEEE802154_PHY
d62a17ae 238 case ARPHRD_IEEE802154_PHY:
239 return ZEBRA_LLT_IEEE802154_PHY;
1fdc9eae 240#endif
241
d62a17ae 242 default:
243 return ZEBRA_LLT_UNKNOWN;
244 }
1fdc9eae 245}
246
b9368db9
DD		 247static void netlink_determine_zebra_iftype(const char *kind,
248 zebra_iftype_t *zif_type)
6675513d 249{
d62a17ae 250 *zif_type = ZEBRA_IF_OTHER;
251
252 if (!kind)
253 return;
254
255 if (strcmp(kind, "vrf") == 0)
256 *zif_type = ZEBRA_IF_VRF;
257 else if (strcmp(kind, "bridge") == 0)
258 *zif_type = ZEBRA_IF_BRIDGE;
259 else if (strcmp(kind, "vlan") == 0)
260 *zif_type = ZEBRA_IF_VLAN;
261 else if (strcmp(kind, "vxlan") == 0)
262 *zif_type = ZEBRA_IF_VXLAN;
1a98c087
MK		 263 else if (strcmp(kind, "macvlan") == 0)
264 *zif_type = ZEBRA_IF_MACVLAN;
0e4864ea
PG		 265 else if (strcmp(kind, "veth") == 0)
266 *zif_type = ZEBRA_IF_VETH;
b9368db9
DD		 267 else if (strcmp(kind, "bond") == 0)
268 *zif_type = ZEBRA_IF_BOND;
269 else if (strcmp(kind, "bond_slave") == 0)
270 *zif_type = ZEBRA_IF_BOND_SLAVE;
6675513d 271}
52d8f0d8 272
d62a17ae 273#define parse_rtattr_nested(tb, max, rta) \
274 netlink_parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta))
1fdc9eae 275
d62a17ae 276static void netlink_vrf_change(struct nlmsghdr *h, struct rtattr *tb,
277 const char *name)
1fdc9eae 278{
d62a17ae 279 struct ifinfomsg *ifi;
280 struct rtattr *linkinfo[IFLA_INFO_MAX + 1];
281 struct rtattr *attr[IFLA_VRF_MAX + 1];
282 struct vrf *vrf;
283 struct zebra_vrf *zvrf;
d7c0a89a 284 uint32_t nl_table_id;
d62a17ae 285
286 ifi = NLMSG_DATA(h);
287
288 memset(linkinfo, 0, sizeof linkinfo);
289 parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb);
290
291 if (!linkinfo[IFLA_INFO_DATA]) {
292 if (IS_ZEBRA_DEBUG_KERNEL)
293 zlog_debug(
294 "%s: IFLA_INFO_DATA missing from VRF message: %s",
295 __func__, name);
296 return;
297 }
298
299 memset(attr, 0, sizeof attr);
300 parse_rtattr_nested(attr, IFLA_VRF_MAX, linkinfo[IFLA_INFO_DATA]);
301 if (!attr[IFLA_VRF_TABLE]) {
302 if (IS_ZEBRA_DEBUG_KERNEL)
303 zlog_debug(
304 "%s: IFLA_VRF_TABLE missing from VRF message: %s",
305 __func__, name);
306 return;
1fdc9eae 307 }
308
d7c0a89a 309 nl_table_id = *(uint32_t *)RTA_DATA(attr[IFLA_VRF_TABLE]);
d62a17ae 310
311 if (h->nlmsg_type == RTM_NEWLINK) {
312 if (IS_ZEBRA_DEBUG_KERNEL)
313 zlog_debug("RTM_NEWLINK for VRF %s(%u) table %u", name,
314 ifi->ifi_index, nl_table_id);
315
316 /*
317 * vrf_get is implied creation if it does not exist
318 */
319 vrf = vrf_get((vrf_id_t)ifi->ifi_index,
320 name); // It would create vrf
321 if (!vrf) {
450971aa 322 flog_err(EC_LIB_INTERFACE, "VRF %s id %u not created",
1c50c1c0 323 name, ifi->ifi_index);
d62a17ae 324 return;
325 }
326
d62a17ae 327 /*
328 * This is the only place that we get the actual kernel table_id
329 * being used. We need it to set the table_id of the routes
330 * we are passing to the kernel.... And to throw some totally
331 * awesome parties. that too.
593406a1
DS		 332 *
333 * At this point we *must* have a zvrf because the vrf_create
334 * callback creates one. We *must* set the table id
335 * before the vrf_enable because of( at the very least )
336 * static routes being delayed for installation until
337 * during the vrf_enable callbacks.
d62a17ae 338 */
339 zvrf = (struct zebra_vrf *)vrf->info;
340 zvrf->table_id = nl_table_id;
593406a1
DS		 341
342 /* Enable the created VRF. */
343 if (!vrf_enable(vrf)) {
450971aa 344 flog_err(EC_LIB_INTERFACE,
1c50c1c0
QY		 345 "Failed to enable VRF %s id %u", name,
346 ifi->ifi_index);
593406a1
DS		 347 return;
348 }
349
d62a17ae 350 } else // h->nlmsg_type == RTM_DELLINK
351 {
352 if (IS_ZEBRA_DEBUG_KERNEL)
353 zlog_debug("RTM_DELLINK for VRF %s(%u)", name,
354 ifi->ifi_index);
355
356 vrf = vrf_lookup_by_id((vrf_id_t)ifi->ifi_index);
357
358 if (!vrf) {
e914ccbe 359 flog_warn(EC_ZEBRA_VRF_NOT_FOUND, "%s: vrf not found",
9df414fe 360 __func__);
d62a17ae 361 return;
362 }
363
364 vrf_delete(vrf);
365 }
1fdc9eae 366}
367
0268f30e 368static int get_iflink_speed(struct interface *interface)
535fe877 369{
d62a17ae 370 struct ifreq ifdata;
371 struct ethtool_cmd ecmd;
372 int sd;
373 int rc;
0268f30e 374 const char *ifname = interface->name;
d62a17ae 375
376 /* initialize struct */
377 memset(&ifdata, 0, sizeof(ifdata));
378
379 /* set interface name */
0af35d90 380 strlcpy(ifdata.ifr_name, ifname, sizeof(ifdata.ifr_name));
d62a17ae 381
382 /* initialize ethtool interface */
383 memset(&ecmd, 0, sizeof(ecmd));
384 ecmd.cmd = ETHTOOL_GSET; /* ETHTOOL_GLINK */
ba85366a 385 ifdata.ifr_data = (caddr_t)&ecmd;
d62a17ae 386
387 /* use ioctl to get IP address of an interface */
01b9e3fd
DL		 388 frr_elevate_privs(&zserv_privs) {
389 sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP,
390 interface->vrf_id,
391 NULL);
392 if (sd < 0) {
393 if (IS_ZEBRA_DEBUG_KERNEL)
394 zlog_debug("Failure to read interface %s speed: %d %s",
395 ifname, errno, safe_strerror(errno));
396 return 0;
397 }
d62a17ae 398 /* Get the current link state for the interface */
633fc9b1
DL		 399 rc = vrf_ioctl(interface->vrf_id, sd, SIOCETHTOOL,
400 (char *)&ifdata);
01b9e3fd 401 }
d62a17ae 402 if (rc < 0) {
f767cee4 403 if (errno != EOPNOTSUPP && IS_ZEBRA_DEBUG_KERNEL)
bd7d0299
DS		 404 zlog_debug(
405 "IOCTL failure to read interface %s speed: %d %s",
406 ifname, errno, safe_strerror(errno));
d62a17ae 407 ecmd.speed_hi = 0;
408 ecmd.speed = 0;
409 }
410
411 close(sd);
412
413 return (ecmd.speed_hi << 16) | ecmd.speed;
535fe877
DS		 414}
415
dc7b3cae
DS		 416uint32_t kernel_get_speed(struct interface *ifp)
417{
0268f30e 418 return get_iflink_speed(ifp);
dc7b3cae
DS		 419}
420
d62a17ae 421static int netlink_extract_bridge_info(struct rtattr *link_data,
422 struct zebra_l2info_bridge *bridge_info)
6675513d 423{
d62a17ae 424 struct rtattr *attr[IFLA_BR_MAX + 1];
425
426 memset(bridge_info, 0, sizeof(*bridge_info));
427 memset(attr, 0, sizeof attr);
428 parse_rtattr_nested(attr, IFLA_BR_MAX, link_data);
429 if (attr[IFLA_BR_VLAN_FILTERING])
430 bridge_info->vlan_aware =
d7c0a89a 431 *(uint8_t *)RTA_DATA(attr[IFLA_BR_VLAN_FILTERING]);
d62a17ae 432 return 0;
6675513d 433}
434
d62a17ae 435static int netlink_extract_vlan_info(struct rtattr *link_data,
436 struct zebra_l2info_vlan *vlan_info)
6675513d 437{
d62a17ae 438 struct rtattr *attr[IFLA_VLAN_MAX + 1];
439 vlanid_t vid_in_msg;
440
441 memset(vlan_info, 0, sizeof(*vlan_info));
442 memset(attr, 0, sizeof attr);
443 parse_rtattr_nested(attr, IFLA_VLAN_MAX, link_data);
444 if (!attr[IFLA_VLAN_ID]) {
445 if (IS_ZEBRA_DEBUG_KERNEL)
446 zlog_debug("IFLA_VLAN_ID missing from VLAN IF message");
447 return -1;
448 }
449
450 vid_in_msg = *(vlanid_t *)RTA_DATA(attr[IFLA_VLAN_ID]);
451 vlan_info->vid = vid_in_msg;
452 return 0;
6675513d 453}
454
d62a17ae 455static int netlink_extract_vxlan_info(struct rtattr *link_data,
456 struct zebra_l2info_vxlan *vxl_info)
6675513d 457{
d62a17ae 458 struct rtattr *attr[IFLA_VXLAN_MAX + 1];
459 vni_t vni_in_msg;
460 struct in_addr vtep_ip_in_msg;
461
462 memset(vxl_info, 0, sizeof(*vxl_info));
463 memset(attr, 0, sizeof attr);
464 parse_rtattr_nested(attr, IFLA_VXLAN_MAX, link_data);
465 if (!attr[IFLA_VXLAN_ID]) {
466 if (IS_ZEBRA_DEBUG_KERNEL)
467 zlog_debug(
468 "IFLA_VXLAN_ID missing from VXLAN IF message");
469 return -1;
470 }
471
472 vni_in_msg = *(vni_t *)RTA_DATA(attr[IFLA_VXLAN_ID]);
473 vxl_info->vni = vni_in_msg;
474 if (!attr[IFLA_VXLAN_LOCAL]) {
475 if (IS_ZEBRA_DEBUG_KERNEL)
476 zlog_debug(
477 "IFLA_VXLAN_LOCAL missing from VXLAN IF message");
478 } else {
479 vtep_ip_in_msg =
480 *(struct in_addr *)RTA_DATA(attr[IFLA_VXLAN_LOCAL]);
481 vxl_info->vtep_ip = vtep_ip_in_msg;
482 }
483
484 return 0;
6675513d 485}
486
487/*
488 * Extract and save L2 params (of interest) for an interface. When a
489 * bridge interface is added or updated, take further actions to map
490 * its members. Likewise, for VxLAN interface.
491 */
d62a17ae 492static void netlink_interface_update_l2info(struct interface *ifp,
493 struct rtattr *link_data, int add)
6675513d 494{
d62a17ae 495 if (!link_data)
496 return;
497
498 if (IS_ZEBRA_IF_BRIDGE(ifp)) {
499 struct zebra_l2info_bridge bridge_info;
500
501 netlink_extract_bridge_info(link_data, &bridge_info);
502 zebra_l2_bridge_add_update(ifp, &bridge_info, add);
503 } else if (IS_ZEBRA_IF_VLAN(ifp)) {
504 struct zebra_l2info_vlan vlan_info;
505
506 netlink_extract_vlan_info(link_data, &vlan_info);
507 zebra_l2_vlanif_update(ifp, &vlan_info);
508 } else if (IS_ZEBRA_IF_VXLAN(ifp)) {
509 struct zebra_l2info_vxlan vxlan_info;
510
511 netlink_extract_vxlan_info(link_data, &vxlan_info);
512 zebra_l2_vxlanif_add_update(ifp, &vxlan_info, add);
513 }
6675513d 514}
515
d62a17ae 516static int netlink_bridge_interface(struct nlmsghdr *h, int len, ns_id_t ns_id,
517 int startup)
6675513d 518{
d62a17ae 519 char *name = NULL;
520 struct ifinfomsg *ifi;
521 struct rtattr *tb[IFLA_MAX + 1];
522 struct interface *ifp;
523 struct rtattr *aftb[IFLA_BRIDGE_MAX + 1];
524 struct {
d7c0a89a
QY		 525 uint16_t flags;
526 uint16_t vid;
d62a17ae 527 } * vinfo;
528 vlanid_t access_vlan;
529
530 /* Fetch name and ifindex */
531 ifi = NLMSG_DATA(h);
532 memset(tb, 0, sizeof tb);
533 netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
534
535 if (tb[IFLA_IFNAME] == NULL)
536 return -1;
537 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
538
539 /* The interface should already be known, if not discard. */
540 ifp = if_lookup_by_index_per_ns(zebra_ns_lookup(ns_id), ifi->ifi_index);
541 if (!ifp) {
9df414fe
QY		 542 zlog_debug("Cannot find bridge IF %s(%u)", name,
543 ifi->ifi_index);
d62a17ae 544 return 0;
545 }
546 if (!IS_ZEBRA_IF_VXLAN(ifp))
547 return 0;
548
549 /* We are only interested in the access VLAN i.e., AF_SPEC */
550 if (!tb[IFLA_AF_SPEC])
551 return 0;
552
553 /* There is a 1-to-1 mapping of VLAN to VxLAN - hence
554 * only 1 access VLAN is accepted.
555 */
556 memset(aftb, 0, sizeof aftb);
557 parse_rtattr_nested(aftb, IFLA_BRIDGE_MAX, tb[IFLA_AF_SPEC]);
558 if (!aftb[IFLA_BRIDGE_VLAN_INFO])
559 return 0;
560
561 vinfo = RTA_DATA(aftb[IFLA_BRIDGE_VLAN_INFO]);
562 if (!(vinfo->flags & BRIDGE_VLAN_INFO_PVID))
563 return 0;
564
565 access_vlan = (vlanid_t)vinfo->vid;
566 if (IS_ZEBRA_DEBUG_KERNEL)
567 zlog_debug("Access VLAN %u for VxLAN IF %s(%u)", access_vlan,
568 name, ifi->ifi_index);
569 zebra_l2_vxlanif_update_access_vlan(ifp, access_vlan);
570 return 0;
6675513d 571}
572
2414abd3
DS		 573/*
574 * Called from interface_lookup_netlink(). This function is only used
575 * during bootstrap.
576 */
577static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1fdc9eae 578{
d62a17ae 579 int len;
580 struct ifinfomsg *ifi;
581 struct rtattr *tb[IFLA_MAX + 1];
582 struct rtattr *linkinfo[IFLA_MAX + 1];
583 struct interface *ifp;
584 char *name = NULL;
585 char *kind = NULL;
48884c6b 586 char *desc = NULL;
d62a17ae 587 char *slave_kind = NULL;
588 struct zebra_ns *zns;
589 vrf_id_t vrf_id = VRF_DEFAULT;
590 zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
591 zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
592 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
593 ifindex_t link_ifindex = IFINDEX_INTERNAL;
b9368db9 594 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
520ebf72 595 struct zebra_if *zif;
d62a17ae 596
597 zns = zebra_ns_lookup(ns_id);
598 ifi = NLMSG_DATA(h);
599
600 if (h->nlmsg_type != RTM_NEWLINK)
601 return 0;
602
603 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
9bdf8618
DS		 604 if (len < 0) {
605 zlog_err("%s: Message received from netlink is of a broken size: %d %zu",
606 __PRETTY_FUNCTION__,
607 h->nlmsg_len,
608 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
d62a17ae 609 return -1;
9bdf8618 610 }
d62a17ae 611
612 /* We are interested in some AF_BRIDGE notifications. */
613 if (ifi->ifi_family == AF_BRIDGE)
614 return netlink_bridge_interface(h, len, ns_id, startup);
615
616 /* Looking up interface name. */
617 memset(tb, 0, sizeof tb);
618 memset(linkinfo, 0, sizeof linkinfo);
619 netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
1fdc9eae 620
d62a17ae 621 /* check for wireless messages to ignore */
622 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
623 if (IS_ZEBRA_DEBUG_KERNEL)
624 zlog_debug("%s: ignoring IFLA_WIRELESS message",
625 __func__);
626 return 0;
627 }
1fdc9eae 628
d62a17ae 629 if (tb[IFLA_IFNAME] == NULL)
630 return -1;
631 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
1fdc9eae 632
48884c6b
DS		 633 if (tb[IFLA_IFALIAS])
634 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
635
d62a17ae 636 if (tb[IFLA_LINKINFO]) {
637 parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
1fdc9eae 638
d62a17ae 639 if (linkinfo[IFLA_INFO_KIND])
640 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
1fdc9eae 641
d62a17ae 642 if (linkinfo[IFLA_INFO_SLAVE_KIND])
643 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
1fdc9eae 644
b9368db9
DD		 645 if ((slave_kind != NULL) && strcmp(slave_kind, "bond") == 0)
646 netlink_determine_zebra_iftype("bond_slave", &zif_type);
647 else
648 netlink_determine_zebra_iftype(kind, &zif_type);
d62a17ae 649 }
650
651 /* If VRF, create the VRF structure itself. */
78dd30b2 652 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
d62a17ae 653 netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
654 vrf_id = (vrf_id_t)ifi->ifi_index;
655 }
656
657 if (tb[IFLA_MASTER]) {
78dd30b2
PG		 658 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
659 && !vrf_is_backend_netns()) {
d62a17ae 660 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
d7c0a89a 661 vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
d62a17ae 662 } else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
663 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
664 bridge_ifindex =
665 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
b9368db9
DD		 666 } else if (slave_kind && (strcmp(slave_kind, "bond") == 0)) {
667 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
668 bond_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
d62a17ae 669 } else
670 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
671 }
78dd30b2
PG		 672 if (vrf_is_backend_netns())
673 vrf_id = (vrf_id_t)ns_id;
d62a17ae 674
675 /* If linking to another interface, note it. */
676 if (tb[IFLA_LINK])
677 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
678
679 /* Add interface. */
8f90d89b 680 ifp = if_get_by_name(name, vrf_id);
d62a17ae 681 set_ifindex(ifp, ifi->ifi_index, zns);
682 ifp->flags = ifi->ifi_flags & 0x0000fffff;
d62a17ae 683 ifp->mtu6 = ifp->mtu = *(uint32_t *)RTA_DATA(tb[IFLA_MTU]);
684 ifp->metric = 0;
0268f30e 685 ifp->speed = get_iflink_speed(ifp);
d62a17ae 686 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
687
48884c6b
DS		 688 if (desc)
689 ifp->desc = XSTRDUP(MTYPE_TMP, desc);
690
d62a17ae 691 /* Set zebra interface type */
692 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
b0fa6f6a
CS		 693 if (IS_ZEBRA_IF_VRF(ifp))
694 SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
d62a17ae 695
98efddf1
DS		 696 /*
697 * Just set the @link/lower-device ifindex. During nldump interfaces are
520ebf72
AK		 698 * not ordered in any fashion so we may end up getting upper devices
699 * before lower devices. We will setup the real linkage once the dump
98efddf1
DS		 700 * is complete.
701 */
520ebf72
AK		 702 zif = (struct zebra_if *)ifp->info;
703 zif->link_ifindex = link_ifindex;
d62a17ae 704
705 /* Hardware type and address. */
706 ifp->ll_type = netlink_to_zebra_link_type(ifi->ifi_type);
707 netlink_interface_update_hw_addr(tb, ifp);
708
709 if_add_update(ifp);
710
711 /* Extract and save L2 interface information, take additional actions.
712 */
713 netlink_interface_update_l2info(ifp, linkinfo[IFLA_INFO_DATA], 1);
714 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
715 zebra_l2if_update_bridge_slave(ifp, bridge_ifindex);
b9368db9
DD		 716 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
717 zebra_l2if_update_bond_slave(ifp, bond_ifindex);
d62a17ae 718
719 return 0;
1fdc9eae 720}
721
289602d7 722/* Request for specific interface or address information from the kernel */
85a75f1e
MS		 723static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
724 int type, uint32_t filter_mask)
289602d7 725{
d62a17ae 726 struct {
727 struct nlmsghdr n;
728 struct ifinfomsg ifm;
729 char buf[256];
730 } req;
731
732 /* Form the request, specifying filter (rtattr) if needed. */
733 memset(&req, 0, sizeof(req));
734 req.n.nlmsg_type = type;
718f9b0f 735 req.n.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
d62a17ae 736 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
737 req.ifm.ifi_family = family;
738
739 /* Include filter, if specified. */
740 if (filter_mask)
741 addattr32(&req.n, sizeof(req), IFLA_EXT_MASK, filter_mask);
742
85a75f1e 743 return netlink_request(netlink_cmd, &req.n);
289602d7 744}
745
1fdc9eae 746/* Interface lookup by netlink socket. */
d62a17ae 747int interface_lookup_netlink(struct zebra_ns *zns)
1fdc9eae 748{
d62a17ae 749 int ret;
85a75f1e
MS		 750 struct zebra_dplane_info dp_info;
751 struct nlsock *netlink_cmd = &zns->netlink_cmd;
752
753 /* Capture key info from ns struct */
754 zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
d62a17ae 755
756 /* Get interface information. */
85a75f1e 757 ret = netlink_request_intf_addr(netlink_cmd, AF_PACKET, RTM_GETLINK, 0);
d62a17ae 758 if (ret < 0)
759 return ret;
85a75f1e 760 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
d62a17ae 761 1);
762 if (ret < 0)
763 return ret;
764
765 /* Get interface information - for bridge interfaces. */
85a75f1e 766 ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
d62a17ae 767 RTEXT_FILTER_BRVLAN);
768 if (ret < 0)
769 return ret;
85a75f1e 770 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
d62a17ae 771 0);
772 if (ret < 0)
773 return ret;
774
775 /* Get interface information - for bridge interfaces. */
85a75f1e 776 ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
d62a17ae 777 RTEXT_FILTER_BRVLAN);
778 if (ret < 0)
779 return ret;
85a75f1e 780 ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
d62a17ae 781 0);
782 if (ret < 0)
783 return ret;
784
520ebf72
AK		 785 /* fixup linkages */
786 zebra_if_update_all_links();
787
d62a17ae 788 /* Get IPv4 address of the interfaces. */
85a75f1e 789 ret = netlink_request_intf_addr(netlink_cmd, AF_INET, RTM_GETADDR, 0);
d62a17ae 790 if (ret < 0)
791 return ret;
85a75f1e 792 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
d62a17ae 793 0, 1);
794 if (ret < 0)
795 return ret;
796
797 /* Get IPv6 address of the interfaces. */
85a75f1e 798 ret = netlink_request_intf_addr(netlink_cmd, AF_INET6, RTM_GETADDR, 0);
d62a17ae 799 if (ret < 0)
800 return ret;
85a75f1e 801 ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
d62a17ae 802 0, 1);
803 if (ret < 0)
804 return ret;
805
806 return 0;
1fdc9eae 807}
808
e0ae31b8
DS		 809int kernel_interface_set_master(struct interface *master,
810 struct interface *slave)
811{
812 struct zebra_ns *zns = zebra_ns_lookup(NS_DEFAULT);
813
814 struct {
815 struct nlmsghdr n;
816 struct ifinfomsg ifa;
817 char buf[NL_PKT_BUF_SIZE];
818 } req;
819
820 memset(&req, 0, sizeof req);
821
822 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
823 req.n.nlmsg_flags = NLM_F_REQUEST;
824 req.n.nlmsg_type = RTM_SETLINK;
825 req.n.nlmsg_pid = zns->netlink_cmd.snl.nl_pid;
826
827 req.ifa.ifi_index = slave->ifindex;
828
829 addattr_l(&req.n, sizeof req, IFLA_MASTER, &master->ifindex, 4);
830 addattr_l(&req.n, sizeof req, IFLA_LINK, &slave->ifindex, 4);
831
832 return netlink_talk(netlink_talk_filter, &req.n, &zns->netlink_cmd, zns,
833 0);
834}
835
1fdc9eae 836/* Interface address modification. */
d62a17ae 837static int netlink_address(int cmd, int family, struct interface *ifp,
838 struct connected *ifc)
1fdc9eae 839{
d62a17ae 840 int bytelen;
841 struct prefix *p;
1fdc9eae 842
d62a17ae 843 struct {
844 struct nlmsghdr n;
845 struct ifaddrmsg ifa;
846 char buf[NL_PKT_BUF_SIZE];
847 } req;
1fdc9eae 848
fe533c56 849 struct zebra_ns *zns;
1fdc9eae 850
fe533c56
PG		 851 if (vrf_is_backend_netns())
852 zns = zebra_ns_lookup((ns_id_t)ifp->vrf_id);
853 else
854 zns = zebra_ns_lookup(NS_DEFAULT);
d62a17ae 855 p = ifc->address;
856 memset(&req, 0, sizeof req - NL_PKT_BUF_SIZE);
1fdc9eae 857
d62a17ae 858 bytelen = (family == AF_INET ? 4 : 16);
1fdc9eae 859
d62a17ae 860 req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
861 req.n.nlmsg_flags = NLM_F_REQUEST;
862 req.n.nlmsg_type = cmd;
863 req.n.nlmsg_pid = zns->netlink_cmd.snl.nl_pid;
a55ba23f 864
d62a17ae 865 req.ifa.ifa_family = family;
1fdc9eae 866
d62a17ae 867 req.ifa.ifa_index = ifp->ifindex;
1fdc9eae 868
d62a17ae 869 addattr_l(&req.n, sizeof req, IFA_LOCAL, &p->u.prefix, bytelen);
1fdc9eae 870
e8d19a05
DL		 871 if (family == AF_INET) {
872 if (CONNECTED_PEER(ifc)) {
873 p = ifc->destination;
60466a63
QY		 874 addattr_l(&req.n, sizeof req, IFA_ADDRESS, &p->u.prefix,
875 bytelen);
e8d19a05 876 } else if (cmd == RTM_NEWADDR && ifc->destination) {
d62a17ae 877 p = ifc->destination;
878 addattr_l(&req.n, sizeof req, IFA_BROADCAST,
879 &p->u.prefix, bytelen);
880 }
881 }
1fdc9eae 882
e8d19a05
DL		 883 /* p is now either ifc->address or ifc->destination */
884 req.ifa.ifa_prefixlen = p->prefixlen;
885
d62a17ae 886 if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_SECONDARY))
887 SET_FLAG(req.ifa.ifa_flags, IFA_F_SECONDARY);
1fdc9eae 888
d62a17ae 889 if (ifc->label)
890 addattr_l(&req.n, sizeof req, IFA_LABEL, ifc->label,
891 strlen(ifc->label) + 1);
1fdc9eae 892
d62a17ae 893 return netlink_talk(netlink_talk_filter, &req.n, &zns->netlink_cmd, zns,
894 0);
1fdc9eae 895}
896
d62a17ae 897int kernel_address_add_ipv4(struct interface *ifp, struct connected *ifc)
1fdc9eae 898{
d62a17ae 899 return netlink_address(RTM_NEWADDR, AF_INET, ifp, ifc);
1fdc9eae 900}
901
d62a17ae 902int kernel_address_delete_ipv4(struct interface *ifp, struct connected *ifc)
1fdc9eae 903{
d62a17ae 904 return netlink_address(RTM_DELADDR, AF_INET, ifp, ifc);
1fdc9eae 905}
906
996c9314 907int kernel_address_add_ipv6(struct interface *ifp, struct connected *ifc)
e86b71f1 908{
996c9314 909 return netlink_address(RTM_NEWADDR, AF_INET6, ifp, ifc);
e86b71f1
PG		 910}
911
996c9314 912int kernel_address_delete_ipv6(struct interface *ifp, struct connected *ifc)
e86b71f1 913{
996c9314 914 return netlink_address(RTM_DELADDR, AF_INET6, ifp, ifc);
e86b71f1
PG		 915}
916
2414abd3 917int netlink_interface_addr(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1fdc9eae 918{
d62a17ae 919 int len;
920 struct ifaddrmsg *ifa;
921 struct rtattr *tb[IFA_MAX + 1];
922 struct interface *ifp;
923 void *addr;
924 void *broad;
d7c0a89a 925 uint8_t flags = 0;
d62a17ae 926 char *label = NULL;
927 struct zebra_ns *zns;
cde1af84 928 uint32_t metric = METRIC_MAX;
9254efed 929 uint32_t kernel_flags = 0;
d62a17ae 930
931 zns = zebra_ns_lookup(ns_id);
932 ifa = NLMSG_DATA(h);
933
8a1b681c 934 if (ifa->ifa_family != AF_INET && ifa->ifa_family != AF_INET6) {
9df414fe 935 flog_warn(
e914ccbe 936 EC_ZEBRA_UNKNOWN_FAMILY,
87b5d1b0
DS		 937 "Invalid address family: %u received from kernel interface addr change: %s",
938 ifa->ifa_family, nl_msg_type_to_str(h->nlmsg_type));
d62a17ae 939 return 0;
8a1b681c 940 }
d62a17ae 941
942 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
943 return 0;
944
945 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
9bdf8618
DS		 946 if (len < 0) {
947 zlog_err("%s: Message received from netlink is of a broken size: %d %zu",
948 __PRETTY_FUNCTION__,
949 h->nlmsg_len,
950 (size_t)NLMSG_LENGTH(sizeof(struct ifaddrmsg)));
d62a17ae 951 return -1;
9bdf8618 952 }
d62a17ae 953
954 memset(tb, 0, sizeof tb);
955 netlink_parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
956
957 ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
958 if (ifp == NULL) {
af4c2728 959 flog_err(
450971aa 960 EC_LIB_INTERFACE,
d62a17ae 961 "netlink_interface_addr can't find interface by index %d",
962 ifa->ifa_index);
963 return -1;
964 }
965
9254efed
DS		 966 /* Flags passed through */
967 if (tb[IFA_FLAGS])
968 kernel_flags = *(int *)RTA_DATA(tb[IFA_FLAGS]);
969 else
970 kernel_flags = ifa->ifa_flags;
971
d62a17ae 972 if (IS_ZEBRA_DEBUG_KERNEL) /* remove this line to see initial ifcfg */
973 {
974 char buf[BUFSIZ];
975 zlog_debug("netlink_interface_addr %s %s flags 0x%x:",
976 nl_msg_type_to_str(h->nlmsg_type), ifp->name,
9254efed 977 kernel_flags);
d62a17ae 978 if (tb[IFA_LOCAL])
979 zlog_debug(" IFA_LOCAL %s/%d",
980 inet_ntop(ifa->ifa_family,
981 RTA_DATA(tb[IFA_LOCAL]), buf,
982 BUFSIZ),
983 ifa->ifa_prefixlen);
984 if (tb[IFA_ADDRESS])
985 zlog_debug(" IFA_ADDRESS %s/%d",
986 inet_ntop(ifa->ifa_family,
987 RTA_DATA(tb[IFA_ADDRESS]), buf,
988 BUFSIZ),
989 ifa->ifa_prefixlen);
990 if (tb[IFA_BROADCAST])
991 zlog_debug(" IFA_BROADCAST %s/%d",
992 inet_ntop(ifa->ifa_family,
993 RTA_DATA(tb[IFA_BROADCAST]), buf,
994 BUFSIZ),
995 ifa->ifa_prefixlen);
996 if (tb[IFA_LABEL] && strcmp(ifp->name, RTA_DATA(tb[IFA_LABEL])))
997 zlog_debug(" IFA_LABEL %s",
998 (char *)RTA_DATA(tb[IFA_LABEL]));
999
1000 if (tb[IFA_CACHEINFO]) {
1001 struct ifa_cacheinfo *ci = RTA_DATA(tb[IFA_CACHEINFO]);
1002 zlog_debug(" IFA_CACHEINFO pref %d, valid %d",
1003 ci->ifa_prefered, ci->ifa_valid);
1004 }
1005 }
1006
1007 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
1008 if (tb[IFA_LOCAL] == NULL)
1009 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
1010 if (tb[IFA_ADDRESS] == NULL)
1011 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
1012
1013 /* local interface address */
1014 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
1015
1016 /* is there a peer address? */
1017 if (tb[IFA_ADDRESS]
1018 && memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]),
1019 RTA_PAYLOAD(tb[IFA_ADDRESS]))) {
1020 broad = RTA_DATA(tb[IFA_ADDRESS]);
1021 SET_FLAG(flags, ZEBRA_IFA_PEER);
1022 } else
1023 /* seeking a broadcast address */
1024 broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST])
1025 : NULL);
1026
1027 /* addr is primary key, SOL if we don't have one */
1028 if (addr == NULL) {
1029 zlog_debug("%s: NULL address", __func__);
1030 return -1;
1031 }
1032
1033 /* Flags. */
9254efed 1034 if (kernel_flags & IFA_F_SECONDARY)
d62a17ae 1035 SET_FLAG(flags, ZEBRA_IFA_SECONDARY);
1036
1037 /* Label */
1038 if (tb[IFA_LABEL])
1039 label = (char *)RTA_DATA(tb[IFA_LABEL]);
1040
2e1cc436 1041 if (label && strcmp(ifp->name, label) == 0)
d62a17ae 1042 label = NULL;
1043
cde1af84
AK		 1044 if (tb[IFA_RT_PRIORITY])
1045 metric = *(uint32_t *)RTA_DATA(tb[IFA_RT_PRIORITY]);
1046
d62a17ae 1047 /* Register interface address to the interface. */
1048 if (ifa->ifa_family == AF_INET) {
930571d2 1049 if (ifa->ifa_prefixlen > IPV4_MAX_BITLEN) {
e17d9b2d 1050 zlog_err(
87b5d1b0
DS		 1051 "Invalid prefix length: %u received from kernel interface addr change: %s",
1052 ifa->ifa_prefixlen,
1053 nl_msg_type_to_str(h->nlmsg_type));
e17d9b2d 1054 return -1;
930571d2 1055 }
d62a17ae 1056 if (h->nlmsg_type == RTM_NEWADDR)
1057 connected_add_ipv4(ifp, flags, (struct in_addr *)addr,
1058 ifa->ifa_prefixlen,
cde1af84
AK		 1059 (struct in_addr *)broad, label,
1060 metric);
d62a17ae 1061 else
1062 connected_delete_ipv4(
1063 ifp, flags, (struct in_addr *)addr,
1064 ifa->ifa_prefixlen, (struct in_addr *)broad);
1065 }
1066 if (ifa->ifa_family == AF_INET6) {
930571d2 1067 if (ifa->ifa_prefixlen > IPV6_MAX_BITLEN) {
e17d9b2d 1068 zlog_err(
87b5d1b0
DS		 1069 "Invalid prefix length: %u received from kernel interface addr change: %s",
1070 ifa->ifa_prefixlen,
1071 nl_msg_type_to_str(h->nlmsg_type));
e17d9b2d 1072 return -1;
930571d2 1073 }
d62a17ae 1074 if (h->nlmsg_type == RTM_NEWADDR) {
1075 /* Only consider valid addresses; we'll not get a
1076 * notification from
1077 * the kernel till IPv6 DAD has completed, but at init
1078 * time, Quagga
1079 * does query for and will receive all addresses.
1080 */
9254efed 1081 if (!(kernel_flags
d62a17ae 1082 & (IFA_F_DADFAILED | IFA_F_TENTATIVE)))
60466a63
QY		 1083 connected_add_ipv6(ifp, flags,
1084 (struct in6_addr *)addr,
60c0687a 1085 (struct in6_addr *)broad,
cde1af84
AK		 1086 ifa->ifa_prefixlen, label,
1087 metric);
d62a17ae 1088 } else
1089 connected_delete_ipv6(ifp, (struct in6_addr *)addr,
60c0687a 1090 (struct in6_addr *)broad,
608105a7 1091 ifa->ifa_prefixlen);
d62a17ae 1092 }
1093
1094 return 0;
1fdc9eae 1095}
1096
2414abd3 1097int netlink_link_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
1fdc9eae 1098{
d62a17ae 1099 int len;
1100 struct ifinfomsg *ifi;
1101 struct rtattr *tb[IFLA_MAX + 1];
1102 struct rtattr *linkinfo[IFLA_MAX + 1];
1103 struct interface *ifp;
1104 char *name = NULL;
1105 char *kind = NULL;
48884c6b 1106 char *desc = NULL;
d62a17ae 1107 char *slave_kind = NULL;
1108 struct zebra_ns *zns;
1109 vrf_id_t vrf_id = VRF_DEFAULT;
1110 zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
1111 zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
1112 ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
b9368db9 1113 ifindex_t bond_ifindex = IFINDEX_INTERNAL;
d62a17ae 1114 ifindex_t link_ifindex = IFINDEX_INTERNAL;
97c4e1d0 1115 uint8_t old_hw_addr[INTERFACE_HWADDR_MAX];
d62a17ae 1116
1117
1118 zns = zebra_ns_lookup(ns_id);
1119 ifi = NLMSG_DATA(h);
1120
fe533c56 1121 /* assume if not default zns, then new VRF */
d62a17ae 1122 if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)) {
1123 /* If this is not link add/delete message so print warning. */
87b5d1b0
DS		 1124 zlog_debug("netlink_link_change: wrong kernel message %s",
1125 nl_msg_type_to_str(h->nlmsg_type));
d62a17ae 1126 return 0;
1127 }
1128
8a1b681c
SW		 1129 if (!(ifi->ifi_family == AF_UNSPEC || ifi->ifi_family == AF_BRIDGE
1130 || ifi->ifi_family == AF_INET6)) {
9df414fe 1131 flog_warn(
e914ccbe 1132 EC_ZEBRA_UNKNOWN_FAMILY,
87b5d1b0
DS		 1133 "Invalid address family: %u received from kernel link change: %s",
1134 ifi->ifi_family, nl_msg_type_to_str(h->nlmsg_type));
8a1b681c
SW		 1135 return 0;
1136 }
1137
d62a17ae 1138 len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
9bdf8618
DS		 1139 if (len < 0) {
1140 zlog_err("%s: Message received from netlink is of a broken size %d %zu",
1141 __PRETTY_FUNCTION__, h->nlmsg_len,
1142 (size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
d62a17ae 1143 return -1;
9bdf8618 1144 }
d62a17ae 1145
1146 /* We are interested in some AF_BRIDGE notifications. */
1147 if (ifi->ifi_family == AF_BRIDGE)
1148 return netlink_bridge_interface(h, len, ns_id, startup);
1149
1150 /* Looking up interface name. */
1151 memset(tb, 0, sizeof tb);
1152 memset(linkinfo, 0, sizeof linkinfo);
1153 netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
1fdc9eae 1154
d62a17ae 1155 /* check for wireless messages to ignore */
1156 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
1157 if (IS_ZEBRA_DEBUG_KERNEL)
1158 zlog_debug("%s: ignoring IFLA_WIRELESS message",
1159 __func__);
1160 return 0;
1161 }
1fdc9eae 1162
d62a17ae 1163 if (tb[IFLA_IFNAME] == NULL)
1164 return -1;
1165 name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
1fdc9eae 1166
d62a17ae 1167 if (tb[IFLA_LINKINFO]) {
1168 parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
1fdc9eae 1169
d62a17ae 1170 if (linkinfo[IFLA_INFO_KIND])
1171 kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
1fdc9eae 1172
d62a17ae 1173 if (linkinfo[IFLA_INFO_SLAVE_KIND])
1174 slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
1fdc9eae 1175
d62a17ae 1176 netlink_determine_zebra_iftype(kind, &zif_type);
1177 }
6675513d 1178
d62a17ae 1179 /* If linking to another interface, note it. */
1180 if (tb[IFLA_LINK])
1181 link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
1fdc9eae 1182
48884c6b
DS		 1183 if (tb[IFLA_IFALIAS]) {
1184 desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
1185 }
1186
d62a17ae 1187 /* If VRF, create or update the VRF structure itself. */
78dd30b2 1188 if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
d62a17ae 1189 netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
1190 vrf_id = (vrf_id_t)ifi->ifi_index;
1191 }
1fdc9eae 1192
d62a17ae 1193 /* See if interface is present. */
1194 ifp = if_lookup_by_name_per_ns(zns, name);
1195
48884c6b 1196 if (ifp) {
0a22ddfb 1197 XFREE(MTYPE_TMP, ifp->desc);
48884c6b
DS		 1198 if (desc)
1199 ifp->desc = XSTRDUP(MTYPE_TMP, desc);
1200 }
1201
d62a17ae 1202 if (h->nlmsg_type == RTM_NEWLINK) {
1203 if (tb[IFLA_MASTER]) {
78dd30b2
PG		 1204 if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
1205 && !vrf_is_backend_netns()) {
d62a17ae 1206 zif_slave_type = ZEBRA_IF_SLAVE_VRF;
d7c0a89a 1207 vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
d62a17ae 1208 } else if (slave_kind
1209 && (strcmp(slave_kind, "bridge") == 0)) {
1210 zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
1211 bridge_ifindex =
1212 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
b9368db9
DD		 1213 } else if (slave_kind
1214 && (strcmp(slave_kind, "bond") == 0)) {
1215 zif_slave_type = ZEBRA_IF_SLAVE_BOND;
1216 bond_ifindex =
1217 *(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
d62a17ae 1218 } else
1219 zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
1220 }
fe533c56
PG		 1221 if (vrf_is_backend_netns())
1222 vrf_id = (vrf_id_t)ns_id;
d62a17ae 1223 if (ifp == NULL
1224 || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
1225 /* Add interface notification from kernel */
1226 if (IS_ZEBRA_DEBUG_KERNEL)
1227 zlog_debug(
1228 "RTM_NEWLINK ADD for %s(%u) vrf_id %u type %d "
1229 "sl_type %d master %u flags 0x%x",
1230 name, ifi->ifi_index, vrf_id, zif_type,
1231 zif_slave_type, bridge_ifindex,
1232 ifi->ifi_flags);
1233
1234 if (ifp == NULL) {
1235 /* unknown interface */
8f90d89b 1236 ifp = if_get_by_name(name, vrf_id);
d62a17ae 1237 } else {
1238 /* pre-configured interface, learnt now */
1239 if (ifp->vrf_id != vrf_id)
1240 if_update_to_new_vrf(ifp, vrf_id);
1241 }
1242
1243 /* Update interface information. */
1244 set_ifindex(ifp, ifi->ifi_index, zns);
1245 ifp->flags = ifi->ifi_flags & 0x0000fffff;
d23b983b 1246 if (!tb[IFLA_MTU]) {
9df414fe 1247 zlog_debug(
d23b983b
SW		 1248 "RTM_NEWLINK for interface %s(%u) without MTU set",
1249 name, ifi->ifi_index);
1250 return 0;
1251 }
d62a17ae 1252 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
1253 ifp->metric = 0;
1254 ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
1255
1256 /* Set interface type */
1257 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
b0fa6f6a
CS		 1258 if (IS_ZEBRA_IF_VRF(ifp))
1259 SET_FLAG(ifp->status,
1260 ZEBRA_INTERFACE_VRF_LOOPBACK);
d62a17ae 1261
1262 /* Update link. */
680c278f 1263 zebra_if_update_link(ifp, link_ifindex, ns_id);
d62a17ae 1264
1265 netlink_interface_update_hw_addr(tb, ifp);
1266
1267 /* Inform clients, install any configured addresses. */
1268 if_add_update(ifp);
1269
1270 /* Extract and save L2 interface information, take
1271 * additional actions. */
1272 netlink_interface_update_l2info(
1273 ifp, linkinfo[IFLA_INFO_DATA], 1);
1274 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
1275 zebra_l2if_update_bridge_slave(ifp,
1276 bridge_ifindex);
b9368db9
DD		 1277 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp))
1278 zebra_l2if_update_bond_slave(ifp, bond_ifindex);
d62a17ae 1279 } else if (ifp->vrf_id != vrf_id) {
1280 /* VRF change for an interface. */
1281 if (IS_ZEBRA_DEBUG_KERNEL)
1282 zlog_debug(
1283 "RTM_NEWLINK vrf-change for %s(%u) "
1284 "vrf_id %u -> %u flags 0x%x",
1285 name, ifp->ifindex, ifp->vrf_id, vrf_id,
1286 ifi->ifi_flags);
1287
1288 if_handle_vrf_change(ifp, vrf_id);
1289 } else {
b9368db9 1290 bool was_bridge_slave, was_bond_slave;
d62a17ae 1291
1292 /* Interface update. */
1293 if (IS_ZEBRA_DEBUG_KERNEL)
1294 zlog_debug(
1295 "RTM_NEWLINK update for %s(%u) "
1296 "sl_type %d master %u flags 0x%x",
1297 name, ifp->ifindex, zif_slave_type,
1298 bridge_ifindex, ifi->ifi_flags);
1299
1300 set_ifindex(ifp, ifi->ifi_index, zns);
d23b983b 1301 if (!tb[IFLA_MTU]) {
9df414fe 1302 zlog_debug(
d23b983b
SW		 1303 "RTM_NEWLINK for interface %s(%u) without MTU set",
1304 name, ifi->ifi_index);
1305 return 0;
1306 }
d62a17ae 1307 ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
1308 ifp->metric = 0;
1309
1310 /* Update interface type - NOTE: Only slave_type can
1311 * change. */
1312 was_bridge_slave = IS_ZEBRA_IF_BRIDGE_SLAVE(ifp);
b9368db9 1313 was_bond_slave = IS_ZEBRA_IF_BOND_SLAVE(ifp);
d62a17ae 1314 zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
1315
97c4e1d0
CS		 1316 memcpy(old_hw_addr, ifp->hw_addr, INTERFACE_HWADDR_MAX);
1317
d62a17ae 1318 netlink_interface_update_hw_addr(tb, ifp);
1319
1320 if (if_is_no_ptm_operative(ifp)) {
1321 ifp->flags = ifi->ifi_flags & 0x0000fffff;
1322 if (!if_is_no_ptm_operative(ifp)) {
1323 if (IS_ZEBRA_DEBUG_KERNEL)
1324 zlog_debug(
1325 "Intf %s(%u) has gone DOWN",
1326 name, ifp->ifindex);
1327 if_down(ifp);
1328 } else if (if_is_operative(ifp)) {
1329 /* Must notify client daemons of new
1330 * interface status. */
1331 if (IS_ZEBRA_DEBUG_KERNEL)
1332 zlog_debug(
1333 "Intf %s(%u) PTM up, notifying clients",
1334 name, ifp->ifindex);
1335 zebra_interface_up_update(ifp);
97c4e1d0
CS		 1336
1337 /* Update EVPN VNI when SVI MAC change
1338 */
1339 if (IS_ZEBRA_IF_VLAN(ifp) &&
1340 memcmp(old_hw_addr, ifp->hw_addr,
1341 INTERFACE_HWADDR_MAX)) {
1342 struct interface *link_if;
1343
1344 link_if =
1345 if_lookup_by_index_per_ns(
1346 zebra_ns_lookup(NS_DEFAULT),
1347 link_ifindex);
1348 if (link_if)
1349 zebra_vxlan_svi_up(ifp,
1350 link_if);
1351 }
d62a17ae 1352 }
1353 } else {
1354 ifp->flags = ifi->ifi_flags & 0x0000fffff;
1355 if (if_is_operative(ifp)) {
1356 if (IS_ZEBRA_DEBUG_KERNEL)
1357 zlog_debug(
1358 "Intf %s(%u) has come UP",
1359 name, ifp->ifindex);
1360 if_up(ifp);
1361 }
1362 }
1363
1364 /* Extract and save L2 interface information, take
1365 * additional actions. */
1366 netlink_interface_update_l2info(
1367 ifp, linkinfo[IFLA_INFO_DATA], 0);
1368 if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) || was_bridge_slave)
1369 zebra_l2if_update_bridge_slave(ifp,
1370 bridge_ifindex);
b9368db9
DD		 1371 else if (IS_ZEBRA_IF_BOND_SLAVE(ifp) || was_bond_slave)
1372 zebra_l2if_update_bond_slave(ifp, bond_ifindex);
d62a17ae 1373 }
1374 } else {
1375 /* Delete interface notification from kernel */
1376 if (ifp == NULL) {
9df414fe
QY		 1377 if (IS_ZEBRA_DEBUG_KERNEL)
1378 zlog_debug(
1379 "RTM_DELLINK for unknown interface %s(%u)",
1380 name, ifi->ifi_index);
d62a17ae 1381 return 0;
1382 }
1383
1384 if (IS_ZEBRA_DEBUG_KERNEL)
1385 zlog_debug("RTM_DELLINK for %s(%u)", name,
1386 ifp->ifindex);
1387
1388 UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
1389
1390 /* Special handling for bridge or VxLAN interfaces. */
1391 if (IS_ZEBRA_IF_BRIDGE(ifp))
1392 zebra_l2_bridge_del(ifp);
1393 else if (IS_ZEBRA_IF_VXLAN(ifp))
1394 zebra_l2_vxlanif_del(ifp);
1395
1396 if (!IS_ZEBRA_IF_VRF(ifp))
1397 if_delete_update(ifp);
1fdc9eae 1398 }
1399
d62a17ae 1400 return 0;
1fdc9eae 1401}
718e3744 1402
1403/* Interface information read by netlink. */
d62a17ae 1404void interface_list(struct zebra_ns *zns)
718e3744 1405{
d62a17ae 1406 interface_lookup_netlink(zns);
718e3744 1407}
ddfeb486
DL		 1408
1409#endif /* GNU_LINUX */
FRRouting mirror