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