Annotation of embedaddon/bird/sysdep/linux/netlink.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Linux Netlink Interface
3: *
4: * (c) 1999--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #include <stdio.h>
10: #include <unistd.h>
11: #include <fcntl.h>
12: #include <sys/socket.h>
13: #include <sys/uio.h>
14: #include <errno.h>
15:
16: #undef LOCAL_DEBUG
17:
18: #include "nest/bird.h"
19: #include "nest/route.h"
20: #include "nest/protocol.h"
21: #include "nest/iface.h"
22: #include "lib/timer.h"
23: #include "lib/unix.h"
24: #include "lib/krt.h"
25: #include "lib/socket.h"
26: #include "lib/string.h"
27: #include "lib/hash.h"
28: #include "conf/conf.h"
29:
30: #include <asm/types.h>
31: #include <linux/if.h>
32: #include <linux/netlink.h>
33: #include <linux/rtnetlink.h>
34:
35:
36: #ifndef MSG_TRUNC /* Hack: Several versions of glibc miss this one :( */
37: #define MSG_TRUNC 0x20
38: #endif
39:
40: #ifndef IFA_FLAGS
41: #define IFA_FLAGS 8
42: #endif
43:
44: #ifndef IFF_LOWER_UP
45: #define IFF_LOWER_UP 0x10000
46: #endif
47:
48: #ifndef RTA_TABLE
49: #define RTA_TABLE 15
50: #endif
51:
52:
53: #ifdef IPV6
54: #define krt_ecmp6(X) 1
55: #else
56: #define krt_ecmp6(X) 0
57: #endif
58:
59: /*
60: * Structure nl_parse_state keeps state of received route processing. Ideally,
61: * we could just independently parse received Netlink messages and immediately
62: * propagate received routes to the rest of BIRD, but Linux kernel represents
63: * and announces IPv6 ECMP routes not as one route with multiple next hops (like
64: * RTA_MULTIPATH in IPv4 ECMP), but as a set of routes with the same prefix.
65: *
66: * Therefore, BIRD keeps currently processed route in nl_parse_state structure
67: * and postpones its propagation until we expect it to be final; i.e., when
68: * non-matching route is received or when the scan ends. When another matching
69: * route is received, it is merged with the already processed route to form an
70: * ECMP route. Note that merging is done only for IPv6 (merge == 1), but the
71: * postponing is done in both cases (for simplicity). All IPv4 routes are just
72: * considered non-matching.
73: *
74: * This is ignored for asynchronous notifications (every notification is handled
75: * as a separate route). It is not an issue for our routes, as we ignore such
76: * notifications anyways. But importing alien IPv6 ECMP routes does not work
77: * properly.
78: */
79:
80: struct nl_parse_state
81: {
82: struct linpool *pool;
83: int scan;
84: int merge;
85:
86: net *net;
87: rta *attrs;
88: struct krt_proto *proto;
89: s8 new;
90: s8 krt_src;
91: u8 krt_type;
92: u8 krt_proto;
93: u32 krt_metric;
94: };
95:
96: /*
97: * Synchronous Netlink interface
98: */
99:
100: struct nl_sock
101: {
102: int fd;
103: u32 seq;
104: byte *rx_buffer; /* Receive buffer */
105: struct nlmsghdr *last_hdr; /* Recently received packet */
106: uint last_size;
107: };
108:
109: #define NL_RX_SIZE 8192
110:
111: #define NL_OP_DELETE 0
112: #define NL_OP_ADD (NLM_F_CREATE|NLM_F_EXCL)
113: #define NL_OP_REPLACE (NLM_F_CREATE|NLM_F_REPLACE)
114: #define NL_OP_APPEND (NLM_F_CREATE|NLM_F_APPEND)
115:
116: static linpool *nl_linpool;
117:
118: static struct nl_sock nl_scan = {.fd = -1}; /* Netlink socket for synchronous scan */
119: static struct nl_sock nl_req = {.fd = -1}; /* Netlink socket for requests */
120:
121: static void
122: nl_open_sock(struct nl_sock *nl)
123: {
124: if (nl->fd < 0)
125: {
126: nl->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
127: if (nl->fd < 0)
128: die("Unable to open rtnetlink socket: %m");
129: nl->seq = now;
130: nl->rx_buffer = xmalloc(NL_RX_SIZE);
131: nl->last_hdr = NULL;
132: nl->last_size = 0;
133: }
134: }
135:
136: static void
137: nl_open(void)
138: {
139: nl_open_sock(&nl_scan);
140: nl_open_sock(&nl_req);
141: }
142:
143: static void
144: nl_send(struct nl_sock *nl, struct nlmsghdr *nh)
145: {
146: struct sockaddr_nl sa;
147:
148: memset(&sa, 0, sizeof(sa));
149: sa.nl_family = AF_NETLINK;
150: nh->nlmsg_pid = 0;
151: nh->nlmsg_seq = ++(nl->seq);
152: if (sendto(nl->fd, nh, nh->nlmsg_len, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0)
153: die("rtnetlink sendto: %m");
154: nl->last_hdr = NULL;
155: }
156:
157: static void
158: nl_request_dump(int af, int cmd)
159: {
160: struct {
161: struct nlmsghdr nh;
162: struct rtgenmsg g;
163: } req = {
164: .nh.nlmsg_type = cmd,
165: .nh.nlmsg_len = sizeof(req),
166: .nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP,
167: .g.rtgen_family = af
168: };
169: nl_send(&nl_scan, &req.nh);
170: }
171:
172: static struct nlmsghdr *
173: nl_get_reply(struct nl_sock *nl)
174: {
175: for(;;)
176: {
177: if (!nl->last_hdr)
178: {
179: struct iovec iov = { nl->rx_buffer, NL_RX_SIZE };
180: struct sockaddr_nl sa;
181: struct msghdr m = {
182: .msg_name = &sa,
183: .msg_namelen = sizeof(sa),
184: .msg_iov = &iov,
185: .msg_iovlen = 1,
186: };
187: int x = recvmsg(nl->fd, &m, 0);
188: if (x < 0)
189: die("nl_get_reply: %m");
190: if (sa.nl_pid) /* It isn't from the kernel */
191: {
192: DBG("Non-kernel packet\n");
193: continue;
194: }
195: nl->last_size = x;
196: nl->last_hdr = (void *) nl->rx_buffer;
197: if (m.msg_flags & MSG_TRUNC)
198: bug("nl_get_reply: got truncated reply which should be impossible");
199: }
200: if (NLMSG_OK(nl->last_hdr, nl->last_size))
201: {
202: struct nlmsghdr *h = nl->last_hdr;
203: nl->last_hdr = NLMSG_NEXT(h, nl->last_size);
204: if (h->nlmsg_seq != nl->seq)
205: {
206: log(L_WARN "nl_get_reply: Ignoring out of sequence netlink packet (%x != %x)",
207: h->nlmsg_seq, nl->seq);
208: continue;
209: }
210: return h;
211: }
212: if (nl->last_size)
213: log(L_WARN "nl_get_reply: Found packet remnant of size %d", nl->last_size);
214: nl->last_hdr = NULL;
215: }
216: }
217:
218: static struct tbf rl_netlink_err = TBF_DEFAULT_LOG_LIMITS;
219:
220: static int
221: nl_error(struct nlmsghdr *h, int ignore_esrch)
222: {
223: struct nlmsgerr *e;
224: int ec;
225:
226: if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
227: {
228: log(L_WARN "Netlink: Truncated error message received");
229: return ENOBUFS;
230: }
231: e = (struct nlmsgerr *) NLMSG_DATA(h);
232: ec = -e->error;
233: if (ec && !(ignore_esrch && (ec == ESRCH)))
234: log_rl(&rl_netlink_err, L_WARN "Netlink: %s", strerror(ec));
235: return ec;
236: }
237:
238: static struct nlmsghdr *
239: nl_get_scan(void)
240: {
241: struct nlmsghdr *h = nl_get_reply(&nl_scan);
242:
243: if (h->nlmsg_type == NLMSG_DONE)
244: return NULL;
245: if (h->nlmsg_type == NLMSG_ERROR)
246: {
247: nl_error(h, 0);
248: return NULL;
249: }
250: return h;
251: }
252:
253: static int
254: nl_exchange(struct nlmsghdr *pkt, int ignore_esrch)
255: {
256: struct nlmsghdr *h;
257:
258: nl_send(&nl_req, pkt);
259: for(;;)
260: {
261: h = nl_get_reply(&nl_req);
262: if (h->nlmsg_type == NLMSG_ERROR)
263: break;
264: log(L_WARN "nl_exchange: Unexpected reply received");
265: }
266: return nl_error(h, ignore_esrch) ? -1 : 0;
267: }
268:
269: /*
270: * Netlink attributes
271: */
272:
273: static int nl_attr_len;
274:
275: static void *
276: nl_checkin(struct nlmsghdr *h, int lsize)
277: {
278: nl_attr_len = h->nlmsg_len - NLMSG_LENGTH(lsize);
279: if (nl_attr_len < 0)
280: {
281: log(L_ERR "nl_checkin: underrun by %d bytes", -nl_attr_len);
282: return NULL;
283: }
284: return NLMSG_DATA(h);
285: }
286:
287: struct nl_want_attrs {
288: u8 defined:1;
289: u8 checksize:1;
290: u8 size;
291: };
292:
293:
294: #define BIRD_IFLA_MAX (IFLA_WIRELESS+1)
295:
296: static struct nl_want_attrs ifla_attr_want[BIRD_IFLA_MAX] = {
297: [IFLA_IFNAME] = { 1, 0, 0 },
298: [IFLA_MTU] = { 1, 1, sizeof(u32) },
299: [IFLA_WIRELESS] = { 1, 0, 0 },
300: };
301:
302:
303: #define BIRD_IFA_MAX (IFA_FLAGS+1)
304:
305: #ifndef IPV6
306: static struct nl_want_attrs ifa_attr_want4[BIRD_IFA_MAX] = {
307: [IFA_ADDRESS] = { 1, 1, sizeof(ip4_addr) },
308: [IFA_LOCAL] = { 1, 1, sizeof(ip4_addr) },
309: [IFA_BROADCAST] = { 1, 1, sizeof(ip4_addr) },
310: [IFA_FLAGS] = { 1, 1, sizeof(u32) },
311: };
312: #else
313: static struct nl_want_attrs ifa_attr_want6[BIRD_IFA_MAX] = {
314: [IFA_ADDRESS] = { 1, 1, sizeof(ip6_addr) },
315: [IFA_LOCAL] = { 1, 1, sizeof(ip6_addr) },
316: [IFA_FLAGS] = { 1, 1, sizeof(u32) },
317: };
318: #endif
319:
320:
321: #define BIRD_RTA_MAX (RTA_TABLE+1)
322:
323: static struct nl_want_attrs mpnh_attr_want4[BIRD_RTA_MAX] = {
324: [RTA_GATEWAY] = { 1, 1, sizeof(ip4_addr) },
325: };
326:
327: #ifndef IPV6
328: static struct nl_want_attrs rtm_attr_want4[BIRD_RTA_MAX] = {
329: [RTA_DST] = { 1, 1, sizeof(ip4_addr) },
330: [RTA_OIF] = { 1, 1, sizeof(u32) },
331: [RTA_GATEWAY] = { 1, 1, sizeof(ip4_addr) },
332: [RTA_PRIORITY] = { 1, 1, sizeof(u32) },
333: [RTA_PREFSRC] = { 1, 1, sizeof(ip4_addr) },
334: [RTA_METRICS] = { 1, 0, 0 },
335: [RTA_MULTIPATH] = { 1, 0, 0 },
336: [RTA_FLOW] = { 1, 1, sizeof(u32) },
337: [RTA_TABLE] = { 1, 1, sizeof(u32) },
338: };
339: #else
340: static struct nl_want_attrs rtm_attr_want6[BIRD_RTA_MAX] = {
341: [RTA_DST] = { 1, 1, sizeof(ip6_addr) },
342: [RTA_IIF] = { 1, 1, sizeof(u32) },
343: [RTA_OIF] = { 1, 1, sizeof(u32) },
344: [RTA_GATEWAY] = { 1, 1, sizeof(ip6_addr) },
345: [RTA_PRIORITY] = { 1, 1, sizeof(u32) },
346: [RTA_PREFSRC] = { 1, 1, sizeof(ip6_addr) },
347: [RTA_METRICS] = { 1, 0, 0 },
348: [RTA_FLOW] = { 1, 1, sizeof(u32) },
349: [RTA_TABLE] = { 1, 1, sizeof(u32) },
350: };
351: #endif
352:
353:
354: static int
355: nl_parse_attrs(struct rtattr *a, struct nl_want_attrs *want, struct rtattr **k, int ksize)
356: {
357: int max = ksize / sizeof(struct rtattr *);
358: bzero(k, ksize);
359:
360: for ( ; RTA_OK(a, nl_attr_len); a = RTA_NEXT(a, nl_attr_len))
361: {
362: if ((a->rta_type >= max) || !want[a->rta_type].defined)
363: continue;
364:
365: if (want[a->rta_type].checksize && (RTA_PAYLOAD(a) != want[a->rta_type].size))
366: {
367: log(L_ERR "nl_parse_attrs: Malformed message received");
368: return 0;
369: }
370:
371: k[a->rta_type] = a;
372: }
373:
374: if (nl_attr_len)
375: {
376: log(L_ERR "nl_parse_attrs: remnant of size %d", nl_attr_len);
377: return 0;
378: }
379:
380: return 1;
381: }
382:
383: static inline u32 rta_get_u32(struct rtattr *a)
384: { return *(u32 *) RTA_DATA(a); }
385:
386: static inline ip4_addr rta_get_ip4(struct rtattr *a)
387: { return ip4_ntoh(*(ip4_addr *) RTA_DATA(a)); }
388:
389: static inline ip6_addr rta_get_ip6(struct rtattr *a)
390: { return ip6_ntoh(*(ip6_addr *) RTA_DATA(a)); }
391:
392:
393: struct rtattr *
394: nl_add_attr(struct nlmsghdr *h, uint bufsize, uint code, const void *data, uint dlen)
395: {
396: uint pos = NLMSG_ALIGN(h->nlmsg_len);
397: uint len = RTA_LENGTH(dlen);
398:
399: if (pos + len > bufsize)
400: bug("nl_add_attr: packet buffer overflow");
401:
402: struct rtattr *a = (struct rtattr *)((char *)h + pos);
403: a->rta_type = code;
404: a->rta_len = len;
405: h->nlmsg_len = pos + len;
406:
407: if (dlen > 0)
408: memcpy(RTA_DATA(a), data, dlen);
409:
410: return a;
411: }
412:
413: static inline void
414: nl_add_attr_u32(struct nlmsghdr *h, unsigned bufsize, int code, u32 data)
415: {
416: nl_add_attr(h, bufsize, code, &data, 4);
417: }
418:
419: static inline void
420: nl_add_attr_ipa(struct nlmsghdr *h, unsigned bufsize, int code, ip_addr ipa)
421: {
422: ipa_hton(ipa);
423: nl_add_attr(h, bufsize, code, &ipa, sizeof(ipa));
424: }
425:
426: static inline struct rtattr *
427: nl_open_attr(struct nlmsghdr *h, uint bufsize, uint code)
428: {
429: return nl_add_attr(h, bufsize, code, NULL, 0);
430: }
431:
432: static inline void
433: nl_close_attr(struct nlmsghdr *h, struct rtattr *a)
434: {
435: a->rta_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)a;
436: }
437:
438: static inline struct rtnexthop *
439: nl_open_nexthop(struct nlmsghdr *h, uint bufsize)
440: {
441: uint pos = NLMSG_ALIGN(h->nlmsg_len);
442: uint len = RTNH_LENGTH(0);
443:
444: if (pos + len > bufsize)
445: bug("nl_open_nexthop: packet buffer overflow");
446:
447: h->nlmsg_len = pos + len;
448:
449: return (void *)h + pos;
450: }
451:
452: static inline void
453: nl_close_nexthop(struct nlmsghdr *h, struct rtnexthop *nh)
454: {
455: nh->rtnh_len = (void *)h + NLMSG_ALIGN(h->nlmsg_len) - (void *)nh;
456: }
457:
458: static void
459: nl_add_multipath(struct nlmsghdr *h, unsigned bufsize, struct mpnh *nh)
460: {
461: struct rtattr *a = nl_open_attr(h, bufsize, RTA_MULTIPATH);
462:
463: for (; nh; nh = nh->next)
464: {
465: struct rtnexthop *rtnh = nl_open_nexthop(h, bufsize);
466:
467: rtnh->rtnh_flags = 0;
468: rtnh->rtnh_hops = nh->weight;
469: rtnh->rtnh_ifindex = nh->iface->index;
470:
471: nl_add_attr_ipa(h, bufsize, RTA_GATEWAY, nh->gw);
472:
473: nl_close_nexthop(h, rtnh);
474: }
475:
476: nl_close_attr(h, a);
477: }
478:
479: static struct mpnh *
480: nl_parse_multipath(struct krt_proto *p, struct rtattr *ra)
481: {
482: /* Temporary buffer for multicast nexthops */
483: static struct mpnh *nh_buffer;
484: static int nh_buf_size; /* in number of structures */
485: static int nh_buf_used;
486:
487: struct rtattr *a[BIRD_RTA_MAX];
488: struct rtnexthop *nh = RTA_DATA(ra);
489: struct mpnh *rv, *first, **last;
490: unsigned len = RTA_PAYLOAD(ra);
491:
492: first = NULL;
493: last = &first;
494: nh_buf_used = 0;
495:
496: while (len)
497: {
498: /* Use RTNH_OK(nh,len) ?? */
499: if ((len < sizeof(*nh)) || (len < nh->rtnh_len))
500: return NULL;
501:
502: if (nh_buf_used == nh_buf_size)
503: {
504: nh_buf_size = nh_buf_size ? (nh_buf_size * 2) : 4;
505: nh_buffer = xrealloc(nh_buffer, nh_buf_size * sizeof(struct mpnh));
506: }
507: *last = rv = nh_buffer + nh_buf_used++;
508: rv->next = NULL;
509: last = &(rv->next);
510:
511: rv->weight = nh->rtnh_hops;
512: rv->iface = if_find_by_index(nh->rtnh_ifindex);
513: if (!rv->iface)
514: return NULL;
515:
516: /* Nonexistent RTNH_PAYLOAD ?? */
517: nl_attr_len = nh->rtnh_len - RTNH_LENGTH(0);
518: nl_parse_attrs(RTNH_DATA(nh), mpnh_attr_want4, a, sizeof(a));
519: if (a[RTA_GATEWAY])
520: {
521: memcpy(&rv->gw, RTA_DATA(a[RTA_GATEWAY]), sizeof(ip_addr));
522: ipa_ntoh(rv->gw);
523:
524: neighbor *ng = neigh_find2(&p->p, &rv->gw, rv->iface,
525: (nh->rtnh_flags & RTNH_F_ONLINK) ? NEF_ONLINK : 0);
526: if (!ng || (ng->scope == SCOPE_HOST))
527: return NULL;
528: }
529: else
530: return NULL;
531:
532: len -= NLMSG_ALIGN(nh->rtnh_len);
533: nh = RTNH_NEXT(nh);
534: }
535:
536: return first;
537: }
538:
539: static void
540: nl_add_metrics(struct nlmsghdr *h, uint bufsize, u32 *metrics, int max)
541: {
542: struct rtattr *a = nl_open_attr(h, bufsize, RTA_METRICS);
543: int t;
544:
545: for (t = 1; t < max; t++)
546: if (metrics[0] & (1 << t))
547: nl_add_attr_u32(h, bufsize, t, metrics[t]);
548:
549: nl_close_attr(h, a);
550: }
551:
552: static int
553: nl_parse_metrics(struct rtattr *hdr, u32 *metrics, int max)
554: {
555: struct rtattr *a = RTA_DATA(hdr);
556: int len = RTA_PAYLOAD(hdr);
557:
558: metrics[0] = 0;
559: for (; RTA_OK(a, len); a = RTA_NEXT(a, len))
560: {
561: if (a->rta_type == RTA_UNSPEC)
562: continue;
563:
564: if (a->rta_type >= max)
565: continue;
566:
567: if (RTA_PAYLOAD(a) != 4)
568: return -1;
569:
570: metrics[0] |= 1 << a->rta_type;
571: metrics[a->rta_type] = rta_get_u32(a);
572: }
573:
574: if (len > 0)
575: return -1;
576:
577: return 0;
578: }
579:
580:
581: /*
582: * Scanning of interfaces
583: */
584:
585: static void
586: nl_parse_link(struct nlmsghdr *h, int scan)
587: {
588: struct ifinfomsg *i;
589: struct rtattr *a[BIRD_IFLA_MAX];
590: int new = h->nlmsg_type == RTM_NEWLINK;
591: struct iface f = {};
592: struct iface *ifi;
593: char *name;
594: u32 mtu;
595: uint fl;
596:
597: if (!(i = nl_checkin(h, sizeof(*i))) || !nl_parse_attrs(IFLA_RTA(i), ifla_attr_want, a, sizeof(a)))
598: return;
599: if (!a[IFLA_IFNAME] || (RTA_PAYLOAD(a[IFLA_IFNAME]) < 2) || !a[IFLA_MTU])
600: {
601: /*
602: * IFLA_IFNAME and IFLA_MTU are required, in fact, but there may also come
603: * a message with IFLA_WIRELESS set, where (e.g.) no IFLA_IFNAME exists.
604: * We simply ignore all such messages with IFLA_WIRELESS without notice.
605: */
606:
607: if (a[IFLA_WIRELESS])
608: return;
609:
610: log(L_ERR "KIF: Malformed message received");
611: return;
612: }
613:
614: name = RTA_DATA(a[IFLA_IFNAME]);
615: mtu = rta_get_u32(a[IFLA_MTU]);
616:
617: ifi = if_find_by_index(i->ifi_index);
618: if (!new)
619: {
620: DBG("KIF: IF%d(%s) goes down\n", i->ifi_index, name);
621: if (!ifi)
622: return;
623:
624: if_delete(ifi);
625: }
626: else
627: {
628: DBG("KIF: IF%d(%s) goes up (mtu=%d,flg=%x)\n", i->ifi_index, name, mtu, i->ifi_flags);
629: if (ifi && strncmp(ifi->name, name, sizeof(ifi->name)-1))
630: if_delete(ifi);
631:
632: strncpy(f.name, name, sizeof(f.name)-1);
633: f.index = i->ifi_index;
634: f.mtu = mtu;
635:
636: fl = i->ifi_flags;
637: if (fl & IFF_UP)
638: f.flags |= IF_ADMIN_UP;
639: if (fl & IFF_LOWER_UP)
640: f.flags |= IF_LINK_UP;
641: if (fl & IFF_LOOPBACK) /* Loopback */
642: f.flags |= IF_MULTIACCESS | IF_LOOPBACK | IF_IGNORE;
643: else if (fl & IFF_POINTOPOINT) /* PtP */
644: f.flags |= IF_MULTICAST;
645: else if (fl & IFF_BROADCAST) /* Broadcast */
646: f.flags |= IF_MULTIACCESS | IF_BROADCAST | IF_MULTICAST;
647: else
648: f.flags |= IF_MULTIACCESS; /* NBMA */
649:
650: if (fl & IFF_MULTICAST)
651: f.flags |= IF_MULTICAST;
652:
653: ifi = if_update(&f);
654:
655: if (!scan)
656: if_end_partial_update(ifi);
657: }
658: }
659:
660: static void
661: nl_parse_addr(struct nlmsghdr *h, int scan)
662: {
663: struct ifaddrmsg *i;
664: struct rtattr *a[BIRD_IFA_MAX];
665: int new = h->nlmsg_type == RTM_NEWADDR;
666: struct ifa ifa;
667: struct iface *ifi;
668: int scope;
669: u32 ifa_flags;
670:
671: if (!(i = nl_checkin(h, sizeof(*i))))
672: return;
673:
674: switch (i->ifa_family)
675: {
676: #ifndef IPV6
677: case AF_INET:
678: if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want4, a, sizeof(a)))
679: return;
680: if (!a[IFA_LOCAL])
681: {
682: log(L_ERR "KIF: Malformed message received (missing IFA_LOCAL)");
683: return;
684: }
685: break;
686: #else
687: case AF_INET6:
688: if (!nl_parse_attrs(IFA_RTA(i), ifa_attr_want6, a, sizeof(a)))
689: return;
690: break;
691: #endif
692: default:
693: return;
694: }
695:
696: if (!a[IFA_ADDRESS])
697: {
698: log(L_ERR "KIF: Malformed message received (missing IFA_ADDRESS)");
699: return;
700: }
701:
702: if (a[IFA_FLAGS])
703: ifa_flags = rta_get_u32(a[IFA_FLAGS]);
704: else
705: ifa_flags = i->ifa_flags;
706:
707: ifi = if_find_by_index(i->ifa_index);
708: if (!ifi)
709: {
710: log(L_ERR "KIF: Received address message for unknown interface %d", i->ifa_index);
711: return;
712: }
713:
714: bzero(&ifa, sizeof(ifa));
715: ifa.iface = ifi;
716: if (ifa_flags & IFA_F_SECONDARY)
717: ifa.flags |= IA_SECONDARY;
718:
719: #ifdef IPV6
720: /* Ignore tentative addresses silently */
721: if (ifa_flags & IFA_F_TENTATIVE)
722: return;
723: #endif
724:
725: /* IFA_LOCAL can be unset for IPv6 interfaces */
726: memcpy(&ifa.ip, RTA_DATA(a[IFA_LOCAL] ? : a[IFA_ADDRESS]), sizeof(ifa.ip));
727: ipa_ntoh(ifa.ip);
728: ifa.pxlen = i->ifa_prefixlen;
729: if (i->ifa_prefixlen > BITS_PER_IP_ADDRESS)
730: {
731: log(L_ERR "KIF: Invalid prefix length for interface %s: %d", ifi->name, i->ifa_prefixlen);
732: new = 0;
733: }
734: if (i->ifa_prefixlen == BITS_PER_IP_ADDRESS)
735: {
736: ip_addr addr;
737: memcpy(&addr, RTA_DATA(a[IFA_ADDRESS]), sizeof(addr));
738: ipa_ntoh(addr);
739: ifa.prefix = ifa.brd = addr;
740:
741: /* It is either a host address or a peer address */
742: if (ipa_equal(ifa.ip, addr))
743: ifa.flags |= IA_HOST;
744: else
745: {
746: ifa.flags |= IA_PEER;
747: ifa.opposite = addr;
748: }
749: }
750: else
751: {
752: ip_addr netmask = ipa_mkmask(ifa.pxlen);
753: ifa.prefix = ipa_and(ifa.ip, netmask);
754: ifa.brd = ipa_or(ifa.ip, ipa_not(netmask));
755: if (i->ifa_prefixlen == BITS_PER_IP_ADDRESS - 1)
756: ifa.opposite = ipa_opposite_m1(ifa.ip);
757:
758: #ifndef IPV6
759: if (i->ifa_prefixlen == BITS_PER_IP_ADDRESS - 2)
760: ifa.opposite = ipa_opposite_m2(ifa.ip);
761:
762: if ((ifi->flags & IF_BROADCAST) && a[IFA_BROADCAST])
763: {
764: ip_addr xbrd;
765: memcpy(&xbrd, RTA_DATA(a[IFA_BROADCAST]), sizeof(xbrd));
766: ipa_ntoh(xbrd);
767: if (ipa_equal(xbrd, ifa.prefix) || ipa_equal(xbrd, ifa.brd))
768: ifa.brd = xbrd;
769: else if (ifi->flags & IF_TMP_DOWN) /* Complain only during the first scan */
770: log(L_ERR "KIF: Invalid broadcast address %I for %s", xbrd, ifi->name);
771: }
772: #endif
773: }
774:
775: scope = ipa_classify(ifa.ip);
776: if (scope < 0)
777: {
778: log(L_ERR "KIF: Invalid interface address %I for %s", ifa.ip, ifi->name);
779: return;
780: }
781: ifa.scope = scope & IADDR_SCOPE_MASK;
782:
783: DBG("KIF: IF%d(%s): %s IPA %I, flg %x, net %I/%d, brd %I, opp %I\n",
784: ifi->index, ifi->name,
785: new ? "added" : "removed",
786: ifa.ip, ifa.flags, ifa.prefix, ifa.pxlen, ifa.brd, ifa.opposite);
787:
788: if (new)
789: ifa_update(&ifa);
790: else
791: ifa_delete(&ifa);
792:
793: if (!scan)
794: if_end_partial_update(ifi);
795: }
796:
797: void
798: kif_do_scan(struct kif_proto *p UNUSED)
799: {
800: struct nlmsghdr *h;
801:
802: if_start_update();
803:
804: nl_request_dump(AF_UNSPEC, RTM_GETLINK);
805: while (h = nl_get_scan())
806: if (h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)
807: nl_parse_link(h, 1);
808: else
809: log(L_DEBUG "nl_scan_ifaces: Unknown packet received (type=%d)", h->nlmsg_type);
810:
811: nl_request_dump(BIRD_AF, RTM_GETADDR);
812: while (h = nl_get_scan())
813: if (h->nlmsg_type == RTM_NEWADDR || h->nlmsg_type == RTM_DELADDR)
814: nl_parse_addr(h, 1);
815: else
816: log(L_DEBUG "nl_scan_ifaces: Unknown packet received (type=%d)", h->nlmsg_type);
817:
818: if_end_update();
819: }
820:
821: /*
822: * Routes
823: */
824:
825: static inline u32
826: krt_table_id(struct krt_proto *p)
827: {
828: return KRT_CF->sys.table_id;
829: }
830:
831: static HASH(struct krt_proto) nl_table_map;
832:
833: #define RTH_FN(k) u32_hash(k)
834: #define RTH_EQ(k1,k2) k1 == k2
835: #define RTH_KEY(p) krt_table_id(p)
836: #define RTH_NEXT(p) p->sys.hash_next
837:
838: #define RTH_REHASH rth_rehash
839: #define RTH_PARAMS /8, *2, 2, 2, 6, 20
840:
841: HASH_DEFINE_REHASH_FN(RTH, struct krt_proto)
842:
843: int
844: krt_capable(rte *e)
845: {
846: rta *a = e->attrs;
847:
848: if (a->cast != RTC_UNICAST)
849: return 0;
850:
851: switch (a->dest)
852: {
853: case RTD_ROUTER:
854: case RTD_DEVICE:
855: if (a->iface == NULL)
856: return 0;
857: case RTD_BLACKHOLE:
858: case RTD_UNREACHABLE:
859: case RTD_PROHIBIT:
860: case RTD_MULTIPATH:
861: break;
862: default:
863: return 0;
864: }
865: return 1;
866: }
867:
868: static inline int
869: nh_bufsize(struct mpnh *nh)
870: {
871: int rv = 0;
872: for (; nh != NULL; nh = nh->next)
873: rv += RTNH_LENGTH(RTA_LENGTH(sizeof(ip_addr)));
874: return rv;
875: }
876:
877: static int
878: nl_send_route(struct krt_proto *p, rte *e, struct ea_list *eattrs, int op, int dest, ip_addr gw, struct iface *iface)
879: {
880: eattr *ea;
881: net *net = e->net;
882: rta *a = e->attrs;
883: u32 priority = 0;
884:
885: struct {
886: struct nlmsghdr h;
887: struct rtmsg r;
888: char buf[128 + KRT_METRICS_MAX*8 + nh_bufsize(a->nexthops)];
889: } r;
890:
891: DBG("nl_send_route(%I/%d,op=%x)\n", net->n.prefix, net->n.pxlen, op);
892:
893: bzero(&r.h, sizeof(r.h));
894: bzero(&r.r, sizeof(r.r));
895: r.h.nlmsg_type = op ? RTM_NEWROUTE : RTM_DELROUTE;
896: r.h.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
897: r.h.nlmsg_flags = op | NLM_F_REQUEST | NLM_F_ACK;
898:
899: r.r.rtm_family = BIRD_AF;
900: r.r.rtm_dst_len = net->n.pxlen;
901: r.r.rtm_protocol = RTPROT_BIRD;
902: r.r.rtm_scope = RT_SCOPE_NOWHERE;
903: nl_add_attr_ipa(&r.h, sizeof(r), RTA_DST, net->n.prefix);
904:
905: /*
906: * Strange behavior for RTM_DELROUTE:
907: * 1) rtm_family is ignored in IPv6, works for IPv4
908: * 2) not setting RTA_PRIORITY is different from setting default value (on IPv6)
909: * 3) not setting RTA_PRIORITY is equivalent to setting 0, which is wildcard
910: */
911:
912: if (krt_table_id(p) < 256)
913: r.r.rtm_table = krt_table_id(p);
914: else
915: nl_add_attr_u32(&r.h, sizeof(r), RTA_TABLE, krt_table_id(p));
916:
917: if (a->source == RTS_DUMMY)
918: priority = e->u.krt.metric;
919: else if (KRT_CF->sys.metric)
920: priority = KRT_CF->sys.metric;
921: else if ((op != NL_OP_DELETE) && (ea = ea_find(eattrs, EA_KRT_METRIC)))
922: priority = ea->u.data;
923:
924: if (priority)
925: nl_add_attr_u32(&r.h, sizeof(r), RTA_PRIORITY, priority);
926:
927: /* For route delete, we do not specify remaining route attributes */
928: if (op == NL_OP_DELETE)
929: goto dest;
930:
931: /* Default scope is LINK for device routes, UNIVERSE otherwise */
932: if (ea = ea_find(eattrs, EA_KRT_SCOPE))
933: r.r.rtm_scope = ea->u.data;
934: else
935: r.r.rtm_scope = (dest == RTD_DEVICE) ? RT_SCOPE_LINK : RT_SCOPE_UNIVERSE;
936:
937: if (ea = ea_find(eattrs, EA_KRT_PREFSRC))
938: nl_add_attr_ipa(&r.h, sizeof(r), RTA_PREFSRC, *(ip_addr *)ea->u.ptr->data);
939:
940: if (ea = ea_find(eattrs, EA_KRT_REALM))
941: nl_add_attr_u32(&r.h, sizeof(r), RTA_FLOW, ea->u.data);
942:
943:
944: u32 metrics[KRT_METRICS_MAX];
945: metrics[0] = 0;
946:
947: struct ea_walk_state ews = { .eattrs = eattrs };
948: while (ea = ea_walk(&ews, EA_KRT_METRICS, KRT_METRICS_MAX))
949: {
950: int id = ea->id - EA_KRT_METRICS;
951: metrics[0] |= 1 << id;
952: metrics[id] = ea->u.data;
953: }
954:
955: if (metrics[0])
956: nl_add_metrics(&r.h, sizeof(r), metrics, KRT_METRICS_MAX);
957:
958:
959: dest:
960: /* a->iface != NULL checked in krt_capable() for router and device routes */
961: switch (dest)
962: {
963: case RTD_ROUTER:
964: r.r.rtm_type = RTN_UNICAST;
965: nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, iface->index);
966: nl_add_attr_ipa(&r.h, sizeof(r), RTA_GATEWAY, gw);
967: break;
968: case RTD_DEVICE:
969: r.r.rtm_type = RTN_UNICAST;
970: nl_add_attr_u32(&r.h, sizeof(r), RTA_OIF, iface->index);
971: break;
972: case RTD_BLACKHOLE:
973: r.r.rtm_type = RTN_BLACKHOLE;
974: break;
975: case RTD_UNREACHABLE:
976: r.r.rtm_type = RTN_UNREACHABLE;
977: break;
978: case RTD_PROHIBIT:
979: r.r.rtm_type = RTN_PROHIBIT;
980: break;
981: case RTD_MULTIPATH:
982: r.r.rtm_type = RTN_UNICAST;
983: nl_add_multipath(&r.h, sizeof(r), a->nexthops);
984: break;
985: case RTD_NONE:
986: break;
987: default:
988: bug("krt_capable inconsistent with nl_send_route");
989: }
990:
991: /* Ignore missing for DELETE */
992: return nl_exchange(&r.h, (op == NL_OP_DELETE));
993: }
994:
995: static inline int
996: nl_add_rte(struct krt_proto *p, rte *e, struct ea_list *eattrs)
997: {
998: rta *a = e->attrs;
999: int err = 0;
1000:
1001: if (krt_ecmp6(p) && (a->dest == RTD_MULTIPATH))
1002: {
1003: struct mpnh *nh = a->nexthops;
1004:
1005: err = nl_send_route(p, e, eattrs, NL_OP_ADD, RTD_ROUTER, nh->gw, nh->iface);
1006: if (err < 0)
1007: return err;
1008:
1009: for (nh = nh->next; nh; nh = nh->next)
1010: err += nl_send_route(p, e, eattrs, NL_OP_APPEND, RTD_ROUTER, nh->gw, nh->iface);
1011:
1012: return err;
1013: }
1014:
1015: return nl_send_route(p, e, eattrs, NL_OP_ADD, a->dest, a->gw, a->iface);
1016: }
1017:
1018: static inline int
1019: nl_delete_rte(struct krt_proto *p, rte *e, struct ea_list *eattrs)
1020: {
1021: int err = 0;
1022:
1023: /* For IPv6, we just repeatedly request DELETE until we get error */
1024: do
1025: err = nl_send_route(p, e, eattrs, NL_OP_DELETE, RTD_NONE, IPA_NONE, NULL);
1026: while (krt_ecmp6(p) && !err);
1027:
1028: return err;
1029: }
1030:
1031: void
1032: krt_replace_rte(struct krt_proto *p, net *n, rte *new, rte *old, struct ea_list *eattrs)
1033: {
1034: int err = 0;
1035:
1036: /*
1037: * We could use NL_OP_REPLACE, but route replace on Linux has some problems:
1038: *
1039: * 1) Does not check for matching rtm_protocol
1040: * 2) Has broken semantics for IPv6 ECMP
1041: * 3) Crashes some kernel version when used for IPv6 ECMP
1042: *
1043: * So we use NL_OP_DELETE and then NL_OP_ADD. We also do not trust the old
1044: * route value, so we do not try to optimize IPv6 ECMP reconfigurations.
1045: */
1046:
1047: if (old)
1048: nl_delete_rte(p, old, eattrs);
1049:
1050: if (new)
1051: err = nl_add_rte(p, new, eattrs);
1052:
1053: if (err < 0)
1054: n->n.flags |= KRF_SYNC_ERROR;
1055: else
1056: n->n.flags &= ~KRF_SYNC_ERROR;
1057: }
1058:
1059:
1060: static inline struct mpnh *
1061: nl_alloc_mpnh(struct nl_parse_state *s, ip_addr gw, struct iface *iface, byte weight)
1062: {
1063: struct mpnh *nh = lp_alloc(s->pool, sizeof(struct mpnh));
1064:
1065: nh->gw = gw;
1066: nh->iface = iface;
1067: nh->next = NULL;
1068: nh->weight = weight;
1069:
1070: return nh;
1071: }
1072:
1073: static int
1074: nl_mergable_route(struct nl_parse_state *s, net *net, struct krt_proto *p, uint priority, uint krt_type)
1075: {
1076: /* Route merging must be active */
1077: if (!s->merge)
1078: return 0;
1079:
1080: /* Saved and new route must have same network, proto/table, and priority */
1081: if ((s->net != net) || (s->proto != p) || (s->krt_metric != priority))
1082: return 0;
1083:
1084: /* Both must be regular unicast routes */
1085: if ((s->krt_type != RTN_UNICAST) || (krt_type != RTN_UNICAST))
1086: return 0;
1087:
1088: return 1;
1089: }
1090:
1091: static void
1092: nl_announce_route(struct nl_parse_state *s)
1093: {
1094: rte *e = rte_get_temp(s->attrs);
1095: e->net = s->net;
1096: e->u.krt.src = s->krt_src;
1097: e->u.krt.proto = s->krt_proto;
1098: e->u.krt.seen = 0;
1099: e->u.krt.best = 0;
1100: e->u.krt.metric = s->krt_metric;
1101:
1102: if (s->scan)
1103: krt_got_route(s->proto, e);
1104: else
1105: krt_got_route_async(s->proto, e, s->new);
1106:
1107: s->net = NULL;
1108: s->attrs = NULL;
1109: s->proto = NULL;
1110: lp_flush(s->pool);
1111: }
1112:
1113: static inline void
1114: nl_parse_begin(struct nl_parse_state *s, int scan, int merge)
1115: {
1116: memset(s, 0, sizeof (struct nl_parse_state));
1117: s->pool = nl_linpool;
1118: s->scan = scan;
1119: s->merge = merge;
1120: }
1121:
1122: static inline void
1123: nl_parse_end(struct nl_parse_state *s)
1124: {
1125: if (s->net)
1126: nl_announce_route(s);
1127: }
1128:
1129:
1130: #define SKIP(ARG...) do { DBG("KRT: Ignoring route - " ARG); return; } while(0)
1131:
1132: static void
1133: nl_parse_route(struct nl_parse_state *s, struct nlmsghdr *h)
1134: {
1135: struct krt_proto *p;
1136: struct rtmsg *i;
1137: struct rtattr *a[BIRD_RTA_MAX];
1138: int new = h->nlmsg_type == RTM_NEWROUTE;
1139:
1140: ip_addr dst = IPA_NONE;
1141: u32 oif = ~0;
1142: u32 table;
1143: u32 priority = 0;
1144: u32 def_scope = RT_SCOPE_UNIVERSE;
1145: int src;
1146:
1147: if (!(i = nl_checkin(h, sizeof(*i))))
1148: return;
1149:
1150: switch (i->rtm_family)
1151: {
1152: #ifndef IPV6
1153: case AF_INET:
1154: if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want4, a, sizeof(a)))
1155: return;
1156: break;
1157: #else
1158: case AF_INET6:
1159: if (!nl_parse_attrs(RTM_RTA(i), rtm_attr_want6, a, sizeof(a)))
1160: return;
1161: break;
1162: #endif
1163: default:
1164: return;
1165: }
1166:
1167: if (a[RTA_DST])
1168: {
1169: memcpy(&dst, RTA_DATA(a[RTA_DST]), sizeof(dst));
1170: ipa_ntoh(dst);
1171: }
1172:
1173: if (a[RTA_OIF])
1174: oif = rta_get_u32(a[RTA_OIF]);
1175:
1176: if (a[RTA_TABLE])
1177: table = rta_get_u32(a[RTA_TABLE]);
1178: else
1179: table = i->rtm_table;
1180:
1181: p = HASH_FIND(nl_table_map, RTH, table); /* Do we know this table? */
1182: DBG("KRT: Got %I/%d, type=%d, oif=%d, table=%d, prid=%d, proto=%s\n", dst, i->rtm_dst_len, i->rtm_type, oif, table, i->rtm_protocol, p ? p->p.name : "(none)");
1183: if (!p)
1184: SKIP("unknown table %d\n", table);
1185:
1186: #ifdef IPV6
1187: if (a[RTA_IIF])
1188: SKIP("IIF set\n");
1189: #else
1190: if (i->rtm_tos != 0) /* We don't support TOS */
1191: SKIP("TOS %02x\n", i->rtm_tos);
1192: #endif
1193:
1194: if (s->scan && !new)
1195: SKIP("RTM_DELROUTE in scan\n");
1196:
1197: if (a[RTA_PRIORITY])
1198: priority = rta_get_u32(a[RTA_PRIORITY]);
1199:
1200: int c = ipa_classify_net(dst);
1201: if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
1202: SKIP("strange class/scope\n");
1203:
1204: switch (i->rtm_protocol)
1205: {
1206: case RTPROT_UNSPEC:
1207: SKIP("proto unspec\n");
1208:
1209: case RTPROT_REDIRECT:
1210: src = KRT_SRC_REDIRECT;
1211: break;
1212:
1213: case RTPROT_KERNEL:
1214: src = KRT_SRC_KERNEL;
1215: return;
1216:
1217: case RTPROT_BIRD:
1218: if (!s->scan)
1219: SKIP("echo\n");
1220: src = KRT_SRC_BIRD;
1221: break;
1222:
1223: case RTPROT_BOOT:
1224: default:
1225: src = KRT_SRC_ALIEN;
1226: }
1227:
1228: net *net = net_get(p->p.table, dst, i->rtm_dst_len);
1229:
1230: if (s->net && !nl_mergable_route(s, net, p, priority, i->rtm_type))
1231: nl_announce_route(s);
1232:
1233: rta *ra = lp_allocz(s->pool, sizeof(rta));
1234: ra->src = p->p.main_source;
1235: ra->source = RTS_INHERIT;
1236: ra->scope = SCOPE_UNIVERSE;
1237: ra->cast = RTC_UNICAST;
1238:
1239: switch (i->rtm_type)
1240: {
1241: case RTN_UNICAST:
1242:
1243: if (a[RTA_MULTIPATH] && (i->rtm_family == AF_INET))
1244: {
1245: ra->dest = RTD_MULTIPATH;
1246: ra->nexthops = nl_parse_multipath(p, a[RTA_MULTIPATH]);
1247: if (!ra->nexthops)
1248: {
1249: log(L_ERR "KRT: Received strange multipath route %I/%d",
1250: net->n.prefix, net->n.pxlen);
1251: return;
1252: }
1253:
1254: break;
1255: }
1256:
1257: ra->iface = if_find_by_index(oif);
1258: if (!ra->iface)
1259: {
1260: log(L_ERR "KRT: Received route %I/%d with unknown ifindex %u",
1261: net->n.prefix, net->n.pxlen, oif);
1262: return;
1263: }
1264:
1265: if (a[RTA_GATEWAY])
1266: {
1267: neighbor *ng;
1268: ra->dest = RTD_ROUTER;
1269: memcpy(&ra->gw, RTA_DATA(a[RTA_GATEWAY]), sizeof(ra->gw));
1270: ipa_ntoh(ra->gw);
1271:
1272: #ifdef IPV6
1273: /* Silently skip strange 6to4 routes */
1274: if (ipa_in_net(ra->gw, IPA_NONE, 96))
1275: return;
1276: #endif
1277:
1278: ng = neigh_find2(&p->p, &ra->gw, ra->iface,
1279: (i->rtm_flags & RTNH_F_ONLINK) ? NEF_ONLINK : 0);
1280: if (!ng || (ng->scope == SCOPE_HOST))
1281: {
1282: log(L_ERR "KRT: Received route %I/%d with strange next-hop %I",
1283: net->n.prefix, net->n.pxlen, ra->gw);
1284: return;
1285: }
1286: }
1287: else
1288: {
1289: ra->dest = RTD_DEVICE;
1290: def_scope = RT_SCOPE_LINK;
1291: }
1292:
1293: break;
1294: case RTN_BLACKHOLE:
1295: ra->dest = RTD_BLACKHOLE;
1296: break;
1297: case RTN_UNREACHABLE:
1298: ra->dest = RTD_UNREACHABLE;
1299: break;
1300: case RTN_PROHIBIT:
1301: ra->dest = RTD_PROHIBIT;
1302: break;
1303: /* FIXME: What about RTN_THROW? */
1304: default:
1305: SKIP("type %d\n", i->rtm_type);
1306: return;
1307: }
1308:
1309: if (i->rtm_scope != def_scope)
1310: {
1311: ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
1312: ea->next = ra->eattrs;
1313: ra->eattrs = ea;
1314: ea->flags = EALF_SORTED;
1315: ea->count = 1;
1316: ea->attrs[0].id = EA_KRT_SCOPE;
1317: ea->attrs[0].flags = 0;
1318: ea->attrs[0].type = EAF_TYPE_INT;
1319: ea->attrs[0].u.data = i->rtm_scope;
1320: }
1321:
1322: if (a[RTA_PREFSRC])
1323: {
1324: ip_addr ps;
1325: memcpy(&ps, RTA_DATA(a[RTA_PREFSRC]), sizeof(ps));
1326: ipa_ntoh(ps);
1327:
1328: ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
1329: ea->next = ra->eattrs;
1330: ra->eattrs = ea;
1331: ea->flags = EALF_SORTED;
1332: ea->count = 1;
1333: ea->attrs[0].id = EA_KRT_PREFSRC;
1334: ea->attrs[0].flags = 0;
1335: ea->attrs[0].type = EAF_TYPE_IP_ADDRESS;
1336: ea->attrs[0].u.ptr = lp_alloc(s->pool, sizeof(struct adata) + sizeof(ps));
1337: ea->attrs[0].u.ptr->length = sizeof(ps);
1338: memcpy(ea->attrs[0].u.ptr->data, &ps, sizeof(ps));
1339: }
1340:
1341: if (a[RTA_FLOW])
1342: {
1343: ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + sizeof(eattr));
1344: ea->next = ra->eattrs;
1345: ra->eattrs = ea;
1346: ea->flags = EALF_SORTED;
1347: ea->count = 1;
1348: ea->attrs[0].id = EA_KRT_REALM;
1349: ea->attrs[0].flags = 0;
1350: ea->attrs[0].type = EAF_TYPE_INT;
1351: ea->attrs[0].u.data = rta_get_u32(a[RTA_FLOW]);
1352: }
1353:
1354: if (a[RTA_METRICS])
1355: {
1356: u32 metrics[KRT_METRICS_MAX];
1357: ea_list *ea = lp_alloc(s->pool, sizeof(ea_list) + KRT_METRICS_MAX * sizeof(eattr));
1358: int t, n = 0;
1359:
1360: if (nl_parse_metrics(a[RTA_METRICS], metrics, ARRAY_SIZE(metrics)) < 0)
1361: {
1362: log(L_ERR "KRT: Received route %I/%d with strange RTA_METRICS attribute",
1363: net->n.prefix, net->n.pxlen);
1364: return;
1365: }
1366:
1367: for (t = 1; t < KRT_METRICS_MAX; t++)
1368: if (metrics[0] & (1 << t))
1369: {
1370: ea->attrs[n].id = EA_CODE(EAP_KRT, KRT_METRICS_OFFSET + t);
1371: ea->attrs[n].flags = 0;
1372: ea->attrs[n].type = EAF_TYPE_INT; /* FIXME: Some are EAF_TYPE_BITFIELD */
1373: ea->attrs[n].u.data = metrics[t];
1374: n++;
1375: }
1376:
1377: if (n > 0)
1378: {
1379: ea->next = ra->eattrs;
1380: ea->flags = EALF_SORTED;
1381: ea->count = n;
1382: ra->eattrs = ea;
1383: }
1384: }
1385:
1386: /*
1387: * Ideally, now we would send the received route to the rest of kernel code.
1388: * But IPv6 ECMP routes are sent as a sequence of routes, so we postpone it
1389: * and merge next hops until the end of the sequence.
1390: */
1391:
1392: if (!s->net)
1393: {
1394: /* Store the new route */
1395: s->net = net;
1396: s->attrs = ra;
1397: s->proto = p;
1398: s->new = new;
1399: s->krt_src = src;
1400: s->krt_type = i->rtm_type;
1401: s->krt_proto = i->rtm_protocol;
1402: s->krt_metric = priority;
1403: }
1404: else
1405: {
1406: /* Merge next hops with the stored route */
1407: rta *a = s->attrs;
1408:
1409: if (a->dest != RTD_MULTIPATH)
1410: {
1411: a->dest = RTD_MULTIPATH;
1412: a->nexthops = nl_alloc_mpnh(s, a->gw, a->iface, 0);
1413: }
1414:
1415: mpnh_insert(&a->nexthops, nl_alloc_mpnh(s, ra->gw, ra->iface, 0));
1416: }
1417: }
1418:
1419: void
1420: krt_do_scan(struct krt_proto *p UNUSED) /* CONFIG_ALL_TABLES_AT_ONCE => p is NULL */
1421: {
1422: struct nlmsghdr *h;
1423: struct nl_parse_state s;
1424:
1425: nl_parse_begin(&s, 1, krt_ecmp6(p));
1426:
1427: nl_request_dump(BIRD_AF, RTM_GETROUTE);
1428: while (h = nl_get_scan())
1429: if (h->nlmsg_type == RTM_NEWROUTE || h->nlmsg_type == RTM_DELROUTE)
1430: nl_parse_route(&s, h);
1431: else
1432: log(L_DEBUG "nl_scan_fire: Unknown packet received (type=%d)", h->nlmsg_type);
1433:
1434: nl_parse_end(&s);
1435: }
1436:
1437: /*
1438: * Asynchronous Netlink interface
1439: */
1440:
1441: static sock *nl_async_sk; /* BIRD socket for asynchronous notifications */
1442: static byte *nl_async_rx_buffer; /* Receive buffer */
1443:
1444: static void
1445: nl_async_msg(struct nlmsghdr *h)
1446: {
1447: struct nl_parse_state s;
1448:
1449: switch (h->nlmsg_type)
1450: {
1451: case RTM_NEWROUTE:
1452: case RTM_DELROUTE:
1453: DBG("KRT: Received async route notification (%d)\n", h->nlmsg_type);
1454: nl_parse_begin(&s, 0, 0);
1455: nl_parse_route(&s, h);
1456: nl_parse_end(&s);
1457: break;
1458: case RTM_NEWLINK:
1459: case RTM_DELLINK:
1460: DBG("KRT: Received async link notification (%d)\n", h->nlmsg_type);
1461: if (kif_proto)
1462: nl_parse_link(h, 0);
1463: break;
1464: case RTM_NEWADDR:
1465: case RTM_DELADDR:
1466: DBG("KRT: Received async address notification (%d)\n", h->nlmsg_type);
1467: if (kif_proto)
1468: nl_parse_addr(h, 0);
1469: break;
1470: default:
1471: DBG("KRT: Received unknown async notification (%d)\n", h->nlmsg_type);
1472: }
1473: }
1474:
1475: static int
1476: nl_async_hook(sock *sk, uint size UNUSED)
1477: {
1478: struct iovec iov = { nl_async_rx_buffer, NL_RX_SIZE };
1479: struct sockaddr_nl sa;
1480: struct msghdr m = {
1481: .msg_name = &sa,
1482: .msg_namelen = sizeof(sa),
1483: .msg_iov = &iov,
1484: .msg_iovlen = 1,
1485: };
1486: struct nlmsghdr *h;
1487: int x;
1488: uint len;
1489:
1490: x = recvmsg(sk->fd, &m, 0);
1491: if (x < 0)
1492: {
1493: if (errno == ENOBUFS)
1494: {
1495: /*
1496: * Netlink reports some packets have been thrown away.
1497: * One day we might react to it by asking for route table
1498: * scan in near future.
1499: */
1500: log(L_WARN "Kernel dropped some netlink messages, will resync on next scan.");
1501: return 1; /* More data are likely to be ready */
1502: }
1503: else if (errno != EWOULDBLOCK)
1504: log(L_ERR "Netlink recvmsg: %m");
1505: return 0;
1506: }
1507: if (sa.nl_pid) /* It isn't from the kernel */
1508: {
1509: DBG("Non-kernel packet\n");
1510: return 1;
1511: }
1512: h = (void *) nl_async_rx_buffer;
1513: len = x;
1514: if (m.msg_flags & MSG_TRUNC)
1515: {
1516: log(L_WARN "Netlink got truncated asynchronous message");
1517: return 1;
1518: }
1519: while (NLMSG_OK(h, len))
1520: {
1521: nl_async_msg(h);
1522: h = NLMSG_NEXT(h, len);
1523: }
1524: if (len)
1525: log(L_WARN "nl_async_hook: Found packet remnant of size %d", len);
1526: return 1;
1527: }
1528:
1529: static void
1530: nl_async_err_hook(sock *sk, int e UNUSED)
1531: {
1532: nl_async_hook(sk, 0);
1533: }
1534:
1535: static void
1536: nl_open_async(void)
1537: {
1538: sock *sk;
1539: struct sockaddr_nl sa;
1540: int fd;
1541:
1542: if (nl_async_sk)
1543: return;
1544:
1545: DBG("KRT: Opening async netlink socket\n");
1546:
1547: fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
1548: if (fd < 0)
1549: {
1550: log(L_ERR "Unable to open asynchronous rtnetlink socket: %m");
1551: return;
1552: }
1553:
1554: bzero(&sa, sizeof(sa));
1555: sa.nl_family = AF_NETLINK;
1556: #ifdef IPV6
1557: sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE;
1558: #else
1559: sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE;
1560: #endif
1561: if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0)
1562: {
1563: log(L_ERR "Unable to bind asynchronous rtnetlink socket: %m");
1564: close(fd);
1565: return;
1566: }
1567:
1568: nl_async_rx_buffer = xmalloc(NL_RX_SIZE);
1569:
1570: sk = nl_async_sk = sk_new(krt_pool);
1571: sk->type = SK_MAGIC;
1572: sk->rx_hook = nl_async_hook;
1573: sk->err_hook = nl_async_err_hook;
1574: sk->fd = fd;
1575: if (sk_open(sk) < 0)
1576: bug("Netlink: sk_open failed");
1577: }
1578:
1579:
1580: /*
1581: * Interface to the UNIX krt module
1582: */
1583:
1584: void
1585: krt_sys_io_init(void)
1586: {
1587: nl_linpool = lp_new(krt_pool, 4080);
1588: HASH_INIT(nl_table_map, krt_pool, 6);
1589: }
1590:
1591: int
1592: krt_sys_start(struct krt_proto *p)
1593: {
1594: struct krt_proto *old = HASH_FIND(nl_table_map, RTH, krt_table_id(p));
1595:
1596: if (old)
1597: {
1598: log(L_ERR "%s: Kernel table %u already registered by %s",
1599: p->p.name, krt_table_id(p), old->p.name);
1600: return 0;
1601: }
1602:
1603: HASH_INSERT2(nl_table_map, RTH, krt_pool, p);
1604:
1605: nl_open();
1606: nl_open_async();
1607:
1608: return 1;
1609: }
1610:
1611: void
1612: krt_sys_shutdown(struct krt_proto *p)
1613: {
1614: HASH_REMOVE2(nl_table_map, RTH, krt_pool, p);
1615: }
1616:
1617: int
1618: krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt_config *o)
1619: {
1620: return (n->sys.table_id == o->sys.table_id) && (n->sys.metric == o->sys.metric);
1621: }
1622:
1623: void
1624: krt_sys_init_config(struct krt_config *cf)
1625: {
1626: cf->sys.table_id = RT_TABLE_MAIN;
1627: cf->sys.metric = 0;
1628: }
1629:
1630: void
1631: krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
1632: {
1633: d->sys.table_id = s->sys.table_id;
1634: d->sys.metric = s->sys.metric;
1635: }
1636:
1637: static const char *krt_metrics_names[KRT_METRICS_MAX] = {
1638: NULL, "lock", "mtu", "window", "rtt", "rttvar", "sstresh", "cwnd", "advmss",
1639: "reordering", "hoplimit", "initcwnd", "features", "rto_min", "initrwnd", "quickack"
1640: };
1641:
1642: static const char *krt_features_names[KRT_FEATURES_MAX] = {
1643: "ecn", NULL, NULL, "allfrag"
1644: };
1645:
1646: int
1647: krt_sys_get_attr(eattr *a, byte *buf, int buflen UNUSED)
1648: {
1649: switch (a->id)
1650: {
1651: case EA_KRT_PREFSRC:
1652: bsprintf(buf, "prefsrc");
1653: return GA_NAME;
1654:
1655: case EA_KRT_REALM:
1656: bsprintf(buf, "realm");
1657: return GA_NAME;
1658:
1659: case EA_KRT_SCOPE:
1660: bsprintf(buf, "scope");
1661: return GA_NAME;
1662:
1663: case EA_KRT_LOCK:
1664: buf += bsprintf(buf, "lock:");
1665: ea_format_bitfield(a, buf, buflen, krt_metrics_names, 2, KRT_METRICS_MAX);
1666: return GA_FULL;
1667:
1668: case EA_KRT_FEATURES:
1669: buf += bsprintf(buf, "features:");
1670: ea_format_bitfield(a, buf, buflen, krt_features_names, 0, KRT_FEATURES_MAX);
1671: return GA_FULL;
1672:
1673: default:;
1674: int id = (int)EA_ID(a->id) - KRT_METRICS_OFFSET;
1675: if (id > 0 && id < KRT_METRICS_MAX)
1676: {
1677: bsprintf(buf, "%s", krt_metrics_names[id]);
1678: return GA_NAME;
1679: }
1680:
1681: return GA_UNKNOWN;
1682: }
1683: }
1684:
1685:
1686:
1687: void
1688: kif_sys_start(struct kif_proto *p UNUSED)
1689: {
1690: nl_open();
1691: nl_open_async();
1692: }
1693:
1694: void
1695: kif_sys_shutdown(struct kif_proto *p UNUSED)
1696: {
1697: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to 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 / bird / sysdep / linux