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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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