1: /* dnsmasq is Copyright (c) 2000-2022 Simon Kelley
2:
3: This program is free software; you can redistribute it and/or modify
4: it under the terms of the GNU General Public License as published by
5: the Free Software Foundation; version 2 dated June, 1991, or
6: (at your option) version 3 dated 29 June, 2007.
7:
8: This program is distributed in the hope that it will be useful,
9: but WITHOUT ANY WARRANTY; without even the implied warranty of
10: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11: GNU General Public License for more details.
12:
13: You should have received a copy of the GNU General Public License
14: along with this program. If not, see <http://www.gnu.org/licenses/>.
15: */
16:
17:
18: /* NB. This code may be called during a DHCPv4 or transaction which is in ping-wait
19: It therefore cannot use any DHCP buffer resources except outpacket, which is
20: not used by DHCPv4 code. This code may also be called when DHCP 4 or 6 isn't
21: active, so we ensure that outpacket is allocated here too */
22:
23: #include "dnsmasq.h"
24:
25: #ifdef HAVE_DHCP6
26:
27: #include <netinet/icmp6.h>
28:
29: struct ra_param {
30: time_t now;
31: int ind, managed, other, first, adv_router;
32: char *if_name;
33: struct dhcp_netid *tags;
34: struct in6_addr link_local, link_global, ula;
35: unsigned int glob_pref_time, link_pref_time, ula_pref_time, adv_interval, prio;
36: struct dhcp_context *found_context;
37: };
38:
39: struct search_param {
40: time_t now; int iface;
41: char name[IF_NAMESIZE+1];
42: };
43:
44: struct alias_param {
45: int iface;
46: struct dhcp_bridge *bridge;
47: int num_alias_ifs;
48: int max_alias_ifs;
49: int *alias_ifs;
50: };
51:
52: static void send_ra(time_t now, int iface, char *iface_name, struct in6_addr *dest);
53: static void send_ra_alias(time_t now, int iface, char *iface_name, struct in6_addr *dest,
54: int send_iface);
55: static int send_ra_to_aliases(int index, unsigned int type, char *mac, size_t maclen, void *parm);
56: static int add_prefixes(struct in6_addr *local, int prefix,
57: int scope, int if_index, int flags,
58: unsigned int preferred, unsigned int valid, void *vparam);
59: static int iface_search(struct in6_addr *local, int prefix,
60: int scope, int if_index, int flags,
61: int prefered, int valid, void *vparam);
62: static int add_lla(int index, unsigned int type, char *mac, size_t maclen, void *parm);
63: static void new_timeout(struct dhcp_context *context, char *iface_name, time_t now);
64: static unsigned int calc_lifetime(struct ra_interface *ra);
65: static unsigned int calc_interval(struct ra_interface *ra);
66: static unsigned int calc_prio(struct ra_interface *ra);
67: static struct ra_interface *find_iface_param(char *iface);
68:
69: static int hop_limit;
70:
71: void ra_init(time_t now)
72: {
73: struct icmp6_filter filter;
74: int fd;
75: #if defined(IPV6_TCLASS) && defined(IPTOS_CLASS_CS6)
76: int class = IPTOS_CLASS_CS6;
77: #endif
78: int val = 255; /* radvd uses this value */
79: socklen_t len = sizeof(int);
80: struct dhcp_context *context;
81:
82: /* ensure this is around even if we're not doing DHCPv6 */
83: expand_buf(&daemon->outpacket, sizeof(struct dhcp_packet));
84:
85: /* See if we're guessing SLAAC addresses, if so we need to receive ping replies */
86: for (context = daemon->dhcp6; context; context = context->next)
87: if ((context->flags & CONTEXT_RA_NAME))
88: break;
89:
90: /* Need ICMP6 socket for transmission for DHCPv6 even when not doing RA. */
91:
92: ICMP6_FILTER_SETBLOCKALL(&filter);
93: if (daemon->doing_ra)
94: {
95: ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filter);
96: if (context)
97: ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filter);
98: }
99:
100: if ((fd = socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) == -1 ||
101: getsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &hop_limit, &len) ||
102: #if defined(IPV6_TCLASS) && defined(IPTOS_CLASS_CS6)
103: setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS, &class, sizeof(class)) == -1 ||
104: #endif
105: !fix_fd(fd) ||
106: !set_ipv6pktinfo(fd) ||
107: setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &val, sizeof(val)) ||
108: setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val, sizeof(val)) ||
109: setsockopt(fd, IPPROTO_ICMPV6, ICMP6_FILTER, &filter, sizeof(filter)) == -1)
110: die (_("cannot create ICMPv6 socket: %s"), NULL, EC_BADNET);
111:
112: daemon->icmp6fd = fd;
113:
114: if (daemon->doing_ra)
115: ra_start_unsolicited(now, NULL);
116: }
117:
118: void ra_start_unsolicited(time_t now, struct dhcp_context *context)
119: {
120: /* init timers so that we do ra's for some/all soon. some ra_times will end up zeroed
121: if it's not appropriate to advertise those contexts.
122: This gets re-called on a netlink route-change to re-do the advertisement
123: and pick up new interfaces */
124:
125: if (context)
126: {
127: context->ra_short_period_start = now;
128: /* start after 1 second to get logging right at startup. */
129: context->ra_time = now + 1;
130: }
131: else
132: for (context = daemon->dhcp6; context; context = context->next)
133: if (!(context->flags & CONTEXT_TEMPLATE))
134: {
135: context->ra_time = now + (rand16()/13000); /* range 0 - 5 */
136: /* re-do frequently for a minute or so, in case the first gets lost. */
137: context->ra_short_period_start = now;
138: }
139: }
140:
141: void icmp6_packet(time_t now)
142: {
143: char interface[IF_NAMESIZE+1];
144: ssize_t sz;
145: int if_index = 0;
146: struct cmsghdr *cmptr;
147: struct msghdr msg;
148: union {
149: struct cmsghdr align; /* this ensures alignment */
150: char control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];
151: } control_u;
152: struct sockaddr_in6 from;
153: unsigned char *packet;
154: struct iname *tmp;
155:
156: /* Note: use outpacket for input buffer */
157: msg.msg_control = control_u.control6;
158: msg.msg_controllen = sizeof(control_u);
159: msg.msg_flags = 0;
160: msg.msg_name = &from;
161: msg.msg_namelen = sizeof(from);
162: msg.msg_iov = &daemon->outpacket;
163: msg.msg_iovlen = 1;
164:
165: if ((sz = recv_dhcp_packet(daemon->icmp6fd, &msg)) == -1 || sz < 8)
166: return;
167:
168: packet = (unsigned char *)daemon->outpacket.iov_base;
169:
170: for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
171: if (cmptr->cmsg_level == IPPROTO_IPV6 && cmptr->cmsg_type == daemon->v6pktinfo)
172: {
173: union {
174: unsigned char *c;
175: struct in6_pktinfo *p;
176: } p;
177: p.c = CMSG_DATA(cmptr);
178:
179: if_index = p.p->ipi6_ifindex;
180: }
181:
182: if (!indextoname(daemon->icmp6fd, if_index, interface))
183: return;
184:
185: if (!iface_check(AF_LOCAL, NULL, interface, NULL))
186: return;
187:
188: for (tmp = daemon->dhcp_except; tmp; tmp = tmp->next)
189: if (tmp->name && wildcard_match(tmp->name, interface))
190: return;
191:
192: if (packet[1] != 0)
193: return;
194:
195: if (packet[0] == ICMP6_ECHO_REPLY)
196: lease_ping_reply(&from.sin6_addr, packet, interface);
197: else if (packet[0] == ND_ROUTER_SOLICIT)
198: {
199: char *mac = "";
200: struct dhcp_bridge *bridge, *alias;
201: ssize_t rem;
202: unsigned char *p;
203: int opt_sz;
204:
205: #ifdef HAVE_DUMPFILE
206: dump_packet_icmp(DUMP_RA, (void *)packet, sz, (union mysockaddr *)&from, NULL);
207: #endif
208:
209: /* look for link-layer address option for logging */
210: for (rem = sz - 8, p = &packet[8]; rem >= 2; rem -= opt_sz, p += opt_sz)
211: {
212: opt_sz = p[1] * 8;
213:
214: if (opt_sz == 0 || opt_sz > rem)
215: return; /* Bad packet */
216:
217: if (p[0] == ICMP6_OPT_SOURCE_MAC && ((opt_sz - 2) * 3 - 1 < MAXDNAME))
218: {
219: print_mac(daemon->namebuff, &p[2], opt_sz - 2);
220: mac = daemon->namebuff;
221: }
222: }
223:
224: if (!option_bool(OPT_QUIET_RA))
225: my_syslog(MS_DHCP | LOG_INFO, "RTR-SOLICIT(%s) %s", interface, mac);
226:
227: /* If the incoming interface is an alias of some other one (as
228: specified by the --bridge-interface option), send an RA using
229: the context of the aliased interface. */
230: for (bridge = daemon->bridges; bridge; bridge = bridge->next)
231: {
232: int bridge_index = if_nametoindex(bridge->iface);
233: if (bridge_index)
234: {
235: for (alias = bridge->alias; alias; alias = alias->next)
236: if (wildcard_matchn(alias->iface, interface, IF_NAMESIZE))
237: {
238: /* Send an RA on if_index with information from
239: bridge_index. */
240: send_ra_alias(now, bridge_index, bridge->iface, NULL, if_index);
241: break;
242: }
243: if (alias)
244: break;
245: }
246: }
247:
248: /* If the incoming interface wasn't an alias, send an RA using
249: the context of the incoming interface. */
250: if (!bridge)
251: /* source address may not be valid in solicit request. */
252: send_ra(now, if_index, interface, !IN6_IS_ADDR_UNSPECIFIED(&from.sin6_addr) ? &from.sin6_addr : NULL);
253: }
254: }
255:
256: static void send_ra_alias(time_t now, int iface, char *iface_name, struct in6_addr *dest, int send_iface)
257: {
258: struct ra_packet *ra;
259: struct ra_param parm;
260: struct sockaddr_in6 addr;
261: struct dhcp_context *context, *tmp, **up;
262: struct dhcp_netid iface_id;
263: struct dhcp_opt *opt_cfg;
264: struct ra_interface *ra_param = find_iface_param(iface_name);
265: int done_dns = 0, old_prefix = 0, mtu = 0;
266: unsigned int min_pref_time;
267: #ifdef HAVE_LINUX_NETWORK
268: FILE *f;
269: #endif
270:
271: parm.ind = iface;
272: parm.managed = 0;
273: parm.other = 0;
274: parm.found_context = NULL;
275: parm.adv_router = 0;
276: parm.if_name = iface_name;
277: parm.first = 1;
278: parm.now = now;
279: parm.glob_pref_time = parm.link_pref_time = parm.ula_pref_time = 0;
280: parm.adv_interval = calc_interval(ra_param);
281: parm.prio = calc_prio(ra_param);
282:
283: reset_counter();
284:
285: if (!(ra = expand(sizeof(struct ra_packet))))
286: return;
287:
288: ra->type = ND_ROUTER_ADVERT;
289: ra->code = 0;
290: ra->hop_limit = hop_limit;
291: ra->flags = parm.prio;
292: ra->lifetime = htons(calc_lifetime(ra_param));
293: ra->reachable_time = 0;
294: ra->retrans_time = 0;
295:
296: /* set tag with name == interface */
297: iface_id.net = iface_name;
298: iface_id.next = NULL;
299: parm.tags = &iface_id;
300:
301: for (context = daemon->dhcp6; context; context = context->next)
302: {
303: context->flags &= ~CONTEXT_RA_DONE;
304: context->netid.next = &context->netid;
305: }
306:
307: /* If no link-local address then we can't advertise since source address of
308: advertisement must be link local address: RFC 4861 para 6.1.2. */
309: if (!iface_enumerate(AF_INET6, &parm, add_prefixes) ||
310: parm.link_pref_time == 0)
311: return;
312:
313: /* Find smallest preferred time within address classes,
314: to use as lifetime for options. This is a rather arbitrary choice. */
315: min_pref_time = 0xffffffff;
316: if (parm.glob_pref_time != 0 && parm.glob_pref_time < min_pref_time)
317: min_pref_time = parm.glob_pref_time;
318:
319: if (parm.ula_pref_time != 0 && parm.ula_pref_time < min_pref_time)
320: min_pref_time = parm.ula_pref_time;
321:
322: if (parm.link_pref_time != 0 && parm.link_pref_time < min_pref_time)
323: min_pref_time = parm.link_pref_time;
324:
325: /* Look for constructed contexts associated with addresses which have gone,
326: and advertise them with preferred_time == 0 RFC 6204 4.3 L-13 */
327: for (up = &daemon->dhcp6, context = daemon->dhcp6; context; context = tmp)
328: {
329: tmp = context->next;
330:
331: if (context->if_index == iface && (context->flags & CONTEXT_OLD))
332: {
333: unsigned int old = difftime(now, context->address_lost_time);
334:
335: if (old > context->saved_valid)
336: {
337: /* We've advertised this enough, time to go */
338:
339: /* If this context held the timeout, and there's another context in use
340: transfer the timeout there. */
341: if (context->ra_time != 0 && parm.found_context && parm.found_context->ra_time == 0)
342: new_timeout(parm.found_context, iface_name, now);
343:
344: *up = context->next;
345: free(context);
346: }
347: else
348: {
349: struct prefix_opt *opt;
350: struct in6_addr local = context->start6;
351: int do_slaac = 0;
352:
353: old_prefix = 1;
354:
355: /* zero net part of address */
356: setaddr6part(&local, addr6part(&local) & ~((context->prefix == 64) ? (u64)-1LL : (1LLU << (128 - context->prefix)) - 1LLU));
357:
358:
359: if (context->flags & CONTEXT_RA)
360: {
361: do_slaac = 1;
362: if (context->flags & CONTEXT_DHCP)
363: {
364: parm.other = 1;
365: if (!(context->flags & CONTEXT_RA_STATELESS))
366: parm.managed = 1;
367: }
368: }
369: else
370: {
371: /* don't do RA for non-ra-only unless --enable-ra is set */
372: if (option_bool(OPT_RA))
373: {
374: parm.managed = 1;
375: parm.other = 1;
376: }
377: }
378:
379: if ((opt = expand(sizeof(struct prefix_opt))))
380: {
381: opt->type = ICMP6_OPT_PREFIX;
382: opt->len = 4;
383: opt->prefix_len = context->prefix;
384: /* autonomous only if we're not doing dhcp, set
385: "on-link" unless "off-link" was specified */
386: opt->flags = (do_slaac ? 0x40 : 0) |
387: ((context->flags & CONTEXT_RA_OFF_LINK) ? 0 : 0x80);
388: opt->valid_lifetime = htonl(context->saved_valid - old);
389: opt->preferred_lifetime = htonl(0);
390: opt->reserved = 0;
391: opt->prefix = local;
392:
393: inet_ntop(AF_INET6, &local, daemon->addrbuff, ADDRSTRLEN);
394: if (!option_bool(OPT_QUIET_RA))
395: my_syslog(MS_DHCP | LOG_INFO, "RTR-ADVERT(%s) %s old prefix", iface_name, daemon->addrbuff);
396: }
397:
398: up = &context->next;
399: }
400: }
401: else
402: up = &context->next;
403: }
404:
405: /* If we're advertising only old prefixes, set router lifetime to zero. */
406: if (old_prefix && !parm.found_context)
407: ra->lifetime = htons(0);
408:
409: /* No prefixes to advertise. */
410: if (!old_prefix && !parm.found_context)
411: return;
412:
413: /* If we're sending router address instead of prefix in at least on prefix,
414: include the advertisement interval option. */
415: if (parm.adv_router)
416: {
417: put_opt6_char(ICMP6_OPT_ADV_INTERVAL);
418: put_opt6_char(1);
419: put_opt6_short(0);
420: /* interval value is in milliseconds */
421: put_opt6_long(1000 * calc_interval(find_iface_param(iface_name)));
422: }
423:
424: /* Set the MTU from ra_param if any, an MTU of 0 mean automatic for linux, */
425: /* an MTU of -1 prevents the option from being sent. */
426: if (ra_param)
427: mtu = ra_param->mtu;
428: #ifdef HAVE_LINUX_NETWORK
429: /* Note that IPv6 MTU is not necessarily the same as the IPv4 MTU
430: available from SIOCGIFMTU */
431: if (mtu == 0)
432: {
433: char *mtu_name = ra_param ? ra_param->mtu_name : NULL;
434: sprintf(daemon->namebuff, "/proc/sys/net/ipv6/conf/%s/mtu", mtu_name ? mtu_name : iface_name);
435: if ((f = fopen(daemon->namebuff, "r")))
436: {
437: if (fgets(daemon->namebuff, MAXDNAME, f))
438: mtu = atoi(daemon->namebuff);
439: fclose(f);
440: }
441: }
442: #endif
443: if (mtu > 0)
444: {
445: put_opt6_char(ICMP6_OPT_MTU);
446: put_opt6_char(1);
447: put_opt6_short(0);
448: put_opt6_long(mtu);
449: }
450:
451: iface_enumerate(AF_LOCAL, &send_iface, add_lla);
452:
453: /* RDNSS, RFC 6106, use relevant DHCP6 options */
454: (void)option_filter(parm.tags, NULL, daemon->dhcp_opts6);
455:
456: for (opt_cfg = daemon->dhcp_opts6; opt_cfg; opt_cfg = opt_cfg->next)
457: {
458: int i;
459:
460: /* netids match and not encapsulated? */
461: if (!(opt_cfg->flags & DHOPT_TAGOK))
462: continue;
463:
464: if (opt_cfg->opt == OPTION6_DNS_SERVER)
465: {
466: struct in6_addr *a;
467: int len;
468:
469: done_dns = 1;
470:
471: if (opt_cfg->len == 0)
472: continue;
473:
474: /* reduce len for any addresses we can't substitute */
475: for (a = (struct in6_addr *)opt_cfg->val, len = opt_cfg->len, i = 0;
476: i < opt_cfg->len; i += IN6ADDRSZ, a++)
477: if ((IN6_IS_ADDR_UNSPECIFIED(a) && parm.glob_pref_time == 0) ||
478: (IN6_IS_ADDR_ULA_ZERO(a) && parm.ula_pref_time == 0) ||
479: (IN6_IS_ADDR_LINK_LOCAL_ZERO(a) && parm.link_pref_time == 0))
480: len -= IN6ADDRSZ;
481:
482: if (len != 0)
483: {
484: put_opt6_char(ICMP6_OPT_RDNSS);
485: put_opt6_char((len/8) + 1);
486: put_opt6_short(0);
487: put_opt6_long(min_pref_time);
488:
489: for (a = (struct in6_addr *)opt_cfg->val, i = 0; i < opt_cfg->len; i += IN6ADDRSZ, a++)
490: if (IN6_IS_ADDR_UNSPECIFIED(a))
491: {
492: if (parm.glob_pref_time != 0)
493: put_opt6(&parm.link_global, IN6ADDRSZ);
494: }
495: else if (IN6_IS_ADDR_ULA_ZERO(a))
496: {
497: if (parm.ula_pref_time != 0)
498: put_opt6(&parm.ula, IN6ADDRSZ);
499: }
500: else if (IN6_IS_ADDR_LINK_LOCAL_ZERO(a))
501: {
502: if (parm.link_pref_time != 0)
503: put_opt6(&parm.link_local, IN6ADDRSZ);
504: }
505: else
506: put_opt6(a, IN6ADDRSZ);
507: }
508: }
509:
510: if (opt_cfg->opt == OPTION6_DOMAIN_SEARCH && opt_cfg->len != 0)
511: {
512: int len = ((opt_cfg->len+7)/8);
513:
514: put_opt6_char(ICMP6_OPT_DNSSL);
515: put_opt6_char(len + 1);
516: put_opt6_short(0);
517: put_opt6_long(min_pref_time);
518: put_opt6(opt_cfg->val, opt_cfg->len);
519:
520: /* pad */
521: for (i = opt_cfg->len; i < len * 8; i++)
522: put_opt6_char(0);
523: }
524: }
525:
526: if (daemon->port == NAMESERVER_PORT && !done_dns && parm.link_pref_time != 0)
527: {
528: /* default == us, as long as we are supplying DNS service. */
529: put_opt6_char(ICMP6_OPT_RDNSS);
530: put_opt6_char(3);
531: put_opt6_short(0);
532: put_opt6_long(min_pref_time);
533: put_opt6(&parm.link_local, IN6ADDRSZ);
534: }
535:
536: /* set managed bits unless we're providing only RA on this link */
537: if (parm.managed)
538: ra->flags |= 0x80; /* M flag, managed, */
539: if (parm.other)
540: ra->flags |= 0x40; /* O flag, other */
541:
542: /* decide where we're sending */
543: memset(&addr, 0, sizeof(addr));
544: #ifdef HAVE_SOCKADDR_SA_LEN
545: addr.sin6_len = sizeof(struct sockaddr_in6);
546: #endif
547: addr.sin6_family = AF_INET6;
548: addr.sin6_port = htons(IPPROTO_ICMPV6);
549: if (dest)
550: {
551: addr.sin6_addr = *dest;
552: if (IN6_IS_ADDR_LINKLOCAL(dest) ||
553: IN6_IS_ADDR_MC_LINKLOCAL(dest))
554: addr.sin6_scope_id = iface;
555: }
556: else
557: {
558: inet_pton(AF_INET6, ALL_NODES, &addr.sin6_addr);
559: setsockopt(daemon->icmp6fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, &send_iface, sizeof(send_iface));
560: }
561:
562: #ifdef HAVE_DUMPFILE
563: {
564: struct sockaddr_in6 src;
565: src.sin6_family = AF_INET6;
566: src.sin6_addr = parm.link_local;
567:
568: dump_packet_icmp(DUMP_RA, (void *)daemon->outpacket.iov_base, save_counter(-1), (union mysockaddr *)&src, (union mysockaddr *)&addr);
569: }
570: #endif
571:
572: while (retry_send(sendto(daemon->icmp6fd, daemon->outpacket.iov_base,
573: save_counter(-1), 0, (struct sockaddr *)&addr,
574: sizeof(addr))));
575:
576: }
577:
578: static void send_ra(time_t now, int iface, char *iface_name, struct in6_addr *dest)
579: {
580: /* Send an RA on the same interface that the RA content is based
581: on. */
582: send_ra_alias(now, iface, iface_name, dest, iface);
583: }
584:
585: static int add_prefixes(struct in6_addr *local, int prefix,
586: int scope, int if_index, int flags,
587: unsigned int preferred, unsigned int valid, void *vparam)
588: {
589: struct ra_param *param = vparam;
590:
591: (void)scope; /* warning */
592:
593: if (if_index == param->ind)
594: {
595: if (IN6_IS_ADDR_LINKLOCAL(local))
596: {
597: /* Can there be more than one LL address?
598: Select the one with the longest preferred time
599: if there is. */
600: if (preferred > param->link_pref_time)
601: {
602: param->link_pref_time = preferred;
603: param->link_local = *local;
604: }
605: }
606: else if (!IN6_IS_ADDR_LOOPBACK(local) &&
607: !IN6_IS_ADDR_MULTICAST(local))
608: {
609: int real_prefix = 0;
610: int do_slaac = 0;
611: int deprecate = 0;
612: int constructed = 0;
613: int adv_router = 0;
614: int off_link = 0;
615: unsigned int time = 0xffffffff;
616: struct dhcp_context *context;
617:
618: for (context = daemon->dhcp6; context; context = context->next)
619: if (!(context->flags & (CONTEXT_TEMPLATE | CONTEXT_OLD)) &&
620: prefix <= context->prefix &&
621: is_same_net6(local, &context->start6, context->prefix) &&
622: is_same_net6(local, &context->end6, context->prefix))
623: {
624: context->saved_valid = valid;
625:
626: if (context->flags & CONTEXT_RA)
627: {
628: do_slaac = 1;
629: if (context->flags & CONTEXT_DHCP)
630: {
631: param->other = 1;
632: if (!(context->flags & CONTEXT_RA_STATELESS))
633: param->managed = 1;
634: }
635: }
636: else
637: {
638: /* don't do RA for non-ra-only unless --enable-ra is set */
639: if (!option_bool(OPT_RA))
640: continue;
641: param->managed = 1;
642: param->other = 1;
643: }
644:
645: /* Configured to advertise router address, not prefix. See RFC 3775 7.2
646: In this case we do all addresses associated with a context,
647: hence the real_prefix setting here. */
648: if (context->flags & CONTEXT_RA_ROUTER)
649: {
650: adv_router = 1;
651: param->adv_router = 1;
652: real_prefix = context->prefix;
653: }
654:
655: /* find floor time, don't reduce below 3 * RA interval.
656: If the lease time has been left as default, don't
657: use that as a floor. */
658: if ((context->flags & CONTEXT_SETLEASE) &&
659: time > context->lease_time)
660: {
661: time = context->lease_time;
662: if (time < ((unsigned int)(3 * param->adv_interval)))
663: time = 3 * param->adv_interval;
664: }
665:
666: if (context->flags & CONTEXT_DEPRECATE)
667: deprecate = 1;
668:
669: if (context->flags & CONTEXT_CONSTRUCTED)
670: constructed = 1;
671:
672:
673: /* collect dhcp-range tags */
674: if (context->netid.next == &context->netid && context->netid.net)
675: {
676: context->netid.next = param->tags;
677: param->tags = &context->netid;
678: }
679:
680: /* subsequent prefixes on the same interface
681: and subsequent instances of this prefix don't need timers.
682: Be careful not to find the same prefix twice with different
683: addresses unless we're advertising the actual addresses. */
684: if (!(context->flags & CONTEXT_RA_DONE))
685: {
686: if (!param->first)
687: context->ra_time = 0;
688: context->flags |= CONTEXT_RA_DONE;
689: real_prefix = context->prefix;
690: off_link = (context->flags & CONTEXT_RA_OFF_LINK);
691: }
692:
693: param->first = 0;
694: /* found_context is the _last_ one we found, so if there's
695: more than one, it's not the first. */
696: param->found_context = context;
697: }
698:
699: /* configured time is ceiling */
700: if (!constructed || valid > time)
701: valid = time;
702:
703: if (flags & IFACE_DEPRECATED)
704: preferred = 0;
705:
706: if (deprecate)
707: time = 0;
708:
709: /* configured time is ceiling */
710: if (!constructed || preferred > time)
711: preferred = time;
712:
713: if (IN6_IS_ADDR_ULA(local))
714: {
715: if (preferred > param->ula_pref_time)
716: {
717: param->ula_pref_time = preferred;
718: param->ula = *local;
719: }
720: }
721: else
722: {
723: if (preferred > param->glob_pref_time)
724: {
725: param->glob_pref_time = preferred;
726: param->link_global = *local;
727: }
728: }
729:
730: if (real_prefix != 0)
731: {
732: struct prefix_opt *opt;
733:
734: if ((opt = expand(sizeof(struct prefix_opt))))
735: {
736: /* zero net part of address */
737: if (!adv_router)
738: setaddr6part(local, addr6part(local) & ~((real_prefix == 64) ? (u64)-1LL : (1LLU << (128 - real_prefix)) - 1LLU));
739:
740: opt->type = ICMP6_OPT_PREFIX;
741: opt->len = 4;
742: opt->prefix_len = real_prefix;
743: /* autonomous only if we're not doing dhcp, set
744: "on-link" unless "off-link" was specified */
745: opt->flags = (off_link ? 0 : 0x80);
746: if (do_slaac)
747: opt->flags |= 0x40;
748: if (adv_router)
749: opt->flags |= 0x20;
750: opt->valid_lifetime = htonl(valid);
751: opt->preferred_lifetime = htonl(preferred);
752: opt->reserved = 0;
753: opt->prefix = *local;
754:
755: inet_ntop(AF_INET6, local, daemon->addrbuff, ADDRSTRLEN);
756: if (!option_bool(OPT_QUIET_RA))
757: my_syslog(MS_DHCP | LOG_INFO, "RTR-ADVERT(%s) %s", param->if_name, daemon->addrbuff);
758: }
759: }
760: }
761: }
762: return 1;
763: }
764:
765: static int add_lla(int index, unsigned int type, char *mac, size_t maclen, void *parm)
766: {
767: (void)type;
768:
769: if (index == *((int *)parm))
770: {
771: /* size is in units of 8 octets and includes type and length (2 bytes)
772: add 7 to round up */
773: int len = (maclen + 9) >> 3;
774: unsigned char *p = expand(len << 3);
775: if (!p)
776: return 1;
777: memset(p, 0, len << 3);
778: *p++ = ICMP6_OPT_SOURCE_MAC;
779: *p++ = len;
780: memcpy(p, mac, maclen);
781:
782: return 0;
783: }
784:
785: return 1;
786: }
787:
788: time_t periodic_ra(time_t now)
789: {
790: struct search_param param;
791: struct dhcp_context *context;
792: time_t next_event;
793: struct alias_param aparam;
794:
795: param.now = now;
796: param.iface = 0;
797:
798: while (1)
799: {
800: /* find overdue events, and time of first future event */
801: for (next_event = 0, context = daemon->dhcp6; context; context = context->next)
802: if (context->ra_time != 0)
803: {
804: if (difftime(context->ra_time, now) <= 0.0)
805: break; /* overdue */
806:
807: if (next_event == 0 || difftime(next_event, context->ra_time) > 0.0)
808: next_event = context->ra_time;
809: }
810:
811: /* none overdue */
812: if (!context)
813: break;
814:
815: if ((context->flags & CONTEXT_OLD) &&
816: context->if_index != 0 &&
817: indextoname(daemon->icmp6fd, context->if_index, param.name))
818: {
819: /* A context for an old address. We'll not find the interface by
820: looking for addresses, but we know it anyway, since the context is
821: constructed */
822: param.iface = context->if_index;
823: new_timeout(context, param.name, now);
824: }
825: else if (iface_enumerate(AF_INET6, ¶m, iface_search))
826: /* There's a context overdue, but we can't find an interface
827: associated with it, because it's for a subnet we dont
828: have an interface on. Probably we're doing DHCP on
829: a remote subnet via a relay. Zero the timer, since we won't
830: ever be able to send ra's and satisfy it. */
831: context->ra_time = 0;
832:
833: if (param.iface != 0 &&
834: iface_check(AF_LOCAL, NULL, param.name, NULL))
835: {
836: struct iname *tmp;
837: for (tmp = daemon->dhcp_except; tmp; tmp = tmp->next)
838: if (tmp->name && wildcard_match(tmp->name, param.name))
839: break;
840: if (!tmp)
841: {
842: send_ra(now, param.iface, param.name, NULL);
843:
844: /* Also send on all interfaces that are aliases of this
845: one. */
846: for (aparam.bridge = daemon->bridges;
847: aparam.bridge;
848: aparam.bridge = aparam.bridge->next)
849: if ((int)if_nametoindex(aparam.bridge->iface) == param.iface)
850: {
851: /* Count the number of alias interfaces for this
852: 'bridge', by calling iface_enumerate with
853: send_ra_to_aliases and NULL alias_ifs. */
854: aparam.iface = param.iface;
855: aparam.alias_ifs = NULL;
856: aparam.num_alias_ifs = 0;
857: iface_enumerate(AF_LOCAL, &aparam, send_ra_to_aliases);
858: my_syslog(MS_DHCP | LOG_INFO, "RTR-ADVERT(%s) %s => %d alias(es)",
859: param.name, daemon->addrbuff, aparam.num_alias_ifs);
860:
861: /* Allocate memory to store the alias interface
862: indices. */
863: aparam.alias_ifs = (int *)whine_malloc(aparam.num_alias_ifs *
864: sizeof(int));
865: if (aparam.alias_ifs)
866: {
867: /* Use iface_enumerate again to get the alias
868: interface indices, then send on each of
869: those. */
870: aparam.max_alias_ifs = aparam.num_alias_ifs;
871: aparam.num_alias_ifs = 0;
872: iface_enumerate(AF_LOCAL, &aparam, send_ra_to_aliases);
873: for (; aparam.num_alias_ifs; aparam.num_alias_ifs--)
874: {
875: my_syslog(MS_DHCP | LOG_INFO, "RTR-ADVERT(%s) %s => i/f %d",
876: param.name, daemon->addrbuff,
877: aparam.alias_ifs[aparam.num_alias_ifs - 1]);
878: send_ra_alias(now,
879: param.iface,
880: param.name,
881: NULL,
882: aparam.alias_ifs[aparam.num_alias_ifs - 1]);
883: }
884: free(aparam.alias_ifs);
885: }
886:
887: /* The source interface can only appear in at most
888: one --bridge-interface. */
889: break;
890: }
891: }
892: }
893: }
894: return next_event;
895: }
896:
897: static int send_ra_to_aliases(int index, unsigned int type, char *mac, size_t maclen, void *parm)
898: {
899: struct alias_param *aparam = (struct alias_param *)parm;
900: char ifrn_name[IFNAMSIZ];
901: struct dhcp_bridge *alias;
902:
903: (void)type;
904: (void)mac;
905: (void)maclen;
906:
907: if (if_indextoname(index, ifrn_name))
908: for (alias = aparam->bridge->alias; alias; alias = alias->next)
909: if (wildcard_matchn(alias->iface, ifrn_name, IFNAMSIZ))
910: {
911: if (aparam->alias_ifs && (aparam->num_alias_ifs < aparam->max_alias_ifs))
912: aparam->alias_ifs[aparam->num_alias_ifs] = index;
913: aparam->num_alias_ifs++;
914: }
915:
916: return 1;
917: }
918:
919: static int iface_search(struct in6_addr *local, int prefix,
920: int scope, int if_index, int flags,
921: int preferred, int valid, void *vparam)
922: {
923: struct search_param *param = vparam;
924: struct dhcp_context *context;
925: struct iname *tmp;
926:
927: (void)scope;
928: (void)preferred;
929: (void)valid;
930:
931: /* ignore interfaces we're not doing DHCP on. */
932: if (!indextoname(daemon->icmp6fd, if_index, param->name) ||
933: !iface_check(AF_LOCAL, NULL, param->name, NULL))
934: return 1;
935:
936: for (tmp = daemon->dhcp_except; tmp; tmp = tmp->next)
937: if (tmp->name && wildcard_match(tmp->name, param->name))
938: return 1;
939:
940: for (context = daemon->dhcp6; context; context = context->next)
941: if (!(context->flags & (CONTEXT_TEMPLATE | CONTEXT_OLD)) &&
942: prefix <= context->prefix &&
943: is_same_net6(local, &context->start6, context->prefix) &&
944: is_same_net6(local, &context->end6, context->prefix) &&
945: context->ra_time != 0 &&
946: difftime(context->ra_time, param->now) <= 0.0)
947: {
948: /* found an interface that's overdue for RA determine new
949: timeout value and arrange for RA to be sent unless interface is
950: still doing DAD.*/
951: if (!(flags & IFACE_TENTATIVE))
952: param->iface = if_index;
953:
954: new_timeout(context, param->name, param->now);
955:
956: /* zero timers for other contexts on the same subnet, so they don't timeout
957: independently */
958: for (context = context->next; context; context = context->next)
959: if (prefix <= context->prefix &&
960: is_same_net6(local, &context->start6, context->prefix) &&
961: is_same_net6(local, &context->end6, context->prefix))
962: context->ra_time = 0;
963:
964: return 0; /* found, abort */
965: }
966:
967: return 1; /* keep searching */
968: }
969:
970: static void new_timeout(struct dhcp_context *context, char *iface_name, time_t now)
971: {
972: if (difftime(now, context->ra_short_period_start) < 60.0)
973: /* range 5 - 20 */
974: context->ra_time = now + 5 + (rand16()/4400);
975: else
976: {
977: /* range 3/4 - 1 times MaxRtrAdvInterval */
978: unsigned int adv_interval = calc_interval(find_iface_param(iface_name));
979: context->ra_time = now + (3 * adv_interval)/4 + ((adv_interval * (unsigned int)rand16()) >> 18);
980: }
981: }
982:
983: static struct ra_interface *find_iface_param(char *iface)
984: {
985: struct ra_interface *ra;
986:
987: for (ra = daemon->ra_interfaces; ra; ra = ra->next)
988: if (wildcard_match(ra->name, iface))
989: return ra;
990:
991: return NULL;
992: }
993:
994: static unsigned int calc_interval(struct ra_interface *ra)
995: {
996: int interval = 600;
997:
998: if (ra && ra->interval != 0)
999: {
1000: interval = ra->interval;
1001: if (interval > 1800)
1002: interval = 1800;
1003: else if (interval < 4)
1004: interval = 4;
1005: }
1006:
1007: return (unsigned int)interval;
1008: }
1009:
1010: static unsigned int calc_lifetime(struct ra_interface *ra)
1011: {
1012: int lifetime, interval = (int)calc_interval(ra);
1013:
1014: if (!ra || ra->lifetime == -1) /* not specified */
1015: lifetime = 3 * interval;
1016: else
1017: {
1018: lifetime = ra->lifetime;
1019: if (lifetime < interval && lifetime != 0)
1020: lifetime = interval;
1021: else if (lifetime > 9000)
1022: lifetime = 9000;
1023: }
1024:
1025: return (unsigned int)lifetime;
1026: }
1027:
1028: static unsigned int calc_prio(struct ra_interface *ra)
1029: {
1030: if (ra)
1031: return ra->prio;
1032:
1033: return 0;
1034: }
1035:
1036: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to radv.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src