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
17 * along with GNU Zebra; see the file COPYING. If not, write to the Free
18 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include "sockunion.h"
27 #include "connected.h"
37 #include "zebra/interface.h"
38 #include "zebra/zserv.h"
39 #include "zebra/debug.h"
40 #include "zebra/kernel_socket.h"
41 #include "zebra/rib.h"
43 extern struct zebra_privs_t zserv_privs
;
44 extern struct zebra_t zebrad
;
47 * Given a sockaddr length, round it up to include pad bytes following
48 * it. Assumes the kernel pads to sizeof(long).
50 * XXX: why is ROUNDUP(0) sizeof(long)? 0 is an illegal sockaddr
51 * length anyway (< sizeof (struct sockaddr)), so this shouldn't
53 * On OS X, both 32, 64bit syatems align on 4 byte boundary
57 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(int) - 1))) : sizeof(int))
60 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
64 * Given a pointer (sockaddr or void *), return the number of bytes
65 * taken up by the sockaddr and any padding needed for alignment.
67 #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN)
68 #define SAROUNDUP(X) ROUNDUP(((struct sockaddr *)(X))->sa_len)
69 #elif defined(HAVE_IPV6)
71 * One would hope all fixed-size structure definitions are aligned,
72 * but round them up nonetheless.
74 #define SAROUNDUP(X) \
75 (((struct sockaddr *)(X))->sa_family == AF_INET ? \
76 ROUNDUP(sizeof(struct sockaddr_in)):\
77 (((struct sockaddr *)(X))->sa_family == AF_INET6 ? \
78 ROUNDUP(sizeof(struct sockaddr_in6)) : \
79 (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
80 ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr))))
82 #define SAROUNDUP(X) \
83 (((struct sockaddr *)(X))->sa_family == AF_INET ? \
84 ROUNDUP(sizeof(struct sockaddr_in)):\
85 (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
86 ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr)))
87 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
90 * We use a call to an inline function to copy (PNT) to (DEST)
91 * 1. Calculating the length of the copy requires an #ifdef to determine
92 * if sa_len is a field and can't be used directly inside a #define
93 * 2. So the compiler doesn't complain when DEST is NULL, which is only true
94 * when we are skipping the copy and incrementing to the next SA
97 rta_copy (union sockunion
*dest
, caddr_t src
) {
99 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
100 len
= (((struct sockaddr
*)src
)->sa_len
> sizeof (*dest
)) ?
101 sizeof (*dest
) : ((struct sockaddr
*)src
)->sa_len
;
103 len
= (SAROUNDUP (src
) > sizeof (*dest
)) ?
104 sizeof (*dest
) : SAROUNDUP (src
) ;
106 memcpy (dest
, src
, len
);
109 #define RTA_ADDR_GET(DEST, RTA, RTMADDRS, PNT) \
110 if ((RTMADDRS) & (RTA)) \
112 int len = SAROUNDUP ((PNT)); \
113 if ( ((DEST) != NULL) && \
114 af_check (((struct sockaddr *)(PNT))->sa_family)) \
115 rta_copy((DEST), (PNT)); \
118 #define RTA_ATTR_GET(DEST, RTA, RTMADDRS, PNT) \
119 if ((RTMADDRS) & (RTA)) \
121 int len = SAROUNDUP ((PNT)); \
122 if ((DEST) != NULL) \
123 rta_copy((DEST), (PNT)); \
127 #define RTA_NAME_GET(DEST, RTA, RTMADDRS, PNT, LEN) \
128 if ((RTMADDRS) & (RTA)) \
130 u_char *pdest = (u_char *) (DEST); \
131 int len = SAROUNDUP ((PNT)); \
132 struct sockaddr_dl *sdl = (struct sockaddr_dl *)(PNT); \
133 if (IS_ZEBRA_DEBUG_KERNEL) \
134 zlog_debug ("%s: RTA_SDL_GET nlen %d, alen %d", \
135 __func__, sdl->sdl_nlen, sdl->sdl_alen); \
136 if ( ((DEST) != NULL) && (sdl->sdl_family == AF_LINK) \
137 && (sdl->sdl_nlen < IFNAMSIZ) && (sdl->sdl_nlen <= len) ) \
139 memcpy (pdest, sdl->sdl_data, sdl->sdl_nlen); \
140 pdest[sdl->sdl_nlen] = '\0'; \
141 (LEN) = sdl->sdl_nlen; \
149 /* Routing socket message types. */
150 const struct message rtm_type_str
[] =
152 {RTM_ADD
, "RTM_ADD"},
153 {RTM_DELETE
, "RTM_DELETE"},
154 {RTM_CHANGE
, "RTM_CHANGE"},
155 {RTM_GET
, "RTM_GET"},
156 {RTM_LOSING
, "RTM_LOSING"},
157 {RTM_REDIRECT
, "RTM_REDIRECT"},
158 {RTM_MISS
, "RTM_MISS"},
159 {RTM_LOCK
, "RTM_LOCK"},
161 {RTM_OLDADD
, "RTM_OLDADD"},
162 #endif /* RTM_OLDADD */
164 {RTM_OLDDEL
, "RTM_OLDDEL"},
165 #endif /* RTM_OLDDEL */
166 {RTM_RESOLVE
, "RTM_RESOLVE"},
167 {RTM_NEWADDR
, "RTM_NEWADDR"},
168 {RTM_DELADDR
, "RTM_DELADDR"},
169 {RTM_IFINFO
, "RTM_IFINFO"},
171 {RTM_OIFINFO
, "RTM_OIFINFO"},
172 #endif /* RTM_OIFINFO */
174 {RTM_NEWMADDR
, "RTM_NEWMADDR"},
175 #endif /* RTM_NEWMADDR */
177 {RTM_DELMADDR
, "RTM_DELMADDR"},
178 #endif /* RTM_DELMADDR */
179 #ifdef RTM_IFANNOUNCE
180 {RTM_IFANNOUNCE
, "RTM_IFANNOUNCE"},
181 #endif /* RTM_IFANNOUNCE */
185 static const struct message rtm_flag_str
[] =
188 {RTF_GATEWAY
, "GATEWAY"},
190 {RTF_REJECT
, "REJECT"},
191 {RTF_DYNAMIC
, "DYNAMIC"},
192 {RTF_MODIFIED
, "MODIFIED"},
196 #endif /* RTF_MASK */
198 {RTF_CLONING
, "CLONING"},
199 #endif /* RTF_CLONING */
200 {RTF_XRESOLVE
, "XRESOLVE"},
201 {RTF_LLINFO
, "LLINFO"},
202 {RTF_STATIC
, "STATIC"},
203 {RTF_BLACKHOLE
, "BLACKHOLE"},
205 {RTF_PRIVATE
, "PRIVATE"},
206 #endif /* RTF_PRIVATE */
207 {RTF_PROTO1
, "PROTO1"},
208 {RTF_PROTO2
, "PROTO2"},
210 {RTF_PRCLONING
, "PRCLONING"},
211 #endif /* RTF_PRCLONING */
213 {RTF_WASCLONED
, "WASCLONED"},
214 #endif /* RTF_WASCLONED */
216 {RTF_PROTO3
, "PROTO3"},
217 #endif /* RTF_PROTO3 */
219 {RTF_PINNED
, "PINNED"},
220 #endif /* RTF_PINNED */
222 {RTF_LOCAL
, "LOCAL"},
223 #endif /* RTF_LOCAL */
225 {RTF_BROADCAST
, "BROADCAST"},
226 #endif /* RTF_BROADCAST */
228 {RTF_MULTICAST
, "MULTICAST"},
229 #endif /* RTF_MULTICAST */
231 {RTF_MULTIRT
, "MULTIRT"},
232 #endif /* RTF_MULTIRT */
234 {RTF_SETSRC
, "SETSRC"},
235 #endif /* RTF_SETSRC */
239 /* Kernel routing update socket. */
240 int routing_sock
= -1;
242 /* Yes I'm checking ugly routing socket behavior. */
245 /* Supported address family check. */
247 af_check (int family
)
249 if (family
== AF_INET
)
252 if (family
== AF_INET6
)
254 #endif /* HAVE_IPV6 */
258 /* Dump routing table flag for debug purpose. */
260 rtm_flag_dump (int flag
)
262 const struct message
*mes
;
263 static char buf
[BUFSIZ
];
266 for (mes
= rtm_flag_str
; mes
->key
!= 0; mes
++)
270 strlcat (buf
, mes
->str
, BUFSIZ
);
271 strlcat (buf
, " ", BUFSIZ
);
274 zlog_debug ("Kernel: %s", buf
);
277 #ifdef RTM_IFANNOUNCE
278 /* Interface adding function */
280 ifan_read (struct if_announcemsghdr
*ifan
)
282 struct interface
*ifp
;
284 ifp
= if_lookup_by_index (ifan
->ifan_index
);
287 assert ( (ifp
->ifindex
== ifan
->ifan_index
)
288 || (ifp
->ifindex
== IFINDEX_INTERNAL
) );
291 || ((ifp
->ifindex
== IFINDEX_INTERNAL
)
292 && (ifan
->ifan_what
== IFAN_ARRIVAL
)) )
294 if (IS_ZEBRA_DEBUG_KERNEL
)
295 zlog_debug ("%s: creating interface for ifindex %d, name %s",
296 __func__
, ifan
->ifan_index
, ifan
->ifan_name
);
298 /* Create Interface */
299 ifp
= if_get_by_name_len(ifan
->ifan_name
,
300 strnlen(ifan
->ifan_name
,
301 sizeof(ifan
->ifan_name
)));
302 ifp
->ifindex
= ifan
->ifan_index
;
307 else if (ifp
!= NULL
&& ifan
->ifan_what
== IFAN_DEPARTURE
)
308 if_delete_update (ifp
);
314 if (IS_ZEBRA_DEBUG_KERNEL
)
315 zlog_debug ("%s: interface %s index %d",
316 __func__
, ifan
->ifan_name
, ifan
->ifan_index
);
320 #endif /* RTM_IFANNOUNCE */
322 #ifdef HAVE_BSD_IFI_LINK_STATE
323 /* BSD link detect translation */
325 bsd_linkdetect_translate (struct if_msghdr
*ifm
)
327 if ((ifm
->ifm_data
.ifi_link_state
>= LINK_STATE_UP
) ||
328 (ifm
->ifm_data
.ifi_link_state
== LINK_STATE_UNKNOWN
))
329 SET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
331 UNSET_FLAG(ifm
->ifm_flags
, IFF_RUNNING
);
333 #endif /* HAVE_BSD_IFI_LINK_STATE */
336 * Handle struct if_msghdr obtained from reading routing socket or
337 * sysctl (from interface_list). There may or may not be sockaddrs
338 * present after the header.
341 ifm_read (struct if_msghdr
*ifm
)
343 struct interface
*ifp
= NULL
;
344 struct sockaddr_dl
*sdl
;
345 char ifname
[IFNAMSIZ
];
349 /* terminate ifname at head (for strnlen) and tail (for safety) */
350 ifname
[IFNAMSIZ
- 1] = '\0';
352 /* paranoia: sanity check structure */
353 if (ifm
->ifm_msglen
< sizeof(struct if_msghdr
))
355 zlog_err ("ifm_read: ifm->ifm_msglen %d too short\n",
361 * Check for a sockaddr_dl following the message. First, point to
362 * where a socakddr might be if one follows the message.
364 cp
= (void *)(ifm
+ 1);
368 * XXX This behavior should be narrowed to only the kernel versions
369 * for which the structures returned do not match the headers.
371 * if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
372 * is 12 bytes larger than the 32 bit version.
374 if (((struct sockaddr
*) cp
)->sa_family
== AF_UNSPEC
)
378 RTA_ADDR_GET (NULL
, RTA_DST
, ifm
->ifm_addrs
, cp
);
379 RTA_ADDR_GET (NULL
, RTA_GATEWAY
, ifm
->ifm_addrs
, cp
);
380 RTA_ATTR_GET (NULL
, RTA_NETMASK
, ifm
->ifm_addrs
, cp
);
381 RTA_ADDR_GET (NULL
, RTA_GENMASK
, ifm
->ifm_addrs
, cp
);
382 sdl
= (struct sockaddr_dl
*)cp
;
383 RTA_NAME_GET (ifname
, RTA_IFP
, ifm
->ifm_addrs
, cp
, ifnlen
);
384 RTA_ADDR_GET (NULL
, RTA_IFA
, ifm
->ifm_addrs
, cp
);
385 RTA_ADDR_GET (NULL
, RTA_AUTHOR
, ifm
->ifm_addrs
, cp
);
386 RTA_ADDR_GET (NULL
, RTA_BRD
, ifm
->ifm_addrs
, cp
);
388 if (IS_ZEBRA_DEBUG_KERNEL
)
389 zlog_debug ("%s: sdl ifname %s", __func__
, (ifnlen
? ifname
: "(nil)"));
392 * Look up on ifindex first, because ifindices are the primary handle for
393 * interfaces across the user/kernel boundary, for most systems. (Some
394 * messages, such as up/down status changes on NetBSD, do not include a
397 if ( (ifp
= if_lookup_by_index (ifm
->ifm_index
)) != NULL
)
399 /* we have an ifp, verify that the name matches as some systems,
400 * eg Solaris, have a 1:many association of ifindex:ifname
401 * if they dont match, we dont have the correct ifp and should
402 * set it back to NULL to let next check do lookup by name
404 if (ifnlen
&& (strncmp (ifp
->name
, ifname
, IFNAMSIZ
) != 0) )
406 if (IS_ZEBRA_DEBUG_KERNEL
)
407 zlog_debug ("%s: ifp name %s doesnt match sdl name %s",
408 __func__
, ifp
->name
, ifname
);
414 * If we dont have an ifp, try looking up by name. Particularly as some
415 * systems (Solaris) have a 1:many mapping of ifindex:ifname - the ifname
416 * is therefore our unique handle to that interface.
418 * Interfaces specified in the configuration file for which the ifindex
419 * has not been determined will have ifindex == IFINDEX_INTERNAL, and such
420 * interfaces are found by this search, and then their ifindex values can
423 if ( (ifp
== NULL
) && ifnlen
)
424 ifp
= if_lookup_by_name (ifname
);
427 * If ifp still does not exist or has an invalid index (IFINDEX_INTERNAL),
428 * create or fill in an interface.
430 if ((ifp
== NULL
) || (ifp
->ifindex
== IFINDEX_INTERNAL
))
433 * To create or fill in an interface, a sockaddr_dl (via
434 * RTA_IFP) is required.
438 zlog_warn ("Interface index %d (new) missing ifname\n",
443 #ifndef RTM_IFANNOUNCE
444 /* Down->Down interface should be ignored here.
445 * See further comment below.
447 if (!CHECK_FLAG (ifm
->ifm_flags
, IFF_UP
))
449 #endif /* !RTM_IFANNOUNCE */
453 /* Interface that zebra was not previously aware of, so create. */
454 ifp
= if_create (ifname
, ifnlen
);
455 if (IS_ZEBRA_DEBUG_KERNEL
)
456 zlog_debug ("%s: creating ifp for ifindex %d",
457 __func__
, ifm
->ifm_index
);
460 if (IS_ZEBRA_DEBUG_KERNEL
)
461 zlog_debug ("%s: updated/created ifp, ifname %s, ifindex %d",
462 __func__
, ifp
->name
, ifp
->ifindex
);
464 * Fill in newly created interface structure, or larval
465 * structure with ifindex IFINDEX_INTERNAL.
467 ifp
->ifindex
= ifm
->ifm_index
;
469 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
470 bsd_linkdetect_translate(ifm
);
471 #endif /* HAVE_BSD_IFI_LINK_STATE */
473 if_flags_update (ifp
, ifm
->ifm_flags
);
474 #if defined(__bsdi__)
475 if_kvm_get_mtu (ifp
);
478 #endif /* __bsdi__ */
482 * XXX sockaddr_dl contents can be larger than the structure
483 * definition. There are 2 big families here:
484 * - BSD has sdl_len + sdl_data[16] + overruns sdl_data
485 * we MUST use sdl_len here or we'll truncate data.
486 * - Solaris has no sdl_len, but sdl_data[244]
487 * presumably, it's not going to run past that, so sizeof()
489 * a nonzero ifnlen from RTA_NAME_GET() means sdl is valid
493 #ifdef HAVE_STRUCT_SOCKADDR_DL_SDL_LEN
494 memcpy (&ifp
->sdl
, sdl
, sdl
->sdl_len
);
496 memcpy (&ifp
->sdl
, sdl
, sizeof (struct sockaddr_dl
));
497 #endif /* HAVE_STRUCT_SOCKADDR_DL_SDL_LEN */
504 * Interface structure exists. Adjust stored flags from
505 * notification. If interface has up->down or down->up
506 * transition, call state change routines (to adjust routes,
507 * notify routing daemons, etc.). (Other flag changes are stored
508 * but apparently do not trigger action.)
511 if (ifp
->ifindex
!= ifm
->ifm_index
)
513 zlog_warn ("%s: index mismatch, ifname %s, ifp index %d, "
515 __func__
, ifp
->name
, ifp
->ifindex
, ifm
->ifm_index
);
519 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
520 bsd_linkdetect_translate(ifm
);
521 #endif /* HAVE_BSD_IFI_LINK_STATE */
523 /* update flags and handle operative->inoperative transition, if any */
524 if_flags_update (ifp
, ifm
->ifm_flags
);
526 #ifndef RTM_IFANNOUNCE
529 /* No RTM_IFANNOUNCE on this platform, so we can never
530 * distinguish between ~IFF_UP and delete. We must presume
531 * it has been deleted.
532 * Eg, Solaris will not notify us of unplumb.
534 * XXX: Fixme - this should be runtime detected
535 * So that a binary compiled on a system with IFANNOUNCE
536 * will still behave correctly if run on a platform without
538 if_delete_update (ifp
);
540 #endif /* RTM_IFANNOUNCE */
543 #if defined(__bsdi__)
544 if_kvm_get_mtu (ifp
);
547 #endif /* __bsdi__ */
552 #ifdef HAVE_NET_RT_IFLIST
553 ifp
->stats
= ifm
->ifm_data
;
554 #endif /* HAVE_NET_RT_IFLIST */
556 if (IS_ZEBRA_DEBUG_KERNEL
)
557 zlog_debug ("%s: interface %s index %d",
558 __func__
, ifp
->name
, ifp
->ifindex
);
563 /* Address read from struct ifa_msghdr. */
565 ifam_read_mesg (struct ifa_msghdr
*ifm
,
566 union sockunion
*addr
,
567 union sockunion
*mask
,
568 union sockunion
*brd
,
574 union sockunion gateway
;
576 pnt
= (caddr_t
)(ifm
+ 1);
577 end
= ((caddr_t
)ifm
) + ifm
->ifam_msglen
;
579 /* Be sure structure is cleared */
580 memset (mask
, 0, sizeof (union sockunion
));
581 memset (addr
, 0, sizeof (union sockunion
));
582 memset (brd
, 0, sizeof (union sockunion
));
583 memset (&dst
, 0, sizeof (union sockunion
));
584 memset (&gateway
, 0, sizeof (union sockunion
));
586 /* We fetch each socket variable into sockunion. */
587 RTA_ADDR_GET (&dst
, RTA_DST
, ifm
->ifam_addrs
, pnt
);
588 RTA_ADDR_GET (&gateway
, RTA_GATEWAY
, ifm
->ifam_addrs
, pnt
);
589 RTA_ATTR_GET (mask
, RTA_NETMASK
, ifm
->ifam_addrs
, pnt
);
590 RTA_ADDR_GET (NULL
, RTA_GENMASK
, ifm
->ifam_addrs
, pnt
);
591 RTA_NAME_GET (ifname
, RTA_IFP
, ifm
->ifam_addrs
, pnt
, *ifnlen
);
592 RTA_ADDR_GET (addr
, RTA_IFA
, ifm
->ifam_addrs
, pnt
);
593 RTA_ADDR_GET (NULL
, RTA_AUTHOR
, ifm
->ifam_addrs
, pnt
);
594 RTA_ADDR_GET (brd
, RTA_BRD
, ifm
->ifam_addrs
, pnt
);
596 if (IS_ZEBRA_DEBUG_KERNEL
)
598 switch (sockunion_family(addr
))
602 char buf
[4][INET_ADDRSTRLEN
];
603 zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
604 "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
606 __func__
, ifm
->ifam_index
,
607 (ifnlen
? ifname
: "(nil)"), ifm
->ifam_addrs
,
609 inet_ntop(AF_INET
,&addr
->sin
.sin_addr
,
610 buf
[0],sizeof(buf
[0])),
611 ip_masklen(mask
->sin
.sin_addr
),
612 inet_ntop(AF_INET
,&brd
->sin
.sin_addr
,
613 buf
[1],sizeof(buf
[1])),
614 inet_ntop(AF_INET
,&dst
.sin
.sin_addr
,
615 buf
[2],sizeof(buf
[2])),
616 inet_ntop(AF_INET
,&gateway
.sin
.sin_addr
,
617 buf
[3],sizeof(buf
[3])));
623 char buf
[4][INET6_ADDRSTRLEN
];
624 zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
625 "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
627 __func__
, ifm
->ifam_index
,
628 (ifnlen
? ifname
: "(nil)"), ifm
->ifam_addrs
,
630 inet_ntop(AF_INET6
,&addr
->sin6
.sin6_addr
,
631 buf
[0],sizeof(buf
[0])),
632 ip6_masklen(mask
->sin6
.sin6_addr
),
633 inet_ntop(AF_INET6
,&brd
->sin6
.sin6_addr
,
634 buf
[1],sizeof(buf
[1])),
635 inet_ntop(AF_INET6
,&dst
.sin6
.sin6_addr
,
636 buf
[2],sizeof(buf
[2])),
637 inet_ntop(AF_INET6
,&gateway
.sin6
.sin6_addr
,
638 buf
[3],sizeof(buf
[3])));
641 #endif /* HAVE_IPV6 */
643 zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x",
644 __func__
, ifm
->ifam_index
,
645 (ifnlen
? ifname
: "(nil)"), ifm
->ifam_addrs
);
650 /* Assert read up end point matches to end point */
652 zlog_warn ("ifam_read() doesn't read all socket data");
655 /* Interface's address information get. */
657 ifam_read (struct ifa_msghdr
*ifam
)
659 struct interface
*ifp
= NULL
;
660 union sockunion addr
, mask
, brd
;
661 char ifname
[INTERFACE_NAMSIZ
];
666 ifname
[0] = ifname
[INTERFACE_NAMSIZ
- 1] = '\0';
668 /* Allocate and read address information. */
669 ifam_read_mesg (ifam
, &addr
, &mask
, &brd
, ifname
, &ifnlen
);
671 if ((ifp
= if_lookup_by_index(ifam
->ifam_index
)) == NULL
)
673 zlog_warn ("%s: no interface for ifname %s, index %d",
674 __func__
, ifname
, ifam
->ifam_index
);
678 if (ifnlen
&& strncmp (ifp
->name
, ifname
, INTERFACE_NAMSIZ
))
681 /* N.B. The info in ifa_msghdr does not tell us whether the RTA_BRD
682 field contains a broadcast address or a peer address, so we are forced to
683 rely upon the interface type. */
684 if (if_is_pointopoint(ifp
))
685 SET_FLAG(flags
, ZEBRA_IFA_PEER
);
688 /* it might seem cute to grab the interface metric here, however
689 * we're processing an address update message, and so some systems
690 * (e.g. FBSD) dont bother to fill in ifam_metric. Disabled, but left
691 * in deliberately, as comment.
693 ifp
->metric
= ifam
->ifam_metric
;
696 /* Add connected address. */
697 switch (sockunion_family (&addr
))
700 if (ifam
->ifam_type
== RTM_NEWADDR
)
701 connected_add_ipv4 (ifp
, flags
, &addr
.sin
.sin_addr
,
702 ip_masklen (mask
.sin
.sin_addr
),
704 (isalias
? ifname
: NULL
));
706 connected_delete_ipv4 (ifp
, flags
, &addr
.sin
.sin_addr
,
707 ip_masklen (mask
.sin
.sin_addr
),
712 /* Unset interface index from link-local address when IPv6 stack
714 if (IN6_IS_ADDR_LINKLOCAL (&addr
.sin6
.sin6_addr
))
715 SET_IN6_LINKLOCAL_IFINDEX (addr
.sin6
.sin6_addr
, 0);
717 if (ifam
->ifam_type
== RTM_NEWADDR
)
718 connected_add_ipv6 (ifp
, flags
, &addr
.sin6
.sin6_addr
,
719 ip6_masklen (mask
.sin6
.sin6_addr
),
721 (isalias
? ifname
: NULL
));
723 connected_delete_ipv6 (ifp
,
724 &addr
.sin6
.sin6_addr
,
725 ip6_masklen (mask
.sin6
.sin6_addr
),
726 &brd
.sin6
.sin6_addr
);
728 #endif /* HAVE_IPV6 */
730 /* Unsupported family silently ignore... */
734 /* Check interface flag for implicit up of the interface. */
738 /* In addition to lacking IFANNOUNCE, on SUNOS IFF_UP is strange.
739 * See comments for SUNOS_5 in interface.c::if_flags_mangle.
741 * Here we take care of case where the real IFF_UP was previously
742 * unset (as kept in struct zebra_if.primary_state) and the mangled
743 * IFF_UP (ie IFF_UP set || listcount(connected) has now transitioned
744 * to unset due to the lost non-primary address having DELADDR'd.
746 * we must delete the interface, because in between here and next
747 * event for this interface-name the administrator could unplumb
748 * and replumb the interface.
751 if_delete_update (ifp
);
757 /* Interface function for reading kernel routing table information. */
759 rtm_read_mesg (struct rt_msghdr
*rtm
,
760 union sockunion
*dest
,
761 union sockunion
*mask
,
762 union sockunion
*gate
,
768 /* Pnt points out socket data start point. */
769 pnt
= (caddr_t
)(rtm
+ 1);
770 end
= ((caddr_t
)rtm
) + rtm
->rtm_msglen
;
772 /* rt_msghdr version check. */
773 if (rtm
->rtm_version
!= RTM_VERSION
)
774 zlog (NULL
, LOG_WARNING
,
775 "Routing message version different %d should be %d."
776 "This may cause problem\n", rtm
->rtm_version
, RTM_VERSION
);
778 /* Be sure structure is cleared */
779 memset (dest
, 0, sizeof (union sockunion
));
780 memset (gate
, 0, sizeof (union sockunion
));
781 memset (mask
, 0, sizeof (union sockunion
));
783 /* We fetch each socket variable into sockunion. */
784 RTA_ADDR_GET (dest
, RTA_DST
, rtm
->rtm_addrs
, pnt
);
785 RTA_ADDR_GET (gate
, RTA_GATEWAY
, rtm
->rtm_addrs
, pnt
);
786 RTA_ATTR_GET (mask
, RTA_NETMASK
, rtm
->rtm_addrs
, pnt
);
787 RTA_ADDR_GET (NULL
, RTA_GENMASK
, rtm
->rtm_addrs
, pnt
);
788 RTA_NAME_GET (ifname
, RTA_IFP
, rtm
->rtm_addrs
, pnt
, *ifnlen
);
789 RTA_ADDR_GET (NULL
, RTA_IFA
, rtm
->rtm_addrs
, pnt
);
790 RTA_ADDR_GET (NULL
, RTA_AUTHOR
, rtm
->rtm_addrs
, pnt
);
791 RTA_ADDR_GET (NULL
, RTA_BRD
, rtm
->rtm_addrs
, pnt
);
793 /* If there is netmask information set it's family same as
795 if (rtm
->rtm_addrs
& RTA_NETMASK
)
796 mask
->sa
.sa_family
= dest
->sa
.sa_family
;
798 /* Assert read up to the end of pointer. */
800 zlog (NULL
, LOG_WARNING
, "rtm_read() doesn't read all socket data.");
802 return rtm
->rtm_flags
;
806 rtm_read (struct rt_msghdr
*rtm
)
810 union sockunion dest
, mask
, gate
;
811 char ifname
[INTERFACE_NAMSIZ
+ 1];
816 /* Read destination and netmask and gateway from rtm message
818 flags
= rtm_read_mesg (rtm
, &dest
, &mask
, &gate
, ifname
, &ifnlen
);
819 if (!(flags
& RTF_DONE
))
821 if (IS_ZEBRA_DEBUG_KERNEL
)
822 zlog_debug ("%s: got rtm of type %d (%s)", __func__
, rtm
->rtm_type
,
823 lookup (rtm_type_str
, rtm
->rtm_type
));
825 #ifdef RTF_CLONED /*bsdi, netbsd 1.6*/
826 if (flags
& RTF_CLONED
)
829 #ifdef RTF_WASCLONED /*freebsd*/
830 if (flags
& RTF_WASCLONED
)
834 if ((rtm
->rtm_type
== RTM_ADD
) && ! (flags
& RTF_UP
))
837 /* This is connected route. */
838 if (! (flags
& RTF_GATEWAY
))
841 if (flags
& RTF_PROTO1
)
842 SET_FLAG (zebra_flags
, ZEBRA_FLAG_SELFROUTE
);
844 /* This is persistent route. */
845 if (flags
& RTF_STATIC
)
846 SET_FLAG (zebra_flags
, ZEBRA_FLAG_STATIC
);
848 /* This is a reject or blackhole route */
849 if (flags
& RTF_REJECT
)
850 SET_FLAG (zebra_flags
, ZEBRA_FLAG_REJECT
);
851 if (flags
& RTF_BLACKHOLE
)
852 SET_FLAG (zebra_flags
, ZEBRA_FLAG_BLACKHOLE
);
854 if (dest
.sa
.sa_family
== AF_INET
)
856 struct prefix_ipv4 p
;
859 p
.prefix
= dest
.sin
.sin_addr
;
860 if (flags
& RTF_HOST
)
861 p
.prefixlen
= IPV4_MAX_PREFIXLEN
;
863 p
.prefixlen
= ip_masklen (mask
.sin
.sin_addr
);
865 /* Catch self originated messages and match them against our current RIB.
866 * At the same time, ignore unconfirmed messages, they should be tracked
867 * by rtm_write() and kernel_rtm_ipv4().
869 if (rtm
->rtm_type
!= RTM_GET
&& rtm
->rtm_pid
== pid
)
871 char buf
[INET_ADDRSTRLEN
], gate_buf
[INET_ADDRSTRLEN
];
873 if (! IS_ZEBRA_DEBUG_RIB
)
875 ret
= rib_lookup_ipv4_route (&p
, &gate
, VRF_DEFAULT
);
876 prefix2str (&p
, buf
, sizeof(buf
));
877 switch (rtm
->rtm_type
)
882 /* The kernel notifies us about a new route in FIB created by us.
883 Do we have a correspondent entry in our RIB? */
886 case ZEBRA_RIB_NOTFOUND
:
887 zlog_debug ("%s: %s %s/%d: desync: RR isn't yet in RIB, while already in FIB",
888 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
);
890 case ZEBRA_RIB_FOUND_CONNECTED
:
891 case ZEBRA_RIB_FOUND_NOGATE
:
892 inet_ntop (AF_INET
, &gate
.sin
.sin_addr
, gate_buf
, INET_ADDRSTRLEN
);
893 zlog_debug ("%s: %s %s/%d: desync: RR is in RIB, but gate differs (ours is %s)",
894 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
, gate_buf
);
896 case ZEBRA_RIB_FOUND_EXACT
: /* RIB RR == FIB RR */
897 zlog_debug ("%s: %s %s/%d: done Ok",
898 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
);
899 rib_lookup_and_dump (&p
);
905 /* The kernel notifies us about a route deleted by us. Do we still
906 have it in the RIB? Do we have anything instead? */
909 case ZEBRA_RIB_FOUND_EXACT
:
910 zlog_debug ("%s: %s %s/%d: desync: RR is still in RIB, while already not in FIB",
911 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
);
912 rib_lookup_and_dump (&p
);
914 case ZEBRA_RIB_FOUND_CONNECTED
:
915 case ZEBRA_RIB_FOUND_NOGATE
:
916 zlog_debug ("%s: %s %s/%d: desync: RR is still in RIB, plus gate differs",
917 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
);
918 rib_lookup_and_dump (&p
);
920 case ZEBRA_RIB_NOTFOUND
: /* RIB RR == FIB RR */
921 zlog_debug ("%s: %s %s/%d: done Ok",
922 __func__
, lookup (rtm_type_str
, rtm
->rtm_type
), buf
, p
.prefixlen
);
923 rib_lookup_and_dump (&p
);
929 zlog_debug ("%s: %s/%d: warning: loopback RTM of type %s received",
930 __func__
, buf
, p
.prefixlen
, lookup (rtm_type_str
, rtm
->rtm_type
));
935 /* Change, delete the old prefix, we have no further information
936 * to specify the route really
938 if (rtm
->rtm_type
== RTM_CHANGE
)
939 rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
,
940 NULL
, 0, VRF_DEFAULT
, SAFI_UNICAST
);
942 if (rtm
->rtm_type
== RTM_GET
943 || rtm
->rtm_type
== RTM_ADD
944 || rtm
->rtm_type
== RTM_CHANGE
)
945 rib_add_ipv4 (ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
,
946 &p
, &gate
.sin
.sin_addr
, NULL
, 0, VRF_DEFAULT
, 0, 0, SAFI_UNICAST
);
948 rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL
, 0 zebra_flags
,
949 &p
, &gate
.sin
.sin_addr
, 0, VRF_DEFAULT
, SAFI_UNICAST
);
952 if (dest
.sa
.sa_family
== AF_INET6
)
954 /* One day we might have a debug section here like one in the
955 * IPv4 case above. Just ignore own messages at the moment.
957 if (rtm
->rtm_type
!= RTM_GET
&& rtm
->rtm_pid
== pid
)
959 struct prefix_ipv6 p
;
960 unsigned int ifindex
= 0;
963 p
.prefix
= dest
.sin6
.sin6_addr
;
964 if (flags
& RTF_HOST
)
965 p
.prefixlen
= IPV6_MAX_PREFIXLEN
;
967 p
.prefixlen
= ip6_masklen (mask
.sin6
.sin6_addr
);
970 if (IN6_IS_ADDR_LINKLOCAL (&gate
.sin6
.sin6_addr
))
972 ifindex
= IN6_LINKLOCAL_IFINDEX (gate
.sin6
.sin6_addr
);
973 SET_IN6_LINKLOCAL_IFINDEX (gate
.sin6
.sin6_addr
, 0);
977 /* CHANGE: delete the old prefix, we have no further information
978 * to specify the route really
980 if (rtm
->rtm_type
== RTM_CHANGE
)
981 rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
, &p
,
982 NULL
, 0, VRF_DEFAULT
, SAFI_UNICAST
);
984 if (rtm
->rtm_type
== RTM_GET
985 || rtm
->rtm_type
== RTM_ADD
986 || rtm
->rtm_type
== RTM_CHANGE
)
987 rib_add_ipv6 (ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
,
988 &p
, &gate
.sin6
.sin6_addr
, ifindex
, VRF_DEFAULT
, 0, 0, SAFI_UNICAST
);
990 rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL
, 0, zebra_flags
,
991 &p
, &gate
.sin6
.sin6_addr
, ifindex
, VRF_DEFAULT
, SAFI_UNICAST
);
993 #endif /* HAVE_IPV6 */
996 /* Interface function for the kernel routing table updates. Support
997 * for RTM_CHANGE will be needed.
998 * Exported only for rt_socket.c
1001 rtm_write (int message
,
1002 union sockunion
*dest
,
1003 union sockunion
*mask
,
1004 union sockunion
*gate
,
1011 struct interface
*ifp
;
1013 /* Sequencial number of routing message. */
1014 static int msg_seq
= 0;
1016 /* Struct of rt_msghdr and buffer for storing socket's data. */
1019 struct rt_msghdr rtm
;
1023 if (routing_sock
< 0)
1024 return ZEBRA_ERR_EPERM
;
1026 /* Clear and set rt_msghdr values */
1027 memset (&msg
, 0, sizeof (struct rt_msghdr
));
1028 msg
.rtm
.rtm_version
= RTM_VERSION
;
1029 msg
.rtm
.rtm_type
= message
;
1030 msg
.rtm
.rtm_seq
= msg_seq
++;
1031 msg
.rtm
.rtm_addrs
= RTA_DST
;
1032 msg
.rtm
.rtm_addrs
|= RTA_GATEWAY
;
1033 msg
.rtm
.rtm_flags
= RTF_UP
;
1034 msg
.rtm
.rtm_index
= index
;
1038 msg
.rtm
.rtm_rmx
.rmx_hopcount
= metric
;
1039 msg
.rtm
.rtm_inits
|= RTV_HOPCOUNT
;
1042 ifp
= if_lookup_by_index (index
);
1044 if (gate
&& message
== RTM_ADD
)
1045 msg
.rtm
.rtm_flags
|= RTF_GATEWAY
;
1047 /* When RTF_CLONING is unavailable on BSD, should we set some
1048 * other flag instead?
1051 if (! gate
&& message
== RTM_ADD
&& ifp
&&
1052 (ifp
->flags
& IFF_POINTOPOINT
) == 0)
1053 msg
.rtm
.rtm_flags
|= RTF_CLONING
;
1054 #endif /* RTF_CLONING */
1056 /* If no protocol specific gateway is specified, use link
1057 address for gateway. */
1062 char dest_buf
[INET_ADDRSTRLEN
] = "NULL", mask_buf
[INET_ADDRSTRLEN
] = "255.255.255.255";
1064 inet_ntop (AF_INET
, &dest
->sin
.sin_addr
, dest_buf
, INET_ADDRSTRLEN
);
1066 inet_ntop (AF_INET
, &mask
->sin
.sin_addr
, mask_buf
, INET_ADDRSTRLEN
);
1067 zlog_warn ("%s: %s/%s: gate == NULL and no gateway found for ifindex %d",
1068 __func__
, dest_buf
, mask_buf
, index
);
1071 gate
= (union sockunion
*) & ifp
->sdl
;
1075 msg
.rtm
.rtm_addrs
|= RTA_NETMASK
;
1076 else if (message
== RTM_ADD
)
1077 msg
.rtm
.rtm_flags
|= RTF_HOST
;
1079 /* Tagging route with flags */
1080 msg
.rtm
.rtm_flags
|= (RTF_PROTO1
);
1082 /* Additional flags. */
1083 if (zebra_flags
& ZEBRA_FLAG_BLACKHOLE
)
1084 msg
.rtm
.rtm_flags
|= RTF_BLACKHOLE
;
1085 if (zebra_flags
& ZEBRA_FLAG_REJECT
)
1086 msg
.rtm
.rtm_flags
|= RTF_REJECT
;
1089 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
1090 #define SOCKADDRSET(X,R) \
1091 if (msg.rtm.rtm_addrs & (R)) \
1093 int len = ROUNDUP ((X)->sa.sa_len); \
1094 memcpy (pnt, (caddr_t)(X), len); \
1098 #define SOCKADDRSET(X,R) \
1099 if (msg.rtm.rtm_addrs & (R)) \
1101 int len = SAROUNDUP (X); \
1102 memcpy (pnt, (caddr_t)(X), len); \
1105 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
1107 pnt
= (caddr_t
) msg
.buf
;
1109 /* Write each socket data into rtm message buffer */
1110 SOCKADDRSET (dest
, RTA_DST
);
1111 SOCKADDRSET (gate
, RTA_GATEWAY
);
1112 SOCKADDRSET (mask
, RTA_NETMASK
);
1114 msg
.rtm
.rtm_msglen
= pnt
- (caddr_t
) &msg
;
1116 ret
= write (routing_sock
, &msg
, msg
.rtm
.rtm_msglen
);
1118 if (ret
!= msg
.rtm
.rtm_msglen
)
1120 if (errno
== EEXIST
)
1121 return ZEBRA_ERR_RTEXIST
;
1122 if (errno
== ENETUNREACH
)
1123 return ZEBRA_ERR_RTUNREACH
;
1125 return ZEBRA_ERR_RTNOEXIST
;
1127 zlog_warn ("%s: write : %s (%d)", __func__
, safe_strerror (errno
), errno
);
1128 return ZEBRA_ERR_KERNEL
;
1130 return ZEBRA_ERR_NOERROR
;
1135 #include "zebra/zserv.h"
1137 /* For debug purpose. */
1139 rtmsg_debug (struct rt_msghdr
*rtm
)
1141 zlog_debug ("Kernel: Len: %d Type: %s", rtm
->rtm_msglen
, lookup (rtm_type_str
, rtm
->rtm_type
));
1142 rtm_flag_dump (rtm
->rtm_flags
);
1143 zlog_debug ("Kernel: message seq %d", rtm
->rtm_seq
);
1144 zlog_debug ("Kernel: pid %d, rtm_addrs 0x%x", rtm
->rtm_pid
, rtm
->rtm_addrs
);
1147 /* This is pretty gross, better suggestions welcome -- mhandler */
1150 #define RTAX_MAX RTA_NUMBITS
1153 #endif /* RTA_NUMBITS */
1154 #endif /* RTAX_MAX */
1156 /* Kernel routing table and interface updates via routing socket. */
1158 kernel_read (struct thread
*thread
)
1162 struct rt_msghdr
*rtm
;
1165 * This must be big enough for any message the kernel might send.
1166 * Rather than determining how many sockaddrs of what size might be
1167 * in each particular message, just use RTAX_MAX of sockaddr_storage
1168 * for each. Note that the sockaddrs must be after each message
1169 * definition, or rather after whichever happens to be the largest,
1170 * since the buffer needs to be big enough for a message and the
1171 * sockaddrs together.
1175 /* Routing information. */
1178 struct rt_msghdr rtm
;
1179 struct sockaddr_storage addr
[RTAX_MAX
];
1182 /* Interface information. */
1185 struct if_msghdr ifm
;
1186 struct sockaddr_storage addr
[RTAX_MAX
];
1189 /* Interface address information. */
1192 struct ifa_msghdr ifa
;
1193 struct sockaddr_storage addr
[RTAX_MAX
];
1196 #ifdef RTM_IFANNOUNCE
1197 /* Interface arrival/departure */
1200 struct if_announcemsghdr ifan
;
1201 struct sockaddr_storage addr
[RTAX_MAX
];
1203 #endif /* RTM_IFANNOUNCE */
1207 /* Fetch routing socket. */
1208 sock
= THREAD_FD (thread
);
1210 nbytes
= read (sock
, &buf
, sizeof buf
);
1214 if (nbytes
< 0 && errno
!= EWOULDBLOCK
&& errno
!= EAGAIN
)
1215 zlog_warn ("routing socket error: %s", safe_strerror (errno
));
1219 thread_add_read (zebrad
.master
, kernel_read
, NULL
, sock
);
1221 if (IS_ZEBRA_DEBUG_KERNEL
)
1222 rtmsg_debug (&buf
.r
.rtm
);
1227 * Ensure that we didn't drop any data, so that processing routines
1228 * can assume they have the whole message.
1230 if (rtm
->rtm_msglen
!= nbytes
)
1232 zlog_warn ("kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d\n",
1233 rtm
->rtm_msglen
, nbytes
, rtm
->rtm_type
);
1237 switch (rtm
->rtm_type
)
1245 ifm_read (&buf
.im
.ifm
);
1249 ifam_read (&buf
.ia
.ifa
);
1251 #ifdef RTM_IFANNOUNCE
1252 case RTM_IFANNOUNCE
:
1253 ifan_read (&buf
.ian
.ifan
);
1255 #endif /* RTM_IFANNOUNCE */
1257 if (IS_ZEBRA_DEBUG_KERNEL
)
1258 zlog_debug("Unprocessed RTM_type: %d", rtm
->rtm_type
);
1264 /* Make routing socket. */
1266 routing_socket (struct zebra_vrf
*zvrf
)
1268 if (zvrf
->vrf_id
!= VRF_DEFAULT
)
1271 if ( zserv_privs
.change (ZPRIVS_RAISE
) )
1272 zlog_err ("routing_socket: Can't raise privileges");
1274 routing_sock
= socket (AF_ROUTE
, SOCK_RAW
, 0);
1276 if (routing_sock
< 0)
1278 if ( zserv_privs
.change (ZPRIVS_LOWER
) )
1279 zlog_err ("routing_socket: Can't lower privileges");
1280 zlog_warn ("Can't init kernel routing socket");
1284 /* XXX: Socket should be NONBLOCK, however as we currently
1285 * discard failed writes, this will lead to inconsistencies.
1286 * For now, socket must be blocking.
1288 /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
1289 zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
1291 if ( zserv_privs
.change (ZPRIVS_LOWER
) )
1292 zlog_err ("routing_socket: Can't lower privileges");
1294 /* kernel_read needs rewrite. */
1295 thread_add_read (zebrad
.master
, kernel_read
, NULL
, routing_sock
);
1298 /* Exported interface function. This function simply calls
1299 routing_socket (). */
1301 kernel_init (struct zebra_vrf
*zvrf
)
1303 routing_socket (zvrf
);
1307 kernel_terminate (struct zebra_vrf
*zvrf
)