]> git.proxmox.com Git - mirror_frr.git/blob - zebra/kernel_socket.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
doc: Add `show ipv6 rpf X:X::X:X` command to docs
[mirror_frr.git] / zebra / kernel_socket.c
1 /* Kernel communication using routing socket.
2 * Copyright (C) 1999 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
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
9 * later version.
10 *
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.
15 *
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
19 */
20
21 #include <zebra.h>
22
23 #ifndef HAVE_NETLINK
24
25 #include <net/if_types.h>
26 #ifdef __OpenBSD__
27 #include <netmpls/mpls.h>
28 #endif
29
30 #include "if.h"
31 #include "prefix.h"
32 #include "sockunion.h"
33 #include "connected.h"
34 #include "memory.h"
35 #include "ioctl.h"
36 #include "log.h"
37 #include "table.h"
38 #include "rib.h"
39 #include "privs.h"
40 #include "vrf.h"
41 #include "lib_errors.h"
42
43 #include "zebra/rt.h"
44 #include "zebra/interface.h"
45 #include "zebra/zebra_router.h"
46 #include "zebra/debug.h"
47 #include "zebra/kernel_socket.h"
48 #include "zebra/rib.h"
49 #include "zebra/zebra_errors.h"
50 #include "zebra/zebra_ptm.h"
51
52 extern struct zebra_privs_t zserv_privs;
53
54 /*
55 * Historically, the BSD routing socket has aligned data following a
56 * struct sockaddr to sizeof(long), which was 4 bytes on some
57 * platforms, and 8 bytes on others. NetBSD 6 changed the routing
58 * socket to align to sizeof(uint64_t), which is 8 bytes. OS X
59 * appears to align to sizeof(int), which is 4 bytes.
60 *
61 * Alignment of zero-sized sockaddrs is nonsensical, but historically
62 * BSD defines RT_ROUNDUP(0) to be the alignment interval (rather than
63 * 0). We follow this practice without questioning it, but it is a
64 * bug if frr calls ROUNDUP with 0.
65 */
66 #ifdef __APPLE__
67 #define ROUNDUP_TYPE int
68 #else
69 #define ROUNDUP_TYPE long
70 #endif
71
72 /*
73 * Because of these varying conventions, the only sane approach is for
74 * the <net/route.h> header to define some flavor of ROUNDUP macro.
75 */
76
77 /* OS X (Xcode as of 2014-12) is known not to define RT_ROUNDUP */
78 #if defined(RT_ROUNDUP)
79 #define ROUNDUP(a) RT_ROUNDUP(a)
80 #endif /* defined(RT_ROUNDUP) */
81
82 /*
83 * If ROUNDUP has not yet been defined in terms of platform-provided
84 * defines, attempt to cope with heuristics.
85 */
86 #if !defined(ROUNDUP)
87
88 /*
89 * If you're porting to a platform that changed RT_ROUNDUP but doesn't
90 * have it in its headers, this will break rather obviously and you'll
91 * have to fix it here.
92 */
93 #define ROUNDUP(a) \
94 ((a) > 0 ? (1 + (((a)-1) | (sizeof(ROUNDUP_TYPE) - 1))) \
95 : sizeof(ROUNDUP_TYPE))
96
97 #endif /* defined(ROUNDUP) */
98
99
100 #if defined(SA_SIZE)
101 /* SAROUNDUP is the only thing we need, and SA_SIZE provides that */
102 #define SAROUNDUP(a) SA_SIZE(a)
103 #else /* !SA_SIZE */
104 /*
105 * Given a pointer (sockaddr or void *), return the number of bytes
106 * taken up by the sockaddr and any padding needed for alignment.
107 */
108 #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN)
109 #define SAROUNDUP(X) ROUNDUP(((struct sockaddr *)(X))->sa_len)
110 #else
111 /*
112 * One would hope all fixed-size structure definitions are aligned,
113 * but round them up nonetheless.
114 */
115 #define SAROUNDUP(X) \
116 (((struct sockaddr *)(X))->sa_family == AF_INET \
117 ? ROUNDUP(sizeof(struct sockaddr_in)) \
118 : (((struct sockaddr *)(X))->sa_family == AF_INET6 \
119 ? ROUNDUP(sizeof(struct sockaddr_in6)) \
120 : (((struct sockaddr *)(X))->sa_family == AF_LINK \
121 ? ROUNDUP(sizeof(struct sockaddr_dl)) \
122 : sizeof(struct sockaddr))))
123 #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
124
125 #endif /* !SA_SIZE */
126
127 /* Routing socket message types. */
128 const struct message rtm_type_str[] = {{RTM_ADD, "RTM_ADD"},
129 {RTM_DELETE, "RTM_DELETE"},
130 {RTM_CHANGE, "RTM_CHANGE"},
131 {RTM_GET, "RTM_GET"},
132 {RTM_LOSING, "RTM_LOSING"},
133 {RTM_REDIRECT, "RTM_REDIRECT"},
134 {RTM_MISS, "RTM_MISS"},
135 #ifdef RTM_LOCK
136 {RTM_LOCK, "RTM_LOCK"},
137 #endif /* RTM_LOCK */
138 #ifdef OLDADD
139 {RTM_OLDADD, "RTM_OLDADD"},
140 #endif /* RTM_OLDADD */
141 #ifdef RTM_OLDDEL
142 {RTM_OLDDEL, "RTM_OLDDEL"},
143 #endif /* RTM_OLDDEL */
144 #ifdef RTM_RESOLVE
145 {RTM_RESOLVE, "RTM_RESOLVE"},
146 #endif /* RTM_RESOLVE */
147 {RTM_NEWADDR, "RTM_NEWADDR"},
148 {RTM_DELADDR, "RTM_DELADDR"},
149 {RTM_IFINFO, "RTM_IFINFO"},
150 #ifdef RTM_OIFINFO
151 {RTM_OIFINFO, "RTM_OIFINFO"},
152 #endif /* RTM_OIFINFO */
153 #ifdef RTM_NEWMADDR
154 {RTM_NEWMADDR, "RTM_NEWMADDR"},
155 #endif /* RTM_NEWMADDR */
156 #ifdef RTM_DELMADDR
157 {RTM_DELMADDR, "RTM_DELMADDR"},
158 #endif /* RTM_DELMADDR */
159 #ifdef RTM_IFANNOUNCE
160 {RTM_IFANNOUNCE, "RTM_IFANNOUNCE"},
161 #endif /* RTM_IFANNOUNCE */
162 #ifdef RTM_IEEE80211
163 {RTM_IEEE80211, "RTM_IEEE80211"},
164 #endif
165 {0}};
166
167 static const struct message rtm_flag_str[] = {{RTF_UP, "UP"},
168 {RTF_GATEWAY, "GATEWAY"},
169 {RTF_HOST, "HOST"},
170 {RTF_REJECT, "REJECT"},
171 {RTF_DYNAMIC, "DYNAMIC"},
172 {RTF_MODIFIED, "MODIFIED"},
173 {RTF_DONE, "DONE"},
174 #ifdef RTF_MASK
175 {RTF_MASK, "MASK"},
176 #endif /* RTF_MASK */
177 #ifdef RTF_CLONING
178 {RTF_CLONING, "CLONING"},
179 #endif /* RTF_CLONING */
180 #ifdef RTF_XRESOLVE
181 {RTF_XRESOLVE, "XRESOLVE"},
182 #endif /* RTF_XRESOLVE */
183 #ifdef RTF_LLINFO
184 {RTF_LLINFO, "LLINFO"},
185 #endif /* RTF_LLINFO */
186 {RTF_STATIC, "STATIC"},
187 {RTF_BLACKHOLE, "BLACKHOLE"},
188 #ifdef RTF_PRIVATE
189 {RTF_PRIVATE, "PRIVATE"},
190 #endif /* RTF_PRIVATE */
191 {RTF_PROTO1, "PROTO1"},
192 {RTF_PROTO2, "PROTO2"},
193 #ifdef RTF_PRCLONING
194 {RTF_PRCLONING, "PRCLONING"},
195 #endif /* RTF_PRCLONING */
196 #ifdef RTF_WASCLONED
197 {RTF_WASCLONED, "WASCLONED"},
198 #endif /* RTF_WASCLONED */
199 #ifdef RTF_PROTO3
200 {RTF_PROTO3, "PROTO3"},
201 #endif /* RTF_PROTO3 */
202 #ifdef RTF_PINNED
203 {RTF_PINNED, "PINNED"},
204 #endif /* RTF_PINNED */
205 #ifdef RTF_LOCAL
206 {RTF_LOCAL, "LOCAL"},
207 #endif /* RTF_LOCAL */
208 #ifdef RTF_BROADCAST
209 {RTF_BROADCAST, "BROADCAST"},
210 #endif /* RTF_BROADCAST */
211 #ifdef RTF_MULTICAST
212 {RTF_MULTICAST, "MULTICAST"},
213 #endif /* RTF_MULTICAST */
214 #ifdef RTF_MULTIRT
215 {RTF_MULTIRT, "MULTIRT"},
216 #endif /* RTF_MULTIRT */
217 #ifdef RTF_SETSRC
218 {RTF_SETSRC, "SETSRC"},
219 #endif /* RTF_SETSRC */
220 {0}};
221
222 /* Kernel routing update socket. */
223 int routing_sock = -1;
224
225 /* Kernel dataplane routing update socket, used in the dataplane pthread
226 * context.
227 */
228 int dplane_routing_sock = -1;
229
230 /* Yes I'm checking ugly routing socket behavior. */
231 /* #define DEBUG */
232
233 size_t _rta_get(caddr_t sap, void *destp, size_t destlen, bool checkaf);
234 size_t rta_get(caddr_t sap, void *dest, size_t destlen);
235 size_t rta_getattr(caddr_t sap, void *destp, size_t destlen);
236 size_t rta_getsdlname(caddr_t sap, void *dest, short *destlen);
237 const char *rtatostr(unsigned int flags, char *buf, size_t buflen);
238
239 /* Supported address family check. */
240 static inline int af_check(int family)
241 {
242 if (family == AF_INET)
243 return 1;
244 if (family == AF_INET6)
245 return 1;
246 return 0;
247 }
248
249 size_t _rta_get(caddr_t sap, void *destp, size_t destlen, bool checkaf)
250 {
251 struct sockaddr *sa = (struct sockaddr *)sap;
252 struct sockaddr_dl *sdl;
253 uint8_t *dest = destp;
254 size_t tlen, copylen;
255
256 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
257 copylen = sa->sa_len;
258 tlen = (copylen == 0) ? sizeof(ROUNDUP_TYPE) : ROUNDUP(copylen);
259 #else /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
260 copylen = tlen = SAROUNDUP(sap);
261 #endif /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
262
263 if (copylen > 0 && dest != NULL) {
264 if (checkaf && af_check(sa->sa_family) == 0)
265 return tlen;
266 /*
267 * Handle sockaddr_dl corner case:
268 * RTA_NETMASK might be AF_LINK, but it doesn't anything
269 * relevant (e.g. zeroed out fields). Check for this
270 * case and avoid warning log message.
271 */
272 if (sa->sa_family == AF_LINK) {
273 sdl = (struct sockaddr_dl *)sa;
274 if (sdl->sdl_index == 0 || sdl->sdl_nlen == 0)
275 copylen = destlen;
276 }
277
278 if (copylen > destlen) {
279 zlog_warn(
280 "%s: destination buffer too small (%zu vs %zu)",
281 __func__, copylen, destlen);
282 memcpy(dest, sap, destlen);
283 } else
284 memcpy(dest, sap, copylen);
285 }
286
287 return tlen;
288 }
289
290 size_t rta_get(caddr_t sap, void *destp, size_t destlen)
291 {
292 return _rta_get(sap, destp, destlen, true);
293 }
294
295 size_t rta_getattr(caddr_t sap, void *destp, size_t destlen)
296 {
297 return _rta_get(sap, destp, destlen, false);
298 }
299
300 size_t rta_getsdlname(caddr_t sap, void *destp, short *destlen)
301 {
302 struct sockaddr_dl *sdl = (struct sockaddr_dl *)sap;
303 uint8_t *dest = destp;
304 size_t tlen, copylen;
305
306 copylen = sdl->sdl_nlen;
307 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
308 struct sockaddr *sa = (struct sockaddr *)sap;
309
310 tlen = (sa->sa_len == 0) ? sizeof(ROUNDUP_TYPE) : ROUNDUP(sa->sa_len);
311 #else /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
312 tlen = SAROUNDUP(sap);
313 #endif /* !HAVE_STRUCT_SOCKADDR_SA_LEN */
314
315 if (copylen > 0 && dest != NULL && sdl->sdl_family == AF_LINK) {
316 if (copylen > IFNAMSIZ) {
317 zlog_warn(
318 "%s: destination buffer too small (%zu vs %d)",
319 __func__, copylen, IFNAMSIZ);
320 memcpy(dest, sdl->sdl_data, IFNAMSIZ);
321 dest[IFNAMSIZ] = 0;
322 *destlen = IFNAMSIZ;
323 } else {
324 memcpy(dest, sdl->sdl_data, copylen);
325 dest[copylen] = 0;
326 *destlen = copylen;
327 }
328 } else
329 *destlen = 0;
330
331 return tlen;
332 }
333
334 const char *rtatostr(unsigned int flags, char *buf, size_t buflen)
335 {
336 const char *flagstr, *bufstart;
337 int bit, wlen;
338 char ustr[32];
339
340 /* Hold the pointer to the buffer beginning. */
341 bufstart = buf;
342
343 for (bit = 1; bit; bit <<= 1) {
344 if ((flags & bit) == 0)
345 continue;
346
347 switch (bit) {
348 case RTA_DST:
349 flagstr = "DST";
350 break;
351 case RTA_GATEWAY:
352 flagstr = "GATEWAY";
353 break;
354 case RTA_NETMASK:
355 flagstr = "NETMASK";
356 break;
357 #ifdef RTA_GENMASK
358 case RTA_GENMASK:
359 flagstr = "GENMASK";
360 break;
361 #endif /* RTA_GENMASK */
362 case RTA_IFP:
363 flagstr = "IFP";
364 break;
365 case RTA_IFA:
366 flagstr = "IFA";
367 break;
368 #ifdef RTA_AUTHOR
369 case RTA_AUTHOR:
370 flagstr = "AUTHOR";
371 break;
372 #endif /* RTA_AUTHOR */
373 case RTA_BRD:
374 flagstr = "BRD";
375 break;
376 #ifdef RTA_SRC
377 case RTA_SRC:
378 flagstr = "SRC";
379 break;
380 #endif /* RTA_SRC */
381 #ifdef RTA_SRCMASK
382 case RTA_SRCMASK:
383 flagstr = "SRCMASK";
384 break;
385 #endif /* RTA_SRCMASK */
386 #ifdef RTA_LABEL
387 case RTA_LABEL:
388 flagstr = "LABEL";
389 break;
390 #endif /* RTA_LABEL */
391
392 default:
393 snprintf(ustr, sizeof(ustr), "0x%x", bit);
394 flagstr = ustr;
395 break;
396 }
397
398 wlen = snprintf(buf, buflen, "%s,", flagstr);
399 buf += wlen;
400 buflen -= wlen;
401 }
402
403 /* Check for empty buffer. */
404 if (bufstart != buf)
405 buf--;
406
407 /* Remove the last comma. */
408 *buf = 0;
409
410 return bufstart;
411 }
412
413 /* Dump routing table flag for debug purpose. */
414 static void rtm_flag_dump(int flag)
415 {
416 const struct message *mes;
417 static char buf[BUFSIZ];
418
419 buf[0] = '\0';
420 for (mes = rtm_flag_str; mes->key != 0; mes++) {
421 if (mes->key & flag) {
422 strlcat(buf, mes->str, BUFSIZ);
423 strlcat(buf, " ", BUFSIZ);
424 }
425 }
426 zlog_debug("Kernel: %s", buf);
427 }
428
429 #ifdef RTM_IFANNOUNCE
430 /* Interface adding function */
431 static int ifan_read(struct if_announcemsghdr *ifan)
432 {
433 struct interface *ifp;
434
435 ifp = if_lookup_by_index(ifan->ifan_index, VRF_DEFAULT);
436
437 if (ifp)
438 assert((ifp->ifindex == ifan->ifan_index)
439 || (ifp->ifindex == IFINDEX_INTERNAL));
440
441 if ((ifp == NULL) || ((ifp->ifindex == IFINDEX_INTERNAL)
442 && (ifan->ifan_what == IFAN_ARRIVAL))) {
443 if (IS_ZEBRA_DEBUG_KERNEL)
444 zlog_debug(
445 "%s: creating interface for ifindex %d, name %s",
446 __func__, ifan->ifan_index, ifan->ifan_name);
447
448 /* Create Interface */
449 ifp = if_get_by_name(ifan->ifan_name, VRF_DEFAULT,
450 VRF_DEFAULT_NAME);
451 if_set_index(ifp, ifan->ifan_index);
452
453 if_get_metric(ifp);
454 if_add_update(ifp);
455 } else if (ifp != NULL && ifan->ifan_what == IFAN_DEPARTURE)
456 if_delete_update(&ifp);
457
458 if (ifp) {
459 if_get_flags(ifp);
460 if_get_mtu(ifp);
461 if_get_metric(ifp);
462 }
463 if (IS_ZEBRA_DEBUG_KERNEL)
464 zlog_debug("%s: interface %s index %d", __func__,
465 ifan->ifan_name, ifan->ifan_index);
466
467 return 0;
468 }
469 #endif /* RTM_IFANNOUNCE */
470
471 #ifdef HAVE_BSD_IFI_LINK_STATE
472 /* BSD link detect translation */
473 static void bsd_linkdetect_translate(struct if_msghdr *ifm)
474 {
475 if ((ifm->ifm_data.ifi_link_state >= LINK_STATE_UP)
476 || (ifm->ifm_data.ifi_link_state == LINK_STATE_UNKNOWN))
477 SET_FLAG(ifm->ifm_flags, IFF_RUNNING);
478 else
479 UNSET_FLAG(ifm->ifm_flags, IFF_RUNNING);
480 }
481 #endif /* HAVE_BSD_IFI_LINK_STATE */
482
483 static enum zebra_link_type sdl_to_zebra_link_type(unsigned int sdlt)
484 {
485 switch (sdlt) {
486 case IFT_ETHER:
487 return ZEBRA_LLT_ETHER;
488 case IFT_X25:
489 return ZEBRA_LLT_X25;
490 case IFT_FDDI:
491 return ZEBRA_LLT_FDDI;
492 case IFT_PPP:
493 return ZEBRA_LLT_PPP;
494 case IFT_LOOP:
495 return ZEBRA_LLT_LOOPBACK;
496 case IFT_SLIP:
497 return ZEBRA_LLT_SLIP;
498 case IFT_ARCNET:
499 return ZEBRA_LLT_ARCNET;
500 case IFT_ATM:
501 return ZEBRA_LLT_ATM;
502 case IFT_LOCALTALK:
503 return ZEBRA_LLT_LOCALTLK;
504 case IFT_HIPPI:
505 return ZEBRA_LLT_HIPPI;
506 #ifdef IFT_IEEE1394
507 case IFT_IEEE1394:
508 return ZEBRA_LLT_IEEE1394;
509 #endif
510
511 default:
512 return ZEBRA_LLT_UNKNOWN;
513 }
514 }
515
516 /*
517 * Handle struct if_msghdr obtained from reading routing socket or
518 * sysctl (from interface_list). There may or may not be sockaddrs
519 * present after the header.
520 */
521 int ifm_read(struct if_msghdr *ifm)
522 {
523 struct interface *ifp = NULL;
524 struct sockaddr_dl *sdl = NULL;
525 char ifname[IFNAMSIZ];
526 short ifnlen = 0;
527 int maskbit;
528 caddr_t cp;
529 char fbuf[64];
530
531 /* terminate ifname at head (for strnlen) and tail (for safety) */
532 ifname[IFNAMSIZ - 1] = '\0';
533
534 /* paranoia: sanity check structure */
535 if (ifm->ifm_msglen < sizeof(struct if_msghdr)) {
536 flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
537 "%s: ifm->ifm_msglen %d too short", __func__,
538 ifm->ifm_msglen);
539 return -1;
540 }
541
542 /*
543 * Check for a sockaddr_dl following the message. First, point to
544 * where a socakddr might be if one follows the message.
545 */
546 cp = (void *)(ifm + 1);
547
548 /* Look up for RTA_IFP and skip others. */
549 for (maskbit = 1; maskbit; maskbit <<= 1) {
550 if ((maskbit & ifm->ifm_addrs) == 0)
551 continue;
552 if (maskbit != RTA_IFP) {
553 cp += rta_get(cp, NULL, 0);
554 continue;
555 }
556
557 /* Save the pointer to the structure. */
558 sdl = (struct sockaddr_dl *)cp;
559 cp += rta_getsdlname(cp, ifname, &ifnlen);
560 }
561
562 if (IS_ZEBRA_DEBUG_KERNEL)
563 zlog_debug("%s: sdl ifname %s addrs {%s}", __func__,
564 (ifnlen ? ifname : "(nil)"),
565 rtatostr(ifm->ifm_addrs, fbuf, sizeof(fbuf)));
566
567 /*
568 * Look up on ifindex first, because ifindices are the primary handle
569 * for
570 * interfaces across the user/kernel boundary, for most systems. (Some
571 * messages, such as up/down status changes on NetBSD, do not include a
572 * sockaddr_dl).
573 */
574 if ((ifp = if_lookup_by_index(ifm->ifm_index, VRF_DEFAULT)) != NULL) {
575 /* we have an ifp, verify that the name matches as some systems,
576 * eg Solaris, have a 1:many association of ifindex:ifname
577 * if they dont match, we dont have the correct ifp and should
578 * set it back to NULL to let next check do lookup by name
579 */
580 if (ifnlen && (strncmp(ifp->name, ifname, IFNAMSIZ) != 0)) {
581 if (IS_ZEBRA_DEBUG_KERNEL)
582 zlog_debug(
583 "%s: ifp name %s doesn't match sdl name %s",
584 __func__, ifp->name, ifname);
585 ifp = NULL;
586 }
587 }
588
589 /*
590 * If we dont have an ifp, try looking up by name. Particularly as some
591 * systems (Solaris) have a 1:many mapping of ifindex:ifname - the
592 * ifname
593 * is therefore our unique handle to that interface.
594 *
595 * Interfaces specified in the configuration file for which the ifindex
596 * has not been determined will have ifindex == IFINDEX_INTERNAL, and
597 * such
598 * interfaces are found by this search, and then their ifindex values
599 * can
600 * be filled in.
601 */
602 if ((ifp == NULL) && ifnlen)
603 ifp = if_lookup_by_name(ifname, VRF_DEFAULT);
604
605 /*
606 * If ifp still does not exist or has an invalid index
607 * (IFINDEX_INTERNAL),
608 * create or fill in an interface.
609 */
610 if ((ifp == NULL) || (ifp->ifindex == IFINDEX_INTERNAL)) {
611 /*
612 * To create or fill in an interface, a sockaddr_dl (via
613 * RTA_IFP) is required.
614 */
615 if (!ifnlen) {
616 zlog_debug("Interface index %d (new) missing ifname",
617 ifm->ifm_index);
618 return -1;
619 }
620
621 #ifndef RTM_IFANNOUNCE
622 /* Down->Down interface should be ignored here.
623 * See further comment below.
624 */
625 if (!CHECK_FLAG(ifm->ifm_flags, IFF_UP))
626 return 0;
627 #endif /* !RTM_IFANNOUNCE */
628
629 if (ifp == NULL) {
630 /* Interface that zebra was not previously aware of, so
631 * create. */
632 ifp = if_get_by_name(ifname, VRF_DEFAULT,
633 VRF_DEFAULT_NAME);
634 if (IS_ZEBRA_DEBUG_KERNEL)
635 zlog_debug("%s: creating ifp for ifindex %d",
636 __func__, ifm->ifm_index);
637 }
638
639 if (IS_ZEBRA_DEBUG_KERNEL)
640 zlog_debug(
641 "%s: updated/created ifp, ifname %s, ifindex %d",
642 __func__, ifp->name, ifp->ifindex);
643 /*
644 * Fill in newly created interface structure, or larval
645 * structure with ifindex IFINDEX_INTERNAL.
646 */
647 if_set_index(ifp, ifm->ifm_index);
648
649 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
650 bsd_linkdetect_translate(ifm);
651 #endif /* HAVE_BSD_IFI_LINK_STATE */
652
653 if_flags_update(ifp, ifm->ifm_flags);
654 #if defined(__bsdi__)
655 if_kvm_get_mtu(ifp);
656 #else
657 if_get_mtu(ifp);
658 #endif /* __bsdi__ */
659 if_get_metric(ifp);
660
661 /*
662 * XXX sockaddr_dl contents can be larger than the structure
663 * definition. There are 2 big families here:
664 * - BSD has sdl_len + sdl_data[16] + overruns sdl_data
665 * we MUST use sdl_len here or we'll truncate data.
666 * - Solaris has no sdl_len, but sdl_data[244]
667 * presumably, it's not going to run past that, so sizeof()
668 * is fine here.
669 * a nonzero ifnlen from rta_getsdlname() means sdl is valid
670 */
671 ifp->ll_type = ZEBRA_LLT_UNKNOWN;
672 ifp->hw_addr_len = 0;
673 if (ifnlen) {
674 #ifdef HAVE_STRUCT_SOCKADDR_DL_SDL_LEN
675 memcpy(&((struct zebra_if *)ifp->info)->sdl, sdl,
676 sdl->sdl_len);
677 #else
678 memcpy(&((struct zebra_if *)ifp->info)->sdl, sdl,
679 sizeof(struct sockaddr_dl));
680 #endif /* HAVE_STRUCT_SOCKADDR_DL_SDL_LEN */
681
682 ifp->ll_type = sdl_to_zebra_link_type(sdl->sdl_type);
683 if (sdl->sdl_alen <= sizeof(ifp->hw_addr)) {
684 memcpy(ifp->hw_addr, LLADDR(sdl),
685 sdl->sdl_alen);
686 ifp->hw_addr_len = sdl->sdl_alen;
687 }
688 }
689
690 if_add_update(ifp);
691 } else
692 /*
693 * Interface structure exists. Adjust stored flags from
694 * notification. If interface has up->down or down->up
695 * transition, call state change routines (to adjust routes,
696 * notify routing daemons, etc.). (Other flag changes are stored
697 * but apparently do not trigger action.)
698 */
699 {
700 if (ifp->ifindex != ifm->ifm_index) {
701 zlog_debug(
702 "%s: index mismatch, ifname %s, ifp index %d, ifm index %d",
703 __func__, ifp->name, ifp->ifindex,
704 ifm->ifm_index);
705 return -1;
706 }
707
708 #ifdef HAVE_BSD_IFI_LINK_STATE /* translate BSD kernel msg for link-state */
709 bsd_linkdetect_translate(ifm);
710 #endif /* HAVE_BSD_IFI_LINK_STATE */
711
712 /* update flags and handle operative->inoperative transition, if
713 * any */
714 if_flags_update(ifp, ifm->ifm_flags);
715
716 #ifndef RTM_IFANNOUNCE
717 if (!if_is_up(ifp)) {
718 /* No RTM_IFANNOUNCE on this platform, so we can never
719 * distinguish between ~IFF_UP and delete. We must
720 * presume
721 * it has been deleted.
722 * Eg, Solaris will not notify us of unplumb.
723 *
724 * XXX: Fixme - this should be runtime detected
725 * So that a binary compiled on a system with IFANNOUNCE
726 * will still behave correctly if run on a platform
727 * without
728 */
729 if_delete_update(&ifp);
730 }
731 #endif /* RTM_IFANNOUNCE */
732 if (ifp && if_is_up(ifp)) {
733 #if defined(__bsdi__)
734 if_kvm_get_mtu(ifp);
735 #else
736 if_get_mtu(ifp);
737 #endif /* __bsdi__ */
738 if_get_metric(ifp);
739 }
740 }
741
742 if (ifp) {
743 #ifdef HAVE_NET_RT_IFLIST
744 ifp->stats = ifm->ifm_data;
745 #endif /* HAVE_NET_RT_IFLIST */
746 ifp->speed = ifm->ifm_data.ifi_baudrate / 1000000;
747
748 if (IS_ZEBRA_DEBUG_KERNEL)
749 zlog_debug("%s: interface %s index %d", __func__,
750 ifp->name, ifp->ifindex);
751 }
752
753 return 0;
754 }
755
756 /* Address read from struct ifa_msghdr. */
757 static void ifam_read_mesg(struct ifa_msghdr *ifm, union sockunion *addr,
758 union sockunion *mask, union sockunion *brd,
759 char *ifname, short *ifnlen)
760 {
761 caddr_t pnt, end;
762 union sockunion dst;
763 union sockunion gateway;
764 int maskbit;
765 char fbuf[64];
766
767 pnt = (caddr_t)(ifm + 1);
768 end = ((caddr_t)ifm) + ifm->ifam_msglen;
769
770 /* Be sure structure is cleared */
771 memset(mask, 0, sizeof(union sockunion));
772 memset(addr, 0, sizeof(union sockunion));
773 memset(brd, 0, sizeof(union sockunion));
774 memset(&dst, 0, sizeof(union sockunion));
775 memset(&gateway, 0, sizeof(union sockunion));
776
777 /* We fetch each socket variable into sockunion. */
778 for (maskbit = 1; maskbit; maskbit <<= 1) {
779 if ((maskbit & ifm->ifam_addrs) == 0)
780 continue;
781
782 switch (maskbit) {
783 case RTA_DST:
784 pnt += rta_get(pnt, &dst, sizeof(dst));
785 break;
786 case RTA_GATEWAY:
787 pnt += rta_get(pnt, &gateway, sizeof(gateway));
788 break;
789 case RTA_NETMASK:
790 pnt += rta_getattr(pnt, mask, sizeof(*mask));
791 break;
792 case RTA_IFP:
793 pnt += rta_getsdlname(pnt, ifname, ifnlen);
794 break;
795 case RTA_IFA:
796 pnt += rta_get(pnt, addr, sizeof(*addr));
797 break;
798 case RTA_BRD:
799 pnt += rta_get(pnt, brd, sizeof(*brd));
800 break;
801
802 default:
803 pnt += rta_get(pnt, NULL, 0);
804 break;
805 }
806
807 if (pnt > end) {
808 zlog_warn("%s: overflow detected (pnt:%p end:%p)",
809 __func__, pnt, end);
810 break;
811 }
812 }
813
814 if (IS_ZEBRA_DEBUG_KERNEL) {
815 switch (sockunion_family(addr)) {
816 case AF_INET:
817 case AF_INET6: {
818 int masklen =
819 (sockunion_family(addr) == AF_INET)
820 ? ip_masklen(mask->sin.sin_addr)
821 : ip6_masklen(mask->sin6.sin6_addr);
822 zlog_debug(
823 "%s: ifindex %d, ifname %s, ifam_addrs {%s}, ifam_flags 0x%x, addr %pSU/%d broad %pSU dst %pSU gateway %pSU",
824 __func__, ifm->ifam_index,
825 (ifnlen ? ifname : "(nil)"),
826 rtatostr(ifm->ifam_addrs, fbuf, sizeof(fbuf)),
827 ifm->ifam_flags, addr, masklen, brd, &dst,
828 &gateway);
829 } break;
830 default:
831 zlog_debug("%s: ifindex %d, ifname %s, ifam_addrs {%s}",
832 __func__, ifm->ifam_index,
833 (ifnlen ? ifname : "(nil)"),
834 rtatostr(ifm->ifam_addrs, fbuf,
835 sizeof(fbuf)));
836 break;
837 }
838 }
839
840 /* Assert read up end point matches to end point */
841 pnt = (caddr_t)ROUNDUP((size_t)pnt);
842 if (pnt != (caddr_t)ROUNDUP((size_t)end))
843 zlog_debug("ifam_read() doesn't read all socket data");
844 }
845
846 /* Interface's address information get. */
847 int ifam_read(struct ifa_msghdr *ifam)
848 {
849 struct interface *ifp = NULL;
850 union sockunion addr, mask, brd;
851 bool dest_same = false;
852 char ifname[INTERFACE_NAMSIZ];
853 short ifnlen = 0;
854 bool isalias = false;
855 uint32_t flags = 0;
856
857 ifname[0] = ifname[INTERFACE_NAMSIZ - 1] = '\0';
858
859 /* Allocate and read address information. */
860 ifam_read_mesg(ifam, &addr, &mask, &brd, ifname, &ifnlen);
861
862 if ((ifp = if_lookup_by_index(ifam->ifam_index, VRF_DEFAULT)) == NULL) {
863 flog_warn(EC_ZEBRA_UNKNOWN_INTERFACE,
864 "%s: no interface for ifname %s, index %d", __func__,
865 ifname, ifam->ifam_index);
866 return -1;
867 }
868
869 if (ifnlen && strncmp(ifp->name, ifname, INTERFACE_NAMSIZ))
870 isalias = true;
871
872 /*
873 * Mark the alias prefixes as secondary
874 */
875 if (isalias)
876 SET_FLAG(flags, ZEBRA_IFA_SECONDARY);
877
878 /* N.B. The info in ifa_msghdr does not tell us whether the RTA_BRD
879 field contains a broadcast address or a peer address, so we are
880 forced to
881 rely upon the interface type. */
882 if (if_is_pointopoint(ifp))
883 SET_FLAG(flags, ZEBRA_IFA_PEER);
884 else {
885 if (memcmp(&addr, &brd, sizeof(addr)) == 0)
886 dest_same = true;
887 }
888
889 #if 0
890 /* it might seem cute to grab the interface metric here, however
891 * we're processing an address update message, and so some systems
892 * (e.g. FBSD) dont bother to fill in ifam_metric. Disabled, but left
893 * in deliberately, as comment.
894 */
895 ifp->metric = ifam->ifam_metric;
896 #endif
897
898 /* Add connected address. */
899 switch (sockunion_family(&addr)) {
900 case AF_INET:
901 if (ifam->ifam_type == RTM_NEWADDR)
902 connected_add_ipv4(ifp, flags, &addr.sin.sin_addr,
903 ip_masklen(mask.sin.sin_addr),
904 dest_same ? NULL : &brd.sin.sin_addr,
905 (isalias ? ifname : NULL),
906 METRIC_MAX);
907 else
908 connected_delete_ipv4(ifp, flags, &addr.sin.sin_addr,
909 ip_masklen(mask.sin.sin_addr),
910 dest_same ? NULL
911 : &brd.sin.sin_addr);
912 break;
913 case AF_INET6:
914 /* Unset interface index from link-local address when IPv6 stack
915 is KAME. */
916 if (IN6_IS_ADDR_LINKLOCAL(&addr.sin6.sin6_addr)) {
917 SET_IN6_LINKLOCAL_IFINDEX(addr.sin6.sin6_addr, 0);
918 }
919
920 if (ifam->ifam_type == RTM_NEWADDR)
921 connected_add_ipv6(ifp, flags, &addr.sin6.sin6_addr,
922 NULL,
923 ip6_masklen(mask.sin6.sin6_addr),
924 (isalias ? ifname : NULL),
925 METRIC_MAX);
926 else
927 connected_delete_ipv6(ifp, &addr.sin6.sin6_addr, NULL,
928 ip6_masklen(mask.sin6.sin6_addr));
929 break;
930 default:
931 /* Unsupported family silently ignore... */
932 break;
933 }
934
935 /* Check interface flag for implicit up of the interface. */
936 if_refresh(ifp);
937
938 return 0;
939 }
940
941 /* Interface function for reading kernel routing table information. */
942 static int rtm_read_mesg(struct rt_msghdr *rtm, union sockunion *dest,
943 union sockunion *mask, union sockunion *gate,
944 char *ifname, short *ifnlen)
945 {
946 caddr_t pnt, end;
947 int maskbit;
948
949 /* Pnt points out socket data start point. */
950 pnt = (caddr_t)(rtm + 1);
951 end = ((caddr_t)rtm) + rtm->rtm_msglen;
952
953 /* rt_msghdr version check. */
954 if (rtm->rtm_version != RTM_VERSION)
955 flog_warn(EC_ZEBRA_RTM_VERSION_MISMATCH,
956 "Routing message version different %d should be %d.This may cause problem",
957 rtm->rtm_version, RTM_VERSION);
958
959 /* Be sure structure is cleared */
960 memset(dest, 0, sizeof(union sockunion));
961 memset(gate, 0, sizeof(union sockunion));
962 memset(mask, 0, sizeof(union sockunion));
963
964 /* We fetch each socket variable into sockunion. */
965 /* We fetch each socket variable into sockunion. */
966 for (maskbit = 1; maskbit; maskbit <<= 1) {
967 if ((maskbit & rtm->rtm_addrs) == 0)
968 continue;
969
970 switch (maskbit) {
971 case RTA_DST:
972 pnt += rta_get(pnt, dest, sizeof(*dest));
973 break;
974 case RTA_GATEWAY:
975 pnt += rta_get(pnt, gate, sizeof(*gate));
976 break;
977 case RTA_NETMASK:
978 pnt += rta_getattr(pnt, mask, sizeof(*mask));
979 break;
980 case RTA_IFP:
981 pnt += rta_getsdlname(pnt, ifname, ifnlen);
982 break;
983
984 default:
985 pnt += rta_get(pnt, NULL, 0);
986 break;
987 }
988
989 if (pnt > end) {
990 zlog_warn("%s: overflow detected (pnt:%p end:%p)",
991 __func__, pnt, end);
992 break;
993 }
994 }
995
996 /* If there is netmask information set it's family same as
997 destination family*/
998 if (rtm->rtm_addrs & RTA_NETMASK)
999 mask->sa.sa_family = dest->sa.sa_family;
1000
1001 /* Assert read up to the end of pointer. */
1002 if (pnt != end)
1003 zlog_debug("rtm_read() doesn't read all socket data.");
1004
1005 return rtm->rtm_flags;
1006 }
1007
1008 void rtm_read(struct rt_msghdr *rtm)
1009 {
1010 int flags;
1011 uint32_t zebra_flags;
1012 union sockunion dest, mask, gate;
1013 char ifname[INTERFACE_NAMSIZ + 1];
1014 short ifnlen = 0;
1015 struct nexthop nh;
1016 struct prefix p;
1017 ifindex_t ifindex = 0;
1018 afi_t afi;
1019 char fbuf[64];
1020 int32_t proto = ZEBRA_ROUTE_KERNEL;
1021 uint8_t distance = 0;
1022
1023 zebra_flags = 0;
1024
1025 /* Read destination and netmask and gateway from rtm message
1026 structure. */
1027 flags = rtm_read_mesg(rtm, &dest, &mask, &gate, ifname, &ifnlen);
1028 if (!(flags & RTF_DONE))
1029 return;
1030 if (IS_ZEBRA_DEBUG_KERNEL)
1031 zlog_debug("%s: got rtm of type %d (%s) addrs {%s}", __func__,
1032 rtm->rtm_type,
1033 lookup_msg(rtm_type_str, rtm->rtm_type, NULL),
1034 rtatostr(rtm->rtm_addrs, fbuf, sizeof(fbuf)));
1035
1036 #ifdef RTF_CLONED /*bsdi, netbsd 1.6*/
1037 if (flags & RTF_CLONED)
1038 return;
1039 #endif
1040 #ifdef RTF_WASCLONED /*freebsd*/
1041 if (flags & RTF_WASCLONED)
1042 return;
1043 #endif
1044
1045 if ((rtm->rtm_type == RTM_ADD || rtm->rtm_type == RTM_CHANGE)
1046 && !(flags & RTF_UP))
1047 return;
1048
1049 /* This is connected route. */
1050 if (!(flags & RTF_GATEWAY))
1051 return;
1052
1053 if (flags & RTF_PROTO1) {
1054 SET_FLAG(zebra_flags, ZEBRA_FLAG_SELFROUTE);
1055 proto = ZEBRA_ROUTE_STATIC;
1056 distance = 255;
1057 }
1058
1059 memset(&nh, 0, sizeof(nh));
1060
1061 nh.vrf_id = VRF_DEFAULT;
1062 /* This is a reject or blackhole route */
1063 if (flags & RTF_REJECT) {
1064 nh.type = NEXTHOP_TYPE_BLACKHOLE;
1065 nh.bh_type = BLACKHOLE_REJECT;
1066 } else if (flags & RTF_BLACKHOLE) {
1067 nh.type = NEXTHOP_TYPE_BLACKHOLE;
1068 nh.bh_type = BLACKHOLE_NULL;
1069 }
1070
1071 /*
1072 * Ignore our own messages.
1073 */
1074 if (rtm->rtm_type != RTM_GET && rtm->rtm_pid == pid)
1075 return;
1076
1077 if (dest.sa.sa_family == AF_INET) {
1078 afi = AFI_IP;
1079 p.family = AF_INET;
1080 p.u.prefix4 = dest.sin.sin_addr;
1081 if (flags & RTF_HOST)
1082 p.prefixlen = IPV4_MAX_BITLEN;
1083 else
1084 p.prefixlen = ip_masklen(mask.sin.sin_addr);
1085
1086 if (!nh.type) {
1087 nh.type = NEXTHOP_TYPE_IPV4;
1088 nh.gate.ipv4 = gate.sin.sin_addr;
1089 }
1090 } else if (dest.sa.sa_family == AF_INET6) {
1091 afi = AFI_IP6;
1092 p.family = AF_INET6;
1093 p.u.prefix6 = dest.sin6.sin6_addr;
1094 if (flags & RTF_HOST)
1095 p.prefixlen = IPV6_MAX_BITLEN;
1096 else
1097 p.prefixlen = ip6_masklen(mask.sin6.sin6_addr);
1098
1099 #ifdef KAME
1100 if (IN6_IS_ADDR_LINKLOCAL(&gate.sin6.sin6_addr)) {
1101 ifindex = IN6_LINKLOCAL_IFINDEX(gate.sin6.sin6_addr);
1102 SET_IN6_LINKLOCAL_IFINDEX(gate.sin6.sin6_addr, 0);
1103 }
1104 #endif /* KAME */
1105
1106 if (!nh.type) {
1107 nh.type = ifindex ? NEXTHOP_TYPE_IPV6_IFINDEX
1108 : NEXTHOP_TYPE_IPV6;
1109 nh.gate.ipv6 = gate.sin6.sin6_addr;
1110 nh.ifindex = ifindex;
1111 }
1112 } else
1113 return;
1114
1115 if (rtm->rtm_type == RTM_GET || rtm->rtm_type == RTM_ADD
1116 || rtm->rtm_type == RTM_CHANGE)
1117 rib_add(afi, SAFI_UNICAST, VRF_DEFAULT, proto, 0, zebra_flags,
1118 &p, NULL, &nh, 0, RT_TABLE_MAIN, 0, 0, distance, 0,
1119 false);
1120 else
1121 rib_delete(afi, SAFI_UNICAST, VRF_DEFAULT, proto, 0,
1122 zebra_flags, &p, NULL, &nh, 0, RT_TABLE_MAIN, 0,
1123 distance, true);
1124 }
1125
1126 /* Interface function for the kernel routing table updates. Support
1127 * for RTM_CHANGE will be needed.
1128 * Exported only for rt_socket.c
1129 */
1130 int rtm_write(int message, union sockunion *dest, union sockunion *mask,
1131 union sockunion *gate, union sockunion *mpls, unsigned int index,
1132 enum blackhole_type bh_type, int metric)
1133 {
1134 int ret;
1135 caddr_t pnt;
1136 struct interface *ifp;
1137
1138 /* Sequencial number of routing message. */
1139 static int msg_seq = 0;
1140
1141 /* Struct of rt_msghdr and buffer for storing socket's data. */
1142 struct {
1143 struct rt_msghdr rtm;
1144 char buf[512];
1145 } msg;
1146
1147 if (dplane_routing_sock < 0)
1148 return ZEBRA_ERR_EPERM;
1149
1150 /* Clear and set rt_msghdr values */
1151 memset(&msg, 0, sizeof(msg));
1152 msg.rtm.rtm_version = RTM_VERSION;
1153 msg.rtm.rtm_type = message;
1154 msg.rtm.rtm_seq = msg_seq++;
1155 msg.rtm.rtm_addrs = RTA_DST;
1156 msg.rtm.rtm_addrs |= RTA_GATEWAY;
1157 msg.rtm.rtm_flags = RTF_UP;
1158 #ifdef __OpenBSD__
1159 msg.rtm.rtm_flags |= RTF_MPATH;
1160 msg.rtm.rtm_fmask = RTF_MPLS;
1161 #endif
1162 msg.rtm.rtm_index = index;
1163
1164 if (metric != 0) {
1165 msg.rtm.rtm_rmx.rmx_hopcount = metric;
1166 msg.rtm.rtm_inits |= RTV_HOPCOUNT;
1167 }
1168
1169 ifp = if_lookup_by_index(index, VRF_DEFAULT);
1170
1171 if (gate && (message == RTM_ADD || message == RTM_CHANGE))
1172 msg.rtm.rtm_flags |= RTF_GATEWAY;
1173
1174 /* When RTF_CLONING is unavailable on BSD, should we set some
1175 * other flag instead?
1176 */
1177 #ifdef RTF_CLONING
1178 if (!gate && (message == RTM_ADD || message == RTM_CHANGE) && ifp
1179 && (ifp->flags & IFF_POINTOPOINT) == 0)
1180 msg.rtm.rtm_flags |= RTF_CLONING;
1181 #endif /* RTF_CLONING */
1182
1183 /* If no protocol specific gateway is specified, use link
1184 address for gateway. */
1185 if (!gate) {
1186 if (!ifp) {
1187 char dest_buf[INET_ADDRSTRLEN] = "NULL",
1188 mask_buf[INET_ADDRSTRLEN] = "255.255.255.255";
1189 if (dest)
1190 inet_ntop(AF_INET, &dest->sin.sin_addr,
1191 dest_buf, INET_ADDRSTRLEN);
1192 if (mask)
1193 inet_ntop(AF_INET, &mask->sin.sin_addr,
1194 mask_buf, INET_ADDRSTRLEN);
1195 flog_warn(
1196 EC_ZEBRA_RTM_NO_GATEWAY,
1197 "%s: %s/%s: gate == NULL and no gateway found for ifindex %d",
1198 __func__, dest_buf, mask_buf, index);
1199 return -1;
1200 }
1201 gate = (union sockunion *)&((struct zebra_if *)ifp->info)->sdl;
1202 }
1203
1204 if (mask)
1205 msg.rtm.rtm_addrs |= RTA_NETMASK;
1206 else if (message == RTM_ADD || message == RTM_CHANGE)
1207 msg.rtm.rtm_flags |= RTF_HOST;
1208
1209 #ifdef __OpenBSD__
1210 if (mpls) {
1211 msg.rtm.rtm_addrs |= RTA_SRC;
1212 msg.rtm.rtm_flags |= RTF_MPLS;
1213
1214 if (mpls->smpls.smpls_label
1215 != htonl(MPLS_LABEL_IMPLICIT_NULL << MPLS_LABEL_OFFSET))
1216 msg.rtm.rtm_mpls = MPLS_OP_PUSH;
1217 }
1218 #endif
1219
1220 /* Tagging route with flags */
1221 msg.rtm.rtm_flags |= (RTF_PROTO1);
1222
1223 switch (bh_type) {
1224 case BLACKHOLE_UNSPEC:
1225 break;
1226 case BLACKHOLE_REJECT:
1227 msg.rtm.rtm_flags |= RTF_REJECT;
1228 break;
1229 case BLACKHOLE_NULL:
1230 case BLACKHOLE_ADMINPROHIB:
1231 msg.rtm.rtm_flags |= RTF_BLACKHOLE;
1232 break;
1233 }
1234
1235
1236 #define SOCKADDRSET(X, R) \
1237 if (msg.rtm.rtm_addrs & (R)) { \
1238 int len = SAROUNDUP(X); \
1239 memcpy(pnt, (caddr_t)(X), len); \
1240 pnt += len; \
1241 }
1242
1243 pnt = (caddr_t)msg.buf;
1244
1245 /* Write each socket data into rtm message buffer */
1246 SOCKADDRSET(dest, RTA_DST);
1247 SOCKADDRSET(gate, RTA_GATEWAY);
1248 SOCKADDRSET(mask, RTA_NETMASK);
1249 #ifdef __OpenBSD__
1250 SOCKADDRSET(mpls, RTA_SRC);
1251 #endif
1252
1253 msg.rtm.rtm_msglen = pnt - (caddr_t)&msg;
1254
1255 ret = write(dplane_routing_sock, &msg, msg.rtm.rtm_msglen);
1256
1257 if (ret != msg.rtm.rtm_msglen) {
1258 if (errno == EEXIST)
1259 return ZEBRA_ERR_RTEXIST;
1260 if (errno == ENETUNREACH)
1261 return ZEBRA_ERR_RTUNREACH;
1262 if (errno == ESRCH)
1263 return ZEBRA_ERR_RTNOEXIST;
1264
1265 flog_err_sys(EC_LIB_SOCKET, "%s: write : %s (%d)", __func__,
1266 safe_strerror(errno), errno);
1267 return ZEBRA_ERR_KERNEL;
1268 }
1269 return ZEBRA_ERR_NOERROR;
1270 }
1271
1272
1273 #include "thread.h"
1274 #include "zebra/zserv.h"
1275
1276 /* For debug purpose. */
1277 static void rtmsg_debug(struct rt_msghdr *rtm)
1278 {
1279 char fbuf[64];
1280
1281 zlog_debug("Kernel: Len: %d Type: %s", rtm->rtm_msglen,
1282 lookup_msg(rtm_type_str, rtm->rtm_type, NULL));
1283 rtm_flag_dump(rtm->rtm_flags);
1284 zlog_debug("Kernel: message seq %d", rtm->rtm_seq);
1285 zlog_debug("Kernel: pid %lld, rtm_addrs {%s}", (long long)rtm->rtm_pid,
1286 rtatostr(rtm->rtm_addrs, fbuf, sizeof(fbuf)));
1287 }
1288
1289 /* This is pretty gross, better suggestions welcome -- mhandler */
1290 #ifndef RTAX_MAX
1291 #ifdef RTA_NUMBITS
1292 #define RTAX_MAX RTA_NUMBITS
1293 #else
1294 #define RTAX_MAX 8
1295 #endif /* RTA_NUMBITS */
1296 #endif /* RTAX_MAX */
1297
1298 /* Kernel routing table and interface updates via routing socket. */
1299 static void kernel_read(struct thread *thread)
1300 {
1301 int sock;
1302 int nbytes;
1303 struct rt_msghdr *rtm;
1304
1305 /*
1306 * This must be big enough for any message the kernel might send.
1307 * Rather than determining how many sockaddrs of what size might be
1308 * in each particular message, just use RTAX_MAX of sockaddr_storage
1309 * for each. Note that the sockaddrs must be after each message
1310 * definition, or rather after whichever happens to be the largest,
1311 * since the buffer needs to be big enough for a message and the
1312 * sockaddrs together.
1313 */
1314 union {
1315 /* Routing information. */
1316 struct {
1317 struct rt_msghdr rtm;
1318 struct sockaddr_storage addr[RTAX_MAX];
1319 } r;
1320
1321 /* Interface information. */
1322 struct {
1323 struct if_msghdr ifm;
1324 struct sockaddr_storage addr[RTAX_MAX];
1325 } im;
1326
1327 /* Interface address information. */
1328 struct {
1329 struct ifa_msghdr ifa;
1330 struct sockaddr_storage addr[RTAX_MAX];
1331 } ia;
1332
1333 #ifdef RTM_IFANNOUNCE
1334 /* Interface arrival/departure */
1335 struct {
1336 struct if_announcemsghdr ifan;
1337 struct sockaddr_storage addr[RTAX_MAX];
1338 } ian;
1339 #endif /* RTM_IFANNOUNCE */
1340
1341 } buf;
1342
1343 /* Fetch routing socket. */
1344 sock = THREAD_FD(thread);
1345
1346 nbytes = read(sock, &buf, sizeof(buf));
1347
1348 if (nbytes < 0) {
1349 if (errno == ENOBUFS) {
1350 #ifdef __FreeBSD__
1351 /*
1352 * ENOBUFS indicates a temporary resource
1353 * shortage and is not harmful for consistency of
1354 * reading the routing socket. Ignore it.
1355 */
1356 thread_add_read(zrouter.master, kernel_read, NULL, sock,
1357 NULL);
1358 return;
1359 #else
1360 flog_err(EC_ZEBRA_RECVMSG_OVERRUN,
1361 "routing socket overrun: %s",
1362 safe_strerror(errno));
1363 /*
1364 * In this case we are screwed.
1365 * There is no good way to
1366 * recover zebra at this point.
1367 */
1368 exit(-1);
1369 #endif
1370 }
1371 if (errno != EAGAIN && errno != EWOULDBLOCK)
1372 flog_err_sys(EC_LIB_SOCKET, "routing socket error: %s",
1373 safe_strerror(errno));
1374 return;
1375 }
1376
1377 if (nbytes == 0)
1378 return;
1379
1380 thread_add_read(zrouter.master, kernel_read, NULL, sock, NULL);
1381
1382 if (IS_ZEBRA_DEBUG_KERNEL)
1383 rtmsg_debug(&buf.r.rtm);
1384
1385 rtm = &buf.r.rtm;
1386
1387 /*
1388 * Ensure that we didn't drop any data, so that processing routines
1389 * can assume they have the whole message.
1390 */
1391 if (rtm->rtm_msglen != nbytes) {
1392 zlog_debug("%s: rtm->rtm_msglen %d, nbytes %d, type %d",
1393 __func__, rtm->rtm_msglen, nbytes, rtm->rtm_type);
1394 return;
1395 }
1396
1397 switch (rtm->rtm_type) {
1398 case RTM_ADD:
1399 case RTM_DELETE:
1400 case RTM_CHANGE:
1401 rtm_read(rtm);
1402 break;
1403 case RTM_IFINFO:
1404 ifm_read(&buf.im.ifm);
1405 break;
1406 case RTM_NEWADDR:
1407 case RTM_DELADDR:
1408 ifam_read(&buf.ia.ifa);
1409 break;
1410 #ifdef RTM_IFANNOUNCE
1411 case RTM_IFANNOUNCE:
1412 ifan_read(&buf.ian.ifan);
1413 break;
1414 #endif /* RTM_IFANNOUNCE */
1415 default:
1416 if (IS_ZEBRA_DEBUG_KERNEL)
1417 zlog_debug(
1418 "Unprocessed RTM_type: %s(%d)",
1419 lookup_msg(rtm_type_str, rtm->rtm_type, NULL),
1420 rtm->rtm_type);
1421 break;
1422 }
1423 }
1424
1425 /* Make routing socket. */
1426 static void routing_socket(struct zebra_ns *zns)
1427 {
1428 uint32_t default_rcvbuf;
1429 socklen_t optlen;
1430
1431 frr_with_privs(&zserv_privs) {
1432 routing_sock = ns_socket(AF_ROUTE, SOCK_RAW, 0, zns->ns_id);
1433
1434 dplane_routing_sock =
1435 ns_socket(AF_ROUTE, SOCK_RAW, 0, zns->ns_id);
1436 }
1437
1438 if (routing_sock < 0) {
1439 flog_err_sys(EC_LIB_SOCKET, "Can't init kernel routing socket");
1440 return;
1441 }
1442
1443 if (dplane_routing_sock < 0) {
1444 flog_err_sys(EC_LIB_SOCKET,
1445 "Can't init kernel dataplane routing socket");
1446 return;
1447 }
1448
1449 #ifdef SO_RERROR
1450 /* Allow reporting of route(4) buffer overflow errors */
1451 int n = 1;
1452
1453 if (setsockopt(routing_sock, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) < 0)
1454 flog_err_sys(EC_LIB_SOCKET,
1455 "Can't set SO_RERROR on routing socket");
1456 #endif
1457
1458 /* XXX: Socket should be NONBLOCK, however as we currently
1459 * discard failed writes, this will lead to inconsistencies.
1460 * For now, socket must be blocking.
1461 */
1462 /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
1463 zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
1464
1465 /*
1466 * Attempt to set a more useful receive buffer size
1467 */
1468 optlen = sizeof(default_rcvbuf);
1469 if (getsockopt(routing_sock, SOL_SOCKET, SO_RCVBUF, &default_rcvbuf,
1470 &optlen) == -1)
1471 flog_err_sys(EC_LIB_SOCKET,
1472 "routing_sock sockopt SOL_SOCKET SO_RCVBUF");
1473 else {
1474 for (; rcvbufsize > default_rcvbuf &&
1475 setsockopt(routing_sock, SOL_SOCKET, SO_RCVBUF,
1476 &rcvbufsize, sizeof(rcvbufsize)) == -1 &&
1477 errno == ENOBUFS;
1478 rcvbufsize /= 2)
1479 ;
1480 }
1481
1482 /* kernel_read needs rewrite. */
1483 thread_add_read(zrouter.master, kernel_read, NULL, routing_sock, NULL);
1484 }
1485
1486 /* Exported interface function. This function simply calls
1487 routing_socket (). */
1488 void kernel_init(struct zebra_ns *zns)
1489 {
1490 routing_socket(zns);
1491 }
1492
1493 void kernel_terminate(struct zebra_ns *zns, bool complete)
1494 {
1495 return;
1496 }
1497
1498 /*
1499 * Global init for platform-/OS-specific things
1500 */
1501 void kernel_router_init(void)
1502 {
1503 }
1504
1505 /*
1506 * Global deinit for platform-/OS-specific things
1507 */
1508 void kernel_router_terminate(void)
1509 {
1510 }
1511
1512 /*
1513 * Called by the dplane pthread to read incoming OS messages and dispatch them.
1514 */
1515 int kernel_dplane_read(struct zebra_dplane_info *info)
1516 {
1517 return 0;
1518 }
1519
1520 void kernel_update_multi(struct dplane_ctx_list_head *ctx_list)
1521 {
1522 struct zebra_dplane_ctx *ctx;
1523 struct dplane_ctx_list_head handled_list;
1524 enum zebra_dplane_result res = ZEBRA_DPLANE_REQUEST_SUCCESS;
1525
1526 dplane_ctx_q_init(&handled_list);
1527
1528 while (true) {
1529 ctx = dplane_ctx_dequeue(ctx_list);
1530 if (ctx == NULL)
1531 break;
1532
1533 /*
1534 * A previous provider plugin may have asked to skip the
1535 * kernel update.
1536 */
1537 if (dplane_ctx_is_skip_kernel(ctx)) {
1538 res = ZEBRA_DPLANE_REQUEST_SUCCESS;
1539 goto skip_one;
1540 }
1541
1542 switch (dplane_ctx_get_op(ctx)) {
1543
1544 case DPLANE_OP_ROUTE_INSTALL:
1545 case DPLANE_OP_ROUTE_UPDATE:
1546 case DPLANE_OP_ROUTE_DELETE:
1547 res = kernel_route_update(ctx);
1548 break;
1549
1550 case DPLANE_OP_NH_INSTALL:
1551 case DPLANE_OP_NH_UPDATE:
1552 case DPLANE_OP_NH_DELETE:
1553 res = kernel_nexthop_update(ctx);
1554 break;
1555
1556 case DPLANE_OP_LSP_INSTALL:
1557 case DPLANE_OP_LSP_UPDATE:
1558 case DPLANE_OP_LSP_DELETE:
1559 res = kernel_lsp_update(ctx);
1560 break;
1561
1562 case DPLANE_OP_PW_INSTALL:
1563 case DPLANE_OP_PW_UNINSTALL:
1564 res = kernel_pw_update(ctx);
1565 break;
1566
1567 case DPLANE_OP_ADDR_INSTALL:
1568 case DPLANE_OP_ADDR_UNINSTALL:
1569 res = kernel_address_update_ctx(ctx);
1570 break;
1571
1572 case DPLANE_OP_MAC_INSTALL:
1573 case DPLANE_OP_MAC_DELETE:
1574 res = kernel_mac_update_ctx(ctx);
1575 break;
1576
1577 case DPLANE_OP_NEIGH_INSTALL:
1578 case DPLANE_OP_NEIGH_UPDATE:
1579 case DPLANE_OP_NEIGH_DELETE:
1580 case DPLANE_OP_VTEP_ADD:
1581 case DPLANE_OP_VTEP_DELETE:
1582 case DPLANE_OP_NEIGH_DISCOVER:
1583 res = kernel_neigh_update_ctx(ctx);
1584 break;
1585
1586 case DPLANE_OP_RULE_ADD:
1587 case DPLANE_OP_RULE_DELETE:
1588 case DPLANE_OP_RULE_UPDATE:
1589 res = kernel_pbr_rule_update(ctx);
1590 break;
1591
1592 case DPLANE_OP_INTF_INSTALL:
1593 case DPLANE_OP_INTF_UPDATE:
1594 case DPLANE_OP_INTF_DELETE:
1595 res = kernel_intf_update(ctx);
1596 break;
1597
1598 case DPLANE_OP_TC_QDISC_INSTALL:
1599 case DPLANE_OP_TC_QDISC_UNINSTALL:
1600 case DPLANE_OP_TC_CLASS_ADD:
1601 case DPLANE_OP_TC_CLASS_DELETE:
1602 case DPLANE_OP_TC_CLASS_UPDATE:
1603 case DPLANE_OP_TC_FILTER_ADD:
1604 case DPLANE_OP_TC_FILTER_DELETE:
1605 case DPLANE_OP_TC_FILTER_UPDATE:
1606 res = kernel_tc_update(ctx);
1607 break;
1608
1609 /* Ignore 'notifications' - no-op */
1610 case DPLANE_OP_SYS_ROUTE_ADD:
1611 case DPLANE_OP_SYS_ROUTE_DELETE:
1612 case DPLANE_OP_ROUTE_NOTIFY:
1613 case DPLANE_OP_LSP_NOTIFY:
1614 res = ZEBRA_DPLANE_REQUEST_SUCCESS;
1615 break;
1616
1617 case DPLANE_OP_INTF_NETCONFIG:
1618 res = kernel_intf_netconf_update(ctx);
1619 break;
1620
1621 case DPLANE_OP_NONE:
1622 case DPLANE_OP_BR_PORT_UPDATE:
1623 case DPLANE_OP_IPTABLE_ADD:
1624 case DPLANE_OP_IPTABLE_DELETE:
1625 case DPLANE_OP_IPSET_ADD:
1626 case DPLANE_OP_IPSET_DELETE:
1627 case DPLANE_OP_IPSET_ENTRY_ADD:
1628 case DPLANE_OP_IPSET_ENTRY_DELETE:
1629 case DPLANE_OP_NEIGH_IP_INSTALL:
1630 case DPLANE_OP_NEIGH_IP_DELETE:
1631 case DPLANE_OP_NEIGH_TABLE_UPDATE:
1632 case DPLANE_OP_GRE_SET:
1633 case DPLANE_OP_INTF_ADDR_ADD:
1634 case DPLANE_OP_INTF_ADDR_DEL:
1635 zlog_err("Unhandled dplane data for %s",
1636 dplane_op2str(dplane_ctx_get_op(ctx)));
1637 res = ZEBRA_DPLANE_REQUEST_FAILURE;
1638 }
1639
1640 skip_one:
1641 dplane_ctx_set_status(ctx, res);
1642
1643 dplane_ctx_enqueue_tail(&handled_list, ctx);
1644 }
1645
1646 dplane_ctx_q_init(ctx_list);
1647 dplane_ctx_list_append(ctx_list, &handled_list);
1648 }
1649
1650 #endif /* !HAVE_NETLINK */
FRRouting mirror