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