Annotation of embedaddon/bird2/sysdep/bsd/krt-sock.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- BSD Routing Table Syncing
3: *
4: * (c) 2004 Ondrej Filip <feela@network.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #include <stdio.h>
10: #include <stdlib.h>
11: #include <ctype.h>
12: #include <fcntl.h>
13: #include <unistd.h>
14: #include <sys/param.h>
15: #include <sys/types.h>
16: #include <sys/socket.h>
17: #include <sys/sysctl.h>
18: #include <sys/ioctl.h>
19: #include <netinet/in.h>
20: #include <net/route.h>
21: #include <net/if.h>
22: #include <net/if_dl.h>
23:
24: #undef LOCAL_DEBUG
25:
26: #include "nest/bird.h"
27: #include "nest/iface.h"
28: #include "nest/route.h"
29: #include "nest/protocol.h"
30: #include "nest/iface.h"
31: #include "sysdep/unix/unix.h"
32: #include "sysdep/unix/krt.h"
33: #include "lib/string.h"
34: #include "lib/socket.h"
35:
36: const int rt_default_ecmp = 0;
37:
38: /*
39: * There are significant differences in multiple tables support between BSD variants.
40: *
41: * OpenBSD has table_id field for routes in route socket protocol, therefore all
42: * tables could be managed by one kernel socket. FreeBSD lacks such field,
43: * therefore multiple sockets (locked to specific table using SO_SETFIB socket
44: * option) must be used.
45: *
46: * Both FreeBSD and OpenBSD uses separate scans for each table. In OpenBSD,
47: * table_id is specified explicitly as sysctl scan argument, while in FreeBSD it
48: * is handled implicitly by changing default table using setfib() syscall.
49: *
50: * KRT_SHARED_SOCKET - use shared kernel socked instead of one for each krt_proto
51: * KRT_USE_SETFIB_SCAN - use setfib() for sysctl() route scan
52: * KRT_USE_SETFIB_SOCK - use SO_SETFIB socket option for kernel sockets
53: * KRT_USE_SYSCTL_7 - use 7-th arg of sysctl() as table id for route scans
54: * KRT_USE_SYSCTL_NET_FIBS - use net.fibs sysctl() for dynamic max number of fibs
55: */
56:
57: #ifdef __FreeBSD__
58: #define KRT_MAX_TABLES 256
59: #define KRT_USE_SETFIB_SCAN
60: #define KRT_USE_SETFIB_SOCK
61: #define KRT_USE_SYSCTL_NET_FIBS
62: #endif
63:
64: #ifdef __OpenBSD__
65: #define KRT_MAX_TABLES (RT_TABLEID_MAX+1)
66: #define KRT_SHARED_SOCKET
67: #define KRT_USE_SYSCTL_7
68: #endif
69:
70: #ifndef KRT_MAX_TABLES
71: #define KRT_MAX_TABLES 1
72: #endif
73:
74:
75: /* Dynamic max number of tables */
76:
77: uint krt_max_tables;
78:
79: #ifdef KRT_USE_SYSCTL_NET_FIBS
80:
81: static uint
82: krt_get_max_tables(void)
83: {
84: int fibs;
85: size_t fibs_len = sizeof(fibs);
86:
87: if (sysctlbyname("net.fibs", &fibs, &fibs_len, NULL, 0) < 0)
88: {
89: log(L_WARN "KRT: unable to get max number of fib tables: %m");
90: return 1;
91: }
92:
93: /* Should not happen */
94: if (fibs < 1)
95: return 1;
96:
97: return (uint) MIN(fibs, KRT_MAX_TABLES);
98: }
99:
100: #else
101:
102: static int
103: krt_get_max_tables(void)
104: {
105: return KRT_MAX_TABLES;
106: }
107:
108: #endif /* KRT_USE_SYSCTL_NET_FIBS */
109:
110:
111: /* setfib() syscall for FreeBSD scans */
112:
113: #ifdef KRT_USE_SETFIB_SCAN
114:
115: /*
116: static int krt_default_fib;
117:
118: static int
119: krt_get_active_fib(void)
120: {
121: int fib;
122: size_t fib_len = sizeof(fib);
123:
124: if (sysctlbyname("net.my_fibnum", &fib, &fib_len, NULL, 0) < 0)
125: {
126: log(L_WARN "KRT: unable to get active fib number: %m");
127: return 0;
128: }
129:
130: return fib;
131: }
132: */
133:
134: extern int setfib(int fib);
135:
136: #endif /* KRT_USE_SETFIB_SCAN */
137:
138:
139: /* table_id -> krt_proto map */
140:
141: #ifdef KRT_SHARED_SOCKET
142: static struct krt_proto *krt_table_map[KRT_MAX_TABLES][2];
143: #endif
144:
145:
146: /* Route socket message processing */
147:
148: int
149: krt_capable(rte *e)
150: {
151: rta *a = e->attrs;
152:
153: return
154: ((a->dest == RTD_UNICAST && !a->nh.next) /* No multipath support */
155: #ifdef RTF_REJECT
156: || a->dest == RTD_UNREACHABLE
157: #endif
158: #ifdef RTF_BLACKHOLE
159: || a->dest == RTD_BLACKHOLE
160: #endif
161: );
162: }
163:
164: #ifndef RTAX_MAX
165: #define RTAX_MAX 8
166: #endif
167:
168: struct ks_msg
169: {
170: struct rt_msghdr rtm;
171: struct sockaddr_storage buf[RTAX_MAX];
172: } PACKED;
173:
174: #define ROUNDUP(a) \
175: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
176:
177: #define NEXTADDR(w, u) \
178: if (msg.rtm.rtm_addrs & (w)) {\
179: l = ROUNDUP(((struct sockaddr *)&(u))->sa_len);\
180: memmove(body, &(u), l); body += l;}
181:
182: #define GETADDR(p, F) \
183: bzero(p, sizeof(*p));\
184: if ((addrs & (F)) && ((struct sockaddr *)body)->sa_len) {\
185: uint l = ROUNDUP(((struct sockaddr *)body)->sa_len);\
186: memcpy(p, body, (l > sizeof(*p) ? sizeof(*p) : l));\
187: body += l;}
188:
189: static inline void
190: sockaddr_fill_dl(struct sockaddr_dl *sa, struct iface *ifa)
191: {
192: uint len = OFFSETOF(struct sockaddr_dl, sdl_data);
193: memset(sa, 0, len);
194: sa->sdl_len = len;
195: sa->sdl_family = AF_LINK;
196: sa->sdl_index = ifa->index;
197: }
198:
199: static int
200: krt_send_route(struct krt_proto *p, int cmd, rte *e)
201: {
202: net *net = e->net;
203: rta *a = e->attrs;
204: static int msg_seq;
205: struct iface *j, *i = a->nh.iface;
206: int l;
207: struct ks_msg msg;
208: char *body = (char *)msg.buf;
209: sockaddr gate, mask, dst;
210:
211: DBG("krt-sock: send %I/%d via %I\n", net->n.prefix, net->n.pxlen, a->gw);
212:
213: bzero(&msg,sizeof (struct rt_msghdr));
214: msg.rtm.rtm_version = RTM_VERSION;
215: msg.rtm.rtm_type = cmd;
216: msg.rtm.rtm_seq = msg_seq++;
217: msg.rtm.rtm_addrs = RTA_DST;
218: msg.rtm.rtm_flags = RTF_UP | RTF_PROTO1;
219:
220: /* XXXX */
221: if (net_pxlen(net->n.addr) == net_max_prefix_length[net->n.addr->type])
222: msg.rtm.rtm_flags |= RTF_HOST;
223: else
224: msg.rtm.rtm_addrs |= RTA_NETMASK;
225:
226: #ifdef KRT_SHARED_SOCKET
227: msg.rtm.rtm_tableid = KRT_CF->sys.table_id;
228: #endif
229:
230: #ifdef RTF_REJECT
231: if(a->dest == RTD_UNREACHABLE)
232: msg.rtm.rtm_flags |= RTF_REJECT;
233: #endif
234: #ifdef RTF_BLACKHOLE
235: if(a->dest == RTD_BLACKHOLE)
236: msg.rtm.rtm_flags |= RTF_BLACKHOLE;
237: #endif
238:
239: /*
240: * This is really very nasty, but I'm not able to add reject/blackhole route
241: * without gateway address.
242: */
243: if (!i)
244: {
245: WALK_LIST(j, iface_list)
246: {
247: if (j->flags & IF_LOOPBACK)
248: {
249: i = j;
250: break;
251: }
252: }
253:
254: if (!i)
255: {
256: log(L_ERR "KRT: Cannot find loopback iface");
257: return -1;
258: }
259: }
260:
261: int af = AF_UNSPEC;
262:
263: switch (net->n.addr->type) {
264: case NET_IP4:
265: af = AF_INET;
266: break;
267: case NET_IP6:
268: af = AF_INET6;
269: break;
270: default:
271: log(L_ERR "KRT: Not sending route %N to kernel", net->n.addr);
272: return -1;
273: }
274:
275: sockaddr_fill(&dst, af, net_prefix(net->n.addr), NULL, 0);
276: sockaddr_fill(&mask, af, net_pxmask(net->n.addr), NULL, 0);
277:
278: switch (a->dest)
279: {
280: case RTD_UNICAST:
281: if (ipa_nonzero(a->nh.gw))
282: {
283: ip_addr gw = a->nh.gw;
284:
285: /* Embed interface ID to link-local address */
286: if (ipa_is_link_local(gw))
287: _I0(gw) = 0xfe800000 | (i->index & 0x0000ffff);
288:
289: sockaddr_fill(&gate, af, gw, NULL, 0);
290: msg.rtm.rtm_flags |= RTF_GATEWAY;
291: msg.rtm.rtm_addrs |= RTA_GATEWAY;
292: break;
293: }
294:
295: #ifdef RTF_REJECT
296: case RTD_UNREACHABLE:
297: #endif
298: #ifdef RTF_BLACKHOLE
299: case RTD_BLACKHOLE:
300: #endif
301: {
302: /* Fallback for all other valid cases */
303:
304: #if __OpenBSD__
305: /* Keeping temporarily old code for OpenBSD */
306: struct ifa *addr = (net->n.addr->type == NET_IP4) ? i->addr4 : (i->addr6 ?: i->llv6);
307:
308: if (!addr)
309: {
310: log(L_ERR "KRT: interface %s has no IP addess", i->name);
311: return -1;
312: }
313:
314: /* Embed interface ID to link-local address */
315: ip_addr gw = addr->ip;
316: if (ipa_is_link_local(gw))
317: _I0(gw) = 0xfe800000 | (i->index & 0x0000ffff);
318:
319: sockaddr_fill(&gate, af, gw, i, 0);
320: #else
321: sockaddr_fill_dl(&gate, i);
322: #endif
323:
324: msg.rtm.rtm_addrs |= RTA_GATEWAY;
325: break;
326: }
327:
328: default:
329: bug("krt-sock: unknown flags, but not filtered");
330: }
331:
332: msg.rtm.rtm_index = i->index;
333:
334: NEXTADDR(RTA_DST, dst);
335: NEXTADDR(RTA_GATEWAY, gate);
336: NEXTADDR(RTA_NETMASK, mask);
337:
338: l = body - (char *)&msg;
339: msg.rtm.rtm_msglen = l;
340:
341: if ((l = write(p->sys.sk->fd, (char *)&msg, l)) < 0) {
342: log(L_ERR "KRT: Error sending route %N to kernel: %m", net->n.addr);
343: return -1;
344: }
345:
346: return 0;
347: }
348:
349: void
350: krt_replace_rte(struct krt_proto *p, net *n, rte *new, rte *old)
351: {
352: int err = 0;
353:
354: if (old)
355: krt_send_route(p, RTM_DELETE, old);
356:
357: if (new)
358: err = krt_send_route(p, RTM_ADD, new);
359:
360: if (err < 0)
361: n->n.flags |= KRF_SYNC_ERROR;
362: else
363: n->n.flags &= ~KRF_SYNC_ERROR;
364: }
365:
366: #define SKIP(ARG...) do { DBG("KRT: Ignoring route - " ARG); return; } while(0)
367:
368: static void
369: krt_read_route(struct ks_msg *msg, struct krt_proto *p, int scan)
370: {
371: /* p is NULL iff KRT_SHARED_SOCKET and !scan */
372:
373: int ipv6;
374: rte *e;
375: net *net;
376: sockaddr dst, gate, mask;
377: ip_addr idst, igate, imask;
378: net_addr ndst;
379: void *body = (char *)msg->buf;
380: int new = (msg->rtm.rtm_type != RTM_DELETE);
381: char *errmsg = "KRT: Invalid route received";
382: int flags = msg->rtm.rtm_flags;
383: int addrs = msg->rtm.rtm_addrs;
384: int src;
385: byte src2;
386:
387: if (!(flags & RTF_UP) && scan)
388: SKIP("not up in scan\n");
389:
390: if (!(flags & RTF_DONE) && !scan)
391: SKIP("not done in async\n");
392:
393: if (flags & RTF_LLINFO)
394: SKIP("link-local\n");
395:
396: GETADDR(&dst, RTA_DST);
397: GETADDR(&gate, RTA_GATEWAY);
398: GETADDR(&mask, RTA_NETMASK);
399:
400: switch (dst.sa.sa_family) {
401: case AF_INET:
402: ipv6 = 0;
403: break;
404: case AF_INET6:
405: ipv6 = 1;
406: break;
407: default:
408: SKIP("invalid DST");
409: }
410:
411: /* We do not test family for RTA_NETMASK, because BSD sends us
412: some strange values, but interpreting them as IPv4/IPv6 works */
413: mask.sa.sa_family = dst.sa.sa_family;
414:
415: idst = ipa_from_sa(&dst);
416: imask = ipa_from_sa(&mask);
417: igate = (gate.sa.sa_family == dst.sa.sa_family) ? ipa_from_sa(&gate) : IPA_NONE;
418:
419: #ifdef KRT_SHARED_SOCKET
420: if (!scan)
421: {
422: int table_id = msg->rtm.rtm_tableid;
423: p = (table_id < KRT_MAX_TABLES) ? krt_table_map[table_id][ipv6] : NULL;
424:
425: if (!p)
426: SKIP("unknown table id %d\n", table_id);
427: }
428: #endif
429: if ((!ipv6) && (p->p.main_channel->table->addr_type != NET_IP4))
430: SKIP("reading only IPv4 routes");
431: if ( ipv6 && (p->p.main_channel->table->addr_type != NET_IP6))
432: SKIP("reading only IPv6 routes");
433:
434: int c = ipa_classify_net(idst);
435: if ((c < 0) || !(c & IADDR_HOST) || ((c & IADDR_SCOPE_MASK) <= SCOPE_LINK))
436: SKIP("strange class/scope\n");
437:
438: int pxlen;
439: if (ipv6)
440: pxlen = (flags & RTF_HOST) ? IP6_MAX_PREFIX_LENGTH : ip6_masklen(&ipa_to_ip6(imask));
441: else
442: pxlen = (flags & RTF_HOST) ? IP4_MAX_PREFIX_LENGTH : ip4_masklen(ipa_to_ip4(imask));
443:
444: if (pxlen < 0)
445: { log(L_ERR "%s (%I) - netmask %I", errmsg, idst, imask); return; }
446:
447: if (ipv6)
448: net_fill_ip6(&ndst, ipa_to_ip6(idst), pxlen);
449: else
450: net_fill_ip4(&ndst, ipa_to_ip4(idst), pxlen);
451:
452: if ((flags & RTF_GATEWAY) && ipa_zero(igate))
453: { log(L_ERR "%s (%N) - missing gateway", errmsg, ndst); return; }
454:
455: u32 self_mask = RTF_PROTO1;
456: u32 alien_mask = RTF_STATIC | RTF_PROTO1 | RTF_GATEWAY;
457:
458: src2 = (flags & RTF_STATIC) ? 1 : 0;
459: src2 |= (flags & RTF_PROTO1) ? 2 : 0;
460:
461: #ifdef RTF_PROTO2
462: alien_mask |= RTF_PROTO2;
463: src2 |= (flags & RTF_PROTO2) ? 4 : 0;
464: #endif
465:
466: #ifdef RTF_PROTO3
467: alien_mask |= RTF_PROTO3;
468: src2 |= (flags & RTF_PROTO3) ? 8 : 0;
469: #endif
470:
471: #ifdef RTF_REJECT
472: alien_mask |= RTF_REJECT;
473: #endif
474:
475: #ifdef RTF_BLACKHOLE
476: alien_mask |= RTF_BLACKHOLE;
477: #endif
478:
479: if (flags & (RTF_DYNAMIC | RTF_MODIFIED))
480: src = KRT_SRC_REDIRECT;
481: else if (flags & self_mask)
482: {
483: if (!scan)
484: SKIP("echo\n");
485: src = KRT_SRC_BIRD;
486: }
487: else if (flags & alien_mask)
488: src = KRT_SRC_ALIEN;
489: else
490: src = KRT_SRC_KERNEL;
491:
492: net = net_get(p->p.main_channel->table, &ndst);
493:
494: rta a = {
495: .src = p->p.main_source,
496: .source = RTS_INHERIT,
497: .scope = SCOPE_UNIVERSE,
498: };
499:
500: /* reject/blackhole routes have also set RTF_GATEWAY,
501: we wil check them first. */
502:
503: #ifdef RTF_REJECT
504: if(flags & RTF_REJECT) {
505: a.dest = RTD_UNREACHABLE;
506: goto done;
507: }
508: #endif
509:
510: #ifdef RTF_BLACKHOLE
511: if(flags & RTF_BLACKHOLE) {
512: a.dest = RTD_BLACKHOLE;
513: goto done;
514: }
515: #endif
516:
517: a.nh.iface = if_find_by_index(msg->rtm.rtm_index);
518: if (!a.nh.iface)
519: {
520: log(L_ERR "KRT: Received route %N with unknown ifindex %u",
521: net->n.addr, msg->rtm.rtm_index);
522: return;
523: }
524:
525: a.dest = RTD_UNICAST;
526: if (flags & RTF_GATEWAY)
527: {
528: neighbor *ng;
529: a.nh.gw = igate;
530:
531: /* Clean up embedded interface ID returned in link-local address */
532: if (ipa_is_link_local(a.nh.gw))
533: _I0(a.nh.gw) = 0xfe800000;
534:
535: ng = neigh_find(&p->p, a.nh.gw, a.nh.iface, 0);
536: if (!ng || (ng->scope == SCOPE_HOST))
537: {
538: /* Ignore routes with next-hop 127.0.0.1, host routes with such
539: next-hop appear on OpenBSD for address aliases. */
540: if (ipa_classify(a.nh.gw) == (IADDR_HOST | SCOPE_HOST))
541: return;
542:
543: log(L_ERR "KRT: Received route %N with strange next-hop %I",
544: net->n.addr, a.nh.gw);
545: return;
546: }
547: }
548:
549: done:
550: e = rte_get_temp(&a);
551: e->net = net;
552: e->u.krt.src = src;
553: e->u.krt.proto = src2;
554: e->u.krt.seen = 0;
555: e->u.krt.best = 0;
556: e->u.krt.metric = 0;
557:
558: if (scan)
559: krt_got_route(p, e);
560: else
561: krt_got_route_async(p, e, new);
562: }
563:
564: static void
565: krt_read_ifannounce(struct ks_msg *msg)
566: {
567: struct if_announcemsghdr *ifam = (struct if_announcemsghdr *)&msg->rtm;
568:
569: if (ifam->ifan_what == IFAN_ARRIVAL)
570: {
571: /* Not enough info to create the iface, so we just trigger iface scan */
572: kif_request_scan();
573: }
574: else if (ifam->ifan_what == IFAN_DEPARTURE)
575: {
576: struct iface *iface = if_find_by_index(ifam->ifan_index);
577:
578: /* Interface is destroyed */
579: if (!iface)
580: {
581: DBG("KRT: unknown interface (%s, #%d) going down. Ignoring\n", ifam->ifan_name, ifam->ifan_index);
582: return;
583: }
584:
585: if_delete(iface);
586: }
587:
588: DBG("KRT: IFANNOUNCE what: %d index %d name %s\n", ifam->ifan_what, ifam->ifan_index, ifam->ifan_name);
589: }
590:
591: static void
592: krt_read_ifinfo(struct ks_msg *msg, int scan)
593: {
594: struct if_msghdr *ifm = (struct if_msghdr *)&msg->rtm;
595: void *body = (void *)(ifm + 1);
596: struct sockaddr_dl *dl = NULL;
597: uint i;
598: struct iface *iface = NULL, f = {};
599: int fl = ifm->ifm_flags;
600: int nlen = 0;
601:
602: for (i = 1; i<=RTA_IFP; i <<= 1)
603: {
604: if (i & ifm->ifm_addrs)
605: {
606: if (i == RTA_IFP)
607: {
608: dl = (struct sockaddr_dl *)body;
609: break;
610: }
611: body += ROUNDUP(((struct sockaddr *)&(body))->sa_len);
612: }
613: }
614:
615: if (dl && (dl->sdl_family != AF_LINK))
616: {
617: log(L_WARN "Ignoring strange IFINFO");
618: return;
619: }
620:
621: if (dl)
622: nlen = MIN(sizeof(f.name)-1, dl->sdl_nlen);
623:
624: /* Note that asynchronous IFINFO messages do not contain iface
625: name, so we have to found an existing iface by iface index */
626:
627: iface = if_find_by_index(ifm->ifm_index);
628: if (!iface)
629: {
630: /* New interface */
631: if (!dl)
632: return; /* No interface name, ignoring */
633:
634: memcpy(f.name, dl->sdl_data, nlen);
635: DBG("New interface '%s' found\n", f.name);
636: }
637: else if (dl && memcmp(iface->name, dl->sdl_data, nlen))
638: {
639: /* Interface renamed */
640: if_delete(iface);
641: memcpy(f.name, dl->sdl_data, nlen);
642: }
643: else
644: {
645: /* Old interface */
646: memcpy(f.name, iface->name, sizeof(f.name));
647: }
648:
649: f.index = ifm->ifm_index;
650: f.mtu = ifm->ifm_data.ifi_mtu;
651:
652: if (fl & IFF_UP)
653: f.flags |= IF_ADMIN_UP;
654: if (ifm->ifm_data.ifi_link_state != LINK_STATE_DOWN)
655: f.flags |= IF_LINK_UP; /* up or unknown */
656: if (fl & IFF_LOOPBACK) /* Loopback */
657: f.flags |= IF_MULTIACCESS | IF_LOOPBACK | IF_IGNORE;
658: else if (fl & IFF_POINTOPOINT) /* PtP */
659: f.flags |= IF_MULTICAST;
660: else if (fl & IFF_BROADCAST) /* Broadcast */
661: f.flags |= IF_MULTIACCESS | IF_BROADCAST | IF_MULTICAST;
662: else
663: f.flags |= IF_MULTIACCESS; /* NBMA */
664:
665: iface = if_update(&f);
666:
667: if (!scan)
668: if_end_partial_update(iface);
669: }
670:
671: static void
672: krt_read_addr(struct ks_msg *msg, int scan)
673: {
674: struct ifa_msghdr *ifam = (struct ifa_msghdr *)&msg->rtm;
675: void *body = (void *)(ifam + 1);
676: sockaddr addr, mask, brd;
677: struct iface *iface = NULL;
678: struct ifa ifa;
679: struct sockaddr null;
680: ip_addr iaddr, imask, ibrd;
681: int addrs = ifam->ifam_addrs;
682: int scope, masklen = -1;
683: int new = (ifam->ifam_type == RTM_NEWADDR);
684:
685: /* Strange messages with zero (invalid) ifindex appear on OpenBSD */
686: if (ifam->ifam_index == 0)
687: return;
688:
689: if(!(iface = if_find_by_index(ifam->ifam_index)))
690: {
691: log(L_ERR "KIF: Received address message for unknown interface %d", ifam->ifam_index);
692: return;
693: }
694:
695: GETADDR (&null, RTA_DST);
696: GETADDR (&null, RTA_GATEWAY);
697: GETADDR (&mask, RTA_NETMASK);
698: GETADDR (&null, RTA_GENMASK);
699: GETADDR (&null, RTA_IFP);
700: GETADDR (&addr, RTA_IFA);
701: GETADDR (&null, RTA_AUTHOR);
702: GETADDR (&brd, RTA_BRD);
703:
704: /* Is addr family IP4 or IP6? */
705: int ipv6;
706: switch (addr.sa.sa_family) {
707: case AF_INET: ipv6 = 0; break;
708: case AF_INET6: ipv6 = 1; break;
709: default: return;
710: }
711:
712: /* We do not test family for RTA_NETMASK, because BSD sends us
713: some strange values, but interpreting them as IPv4/IPv6 works */
714: mask.sa.sa_family = addr.sa.sa_family;
715:
716: iaddr = ipa_from_sa(&addr);
717: imask = ipa_from_sa(&mask);
718: ibrd = ipa_from_sa(&brd);
719:
720: if ((ipv6 ? (masklen = ip6_masklen(&ipa_to_ip6(imask))) : (masklen = ip4_masklen(ipa_to_ip4(imask)))) < 0)
721: {
722: log(L_ERR "KIF: Invalid mask %I for %s", imask, iface->name);
723: return;
724: }
725:
726: /* Clean up embedded interface ID returned in link-local address */
727:
728: if (ipa_is_link_local(iaddr))
729: _I0(iaddr) = 0xfe800000;
730:
731: if (ipa_is_link_local(ibrd))
732: _I0(ibrd) = 0xfe800000;
733:
734:
735: bzero(&ifa, sizeof(ifa));
736: ifa.iface = iface;
737: ifa.ip = iaddr;
738:
739: scope = ipa_classify(ifa.ip);
740: if (scope < 0)
741: {
742: log(L_ERR "KIF: Invalid interface address %I for %s", ifa.ip, iface->name);
743: return;
744: }
745: ifa.scope = scope & IADDR_SCOPE_MASK;
746:
747: if (masklen < (ipv6 ? IP6_MAX_PREFIX_LENGTH : IP4_MAX_PREFIX_LENGTH))
748: {
749: net_fill_ipa(&ifa.prefix, ifa.ip, masklen);
750: net_normalize(&ifa.prefix);
751:
752: if (masklen == ((ipv6 ? IP6_MAX_PREFIX_LENGTH : IP4_MAX_PREFIX_LENGTH) - 1))
753: ifa.opposite = ipa_opposite_m1(ifa.ip);
754:
755: if ((!ipv6) && (masklen == IP4_MAX_PREFIX_LENGTH - 2))
756: ifa.opposite = ipa_opposite_m2(ifa.ip);
757:
758: if (iface->flags & IF_BROADCAST)
759: ifa.brd = ibrd;
760:
761: if (!(iface->flags & IF_MULTIACCESS))
762: ifa.opposite = ibrd;
763: }
764: else if (!(iface->flags & IF_MULTIACCESS) && ipa_nonzero(ibrd))
765: {
766: net_fill_ipa(&ifa.prefix, ibrd, (ipv6 ? IP6_MAX_PREFIX_LENGTH : IP4_MAX_PREFIX_LENGTH));
767: ifa.opposite = ibrd;
768: ifa.flags |= IA_PEER;
769: }
770: else
771: {
772: net_fill_ipa(&ifa.prefix, ifa.ip, (ipv6 ? IP6_MAX_PREFIX_LENGTH : IP4_MAX_PREFIX_LENGTH));
773: ifa.flags |= IA_HOST;
774: }
775:
776: if (new)
777: ifa_update(&ifa);
778: else
779: ifa_delete(&ifa);
780:
781: if (!scan)
782: if_end_partial_update(iface);
783: }
784:
785: static void
786: krt_read_msg(struct proto *p, struct ks_msg *msg, int scan)
787: {
788: /* p is NULL iff KRT_SHARED_SOCKET and !scan */
789:
790: switch (msg->rtm.rtm_type)
791: {
792: case RTM_GET:
793: if(!scan) return;
794: case RTM_ADD:
795: case RTM_DELETE:
796: case RTM_CHANGE:
797: krt_read_route(msg, (struct krt_proto *)p, scan);
798: break;
799: case RTM_IFANNOUNCE:
800: krt_read_ifannounce(msg);
801: break;
802: case RTM_IFINFO:
803: krt_read_ifinfo(msg, scan);
804: break;
805: case RTM_NEWADDR:
806: case RTM_DELADDR:
807: krt_read_addr(msg, scan);
808: break;
809: default:
810: break;
811: }
812: }
813:
814:
815: /* Sysctl based scans */
816:
817: static byte *krt_buffer;
818: static size_t krt_buflen, krt_bufmin;
819: static struct proto *krt_buffer_owner;
820:
821: static byte *
822: krt_buffer_update(struct proto *p, size_t *needed)
823: {
824: size_t req = *needed;
825:
826: if ((req > krt_buflen) ||
827: ((p == krt_buffer_owner) && (req < krt_bufmin)))
828: {
829: /* min buflen is 32 kB, step is 8 kB, or 128 kB if > 1 MB */
830: size_t step = (req < 0x100000) ? 0x2000 : 0x20000;
831: krt_buflen = (req < 0x6000) ? 0x8000 : (req + step);
832: krt_bufmin = (req < 0x8000) ? 0 : (req - 2*step);
833:
834: if (krt_buffer)
835: mb_free(krt_buffer);
836: krt_buffer = mb_alloc(krt_pool, krt_buflen);
837: krt_buffer_owner = p;
838: }
839:
840: *needed = krt_buflen;
841: return krt_buffer;
842: }
843:
844: static void
845: krt_buffer_release(struct proto *p)
846: {
847: if (p == krt_buffer_owner)
848: {
849: mb_free(krt_buffer);
850: krt_buffer = NULL;
851: krt_buflen = 0;
852: krt_buffer_owner = 0;
853: }
854: }
855:
856: static void
857: krt_sysctl_scan(struct proto *p, int cmd, int table_id)
858: {
859: byte *buf, *next;
860: int mib[7], mcnt;
861: size_t needed;
862: struct ks_msg *m;
863: int retries = 3;
864: int rv;
865:
866: mib[0] = CTL_NET;
867: mib[1] = PF_ROUTE;
868: mib[2] = 0;
869: mib[3] = 0; // Set AF to 0 for all available families
870: mib[4] = cmd;
871: mib[5] = 0;
872: mcnt = 6;
873:
874: #ifdef KRT_USE_SYSCTL_7
875: if (table_id >= 0)
876: {
877: mib[6] = table_id;
878: mcnt = 7;
879: }
880: #endif
881:
882: #ifdef KRT_USE_SETFIB_SCAN
883: if (table_id > 0)
884: if (setfib(table_id) < 0)
885: {
886: log(L_ERR "KRT: setfib(%d) failed: %m", table_id);
887: return;
888: }
889: #endif
890:
891: try:
892: rv = sysctl(mib, mcnt, NULL, &needed, NULL, 0);
893: if (rv < 0)
894: {
895: /* OpenBSD returns EINVAL for not yet used tables */
896: if ((errno == EINVAL) && (table_id > 0))
897: goto exit;
898:
899: log(L_ERR "KRT: Route scan estimate failed: %m");
900: goto exit;
901: }
902:
903: /* The table is empty */
904: if (needed == 0)
905: goto exit;
906:
907: buf = krt_buffer_update(p, &needed);
908:
909: rv = sysctl(mib, mcnt, buf, &needed, NULL, 0);
910: if (rv < 0)
911: {
912: /* The buffer size changed since last sysctl ('needed' is not changed) */
913: if ((errno == ENOMEM) && retries--)
914: goto try;
915:
916: log(L_ERR "KRT: Route scan failed: %m");
917: goto exit;
918: }
919:
920: #ifdef KRT_USE_SETFIB_SCAN
921: if (table_id > 0)
922: if (setfib(0) < 0)
923: die("KRT: setfib(%d) failed: %m", 0);
924: #endif
925:
926: /* Process received messages */
927: for (next = buf; next < (buf + needed); next += m->rtm.rtm_msglen)
928: {
929: m = (struct ks_msg *)next;
930: krt_read_msg(p, m, 1);
931: }
932:
933: return;
934:
935: exit:
936: krt_buffer_release(p);
937:
938: #ifdef KRT_USE_SETFIB_SCAN
939: if (table_id > 0)
940: if (setfib(0) < 0)
941: die("KRT: setfib(%d) failed: %m", 0);
942: #endif
943: }
944:
945: void
946: krt_do_scan(struct krt_proto *p)
947: {
948: krt_sysctl_scan(&p->p, NET_RT_DUMP, KRT_CF->sys.table_id);
949: }
950:
951: void
952: kif_do_scan(struct kif_proto *p)
953: {
954: if_start_update();
955: krt_sysctl_scan(&p->p, NET_RT_IFLIST, -1);
956: if_end_update();
957: }
958:
959:
960: /* Kernel sockets */
961:
962: static int
963: krt_sock_hook(sock *sk, uint size UNUSED)
964: {
965: struct ks_msg msg;
966: int l = read(sk->fd, (char *)&msg, sizeof(msg));
967:
968: if (l <= 0)
969: log(L_ERR "krt-sock: read failed");
970: else
971: krt_read_msg((struct proto *) sk->data, &msg, 0);
972:
973: return 0;
974: }
975:
976: static void
977: krt_sock_err_hook(sock *sk, int e UNUSED)
978: {
979: krt_sock_hook(sk, 0);
980: }
981:
982: static sock *
983: krt_sock_open(pool *pool, void *data, int table_id UNUSED)
984: {
985: sock *sk;
986: int fd;
987:
988: fd = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC);
989: if (fd < 0)
990: die("Cannot open kernel socket for routes");
991:
992: #ifdef KRT_USE_SETFIB_SOCK
993: if (table_id > 0)
994: {
995: if (setsockopt(fd, SOL_SOCKET, SO_SETFIB, &table_id, sizeof(table_id)) < 0)
996: die("Cannot set FIB %d for kernel socket: %m", table_id);
997: }
998: #endif
999:
1000: sk = sk_new(pool);
1001: sk->type = SK_MAGIC;
1002: sk->rx_hook = krt_sock_hook;
1003: sk->err_hook = krt_sock_err_hook;
1004: sk->fd = fd;
1005: sk->data = data;
1006:
1007: if (sk_open(sk) < 0)
1008: bug("krt-sock: sk_open failed");
1009:
1010: return sk;
1011: }
1012:
1013: static u32 krt_table_cf[(KRT_MAX_TABLES+31) / 32][2];
1014:
1015: #ifdef KRT_SHARED_SOCKET
1016:
1017: static sock *krt_sock;
1018: static int krt_sock_count;
1019:
1020:
1021: static void
1022: krt_sock_open_shared(void)
1023: {
1024: if (!krt_sock_count)
1025: krt_sock = krt_sock_open(krt_pool, NULL, -1);
1026:
1027: krt_sock_count++;
1028: }
1029:
1030: static void
1031: krt_sock_close_shared(void)
1032: {
1033: krt_sock_count--;
1034:
1035: if (!krt_sock_count)
1036: {
1037: rfree(krt_sock);
1038: krt_sock = NULL;
1039: }
1040: }
1041:
1042: int
1043: krt_sys_start(struct krt_proto *p)
1044: {
1045: int id = KRT_CF->sys.table_id;
1046:
1047: if (krt_table_cf[id/32][!!(p->af == AF_INET6)] & (1 << (id%32)))
1048: {
1049: log(L_ERR "%s: Multiple kernel syncers defined for table #%d", p->p.name, id);
1050: return 0;
1051: }
1052:
1053: krt_table_cf[id/32][!!(p->af == AF_INET6)] |= (1 << (id%32));
1054:
1055: krt_table_map[KRT_CF->sys.table_id][!!(p->af == AF_INET6)] = p;
1056:
1057: krt_sock_open_shared();
1058: p->sys.sk = krt_sock;
1059:
1060: return 1;
1061: }
1062:
1063: void
1064: krt_sys_shutdown(struct krt_proto *p)
1065: {
1066: krt_table_cf[(KRT_CF->sys.table_id)/32][!!(p->af == AF_INET6)] &= ~(1 << ((KRT_CF->sys.table_id)%32));
1067:
1068: krt_sock_close_shared();
1069: p->sys.sk = NULL;
1070:
1071: krt_table_map[KRT_CF->sys.table_id][!!(p->af == AF_INET6)] = NULL;
1072:
1073: krt_buffer_release(&p->p);
1074: }
1075:
1076: #else
1077:
1078: int
1079: krt_sys_start(struct krt_proto *p)
1080: {
1081: int id = KRT_CF->sys.table_id;
1082:
1083: if (krt_table_cf[id/32][!!(p->af == AF_INET6)] & (1 << (id%32)))
1084: {
1085: log(L_ERR "%s: Multiple kernel syncers defined for table #%d", p->p.name, id);
1086: return 0;
1087: }
1088:
1089: krt_table_cf[id/32][!!(p->af == AF_INET6)] |= (1 << (id%32));
1090:
1091: p->sys.sk = krt_sock_open(p->p.pool, p, KRT_CF->sys.table_id);
1092: return 1;
1093: }
1094:
1095: void
1096: krt_sys_shutdown(struct krt_proto *p)
1097: {
1098: krt_table_cf[(KRT_CF->sys.table_id)/32][!!(p->af == AF_INET6)] &= ~(1 << ((KRT_CF->sys.table_id)%32));
1099:
1100: rfree(p->sys.sk);
1101: p->sys.sk = NULL;
1102:
1103: krt_buffer_release(&p->p);
1104: }
1105:
1106: #endif /* KRT_SHARED_SOCKET */
1107:
1108:
1109: /* KRT configuration callbacks */
1110:
1111: int
1112: krt_sys_reconfigure(struct krt_proto *p UNUSED, struct krt_config *n, struct krt_config *o)
1113: {
1114: return n->sys.table_id == o->sys.table_id;
1115: }
1116:
1117: void
1118: krt_sys_preconfig(struct config *c UNUSED)
1119: {
1120: krt_max_tables = krt_get_max_tables();
1121: bzero(&krt_table_cf, sizeof(krt_table_cf));
1122: }
1123:
1124: void krt_sys_init_config(struct krt_config *c)
1125: {
1126: c->sys.table_id = 0; /* Default table */
1127: }
1128:
1129: void krt_sys_copy_config(struct krt_config *d, struct krt_config *s)
1130: {
1131: d->sys.table_id = s->sys.table_id;
1132: }
1133:
1134:
1135: /* KIF misc code */
1136:
1137: void
1138: kif_sys_start(struct kif_proto *p UNUSED)
1139: {
1140: }
1141:
1142: void
1143: kif_sys_shutdown(struct kif_proto *p)
1144: {
1145: krt_buffer_release(&p->p);
1146: }
1147:
1148: int
1149: kif_update_sysdep_addr(struct iface *i)
1150: {
1151: static int fd = -1;
1152:
1153: if (fd < 0)
1154: fd = socket(AF_INET, SOCK_DGRAM, 0);
1155:
1156: struct ifreq ifr;
1157: memset(&ifr, 0, sizeof(ifr));
1158: strncpy(ifr.ifr_name, i->name, IFNAMSIZ);
1159:
1160: int rv = ioctl(fd, SIOCGIFADDR, (char *) &ifr);
1161: if (rv < 0)
1162: return 0;
1163:
1164: ip4_addr old = i->sysdep;
1165: i->sysdep = ipa_to_ip4(ipa_from_sa4(&ifr.ifr_addr));
1166:
1167: return !ip4_equal(i->sysdep, old);
1168: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to krt-sock.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / sysdep / bsd