]> git.proxmox.com Git - mirror_frr.git/blob - zebra/rt_netlink.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
version RE-0.99.17.6
[mirror_frr.git] / zebra / rt_netlink.c
1 /* Kernel routing table updates using netlink over GNU/Linux system.
2 * Copyright (C) 1997, 98, 99 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
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
19 * 02111-1307, USA.
20 */
21
22 #include <zebra.h>
23
24 /* Hack for GNU libc version 2. */
25 #ifndef MSG_TRUNC
26 #define MSG_TRUNC 0x20
27 #endif /* MSG_TRUNC */
28
29 #include "linklist.h"
30 #include "if.h"
31 #include "log.h"
32 #include "prefix.h"
33 #include "connected.h"
34 #include "table.h"
35 #include "rib.h"
36 #include "thread.h"
37 #include "privs.h"
38
39 #include "zebra/zserv.h"
40 #include "zebra/rt.h"
41 #include "zebra/redistribute.h"
42 #include "zebra/interface.h"
43 #include "zebra/debug.h"
44
45 /* Socket interface to kernel */
46 struct nlsock
47 {
48 int sock;
49 int seq;
50 struct sockaddr_nl snl;
51 const char *name;
52 } netlink = { -1, 0, {0}, "netlink-listen"}, /* kernel messages */
53 netlink_cmd = { -1, 0, {0}, "netlink-cmd"}; /* command channel */
54
55 static const struct message nlmsg_str[] = {
56 {RTM_NEWROUTE, "RTM_NEWROUTE"},
57 {RTM_DELROUTE, "RTM_DELROUTE"},
58 {RTM_GETROUTE, "RTM_GETROUTE"},
59 {RTM_NEWLINK, "RTM_NEWLINK"},
60 {RTM_DELLINK, "RTM_DELLINK"},
61 {RTM_GETLINK, "RTM_GETLINK"},
62 {RTM_NEWADDR, "RTM_NEWADDR"},
63 {RTM_DELADDR, "RTM_DELADDR"},
64 {RTM_GETADDR, "RTM_GETADDR"},
65 {0, NULL}
66 };
67
68 static const char *nexthop_types_desc[] =
69 {
70 "none",
71 "Directly connected",
72 "Interface route",
73 "IPv4 nexthop",
74 "IPv4 nexthop with ifindex",
75 "IPv4 nexthop with ifname",
76 "IPv6 nexthop",
77 "IPv6 nexthop with ifindex",
78 "IPv6 nexthop with ifname",
79 "Null0 nexthop",
80 };
81
82 extern struct zebra_t zebrad;
83
84 extern struct zebra_privs_t zserv_privs;
85
86 extern u_int32_t nl_rcvbufsize;
87
88 /* Note: on netlink systems, there should be a 1-to-1 mapping between interface
89 names and ifindex values. */
90 static void
91 set_ifindex(struct interface *ifp, unsigned int ifi_index)
92 {
93 struct interface *oifp;
94
95 if (((oifp = if_lookup_by_index(ifi_index)) != NULL) && (oifp != ifp))
96 {
97 if (ifi_index == IFINDEX_INTERNAL)
98 zlog_err("Netlink is setting interface %s ifindex to reserved "
99 "internal value %u", ifp->name, ifi_index);
100 else
101 {
102 if (IS_ZEBRA_DEBUG_KERNEL)
103 zlog_debug("interface index %d was renamed from %s to %s",
104 ifi_index, oifp->name, ifp->name);
105 if (if_is_up(oifp))
106 zlog_err("interface rename detected on up interface: index %d "
107 "was renamed from %s to %s, results are uncertain!",
108 ifi_index, oifp->name, ifp->name);
109 if_delete_update(oifp);
110 }
111 }
112 ifp->ifindex = ifi_index;
113 }
114
115 static int
116 netlink_recvbuf (struct nlsock *nl, uint32_t newsize)
117 {
118 u_int32_t oldsize;
119 socklen_t newlen = sizeof(newsize);
120 socklen_t oldlen = sizeof(oldsize);
121 int ret;
122
123 ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
124 if (ret < 0)
125 {
126 zlog (NULL, LOG_ERR, "Can't get %s receive buffer size: %s", nl->name,
127 safe_strerror (errno));
128 return -1;
129 }
130
131 ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &nl_rcvbufsize,
132 sizeof(nl_rcvbufsize));
133 if (ret < 0)
134 {
135 zlog (NULL, LOG_ERR, "Can't set %s receive buffer size: %s", nl->name,
136 safe_strerror (errno));
137 return -1;
138 }
139
140 ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
141 if (ret < 0)
142 {
143 zlog (NULL, LOG_ERR, "Can't get %s receive buffer size: %s", nl->name,
144 safe_strerror (errno));
145 return -1;
146 }
147
148 zlog (NULL, LOG_INFO,
149 "Setting netlink socket receive buffer size: %u -> %u",
150 oldsize, newsize);
151 return 0;
152 }
153
154 /* Make socket for Linux netlink interface. */
155 static int
156 netlink_socket (struct nlsock *nl, unsigned long groups)
157 {
158 int ret;
159 struct sockaddr_nl snl;
160 int sock;
161 int namelen;
162 int save_errno;
163
164 sock = socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
165 if (sock < 0)
166 {
167 zlog (NULL, LOG_ERR, "Can't open %s socket: %s", nl->name,
168 safe_strerror (errno));
169 return -1;
170 }
171
172 memset (&snl, 0, sizeof snl);
173 snl.nl_family = AF_NETLINK;
174 snl.nl_groups = groups;
175
176 /* Bind the socket to the netlink structure for anything. */
177 if (zserv_privs.change (ZPRIVS_RAISE))
178 {
179 zlog (NULL, LOG_ERR, "Can't raise privileges");
180 return -1;
181 }
182
183 ret = bind (sock, (struct sockaddr *) &snl, sizeof snl);
184 save_errno = errno;
185 if (zserv_privs.change (ZPRIVS_LOWER))
186 zlog (NULL, LOG_ERR, "Can't lower privileges");
187
188 if (ret < 0)
189 {
190 zlog (NULL, LOG_ERR, "Can't bind %s socket to group 0x%x: %s",
191 nl->name, snl.nl_groups, safe_strerror (save_errno));
192 close (sock);
193 return -1;
194 }
195
196 /* multiple netlink sockets will have different nl_pid */
197 namelen = sizeof snl;
198 ret = getsockname (sock, (struct sockaddr *) &snl, (socklen_t *) &namelen);
199 if (ret < 0 || namelen != sizeof snl)
200 {
201 zlog (NULL, LOG_ERR, "Can't get %s socket name: %s", nl->name,
202 safe_strerror (errno));
203 close (sock);
204 return -1;
205 }
206
207 nl->snl = snl;
208 nl->sock = sock;
209 return ret;
210 }
211
212 /* Get type specified information from netlink. */
213 static int
214 netlink_request (int family, int type, struct nlsock *nl)
215 {
216 int ret;
217 struct sockaddr_nl snl;
218 int save_errno;
219
220 struct
221 {
222 struct nlmsghdr nlh;
223 struct rtgenmsg g;
224 } req;
225
226
227 /* Check netlink socket. */
228 if (nl->sock < 0)
229 {
230 zlog (NULL, LOG_ERR, "%s socket isn't active.", nl->name);
231 return -1;
232 }
233
234 memset (&snl, 0, sizeof snl);
235 snl.nl_family = AF_NETLINK;
236
237 memset (&req, 0, sizeof req);
238 req.nlh.nlmsg_len = sizeof req;
239 req.nlh.nlmsg_type = type;
240 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
241 req.nlh.nlmsg_pid = nl->snl.nl_pid;
242 req.nlh.nlmsg_seq = ++nl->seq;
243 req.g.rtgen_family = family;
244
245 /* linux appears to check capabilities on every message
246 * have to raise caps for every message sent
247 */
248 if (zserv_privs.change (ZPRIVS_RAISE))
249 {
250 zlog (NULL, LOG_ERR, "Can't raise privileges");
251 return -1;
252 }
253
254 ret = sendto (nl->sock, (void *) &req, sizeof req, 0,
255 (struct sockaddr *) &snl, sizeof snl);
256 save_errno = errno;
257
258 if (zserv_privs.change (ZPRIVS_LOWER))
259 zlog (NULL, LOG_ERR, "Can't lower privileges");
260
261 if (ret < 0)
262 {
263 zlog (NULL, LOG_ERR, "%s sendto failed: %s", nl->name,
264 safe_strerror (save_errno));
265 return -1;
266 }
267
268 return 0;
269 }
270
271 /* Receive message from netlink interface and pass those information
272 to the given function. */
273 static int
274 netlink_parse_info (int (*filter) (struct sockaddr_nl *, struct nlmsghdr *),
275 struct nlsock *nl)
276 {
277 int status;
278 int ret = 0;
279 int error;
280
281 while (1)
282 {
283 char buf[4096];
284 struct iovec iov = { buf, sizeof buf };
285 struct sockaddr_nl snl;
286 struct msghdr msg = { (void *) &snl, sizeof snl, &iov, 1, NULL, 0, 0 };
287 struct nlmsghdr *h;
288
289 status = recvmsg (nl->sock, &msg, 0);
290 if (status < 0)
291 {
292 if (errno == EINTR)
293 continue;
294 if (errno == EWOULDBLOCK || errno == EAGAIN)
295 break;
296 zlog (NULL, LOG_ERR, "%s recvmsg overrun: %s",
297 nl->name, safe_strerror(errno));
298 continue;
299 }
300
301 if (status == 0)
302 {
303 zlog (NULL, LOG_ERR, "%s EOF", nl->name);
304 return -1;
305 }
306
307 if (msg.msg_namelen != sizeof snl)
308 {
309 zlog (NULL, LOG_ERR, "%s sender address length error: length %d",
310 nl->name, msg.msg_namelen);
311 return -1;
312 }
313
314 for (h = (struct nlmsghdr *) buf; NLMSG_OK (h, (unsigned int) status);
315 h = NLMSG_NEXT (h, status))
316 {
317 /* Finish of reading. */
318 if (h->nlmsg_type == NLMSG_DONE)
319 return ret;
320
321 /* Error handling. */
322 if (h->nlmsg_type == NLMSG_ERROR)
323 {
324 struct nlmsgerr *err = (struct nlmsgerr *) NLMSG_DATA (h);
325 int errnum = err->error;
326 int msg_type = err->msg.nlmsg_type;
327
328 /* If the error field is zero, then this is an ACK */
329 if (err->error == 0)
330 {
331 if (IS_ZEBRA_DEBUG_KERNEL)
332 {
333 zlog_debug ("%s: %s ACK: type=%s(%u), seq=%u, pid=%u",
334 __FUNCTION__, nl->name,
335 lookup (nlmsg_str, err->msg.nlmsg_type),
336 err->msg.nlmsg_type, err->msg.nlmsg_seq,
337 err->msg.nlmsg_pid);
338 }
339
340 /* return if not a multipart message, otherwise continue */
341 if (!(h->nlmsg_flags & NLM_F_MULTI))
342 {
343 return 0;
344 }
345 continue;
346 }
347
348 if (h->nlmsg_len < NLMSG_LENGTH (sizeof (struct nlmsgerr)))
349 {
350 zlog (NULL, LOG_ERR, "%s error: message truncated",
351 nl->name);
352 return -1;
353 }
354
355 /* Deal with errors that occur because of races in link handling */
356 if (nl == &netlink_cmd
357 && ((msg_type == RTM_DELROUTE &&
358 (-errnum == ENODEV || -errnum == ESRCH))
359 || (msg_type == RTM_NEWROUTE && -errnum == EEXIST)))
360 {
361 if (IS_ZEBRA_DEBUG_KERNEL)
362 zlog_debug ("%s: error: %s type=%s(%u), seq=%u, pid=%u",
363 nl->name, safe_strerror (-errnum),
364 lookup (nlmsg_str, msg_type),
365 msg_type, err->msg.nlmsg_seq, err->msg.nlmsg_pid);
366 return 0;
367 }
368
369 zlog_err ("%s error: %s, type=%s(%u), seq=%u, pid=%u",
370 nl->name, safe_strerror (-errnum),
371 lookup (nlmsg_str, msg_type),
372 msg_type, err->msg.nlmsg_seq, err->msg.nlmsg_pid);
373 return -1;
374 }
375
376 /* OK we got netlink message. */
377 if (IS_ZEBRA_DEBUG_KERNEL)
378 zlog_debug ("netlink_parse_info: %s type %s(%u), seq=%u, pid=%u",
379 nl->name,
380 lookup (nlmsg_str, h->nlmsg_type), h->nlmsg_type,
381 h->nlmsg_seq, h->nlmsg_pid);
382
383 /* skip unsolicited messages originating from command socket */
384 if (nl != &netlink_cmd && h->nlmsg_pid == netlink_cmd.snl.nl_pid)
385 {
386 if (IS_ZEBRA_DEBUG_KERNEL)
387 zlog_debug ("netlink_parse_info: %s packet comes from %s",
388 netlink_cmd.name, nl->name);
389 continue;
390 }
391
392 error = (*filter) (&snl, h);
393 if (error < 0)
394 {
395 zlog (NULL, LOG_ERR, "%s filter function error", nl->name);
396 ret = error;
397 }
398 }
399
400 /* After error care. */
401 if (msg.msg_flags & MSG_TRUNC)
402 {
403 zlog (NULL, LOG_ERR, "%s error: message truncated", nl->name);
404 continue;
405 }
406 if (status)
407 {
408 zlog (NULL, LOG_ERR, "%s error: data remnant size %d", nl->name,
409 status);
410 return -1;
411 }
412 }
413 return ret;
414 }
415
416 /* Utility function for parse rtattr. */
417 static void
418 netlink_parse_rtattr (struct rtattr **tb, int max, struct rtattr *rta,
419 int len)
420 {
421 while (RTA_OK (rta, len))
422 {
423 if (rta->rta_type <= max)
424 tb[rta->rta_type] = rta;
425 rta = RTA_NEXT (rta, len);
426 }
427 }
428
429 /* Called from interface_lookup_netlink(). This function is only used
430 during bootstrap. */
431 static int
432 netlink_interface (struct sockaddr_nl *snl, struct nlmsghdr *h)
433 {
434 int len;
435 struct ifinfomsg *ifi;
436 struct rtattr *tb[IFLA_MAX + 1];
437 struct interface *ifp;
438 char *name;
439 int i;
440
441 ifi = NLMSG_DATA (h);
442
443 if (h->nlmsg_type != RTM_NEWLINK)
444 return 0;
445
446 len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
447 if (len < 0)
448 return -1;
449
450 /* Looking up interface name. */
451 memset (tb, 0, sizeof tb);
452 netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
453
454 #ifdef IFLA_WIRELESS
455 /* check for wireless messages to ignore */
456 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
457 {
458 if (IS_ZEBRA_DEBUG_KERNEL)
459 zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
460 return 0;
461 }
462 #endif /* IFLA_WIRELESS */
463
464 if (tb[IFLA_IFNAME] == NULL)
465 return -1;
466 name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
467
468 /* Add interface. */
469 ifp = if_get_by_name (name);
470 set_ifindex(ifp, ifi->ifi_index);
471 ifp->flags = ifi->ifi_flags & 0x0000fffff;
472 ifp->mtu6 = ifp->mtu = *(uint32_t *) RTA_DATA (tb[IFLA_MTU]);
473 ifp->metric = 1;
474
475 /* Hardware type and address. */
476 ifp->hw_type = ifi->ifi_type;
477
478 if (tb[IFLA_ADDRESS])
479 {
480 int hw_addr_len;
481
482 hw_addr_len = RTA_PAYLOAD (tb[IFLA_ADDRESS]);
483
484 if (hw_addr_len > INTERFACE_HWADDR_MAX)
485 zlog_warn ("Hardware address is too large: %d", hw_addr_len);
486 else
487 {
488 ifp->hw_addr_len = hw_addr_len;
489 memcpy (ifp->hw_addr, RTA_DATA (tb[IFLA_ADDRESS]), hw_addr_len);
490
491 for (i = 0; i < hw_addr_len; i++)
492 if (ifp->hw_addr[i] != 0)
493 break;
494
495 if (i == hw_addr_len)
496 ifp->hw_addr_len = 0;
497 else
498 ifp->hw_addr_len = hw_addr_len;
499 }
500 }
501
502 if_add_update (ifp);
503
504 return 0;
505 }
506
507 /* Lookup interface IPv4/IPv6 address. */
508 static int
509 netlink_interface_addr (struct sockaddr_nl *snl, struct nlmsghdr *h)
510 {
511 int len;
512 struct ifaddrmsg *ifa;
513 struct rtattr *tb[IFA_MAX + 1];
514 struct interface *ifp;
515 void *addr;
516 void *broad;
517 u_char flags = 0;
518 char *label = NULL;
519
520 ifa = NLMSG_DATA (h);
521
522 if (ifa->ifa_family != AF_INET
523 #ifdef HAVE_IPV6
524 && ifa->ifa_family != AF_INET6
525 #endif /* HAVE_IPV6 */
526 )
527 return 0;
528
529 if (h->nlmsg_type != RTM_NEWADDR && h->nlmsg_type != RTM_DELADDR)
530 return 0;
531
532 len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifaddrmsg));
533 if (len < 0)
534 return -1;
535
536 memset (tb, 0, sizeof tb);
537 netlink_parse_rtattr (tb, IFA_MAX, IFA_RTA (ifa), len);
538
539 ifp = if_lookup_by_index (ifa->ifa_index);
540 if (ifp == NULL)
541 {
542 zlog_err ("netlink_interface_addr can't find interface by index %d",
543 ifa->ifa_index);
544 return -1;
545 }
546
547 if (IS_ZEBRA_DEBUG_KERNEL) /* remove this line to see initial ifcfg */
548 {
549 char buf[BUFSIZ];
550 zlog_debug ("netlink_interface_addr %s %s:",
551 lookup (nlmsg_str, h->nlmsg_type), ifp->name);
552 if (tb[IFA_LOCAL])
553 zlog_debug (" IFA_LOCAL %s/%d",
554 inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_LOCAL]),
555 buf, BUFSIZ), ifa->ifa_prefixlen);
556 if (tb[IFA_ADDRESS])
557 zlog_debug (" IFA_ADDRESS %s/%d",
558 inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_ADDRESS]),
559 buf, BUFSIZ), ifa->ifa_prefixlen);
560 if (tb[IFA_BROADCAST])
561 zlog_debug (" IFA_BROADCAST %s/%d",
562 inet_ntop (ifa->ifa_family, RTA_DATA (tb[IFA_BROADCAST]),
563 buf, BUFSIZ), ifa->ifa_prefixlen);
564 if (tb[IFA_LABEL] && strcmp (ifp->name, RTA_DATA (tb[IFA_LABEL])))
565 zlog_debug (" IFA_LABEL %s", (char *)RTA_DATA (tb[IFA_LABEL]));
566
567 if (tb[IFA_CACHEINFO])
568 {
569 struct ifa_cacheinfo *ci = RTA_DATA (tb[IFA_CACHEINFO]);
570 zlog_debug (" IFA_CACHEINFO pref %d, valid %d",
571 ci->ifa_prefered, ci->ifa_valid);
572 }
573 }
574
575 /* logic copied from iproute2/ip/ipaddress.c:print_addrinfo() */
576 if (tb[IFA_LOCAL] == NULL)
577 tb[IFA_LOCAL] = tb[IFA_ADDRESS];
578 if (tb[IFA_ADDRESS] == NULL)
579 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
580
581 /* local interface address */
582 addr = (tb[IFA_LOCAL] ? RTA_DATA(tb[IFA_LOCAL]) : NULL);
583
584 /* is there a peer address? */
585 if (tb[IFA_ADDRESS] &&
586 memcmp(RTA_DATA(tb[IFA_ADDRESS]), RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_ADDRESS])))
587 {
588 broad = RTA_DATA(tb[IFA_ADDRESS]);
589 SET_FLAG (flags, ZEBRA_IFA_PEER);
590 }
591 else
592 /* seeking a broadcast address */
593 broad = (tb[IFA_BROADCAST] ? RTA_DATA(tb[IFA_BROADCAST]) : NULL);
594
595 /* addr is primary key, SOL if we don't have one */
596 if (addr == NULL)
597 {
598 zlog_debug ("%s: NULL address", __func__);
599 return -1;
600 }
601
602 /* Flags. */
603 if (ifa->ifa_flags & IFA_F_SECONDARY)
604 SET_FLAG (flags, ZEBRA_IFA_SECONDARY);
605
606 /* Label */
607 if (tb[IFA_LABEL])
608 label = (char *) RTA_DATA (tb[IFA_LABEL]);
609
610 if (ifp && label && strcmp (ifp->name, label) == 0)
611 label = NULL;
612
613 /* Register interface address to the interface. */
614 if (ifa->ifa_family == AF_INET)
615 {
616 if (h->nlmsg_type == RTM_NEWADDR)
617 connected_add_ipv4 (ifp, flags,
618 (struct in_addr *) addr, ifa->ifa_prefixlen,
619 (struct in_addr *) broad, label);
620 else
621 connected_delete_ipv4 (ifp, flags,
622 (struct in_addr *) addr, ifa->ifa_prefixlen,
623 (struct in_addr *) broad);
624 }
625 #ifdef HAVE_IPV6
626 if (ifa->ifa_family == AF_INET6)
627 {
628 if (h->nlmsg_type == RTM_NEWADDR)
629 connected_add_ipv6 (ifp, flags,
630 (struct in6_addr *) addr, ifa->ifa_prefixlen,
631 (struct in6_addr *) broad, label);
632 else
633 connected_delete_ipv6 (ifp,
634 (struct in6_addr *) addr, ifa->ifa_prefixlen,
635 (struct in6_addr *) broad);
636 }
637 #endif /* HAVE_IPV6 */
638
639 return 0;
640 }
641
642 /* Looking up routing table by netlink interface. */
643 static int
644 netlink_routing_table (struct sockaddr_nl *snl, struct nlmsghdr *h)
645 {
646 int len;
647 struct rtmsg *rtm;
648 struct rtattr *tb[RTA_MAX + 1];
649 u_char flags = 0;
650
651 char anyaddr[16] = { 0 };
652
653 int index;
654 int table;
655 int metric;
656
657 void *dest;
658 void *gate;
659 void *src;
660
661 rtm = NLMSG_DATA (h);
662
663 if (h->nlmsg_type != RTM_NEWROUTE)
664 return 0;
665 if (rtm->rtm_type != RTN_UNICAST)
666 return 0;
667
668 table = rtm->rtm_table;
669 #if 0 /* we weed them out later in rib_weed_tables () */
670 if (table != RT_TABLE_MAIN && table != zebrad.rtm_table_default)
671 return 0;
672 #endif
673
674 len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct rtmsg));
675 if (len < 0)
676 return -1;
677
678 memset (tb, 0, sizeof tb);
679 netlink_parse_rtattr (tb, RTA_MAX, RTM_RTA (rtm), len);
680
681 if (rtm->rtm_flags & RTM_F_CLONED)
682 return 0;
683 if (rtm->rtm_protocol == RTPROT_REDIRECT)
684 return 0;
685 if (rtm->rtm_protocol == RTPROT_KERNEL)
686 return 0;
687
688 if (rtm->rtm_src_len != 0)
689 return 0;
690
691 /* Route which inserted by Zebra. */
692 if (rtm->rtm_protocol == RTPROT_ZEBRA)
693 flags |= ZEBRA_FLAG_SELFROUTE;
694
695 index = 0;
696 metric = 0;
697 dest = NULL;
698 gate = NULL;
699 src = NULL;
700
701 if (tb[RTA_OIF])
702 index = *(int *) RTA_DATA (tb[RTA_OIF]);
703
704 if (tb[RTA_DST])
705 dest = RTA_DATA (tb[RTA_DST]);
706 else
707 dest = anyaddr;
708
709 if (tb[RTA_PREFSRC])
710 src = RTA_DATA (tb[RTA_PREFSRC]);
711
712 /* Multipath treatment is needed. */
713 if (tb[RTA_GATEWAY])
714 gate = RTA_DATA (tb[RTA_GATEWAY]);
715
716 if (tb[RTA_PRIORITY])
717 metric = *(int *) RTA_DATA(tb[RTA_PRIORITY]);
718
719 if (rtm->rtm_family == AF_INET)
720 {
721 struct prefix_ipv4 p;
722 p.family = AF_INET;
723 memcpy (&p.prefix, dest, 4);
724 p.prefixlen = rtm->rtm_dst_len;
725
726 rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, flags, &p, gate, src, index, table, metric, 0);
727 }
728 #ifdef HAVE_IPV6
729 if (rtm->rtm_family == AF_INET6)
730 {
731 struct prefix_ipv6 p;
732 p.family = AF_INET6;
733 memcpy (&p.prefix, dest, 16);
734 p.prefixlen = rtm->rtm_dst_len;
735
736 rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, flags, &p, gate, index, table,
737 metric, 0);
738 }
739 #endif /* HAVE_IPV6 */
740
741 return 0;
742 }
743
744 static const struct message rtproto_str[] = {
745 {RTPROT_REDIRECT, "redirect"},
746 {RTPROT_KERNEL, "kernel"},
747 {RTPROT_BOOT, "boot"},
748 {RTPROT_STATIC, "static"},
749 {RTPROT_GATED, "GateD"},
750 {RTPROT_RA, "router advertisement"},
751 {RTPROT_MRT, "MRT"},
752 {RTPROT_ZEBRA, "Zebra"},
753 #ifdef RTPROT_BIRD
754 {RTPROT_BIRD, "BIRD"},
755 #endif /* RTPROT_BIRD */
756 {0, NULL}
757 };
758
759 /* Routing information change from the kernel. */
760 static int
761 netlink_route_change (struct sockaddr_nl *snl, struct nlmsghdr *h)
762 {
763 int len;
764 struct rtmsg *rtm;
765 struct rtattr *tb[RTA_MAX + 1];
766
767 char anyaddr[16] = { 0 };
768
769 int index;
770 int table;
771 int metric;
772
773 void *dest;
774 void *gate;
775 void *src;
776
777 rtm = NLMSG_DATA (h);
778
779 if (!(h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE))
780 {
781 /* If this is not route add/delete message print warning. */
782 zlog_warn ("Kernel message: %d\n", h->nlmsg_type);
783 return 0;
784 }
785
786 /* Connected route. */
787 if (IS_ZEBRA_DEBUG_KERNEL)
788 zlog_debug ("%s %s %s proto %s",
789 h->nlmsg_type ==
790 RTM_NEWROUTE ? "RTM_NEWROUTE" : "RTM_DELROUTE",
791 rtm->rtm_family == AF_INET ? "ipv4" : "ipv6",
792 rtm->rtm_type == RTN_UNICAST ? "unicast" : "multicast",
793 lookup (rtproto_str, rtm->rtm_protocol));
794
795 if (rtm->rtm_type != RTN_UNICAST)
796 {
797 return 0;
798 }
799
800 table = rtm->rtm_table;
801 if (table != RT_TABLE_MAIN && table != zebrad.rtm_table_default)
802 {
803 return 0;
804 }
805
806 len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct rtmsg));
807 if (len < 0)
808 return -1;
809
810 memset (tb, 0, sizeof tb);
811 netlink_parse_rtattr (tb, RTA_MAX, RTM_RTA (rtm), len);
812
813 if (rtm->rtm_flags & RTM_F_CLONED)
814 return 0;
815 if (rtm->rtm_protocol == RTPROT_REDIRECT)
816 return 0;
817 if (rtm->rtm_protocol == RTPROT_KERNEL)
818 return 0;
819
820 if (rtm->rtm_protocol == RTPROT_ZEBRA && h->nlmsg_type == RTM_NEWROUTE)
821 return 0;
822
823 if (rtm->rtm_src_len != 0)
824 {
825 zlog_warn ("netlink_route_change(): no src len");
826 return 0;
827 }
828
829 index = 0;
830 metric = 0;
831 dest = NULL;
832 gate = NULL;
833 src = NULL;
834
835 if (tb[RTA_OIF])
836 index = *(int *) RTA_DATA (tb[RTA_OIF]);
837
838 if (tb[RTA_DST])
839 dest = RTA_DATA (tb[RTA_DST]);
840 else
841 dest = anyaddr;
842
843 if (tb[RTA_GATEWAY])
844 gate = RTA_DATA (tb[RTA_GATEWAY]);
845
846 if (tb[RTA_PREFSRC])
847 src = RTA_DATA (tb[RTA_PREFSRC]);
848
849 if (h->nlmsg_type == RTM_NEWROUTE && tb[RTA_PRIORITY])
850 metric = *(int *) RTA_DATA(tb[RTA_PRIORITY]);
851
852 if (rtm->rtm_family == AF_INET)
853 {
854 struct prefix_ipv4 p;
855 p.family = AF_INET;
856 memcpy (&p.prefix, dest, 4);
857 p.prefixlen = rtm->rtm_dst_len;
858
859 if (IS_ZEBRA_DEBUG_KERNEL)
860 {
861 if (h->nlmsg_type == RTM_NEWROUTE)
862 zlog_debug ("RTM_NEWROUTE %s/%d",
863 inet_ntoa (p.prefix), p.prefixlen);
864 else
865 zlog_debug ("RTM_DELROUTE %s/%d",
866 inet_ntoa (p.prefix), p.prefixlen);
867 }
868
869 if (h->nlmsg_type == RTM_NEWROUTE)
870 rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, src, index, table, metric, 0);
871 else
872 rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, index, table);
873 }
874
875 #ifdef HAVE_IPV6
876 if (rtm->rtm_family == AF_INET6)
877 {
878 struct prefix_ipv6 p;
879 char buf[BUFSIZ];
880
881 p.family = AF_INET6;
882 memcpy (&p.prefix, dest, 16);
883 p.prefixlen = rtm->rtm_dst_len;
884
885 if (IS_ZEBRA_DEBUG_KERNEL)
886 {
887 if (h->nlmsg_type == RTM_NEWROUTE)
888 zlog_debug ("RTM_NEWROUTE %s/%d",
889 inet_ntop (AF_INET6, &p.prefix, buf, BUFSIZ),
890 p.prefixlen);
891 else
892 zlog_debug ("RTM_DELROUTE %s/%d",
893 inet_ntop (AF_INET6, &p.prefix, buf, BUFSIZ),
894 p.prefixlen);
895 }
896
897 if (h->nlmsg_type == RTM_NEWROUTE)
898 rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, index, table, metric, 0);
899 else
900 rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL, 0, &p, gate, index, table);
901 }
902 #endif /* HAVE_IPV6 */
903
904 return 0;
905 }
906
907 static int
908 netlink_link_change (struct sockaddr_nl *snl, struct nlmsghdr *h)
909 {
910 int len;
911 struct ifinfomsg *ifi;
912 struct rtattr *tb[IFLA_MAX + 1];
913 struct interface *ifp;
914 char *name;
915
916 ifi = NLMSG_DATA (h);
917
918 if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK))
919 {
920 /* If this is not link add/delete message so print warning. */
921 zlog_warn ("netlink_link_change: wrong kernel message %d\n",
922 h->nlmsg_type);
923 return 0;
924 }
925
926 len = h->nlmsg_len - NLMSG_LENGTH (sizeof (struct ifinfomsg));
927 if (len < 0)
928 return -1;
929
930 /* Looking up interface name. */
931 memset (tb, 0, sizeof tb);
932 netlink_parse_rtattr (tb, IFLA_MAX, IFLA_RTA (ifi), len);
933
934 #ifdef IFLA_WIRELESS
935 /* check for wireless messages to ignore */
936 if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0))
937 {
938 if (IS_ZEBRA_DEBUG_KERNEL)
939 zlog_debug ("%s: ignoring IFLA_WIRELESS message", __func__);
940 return 0;
941 }
942 #endif /* IFLA_WIRELESS */
943
944 if (tb[IFLA_IFNAME] == NULL)
945 return -1;
946 name = (char *) RTA_DATA (tb[IFLA_IFNAME]);
947
948 /* Add interface. */
949 if (h->nlmsg_type == RTM_NEWLINK)
950 {
951 ifp = if_lookup_by_name (name);
952
953 if (ifp == NULL || !CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
954 {
955 if (ifp == NULL)
956 ifp = if_get_by_name (name);
957
958 set_ifindex(ifp, ifi->ifi_index);
959 ifp->flags = ifi->ifi_flags & 0x0000fffff;
960 ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
961 ifp->metric = 1;
962
963 /* If new link is added. */
964 if_add_update (ifp);
965 }
966 else
967 {
968 /* Interface status change. */
969 set_ifindex(ifp, ifi->ifi_index);
970 ifp->mtu6 = ifp->mtu = *(int *) RTA_DATA (tb[IFLA_MTU]);
971 ifp->metric = 1;
972
973 if (if_is_operative (ifp))
974 {
975 ifp->flags = ifi->ifi_flags & 0x0000fffff;
976 if (!if_is_operative (ifp))
977 if_down (ifp);
978 else
979 /* Must notify client daemons of new interface status. */
980 zebra_interface_up_update (ifp);
981 }
982 else
983 {
984 ifp->flags = ifi->ifi_flags & 0x0000fffff;
985 if (if_is_operative (ifp))
986 if_up (ifp);
987 }
988 }
989 }
990 else
991 {
992 /* RTM_DELLINK. */
993 ifp = if_lookup_by_name (name);
994
995 if (ifp == NULL)
996 {
997 zlog (NULL, LOG_WARNING, "interface %s is deleted but can't find",
998 name);
999 return 0;
1000 }
1001
1002 if_delete_update (ifp);
1003 }
1004
1005 return 0;
1006 }
1007
1008 static int
1009 netlink_information_fetch (struct sockaddr_nl *snl, struct nlmsghdr *h)
1010 {
1011 /* JF: Ignore messages that aren't from the kernel */
1012 if ( snl->nl_pid != 0 )
1013 {
1014 zlog ( NULL, LOG_ERR, "Ignoring message from pid %u", snl->nl_pid );
1015 return 0;
1016 }
1017
1018 switch (h->nlmsg_type)
1019 {
1020 case RTM_NEWROUTE:
1021 return netlink_route_change (snl, h);
1022 break;
1023 case RTM_DELROUTE:
1024 return netlink_route_change (snl, h);
1025 break;
1026 case RTM_NEWLINK:
1027 return netlink_link_change (snl, h);
1028 break;
1029 case RTM_DELLINK:
1030 return netlink_link_change (snl, h);
1031 break;
1032 case RTM_NEWADDR:
1033 return netlink_interface_addr (snl, h);
1034 break;
1035 case RTM_DELADDR:
1036 return netlink_interface_addr (snl, h);
1037 break;
1038 default:
1039 zlog_warn ("Unknown netlink nlmsg_type %d\n", h->nlmsg_type);
1040 break;
1041 }
1042 return 0;
1043 }
1044
1045 /* Interface lookup by netlink socket. */
1046 int
1047 interface_lookup_netlink (void)
1048 {
1049 int ret;
1050
1051 /* Get interface information. */
1052 ret = netlink_request (AF_PACKET, RTM_GETLINK, &netlink_cmd);
1053 if (ret < 0)
1054 return ret;
1055 ret = netlink_parse_info (netlink_interface, &netlink_cmd);
1056 if (ret < 0)
1057 return ret;
1058
1059 /* Get IPv4 address of the interfaces. */
1060 ret = netlink_request (AF_INET, RTM_GETADDR, &netlink_cmd);
1061 if (ret < 0)
1062 return ret;
1063 ret = netlink_parse_info (netlink_interface_addr, &netlink_cmd);
1064 if (ret < 0)
1065 return ret;
1066
1067 #ifdef HAVE_IPV6
1068 /* Get IPv6 address of the interfaces. */
1069 ret = netlink_request (AF_INET6, RTM_GETADDR, &netlink_cmd);
1070 if (ret < 0)
1071 return ret;
1072 ret = netlink_parse_info (netlink_interface_addr, &netlink_cmd);
1073 if (ret < 0)
1074 return ret;
1075 #endif /* HAVE_IPV6 */
1076
1077 return 0;
1078 }
1079
1080 /* Routing table read function using netlink interface. Only called
1081 bootstrap time. */
1082 int
1083 netlink_route_read (void)
1084 {
1085 int ret;
1086
1087 /* Get IPv4 routing table. */
1088 ret = netlink_request (AF_INET, RTM_GETROUTE, &netlink_cmd);
1089 if (ret < 0)
1090 return ret;
1091 ret = netlink_parse_info (netlink_routing_table, &netlink_cmd);
1092 if (ret < 0)
1093 return ret;
1094
1095 #ifdef HAVE_IPV6
1096 /* Get IPv6 routing table. */
1097 ret = netlink_request (AF_INET6, RTM_GETROUTE, &netlink_cmd);
1098 if (ret < 0)
1099 return ret;
1100 ret = netlink_parse_info (netlink_routing_table, &netlink_cmd);
1101 if (ret < 0)
1102 return ret;
1103 #endif /* HAVE_IPV6 */
1104
1105 return 0;
1106 }
1107
1108 /* Utility function comes from iproute2.
1109 Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> */
1110 static int
1111 addattr_l (struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
1112 {
1113 int len;
1114 struct rtattr *rta;
1115
1116 len = RTA_LENGTH (alen);
1117
1118 if (NLMSG_ALIGN (n->nlmsg_len) + len > maxlen)
1119 return -1;
1120
1121 rta = (struct rtattr *) (((char *) n) + NLMSG_ALIGN (n->nlmsg_len));
1122 rta->rta_type = type;
1123 rta->rta_len = len;
1124 memcpy (RTA_DATA (rta), data, alen);
1125 n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + len;
1126
1127 return 0;
1128 }
1129
1130 static int
1131 rta_addattr_l (struct rtattr *rta, int maxlen, int type, void *data, int alen)
1132 {
1133 int len;
1134 struct rtattr *subrta;
1135
1136 len = RTA_LENGTH (alen);
1137
1138 if (RTA_ALIGN (rta->rta_len) + len > maxlen)
1139 return -1;
1140
1141 subrta = (struct rtattr *) (((char *) rta) + RTA_ALIGN (rta->rta_len));
1142 subrta->rta_type = type;
1143 subrta->rta_len = len;
1144 memcpy (RTA_DATA (subrta), data, alen);
1145 rta->rta_len = NLMSG_ALIGN (rta->rta_len) + len;
1146
1147 return 0;
1148 }
1149
1150 /* Utility function comes from iproute2.
1151 Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> */
1152 static int
1153 addattr32 (struct nlmsghdr *n, int maxlen, int type, int data)
1154 {
1155 int len;
1156 struct rtattr *rta;
1157
1158 len = RTA_LENGTH (4);
1159
1160 if (NLMSG_ALIGN (n->nlmsg_len) + len > maxlen)
1161 return -1;
1162
1163 rta = (struct rtattr *) (((char *) n) + NLMSG_ALIGN (n->nlmsg_len));
1164 rta->rta_type = type;
1165 rta->rta_len = len;
1166 memcpy (RTA_DATA (rta), &data, 4);
1167 n->nlmsg_len = NLMSG_ALIGN (n->nlmsg_len) + len;
1168
1169 return 0;
1170 }
1171
1172 static int
1173 netlink_talk_filter (struct sockaddr_nl *snl, struct nlmsghdr *h)
1174 {
1175 zlog_warn ("netlink_talk: ignoring message type 0x%04x", h->nlmsg_type);
1176 return 0;
1177 }
1178
1179 /* sendmsg() to netlink socket then recvmsg(). */
1180 static int
1181 netlink_talk (struct nlmsghdr *n, struct nlsock *nl)
1182 {
1183 int status;
1184 struct sockaddr_nl snl;
1185 struct iovec iov = { (void *) n, n->nlmsg_len };
1186 struct msghdr msg = { (void *) &snl, sizeof snl, &iov, 1, NULL, 0, 0 };
1187 int save_errno;
1188
1189 memset (&snl, 0, sizeof snl);
1190 snl.nl_family = AF_NETLINK;
1191
1192 n->nlmsg_seq = ++nl->seq;
1193
1194 /* Request an acknowledgement by setting NLM_F_ACK */
1195 n->nlmsg_flags |= NLM_F_ACK;
1196
1197 if (IS_ZEBRA_DEBUG_KERNEL)
1198 zlog_debug ("netlink_talk: %s type %s(%u), seq=%u", nl->name,
1199 lookup (nlmsg_str, n->nlmsg_type), n->nlmsg_type,
1200 n->nlmsg_seq);
1201
1202 /* Send message to netlink interface. */
1203 if (zserv_privs.change (ZPRIVS_RAISE))
1204 zlog (NULL, LOG_ERR, "Can't raise privileges");
1205 status = sendmsg (nl->sock, &msg, 0);
1206 save_errno = errno;
1207 if (zserv_privs.change (ZPRIVS_LOWER))
1208 zlog (NULL, LOG_ERR, "Can't lower privileges");
1209
1210 if (status < 0)
1211 {
1212 zlog (NULL, LOG_ERR, "netlink_talk sendmsg() error: %s",
1213 safe_strerror (save_errno));
1214 return -1;
1215 }
1216
1217
1218 /*
1219 * Get reply from netlink socket.
1220 * The reply should either be an acknowlegement or an error.
1221 */
1222 return netlink_parse_info (netlink_talk_filter, nl);
1223 }
1224
1225 /* Routing table change via netlink interface. */
1226 static int
1227 netlink_route (int cmd, int family, void *dest, int length, void *gate,
1228 int index, int zebra_flags, int table)
1229 {
1230 int ret;
1231 int bytelen;
1232 struct sockaddr_nl snl;
1233 int discard;
1234
1235 struct
1236 {
1237 struct nlmsghdr n;
1238 struct rtmsg r;
1239 char buf[1024];
1240 } req;
1241
1242 memset (&req, 0, sizeof req);
1243
1244 bytelen = (family == AF_INET ? 4 : 16);
1245
1246 req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtmsg));
1247 req.n.nlmsg_flags = NLM_F_CREATE | NLM_F_REQUEST;
1248 req.n.nlmsg_type = cmd;
1249 req.r.rtm_family = family;
1250 req.r.rtm_table = table;
1251 req.r.rtm_dst_len = length;
1252 req.r.rtm_protocol = RTPROT_ZEBRA;
1253 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
1254
1255 if ((zebra_flags & ZEBRA_FLAG_BLACKHOLE)
1256 || (zebra_flags & ZEBRA_FLAG_REJECT))
1257 discard = 1;
1258 else
1259 discard = 0;
1260
1261 if (cmd == RTM_NEWROUTE)
1262 {
1263 if (discard)
1264 {
1265 if (zebra_flags & ZEBRA_FLAG_BLACKHOLE)
1266 req.r.rtm_type = RTN_BLACKHOLE;
1267 else if (zebra_flags & ZEBRA_FLAG_REJECT)
1268 req.r.rtm_type = RTN_UNREACHABLE;
1269 else
1270 assert (RTN_BLACKHOLE != RTN_UNREACHABLE); /* false */
1271 }
1272 else
1273 req.r.rtm_type = RTN_UNICAST;
1274 }
1275
1276 if (dest)
1277 addattr_l (&req.n, sizeof req, RTA_DST, dest, bytelen);
1278
1279 if (!discard)
1280 {
1281 if (gate)
1282 addattr_l (&req.n, sizeof req, RTA_GATEWAY, gate, bytelen);
1283 if (index > 0)
1284 addattr32 (&req.n, sizeof req, RTA_OIF, index);
1285 }
1286
1287 /* Destination netlink address. */
1288 memset (&snl, 0, sizeof snl);
1289 snl.nl_family = AF_NETLINK;
1290
1291 /* Talk to netlink socket. */
1292 ret = netlink_talk (&req.n, &netlink_cmd);
1293 if (ret < 0)
1294 return -1;
1295
1296 return 0;
1297 }
1298
1299 /* Routing table change via netlink interface. */
1300 static int
1301 netlink_route_multipath (int cmd, struct prefix *p, struct rib *rib,
1302 int family)
1303 {
1304 int bytelen;
1305 struct sockaddr_nl snl;
1306 struct nexthop *nexthop = NULL;
1307 int nexthop_num = 0;
1308 int discard;
1309
1310 struct
1311 {
1312 struct nlmsghdr n;
1313 struct rtmsg r;
1314 char buf[1024];
1315 } req;
1316
1317 memset (&req, 0, sizeof req);
1318
1319 bytelen = (family == AF_INET ? 4 : 16);
1320
1321 req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtmsg));
1322 req.n.nlmsg_flags = NLM_F_CREATE | NLM_F_REQUEST;
1323 req.n.nlmsg_type = cmd;
1324 req.r.rtm_family = family;
1325 req.r.rtm_table = rib->table;
1326 req.r.rtm_dst_len = p->prefixlen;
1327 req.r.rtm_protocol = RTPROT_ZEBRA;
1328 req.r.rtm_scope = RT_SCOPE_UNIVERSE;
1329
1330 if ((rib->flags & ZEBRA_FLAG_BLACKHOLE) || (rib->flags & ZEBRA_FLAG_REJECT))
1331 discard = 1;
1332 else
1333 discard = 0;
1334
1335 if (cmd == RTM_NEWROUTE)
1336 {
1337 if (discard)
1338 {
1339 if (rib->flags & ZEBRA_FLAG_BLACKHOLE)
1340 req.r.rtm_type = RTN_BLACKHOLE;
1341 else if (rib->flags & ZEBRA_FLAG_REJECT)
1342 req.r.rtm_type = RTN_UNREACHABLE;
1343 else
1344 assert (RTN_BLACKHOLE != RTN_UNREACHABLE); /* false */
1345 }
1346 else
1347 req.r.rtm_type = RTN_UNICAST;
1348 }
1349
1350 addattr_l (&req.n, sizeof req, RTA_DST, &p->u.prefix, bytelen);
1351
1352 /* Metric. */
1353 addattr32 (&req.n, sizeof req, RTA_PRIORITY, rib->metric);
1354
1355 if (discard)
1356 {
1357 if (cmd == RTM_NEWROUTE)
1358 for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1359 SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1360 goto skip;
1361 }
1362
1363 /* Multipath case. */
1364 if (rib->nexthop_active_num == 1 || MULTIPATH_NUM == 1)
1365 {
1366 for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
1367 {
1368
1369 if ((cmd == RTM_NEWROUTE
1370 && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
1371 || (cmd == RTM_DELROUTE
1372 && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
1373 {
1374
1375 if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1376 {
1377 if (IS_ZEBRA_DEBUG_KERNEL)
1378 {
1379 zlog_debug
1380 ("netlink_route_multipath() (recursive, 1 hop): "
1381 "%s %s/%d, type %s", lookup (nlmsg_str, cmd),
1382 #ifdef HAVE_IPV6
1383 (family == AF_INET) ? inet_ntoa (p->u.prefix4) :
1384 inet6_ntoa (p->u.prefix6),
1385 #else
1386 inet_ntoa (p->u.prefix4),
1387 #endif /* HAVE_IPV6 */
1388
1389 p->prefixlen, nexthop_types_desc[nexthop->rtype]);
1390 }
1391
1392 if (nexthop->rtype == NEXTHOP_TYPE_IPV4
1393 || nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX)
1394 {
1395 addattr_l (&req.n, sizeof req, RTA_GATEWAY,
1396 &nexthop->rgate.ipv4, bytelen);
1397 if (nexthop->src.ipv4.s_addr)
1398 addattr_l(&req.n, sizeof req, RTA_PREFSRC,
1399 &nexthop->src.ipv4, bytelen);
1400 if (IS_ZEBRA_DEBUG_KERNEL)
1401 zlog_debug("netlink_route_multipath() (recursive, "
1402 "1 hop): nexthop via %s if %u",
1403 inet_ntoa (nexthop->rgate.ipv4),
1404 nexthop->rifindex);
1405 }
1406 #ifdef HAVE_IPV6
1407 if (nexthop->rtype == NEXTHOP_TYPE_IPV6
1408 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX
1409 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME)
1410 {
1411 addattr_l (&req.n, sizeof req, RTA_GATEWAY,
1412 &nexthop->rgate.ipv6, bytelen);
1413
1414 if (IS_ZEBRA_DEBUG_KERNEL)
1415 zlog_debug("netlink_route_multipath() (recursive, "
1416 "1 hop): nexthop via %s if %u",
1417 inet6_ntoa (nexthop->rgate.ipv6),
1418 nexthop->rifindex);
1419 }
1420 #endif /* HAVE_IPV6 */
1421 if (nexthop->rtype == NEXTHOP_TYPE_IFINDEX
1422 || nexthop->rtype == NEXTHOP_TYPE_IFNAME
1423 || nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX
1424 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX
1425 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME)
1426 {
1427 addattr32 (&req.n, sizeof req, RTA_OIF,
1428 nexthop->rifindex);
1429 if ((nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX
1430 || nexthop->rtype == NEXTHOP_TYPE_IFINDEX)
1431 && nexthop->src.ipv4.s_addr)
1432 addattr_l (&req.n, sizeof req, RTA_PREFSRC,
1433 &nexthop->src.ipv4, bytelen);
1434
1435 if (IS_ZEBRA_DEBUG_KERNEL)
1436 zlog_debug("netlink_route_multipath() (recursive, "
1437 "1 hop): nexthop via if %u",
1438 nexthop->rifindex);
1439 }
1440 }
1441 else
1442 {
1443 if (IS_ZEBRA_DEBUG_KERNEL)
1444 {
1445 zlog_debug
1446 ("netlink_route_multipath() (single hop): "
1447 "%s %s/%d, type %s", lookup (nlmsg_str, cmd),
1448 #ifdef HAVE_IPV6
1449 (family == AF_INET) ? inet_ntoa (p->u.prefix4) :
1450 inet6_ntoa (p->u.prefix6),
1451 #else
1452 inet_ntoa (p->u.prefix4),
1453 #endif /* HAVE_IPV6 */
1454 p->prefixlen, nexthop_types_desc[nexthop->type]);
1455 }
1456
1457 if (nexthop->type == NEXTHOP_TYPE_IPV4
1458 || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1459 {
1460 addattr_l (&req.n, sizeof req, RTA_GATEWAY,
1461 &nexthop->gate.ipv4, bytelen);
1462 if (nexthop->src.ipv4.s_addr)
1463 addattr_l (&req.n, sizeof req, RTA_PREFSRC,
1464 &nexthop->src.ipv4, bytelen);
1465
1466 if (IS_ZEBRA_DEBUG_KERNEL)
1467 zlog_debug("netlink_route_multipath() (single hop): "
1468 "nexthop via %s if %u",
1469 inet_ntoa (nexthop->gate.ipv4),
1470 nexthop->ifindex);
1471 }
1472 #ifdef HAVE_IPV6
1473 if (nexthop->type == NEXTHOP_TYPE_IPV6
1474 || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1475 || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1476 {
1477 addattr_l (&req.n, sizeof req, RTA_GATEWAY,
1478 &nexthop->gate.ipv6, bytelen);
1479
1480 if (IS_ZEBRA_DEBUG_KERNEL)
1481 zlog_debug("netlink_route_multipath() (single hop): "
1482 "nexthop via %s if %u",
1483 inet6_ntoa (nexthop->gate.ipv6),
1484 nexthop->ifindex);
1485 }
1486 #endif /* HAVE_IPV6 */
1487 if (nexthop->type == NEXTHOP_TYPE_IFINDEX
1488 || nexthop->type == NEXTHOP_TYPE_IFNAME
1489 || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1490 {
1491 addattr32 (&req.n, sizeof req, RTA_OIF, nexthop->ifindex);
1492
1493 if (nexthop->src.ipv4.s_addr)
1494 addattr_l (&req.n, sizeof req, RTA_PREFSRC,
1495 &nexthop->src.ipv4, bytelen);
1496
1497 if (IS_ZEBRA_DEBUG_KERNEL)
1498 zlog_debug("netlink_route_multipath() (single hop): "
1499 "nexthop via if %u", nexthop->ifindex);
1500 }
1501 else if (nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX
1502 || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME)
1503 {
1504 addattr32 (&req.n, sizeof req, RTA_OIF, nexthop->ifindex);
1505
1506 if (IS_ZEBRA_DEBUG_KERNEL)
1507 zlog_debug("netlink_route_multipath() (single hop): "
1508 "nexthop via if %u", nexthop->ifindex);
1509 }
1510 }
1511
1512 if (cmd == RTM_NEWROUTE)
1513 SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1514
1515 nexthop_num++;
1516 break;
1517 }
1518 }
1519 }
1520 else
1521 {
1522 char buf[1024];
1523 struct rtattr *rta = (void *) buf;
1524 struct rtnexthop *rtnh;
1525 union g_addr *src = NULL;
1526
1527 rta->rta_type = RTA_MULTIPATH;
1528 rta->rta_len = RTA_LENGTH (0);
1529 rtnh = RTA_DATA (rta);
1530
1531 nexthop_num = 0;
1532 for (nexthop = rib->nexthop;
1533 nexthop && (MULTIPATH_NUM == 0 || nexthop_num < MULTIPATH_NUM);
1534 nexthop = nexthop->next)
1535 {
1536 if ((cmd == RTM_NEWROUTE
1537 && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
1538 || (cmd == RTM_DELROUTE
1539 && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
1540 {
1541 nexthop_num++;
1542
1543 rtnh->rtnh_len = sizeof (*rtnh);
1544 rtnh->rtnh_flags = 0;
1545 rtnh->rtnh_hops = 0;
1546 rta->rta_len += rtnh->rtnh_len;
1547
1548 if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
1549 {
1550 if (IS_ZEBRA_DEBUG_KERNEL)
1551 {
1552 zlog_debug ("netlink_route_multipath() "
1553 "(recursive, multihop): %s %s/%d type %s",
1554 lookup (nlmsg_str, cmd),
1555 #ifdef HAVE_IPV6
1556 (family == AF_INET) ? inet_ntoa (p->u.prefix4) :
1557 inet6_ntoa (p->u.prefix6),
1558 #else
1559 inet_ntoa (p->u.prefix4),
1560 #endif /* HAVE_IPV6 */
1561 p->prefixlen, nexthop_types_desc[nexthop->rtype]);
1562 }
1563 if (nexthop->rtype == NEXTHOP_TYPE_IPV4
1564 || nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX)
1565 {
1566 rta_addattr_l (rta, 4096, RTA_GATEWAY,
1567 &nexthop->rgate.ipv4, bytelen);
1568 rtnh->rtnh_len += sizeof (struct rtattr) + 4;
1569
1570 if (nexthop->src.ipv4.s_addr)
1571 src = &nexthop->src;
1572
1573 if (IS_ZEBRA_DEBUG_KERNEL)
1574 zlog_debug("netlink_route_multipath() (recursive, "
1575 "multihop): nexthop via %s if %u",
1576 inet_ntoa (nexthop->rgate.ipv4),
1577 nexthop->rifindex);
1578 }
1579 #ifdef HAVE_IPV6
1580 if (nexthop->rtype == NEXTHOP_TYPE_IPV6
1581 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME
1582 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX)
1583 {
1584 rta_addattr_l (rta, 4096, RTA_GATEWAY,
1585 &nexthop->rgate.ipv6, bytelen);
1586
1587 if (IS_ZEBRA_DEBUG_KERNEL)
1588 zlog_debug("netlink_route_multipath() (recursive, "
1589 "multihop): nexthop via %s if %u",
1590 inet6_ntoa (nexthop->rgate.ipv6),
1591 nexthop->rifindex);
1592 }
1593 #endif /* HAVE_IPV6 */
1594 /* ifindex */
1595 if (nexthop->rtype == NEXTHOP_TYPE_IPV4_IFINDEX
1596 || nexthop->rtype == NEXTHOP_TYPE_IFINDEX
1597 || nexthop->rtype == NEXTHOP_TYPE_IFNAME)
1598 {
1599 rtnh->rtnh_ifindex = nexthop->rifindex;
1600 if (nexthop->src.ipv4.s_addr)
1601 src = &nexthop->src;
1602
1603 if (IS_ZEBRA_DEBUG_KERNEL)
1604 zlog_debug("netlink_route_multipath() (recursive, "
1605 "multihop): nexthop via if %u",
1606 nexthop->rifindex);
1607 }
1608 else if (nexthop->rtype == NEXTHOP_TYPE_IPV6_IFINDEX
1609 || nexthop->rtype == NEXTHOP_TYPE_IPV6_IFNAME)
1610 {
1611 rtnh->rtnh_ifindex = nexthop->rifindex;
1612
1613 if (IS_ZEBRA_DEBUG_KERNEL)
1614 zlog_debug("netlink_route_multipath() (recursive, "
1615 "multihop): nexthop via if %u",
1616 nexthop->rifindex);
1617 }
1618 else
1619 {
1620 rtnh->rtnh_ifindex = 0;
1621 }
1622 }
1623 else
1624 {
1625 if (IS_ZEBRA_DEBUG_KERNEL)
1626 {
1627 zlog_debug ("netlink_route_multipath() (multihop): "
1628 "%s %s/%d, type %s", lookup (nlmsg_str, cmd),
1629 #ifdef HAVE_IPV6
1630 (family == AF_INET) ? inet_ntoa (p->u.prefix4) :
1631 inet6_ntoa (p->u.prefix6),
1632 #else
1633 inet_ntoa (p->u.prefix4),
1634 #endif /* HAVE_IPV6 */
1635 p->prefixlen, nexthop_types_desc[nexthop->type]);
1636 }
1637 if (nexthop->type == NEXTHOP_TYPE_IPV4
1638 || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
1639 {
1640 rta_addattr_l (rta, 4096, RTA_GATEWAY,
1641 &nexthop->gate.ipv4, bytelen);
1642 rtnh->rtnh_len += sizeof (struct rtattr) + 4;
1643
1644 if (nexthop->src.ipv4.s_addr)
1645 src = &nexthop->src;
1646
1647 if (IS_ZEBRA_DEBUG_KERNEL)
1648 zlog_debug("netlink_route_multipath() (multihop): "
1649 "nexthop via %s if %u",
1650 inet_ntoa (nexthop->gate.ipv4),
1651 nexthop->ifindex);
1652 }
1653 #ifdef HAVE_IPV6
1654 if (nexthop->type == NEXTHOP_TYPE_IPV6
1655 || nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1656 || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1657 {
1658 rta_addattr_l (rta, 4096, RTA_GATEWAY,
1659 &nexthop->gate.ipv6, bytelen);
1660
1661 if (IS_ZEBRA_DEBUG_KERNEL)
1662 zlog_debug("netlink_route_multipath() (multihop): "
1663 "nexthop via %s if %u",
1664 inet6_ntoa (nexthop->gate.ipv6),
1665 nexthop->ifindex);
1666 }
1667 #endif /* HAVE_IPV6 */
1668 /* ifindex */
1669 if (nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX
1670 || nexthop->type == NEXTHOP_TYPE_IFINDEX
1671 || nexthop->type == NEXTHOP_TYPE_IFNAME)
1672 {
1673 rtnh->rtnh_ifindex = nexthop->ifindex;
1674 if (nexthop->src.ipv4.s_addr)
1675 src = &nexthop->src;
1676 if (IS_ZEBRA_DEBUG_KERNEL)
1677 zlog_debug("netlink_route_multipath() (multihop): "
1678 "nexthop via if %u", nexthop->ifindex);
1679 }
1680 else if (nexthop->type == NEXTHOP_TYPE_IPV6_IFNAME
1681 || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
1682 {
1683 rtnh->rtnh_ifindex = nexthop->ifindex;
1684
1685 if (IS_ZEBRA_DEBUG_KERNEL)
1686 zlog_debug("netlink_route_multipath() (multihop): "
1687 "nexthop via if %u", nexthop->ifindex);
1688 }
1689 else
1690 {
1691 rtnh->rtnh_ifindex = 0;
1692 }
1693 }
1694 rtnh = RTNH_NEXT (rtnh);
1695
1696 if (cmd == RTM_NEWROUTE)
1697 SET_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB);
1698 }
1699 }
1700 if (src)
1701 addattr_l (&req.n, sizeof req, RTA_PREFSRC, &src->ipv4, bytelen);
1702
1703 if (rta->rta_len > RTA_LENGTH (0))
1704 addattr_l (&req.n, 1024, RTA_MULTIPATH, RTA_DATA (rta),
1705 RTA_PAYLOAD (rta));
1706 }
1707
1708 /* If there is no useful nexthop then return. */
1709 if (nexthop_num == 0)
1710 {
1711 if (IS_ZEBRA_DEBUG_KERNEL)
1712 zlog_debug ("netlink_route_multipath(): No useful nexthop.");
1713 return 0;
1714 }
1715
1716 skip:
1717
1718 /* Destination netlink address. */
1719 memset (&snl, 0, sizeof snl);
1720 snl.nl_family = AF_NETLINK;
1721
1722 /* Talk to netlink socket. */
1723 return netlink_talk (&req.n, &netlink_cmd);
1724 }
1725
1726 int
1727 kernel_add_ipv4 (struct prefix *p, struct rib *rib)
1728 {
1729 return netlink_route_multipath (RTM_NEWROUTE, p, rib, AF_INET);
1730 }
1731
1732 int
1733 kernel_delete_ipv4 (struct prefix *p, struct rib *rib)
1734 {
1735 return netlink_route_multipath (RTM_DELROUTE, p, rib, AF_INET);
1736 }
1737
1738 #ifdef HAVE_IPV6
1739 int
1740 kernel_add_ipv6 (struct prefix *p, struct rib *rib)
1741 {
1742 return netlink_route_multipath (RTM_NEWROUTE, p, rib, AF_INET6);
1743 }
1744
1745 int
1746 kernel_delete_ipv6 (struct prefix *p, struct rib *rib)
1747 {
1748 return netlink_route_multipath (RTM_DELROUTE, p, rib, AF_INET6);
1749 }
1750
1751 /* Delete IPv6 route from the kernel. */
1752 int
1753 kernel_delete_ipv6_old (struct prefix_ipv6 *dest, struct in6_addr *gate,
1754 unsigned int index, int flags, int table)
1755 {
1756 return netlink_route (RTM_DELROUTE, AF_INET6, &dest->prefix,
1757 dest->prefixlen, gate, index, flags, table);
1758 }
1759 #endif /* HAVE_IPV6 */
1760 \f
1761 /* Interface address modification. */
1762 static int
1763 netlink_address (int cmd, int family, struct interface *ifp,
1764 struct connected *ifc)
1765 {
1766 int bytelen;
1767 struct prefix *p;
1768
1769 struct
1770 {
1771 struct nlmsghdr n;
1772 struct ifaddrmsg ifa;
1773 char buf[1024];
1774 } req;
1775
1776 p = ifc->address;
1777 memset (&req, 0, sizeof req);
1778
1779 bytelen = (family == AF_INET ? 4 : 16);
1780
1781 req.n.nlmsg_len = NLMSG_LENGTH (sizeof (struct ifaddrmsg));
1782 req.n.nlmsg_flags = NLM_F_REQUEST;
1783 req.n.nlmsg_type = cmd;
1784 req.ifa.ifa_family = family;
1785
1786 req.ifa.ifa_index = ifp->ifindex;
1787 req.ifa.ifa_prefixlen = p->prefixlen;
1788
1789 addattr_l (&req.n, sizeof req, IFA_LOCAL, &p->u.prefix, bytelen);
1790
1791 if (family == AF_INET && cmd == RTM_NEWADDR)
1792 {
1793 if (!CONNECTED_PEER(ifc) && ifc->destination)
1794 {
1795 p = ifc->destination;
1796 addattr_l (&req.n, sizeof req, IFA_BROADCAST, &p->u.prefix,
1797 bytelen);
1798 }
1799 }
1800
1801 if (CHECK_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY))
1802 SET_FLAG (req.ifa.ifa_flags, IFA_F_SECONDARY);
1803
1804 if (ifc->label)
1805 addattr_l (&req.n, sizeof req, IFA_LABEL, ifc->label,
1806 strlen (ifc->label) + 1);
1807
1808 return netlink_talk (&req.n, &netlink_cmd);
1809 }
1810
1811 int
1812 kernel_address_add_ipv4 (struct interface *ifp, struct connected *ifc)
1813 {
1814 return netlink_address (RTM_NEWADDR, AF_INET, ifp, ifc);
1815 }
1816
1817 int
1818 kernel_address_delete_ipv4 (struct interface *ifp, struct connected *ifc)
1819 {
1820 return netlink_address (RTM_DELADDR, AF_INET, ifp, ifc);
1821 }
1822
1823
1824 extern struct thread_master *master;
1825
1826 /* Kernel route reflection. */
1827 static int
1828 kernel_read (struct thread *thread)
1829 {
1830 int ret;
1831 int sock;
1832
1833 sock = THREAD_FD (thread);
1834 ret = netlink_parse_info (netlink_information_fetch, &netlink);
1835 thread_add_read (zebrad.master, kernel_read, NULL, netlink.sock);
1836
1837 return 0;
1838 }
1839
1840 /* Filter out messages from self that occur on listener socket,
1841 caused by our actions on the command socket
1842 */
1843 static void netlink_install_filter (int sock, __u32 pid)
1844 {
1845 struct sock_filter filter[] = {
1846 /* 0: ldh [4] */
1847 BPF_STMT(BPF_LD|BPF_ABS|BPF_H, offsetof(struct nlmsghdr, nlmsg_type)),
1848 /* 1: jeq 0x18 jt 3 jf 6 */
1849 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_NEWROUTE), 1, 0),
1850 /* 2: jeq 0x19 jt 3 jf 6 */
1851 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htons(RTM_DELROUTE), 0, 3),
1852 /* 3: ldw [12] */
1853 BPF_STMT(BPF_LD|BPF_ABS|BPF_W, offsetof(struct nlmsghdr, nlmsg_pid)),
1854 /* 4: jeq XX jt 5 jf 6 */
1855 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, htonl(pid), 0, 1),
1856 /* 5: ret 0 (skip) */
1857 BPF_STMT(BPF_RET|BPF_K, 0),
1858 /* 6: ret 0xffff (keep) */
1859 BPF_STMT(BPF_RET|BPF_K, 0xffff),
1860 };
1861
1862 struct sock_fprog prog = {
1863 .len = sizeof(filter) / sizeof(filter[0]),
1864 .filter = filter,
1865 };
1866
1867 if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)) < 0)
1868 zlog_warn ("Can't install socket filter: %s\n", safe_strerror(errno));
1869 }
1870
1871 /* Exported interface function. This function simply calls
1872 netlink_socket (). */
1873 void
1874 kernel_init (void)
1875 {
1876 unsigned long groups;
1877
1878 groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR;
1879 #ifdef HAVE_IPV6
1880 groups |= RTMGRP_IPV6_ROUTE | RTMGRP_IPV6_IFADDR;
1881 #endif /* HAVE_IPV6 */
1882 netlink_socket (&netlink, groups);
1883 netlink_socket (&netlink_cmd, 0);
1884
1885 /* Register kernel socket. */
1886 if (netlink.sock > 0)
1887 {
1888 /* Only want non-blocking on the netlink event socket */
1889 if (fcntl (netlink.sock, F_SETFL, O_NONBLOCK) < 0)
1890 zlog (NULL, LOG_ERR, "Can't set %s socket flags: %s", netlink.name,
1891 safe_strerror (errno));
1892
1893 /* Set receive buffer size if it's set from command line */
1894 if (nl_rcvbufsize)
1895 netlink_recvbuf (&netlink, nl_rcvbufsize);
1896
1897 netlink_install_filter (netlink.sock, netlink_cmd.snl.nl_pid);
1898 thread_add_read (zebrad.master, kernel_read, NULL, netlink.sock);
1899 }
1900 }
FRRouting mirror