Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/net/route.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1980, 1986, 1991, 1993 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 * 4. 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 * @(#)route.c 8.3.1.1 (Berkeley) 2/23/95 30 * $FreeBSD$ 31 */ 32 /************************************************************************ 33 * Note: In this file a 'fib' is a "forwarding information base" * 34 * Which is the new name for an in kernel routing (next hop) table. * 35 ***********************************************************************/ 36 37 #include "opt_inet.h" 38 #include "opt_inet6.h" 39 #include "opt_route.h" 40 #include "opt_mrouting.h" 41 #include "opt_mpath.h" 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/syslog.h> 46 #include <sys/malloc.h> 47 #include <sys/mbuf.h> 48 #include <sys/socket.h> 49 #include <sys/sysctl.h> 50 #include <sys/syslog.h> 51 #include <sys/sysproto.h> 52 #include <sys/proc.h> 53 #include <sys/domain.h> 54 #include <sys/kernel.h> 55 56 #include <net/if.h> 57 #include <net/if_dl.h> 58 #include <net/route.h> 59 #include <net/vnet.h> 60 #include <net/flowtable.h> 61 62 #ifdef RADIX_MPATH 63 #include <net/radix_mpath.h> 64 #endif 65 66 #include <netinet/in.h> 67 #include <netinet/ip_mroute.h> 68 69 #include <vm/uma.h> 70 71 /* We use 4 bits in the mbuf flags, thus we are limited to 16 FIBS. */ 72 #define RT_MAXFIBS 16 73 74 /* Kernel config default option. */ 75 #ifdef ROUTETABLES 76 #if ROUTETABLES <= 0 77 #error "ROUTETABLES defined too low" 78 #endif 79 #if ROUTETABLES > RT_MAXFIBS 80 #error "ROUTETABLES defined too big" 81 #endif 82 #define RT_NUMFIBS ROUTETABLES 83 #endif /* ROUTETABLES */ 84 /* Initialize to default if not otherwise set. */ 85 #ifndef RT_NUMFIBS 86 #define RT_NUMFIBS 1 87 #endif 88 89 u_int rt_numfibs = RT_NUMFIBS; 90 SYSCTL_UINT(_net, OID_AUTO, fibs, CTLFLAG_RD, &rt_numfibs, 0, ""); 91 /* 92 * Allow the boot code to allow LESS than RT_MAXFIBS to be used. 93 * We can't do more because storage is statically allocated for now. 94 * (for compatibility reasons.. this will change. When this changes, code should 95 * be refactored to protocol independent parts and protocol dependent parts, 96 * probably hanging of domain(9) specific storage to not need the full 97 * fib * af RNH allocation etc. but allow tuning the number of tables per 98 * address family). 99 */ 100 TUNABLE_INT("net.fibs", &rt_numfibs); 101 102 /* 103 * By default add routes to all fibs for new interfaces. 104 * Once this is set to 0 then only allocate routes on interface 105 * changes for the FIB of the caller when adding a new set of addresses 106 * to an interface. XXX this is a shotgun aproach to a problem that needs 107 * a more fine grained solution.. that will come. 108 * XXX also has the problems getting the FIB from curthread which will not 109 * always work given the fib can be overridden and prefixes can be added 110 * from the network stack context. 111 */ 112 u_int rt_add_addr_allfibs = 1; 113 SYSCTL_UINT(_net, OID_AUTO, add_addr_allfibs, CTLFLAG_RW, 114 &rt_add_addr_allfibs, 0, ""); 115 TUNABLE_INT("net.add_addr_allfibs", &rt_add_addr_allfibs); 116 117 VNET_DEFINE(struct rtstat, rtstat); 118 #define V_rtstat VNET(rtstat) 119 120 VNET_DEFINE(struct radix_node_head *, rt_tables); 121 #define V_rt_tables VNET(rt_tables) 122 123 VNET_DEFINE(int, rttrash); /* routes not in table but not freed */ 124 #define V_rttrash VNET(rttrash) 125 126 127 /* compare two sockaddr structures */ 128 #define sa_equal(a1, a2) (bcmp((a1), (a2), (a1)->sa_len) == 0) 129 130 /* 131 * Convert a 'struct radix_node *' to a 'struct rtentry *'. 132 * The operation can be done safely (in this code) because a 133 * 'struct rtentry' starts with two 'struct radix_node''s, the first 134 * one representing leaf nodes in the routing tree, which is 135 * what the code in radix.c passes us as a 'struct radix_node'. 136 * 137 * But because there are a lot of assumptions in this conversion, 138 * do not cast explicitly, but always use the macro below. 139 */ 140 #define RNTORT(p) ((struct rtentry *)(p)) 141 142 static VNET_DEFINE(uma_zone_t, rtzone); /* Routing table UMA zone. */ 143 #define V_rtzone VNET(rtzone) 144 145 /* 146 * handler for net.my_fibnum 147 */ 148 static int 149 sysctl_my_fibnum(SYSCTL_HANDLER_ARGS) 150 { 151 int fibnum; 152 int error; 153 154 fibnum = curthread->td_proc->p_fibnum; 155 error = sysctl_handle_int(oidp, &fibnum, 0, req); 156 return (error); 157 } 158 159 SYSCTL_PROC(_net, OID_AUTO, my_fibnum, CTLTYPE_INT|CTLFLAG_RD, 160 NULL, 0, &sysctl_my_fibnum, "I", "default FIB of caller"); 161 162 static __inline struct radix_node_head ** 163 rt_tables_get_rnh_ptr(int table, int fam) 164 { 165 struct radix_node_head **rnh; 166 167 KASSERT(table >= 0 && table < rt_numfibs, ("%s: table out of bounds.", 168 __func__)); 169 KASSERT(fam >= 0 && fam < (AF_MAX+1), ("%s: fam out of bounds.", 170 __func__)); 171 172 /* rnh is [fib=0][af=0]. */ 173 rnh = (struct radix_node_head **)V_rt_tables; 174 /* Get the offset to the requested table and fam. */ 175 rnh += table * (AF_MAX+1) + fam; 176 177 return (rnh); 178 } 179 180 struct radix_node_head * 181 rt_tables_get_rnh(int table, int fam) 182 { 183 184 return (*rt_tables_get_rnh_ptr(table, fam)); 185 } 186 187 /* 188 * route initialization must occur before ip6_init2(), which happenas at 189 * SI_ORDER_MIDDLE. 190 */ 191 static void 192 route_init(void) 193 { 194 struct domain *dom; 195 int max_keylen = 0; 196 197 /* whack the tunable ints into line. */ 198 if (rt_numfibs > RT_MAXFIBS) 199 rt_numfibs = RT_MAXFIBS; 200 if (rt_numfibs == 0) 201 rt_numfibs = 1; 202 203 for (dom = domains; dom; dom = dom->dom_next) 204 if (dom->dom_maxrtkey > max_keylen) 205 max_keylen = dom->dom_maxrtkey; 206 207 rn_init(max_keylen); /* init all zeroes, all ones, mask table */ 208 } 209 SYSINIT(route_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, route_init, 0); 210 211 static void 212 vnet_route_init(const void *unused __unused) 213 { 214 struct domain *dom; 215 struct radix_node_head **rnh; 216 int table; 217 int fam; 218 219 V_rt_tables = malloc(rt_numfibs * (AF_MAX+1) * 220 sizeof(struct radix_node_head *), M_RTABLE, M_WAITOK|M_ZERO); 221 222 V_rtzone = uma_zcreate("rtentry", sizeof(struct rtentry), NULL, NULL, 223 NULL, NULL, UMA_ALIGN_PTR, 0); 224 for (dom = domains; dom; dom = dom->dom_next) { 225 if (dom->dom_rtattach == NULL) 226 continue; 227 228 for (table = 0; table < rt_numfibs; table++) { 229 fam = dom->dom_family; 230 if (table != 0 && fam != AF_INET6 && fam != AF_INET) 231 break; 232 233 /* 234 * XXX MRT rtattach will be also called from 235 * vfs_export.c but the offset will be 0 (only for 236 * AF_INET and AF_INET6 which don't need it anyhow). 237 */ 238 rnh = rt_tables_get_rnh_ptr(table, fam); 239 if (rnh == NULL) 240 panic("%s: rnh NULL", __func__); 241 dom->dom_rtattach((void **)rnh, dom->dom_rtoffset); 242 } 243 } 244 } 245 VNET_SYSINIT(vnet_route_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_FOURTH, 246 vnet_route_init, 0); 247 248 #ifdef VIMAGE 249 static void 250 vnet_route_uninit(const void *unused __unused) 251 { 252 int table; 253 int fam; 254 struct domain *dom; 255 struct radix_node_head **rnh; 256 257 for (dom = domains; dom; dom = dom->dom_next) { 258 if (dom->dom_rtdetach == NULL) 259 continue; 260 261 for (table = 0; table < rt_numfibs; table++) { 262 fam = dom->dom_family; 263 264 if (table != 0 && fam != AF_INET6 && fam != AF_INET) 265 break; 266 267 rnh = rt_tables_get_rnh_ptr(table, fam); 268 if (rnh == NULL) 269 panic("%s: rnh NULL", __func__); 270 dom->dom_rtdetach((void **)rnh, dom->dom_rtoffset); 271 } 272 } 273 } 274 VNET_SYSUNINIT(vnet_route_uninit, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, 275 vnet_route_uninit, 0); 276 #endif 277 278 #ifndef _SYS_SYSPROTO_H_ 279 struct setfib_args { 280 int fibnum; 281 }; 282 #endif 283 int 284 setfib(struct thread *td, struct setfib_args *uap) 285 { 286 if (uap->fibnum < 0 || uap->fibnum >= rt_numfibs) 287 return EINVAL; 288 td->td_proc->p_fibnum = uap->fibnum; 289 return (0); 290 } 291 292 /* 293 * Packet routing routines. 294 */ 295 void 296 rtalloc(struct route *ro) 297 { 298 299 rtalloc_ign_fib(ro, 0UL, RT_DEFAULT_FIB); 300 } 301 302 void 303 rtalloc_fib(struct route *ro, u_int fibnum) 304 { 305 rtalloc_ign_fib(ro, 0UL, fibnum); 306 } 307 308 void 309 rtalloc_ign(struct route *ro, u_long ignore) 310 { 311 struct rtentry *rt; 312 313 if ((rt = ro->ro_rt) != NULL) { 314 if (rt->rt_ifp != NULL && rt->rt_flags & RTF_UP) 315 return; 316 RTFREE(rt); 317 ro->ro_rt = NULL; 318 } 319 ro->ro_rt = rtalloc1_fib(&ro->ro_dst, 1, ignore, RT_DEFAULT_FIB); 320 if (ro->ro_rt) 321 RT_UNLOCK(ro->ro_rt); 322 } 323 324 void 325 rtalloc_ign_fib(struct route *ro, u_long ignore, u_int fibnum) 326 { 327 struct rtentry *rt; 328 329 if ((rt = ro->ro_rt) != NULL) { 330 if (rt->rt_ifp != NULL && rt->rt_flags & RTF_UP) 331 return; 332 RTFREE(rt); 333 ro->ro_rt = NULL; 334 } 335 ro->ro_rt = rtalloc1_fib(&ro->ro_dst, 1, ignore, fibnum); 336 if (ro->ro_rt) 337 RT_UNLOCK(ro->ro_rt); 338 } 339 340 /* 341 * Look up the route that matches the address given 342 * Or, at least try.. Create a cloned route if needed. 343 * 344 * The returned route, if any, is locked. 345 */ 346 struct rtentry * 347 rtalloc1(struct sockaddr *dst, int report, u_long ignflags) 348 { 349 350 return (rtalloc1_fib(dst, report, ignflags, RT_DEFAULT_FIB)); 351 } 352 353 struct rtentry * 354 rtalloc1_fib(struct sockaddr *dst, int report, u_long ignflags, 355 u_int fibnum) 356 { 357 struct radix_node_head *rnh; 358 struct radix_node *rn; 359 struct rtentry *newrt; 360 struct rt_addrinfo info; 361 int err = 0, msgtype = RTM_MISS; 362 int needlock; 363 364 KASSERT((fibnum < rt_numfibs), ("rtalloc1_fib: bad fibnum")); 365 switch (dst->sa_family) { 366 case AF_INET6: 367 case AF_INET: 368 /* We support multiple FIBs. */ 369 break; 370 default: 371 fibnum = RT_DEFAULT_FIB; 372 break; 373 } 374 rnh = rt_tables_get_rnh(fibnum, dst->sa_family); 375 newrt = NULL; 376 if (rnh == NULL) 377 goto miss; 378 379 /* 380 * Look up the address in the table for that Address Family 381 */ 382 needlock = !(ignflags & RTF_RNH_LOCKED); 383 if (needlock) 384 RADIX_NODE_HEAD_RLOCK(rnh); 385 #ifdef INVARIANTS 386 else 387 RADIX_NODE_HEAD_LOCK_ASSERT(rnh); 388 #endif 389 rn = rnh->rnh_matchaddr(dst, rnh); 390 if (rn && ((rn->rn_flags & RNF_ROOT) == 0)) { 391 newrt = RNTORT(rn); 392 RT_LOCK(newrt); 393 RT_ADDREF(newrt); 394 if (needlock) 395 RADIX_NODE_HEAD_RUNLOCK(rnh); 396 goto done; 397 398 } else if (needlock) 399 RADIX_NODE_HEAD_RUNLOCK(rnh); 400 401 /* 402 * Either we hit the root or couldn't find any match, 403 * Which basically means 404 * "caint get there frm here" 405 */ 406 miss: 407 V_rtstat.rts_unreach++; 408 409 if (report) { 410 /* 411 * If required, report the failure to the supervising 412 * Authorities. 413 * For a delete, this is not an error. (report == 0) 414 */ 415 bzero(&info, sizeof(info)); 416 info.rti_info[RTAX_DST] = dst; 417 rt_missmsg_fib(msgtype, &info, 0, err, fibnum); 418 } 419 done: 420 if (newrt) 421 RT_LOCK_ASSERT(newrt); 422 return (newrt); 423 } 424 425 /* 426 * Remove a reference count from an rtentry. 427 * If the count gets low enough, take it out of the routing table 428 */ 429 void 430 rtfree(struct rtentry *rt) 431 { 432 struct radix_node_head *rnh; 433 434 KASSERT(rt != NULL,("%s: NULL rt", __func__)); 435 rnh = rt_tables_get_rnh(rt->rt_fibnum, rt_key(rt)->sa_family); 436 KASSERT(rnh != NULL,("%s: NULL rnh", __func__)); 437 438 RT_LOCK_ASSERT(rt); 439 440 /* 441 * The callers should use RTFREE_LOCKED() or RTFREE(), so 442 * we should come here exactly with the last reference. 443 */ 444 RT_REMREF(rt); 445 if (rt->rt_refcnt > 0) { 446 log(LOG_DEBUG, "%s: %p has %d refs\n", __func__, rt, rt->rt_refcnt); 447 goto done; 448 } 449 450 /* 451 * On last reference give the "close method" a chance 452 * to cleanup private state. This also permits (for 453 * IPv4 and IPv6) a chance to decide if the routing table 454 * entry should be purged immediately or at a later time. 455 * When an immediate purge is to happen the close routine 456 * typically calls rtexpunge which clears the RTF_UP flag 457 * on the entry so that the code below reclaims the storage. 458 */ 459 if (rt->rt_refcnt == 0 && rnh->rnh_close) 460 rnh->rnh_close((struct radix_node *)rt, rnh); 461 462 /* 463 * If we are no longer "up" (and ref == 0) 464 * then we can free the resources associated 465 * with the route. 466 */ 467 if ((rt->rt_flags & RTF_UP) == 0) { 468 if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT)) 469 panic("rtfree 2"); 470 /* 471 * the rtentry must have been removed from the routing table 472 * so it is represented in rttrash.. remove that now. 473 */ 474 V_rttrash--; 475 #ifdef DIAGNOSTIC 476 if (rt->rt_refcnt < 0) { 477 printf("rtfree: %p not freed (neg refs)\n", rt); 478 goto done; 479 } 480 #endif 481 /* 482 * release references on items we hold them on.. 483 * e.g other routes and ifaddrs. 484 */ 485 if (rt->rt_ifa) 486 ifa_free(rt->rt_ifa); 487 /* 488 * The key is separatly alloc'd so free it (see rt_setgate()). 489 * This also frees the gateway, as they are always malloc'd 490 * together. 491 */ 492 Free(rt_key(rt)); 493 494 /* 495 * and the rtentry itself of course 496 */ 497 RT_LOCK_DESTROY(rt); 498 uma_zfree(V_rtzone, rt); 499 return; 500 } 501 done: 502 RT_UNLOCK(rt); 503 } 504 505 506 /* 507 * Force a routing table entry to the specified 508 * destination to go through the given gateway. 509 * Normally called as a result of a routing redirect 510 * message from the network layer. 511 */ 512 void 513 rtredirect(struct sockaddr *dst, 514 struct sockaddr *gateway, 515 struct sockaddr *netmask, 516 int flags, 517 struct sockaddr *src) 518 { 519 520 rtredirect_fib(dst, gateway, netmask, flags, src, RT_DEFAULT_FIB); 521 } 522 523 void 524 rtredirect_fib(struct sockaddr *dst, 525 struct sockaddr *gateway, 526 struct sockaddr *netmask, 527 int flags, 528 struct sockaddr *src, 529 u_int fibnum) 530 { 531 struct rtentry *rt, *rt0 = NULL; 532 int error = 0; 533 short *stat = NULL; 534 struct rt_addrinfo info; 535 struct ifaddr *ifa; 536 struct radix_node_head *rnh; 537 538 ifa = NULL; 539 rnh = rt_tables_get_rnh(fibnum, dst->sa_family); 540 if (rnh == NULL) { 541 error = EAFNOSUPPORT; 542 goto out; 543 } 544 545 /* verify the gateway is directly reachable */ 546 if ((ifa = ifa_ifwithnet(gateway, 0)) == NULL) { 547 error = ENETUNREACH; 548 goto out; 549 } 550 rt = rtalloc1_fib(dst, 0, 0UL, fibnum); /* NB: rt is locked */ 551 /* 552 * If the redirect isn't from our current router for this dst, 553 * it's either old or wrong. If it redirects us to ourselves, 554 * we have a routing loop, perhaps as a result of an interface 555 * going down recently. 556 */ 557 if (!(flags & RTF_DONE) && rt && 558 (!sa_equal(src, rt->rt_gateway) || rt->rt_ifa != ifa)) 559 error = EINVAL; 560 else if (ifa_ifwithaddr_check(gateway)) 561 error = EHOSTUNREACH; 562 if (error) 563 goto done; 564 /* 565 * Create a new entry if we just got back a wildcard entry 566 * or the lookup failed. This is necessary for hosts 567 * which use routing redirects generated by smart gateways 568 * to dynamically build the routing tables. 569 */ 570 if (rt == NULL || (rt_mask(rt) && rt_mask(rt)->sa_len < 2)) 571 goto create; 572 /* 573 * Don't listen to the redirect if it's 574 * for a route to an interface. 575 */ 576 if (rt->rt_flags & RTF_GATEWAY) { 577 if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) { 578 /* 579 * Changing from route to net => route to host. 580 * Create new route, rather than smashing route to net. 581 */ 582 create: 583 rt0 = rt; 584 rt = NULL; 585 586 flags |= RTF_GATEWAY | RTF_DYNAMIC; 587 bzero((caddr_t)&info, sizeof(info)); 588 info.rti_info[RTAX_DST] = dst; 589 info.rti_info[RTAX_GATEWAY] = gateway; 590 info.rti_info[RTAX_NETMASK] = netmask; 591 info.rti_ifa = ifa; 592 info.rti_flags = flags; 593 if (rt0 != NULL) 594 RT_UNLOCK(rt0); /* drop lock to avoid LOR with RNH */ 595 error = rtrequest1_fib(RTM_ADD, &info, &rt, fibnum); 596 if (rt != NULL) { 597 RT_LOCK(rt); 598 if (rt0 != NULL) 599 EVENTHANDLER_INVOKE(route_redirect_event, rt0, rt, dst); 600 flags = rt->rt_flags; 601 } 602 if (rt0 != NULL) 603 RTFREE(rt0); 604 605 stat = &V_rtstat.rts_dynamic; 606 } else { 607 struct rtentry *gwrt; 608 609 /* 610 * Smash the current notion of the gateway to 611 * this destination. Should check about netmask!!! 612 */ 613 rt->rt_flags |= RTF_MODIFIED; 614 flags |= RTF_MODIFIED; 615 stat = &V_rtstat.rts_newgateway; 616 /* 617 * add the key and gateway (in one malloc'd chunk). 618 */ 619 RT_UNLOCK(rt); 620 RADIX_NODE_HEAD_LOCK(rnh); 621 RT_LOCK(rt); 622 rt_setgate(rt, rt_key(rt), gateway); 623 gwrt = rtalloc1(gateway, 1, RTF_RNH_LOCKED); 624 RADIX_NODE_HEAD_UNLOCK(rnh); 625 EVENTHANDLER_INVOKE(route_redirect_event, rt, gwrt, dst); 626 RTFREE_LOCKED(gwrt); 627 } 628 } else 629 error = EHOSTUNREACH; 630 done: 631 if (rt) 632 RTFREE_LOCKED(rt); 633 out: 634 if (error) 635 V_rtstat.rts_badredirect++; 636 else if (stat != NULL) 637 (*stat)++; 638 bzero((caddr_t)&info, sizeof(info)); 639 info.rti_info[RTAX_DST] = dst; 640 info.rti_info[RTAX_GATEWAY] = gateway; 641 info.rti_info[RTAX_NETMASK] = netmask; 642 info.rti_info[RTAX_AUTHOR] = src; 643 rt_missmsg_fib(RTM_REDIRECT, &info, flags, error, fibnum); 644 if (ifa != NULL) 645 ifa_free(ifa); 646 } 647 648 int 649 rtioctl(u_long req, caddr_t data) 650 { 651 652 return (rtioctl_fib(req, data, RT_DEFAULT_FIB)); 653 } 654 655 /* 656 * Routing table ioctl interface. 657 */ 658 int 659 rtioctl_fib(u_long req, caddr_t data, u_int fibnum) 660 { 661 662 /* 663 * If more ioctl commands are added here, make sure the proper 664 * super-user checks are being performed because it is possible for 665 * prison-root to make it this far if raw sockets have been enabled 666 * in jails. 667 */ 668 #ifdef INET 669 /* Multicast goop, grrr... */ 670 return mrt_ioctl ? mrt_ioctl(req, data, fibnum) : EOPNOTSUPP; 671 #else /* INET */ 672 return ENXIO; 673 #endif /* INET */ 674 } 675 676 /* 677 * For both ifa_ifwithroute() routines, 'ifa' is returned referenced. 678 */ 679 struct ifaddr * 680 ifa_ifwithroute(int flags, struct sockaddr *dst, struct sockaddr *gateway) 681 { 682 683 return (ifa_ifwithroute_fib(flags, dst, gateway, RT_DEFAULT_FIB)); 684 } 685 686 struct ifaddr * 687 ifa_ifwithroute_fib(int flags, struct sockaddr *dst, struct sockaddr *gateway, 688 u_int fibnum) 689 { 690 register struct ifaddr *ifa; 691 int not_found = 0; 692 693 if ((flags & RTF_GATEWAY) == 0) { 694 /* 695 * If we are adding a route to an interface, 696 * and the interface is a pt to pt link 697 * we should search for the destination 698 * as our clue to the interface. Otherwise 699 * we can use the local address. 700 */ 701 ifa = NULL; 702 if (flags & RTF_HOST) 703 ifa = ifa_ifwithdstaddr(dst); 704 if (ifa == NULL) 705 ifa = ifa_ifwithaddr(gateway); 706 } else { 707 /* 708 * If we are adding a route to a remote net 709 * or host, the gateway may still be on the 710 * other end of a pt to pt link. 711 */ 712 ifa = ifa_ifwithdstaddr(gateway); 713 } 714 if (ifa == NULL) 715 ifa = ifa_ifwithnet(gateway, 0); 716 if (ifa == NULL) { 717 struct rtentry *rt = rtalloc1_fib(gateway, 0, RTF_RNH_LOCKED, fibnum); 718 if (rt == NULL) 719 return (NULL); 720 /* 721 * dismiss a gateway that is reachable only 722 * through the default router 723 */ 724 switch (gateway->sa_family) { 725 case AF_INET: 726 if (satosin(rt_key(rt))->sin_addr.s_addr == INADDR_ANY) 727 not_found = 1; 728 break; 729 case AF_INET6: 730 if (IN6_IS_ADDR_UNSPECIFIED(&satosin6(rt_key(rt))->sin6_addr)) 731 not_found = 1; 732 break; 733 default: 734 break; 735 } 736 if (!not_found && rt->rt_ifa != NULL) { 737 ifa = rt->rt_ifa; 738 ifa_ref(ifa); 739 } 740 RT_REMREF(rt); 741 RT_UNLOCK(rt); 742 if (not_found || ifa == NULL) 743 return (NULL); 744 } 745 if (ifa->ifa_addr->sa_family != dst->sa_family) { 746 struct ifaddr *oifa = ifa; 747 ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp); 748 if (ifa == NULL) 749 ifa = oifa; 750 else 751 ifa_free(oifa); 752 } 753 return (ifa); 754 } 755 756 /* 757 * Do appropriate manipulations of a routing tree given 758 * all the bits of info needed 759 */ 760 int 761 rtrequest(int req, 762 struct sockaddr *dst, 763 struct sockaddr *gateway, 764 struct sockaddr *netmask, 765 int flags, 766 struct rtentry **ret_nrt) 767 { 768 769 return (rtrequest_fib(req, dst, gateway, netmask, flags, ret_nrt, 770 RT_DEFAULT_FIB)); 771 } 772 773 int 774 rtrequest_fib(int req, 775 struct sockaddr *dst, 776 struct sockaddr *gateway, 777 struct sockaddr *netmask, 778 int flags, 779 struct rtentry **ret_nrt, 780 u_int fibnum) 781 { 782 struct rt_addrinfo info; 783 784 if (dst->sa_len == 0) 785 return(EINVAL); 786 787 bzero((caddr_t)&info, sizeof(info)); 788 info.rti_flags = flags; 789 info.rti_info[RTAX_DST] = dst; 790 info.rti_info[RTAX_GATEWAY] = gateway; 791 info.rti_info[RTAX_NETMASK] = netmask; 792 return rtrequest1_fib(req, &info, ret_nrt, fibnum); 793 } 794 795 /* 796 * These (questionable) definitions of apparent local variables apply 797 * to the next two functions. XXXXXX!!! 798 */ 799 #define dst info->rti_info[RTAX_DST] 800 #define gateway info->rti_info[RTAX_GATEWAY] 801 #define netmask info->rti_info[RTAX_NETMASK] 802 #define ifaaddr info->rti_info[RTAX_IFA] 803 #define ifpaddr info->rti_info[RTAX_IFP] 804 #define flags info->rti_flags 805 806 int 807 rt_getifa(struct rt_addrinfo *info) 808 { 809 810 return (rt_getifa_fib(info, RT_DEFAULT_FIB)); 811 } 812 813 /* 814 * Look up rt_addrinfo for a specific fib. Note that if rti_ifa is defined, 815 * it will be referenced so the caller must free it. 816 */ 817 int 818 rt_getifa_fib(struct rt_addrinfo *info, u_int fibnum) 819 { 820 struct ifaddr *ifa; 821 int error = 0; 822 823 /* 824 * ifp may be specified by sockaddr_dl 825 * when protocol address is ambiguous. 826 */ 827 if (info->rti_ifp == NULL && ifpaddr != NULL && 828 ifpaddr->sa_family == AF_LINK && 829 (ifa = ifa_ifwithnet(ifpaddr, 0)) != NULL) { 830 info->rti_ifp = ifa->ifa_ifp; 831 ifa_free(ifa); 832 } 833 if (info->rti_ifa == NULL && ifaaddr != NULL) 834 info->rti_ifa = ifa_ifwithaddr(ifaaddr); 835 if (info->rti_ifa == NULL) { 836 struct sockaddr *sa; 837 838 sa = ifaaddr != NULL ? ifaaddr : 839 (gateway != NULL ? gateway : dst); 840 if (sa != NULL && info->rti_ifp != NULL) 841 info->rti_ifa = ifaof_ifpforaddr(sa, info->rti_ifp); 842 else if (dst != NULL && gateway != NULL) 843 info->rti_ifa = ifa_ifwithroute_fib(flags, dst, gateway, 844 fibnum); 845 else if (sa != NULL) 846 info->rti_ifa = ifa_ifwithroute_fib(flags, sa, sa, 847 fibnum); 848 } 849 if ((ifa = info->rti_ifa) != NULL) { 850 if (info->rti_ifp == NULL) 851 info->rti_ifp = ifa->ifa_ifp; 852 } else 853 error = ENETUNREACH; 854 return (error); 855 } 856 857 /* 858 * Expunges references to a route that's about to be reclaimed. 859 * The route must be locked. 860 */ 861 int 862 rtexpunge(struct rtentry *rt) 863 { 864 #if !defined(RADIX_MPATH) 865 struct radix_node *rn; 866 #else 867 struct rt_addrinfo info; 868 int fib; 869 struct rtentry *rt0; 870 #endif 871 struct radix_node_head *rnh; 872 struct ifaddr *ifa; 873 int error = 0; 874 875 /* 876 * Find the correct routing tree to use for this Address Family 877 */ 878 rnh = rt_tables_get_rnh(rt->rt_fibnum, rt_key(rt)->sa_family); 879 RT_LOCK_ASSERT(rt); 880 if (rnh == NULL) 881 return (EAFNOSUPPORT); 882 RADIX_NODE_HEAD_LOCK_ASSERT(rnh); 883 884 #ifdef RADIX_MPATH 885 fib = rt->rt_fibnum; 886 bzero(&info, sizeof(info)); 887 info.rti_ifp = rt->rt_ifp; 888 info.rti_flags = RTF_RNH_LOCKED; 889 info.rti_info[RTAX_DST] = rt_key(rt); 890 info.rti_info[RTAX_GATEWAY] = rt->rt_ifa->ifa_addr; 891 892 RT_UNLOCK(rt); 893 error = rtrequest1_fib(RTM_DELETE, &info, &rt0, fib); 894 895 if (error == 0 && rt0 != NULL) { 896 rt = rt0; 897 RT_LOCK(rt); 898 } else if (error != 0) { 899 RT_LOCK(rt); 900 return (error); 901 } 902 #else 903 /* 904 * Remove the item from the tree; it should be there, 905 * but when callers invoke us blindly it may not (sigh). 906 */ 907 rn = rnh->rnh_deladdr(rt_key(rt), rt_mask(rt), rnh); 908 if (rn == NULL) { 909 error = ESRCH; 910 goto bad; 911 } 912 KASSERT((rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) == 0, 913 ("unexpected flags 0x%x", rn->rn_flags)); 914 KASSERT(rt == RNTORT(rn), 915 ("lookup mismatch, rt %p rn %p", rt, rn)); 916 #endif /* RADIX_MPATH */ 917 918 rt->rt_flags &= ~RTF_UP; 919 920 /* 921 * Give the protocol a chance to keep things in sync. 922 */ 923 if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest) { 924 struct rt_addrinfo info; 925 926 bzero((caddr_t)&info, sizeof(info)); 927 info.rti_flags = rt->rt_flags; 928 info.rti_info[RTAX_DST] = rt_key(rt); 929 info.rti_info[RTAX_GATEWAY] = rt->rt_gateway; 930 info.rti_info[RTAX_NETMASK] = rt_mask(rt); 931 ifa->ifa_rtrequest(RTM_DELETE, rt, &info); 932 } 933 934 /* 935 * one more rtentry floating around that is not 936 * linked to the routing table. 937 */ 938 V_rttrash++; 939 #if !defined(RADIX_MPATH) 940 bad: 941 #endif 942 return (error); 943 } 944 945 #ifdef RADIX_MPATH 946 static int 947 rn_mpath_update(int req, struct rt_addrinfo *info, 948 struct radix_node_head *rnh, struct rtentry **ret_nrt) 949 { 950 /* 951 * if we got multipath routes, we require users to specify 952 * a matching RTAX_GATEWAY. 953 */ 954 struct rtentry *rt, *rto = NULL; 955 register struct radix_node *rn; 956 int error = 0; 957 958 rn = rnh->rnh_matchaddr(dst, rnh); 959 if (rn == NULL) 960 return (ESRCH); 961 rto = rt = RNTORT(rn); 962 rt = rt_mpath_matchgate(rt, gateway); 963 if (rt == NULL) 964 return (ESRCH); 965 /* 966 * this is the first entry in the chain 967 */ 968 if (rto == rt) { 969 rn = rn_mpath_next((struct radix_node *)rt); 970 /* 971 * there is another entry, now it's active 972 */ 973 if (rn) { 974 rto = RNTORT(rn); 975 RT_LOCK(rto); 976 rto->rt_flags |= RTF_UP; 977 RT_UNLOCK(rto); 978 } else if (rt->rt_flags & RTF_GATEWAY) { 979 /* 980 * For gateway routes, we need to 981 * make sure that we we are deleting 982 * the correct gateway. 983 * rt_mpath_matchgate() does not 984 * check the case when there is only 985 * one route in the chain. 986 */ 987 if (gateway && 988 (rt->rt_gateway->sa_len != gateway->sa_len || 989 memcmp(rt->rt_gateway, gateway, gateway->sa_len))) 990 error = ESRCH; 991 else { 992 /* 993 * remove from tree before returning it 994 * to the caller 995 */ 996 rn = rnh->rnh_deladdr(dst, netmask, rnh); 997 KASSERT(rt == RNTORT(rn), ("radix node disappeared")); 998 goto gwdelete; 999 } 1000 1001 } 1002 /* 1003 * use the normal delete code to remove 1004 * the first entry 1005 */ 1006 if (req != RTM_DELETE) 1007 goto nondelete; 1008 1009 error = ENOENT; 1010 goto done; 1011 } 1012 1013 /* 1014 * if the entry is 2nd and on up 1015 */ 1016 if ((req == RTM_DELETE) && !rt_mpath_deldup(rto, rt)) 1017 panic ("rtrequest1: rt_mpath_deldup"); 1018 gwdelete: 1019 RT_LOCK(rt); 1020 RT_ADDREF(rt); 1021 if (req == RTM_DELETE) { 1022 rt->rt_flags &= ~RTF_UP; 1023 /* 1024 * One more rtentry floating around that is not 1025 * linked to the routing table. rttrash will be decremented 1026 * when RTFREE(rt) is eventually called. 1027 */ 1028 V_rttrash++; 1029 } 1030 1031 nondelete: 1032 if (req != RTM_DELETE) 1033 panic("unrecognized request %d", req); 1034 1035 1036 /* 1037 * If the caller wants it, then it can have it, 1038 * but it's up to it to free the rtentry as we won't be 1039 * doing it. 1040 */ 1041 if (ret_nrt) { 1042 *ret_nrt = rt; 1043 RT_UNLOCK(rt); 1044 } else 1045 RTFREE_LOCKED(rt); 1046 done: 1047 return (error); 1048 } 1049 #endif 1050 1051 int 1052 rtrequest1_fib(int req, struct rt_addrinfo *info, struct rtentry **ret_nrt, 1053 u_int fibnum) 1054 { 1055 int error = 0, needlock = 0; 1056 register struct rtentry *rt; 1057 #ifdef FLOWTABLE 1058 register struct rtentry *rt0; 1059 #endif 1060 register struct radix_node *rn; 1061 register struct radix_node_head *rnh; 1062 struct ifaddr *ifa; 1063 struct sockaddr *ndst; 1064 struct sockaddr_storage mdst; 1065 #define senderr(x) { error = x ; goto bad; } 1066 1067 KASSERT((fibnum < rt_numfibs), ("rtrequest1_fib: bad fibnum")); 1068 switch (dst->sa_family) { 1069 case AF_INET6: 1070 case AF_INET: 1071 /* We support multiple FIBs. */ 1072 break; 1073 default: 1074 fibnum = RT_DEFAULT_FIB; 1075 break; 1076 } 1077 1078 /* 1079 * Find the correct routing tree to use for this Address Family 1080 */ 1081 rnh = rt_tables_get_rnh(fibnum, dst->sa_family); 1082 if (rnh == NULL) 1083 return (EAFNOSUPPORT); 1084 needlock = ((flags & RTF_RNH_LOCKED) == 0); 1085 flags &= ~RTF_RNH_LOCKED; 1086 if (needlock) 1087 RADIX_NODE_HEAD_LOCK(rnh); 1088 else 1089 RADIX_NODE_HEAD_LOCK_ASSERT(rnh); 1090 /* 1091 * If we are adding a host route then we don't want to put 1092 * a netmask in the tree, nor do we want to clone it. 1093 */ 1094 if (flags & RTF_HOST) 1095 netmask = NULL; 1096 1097 switch (req) { 1098 case RTM_DELETE: 1099 if (netmask) { 1100 rt_maskedcopy(dst, (struct sockaddr *)&mdst, netmask); 1101 dst = (struct sockaddr *)&mdst; 1102 } 1103 #ifdef RADIX_MPATH 1104 if (rn_mpath_capable(rnh)) { 1105 error = rn_mpath_update(req, info, rnh, ret_nrt); 1106 /* 1107 * "bad" holds true for the success case 1108 * as well 1109 */ 1110 if (error != ENOENT) 1111 goto bad; 1112 error = 0; 1113 } 1114 #endif 1115 if ((flags & RTF_PINNED) == 0) { 1116 /* Check if target route can be deleted */ 1117 rt = (struct rtentry *)rnh->rnh_lookup(dst, 1118 netmask, rnh); 1119 if ((rt != NULL) && (rt->rt_flags & RTF_PINNED)) 1120 senderr(EADDRINUSE); 1121 } 1122 1123 /* 1124 * Remove the item from the tree and return it. 1125 * Complain if it is not there and do no more processing. 1126 */ 1127 rn = rnh->rnh_deladdr(dst, netmask, rnh); 1128 if (rn == NULL) 1129 senderr(ESRCH); 1130 if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)) 1131 panic ("rtrequest delete"); 1132 rt = RNTORT(rn); 1133 RT_LOCK(rt); 1134 RT_ADDREF(rt); 1135 rt->rt_flags &= ~RTF_UP; 1136 1137 /* 1138 * give the protocol a chance to keep things in sync. 1139 */ 1140 if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest) 1141 ifa->ifa_rtrequest(RTM_DELETE, rt, info); 1142 1143 /* 1144 * One more rtentry floating around that is not 1145 * linked to the routing table. rttrash will be decremented 1146 * when RTFREE(rt) is eventually called. 1147 */ 1148 V_rttrash++; 1149 1150 /* 1151 * If the caller wants it, then it can have it, 1152 * but it's up to it to free the rtentry as we won't be 1153 * doing it. 1154 */ 1155 if (ret_nrt) { 1156 *ret_nrt = rt; 1157 RT_UNLOCK(rt); 1158 } else 1159 RTFREE_LOCKED(rt); 1160 break; 1161 case RTM_RESOLVE: 1162 /* 1163 * resolve was only used for route cloning 1164 * here for compat 1165 */ 1166 break; 1167 case RTM_ADD: 1168 if ((flags & RTF_GATEWAY) && !gateway) 1169 senderr(EINVAL); 1170 if (dst && gateway && (dst->sa_family != gateway->sa_family) && 1171 (gateway->sa_family != AF_UNSPEC) && (gateway->sa_family != AF_LINK)) 1172 senderr(EINVAL); 1173 1174 if (info->rti_ifa == NULL) { 1175 error = rt_getifa_fib(info, fibnum); 1176 if (error) 1177 senderr(error); 1178 } else 1179 ifa_ref(info->rti_ifa); 1180 ifa = info->rti_ifa; 1181 rt = uma_zalloc(V_rtzone, M_NOWAIT | M_ZERO); 1182 if (rt == NULL) { 1183 if (ifa != NULL) 1184 ifa_free(ifa); 1185 senderr(ENOBUFS); 1186 } 1187 RT_LOCK_INIT(rt); 1188 rt->rt_flags = RTF_UP | flags; 1189 rt->rt_fibnum = fibnum; 1190 /* 1191 * Add the gateway. Possibly re-malloc-ing the storage for it. 1192 */ 1193 RT_LOCK(rt); 1194 if ((error = rt_setgate(rt, dst, gateway)) != 0) { 1195 RT_LOCK_DESTROY(rt); 1196 if (ifa != NULL) 1197 ifa_free(ifa); 1198 uma_zfree(V_rtzone, rt); 1199 senderr(error); 1200 } 1201 1202 /* 1203 * point to the (possibly newly malloc'd) dest address. 1204 */ 1205 ndst = (struct sockaddr *)rt_key(rt); 1206 1207 /* 1208 * make sure it contains the value we want (masked if needed). 1209 */ 1210 if (netmask) { 1211 rt_maskedcopy(dst, ndst, netmask); 1212 } else 1213 bcopy(dst, ndst, dst->sa_len); 1214 1215 /* 1216 * We use the ifa reference returned by rt_getifa_fib(). 1217 * This moved from below so that rnh->rnh_addaddr() can 1218 * examine the ifa and ifa->ifa_ifp if it so desires. 1219 */ 1220 rt->rt_ifa = ifa; 1221 rt->rt_ifp = ifa->ifa_ifp; 1222 rt->rt_rmx.rmx_weight = 1; 1223 1224 #ifdef RADIX_MPATH 1225 /* do not permit exactly the same dst/mask/gw pair */ 1226 if (rn_mpath_capable(rnh) && 1227 rt_mpath_conflict(rnh, rt, netmask)) { 1228 if (rt->rt_ifa) { 1229 ifa_free(rt->rt_ifa); 1230 } 1231 Free(rt_key(rt)); 1232 RT_LOCK_DESTROY(rt); 1233 uma_zfree(V_rtzone, rt); 1234 senderr(EEXIST); 1235 } 1236 #endif 1237 1238 #ifdef FLOWTABLE 1239 rt0 = NULL; 1240 /* "flow-table" only supports IPv6 and IPv4 at the moment. */ 1241 switch (dst->sa_family) { 1242 #ifdef notyet 1243 #ifdef INET6 1244 case AF_INET6: 1245 #endif 1246 #endif 1247 #ifdef INET 1248 case AF_INET: 1249 #endif 1250 #if defined(INET6) || defined(INET) 1251 rn = rnh->rnh_matchaddr(dst, rnh); 1252 if (rn && ((rn->rn_flags & RNF_ROOT) == 0)) { 1253 struct sockaddr *mask; 1254 u_char *m, *n; 1255 int len; 1256 1257 /* 1258 * compare mask to see if the new route is 1259 * more specific than the existing one 1260 */ 1261 rt0 = RNTORT(rn); 1262 RT_LOCK(rt0); 1263 RT_ADDREF(rt0); 1264 RT_UNLOCK(rt0); 1265 /* 1266 * A host route is already present, so 1267 * leave the flow-table entries as is. 1268 */ 1269 if (rt0->rt_flags & RTF_HOST) { 1270 RTFREE(rt0); 1271 rt0 = NULL; 1272 } else if (!(flags & RTF_HOST) && netmask) { 1273 mask = rt_mask(rt0); 1274 len = mask->sa_len; 1275 m = (u_char *)mask; 1276 n = (u_char *)netmask; 1277 while (len-- > 0) { 1278 if (*n != *m) 1279 break; 1280 n++; 1281 m++; 1282 } 1283 if (len == 0 || (*n < *m)) { 1284 RTFREE(rt0); 1285 rt0 = NULL; 1286 } 1287 } 1288 } 1289 #endif/* INET6 || INET */ 1290 } 1291 #endif /* FLOWTABLE */ 1292 1293 /* XXX mtu manipulation will be done in rnh_addaddr -- itojun */ 1294 rn = rnh->rnh_addaddr(ndst, netmask, rnh, rt->rt_nodes); 1295 /* 1296 * If it still failed to go into the tree, 1297 * then un-make it (this should be a function) 1298 */ 1299 if (rn == NULL) { 1300 if (rt->rt_ifa) 1301 ifa_free(rt->rt_ifa); 1302 Free(rt_key(rt)); 1303 RT_LOCK_DESTROY(rt); 1304 uma_zfree(V_rtzone, rt); 1305 #ifdef FLOWTABLE 1306 if (rt0 != NULL) 1307 RTFREE(rt0); 1308 #endif 1309 senderr(EEXIST); 1310 } 1311 #ifdef FLOWTABLE 1312 else if (rt0 != NULL) { 1313 switch (dst->sa_family) { 1314 #ifdef notyet 1315 #ifdef INET6 1316 case AF_INET6: 1317 flowtable_route_flush(V_ip6_ft, rt0); 1318 break; 1319 #endif 1320 #endif 1321 #ifdef INET 1322 case AF_INET: 1323 flowtable_route_flush(V_ip_ft, rt0); 1324 break; 1325 #endif 1326 } 1327 RTFREE(rt0); 1328 } 1329 #endif 1330 1331 /* 1332 * If this protocol has something to add to this then 1333 * allow it to do that as well. 1334 */ 1335 if (ifa->ifa_rtrequest) 1336 ifa->ifa_rtrequest(req, rt, info); 1337 1338 /* 1339 * actually return a resultant rtentry and 1340 * give the caller a single reference. 1341 */ 1342 if (ret_nrt) { 1343 *ret_nrt = rt; 1344 RT_ADDREF(rt); 1345 } 1346 RT_UNLOCK(rt); 1347 break; 1348 default: 1349 error = EOPNOTSUPP; 1350 } 1351 bad: 1352 if (needlock) 1353 RADIX_NODE_HEAD_UNLOCK(rnh); 1354 return (error); 1355 #undef senderr 1356 } 1357 1358 #undef dst 1359 #undef gateway 1360 #undef netmask 1361 #undef ifaaddr 1362 #undef ifpaddr 1363 #undef flags 1364 1365 int 1366 rt_setgate(struct rtentry *rt, struct sockaddr *dst, struct sockaddr *gate) 1367 { 1368 /* XXX dst may be overwritten, can we move this to below */ 1369 int dlen = SA_SIZE(dst), glen = SA_SIZE(gate); 1370 #ifdef INVARIANTS 1371 struct radix_node_head *rnh; 1372 1373 rnh = rt_tables_get_rnh(rt->rt_fibnum, dst->sa_family); 1374 #endif 1375 1376 RT_LOCK_ASSERT(rt); 1377 RADIX_NODE_HEAD_LOCK_ASSERT(rnh); 1378 1379 /* 1380 * Prepare to store the gateway in rt->rt_gateway. 1381 * Both dst and gateway are stored one after the other in the same 1382 * malloc'd chunk. If we have room, we can reuse the old buffer, 1383 * rt_gateway already points to the right place. 1384 * Otherwise, malloc a new block and update the 'dst' address. 1385 */ 1386 if (rt->rt_gateway == NULL || glen > SA_SIZE(rt->rt_gateway)) { 1387 caddr_t new; 1388 1389 R_Malloc(new, caddr_t, dlen + glen); 1390 if (new == NULL) 1391 return ENOBUFS; 1392 /* 1393 * XXX note, we copy from *dst and not *rt_key(rt) because 1394 * rt_setgate() can be called to initialize a newly 1395 * allocated route entry, in which case rt_key(rt) == NULL 1396 * (and also rt->rt_gateway == NULL). 1397 * Free()/free() handle a NULL argument just fine. 1398 */ 1399 bcopy(dst, new, dlen); 1400 Free(rt_key(rt)); /* free old block, if any */ 1401 rt_key(rt) = (struct sockaddr *)new; 1402 rt->rt_gateway = (struct sockaddr *)(new + dlen); 1403 } 1404 1405 /* 1406 * Copy the new gateway value into the memory chunk. 1407 */ 1408 bcopy(gate, rt->rt_gateway, glen); 1409 1410 return (0); 1411 } 1412 1413 void 1414 rt_maskedcopy(struct sockaddr *src, struct sockaddr *dst, struct sockaddr *netmask) 1415 { 1416 register u_char *cp1 = (u_char *)src; 1417 register u_char *cp2 = (u_char *)dst; 1418 register u_char *cp3 = (u_char *)netmask; 1419 u_char *cplim = cp2 + *cp3; 1420 u_char *cplim2 = cp2 + *cp1; 1421 1422 *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */ 1423 cp3 += 2; 1424 if (cplim > cplim2) 1425 cplim = cplim2; 1426 while (cp2 < cplim) 1427 *cp2++ = *cp1++ & *cp3++; 1428 if (cp2 < cplim2) 1429 bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2)); 1430 } 1431 1432 /* 1433 * Set up a routing table entry, normally 1434 * for an interface. 1435 */ 1436 #define _SOCKADDR_TMPSIZE 128 /* Not too big.. kernel stack size is limited */ 1437 static inline int 1438 rtinit1(struct ifaddr *ifa, int cmd, int flags, int fibnum) 1439 { 1440 struct sockaddr *dst; 1441 struct sockaddr *netmask; 1442 struct rtentry *rt = NULL; 1443 struct rt_addrinfo info; 1444 int error = 0; 1445 int startfib, endfib; 1446 char tempbuf[_SOCKADDR_TMPSIZE]; 1447 int didwork = 0; 1448 int a_failure = 0; 1449 static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK}; 1450 struct radix_node_head *rnh; 1451 1452 if (flags & RTF_HOST) { 1453 dst = ifa->ifa_dstaddr; 1454 netmask = NULL; 1455 } else { 1456 dst = ifa->ifa_addr; 1457 netmask = ifa->ifa_netmask; 1458 } 1459 if (dst->sa_len == 0) 1460 return(EINVAL); 1461 switch (dst->sa_family) { 1462 case AF_INET6: 1463 case AF_INET: 1464 /* We support multiple FIBs. */ 1465 break; 1466 default: 1467 fibnum = RT_DEFAULT_FIB; 1468 break; 1469 } 1470 if (fibnum == -1) { 1471 if (rt_add_addr_allfibs == 0 && cmd == (int)RTM_ADD) { 1472 startfib = endfib = curthread->td_proc->p_fibnum; 1473 } else { 1474 startfib = 0; 1475 endfib = rt_numfibs - 1; 1476 } 1477 } else { 1478 KASSERT((fibnum < rt_numfibs), ("rtinit1: bad fibnum")); 1479 startfib = fibnum; 1480 endfib = fibnum; 1481 } 1482 1483 /* 1484 * If it's a delete, check that if it exists, 1485 * it's on the correct interface or we might scrub 1486 * a route to another ifa which would 1487 * be confusing at best and possibly worse. 1488 */ 1489 if (cmd == RTM_DELETE) { 1490 /* 1491 * It's a delete, so it should already exist.. 1492 * If it's a net, mask off the host bits 1493 * (Assuming we have a mask) 1494 * XXX this is kinda inet specific.. 1495 */ 1496 if (netmask != NULL) { 1497 rt_maskedcopy(dst, (struct sockaddr *)tempbuf, netmask); 1498 dst = (struct sockaddr *)tempbuf; 1499 } 1500 } 1501 /* 1502 * Now go through all the requested tables (fibs) and do the 1503 * requested action. Realistically, this will either be fib 0 1504 * for protocols that don't do multiple tables or all the 1505 * tables for those that do. 1506 */ 1507 for ( fibnum = startfib; fibnum <= endfib; fibnum++) { 1508 if (cmd == RTM_DELETE) { 1509 struct radix_node *rn; 1510 /* 1511 * Look up an rtentry that is in the routing tree and 1512 * contains the correct info. 1513 */ 1514 rnh = rt_tables_get_rnh(fibnum, dst->sa_family); 1515 if (rnh == NULL) 1516 /* this table doesn't exist but others might */ 1517 continue; 1518 RADIX_NODE_HEAD_RLOCK(rnh); 1519 #ifdef RADIX_MPATH 1520 if (rn_mpath_capable(rnh)) { 1521 1522 rn = rnh->rnh_matchaddr(dst, rnh); 1523 if (rn == NULL) 1524 error = ESRCH; 1525 else { 1526 rt = RNTORT(rn); 1527 /* 1528 * for interface route the 1529 * rt->rt_gateway is sockaddr_intf 1530 * for cloning ARP entries, so 1531 * rt_mpath_matchgate must use the 1532 * interface address 1533 */ 1534 rt = rt_mpath_matchgate(rt, 1535 ifa->ifa_addr); 1536 if (!rt) 1537 error = ESRCH; 1538 } 1539 } 1540 else 1541 #endif 1542 rn = rnh->rnh_lookup(dst, netmask, rnh); 1543 error = (rn == NULL || 1544 (rn->rn_flags & RNF_ROOT) || 1545 RNTORT(rn)->rt_ifa != ifa || 1546 !sa_equal((struct sockaddr *)rn->rn_key, dst)); 1547 RADIX_NODE_HEAD_RUNLOCK(rnh); 1548 if (error) { 1549 /* this is only an error if bad on ALL tables */ 1550 continue; 1551 } 1552 } 1553 /* 1554 * Do the actual request 1555 */ 1556 bzero((caddr_t)&info, sizeof(info)); 1557 info.rti_ifa = ifa; 1558 info.rti_flags = flags | 1559 (ifa->ifa_flags & ~IFA_RTSELF) | RTF_PINNED; 1560 info.rti_info[RTAX_DST] = dst; 1561 /* 1562 * doing this for compatibility reasons 1563 */ 1564 if (cmd == RTM_ADD) 1565 info.rti_info[RTAX_GATEWAY] = 1566 (struct sockaddr *)&null_sdl; 1567 else 1568 info.rti_info[RTAX_GATEWAY] = ifa->ifa_addr; 1569 info.rti_info[RTAX_NETMASK] = netmask; 1570 error = rtrequest1_fib(cmd, &info, &rt, fibnum); 1571 1572 if ((error == EEXIST) && (cmd == RTM_ADD)) { 1573 /* 1574 * Interface route addition failed. 1575 * Atomically delete current prefix generating 1576 * RTM_DELETE message, and retry adding 1577 * interface prefix. 1578 */ 1579 rnh = rt_tables_get_rnh(fibnum, dst->sa_family); 1580 RADIX_NODE_HEAD_LOCK(rnh); 1581 1582 /* Delete old prefix */ 1583 info.rti_ifa = NULL; 1584 info.rti_flags = RTF_RNH_LOCKED; 1585 1586 error = rtrequest1_fib(RTM_DELETE, &info, &rt, fibnum); 1587 if (error == 0) { 1588 info.rti_ifa = ifa; 1589 info.rti_flags = flags | RTF_RNH_LOCKED | 1590 (ifa->ifa_flags & ~IFA_RTSELF) | RTF_PINNED; 1591 error = rtrequest1_fib(cmd, &info, &rt, fibnum); 1592 } 1593 1594 RADIX_NODE_HEAD_UNLOCK(rnh); 1595 } 1596 1597 1598 if (error == 0 && rt != NULL) { 1599 /* 1600 * notify any listening routing agents of the change 1601 */ 1602 RT_LOCK(rt); 1603 #ifdef RADIX_MPATH 1604 /* 1605 * in case address alias finds the first address 1606 * e.g. ifconfig bge0 192.0.2.246/24 1607 * e.g. ifconfig bge0 192.0.2.247/24 1608 * the address set in the route is 192.0.2.246 1609 * so we need to replace it with 192.0.2.247 1610 */ 1611 if (memcmp(rt->rt_ifa->ifa_addr, 1612 ifa->ifa_addr, ifa->ifa_addr->sa_len)) { 1613 ifa_free(rt->rt_ifa); 1614 ifa_ref(ifa); 1615 rt->rt_ifp = ifa->ifa_ifp; 1616 rt->rt_ifa = ifa; 1617 } 1618 #endif 1619 /* 1620 * doing this for compatibility reasons 1621 */ 1622 if (cmd == RTM_ADD) { 1623 ((struct sockaddr_dl *)rt->rt_gateway)->sdl_type = 1624 rt->rt_ifp->if_type; 1625 ((struct sockaddr_dl *)rt->rt_gateway)->sdl_index = 1626 rt->rt_ifp->if_index; 1627 } 1628 RT_ADDREF(rt); 1629 RT_UNLOCK(rt); 1630 rt_newaddrmsg_fib(cmd, ifa, error, rt, fibnum); 1631 RT_LOCK(rt); 1632 RT_REMREF(rt); 1633 if (cmd == RTM_DELETE) { 1634 /* 1635 * If we are deleting, and we found an entry, 1636 * then it's been removed from the tree.. 1637 * now throw it away. 1638 */ 1639 RTFREE_LOCKED(rt); 1640 } else { 1641 if (cmd == RTM_ADD) { 1642 /* 1643 * We just wanted to add it.. 1644 * we don't actually need a reference. 1645 */ 1646 RT_REMREF(rt); 1647 } 1648 RT_UNLOCK(rt); 1649 } 1650 didwork = 1; 1651 } 1652 if (error) 1653 a_failure = error; 1654 } 1655 if (cmd == RTM_DELETE) { 1656 if (didwork) { 1657 error = 0; 1658 } else { 1659 /* we only give an error if it wasn't in any table */ 1660 error = ((flags & RTF_HOST) ? 1661 EHOSTUNREACH : ENETUNREACH); 1662 } 1663 } else { 1664 if (a_failure) { 1665 /* return an error if any of them failed */ 1666 error = a_failure; 1667 } 1668 } 1669 return (error); 1670 } 1671 1672 #ifndef BURN_BRIDGES 1673 /* special one for inet internal use. may not use. */ 1674 int 1675 rtinit_fib(struct ifaddr *ifa, int cmd, int flags) 1676 { 1677 return (rtinit1(ifa, cmd, flags, -1)); 1678 } 1679 #endif 1680 1681 /* 1682 * Set up a routing table entry, normally 1683 * for an interface. 1684 */ 1685 int 1686 rtinit(struct ifaddr *ifa, int cmd, int flags) 1687 { 1688 struct sockaddr *dst; 1689 int fib = RT_DEFAULT_FIB; 1690 1691 if (flags & RTF_HOST) { 1692 dst = ifa->ifa_dstaddr; 1693 } else { 1694 dst = ifa->ifa_addr; 1695 } 1696 1697 switch (dst->sa_family) { 1698 case AF_INET6: 1699 case AF_INET: 1700 /* We do support multiple FIBs. */ 1701 fib = -1; 1702 break; 1703 } 1704 return (rtinit1(ifa, cmd, flags, fib)); 1705 }
Cache object: 822c64bf587411ec52df9ef54febe148
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]