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