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:
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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rt_netlink.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra