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"
44 #include "zebra/interface.h"
45 #include "zebra/zserv.h"
46 #include "zebra/debug.h"
47 #include "zebra/kernel_socket.h"
48 #include "zebra/rib.h"
50 extern struct zebra_privs_t zserv_privs
;
53 * Historically, the BSD routing socket has aligned data following a
54 * struct sockaddr to sizeof(long), which was 4 bytes on some
55 * platforms, and 8 bytes on others. NetBSD 6 changed the routing
56 * socket to align to sizeof(uint64_t), which is 8 bytes. OS X
57 * appears to align to sizeof(int), which is 4 bytes.
59 * Alignment of zero-sized sockaddrs is nonsensical, but historically
60 * BSD defines RT_ROUNDUP(0) to be the alignment interval (rather than
61 * 0). We follow this practice without questioning it, but it is a
62 * bug if quagga calls ROUNDUP with 0.
66 * Because of these varying conventions, the only sane approach is for
67 * the <net/route.h> header to define some flavor of ROUNDUP macro.
71 /* SAROUNDUP is the only thing we need, and SA_SIZE provides that */
72 #define SAROUNDUP(a) SA_SIZE(a)
75 #if defined(RT_ROUNDUP)
76 #define ROUNDUP(a) RT_ROUNDUP(a)
77 #endif /* defined(RT_ROUNDUP) */
80 /* Solaris has struct sockaddr_in[6] definitions at 16 / 32 bytes size,
81 * so the whole concept doesn't really apply. */
82 #define ROUNDUP(a) (a)
86 * If ROUNDUP has not yet been defined in terms of platform-provided
87 * defines, attempt to cope with heuristics.
92 * If you're porting to a platform that changed RT_ROUNDUP but doesn't
93 * have it in its headers, this will break rather obviously and you'll
94 * have to fix it here.
97 /* OS X (Xcode as of 2014-12) is known not to define RT_ROUNDUP */
99 #define ROUNDUP_TYPE int
101 #define ROUNDUP_TYPE long
105 ((a) > 0 ? (1 + (((a)-1) | (sizeof(ROUNDUP_TYPE) - 1))) \
106 : sizeof(ROUNDUP_TYPE))
108 #endif /* defined(ROUNDUP) */
111 * Given a pointer (sockaddr or void *), return the number of bytes
112 * taken up by the sockaddr and any padding needed for alignment.
114 #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN)
115 #define SAROUNDUP(X) ROUNDUP(((struct sockaddr *)(X))->sa_len)
118 * One would hope all fixed-size structure definitions are aligned,
119 * but round them up nonetheless.
121 #define SAROUNDUP(X) \
122 (((struct sockaddr *)(X))->sa_family == AF_INET \
123 ? ROUNDUP(sizeof(struct sockaddr_in)) \
124 : (((struct sockaddr *)(X))->sa_family == AF_INET6 \
125 ? ROUNDUP(sizeof(struct sockaddr_in6)) \
126 : (((struct sockaddr *)(X))->sa_family == AF_LINK \
127 ? ROUNDUP(sizeof(struct sockaddr_dl)) \
128 : sizeof(struct sockaddr))))
129 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
131 #endif /* !SA_SIZE */
134 * We use a call to an inline function to copy (PNT) to (DEST)
135 * 1. Calculating the length of the copy requires an #ifdef to determine
136 * if sa_len is a field and can't be used directly inside a #define
137 * 2. So the compiler doesn't complain when DEST is NULL, which is only true
138 * when we are skipping the copy and incrementing to the next SA
140 static inline void rta_copy(union sockunion
*dest
, caddr_t src
)
145 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
146 len
= (((struct sockaddr
*)src
)->sa_len
> sizeof(*dest
))
148 : ((struct sockaddr
*)src
)->sa_len
;
150 len
= (SAROUNDUP(src
) > sizeof(*dest
)) ? sizeof(*dest
) : SAROUNDUP(src
);
152 memcpy(dest
, src
, len
);
155 #define RTA_ADDR_GET(DEST, RTA, RTMADDRS, PNT) \
156 if ((RTMADDRS) & (RTA)) { \
157 int len = SAROUNDUP((PNT)); \
158 if (af_check(((struct sockaddr *)(PNT))->sa_family)) \
159 rta_copy((DEST), (PNT)); \
162 #define RTA_ATTR_GET(DEST, RTA, RTMADDRS, PNT) \
163 if ((RTMADDRS) & (RTA)) { \
164 int len = SAROUNDUP((PNT)); \
165 rta_copy((DEST), (PNT)); \
169 #define RTA_NAME_GET(DEST, RTA, RTMADDRS, PNT, LEN) \
170 if ((RTMADDRS) & (RTA)) { \
171 u_char *pdest = (u_char *)(DEST); \
172 int len = SAROUNDUP((PNT)); \
173 struct sockaddr_dl *sdl = (struct sockaddr_dl *)(PNT); \
174 if (IS_ZEBRA_DEBUG_KERNEL) \
175 zlog_debug("%s: RTA_SDL_GET nlen %d, alen %d", \
176 __func__, sdl->sdl_nlen, sdl->sdl_alen); \
177 if (((DEST) != NULL) && (sdl->sdl_family == AF_LINK) \
178 && (sdl->sdl_nlen < IFNAMSIZ) && (sdl->sdl_nlen <= len)) { \
179 memcpy(pdest, sdl->sdl_data, sdl->sdl_nlen); \
180 pdest[sdl->sdl_nlen] = '\0'; \
181 (LEN) = sdl->sdl_nlen; \
187 /* Routing socket message types. */
188 const struct message rtm_type_str
[] = {{RTM_ADD
, "RTM_ADD"},
189 {RTM_DELETE
, "RTM_DELETE"},
190 {RTM_CHANGE
, "RTM_CHANGE"},
191 {RTM_GET
, "RTM_GET"},
192 {RTM_LOSING
, "RTM_LOSING"},
193 {RTM_REDIRECT
, "RTM_REDIRECT"},
194 {RTM_MISS
, "RTM_MISS"},
195 {RTM_LOCK
, "RTM_LOCK"},
197 {RTM_OLDADD
, "RTM_OLDADD"},
198 #endif /* RTM_OLDADD */
200 {RTM_OLDDEL
, "RTM_OLDDEL"},
201 #endif /* RTM_OLDDEL */
202 {RTM_RESOLVE
, "RTM_RESOLVE"},
203 {RTM_NEWADDR
, "RTM_NEWADDR"},
204 {RTM_DELADDR
, "RTM_DELADDR"},
205 {RTM_IFINFO
, "RTM_IFINFO"},
207 {RTM_OIFINFO
, "RTM_OIFINFO"},
208 #endif /* RTM_OIFINFO */
210 {RTM_NEWMADDR
, "RTM_NEWMADDR"},
211 #endif /* RTM_NEWMADDR */
213 {RTM_DELMADDR
, "RTM_DELMADDR"},
214 #endif /* RTM_DELMADDR */
215 #ifdef RTM_IFANNOUNCE
216 {RTM_IFANNOUNCE
, "RTM_IFANNOUNCE"},
217 #endif /* RTM_IFANNOUNCE */
220 static const struct message rtm_flag_str
[] = {{RTF_UP
, "UP"},
221 {RTF_GATEWAY
, "GATEWAY"},
223 {RTF_REJECT
, "REJECT"},
224 {RTF_DYNAMIC
, "DYNAMIC"},
225 {RTF_MODIFIED
, "MODIFIED"},
229 #endif /* RTF_MASK */
231 {RTF_CLONING
, "CLONING"},
232 #endif /* RTF_CLONING */
234 {RTF_XRESOLVE
, "XRESOLVE"},
235 #endif /* RTF_XRESOLVE */
237 {RTF_LLINFO
, "LLINFO"},
238 #endif /* RTF_LLINFO */
239 {RTF_STATIC
, "STATIC"},
240 {RTF_BLACKHOLE
, "BLACKHOLE"},
242 {RTF_PRIVATE
, "PRIVATE"},
243 #endif /* RTF_PRIVATE */
244 {RTF_PROTO1
, "PROTO1"},
245 {RTF_PROTO2
, "PROTO2"},
247 {RTF_PRCLONING
, "PRCLONING"},
248 #endif /* RTF_PRCLONING */
250 {RTF_WASCLONED
, "WASCLONED"},
251 #endif /* RTF_WASCLONED */
253 {RTF_PROTO3
, "PROTO3"},
254 #endif /* RTF_PROTO3 */
256 {RTF_PINNED
, "PINNED"},
257 #endif /* RTF_PINNED */
259 {RTF_LOCAL
, "LOCAL"},
260 #endif /* RTF_LOCAL */
262 {RTF_BROADCAST
, "BROADCAST"},
263 #endif /* RTF_BROADCAST */
265 {RTF_MULTICAST
, "MULTICAST"},
266 #endif /* RTF_MULTICAST */
268 {RTF_MULTIRT
, "MULTIRT"},
269 #endif /* RTF_MULTIRT */
271 {RTF_SETSRC
, "SETSRC"},
272 #endif /* RTF_SETSRC */
275 /* Kernel routing update socket. */
276 int routing_sock
= -1;
278 /* Yes I'm checking ugly routing socket behavior. */
281 /* Supported address family check. */
282 static inline int af_check(int family
)
284 if (family
== AF_INET
)
286 if (family
== AF_INET6
)
291 /* Dump routing table flag for debug purpose. */
292 static void rtm_flag_dump(int flag
)
294 const struct message
*mes
;
295 static char buf
[BUFSIZ
];
298 for (mes
= rtm_flag_str
; mes
->key
!= 0; mes
++) {
299 if (mes
->key
& flag
) {
300 strlcat(buf
, mes
->str
, BUFSIZ
);
301 strlcat(buf
, " ", BUFSIZ
);
304 zlog_debug("Kernel: %s", buf
);
307 #ifdef RTM_IFANNOUNCE
308 /* Interface adding function */
309 static int ifan_read(struct if_announcemsghdr
*ifan
)
311 struct interface
*ifp
;
313 ifp
= if_lookup_by_index(ifan
->ifan_index
, VRF_DEFAULT
);
316 assert((ifp
->ifindex
== ifan
->ifan_index
)
317 || (ifp
->ifindex
== IFINDEX_INTERNAL
));
319 if ((ifp
== NULL
) || ((ifp
->ifindex
== IFINDEX_INTERNAL
)
320 && (ifan
->ifan_what
== IFAN_ARRIVAL
))) {
321 if (IS_ZEBRA_DEBUG_KERNEL
)
323 "%s: creating interface for ifindex %d, name %s",
324 __func__
, ifan
->ifan_index
, ifan
->ifan_name
);
326 /* Create Interface */
327 ifp
= if_get_by_name(ifan
->ifan_name
, VRF_DEFAULT
, 0);
328 if_set_index(ifp
, ifan
->ifan_index
);
332 } else if (ifp
!= NULL
&& ifan
->ifan_what
== IFAN_DEPARTURE
)
333 if_delete_update(ifp
);
339 if (IS_ZEBRA_DEBUG_KERNEL
)
340 zlog_debug("%s: interface %s index %d", __func__
,
341 ifan
->ifan_name
, ifan
->ifan_index
);
345 #endif /* RTM_IFANNOUNCE */
347 #ifdef HAVE_BSD_IFI_LINK_STATE
348 /* BSD link detect translation */
349 static void bsd_linkdetect_translate(struct if_msghdr
*ifm
)
351 if ((ifm
->ifm_data
.ifi_link_state
>= LINK_STATE_UP
)
352 || (ifm
->ifm_data
.ifi_link_state
== LINK_STATE_UNKNOWN
))
353 SET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
355 UNSET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
357 #endif /* HAVE_BSD_IFI_LINK_STATE */
359 static enum zebra_link_type
sdl_to_zebra_link_type(unsigned int sdlt
)
363 return ZEBRA_LLT_ETHER
;
365 return ZEBRA_LLT_X25
;
367 return ZEBRA_LLT_FDDI
;
369 return ZEBRA_LLT_PPP
;
371 return ZEBRA_LLT_LOOPBACK
;
373 return ZEBRA_LLT_SLIP
;
375 return ZEBRA_LLT_ARCNET
;
377 return ZEBRA_LLT_ATM
;
379 return ZEBRA_LLT_LOCALTLK
;
381 return ZEBRA_LLT_HIPPI
;
384 return ZEBRA_LLT_IEEE1394
;
388 return ZEBRA_LLT_UNKNOWN
;
393 * Handle struct if_msghdr obtained from reading routing socket or
394 * sysctl (from interface_list). There may or may not be sockaddrs
395 * present after the header.
397 int ifm_read(struct if_msghdr
*ifm
)
399 struct interface
*ifp
= NULL
;
400 struct sockaddr_dl
*sdl
;
401 char ifname
[IFNAMSIZ
];
405 /* terminate ifname at head (for strnlen) and tail (for safety) */
406 ifname
[IFNAMSIZ
- 1] = '\0';
408 /* paranoia: sanity check structure */
409 if (ifm
->ifm_msglen
< sizeof(struct if_msghdr
)) {
410 zlog_err("ifm_read: ifm->ifm_msglen %d too short\n",
416 * Check for a sockaddr_dl following the message. First, point to
417 * where a socakddr might be if one follows the message.
419 cp
= (void *)(ifm
+ 1);
423 * XXX This behavior should be narrowed to only the kernel versions
424 * for which the structures returned do not match the headers.
426 * if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
427 * is 12 bytes larger than the 32 bit version.
429 if (((struct sockaddr
*)cp
)->sa_family
== AF_UNSPEC
)
433 RTA_ADDR_GET(NULL
, RTA_DST
, ifm
->ifm_addrs
, cp
);
434 RTA_ADDR_GET(NULL
, RTA_GATEWAY
, ifm
->ifm_addrs
, cp
);
435 RTA_ATTR_GET(NULL
, RTA_NETMASK
, ifm
->ifm_addrs
, cp
);
436 RTA_ADDR_GET(NULL
, RTA_GENMASK
, ifm
->ifm_addrs
, cp
);
437 sdl
= (struct sockaddr_dl
*)cp
;
438 RTA_NAME_GET(ifname
, RTA_IFP
, ifm
->ifm_addrs
, cp
, ifnlen
);
439 RTA_ADDR_GET(NULL
, RTA_IFA
, ifm
->ifm_addrs
, cp
);
440 RTA_ADDR_GET(NULL
, RTA_AUTHOR
, ifm
->ifm_addrs
, cp
);
441 RTA_ADDR_GET(NULL
, RTA_BRD
, ifm
->ifm_addrs
, cp
);
443 RTA_ATTR_GET(NULL
, RTA_LABEL
, ifm
->ifm_addrs
, cp
);
446 RTA_ADDR_GET(NULL
, RTA_SRC
, ifm
->ifm_addrs
, cp
);
449 if (IS_ZEBRA_DEBUG_KERNEL
)
450 zlog_debug("%s: sdl ifname %s", __func__
,
451 (ifnlen
? ifname
: "(nil)"));
454 * Look up on ifindex first, because ifindices are the primary handle
456 * interfaces across the user/kernel boundary, for most systems. (Some
457 * messages, such as up/down status changes on NetBSD, do not include a
460 if ((ifp
= if_lookup_by_index(ifm
->ifm_index
, VRF_DEFAULT
)) != NULL
) {
461 /* we have an ifp, verify that the name matches as some systems,
462 * eg Solaris, have a 1:many association of ifindex:ifname
463 * if they dont match, we dont have the correct ifp and should
464 * set it back to NULL to let next check do lookup by name
466 if (ifnlen
&& (strncmp(ifp
->name
, ifname
, IFNAMSIZ
) != 0)) {
467 if (IS_ZEBRA_DEBUG_KERNEL
)
469 "%s: ifp name %s doesnt match sdl name %s",
470 __func__
, ifp
->name
, ifname
);
476 * If we dont have an ifp, try looking up by name. Particularly as some
477 * systems (Solaris) have a 1:many mapping of ifindex:ifname - the
479 * is therefore our unique handle to that interface.
481 * Interfaces specified in the configuration file for which the ifindex
482 * has not been determined will have ifindex == IFINDEX_INTERNAL, and
484 * interfaces are found by this search, and then their ifindex values
488 if ((ifp
== NULL
) && ifnlen
)
489 ifp
= if_lookup_by_name(ifname
, VRF_DEFAULT
);
492 * If ifp still does not exist or has an invalid index
493 * (IFINDEX_INTERNAL),
494 * create or fill in an interface.
496 if ((ifp
== NULL
) || (ifp
->ifindex
== IFINDEX_INTERNAL
)) {
498 * To create or fill in an interface, a sockaddr_dl (via
499 * RTA_IFP) is required.
502 zlog_warn("Interface index %d (new) missing ifname\n",
507 #ifndef RTM_IFANNOUNCE
508 /* Down->Down interface should be ignored here.
509 * See further comment below.
511 if (!CHECK_FLAG(ifm
->ifm_flags
, IFF_UP
))
513 #endif /* !RTM_IFANNOUNCE */
516 /* Interface that zebra was not previously aware of, so
518 ifp
= if_create(ifname
, VRF_DEFAULT
);
519 if (IS_ZEBRA_DEBUG_KERNEL
)
520 zlog_debug("%s: creating ifp for ifindex %d",
521 __func__
, ifm
->ifm_index
);
524 if (IS_ZEBRA_DEBUG_KERNEL
)
526 "%s: updated/created ifp, ifname %s, ifindex %d",
527 __func__
, ifp
->name
, ifp
->ifindex
);
529 * Fill in newly created interface structure, or larval
530 * structure with ifindex IFINDEX_INTERNAL.
532 if_set_index(ifp
, ifm
->ifm_index
);
534 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
535 bsd_linkdetect_translate(ifm
);
536 #endif /* HAVE_BSD_IFI_LINK_STATE */
538 if_flags_update(ifp
, ifm
->ifm_flags
);
539 #if defined(__bsdi__)
543 #endif /* __bsdi__ */
547 * XXX sockaddr_dl contents can be larger than the structure
548 * definition. There are 2 big families here:
549 * - BSD has sdl_len + sdl_data[16] + overruns sdl_data
550 * we MUST use sdl_len here or we'll truncate data.
551 * - Solaris has no sdl_len, but sdl_data[244]
552 * presumably, it's not going to run past that, so sizeof()
554 * a nonzero ifnlen from RTA_NAME_GET() means sdl is valid
556 ifp
->ll_type
= ZEBRA_LLT_UNKNOWN
;
557 ifp
->hw_addr_len
= 0;
559 #ifdef HAVE_STRUCT_SOCKADDR_DL_SDL_LEN
560 memcpy(&((struct zebra_if
*)ifp
->info
)->sdl
, sdl
,
563 memcpy(&((struct zebra_if
*)ifp
->info
)->sdl
, sdl
,
564 sizeof(struct sockaddr_dl
));
565 #endif /* HAVE_STRUCT_SOCKADDR_DL_SDL_LEN */
567 ifp
->ll_type
= sdl_to_zebra_link_type(sdl
->sdl_type
);
568 if (sdl
->sdl_alen
<= sizeof(ifp
->hw_addr
)) {
569 memcpy(ifp
->hw_addr
, LLADDR(sdl
),
571 ifp
->hw_addr_len
= sdl
->sdl_alen
;
578 * Interface structure exists. Adjust stored flags from
579 * notification. If interface has up->down or down->up
580 * transition, call state change routines (to adjust routes,
581 * notify routing daemons, etc.). (Other flag changes are stored
582 * but apparently do not trigger action.)
585 if (ifp
->ifindex
!= ifm
->ifm_index
) {
587 "%s: index mismatch, ifname %s, ifp index %d, "
589 __func__
, ifp
->name
, ifp
->ifindex
,
594 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
595 bsd_linkdetect_translate(ifm
);
596 #endif /* HAVE_BSD_IFI_LINK_STATE */
598 /* update flags and handle operative->inoperative transition, if
600 if_flags_update(ifp
, ifm
->ifm_flags
);
602 #ifndef RTM_IFANNOUNCE
603 if (!if_is_up(ifp
)) {
604 /* No RTM_IFANNOUNCE on this platform, so we can never
605 * distinguish between ~IFF_UP and delete. We must
607 * it has been deleted.
608 * Eg, Solaris will not notify us of unplumb.
610 * XXX: Fixme - this should be runtime detected
611 * So that a binary compiled on a system with IFANNOUNCE
612 * will still behave correctly if run on a platform
615 if_delete_update(ifp
);
617 #endif /* RTM_IFANNOUNCE */
619 #if defined(__bsdi__)
623 #endif /* __bsdi__ */
628 #ifdef HAVE_NET_RT_IFLIST
629 ifp
->stats
= ifm
->ifm_data
;
630 #endif /* HAVE_NET_RT_IFLIST */
631 ifp
->speed
= ifm
->ifm_data
.ifi_baudrate
/ 1000000;
633 if (IS_ZEBRA_DEBUG_KERNEL
)
634 zlog_debug("%s: interface %s index %d", __func__
, ifp
->name
,
640 /* Address read from struct ifa_msghdr. */
641 static void ifam_read_mesg(struct ifa_msghdr
*ifm
, union sockunion
*addr
,
642 union sockunion
*mask
, union sockunion
*brd
,
643 char *ifname
, short *ifnlen
)
647 union sockunion gateway
;
649 pnt
= (caddr_t
)(ifm
+ 1);
650 end
= ((caddr_t
)ifm
) + ifm
->ifam_msglen
;
652 /* Be sure structure is cleared */
653 memset(mask
, 0, sizeof(union sockunion
));
654 memset(addr
, 0, sizeof(union sockunion
));
655 memset(brd
, 0, sizeof(union sockunion
));
656 memset(&dst
, 0, sizeof(union sockunion
));
657 memset(&gateway
, 0, sizeof(union sockunion
));
659 /* We fetch each socket variable into sockunion. */
660 RTA_ADDR_GET(&dst
, RTA_DST
, ifm
->ifam_addrs
, pnt
);
661 RTA_ADDR_GET(&gateway
, RTA_GATEWAY
, ifm
->ifam_addrs
, pnt
);
662 RTA_ATTR_GET(mask
, RTA_NETMASK
, ifm
->ifam_addrs
, pnt
);
663 RTA_ADDR_GET(NULL
, RTA_GENMASK
, ifm
->ifam_addrs
, pnt
);
664 RTA_NAME_GET(ifname
, RTA_IFP
, ifm
->ifam_addrs
, pnt
, *ifnlen
);
665 RTA_ADDR_GET(addr
, RTA_IFA
, ifm
->ifam_addrs
, pnt
);
666 RTA_ADDR_GET(NULL
, RTA_AUTHOR
, ifm
->ifam_addrs
, pnt
);
667 RTA_ADDR_GET(brd
, RTA_BRD
, ifm
->ifam_addrs
, pnt
);
669 RTA_ATTR_GET(NULL
, RTA_LABEL
, ifm
->ifam_addrs
, pnt
);
672 RTA_ADDR_GET(NULL
, RTA_SRC
, ifm
->ifam_addrs
, pnt
);
675 if (IS_ZEBRA_DEBUG_KERNEL
) {
676 int family
= sockunion_family(addr
);
680 char buf
[4][INET6_ADDRSTRLEN
];
682 "%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
683 "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
685 __func__
, ifm
->ifam_index
,
686 (ifnlen
? ifname
: "(nil)"), ifm
->ifam_addrs
,
688 inet_ntop(family
, &addr
->sin
.sin_addr
, buf
[0],
690 ip_masklen(mask
->sin
.sin_addr
),
691 inet_ntop(family
, &brd
->sin
.sin_addr
, buf
[1],
693 inet_ntop(family
, &dst
.sin
.sin_addr
, buf
[2],
695 inet_ntop(family
, &gateway
.sin
.sin_addr
, buf
[3],
699 zlog_debug("%s: ifindex %d, ifname %s, ifam_addrs 0x%x",
700 __func__
, ifm
->ifam_index
,
701 (ifnlen
? ifname
: "(nil)"),
707 /* Assert read up end point matches to end point */
709 zlog_warn("ifam_read() doesn't read all socket data");
712 /* Interface's address information get. */
713 int ifam_read(struct ifa_msghdr
*ifam
)
715 struct interface
*ifp
= NULL
;
716 union sockunion addr
, mask
, brd
;
717 char ifname
[INTERFACE_NAMSIZ
];
722 ifname
[0] = ifname
[INTERFACE_NAMSIZ
- 1] = '\0';
724 /* Allocate and read address information. */
725 ifam_read_mesg(ifam
, &addr
, &mask
, &brd
, ifname
, &ifnlen
);
727 if ((ifp
= if_lookup_by_index(ifam
->ifam_index
, VRF_DEFAULT
)) == NULL
) {
728 zlog_warn("%s: no interface for ifname %s, index %d", __func__
,
729 ifname
, ifam
->ifam_index
);
733 if (ifnlen
&& strncmp(ifp
->name
, ifname
, INTERFACE_NAMSIZ
))
736 /* N.B. The info in ifa_msghdr does not tell us whether the RTA_BRD
737 field contains a broadcast address or a peer address, so we are
739 rely upon the interface type. */
740 if (if_is_pointopoint(ifp
))
741 SET_FLAG(flags
, ZEBRA_IFA_PEER
);
744 /* it might seem cute to grab the interface metric here, however
745 * we're processing an address update message, and so some systems
746 * (e.g. FBSD) dont bother to fill in ifam_metric. Disabled, but left
747 * in deliberately, as comment.
749 ifp
->metric
= ifam
->ifam_metric
;
752 /* Add connected address. */
753 switch (sockunion_family(&addr
)) {
755 if (ifam
->ifam_type
== RTM_NEWADDR
)
756 connected_add_ipv4(ifp
, flags
, &addr
.sin
.sin_addr
,
757 ip_masklen(mask
.sin
.sin_addr
),
759 (isalias
? ifname
: NULL
));
761 connected_delete_ipv4(ifp
, flags
, &addr
.sin
.sin_addr
,
762 ip_masklen(mask
.sin
.sin_addr
),
766 /* Unset interface index from link-local address when IPv6 stack
768 if (IN6_IS_ADDR_LINKLOCAL(&addr
.sin6
.sin6_addr
)) {
769 SET_IN6_LINKLOCAL_IFINDEX(addr
.sin6
.sin6_addr
, 0);
772 if (ifam
->ifam_type
== RTM_NEWADDR
)
773 connected_add_ipv6(ifp
, flags
, &addr
.sin6
.sin6_addr
,
774 ip6_masklen(mask
.sin6
.sin6_addr
),
775 (isalias
? ifname
: NULL
));
777 connected_delete_ipv6(ifp
, &addr
.sin6
.sin6_addr
,
778 ip6_masklen(mask
.sin6
.sin6_addr
));
781 /* Unsupported family silently ignore... */
785 /* Check interface flag for implicit up of the interface. */
789 /* In addition to lacking IFANNOUNCE, on SUNOS IFF_UP is strange.
790 * See comments for SUNOS_5 in interface.c::if_flags_mangle.
792 * Here we take care of case where the real IFF_UP was previously
793 * unset (as kept in struct zebra_if.primary_state) and the mangled
794 * IFF_UP (ie IFF_UP set || listcount(connected) has now transitioned
795 * to unset due to the lost non-primary address having DELADDR'd.
797 * we must delete the interface, because in between here and next
798 * event for this interface-name the administrator could unplumb
799 * and replumb the interface.
802 if_delete_update(ifp
);
808 /* Interface function for reading kernel routing table information. */
809 static int rtm_read_mesg(struct rt_msghdr
*rtm
, union sockunion
*dest
,
810 union sockunion
*mask
, union sockunion
*gate
,
811 char *ifname
, short *ifnlen
)
815 /* Pnt points out socket data start point. */
816 pnt
= (caddr_t
)(rtm
+ 1);
817 end
= ((caddr_t
)rtm
) + rtm
->rtm_msglen
;
819 /* rt_msghdr version check. */
820 if (rtm
->rtm_version
!= RTM_VERSION
)
822 "Routing message version different %d should be %d."
823 "This may cause problem\n",
824 rtm
->rtm_version
, RTM_VERSION
);
826 /* Be sure structure is cleared */
827 memset(dest
, 0, sizeof(union sockunion
));
828 memset(gate
, 0, sizeof(union sockunion
));
829 memset(mask
, 0, sizeof(union sockunion
));
831 /* We fetch each socket variable into sockunion. */
832 RTA_ADDR_GET(dest
, RTA_DST
, rtm
->rtm_addrs
, pnt
);
833 RTA_ADDR_GET(gate
, RTA_GATEWAY
, rtm
->rtm_addrs
, pnt
);
834 RTA_ATTR_GET(mask
, RTA_NETMASK
, rtm
->rtm_addrs
, pnt
);
835 RTA_ADDR_GET(NULL
, RTA_GENMASK
, rtm
->rtm_addrs
, pnt
);
836 RTA_NAME_GET(ifname
, RTA_IFP
, rtm
->rtm_addrs
, pnt
, *ifnlen
);
837 RTA_ADDR_GET(NULL
, RTA_IFA
, rtm
->rtm_addrs
, pnt
);
838 RTA_ADDR_GET(NULL
, RTA_AUTHOR
, rtm
->rtm_addrs
, pnt
);
839 RTA_ADDR_GET(NULL
, RTA_BRD
, rtm
->rtm_addrs
, pnt
);
842 union sockunion label
;
843 memset(&label
, 0, sizeof(label
));
844 RTA_ATTR_GET(&label
, RTA_LABEL
, rtm
->rtm_addrs
, pnt
);
846 RTA_ATTR_GET(NULL
, RTA_LABEL
, rtm
->rtm_addrs
, pnt
);
849 RTA_ADDR_GET(NULL
, RTA_SRC
, rtm
->rtm_addrs
, pnt
);
852 /* If there is netmask information set it's family same as
854 if (rtm
->rtm_addrs
& RTA_NETMASK
)
855 mask
->sa
.sa_family
= dest
->sa
.sa_family
;
857 /* Assert read up to the end of pointer. */
859 zlog_warn("rtm_read() doesn't read all socket data.");
861 return rtm
->rtm_flags
;
864 void rtm_read(struct rt_msghdr
*rtm
)
868 union sockunion dest
, mask
, gate
;
869 char ifname
[INTERFACE_NAMSIZ
+ 1];
875 /* Read destination and netmask and gateway from rtm message
877 flags
= rtm_read_mesg(rtm
, &dest
, &mask
, &gate
, ifname
, &ifnlen
);
878 if (!(flags
& RTF_DONE
))
880 if (IS_ZEBRA_DEBUG_KERNEL
)
881 zlog_debug("%s: got rtm of type %d (%s)", __func__
,
883 lookup_msg(rtm_type_str
, rtm
->rtm_type
, NULL
));
885 #ifdef RTF_CLONED /*bsdi, netbsd 1.6*/
886 if (flags
& RTF_CLONED
)
889 #ifdef RTF_WASCLONED /*freebsd*/
890 if (flags
& RTF_WASCLONED
)
894 if ((rtm
->rtm_type
== RTM_ADD
|| rtm
->rtm_type
== RTM_CHANGE
)
895 && !(flags
& RTF_UP
))
898 /* This is connected route. */
899 if (!(flags
& RTF_GATEWAY
))
902 if (flags
& RTF_PROTO1
)
903 SET_FLAG(zebra_flags
, ZEBRA_FLAG_SELFROUTE
);
905 /* This is persistent route. */
906 if (flags
& RTF_STATIC
)
907 SET_FLAG(zebra_flags
, ZEBRA_FLAG_STATIC
);
909 memset(&nh
, 0, sizeof(nh
));
911 nh
.vrf_id
= VRF_DEFAULT
;
912 /* This is a reject or blackhole route */
913 if (flags
& RTF_REJECT
) {
914 nh
.type
= NEXTHOP_TYPE_BLACKHOLE
;
915 nh
.bh_type
= BLACKHOLE_REJECT
;
916 } else if (flags
& RTF_BLACKHOLE
) {
917 nh
.type
= NEXTHOP_TYPE_BLACKHOLE
;
918 nh
.bh_type
= BLACKHOLE_NULL
;
921 if (dest
.sa
.sa_family
== AF_INET
) {
925 p
.u
.prefix4
= dest
.sin
.sin_addr
;
926 if (flags
& RTF_HOST
)
927 p
.prefixlen
= IPV4_MAX_PREFIXLEN
;
929 p
.prefixlen
= ip_masklen(mask
.sin
.sin_addr
);
931 /* Catch self originated messages and match them against our
933 * At the same time, ignore unconfirmed messages, they should be
935 * by rtm_write() and kernel_rtm_ipv4().
937 if (rtm
->rtm_type
!= RTM_GET
&& rtm
->rtm_pid
== pid
) {
938 char buf
[PREFIX_STRLEN
], gate_buf
[INET_ADDRSTRLEN
];
940 if (!IS_ZEBRA_DEBUG_RIB
)
942 ret
= rib_lookup_ipv4_route((struct prefix_ipv4
*)&p
,
944 prefix2str(&p
, buf
, sizeof(buf
));
945 switch (rtm
->rtm_type
) {
949 /* The kernel notifies us about a new route in
951 Do we have a correspondent entry in our RIB?
954 case ZEBRA_RIB_NOTFOUND
:
956 "%s: %s %s: desync: RR isn't yet in RIB, while already in FIB",
958 lookup_msg(rtm_type_str
,
959 rtm
->rtm_type
, NULL
),
962 case ZEBRA_RIB_FOUND_CONNECTED
:
963 case ZEBRA_RIB_FOUND_NOGATE
:
964 inet_ntop(AF_INET
, &gate
.sin
.sin_addr
,
965 gate_buf
, INET_ADDRSTRLEN
);
967 "%s: %s %s: desync: RR is in RIB, but gate differs (ours is %s)",
969 lookup_msg(rtm_type_str
,
970 rtm
->rtm_type
, NULL
),
973 case ZEBRA_RIB_FOUND_EXACT
: /* RIB RR == FIB RR
976 "%s: %s %s: done Ok", __func__
,
977 lookup_msg(rtm_type_str
,
978 rtm
->rtm_type
, NULL
),
981 (struct prefix_ipv4
*)&p
,
988 /* The kernel notifies us about a route deleted
990 have it in the RIB? Do we have anything
993 case ZEBRA_RIB_FOUND_EXACT
:
995 "%s: %s %s: desync: RR is still in RIB, while already not in FIB",
997 lookup_msg(rtm_type_str
,
998 rtm
->rtm_type
, NULL
),
1000 rib_lookup_and_dump(
1001 (struct prefix_ipv4
*)&p
,
1004 case ZEBRA_RIB_FOUND_CONNECTED
:
1005 case ZEBRA_RIB_FOUND_NOGATE
:
1007 "%s: %s %s: desync: RR is still in RIB, plus gate differs",
1009 lookup_msg(rtm_type_str
,
1010 rtm
->rtm_type
, NULL
),
1012 rib_lookup_and_dump(
1013 (struct prefix_ipv4
*)&p
,
1016 case ZEBRA_RIB_NOTFOUND
: /* RIB RR == FIB RR */
1018 "%s: %s %s: done Ok", __func__
,
1019 lookup_msg(rtm_type_str
,
1020 rtm
->rtm_type
, NULL
),
1022 rib_lookup_and_dump(
1023 (struct prefix_ipv4
*)&p
,
1031 "%s: %s: warning: loopback RTM of type %s received",
1033 lookup_msg(rtm_type_str
, rtm
->rtm_type
,
1039 /* Change, delete the old prefix, we have no further information
1040 * to specify the route really
1042 if (rtm
->rtm_type
== RTM_CHANGE
)
1043 rib_delete(AFI_IP
, SAFI_UNICAST
, VRF_DEFAULT
,
1044 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1045 NULL
, 0, 0, true, NULL
);
1048 nh
.type
= NEXTHOP_TYPE_IPV4
;
1049 nh
.gate
.ipv4
= gate
.sin
.sin_addr
;
1052 if (rtm
->rtm_type
== RTM_GET
|| rtm
->rtm_type
== RTM_ADD
1053 || rtm
->rtm_type
== RTM_CHANGE
)
1054 rib_add(AFI_IP
, SAFI_UNICAST
, VRF_DEFAULT
,
1055 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1056 &nh
, 0, 0, 0, 0, 0);
1058 rib_delete(AFI_IP
, SAFI_UNICAST
, VRF_DEFAULT
,
1059 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1060 &nh
, 0, 0, true, NULL
);
1062 if (dest
.sa
.sa_family
== AF_INET6
) {
1063 /* One day we might have a debug section here like one in the
1064 * IPv4 case above. Just ignore own messages at the moment.
1066 if (rtm
->rtm_type
!= RTM_GET
&& rtm
->rtm_pid
== pid
)
1069 ifindex_t ifindex
= 0;
1071 p
.family
= AF_INET6
;
1072 p
.u
.prefix6
= dest
.sin6
.sin6_addr
;
1073 if (flags
& RTF_HOST
)
1074 p
.prefixlen
= IPV6_MAX_PREFIXLEN
;
1076 p
.prefixlen
= ip6_masklen(mask
.sin6
.sin6_addr
);
1079 if (IN6_IS_ADDR_LINKLOCAL(&gate
.sin6
.sin6_addr
)) {
1080 ifindex
= IN6_LINKLOCAL_IFINDEX(gate
.sin6
.sin6_addr
);
1081 SET_IN6_LINKLOCAL_IFINDEX(gate
.sin6
.sin6_addr
, 0);
1085 /* CHANGE: delete the old prefix, we have no further information
1086 * to specify the route really
1088 if (rtm
->rtm_type
== RTM_CHANGE
)
1089 rib_delete(AFI_IP6
, SAFI_UNICAST
, VRF_DEFAULT
,
1090 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1091 NULL
, 0, 0, true, NULL
);
1094 nh
.type
= ifindex
? NEXTHOP_TYPE_IPV6_IFINDEX
1095 : NEXTHOP_TYPE_IPV6
;
1096 nh
.gate
.ipv6
= gate
.sin6
.sin6_addr
;
1097 nh
.ifindex
= ifindex
;
1100 if (rtm
->rtm_type
== RTM_GET
|| rtm
->rtm_type
== RTM_ADD
1101 || rtm
->rtm_type
== RTM_CHANGE
)
1102 rib_add(AFI_IP6
, SAFI_UNICAST
, VRF_DEFAULT
,
1103 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1104 &nh
, 0, 0, 0, 0, 0);
1106 rib_delete(AFI_IP6
, SAFI_UNICAST
, VRF_DEFAULT
,
1107 ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
, NULL
,
1108 &nh
, 0, 0, true, NULL
);
1112 /* Interface function for the kernel routing table updates. Support
1113 * for RTM_CHANGE will be needed.
1114 * Exported only for rt_socket.c
1116 int rtm_write(int message
, union sockunion
*dest
, union sockunion
*mask
,
1117 union sockunion
*gate
, union sockunion
*mpls
, unsigned int index
,
1118 enum blackhole_type bh_type
, int metric
)
1122 struct interface
*ifp
;
1124 /* Sequencial number of routing message. */
1125 static int msg_seq
= 0;
1127 /* Struct of rt_msghdr and buffer for storing socket's data. */
1129 struct rt_msghdr rtm
;
1133 if (routing_sock
< 0)
1134 return ZEBRA_ERR_EPERM
;
1136 /* Clear and set rt_msghdr values */
1137 memset(&msg
, 0, sizeof(struct rt_msghdr
));
1138 msg
.rtm
.rtm_version
= RTM_VERSION
;
1139 msg
.rtm
.rtm_type
= message
;
1140 msg
.rtm
.rtm_seq
= msg_seq
++;
1141 msg
.rtm
.rtm_addrs
= RTA_DST
;
1142 msg
.rtm
.rtm_addrs
|= RTA_GATEWAY
;
1143 msg
.rtm
.rtm_flags
= RTF_UP
;
1145 msg
.rtm
.rtm_flags
|= RTF_MPATH
;
1146 msg
.rtm
.rtm_fmask
= RTF_MPLS
;
1148 msg
.rtm
.rtm_index
= index
;
1151 msg
.rtm
.rtm_rmx
.rmx_hopcount
= metric
;
1152 msg
.rtm
.rtm_inits
|= RTV_HOPCOUNT
;
1155 ifp
= if_lookup_by_index(index
, VRF_DEFAULT
);
1157 if (gate
&& (message
== RTM_ADD
|| message
== RTM_CHANGE
))
1158 msg
.rtm
.rtm_flags
|= RTF_GATEWAY
;
1160 /* When RTF_CLONING is unavailable on BSD, should we set some
1161 * other flag instead?
1164 if (!gate
&& (message
== RTM_ADD
|| message
== RTM_CHANGE
) && ifp
1165 && (ifp
->flags
& IFF_POINTOPOINT
) == 0)
1166 msg
.rtm
.rtm_flags
|= RTF_CLONING
;
1167 #endif /* RTF_CLONING */
1169 /* If no protocol specific gateway is specified, use link
1170 address for gateway. */
1173 char dest_buf
[INET_ADDRSTRLEN
] = "NULL",
1174 mask_buf
[INET_ADDRSTRLEN
] = "255.255.255.255";
1176 inet_ntop(AF_INET
, &dest
->sin
.sin_addr
,
1177 dest_buf
, INET_ADDRSTRLEN
);
1179 inet_ntop(AF_INET
, &mask
->sin
.sin_addr
,
1180 mask_buf
, INET_ADDRSTRLEN
);
1182 "%s: %s/%s: gate == NULL and no gateway found for ifindex %d",
1183 __func__
, dest_buf
, mask_buf
, index
);
1186 gate
= (union sockunion
*)&((struct zebra_if
*)ifp
->info
)->sdl
;
1190 msg
.rtm
.rtm_addrs
|= RTA_NETMASK
;
1191 else if (message
== RTM_ADD
|| message
== RTM_CHANGE
)
1192 msg
.rtm
.rtm_flags
|= RTF_HOST
;
1196 msg
.rtm
.rtm_addrs
|= RTA_SRC
;
1197 msg
.rtm
.rtm_flags
|= RTF_MPLS
;
1199 if (mpls
->smpls
.smpls_label
1200 != htonl(MPLS_LABEL_IMPLICIT_NULL
<< MPLS_LABEL_OFFSET
))
1201 msg
.rtm
.rtm_mpls
= MPLS_OP_PUSH
;
1205 /* Tagging route with flags */
1206 msg
.rtm
.rtm_flags
|= (RTF_PROTO1
);
1209 case BLACKHOLE_UNSPEC
:
1211 case BLACKHOLE_REJECT
:
1212 msg
.rtm
.rtm_flags
|= RTF_REJECT
;
1215 msg
.rtm
.rtm_flags
|= RTF_BLACKHOLE
;
1220 #define SOCKADDRSET(X, R) \
1221 if (msg.rtm.rtm_addrs & (R)) { \
1222 int len = SAROUNDUP(X); \
1223 memcpy(pnt, (caddr_t)(X), len); \
1227 pnt
= (caddr_t
)msg
.buf
;
1229 /* Write each socket data into rtm message buffer */
1230 SOCKADDRSET(dest
, RTA_DST
);
1231 SOCKADDRSET(gate
, RTA_GATEWAY
);
1232 SOCKADDRSET(mask
, RTA_NETMASK
);
1234 SOCKADDRSET(mpls
, RTA_SRC
);
1237 msg
.rtm
.rtm_msglen
= pnt
- (caddr_t
)&msg
;
1239 ret
= write(routing_sock
, &msg
, msg
.rtm
.rtm_msglen
);
1241 if (ret
!= msg
.rtm
.rtm_msglen
) {
1242 if (errno
== EEXIST
)
1243 return ZEBRA_ERR_RTEXIST
;
1244 if (errno
== ENETUNREACH
)
1245 return ZEBRA_ERR_RTUNREACH
;
1247 return ZEBRA_ERR_RTNOEXIST
;
1249 zlog_warn("%s: write : %s (%d)", __func__
, safe_strerror(errno
),
1251 return ZEBRA_ERR_KERNEL
;
1253 return ZEBRA_ERR_NOERROR
;
1258 #include "zebra/zserv.h"
1260 /* For debug purpose. */
1261 static void rtmsg_debug(struct rt_msghdr
*rtm
)
1263 zlog_debug("Kernel: Len: %d Type: %s", rtm
->rtm_msglen
,
1264 lookup_msg(rtm_type_str
, rtm
->rtm_type
, NULL
));
1265 rtm_flag_dump(rtm
->rtm_flags
);
1266 zlog_debug("Kernel: message seq %d", rtm
->rtm_seq
);
1267 zlog_debug("Kernel: pid %lld, rtm_addrs 0x%x", (long long)rtm
->rtm_pid
,
1271 /* This is pretty gross, better suggestions welcome -- mhandler */
1274 #define RTAX_MAX RTA_NUMBITS
1277 #endif /* RTA_NUMBITS */
1278 #endif /* RTAX_MAX */
1280 /* Kernel routing table and interface updates via routing socket. */
1281 static int kernel_read(struct thread
*thread
)
1285 struct rt_msghdr
*rtm
;
1288 * This must be big enough for any message the kernel might send.
1289 * Rather than determining how many sockaddrs of what size might be
1290 * in each particular message, just use RTAX_MAX of sockaddr_storage
1291 * for each. Note that the sockaddrs must be after each message
1292 * definition, or rather after whichever happens to be the largest,
1293 * since the buffer needs to be big enough for a message and the
1294 * sockaddrs together.
1297 /* Routing information. */
1299 struct rt_msghdr rtm
;
1300 struct sockaddr_storage addr
[RTAX_MAX
];
1303 /* Interface information. */
1305 struct if_msghdr ifm
;
1306 struct sockaddr_storage addr
[RTAX_MAX
];
1309 /* Interface address information. */
1311 struct ifa_msghdr ifa
;
1312 struct sockaddr_storage addr
[RTAX_MAX
];
1315 #ifdef RTM_IFANNOUNCE
1316 /* Interface arrival/departure */
1318 struct if_announcemsghdr ifan
;
1319 struct sockaddr_storage addr
[RTAX_MAX
];
1321 #endif /* RTM_IFANNOUNCE */
1325 /* Fetch routing socket. */
1326 sock
= THREAD_FD(thread
);
1328 nbytes
= read(sock
, &buf
, sizeof buf
);
1331 if (nbytes
< 0 && errno
!= EWOULDBLOCK
&& errno
!= EAGAIN
)
1332 zlog_warn("routing socket error: %s",
1333 safe_strerror(errno
));
1337 thread_add_read(zebrad
.master
, kernel_read
, NULL
, sock
, NULL
);
1339 if (IS_ZEBRA_DEBUG_KERNEL
)
1340 rtmsg_debug(&buf
.r
.rtm
);
1345 * Ensure that we didn't drop any data, so that processing routines
1346 * can assume they have the whole message.
1348 if (rtm
->rtm_msglen
!= nbytes
) {
1350 "kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d\n",
1351 rtm
->rtm_msglen
, nbytes
, rtm
->rtm_type
);
1355 switch (rtm
->rtm_type
) {
1362 ifm_read(&buf
.im
.ifm
);
1366 ifam_read(&buf
.ia
.ifa
);
1368 #ifdef RTM_IFANNOUNCE
1369 case RTM_IFANNOUNCE
:
1370 ifan_read(&buf
.ian
.ifan
);
1372 #endif /* RTM_IFANNOUNCE */
1374 if (IS_ZEBRA_DEBUG_KERNEL
)
1375 zlog_debug("Unprocessed RTM_type: %d", rtm
->rtm_type
);
1381 /* Make routing socket. */
1382 static void routing_socket(struct zebra_ns
*zns
)
1384 if (zserv_privs
.change(ZPRIVS_RAISE
))
1385 zlog_err("routing_socket: Can't raise privileges");
1388 ns_socket(AF_ROUTE
, SOCK_RAW
, 0, (ns_id_t
)zns
->ns
->ns_id
);
1390 if (routing_sock
< 0) {
1391 if (zserv_privs
.change(ZPRIVS_LOWER
))
1392 zlog_err("routing_socket: Can't lower privileges");
1393 zlog_warn("Can't init kernel routing socket");
1397 /* XXX: Socket should be NONBLOCK, however as we currently
1398 * discard failed writes, this will lead to inconsistencies.
1399 * For now, socket must be blocking.
1401 /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
1402 zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
1404 if (zserv_privs
.change(ZPRIVS_LOWER
))
1405 zlog_err("routing_socket: Can't lower privileges");
1407 /* kernel_read needs rewrite. */
1408 thread_add_read(zebrad
.master
, kernel_read
, NULL
, routing_sock
, NULL
);
1411 /* Exported interface function. This function simply calls
1412 routing_socket (). */
1413 void kernel_init(struct zebra_ns
*zns
)
1415 routing_socket(zns
);
1418 void kernel_terminate(struct zebra_ns
*zns
)
1423 #endif /* !HAVE_NETLINK */