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