?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add et(4).
[dragonfly.git] / sbin / routed / rdisc.c
blobc9209be12eaf17c6cf463e26f69d8e7d488f739f
1 /*
2 * Copyright (c) 1995
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgment:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * $FreeBSD: src/sbin/routed/rdisc.c,v 1.5.2.1 2000/08/14 17:00:04 sheldonh Exp $
34 * $DragonFly: src/sbin/routed/rdisc.c,v 1.4 2005/03/16 21:21:34 cpressey Exp $
35 */
36
37 #include "defs.h"
38 #include <netinet/in_systm.h>
39 #include <netinet/ip.h>
40 #include <netinet/ip_icmp.h>
41
42 #if !defined(sgi) && !defined(__NetBSD__)
43 static char sccsid[] __attribute__((unused)) = "@(#)rdisc.c 8.1 (Berkeley) x/y/95";
44 #elif defined(__NetBSD__)
45 __RCSID("$NetBSD$");
46 #endif
47 #ident "$FreeBSD: src/sbin/routed/rdisc.c,v 1.5.2.1 2000/08/14 17:00:04 sheldonh Exp $"
48
49 /* router advertisement ICMP packet */
50 struct icmp_ad {
51 u_int8_t icmp_type; /* type of message */
52 u_int8_t icmp_code; /* type sub code */
53 u_int16_t icmp_cksum; /* ones complement cksum of struct */
54 u_int8_t icmp_ad_num; /* # of following router addresses */
55 u_int8_t icmp_ad_asize; /* 2--words in each advertisement */
56 u_int16_t icmp_ad_life; /* seconds of validity */
57 struct icmp_ad_info {
58 n_long icmp_ad_addr;
59 n_long icmp_ad_pref;
60 } icmp_ad_info[1];
61 };
62
63 /* router solicitation ICMP packet */
64 struct icmp_so {
65 u_int8_t icmp_type; /* type of message */
66 u_int8_t icmp_code; /* type sub code */
67 u_int16_t icmp_cksum; /* ones complement cksum of struct */
68 n_long icmp_so_rsvd;
69 };
70
71 union ad_u {
72 struct icmp icmp;
73 struct icmp_ad ad;
74 struct icmp_so so;
75 };
76
77
78 int rdisc_sock = -1; /* router-discovery raw socket */
79 struct interface *rdisc_sock_mcast; /* current multicast interface */
80
81 struct timeval rdisc_timer;
82 int rdisc_ok; /* using solicited route */
83
84
85 #define MAX_ADS 16 /* at least one per interface */
86 struct dr { /* accumulated advertisements */
87 struct interface *dr_ifp;
88 naddr dr_gate; /* gateway */
89 time_t dr_ts; /* when received */
90 time_t dr_life; /* lifetime in host byte order */
91 n_long dr_recv_pref; /* received but biased preference */
92 n_long dr_pref; /* preference adjusted by metric */
93 } *cur_drp, drs[MAX_ADS];
94
95 /* convert between signed, balanced around zero,
96 * and unsigned zero-based preferences */
97 #define SIGN_PREF(p) ((p) ^ MIN_PreferenceLevel)
98 #define UNSIGN_PREF(p) SIGN_PREF(p)
99 /* adjust unsigned preference by interface metric,
100 * without driving it to infinity */
101 #define PREF(p, ifp) ((int)(p) <= (ifp)->int_metric ? ((p) != 0 ? 1 : 0) \
102 : (p) - ((ifp)->int_metric))
103
104 static void rdisc_sort(void);
105
106
107 /* dump an ICMP Router Discovery Advertisement Message
108 */
109 static void
110 trace_rdisc(const char *act,
111 naddr from,
112 naddr to,
113 struct interface *ifp,
114 union ad_u *p,
115 u_int len)
116 {
117 int i;
118 n_long *wp, *lim;
119
120
121 if (!TRACEPACKETS || ftrace == 0)
122 return;
123
124 lastlog();
125
126 if (p->icmp.icmp_type == ICMP_ROUTERADVERT) {
127 fprintf(ftrace, "%s Router Ad"
128 " from %s to %s via %s life=%d\n",
129 act, naddr_ntoa(from), naddr_ntoa(to),
130 ifp ? ifp->int_name : "?",
131 ntohs(p->ad.icmp_ad_life));
132 if (!TRACECONTENTS)
133 return;
134
135 wp = &p->ad.icmp_ad_info[0].icmp_ad_addr;
136 lim = &wp[(len - sizeof(p->ad)) / sizeof(*wp)];
137 for (i = 0; i < p->ad.icmp_ad_num && wp <= lim; i++) {
138 fprintf(ftrace, "\t%s preference=%d",
139 naddr_ntoa(wp[0]), (int)ntohl(wp[1]));
140 wp += p->ad.icmp_ad_asize;
141 }
142 fputc('\n',ftrace);
143
144 } else {
145 trace_act("%s Router Solic. from %s to %s via %s value=%#x",
146 act, naddr_ntoa(from), naddr_ntoa(to),
147 ifp ? ifp->int_name : "?",
148 (int)ntohl(p->so.icmp_so_rsvd));
149 }
150 }
151
152 /* prepare Router Discovery socket.
153 */
154 static void
155 get_rdisc_sock(void)
156 {
157 if (rdisc_sock < 0) {
158 rdisc_sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
159 if (rdisc_sock < 0)
160 BADERR(1,"rdisc_sock = socket()");
161 fix_sock(rdisc_sock,"rdisc_sock");
162 fix_select();
163 }
164 }
165
166
167 /* Pick multicast group for router-discovery socket
168 */
169 void
170 set_rdisc_mg(struct interface *ifp,
171 int on) /* 0=turn it off */
172 {
173 struct ip_mreq m;
174
175 if (rdisc_sock < 0) {
176 /* Create the raw socket so that we can hear at least
177 * broadcast router discovery packets.
178 */
179 if ((ifp->int_state & IS_NO_RDISC) == IS_NO_RDISC
180 || !on)
181 return;
182 get_rdisc_sock();
183 }
184
185 if (!(ifp->int_if_flags & IFF_MULTICAST)) {
186 ifp->int_state &= ~(IS_ALL_HOSTS | IS_ALL_ROUTERS);
187 return;
188 }
189
190 #ifdef MCAST_PPP_BUG
191 if (ifp->int_if_flags & IFF_POINTOPOINT)
192 return;
193 #endif
194 memset(&m, 0, sizeof(m));
195 m.imr_interface.s_addr = ((ifp->int_if_flags & IFF_POINTOPOINT)
196 ? ifp->int_dstaddr
197 : ifp->int_addr);
198 if (supplier
199 || (ifp->int_state & IS_NO_ADV_IN)
200 || !on) {
201 /* stop listening to advertisements
202 */
203 if (ifp->int_state & IS_ALL_HOSTS) {
204 m.imr_multiaddr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
205 if (setsockopt(rdisc_sock, IPPROTO_IP,
206 IP_DROP_MEMBERSHIP,
207 &m, sizeof(m)) < 0)
208 LOGERR("IP_DROP_MEMBERSHIP ALLHOSTS");
209 ifp->int_state &= ~IS_ALL_HOSTS;
210 }
211
212 } else if (!(ifp->int_state & IS_ALL_HOSTS)) {
213 /* start listening to advertisements
214 */
215 m.imr_multiaddr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
216 if (setsockopt(rdisc_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
217 &m, sizeof(m)) < 0) {
218 LOGERR("IP_ADD_MEMBERSHIP ALLHOSTS");
219 } else {
220 ifp->int_state |= IS_ALL_HOSTS;
221 }
222 }
223
224 if (!supplier
225 || (ifp->int_state & IS_NO_ADV_OUT)
226 || !on) {
227 /* stop listening to solicitations
228 */
229 if (ifp->int_state & IS_ALL_ROUTERS) {
230 m.imr_multiaddr.s_addr=htonl(INADDR_ALLROUTERS_GROUP);
231 if (setsockopt(rdisc_sock, IPPROTO_IP,
232 IP_DROP_MEMBERSHIP,
233 &m, sizeof(m)) < 0)
234 LOGERR("IP_DROP_MEMBERSHIP ALLROUTERS");
235 ifp->int_state &= ~IS_ALL_ROUTERS;
236 }
237
238 } else if (!(ifp->int_state & IS_ALL_ROUTERS)) {
239 /* start hearing solicitations
240 */
241 m.imr_multiaddr.s_addr=htonl(INADDR_ALLROUTERS_GROUP);
242 if (setsockopt(rdisc_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
243 &m, sizeof(m)) < 0) {
244 LOGERR("IP_ADD_MEMBERSHIP ALLROUTERS");
245 } else {
246 ifp->int_state |= IS_ALL_ROUTERS;
247 }
248 }
249 }
250
251
252 /* start supplying routes
253 */
254 void
255 set_supplier(void)
256 {
257 struct interface *ifp;
258 struct dr *drp;
259
260 if (supplier_set)
261 return;
262
263 trace_act("start supplying routes");
264
265 /* Forget discovered routes.
266 */
267 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
268 drp->dr_recv_pref = 0;
269 drp->dr_life = 0;
270 }
271 rdisc_age(0);
272
273 supplier_set = 1;
274 supplier = 1;
275
276 /* Do not start advertising until we have heard some RIP routes */
277 LIM_SEC(rdisc_timer, now.tv_sec+MIN_WAITTIME);
278
279 /* Switch router discovery multicast groups from soliciting
280 * to advertising.
281 */
282 for (ifp = ifnet; ifp; ifp = ifp->int_next) {
283 if (ifp->int_state & IS_BROKE)
284 continue;
285 ifp->int_rdisc_cnt = 0;
286 ifp->int_rdisc_timer.tv_usec = rdisc_timer.tv_usec;
287 ifp->int_rdisc_timer.tv_sec = now.tv_sec+MIN_WAITTIME;
288 set_rdisc_mg(ifp, 1);
289 }
290
291 /* get rid of any redirects */
292 del_redirects(0,0);
293 }
294
295
296 /* age discovered routes and find the best one
297 */
298 void
299 rdisc_age(naddr bad_gate)
300 {
301 time_t sec;
302 struct dr *drp;
303
304
305 /* If only advertising, then do only that. */
306 if (supplier) {
307 /* If switching from client to server, get rid of old
308 * default routes.
309 */
310 if (cur_drp != 0)
311 rdisc_sort();
312 rdisc_adv();
313 return;
314 }
315
316 /* If we are being told about a bad router,
317 * then age the discovered default route, and if there is
318 * no alternative, solicit a replacement.
319 */
320 if (bad_gate != 0) {
321 /* Look for the bad discovered default route.
322 * Age it and note its interface.
323 */
324 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
325 if (drp->dr_ts == 0)
326 continue;
327
328 /* When we find the bad router, then age the route
329 * to at most SUPPLY_INTERVAL.
330 * This is contrary to RFC 1256, but defends against
331 * black holes.
332 */
333 if (drp->dr_gate == bad_gate) {
334 sec = (now.tv_sec - drp->dr_life
335 + SUPPLY_INTERVAL);
336 if (drp->dr_ts > sec) {
337 trace_act("age 0.0.0.0 --> %s via %s",
338 naddr_ntoa(drp->dr_gate),
339 drp->dr_ifp->int_name);
340 drp->dr_ts = sec;
341 }
342 break;
343 }
344 }
345 }
346
347 rdisc_sol();
348 rdisc_sort();
349
350 /* Delete old redirected routes to keep the kernel table small,
351 * and to prevent black holes. Check that the kernel table
352 * matches the daemon table (i.e. has the default route).
353 * But only if RIP is not running and we are not dealing with
354 * a bad gateway, since otherwise age() will be called.
355 */
356 if (rip_sock < 0 && bad_gate == 0)
357 age(0);
358 }
359
360
361 /* Zap all routes discovered via an interface that has gone bad
362 * This should only be called when !(ifp->int_state & IS_ALIAS)
363 */
364 void
365 if_bad_rdisc(struct interface *ifp)
366 {
367 struct dr *drp;
368
369 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
370 if (drp->dr_ifp != ifp)
371 continue;
372 drp->dr_recv_pref = 0;
373 drp->dr_ts = 0;
374 drp->dr_life = 0;
375 }
376
377 /* make a note to re-solicit, turn RIP on or off, etc. */
378 rdisc_timer.tv_sec = 0;
379 }
380
381
382 /* mark an interface ok for router discovering.
383 */
384 void
385 if_ok_rdisc(struct interface *ifp)
386 {
387 set_rdisc_mg(ifp, 1);
388
389 ifp->int_rdisc_cnt = 0;
390 ifp->int_rdisc_timer.tv_sec = now.tv_sec + (supplier
391 ? MIN_WAITTIME
392 : MAX_SOLICITATION_DELAY);
393 if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
394 rdisc_timer = ifp->int_rdisc_timer;
395 }
396
397
398 /* get rid of a dead discovered router
399 */
400 static void
401 del_rdisc(struct dr *drp)
402 {
403 struct interface *ifp;
404 naddr gate;
405 int i;
406
407
408 del_redirects(gate = drp->dr_gate, 0);
409 drp->dr_ts = 0;
410 drp->dr_life = 0;
411
412
413 /* Count the other discovered routes on the interface.
414 */
415 i = 0;
416 ifp = drp->dr_ifp;
417 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
418 if (drp->dr_ts != 0
419 && drp->dr_ifp == ifp)
420 i++;
421 }
422
423 /* If that was the last good discovered router on the interface,
424 * then solicit a new one.
425 * This is contrary to RFC 1256, but defends against black holes.
426 */
427 if (i != 0) {
428 trace_act("discovered router %s via %s"
429 " is bad--have %d remaining",
430 naddr_ntoa(gate), ifp->int_name, i);
431 } else if (ifp->int_rdisc_cnt >= MAX_SOLICITATIONS) {
432 trace_act("last discovered router %s via %s"
433 " is bad--re-solicit",
434 naddr_ntoa(gate), ifp->int_name);
435 ifp->int_rdisc_cnt = 0;
436 ifp->int_rdisc_timer.tv_sec = 0;
437 rdisc_sol();
438 } else {
439 trace_act("last discovered router %s via %s"
440 " is bad--wait to solicit",
441 naddr_ntoa(gate), ifp->int_name);
442 }
443 }
444
445
446 /* Find the best discovered route,
447 * and discard stale routers.
448 */
449 static void
450 rdisc_sort(void)
451 {
452 struct dr *drp, *new_drp;
453 struct rt_entry *rt;
454 struct rt_spare new;
455 struct interface *ifp;
456 u_int new_st = 0;
457 n_long new_pref = 0;
458
459
460 /* Find the best discovered route.
461 */
462 new_drp = 0;
463 for (drp = drs; drp < &drs[MAX_ADS]; drp++) {
464 if (drp->dr_ts == 0)
465 continue;
466 ifp = drp->dr_ifp;
467
468 /* Get rid of expired discovered routers.
469 */
470 if (drp->dr_ts + drp->dr_life <= now.tv_sec) {
471 del_rdisc(drp);
472 continue;
473 }
474
475 LIM_SEC(rdisc_timer, drp->dr_ts+drp->dr_life+1);
476
477 /* Update preference with possibly changed interface
478 * metric.
479 */
480 drp->dr_pref = PREF(drp->dr_recv_pref, ifp);
481
482 /* Prefer the current route to prevent thrashing.
483 * Prefer shorter lifetimes to speed the detection of
484 * bad routers.
485 * Avoid sick interfaces.
486 */
487 if (new_drp == 0
488 || (!((new_st ^ drp->dr_ifp->int_state) & IS_SICK)
489 && (new_pref < drp->dr_pref
490 || (new_pref == drp->dr_pref
491 && (drp == cur_drp
492 || (new_drp != cur_drp
493 && new_drp->dr_life > drp->dr_life)))))
494 || ((new_st & IS_SICK)
495 && !(drp->dr_ifp->int_state & IS_SICK))) {
496 new_drp = drp;
497 new_st = drp->dr_ifp->int_state;
498 new_pref = drp->dr_pref;
499 }
500 }
501
502 /* switch to a better default route
503 */
504 if (new_drp != cur_drp) {
505 rt = rtget(RIP_DEFAULT, 0);
506
507 /* Stop using discovered routes if they are all bad
508 */
509 if (new_drp == 0) {
510 trace_act("turn off Router Discovery client");
511 rdisc_ok = 0;
512
513 if (rt != 0
514 && (rt->rt_state & RS_RDISC)) {
515 new = rt->rt_spares[0];
516 new.rts_metric = HOPCNT_INFINITY;
517 new.rts_time = now.tv_sec - GARBAGE_TIME;
518 rtchange(rt, rt->rt_state & ~RS_RDISC,
519 &new, 0);
520 rtswitch(rt, 0);
521 }
522
523 } else {
524 if (cur_drp == 0) {
525 trace_act("turn on Router Discovery client"
526 " using %s via %s",
527 naddr_ntoa(new_drp->dr_gate),
528 new_drp->dr_ifp->int_name);
529 rdisc_ok = 1;
530
531 } else {
532 trace_act("switch Router Discovery from"
533 " %s via %s to %s via %s",
534 naddr_ntoa(cur_drp->dr_gate),
535 cur_drp->dr_ifp->int_name,
536 naddr_ntoa(new_drp->dr_gate),
537 new_drp->dr_ifp->int_name);
538 }
539
540 memset(&new, 0, sizeof(new));
541 new.rts_ifp = new_drp->dr_ifp;
542 new.rts_gate = new_drp->dr_gate;
543 new.rts_router = new_drp->dr_gate;
544 new.rts_metric = HOPCNT_INFINITY-1;
545 new.rts_time = now.tv_sec;
546 if (rt != 0) {
547 rtchange(rt, rt->rt_state | RS_RDISC, &new, 0);
548 } else {
549 rtadd(RIP_DEFAULT, 0, RS_RDISC, &new);
550 }
551 }
552
553 cur_drp = new_drp;
554 }
555
556 /* turn RIP on or off */
557 if (!rdisc_ok || rip_interfaces > 1) {
558 rip_on(0);
559 } else {
560 rip_off();
561 }
562 }
563
564
565 /* handle a single address in an advertisement
566 */
567 static void
568 parse_ad(naddr from,
569 naddr gate,
570 n_long pref, /* signed and in network order */
571 u_short life, /* in host byte order */
572 struct interface *ifp)
573 {
574 static struct msg_limit bad_gate;
575 struct dr *drp, *new_drp;
576
577
578 if (gate == RIP_DEFAULT
579 || !check_dst(gate)) {
580 msglim(&bad_gate, from,"router %s advertising bad gateway %s",
581 naddr_ntoa(from),
582 naddr_ntoa(gate));
583 return;
584 }
585
586 /* ignore pointers to ourself and routes via unreachable networks
587 */
588 if (ifwithaddr(gate, 1, 0) != 0) {
589 trace_pkt(" discard Router Discovery Ad pointing at us");
590 return;
591 }
592 if (!on_net(gate, ifp->int_net, ifp->int_mask)) {
593 trace_pkt(" discard Router Discovery Ad"
594 " toward unreachable net");
595 return;
596 }
597
598 /* Convert preference to an unsigned value
599 * and later bias it by the metric of the interface.
600 */
601 pref = UNSIGN_PREF(ntohl(pref));
602
603 if (pref == 0 || life < MinMaxAdvertiseInterval) {
604 pref = 0;
605 life = 0;
606 }
607
608 for (new_drp = 0, drp = drs; drp < &drs[MAX_ADS]; drp++) {
609 /* accept new info for a familiar entry
610 */
611 if (drp->dr_gate == gate) {
612 new_drp = drp;
613 break;
614 }
615
616 if (life == 0)
617 continue; /* do not worry about dead ads */
618
619 if (drp->dr_ts == 0) {
620 new_drp = drp; /* use unused entry */
621
622 } else if (new_drp == 0) {
623 /* look for an entry worse than the new one to
624 * reuse.
625 */
626 if ((!(ifp->int_state & IS_SICK)
627 && (drp->dr_ifp->int_state & IS_SICK))
628 || (pref > drp->dr_pref
629 && !((ifp->int_state ^ drp->dr_ifp->int_state)
630 & IS_SICK)))
631 new_drp = drp;
632
633 } else if (new_drp->dr_ts != 0) {
634 /* look for the least valuable entry to reuse
635 */
636 if ((!(new_drp->dr_ifp->int_state & IS_SICK)
637 && (drp->dr_ifp->int_state & IS_SICK))
638 || (new_drp->dr_pref > drp->dr_pref
639 && !((new_drp->dr_ifp->int_state
640 ^ drp->dr_ifp->int_state)
641 & IS_SICK)))
642 new_drp = drp;
643 }
644 }
645
646 /* forget it if all of the current entries are better */
647 if (new_drp == 0)
648 return;
649
650 new_drp->dr_ifp = ifp;
651 new_drp->dr_gate = gate;
652 new_drp->dr_ts = now.tv_sec;
653 new_drp->dr_life = life;
654 new_drp->dr_recv_pref = pref;
655 /* bias functional preference by metric of the interface */
656 new_drp->dr_pref = PREF(pref,ifp);
657
658 /* after hearing a good advertisement, stop asking
659 */
660 if (!(ifp->int_state & IS_SICK))
661 ifp->int_rdisc_cnt = MAX_SOLICITATIONS;
662 }
663
664
665 /* Compute the IP checksum
666 * This assumes the packet is less than 32K long.
667 */
668 static u_short
669 in_cksum(u_short *p,
670 u_int len)
671 {
672 u_int sum = 0;
673 int nwords = len >> 1;
674
675 while (nwords-- != 0)
676 sum += *p++;
677
678 if (len & 1)
679 sum += *(u_char *)p;
680
681 /* end-around-carry */
682 sum = (sum >> 16) + (sum & 0xffff);
683 sum += (sum >> 16);
684 return (~sum);
685 }
686
687
688 /* Send a router discovery advertisement or solicitation ICMP packet.
689 */
690 static void
691 send_rdisc(union ad_u *p,
692 int p_size,
693 struct interface *ifp,
694 naddr dst, /* 0 or unicast destination */
695 int type) /* 0=unicast, 1=bcast, 2=mcast */
696 {
697 struct sockaddr_in in;
698 int flags;
699 const char *msg;
700 naddr tgt_mcast;
701
702
703 memset(&in, 0, sizeof(in));
704 in.sin_addr.s_addr = dst;
705 in.sin_family = AF_INET;
706 #ifdef _HAVE_SIN_LEN
707 in.sin_len = sizeof(in);
708 #endif
709 flags = MSG_DONTROUTE;
710
711 switch (type) {
712 case 0: /* unicast */
713 default:
714 msg = "Send";
715 break;
716
717 case 1: /* broadcast */
718 if (ifp->int_if_flags & IFF_POINTOPOINT) {
719 msg = "Send pt-to-pt";
720 in.sin_addr.s_addr = ifp->int_dstaddr;
721 } else {
722 msg = "Send broadcast";
723 in.sin_addr.s_addr = ifp->int_brdaddr;
724 }
725 break;
726
727 case 2: /* multicast */
728 msg = "Send multicast";
729 if (ifp->int_state & IS_DUP) {
730 trace_act("abort multicast output via %s"
731 " with duplicate address",
732 ifp->int_name);
733 return;
734 }
735 if (rdisc_sock_mcast != ifp) {
736 /* select the right interface. */
737 #ifdef MCAST_PPP_BUG
738 /* Do not specify the primary interface explicitly
739 * if we have the multicast point-to-point kernel
740 * bug, since the kernel will do the wrong thing
741 * if the local address of a point-to-point link
742 * is the same as the address of an ordinary
743 * interface.
744 */
745 if (ifp->int_addr == myaddr) {
746 tgt_mcast = 0;
747 } else
748 #endif
749 tgt_mcast = ifp->int_addr;
750 if (0 > setsockopt(rdisc_sock,
751 IPPROTO_IP, IP_MULTICAST_IF,
752 &tgt_mcast, sizeof(tgt_mcast))) {
753 LOGERR("setsockopt(rdisc_sock,"
754 "IP_MULTICAST_IF)");
755 rdisc_sock_mcast = 0;
756 return;
757 }
758 rdisc_sock_mcast = ifp;
759 }
760 flags = 0;
761 break;
762 }
763
764 if (rdisc_sock < 0)
765 get_rdisc_sock();
766
767 trace_rdisc(msg, ifp->int_addr, in.sin_addr.s_addr, ifp,
768 p, p_size);
769
770 if (0 > sendto(rdisc_sock, p, p_size, flags,
771 (struct sockaddr *)&in, sizeof(in))) {
772 if (ifp == 0 || !(ifp->int_state & IS_BROKE))
773 msglog("sendto(%s%s%s): %s",
774 ifp != 0 ? ifp->int_name : "",
775 ifp != 0 ? ", " : "",
776 inet_ntoa(in.sin_addr),
777 strerror(errno));
778 if (ifp != 0)
779 if_sick(ifp);
780 }
781 }
782
783
784 /* Send an advertisement
785 */
786 static void
787 send_adv(struct interface *ifp,
788 naddr dst, /* 0 or unicast destination */
789 int type) /* 0=unicast, 1=bcast, 2=mcast */
790 {
791 union ad_u u;
792 n_long pref;
793
794
795 memset(&u, 0, sizeof(u.ad));
796
797 u.ad.icmp_type = ICMP_ROUTERADVERT;
798 u.ad.icmp_ad_num = 1;
799 u.ad.icmp_ad_asize = sizeof(u.ad.icmp_ad_info[0])/4;
800
801 u.ad.icmp_ad_life = stopint ? 0 : htons(ifp->int_rdisc_int*3);
802
803 /* Convert the configured preference to an unsigned value,
804 * bias it by the interface metric, and then send it as a
805 * signed, network byte order value.
806 */
807 pref = UNSIGN_PREF(ifp->int_rdisc_pref);
808 u.ad.icmp_ad_info[0].icmp_ad_pref = htonl(SIGN_PREF(PREF(pref, ifp)));
809
810 u.ad.icmp_ad_info[0].icmp_ad_addr = ifp->int_addr;
811
812 u.ad.icmp_cksum = in_cksum((u_short*)&u.ad, sizeof(u.ad));
813
814 send_rdisc(&u, sizeof(u.ad), ifp, dst, type);
815 }
816
817
818 /* Advertise for Router Discovery
819 */
820 void
821 rdisc_adv(void)
822 {
823 struct interface *ifp;
824
825 if (!supplier)
826 return;
827
828 rdisc_timer.tv_sec = now.tv_sec + NEVER;
829
830 for (ifp = ifnet; ifp; ifp = ifp->int_next) {
831 if (0 != (ifp->int_state & (IS_NO_ADV_OUT | IS_BROKE)))
832 continue;
833
834 if (!timercmp(&ifp->int_rdisc_timer, &now, >)
835 || stopint) {
836 send_adv(ifp, htonl(INADDR_ALLHOSTS_GROUP),
837 (ifp->int_state&IS_BCAST_RDISC) ? 1 : 2);
838 ifp->int_rdisc_cnt++;
839
840 intvl_random(&ifp->int_rdisc_timer,
841 (ifp->int_rdisc_int*3)/4,
842 ifp->int_rdisc_int);
843 if (ifp->int_rdisc_cnt < MAX_INITIAL_ADVERTS
844 && (ifp->int_rdisc_timer.tv_sec
845 > MAX_INITIAL_ADVERT_INTERVAL)) {
846 ifp->int_rdisc_timer.tv_sec
847 = MAX_INITIAL_ADVERT_INTERVAL;
848 }
849 timevaladd(&ifp->int_rdisc_timer, &now);
850 }
851
852 if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
853 rdisc_timer = ifp->int_rdisc_timer;
854 }
855 }
856
857
858 /* Solicit for Router Discovery
859 */
860 void
861 rdisc_sol(void)
862 {
863 struct interface *ifp;
864 union ad_u u;
865
866
867 if (supplier)
868 return;
869
870 rdisc_timer.tv_sec = now.tv_sec + NEVER;
871
872 for (ifp = ifnet; ifp; ifp = ifp->int_next) {
873 if (0 != (ifp->int_state & (IS_NO_SOL_OUT | IS_BROKE))
874 || ifp->int_rdisc_cnt >= MAX_SOLICITATIONS)
875 continue;
876
877 if (!timercmp(&ifp->int_rdisc_timer, &now, >)) {
878 memset(&u, 0, sizeof(u.so));
879 u.so.icmp_type = ICMP_ROUTERSOLICIT;
880 u.so.icmp_cksum = in_cksum((u_short*)&u.so,
881 sizeof(u.so));
882 send_rdisc(&u, sizeof(u.so), ifp,
883 htonl(INADDR_ALLROUTERS_GROUP),
884 ((ifp->int_state&IS_BCAST_RDISC) ? 1 : 2));
885
886 if (++ifp->int_rdisc_cnt >= MAX_SOLICITATIONS)
887 continue;
888
889 ifp->int_rdisc_timer.tv_sec = SOLICITATION_INTERVAL;
890 ifp->int_rdisc_timer.tv_usec = 0;
891 timevaladd(&ifp->int_rdisc_timer, &now);
892 }
893
894 if (timercmp(&rdisc_timer, &ifp->int_rdisc_timer, >))
895 rdisc_timer = ifp->int_rdisc_timer;
896 }
897 }
898
899
900 /* check the IP header of a possible Router Discovery ICMP packet */
901 static struct interface * /* 0 if bad */
902 ck_icmp(const char *act,
903 naddr from,
904 struct interface *ifp,
905 naddr to,
906 union ad_u *p,
907 u_int len)
908 {
909 const char *type;
910
911
912 if (p->icmp.icmp_type == ICMP_ROUTERADVERT) {
913 type = "advertisement";
914 } else if (p->icmp.icmp_type == ICMP_ROUTERSOLICIT) {
915 type = "solicitation";
916 } else {
917 return 0;
918 }
919
920 if (p->icmp.icmp_code != 0) {
921 trace_pkt("unrecognized ICMP Router %s code=%d from %s to %s",
922 type, p->icmp.icmp_code,
923 naddr_ntoa(from), naddr_ntoa(to));
924 return 0;
925 }
926
927 trace_rdisc(act, from, to, ifp, p, len);
928
929 if (ifp == 0)
930 trace_pkt("unknown interface for router-discovery %s"
931 " from %s to %s",
932 type, naddr_ntoa(from), naddr_ntoa(to));
933
934 return ifp;
935 }
936
937
938 /* read packets from the router discovery socket
939 */
940 void
941 read_d(void)
942 {
943 static struct msg_limit bad_asize, bad_len;
944 #ifdef USE_PASSIFNAME
945 static struct msg_limit bad_name;
946 #endif
947 struct sockaddr_in from;
948 int n, fromlen, cc, hlen;
949 struct {
950 #ifdef USE_PASSIFNAME
951 char ifname[IFNAMSIZ];
952 #endif
953 union {
954 struct ip ip;
955 u_short s[512/2];
956 u_char b[512];
957 } pkt;
958 } buf;
959 union ad_u *p;
960 n_long *wp;
961 struct interface *ifp;
962
963
964 for (;;) {
965 fromlen = sizeof(from);
966 cc = recvfrom(rdisc_sock, &buf, sizeof(buf), 0,
967 (struct sockaddr*)&from,
968 &fromlen);
969 if (cc <= 0) {
970 if (cc < 0 && errno != EWOULDBLOCK)
971 LOGERR("recvfrom(rdisc_sock)");
972 break;
973 }
974 if (fromlen != sizeof(struct sockaddr_in))
975 logbad(1,"impossible recvfrom(rdisc_sock) fromlen=%d",
976 fromlen);
977 #ifdef USE_PASSIFNAME
978 if ((cc -= sizeof(buf.ifname)) < 0)
979 logbad(0,"missing USE_PASSIFNAME; only %d bytes",
980 cc+sizeof(buf.ifname));
981 #endif
982
983 hlen = buf.pkt.ip.ip_hl << 2;
984 if (cc < hlen + ICMP_MINLEN)
985 continue;
986 p = (union ad_u *)&buf.pkt.b[hlen];
987 cc -= hlen;
988
989 #ifdef USE_PASSIFNAME
990 ifp = ifwithname(buf.ifname, 0);
991 if (ifp == 0)
992 msglim(&bad_name, from.sin_addr.s_addr,
993 "impossible rdisc if_ name %.*s",
994 IFNAMSIZ, buf.ifname);
995 #else
996 /* If we could tell the interface on which a packet from
997 * address 0 arrived, we could deal with such solicitations.
998 */
999 ifp = ((from.sin_addr.s_addr == 0)
1000 ? 0 : iflookup(from.sin_addr.s_addr));
1001 #endif
1002 ifp = ck_icmp("Recv", from.sin_addr.s_addr, ifp,
1003 buf.pkt.ip.ip_dst.s_addr, p, cc);
1004 if (ifp == 0)
1005 continue;
1006 if (ifwithaddr(from.sin_addr.s_addr, 0, 0)) {
1007 trace_pkt(" "
1008 "discard our own Router Discovery message");
1009 continue;
1010 }
1011
1012 switch (p->icmp.icmp_type) {
1013 case ICMP_ROUTERADVERT:
1014 if (p->ad.icmp_ad_asize*4
1015 < (int)sizeof(p->ad.icmp_ad_info[0])) {
1016 msglim(&bad_asize, from.sin_addr.s_addr,
1017 "intolerable rdisc address size=%d",
1018 p->ad.icmp_ad_asize);
1019 continue;
1020 }
1021 if (p->ad.icmp_ad_num == 0) {
1022 trace_pkt(" empty?");
1023 continue;
1024 }
1025 if (cc != (int)(sizeof(p->ad)
1026 - sizeof(p->ad.icmp_ad_info)
1027 + (p->ad.icmp_ad_num
1028 * sizeof(p->ad.icmp_ad_info[0])))) {
1029 msglim(&bad_len, from.sin_addr.s_addr,
1030 "rdisc length %d does not match ad_num"
1031 " %d", cc, p->ad.icmp_ad_num);
1032 continue;
1033 }
1034 if (supplier)
1035 continue;
1036 if (ifp->int_state & IS_NO_ADV_IN)
1037 continue;
1038
1039 wp = &p->ad.icmp_ad_info[0].icmp_ad_addr;
1040 for (n = 0; n < p->ad.icmp_ad_num; n++) {
1041 parse_ad(from.sin_addr.s_addr,
1042 wp[0], wp[1],
1043 ntohs(p->ad.icmp_ad_life),
1044 ifp);
1045 wp += p->ad.icmp_ad_asize;
1046 }
1047 break;
1048
1049
1050 case ICMP_ROUTERSOLICIT:
1051 if (!supplier)
1052 continue;
1053 if (ifp->int_state & IS_NO_ADV_OUT)
1054 continue;
1055 if (stopint)
1056 continue;
1057
1058 /* XXX
1059 * We should handle messages from address 0.
1060 */
1061
1062 /* Respond with a point-to-point advertisement */
1063 send_adv(ifp, from.sin_addr.s_addr, 0);
1064 break;
1065 }
1066 }
1067
1068 rdisc_sort();
1069 }
DragonFly BSD