1 /* Kernel communication using routing socket.
2 * Copyright (C) 1999 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <net/if_types.h>
27 #include <netmpls/mpls.h>
32 #include "sockunion.h"
33 #include "connected.h"
35 #include "zebra_memory.h"
42 #include "lib_errors.h"
45 #include "zebra/interface.h"
46 #include "zebra/zserv.h"
47 #include "zebra/debug.h"
48 #include "zebra/kernel_socket.h"
49 #include "zebra/rib.h"
50 #include "zebra/zebra_errors.h"
51 #include "zebra/zebra_ptm.h"
53 extern struct zebra_privs_t zserv_privs
;
56 * Historically, the BSD routing socket has aligned data following a
57 * struct sockaddr to sizeof(long), which was 4 bytes on some
58 * platforms, and 8 bytes on others. NetBSD 6 changed the routing
59 * socket to align to sizeof(uint64_t), which is 8 bytes. OS X
60 * appears to align to sizeof(int), which is 4 bytes.
62 * Alignment of zero-sized sockaddrs is nonsensical, but historically
63 * BSD defines RT_ROUNDUP(0) to be the alignment interval (rather than
64 * 0). We follow this practice without questioning it, but it is a
65 * bug if quagga calls ROUNDUP with 0.
68 #define ROUNDUP_TYPE int
70 #define ROUNDUP_TYPE long
74 * Because of these varying conventions, the only sane approach is for
75 * the <net/route.h> header to define some flavor of ROUNDUP macro.
78 /* OS X (Xcode as of 2014-12) is known not to define RT_ROUNDUP */
79 #if defined(RT_ROUNDUP)
80 #define ROUNDUP(a) RT_ROUNDUP(a)
81 #endif /* defined(RT_ROUNDUP) */
84 /* Solaris has struct sockaddr_in[6] definitions at 16 / 32 bytes size,
85 * so the whole concept doesn't really apply. */
86 #define ROUNDUP(a) (a)
90 * If ROUNDUP has not yet been defined in terms of platform-provided
91 * defines, attempt to cope with heuristics.
96 * If you're porting to a platform that changed RT_ROUNDUP but doesn't
97 * have it in its headers, this will break rather obviously and you'll
98 * have to fix it here.
101 ((a) > 0 ? (1 + (((a)-1) | (sizeof(ROUNDUP_TYPE) - 1))) \
102 : sizeof(ROUNDUP_TYPE))
104 #endif /* defined(ROUNDUP) */
108 /* SAROUNDUP is the only thing we need, and SA_SIZE provides that */
109 #define SAROUNDUP(a) SA_SIZE(a)
112 * Given a pointer (sockaddr or void *), return the number of bytes
113 * taken up by the sockaddr and any padding needed for alignment.
115 #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN)
116 #define SAROUNDUP(X) ROUNDUP(((struct sockaddr *)(X))->sa_len)
119 * One would hope all fixed-size structure definitions are aligned,
120 * but round them up nonetheless.
122 #define SAROUNDUP(X) \
123 (((struct sockaddr *)(X))->sa_family == AF_INET \
124 ? ROUNDUP(sizeof(struct sockaddr_in)) \
125 : (((struct sockaddr *)(X))->sa_family == AF_INET6 \
126 ? ROUNDUP(sizeof(struct sockaddr_in6)) \
127 : (((struct sockaddr *)(X))->sa_family == AF_LINK \
128 ? ROUNDUP(sizeof(struct sockaddr_dl)) \
129 : sizeof(struct sockaddr))))
130 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
132 #endif /* !SA_SIZE */
134 /* Routing socket message types. */
135 const struct message rtm_type_str
[] = {{RTM_ADD
, "RTM_ADD"},
136 {RTM_DELETE
, "RTM_DELETE"},
137 {RTM_CHANGE
, "RTM_CHANGE"},
138 {RTM_GET
, "RTM_GET"},
139 {RTM_LOSING
, "RTM_LOSING"},
140 {RTM_REDIRECT
, "RTM_REDIRECT"},
141 {RTM_MISS
, "RTM_MISS"},
143 {RTM_LOCK
, "RTM_LOCK"},
144 #endif /* RTM_LOCK */
146 {RTM_OLDADD
, "RTM_OLDADD"},
147 #endif /* RTM_OLDADD */
149 {RTM_OLDDEL
, "RTM_OLDDEL"},
150 #endif /* RTM_OLDDEL */
151 {RTM_RESOLVE
, "RTM_RESOLVE"},
152 {RTM_NEWADDR
, "RTM_NEWADDR"},
153 {RTM_DELADDR
, "RTM_DELADDR"},
154 {RTM_IFINFO
, "RTM_IFINFO"},
156 {RTM_OIFINFO
, "RTM_OIFINFO"},
157 #endif /* RTM_OIFINFO */
159 {RTM_NEWMADDR
, "RTM_NEWMADDR"},
160 #endif /* RTM_NEWMADDR */
162 {RTM_DELMADDR
, "RTM_DELMADDR"},
163 #endif /* RTM_DELMADDR */
164 #ifdef RTM_IFANNOUNCE
165 {RTM_IFANNOUNCE
, "RTM_IFANNOUNCE"},
166 #endif /* RTM_IFANNOUNCE */
169 static const struct message rtm_flag_str
[] = {{RTF_UP
, "UP"},
170 {RTF_GATEWAY
, "GATEWAY"},
172 {RTF_REJECT
, "REJECT"},
173 {RTF_DYNAMIC
, "DYNAMIC"},
174 {RTF_MODIFIED
, "MODIFIED"},
178 #endif /* RTF_MASK */
180 {RTF_CLONING
, "CLONING"},
181 #endif /* RTF_CLONING */
183 {RTF_XRESOLVE
, "XRESOLVE"},
184 #endif /* RTF_XRESOLVE */
186 {RTF_LLINFO
, "LLINFO"},
187 #endif /* RTF_LLINFO */
188 {RTF_STATIC
, "STATIC"},
189 {RTF_BLACKHOLE
, "BLACKHOLE"},
191 {RTF_PRIVATE
, "PRIVATE"},
192 #endif /* RTF_PRIVATE */
193 {RTF_PROTO1
, "PROTO1"},
194 {RTF_PROTO2
, "PROTO2"},
196 {RTF_PRCLONING
, "PRCLONING"},
197 #endif /* RTF_PRCLONING */
199 {RTF_WASCLONED
, "WASCLONED"},
200 #endif /* RTF_WASCLONED */
202 {RTF_PROTO3
, "PROTO3"},
203 #endif /* RTF_PROTO3 */
205 {RTF_PINNED
, "PINNED"},
206 #endif /* RTF_PINNED */
208 {RTF_LOCAL
, "LOCAL"},
209 #endif /* RTF_LOCAL */
211 {RTF_BROADCAST
, "BROADCAST"},
212 #endif /* RTF_BROADCAST */
214 {RTF_MULTICAST
, "MULTICAST"},
215 #endif /* RTF_MULTICAST */
217 {RTF_MULTIRT
, "MULTIRT"},
218 #endif /* RTF_MULTIRT */
220 {RTF_SETSRC
, "SETSRC"},
221 #endif /* RTF_SETSRC */
224 /* Kernel routing update socket. */
225 int routing_sock
= -1;
227 /* Kernel dataplane routing update socket, used in the dataplane pthread
230 int dplane_routing_sock
= -1;
232 /* Yes I'm checking ugly routing socket behavior. */
235 size_t rta_get(caddr_t sap
, void *dest
, size_t destlen
);
236 size_t rta_getsdlname(caddr_t sap
, void *dest
, short *destlen
);
238 /* Supported address family check. */
239 static inline int af_check(int family
)
241 if (family
== AF_INET
)
243 if (family
== AF_INET6
)
248 size_t rta_get(caddr_t sap
, void *destp
, size_t destlen
)
250 struct sockaddr
*sa
= (struct sockaddr
*)sap
;
251 uint8_t *dest
= destp
;
252 size_t tlen
, copylen
;
254 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
255 copylen
= sa
->sa_len
;
256 tlen
= (copylen
== 0) ? sizeof(ROUNDUP_TYPE
) : ROUNDUP(copylen
);
257 #else /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
258 copylen
= tlen
= SAROUNDUP(sap
);
259 #endif /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
261 if (copylen
> 0 && dest
!= NULL
&& af_check(sa
->sa_family
)) {
262 if (copylen
> destlen
) {
263 zlog_warn("%s: destination buffer too small (%lu vs %lu)",
264 __func__
, copylen
, destlen
);
265 memcpy(dest
, sap
, destlen
);
267 memcpy(dest
, sap
, copylen
);
273 size_t rta_getsdlname(caddr_t sap
, void *destp
, short *destlen
)
275 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*)sap
;
276 struct sockaddr
*sa
= (struct sockaddr
*)sap
;
277 uint8_t *dest
= destp
;
278 size_t tlen
, copylen
;
280 copylen
= sdl
->sdl_nlen
;
281 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
282 tlen
= (sa
->sa_len
== 0) ? sizeof(ROUNDUP_TYPE
) : ROUNDUP(sa
->sa_len
);
283 #else /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
284 tlen
= SAROUNDUP(sap
);
285 #endif /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
287 if (copylen
> 0 && dest
!= NULL
&& sdl
->sdl_family
== AF_LINK
) {
288 if (copylen
> IFNAMSIZ
) {
289 zlog_warn("%s: destination buffer too small (%lu vs %d)",
290 __func__
, copylen
, IFNAMSIZ
);
291 memcpy(dest
, sdl
->sdl_data
, IFNAMSIZ
);
295 memcpy(dest
, sdl
->sdl_data
, copylen
);
305 /* Dump routing table flag for debug purpose. */
306 static void rtm_flag_dump(int flag
)
308 const struct message
*mes
;
309 static char buf
[BUFSIZ
];
312 for (mes
= rtm_flag_str
; mes
->key
!= 0; mes
++) {
313 if (mes
->key
& flag
) {
314 strlcat(buf
, mes
->str
, BUFSIZ
);
315 strlcat(buf
, " ", BUFSIZ
);
318 zlog_debug("Kernel: %s", buf
);
321 #ifdef RTM_IFANNOUNCE
322 /* Interface adding function */
323 static int ifan_read(struct if_announcemsghdr
*ifan
)
325 struct interface
*ifp
;
327 ifp
= if_lookup_by_index(ifan
->ifan_index
, VRF_DEFAULT
);
330 assert((ifp
->ifindex
== ifan
->ifan_index
)
331 || (ifp
->ifindex
== IFINDEX_INTERNAL
));
333 if ((ifp
== NULL
) || ((ifp
->ifindex
== IFINDEX_INTERNAL
)
334 && (ifan
->ifan_what
== IFAN_ARRIVAL
))) {
335 if (IS_ZEBRA_DEBUG_KERNEL
)
337 "%s: creating interface for ifindex %d, name %s",
338 __func__
, ifan
->ifan_index
, ifan
->ifan_name
);
340 /* Create Interface */
341 ifp
= if_get_by_name(ifan
->ifan_name
, VRF_DEFAULT
);
342 if_set_index(ifp
, ifan
->ifan_index
);
346 } else if (ifp
!= NULL
&& ifan
->ifan_what
== IFAN_DEPARTURE
)
347 if_delete_update(ifp
);
353 if (IS_ZEBRA_DEBUG_KERNEL
)
354 zlog_debug("%s: interface %s index %d", __func__
,
355 ifan
->ifan_name
, ifan
->ifan_index
);
359 #endif /* RTM_IFANNOUNCE */
361 #ifdef HAVE_BSD_IFI_LINK_STATE
362 /* BSD link detect translation */
363 static void bsd_linkdetect_translate(struct if_msghdr
*ifm
)
365 if ((ifm
->ifm_data
.ifi_link_state
>= LINK_STATE_UP
)
366 || (ifm
->ifm_data
.ifi_link_state
== LINK_STATE_UNKNOWN
))
367 SET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
369 UNSET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
371 #endif /* HAVE_BSD_IFI_LINK_STATE */
373 static enum zebra_link_type
sdl_to_zebra_link_type(unsigned int sdlt
)
377 return ZEBRA_LLT_ETHER
;
379 return ZEBRA_LLT_X25
;
381 return ZEBRA_LLT_FDDI
;
383 return ZEBRA_LLT_PPP
;
385 return ZEBRA_LLT_LOOPBACK
;
387 return ZEBRA_LLT_SLIP
;
389 return ZEBRA_LLT_ARCNET
;
391 return ZEBRA_LLT_ATM
;
393 return ZEBRA_LLT_LOCALTLK
;
395 return ZEBRA_LLT_HIPPI
;
398 return ZEBRA_LLT_IEEE1394
;
402 return ZEBRA_LLT_UNKNOWN
;
407 * Handle struct if_msghdr obtained from reading routing socket or
408 * sysctl (from interface_list). There may or may not be sockaddrs
409 * present after the header.
411 int ifm_read(struct if_msghdr
*ifm
)
413 struct interface
*ifp
= NULL
;
414 struct sockaddr_dl
*sdl
;
415 char ifname
[IFNAMSIZ
];
420 /* terminate ifname at head (for strnlen) and tail (for safety) */
421 ifname
[IFNAMSIZ
- 1] = '\0';
423 /* paranoia: sanity check structure */
424 if (ifm
->ifm_msglen
< sizeof(struct if_msghdr
)) {
425 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR
,
426 "ifm_read: ifm->ifm_msglen %d too short\n",
432 * Check for a sockaddr_dl following the message. First, point to
433 * where a socakddr might be if one follows the message.
435 cp
= (void *)(ifm
+ 1);
439 * XXX This behavior should be narrowed to only the kernel versions
440 * for which the structures returned do not match the headers.
442 * if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
443 * is 12 bytes larger than the 32 bit version.
445 if (((struct sockaddr
*)cp
)->sa_family
== AF_UNSPEC
)
449 /* Look up for RTA_IFP and skip others. */
450 for (maskbit
= 1; maskbit
; maskbit
<<= 1) {
451 if ((maskbit
& ifm
->ifm_addrs
) == 0)
453 if (maskbit
!= RTA_IFP
) {
454 cp
+= rta_get(cp
, NULL
, 0);
458 /* Save the pointer to the structure. */
459 sdl
= (struct sockaddr_dl
*)cp
;
460 cp
+= rta_getsdlname(cp
, ifname
, &ifnlen
);
463 if (IS_ZEBRA_DEBUG_KERNEL
)
464 zlog_debug("%s: sdl ifname %s", __func__
,
465 (ifnlen
? ifname
: "(nil)"));
468 * Look up on ifindex first, because ifindices are the primary handle
470 * interfaces across the user/kernel boundary, for most systems. (Some
471 * messages, such as up/down status changes on NetBSD, do not include a
474 if ((ifp
= if_lookup_by_index(ifm
->ifm_index
, VRF_DEFAULT
)) != NULL
) {
475 /* we have an ifp, verify that the name matches as some systems,
476 * eg Solaris, have a 1:many association of ifindex:ifname
477 * if they dont match, we dont have the correct ifp and should
478 * set it back to NULL to let next check do lookup by name
480 if (ifnlen
&& (strncmp(ifp
->name
, ifname
, IFNAMSIZ
) != 0)) {
481 if (IS_ZEBRA_DEBUG_KERNEL
)
483 "%s: ifp name %s doesn't match sdl name %s",
484 __func__
, ifp
->name
, ifname
);
490 * If we dont have an ifp, try looking up by name. Particularly as some
491 * systems (Solaris) have a 1:many mapping of ifindex:ifname - the
493 * is therefore our unique handle to that interface.
495 * Interfaces specified in the configuration file for which the ifindex
496 * has not been determined will have ifindex == IFINDEX_INTERNAL, and
498 * interfaces are found by this search, and then their ifindex values
502 if ((ifp
== NULL
) && ifnlen
)
503 ifp
= if_lookup_by_name(ifname
, VRF_DEFAULT
);
506 * If ifp still does not exist or has an invalid index
507 * (IFINDEX_INTERNAL),
508 * create or fill in an interface.
510 if ((ifp
== NULL
) || (ifp
->ifindex
== IFINDEX_INTERNAL
)) {
512 * To create or fill in an interface, a sockaddr_dl (via
513 * RTA_IFP) is required.
516 zlog_debug("Interface index %d (new) missing ifname\n",
521 #ifndef RTM_IFANNOUNCE
522 /* Down->Down interface should be ignored here.
523 * See further comment below.
525 if (!CHECK_FLAG(ifm
->ifm_flags
, IFF_UP
))
527 #endif /* !RTM_IFANNOUNCE */
530 /* Interface that zebra was not previously aware of, so
532 ifp
= if_create(ifname
, VRF_DEFAULT
);
533 if (IS_ZEBRA_DEBUG_KERNEL
)
534 zlog_debug("%s: creating ifp for ifindex %d",
535 __func__
, ifm
->ifm_index
);
538 if (IS_ZEBRA_DEBUG_KERNEL
)
540 "%s: updated/created ifp, ifname %s, ifindex %d",
541 __func__
, ifp
->name
, ifp
->ifindex
);
543 * Fill in newly created interface structure, or larval
544 * structure with ifindex IFINDEX_INTERNAL.
546 if_set_index(ifp
, ifm
->ifm_index
);
548 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
549 bsd_linkdetect_translate(ifm
);
550 #endif /* HAVE_BSD_IFI_LINK_STATE */
552 if_flags_update(ifp
, ifm
->ifm_flags
);
553 #if defined(__bsdi__)
557 #endif /* __bsdi__ */
561 * XXX sockaddr_dl contents can be larger than the structure
562 * definition. There are 2 big families here:
563 * - BSD has sdl_len + sdl_data[16] + overruns sdl_data
564 * we MUST use sdl_len here or we'll truncate data.
565 * - Solaris has no sdl_len, but sdl_data[244]
566 * presumably, it's not going to run past that, so sizeof()
568 * a nonzero ifnlen from rta_getsdlname() means sdl is valid
570 ifp
->ll_type
= ZEBRA_LLT_UNKNOWN
;
571 ifp
->hw_addr_len
= 0;
573 #ifdef HAVE_STRUCT_SOCKADDR_DL_SDL_LEN
574 memcpy(&((struct zebra_if
*)ifp
->info
)->sdl
, sdl
,
577 memcpy(&((struct zebra_if
*)ifp
->info
)->sdl
, sdl
,
578 sizeof(struct sockaddr_dl
));
579 #endif /* HAVE_STRUCT_SOCKADDR_DL_SDL_LEN */
581 ifp
->ll_type
= sdl_to_zebra_link_type(sdl
->sdl_type
);
582 if (sdl
->sdl_alen
<= sizeof(ifp
->hw_addr
)) {
583 memcpy(ifp
->hw_addr
, LLADDR(sdl
),
585 ifp
->hw_addr_len
= sdl
->sdl_alen
;
592 * Interface structure exists. Adjust stored flags from
593 * notification. If interface has up->down or down->up
594 * transition, call state change routines (to adjust routes,
595 * notify routing daemons, etc.). (Other flag changes are stored
596 * but apparently do not trigger action.)
599 if (ifp
->ifindex
!= ifm
->ifm_index
) {
601 "%s: index mismatch, ifname %s, ifp index %d, "
603 __func__
, ifp
->name
, ifp
->ifindex
,
608 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
609 bsd_linkdetect_translate(ifm
);
610 #endif /* HAVE_BSD_IFI_LINK_STATE */
612 /* update flags and handle operative->inoperative transition, if
614 if_flags_update(ifp
, ifm
->ifm_flags
);
616 #ifndef RTM_IFANNOUNCE
617 if (!if_is_up(ifp
)) {
618 /* No RTM_IFANNOUNCE on this platform, so we can never
619 * distinguish between ~IFF_UP and delete. We must
621 * it has been deleted.
622 * Eg, Solaris will not notify us of unplumb.
624 * XXX: Fixme - this should be runtime detected
625 * So that a binary compiled on a system with IFANNOUNCE
626 * will still behave correctly if run on a platform
629 if_delete_update(ifp
);
631 #endif /* RTM_IFANNOUNCE */
633 #if defined(__bsdi__)
637 #endif /* __bsdi__ */
642 #ifdef HAVE_NET_RT_IFLIST
643 ifp
->stats
= ifm
->ifm_data
;
644 #endif /* HAVE_NET_RT_IFLIST */
645 ifp
->speed
= ifm
->ifm_data
.ifi_baudrate
/ 1000000;
647 if (IS_ZEBRA_DEBUG_KERNEL
)
648 zlog_debug("%s: interface %s index %d", __func__
, ifp
->name
,
654 /* Address read from struct ifa_msghdr. */
655 static void ifam_read_mesg(struct ifa_msghdr
*ifm
, union sockunion
*addr
,
656 union sockunion
*mask
, union sockunion
*brd
,
657 char *ifname
, short *ifnlen
)
661 union sockunion gateway
;
664 pnt
= (caddr_t
)(ifm
+ 1);
665 end
= ((caddr_t
)ifm
) + ifm
->ifam_msglen
;
667 /* Be sure structure is cleared */
668 memset(mask
, 0, sizeof(union sockunion
));
669 memset(addr
, 0, sizeof(union sockunion
));
670 memset(brd
, 0, sizeof(union sockunion
));
671 memset(&dst
, 0, sizeof(union sockunion
));
672 memset(&gateway
, 0, sizeof(union sockunion
));
674 /* We fetch each socket variable into sockunion. */
675 for (maskbit
= 1; maskbit
; maskbit
<<= 1) {
676 if ((maskbit
& ifm
->ifam_addrs
) == 0)
681 pnt
+= rta_get(pnt
, &dst
, sizeof(dst
));
684 pnt
+= rta_get(pnt
, &gateway
, sizeof(gateway
));
687 pnt
+= rta_get(pnt
, mask
, sizeof(*mask
));
690 pnt
+= rta_getsdlname(pnt
, ifname
, ifnlen
);
693 pnt
+= rta_get(pnt
, addr
, sizeof(*addr
));
696 pnt
+= rta_get(pnt
, brd
, sizeof(*brd
));
700 pnt
+= rta_get(pnt
, NULL
, 0);
705 zlog_warn("%s: overflow detected (pnt:%p end:%p)",
711 if (IS_ZEBRA_DEBUG_KERNEL
) {
712 int family
= sockunion_family(addr
);
716 char buf
[4][INET6_ADDRSTRLEN
];
718 "%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
719 "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
721 __func__
, ifm
->ifam_index
,
722 (ifnlen
? ifname
: "(nil)"), ifm
->ifam_addrs
,
724 inet_ntop(family
, &addr
->sin
.sin_addr
, buf
[0],
726 ip_masklen(mask
->sin
.sin_addr
),
727 inet_ntop(family
, &brd
->sin
.sin_addr
, buf
[1],
729 inet_ntop(family
, &dst
.sin
.sin_addr
, buf
[2],
731 inet_ntop(family
, &gateway
.sin
.sin_addr
, buf
[3],
735 zlog_debug("%s: ifindex %d, ifname %s, ifam_addrs 0x%x",
736 __func__
, ifm
->ifam_index
,
737 (ifnlen
? ifname
: "(nil)"),
743 /* Assert read up end point matches to end point */
744 pnt
= (caddr_t
)ROUNDUP((size_t)pnt
);
746 zlog_debug("ifam_read() doesn't read all socket data");
749 /* Interface's address information get. */
750 int ifam_read(struct ifa_msghdr
*ifam
)
752 struct interface
*ifp
= NULL
;
753 union sockunion addr
, mask
, brd
;
754 char ifname
[INTERFACE_NAMSIZ
];
759 ifname
[0] = ifname
[INTERFACE_NAMSIZ
- 1] = '\0';
761 /* Allocate and read address information. */
762 ifam_read_mesg(ifam
, &addr
, &mask
, &brd
, ifname
, &ifnlen
);
764 if ((ifp
= if_lookup_by_index(ifam
->ifam_index
, VRF_DEFAULT
)) == NULL
) {
765 flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE
,
766 "%s: no interface for ifname %s, index %d", __func__
,
767 ifname
, ifam
->ifam_index
);
771 if (ifnlen
&& strncmp(ifp
->name
, ifname
, INTERFACE_NAMSIZ
))
774 /* N.B. The info in ifa_msghdr does not tell us whether the RTA_BRD
775 field contains a broadcast address or a peer address, so we are
777 rely upon the interface type. */
778 if (if_is_pointopoint(ifp
))
779 SET_FLAG(flags
, ZEBRA_IFA_PEER
);
782 /* it might seem cute to grab the interface metric here, however
783 * we're processing an address update message, and so some systems
784 * (e.g. FBSD) dont bother to fill in ifam_metric. Disabled, but left
785 * in deliberately, as comment.
787 ifp
->metric
= ifam
->ifam_metric
;
790 /* Add connected address. */
791 switch (sockunion_family(&addr
)) {
793 if (ifam
->ifam_type
== RTM_NEWADDR
)
794 connected_add_ipv4(ifp
, flags
, &addr
.sin
.sin_addr
,
795 ip_masklen(mask
.sin
.sin_addr
),
797 (isalias
? ifname
: NULL
));
799 connected_delete_ipv4(ifp
, flags
, &addr
.sin
.sin_addr
,
800 ip_masklen(mask
.sin
.sin_addr
),
804 /* Unset interface index from link-local address when IPv6 stack
806 if (IN6_IS_ADDR_LINKLOCAL(&addr
.sin6
.sin6_addr
)) {
807 SET_IN6_LINKLOCAL_IFINDEX(addr
.sin6
.sin6_addr
, 0);
810 if (ifam
->ifam_type
== RTM_NEWADDR
)
811 connected_add_ipv6(ifp
, flags
, &addr
.sin6
.sin6_addr
,
813 ip6_masklen(mask
.sin6
.sin6_addr
),
814 (isalias
? ifname
: NULL
));
816 connected_delete_ipv6(ifp
, &addr
.sin6
.sin6_addr
, NULL
,
817 ip6_masklen(mask
.sin6
.sin6_addr
));
820 /* Unsupported family silently ignore... */
824 /* Check interface flag for implicit up of the interface. */
828 /* In addition to lacking IFANNOUNCE, on SUNOS IFF_UP is strange.
829 * See comments for SUNOS_5 in interface.c::if_flags_mangle.
831 * Here we take care of case where the real IFF_UP was previously
832 * unset (as kept in struct zebra_if.primary_state) and the mangled
833 * IFF_UP (ie IFF_UP set || listcount(connected) has now transitioned
834 * to unset due to the lost non-primary address having DELADDR'd.
836 * we must delete the interface, because in between here and next
837 * event for this interface-name the administrator could unplumb
838 * and replumb the interface.
841 if_delete_update(ifp
);
847 /* Interface function for reading kernel routing table information. */
848 static int rtm_read_mesg(struct rt_msghdr
*rtm
, union sockunion
*dest
,
849 union sockunion
*mask
, union sockunion
*gate
,
850 char *ifname
, short *ifnlen
)
855 /* Pnt points out socket data start point. */
856 pnt
= (caddr_t
)(rtm
+ 1);
857 end
= ((caddr_t
)rtm
) + rtm
->rtm_msglen
;
859 /* rt_msghdr version check. */
860 if (rtm
->rtm_version
!= RTM_VERSION
)
861 flog_warn(EC_ZEBRA_RTM_VERSION_MISMATCH
,
862 "Routing message version different %d should be %d."
863 "This may cause problem\n",
864 rtm
->rtm_version
, RTM_VERSION
);
866 /* Be sure structure is cleared */
867 memset(dest
, 0, sizeof(union sockunion
));
868 memset(gate
, 0, sizeof(union sockunion
));
869 memset(mask
, 0, sizeof(union sockunion
));
871 /* We fetch each socket variable into sockunion. */
872 /* We fetch each socket variable into sockunion. */
873 for (maskbit
= 1; maskbit
; maskbit
<<= 1) {
874 if ((maskbit
& rtm
->rtm_addrs
) == 0)
879 pnt
+= rta_get(pnt
, dest
, sizeof(*dest
));
882 pnt
+= rta_get(pnt
, gate
, sizeof(*gate
));
885 pnt
+= rta_get(pnt
, mask
, sizeof(*mask
));
888 pnt
+= rta_getsdlname(pnt
, ifname
, ifnlen
);
892 pnt
+= rta_get(pnt
, NULL
, 0);
897 zlog_warn("%s: overflow detected (pnt:%p end:%p)",
903 /* If there is netmask information set it's family same as
905 if (rtm
->rtm_addrs
& RTA_NETMASK
)
906 mask
->sa
.sa_family
= dest
->sa
.sa_family
;
908 /* Assert read up to the end of pointer. */
910 zlog_debug("rtm_read() doesn't read all socket data.");
912 return rtm
->rtm_flags
;
915 void rtm_read(struct rt_msghdr
*rtm
)
919 union sockunion dest
, mask
, gate
;
920 char ifname
[INTERFACE_NAMSIZ
+ 1];
924 ifindex_t ifindex
= 0;
929 /* Read destination and netmask and gateway from rtm message
931 flags
= rtm_read_mesg(rtm
, &dest
, &mask
, &gate
, ifname
, &ifnlen
);
932 if (!(flags
& RTF_DONE
))
934 if (IS_ZEBRA_DEBUG_KERNEL
)
935 zlog_debug("%s: got rtm of type %d (%s)", __func__
,
937 lookup_msg(rtm_type_str
, rtm
->rtm_type
, NULL
));
939 #ifdef RTF_CLONED /*bsdi, netbsd 1.6*/
940 if (flags
& RTF_CLONED
)
943 #ifdef RTF_WASCLONED /*freebsd*/
944 if (flags
& RTF_WASCLONED
)
948 if ((rtm
->rtm_type
== RTM_ADD
|| rtm
->rtm_type
== RTM_CHANGE
)
949 && !(flags
& RTF_UP
))
952 /* This is connected route. */
953 if (!(flags
& RTF_GATEWAY
))
956 if (flags
& RTF_PROTO1
)
957 SET_FLAG(zebra_flags
, ZEBRA_FLAG_SELFROUTE
);
959 memset(&nh
, 0, sizeof(nh
));
961 nh
.vrf_id
= VRF_DEFAULT
;
962 /* This is a reject or blackhole route */
963 if (flags
& RTF_REJECT
) {
964 nh
.type
= NEXTHOP_TYPE_BLACKHOLE
;
965 nh
.bh_type
= BLACKHOLE_REJECT
;
966 } else if (flags
& RTF_BLACKHOLE
) {
967 nh
.type
= NEXTHOP_TYPE_BLACKHOLE
;
968 nh
.bh_type
= BLACKHOLE_NULL
;
972 * Ignore our own messages.
974 if (rtm
->rtm_type
!= RTM_GET
&& rtm
->rtm_pid
== pid
)
977 if (dest
.sa
.sa_family
== AF_INET
) {
980 p
.u
.prefix4
= dest
.sin
.sin_addr
;
981 if (flags
& RTF_HOST
)
982 p
.prefixlen
= IPV4_MAX_PREFIXLEN
;
984 p
.prefixlen
= ip_masklen(mask
.sin
.sin_addr
);
987 nh
.type
= NEXTHOP_TYPE_IPV4
;
988 nh
.gate
.ipv4
= gate
.sin
.sin_addr
;
990 } else if (dest
.sa
.sa_family
== AF_INET6
) {
993 p
.u
.prefix6
= dest
.sin6
.sin6_addr
;
994 if (flags
& RTF_HOST
)
995 p
.prefixlen
= IPV6_MAX_PREFIXLEN
;
997 p
.prefixlen
= ip6_masklen(mask
.sin6
.sin6_addr
);
1000 if (IN6_IS_ADDR_LINKLOCAL(&gate
.sin6
.sin6_addr
)) {
1001 ifindex
= IN6_LINKLOCAL_IFINDEX(gate
.sin6
.sin6_addr
);
1002 SET_IN6_LINKLOCAL_IFINDEX(gate
.sin6
.sin6_addr
, 0);
1007 nh
.type
= ifindex
? NEXTHOP_TYPE_IPV6_IFINDEX
1008 : NEXTHOP_TYPE_IPV6
;
1009 nh
.gate
.ipv6
= gate
.sin6
.sin6_addr
;
1010 nh
.ifindex
= ifindex
;
1016 * CHANGE: delete the old prefix, we have no further information
1017 * to specify the route really
1019 if (rtm
->rtm_type
== RTM_CHANGE
)
1020 rib_delete(afi
, SAFI_UNICAST
, VRF_DEFAULT
, ZEBRA_ROUTE_KERNEL
,
1021 0, zebra_flags
, &p
, NULL
, NULL
, 0, 0, 0, true);
1022 if (rtm
->rtm_type
== RTM_GET
|| rtm
->rtm_type
== RTM_ADD
1023 || rtm
->rtm_type
== RTM_CHANGE
)
1024 rib_add(afi
, SAFI_UNICAST
, VRF_DEFAULT
, ZEBRA_ROUTE_KERNEL
, 0,
1025 zebra_flags
, &p
, NULL
, &nh
, 0, 0, 0, 0, 0);
1027 rib_delete(afi
, SAFI_UNICAST
, VRF_DEFAULT
, ZEBRA_ROUTE_KERNEL
,
1028 0, zebra_flags
, &p
, NULL
, &nh
, 0, 0, 0, true);
1031 /* Interface function for the kernel routing table updates. Support
1032 * for RTM_CHANGE will be needed.
1033 * Exported only for rt_socket.c
1035 int rtm_write(int message
, union sockunion
*dest
, union sockunion
*mask
,
1036 union sockunion
*gate
, union sockunion
*mpls
, unsigned int index
,
1037 enum blackhole_type bh_type
, int metric
)
1041 struct interface
*ifp
;
1043 /* Sequencial number of routing message. */
1044 static int msg_seq
= 0;
1046 /* Struct of rt_msghdr and buffer for storing socket's data. */
1048 struct rt_msghdr rtm
;
1052 if (dplane_routing_sock
< 0)
1053 return ZEBRA_ERR_EPERM
;
1055 /* Clear and set rt_msghdr values */
1056 memset(&msg
, 0, sizeof(struct rt_msghdr
));
1057 msg
.rtm
.rtm_version
= RTM_VERSION
;
1058 msg
.rtm
.rtm_type
= message
;
1059 msg
.rtm
.rtm_seq
= msg_seq
++;
1060 msg
.rtm
.rtm_addrs
= RTA_DST
;
1061 msg
.rtm
.rtm_addrs
|= RTA_GATEWAY
;
1062 msg
.rtm
.rtm_flags
= RTF_UP
;
1064 msg
.rtm
.rtm_flags
|= RTF_MPATH
;
1065 msg
.rtm
.rtm_fmask
= RTF_MPLS
;
1067 msg
.rtm
.rtm_index
= index
;
1070 msg
.rtm
.rtm_rmx
.rmx_hopcount
= metric
;
1071 msg
.rtm
.rtm_inits
|= RTV_HOPCOUNT
;
1074 ifp
= if_lookup_by_index(index
, VRF_DEFAULT
);
1076 if (gate
&& (message
== RTM_ADD
|| message
== RTM_CHANGE
))
1077 msg
.rtm
.rtm_flags
|= RTF_GATEWAY
;
1079 /* When RTF_CLONING is unavailable on BSD, should we set some
1080 * other flag instead?
1083 if (!gate
&& (message
== RTM_ADD
|| message
== RTM_CHANGE
) && ifp
1084 && (ifp
->flags
& IFF_POINTOPOINT
) == 0)
1085 msg
.rtm
.rtm_flags
|= RTF_CLONING
;
1086 #endif /* RTF_CLONING */
1088 /* If no protocol specific gateway is specified, use link
1089 address for gateway. */
1092 char dest_buf
[INET_ADDRSTRLEN
] = "NULL",
1093 mask_buf
[INET_ADDRSTRLEN
] = "255.255.255.255";
1095 inet_ntop(AF_INET
, &dest
->sin
.sin_addr
,
1096 dest_buf
, INET_ADDRSTRLEN
);
1098 inet_ntop(AF_INET
, &mask
->sin
.sin_addr
,
1099 mask_buf
, INET_ADDRSTRLEN
);
1101 EC_ZEBRA_RTM_NO_GATEWAY
,
1102 "%s: %s/%s: gate == NULL and no gateway found for ifindex %d",
1103 __func__
, dest_buf
, mask_buf
, index
);
1106 gate
= (union sockunion
*)&((struct zebra_if
*)ifp
->info
)->sdl
;
1110 msg
.rtm
.rtm_addrs
|= RTA_NETMASK
;
1111 else if (message
== RTM_ADD
|| message
== RTM_CHANGE
)
1112 msg
.rtm
.rtm_flags
|= RTF_HOST
;
1116 msg
.rtm
.rtm_addrs
|= RTA_SRC
;
1117 msg
.rtm
.rtm_flags
|= RTF_MPLS
;
1119 if (mpls
->smpls
.smpls_label
1120 != htonl(MPLS_LABEL_IMPLICIT_NULL
<< MPLS_LABEL_OFFSET
))
1121 msg
.rtm
.rtm_mpls
= MPLS_OP_PUSH
;
1125 /* Tagging route with flags */
1126 msg
.rtm
.rtm_flags
|= (RTF_PROTO1
);
1129 case BLACKHOLE_UNSPEC
:
1131 case BLACKHOLE_REJECT
:
1132 msg
.rtm
.rtm_flags
|= RTF_REJECT
;
1135 msg
.rtm
.rtm_flags
|= RTF_BLACKHOLE
;
1140 #define SOCKADDRSET(X, R) \
1141 if (msg.rtm.rtm_addrs & (R)) { \
1142 int len = SAROUNDUP(X); \
1143 memcpy(pnt, (caddr_t)(X), len); \
1147 pnt
= (caddr_t
)msg
.buf
;
1149 /* Write each socket data into rtm message buffer */
1150 SOCKADDRSET(dest
, RTA_DST
);
1151 SOCKADDRSET(gate
, RTA_GATEWAY
);
1152 SOCKADDRSET(mask
, RTA_NETMASK
);
1154 SOCKADDRSET(mpls
, RTA_SRC
);
1157 msg
.rtm
.rtm_msglen
= pnt
- (caddr_t
)&msg
;
1159 ret
= write(dplane_routing_sock
, &msg
, msg
.rtm
.rtm_msglen
);
1161 if (ret
!= msg
.rtm
.rtm_msglen
) {
1162 if (errno
== EEXIST
)
1163 return ZEBRA_ERR_RTEXIST
;
1164 if (errno
== ENETUNREACH
)
1165 return ZEBRA_ERR_RTUNREACH
;
1167 return ZEBRA_ERR_RTNOEXIST
;
1169 flog_err_sys(EC_LIB_SOCKET
, "%s: write : %s (%d)", __func__
,
1170 safe_strerror(errno
), errno
);
1171 return ZEBRA_ERR_KERNEL
;
1173 return ZEBRA_ERR_NOERROR
;
1178 #include "zebra/zserv.h"
1180 /* For debug purpose. */
1181 static void rtmsg_debug(struct rt_msghdr
*rtm
)
1183 zlog_debug("Kernel: Len: %d Type: %s", rtm
->rtm_msglen
,
1184 lookup_msg(rtm_type_str
, rtm
->rtm_type
, NULL
));
1185 rtm_flag_dump(rtm
->rtm_flags
);
1186 zlog_debug("Kernel: message seq %d", rtm
->rtm_seq
);
1187 zlog_debug("Kernel: pid %lld, rtm_addrs 0x%x", (long long)rtm
->rtm_pid
,
1191 /* This is pretty gross, better suggestions welcome -- mhandler */
1194 #define RTAX_MAX RTA_NUMBITS
1197 #endif /* RTA_NUMBITS */
1198 #endif /* RTAX_MAX */
1200 /* Kernel routing table and interface updates via routing socket. */
1201 static int kernel_read(struct thread
*thread
)
1205 struct rt_msghdr
*rtm
;
1208 * This must be big enough for any message the kernel might send.
1209 * Rather than determining how many sockaddrs of what size might be
1210 * in each particular message, just use RTAX_MAX of sockaddr_storage
1211 * for each. Note that the sockaddrs must be after each message
1212 * definition, or rather after whichever happens to be the largest,
1213 * since the buffer needs to be big enough for a message and the
1214 * sockaddrs together.
1217 /* Routing information. */
1219 struct rt_msghdr rtm
;
1220 struct sockaddr_storage addr
[RTAX_MAX
];
1223 /* Interface information. */
1225 struct if_msghdr ifm
;
1226 struct sockaddr_storage addr
[RTAX_MAX
];
1229 /* Interface address information. */
1231 struct ifa_msghdr ifa
;
1232 struct sockaddr_storage addr
[RTAX_MAX
];
1235 #ifdef RTM_IFANNOUNCE
1236 /* Interface arrival/departure */
1238 struct if_announcemsghdr ifan
;
1239 struct sockaddr_storage addr
[RTAX_MAX
];
1241 #endif /* RTM_IFANNOUNCE */
1245 /* Fetch routing socket. */
1246 sock
= THREAD_FD(thread
);
1248 nbytes
= read(sock
, &buf
, sizeof buf
);
1251 if (nbytes
< 0 && errno
!= EWOULDBLOCK
&& errno
!= EAGAIN
)
1252 flog_err_sys(EC_LIB_SOCKET
, "routing socket error: %s",
1253 safe_strerror(errno
));
1257 thread_add_read(zebrad
.master
, kernel_read
, NULL
, sock
, NULL
);
1259 if (IS_ZEBRA_DEBUG_KERNEL
)
1260 rtmsg_debug(&buf
.r
.rtm
);
1265 * Ensure that we didn't drop any data, so that processing routines
1266 * can assume they have the whole message.
1268 if (rtm
->rtm_msglen
!= nbytes
) {
1270 "kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d\n",
1271 rtm
->rtm_msglen
, nbytes
, rtm
->rtm_type
);
1275 switch (rtm
->rtm_type
) {
1282 ifm_read(&buf
.im
.ifm
);
1286 ifam_read(&buf
.ia
.ifa
);
1288 #ifdef RTM_IFANNOUNCE
1289 case RTM_IFANNOUNCE
:
1290 ifan_read(&buf
.ian
.ifan
);
1292 #endif /* RTM_IFANNOUNCE */
1294 if (IS_ZEBRA_DEBUG_KERNEL
)
1295 zlog_debug("Unprocessed RTM_type: %d", rtm
->rtm_type
);
1301 /* Make routing socket. */
1302 static void routing_socket(struct zebra_ns
*zns
)
1304 frr_elevate_privs(&zserv_privs
) {
1305 routing_sock
= ns_socket(AF_ROUTE
, SOCK_RAW
, 0, zns
->ns_id
);
1307 dplane_routing_sock
=
1308 ns_socket(AF_ROUTE
, SOCK_RAW
, 0, zns
->ns_id
);
1311 if (routing_sock
< 0) {
1312 flog_err_sys(EC_LIB_SOCKET
, "Can't init kernel routing socket");
1316 if (dplane_routing_sock
< 0) {
1317 flog_err_sys(EC_LIB_SOCKET
,
1318 "Can't init kernel dataplane routing socket");
1322 /* XXX: Socket should be NONBLOCK, however as we currently
1323 * discard failed writes, this will lead to inconsistencies.
1324 * For now, socket must be blocking.
1326 /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
1327 zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
1329 /* kernel_read needs rewrite. */
1330 thread_add_read(zebrad
.master
, kernel_read
, NULL
, routing_sock
, NULL
);
1333 /* Exported interface function. This function simply calls
1334 routing_socket (). */
1335 void kernel_init(struct zebra_ns
*zns
)
1337 routing_socket(zns
);
1340 void kernel_terminate(struct zebra_ns
*zns
, bool complete
)
1345 #endif /* !HAVE_NETLINK */