sys/net/route.c

   1 /*
   2  * Copyright (c) 2004, 2005 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Jeffrey M. Hsu.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of The DragonFly Project nor the names of its
  16  *    contributors may be used to endorse or promote products derived
  17  *    from this software without specific, prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  23  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  27  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Copyright (c) 1980, 1986, 1991, 1993
  35  *      The Regents of the University of California.  All rights reserved.
  36  *
  37  * Redistribution and use in source and binary forms, with or without
  38  * modification, are permitted provided that the following conditions
  39  * are met:
  40  * 1. Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in the
  44  *    documentation and/or other materials provided with the distribution.
  45  * 3. Neither the name of the University nor the names of its contributors
  46  *    may be used to endorse or promote products derived from this software
  47  *    without specific prior written permission.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  59  * SUCH DAMAGE.
  60  *
  61  *      @(#)route.c     8.3 (Berkeley) 1/9/95
  62  * $FreeBSD: src/sys/net/route.c,v 1.59.2.10 2003/01/17 08:04:00 ru Exp $
  63  */
  64
  65 #include "opt_inet.h"
  66 #include "opt_mpls.h"
  67
  68 #include <sys/param.h>
  69 #include <sys/systm.h>
  70 #include <sys/malloc.h>
  71 #include <sys/mbuf.h>
  72 #include <sys/socket.h>
  73 #include <sys/domain.h>
  74 #include <sys/kernel.h>
  75 #include <sys/sysctl.h>
  76 #include <sys/globaldata.h>
  77 #include <sys/thread.h>
  78
  79 #include <net/if.h>
  80 #include <net/route.h>
  81 #include <net/netisr.h>
  82
  83 #include <netinet/in.h>
  84 #include <net/ip_mroute/ip_mroute.h>
  85
  86 #include <sys/thread2.h>
  87 #include <sys/msgport2.h>
  88 #include <net/netmsg2.h>
  89
  90 #ifdef MPLS
  91 #include <netproto/mpls/mpls.h>
  92 #endif
  93
  94 static struct rtstatistics rtstatistics_percpu[MAXCPU];
  95 #define rtstat  rtstatistics_percpu[mycpuid]
  96
  97 struct radix_node_head *rt_tables[MAXCPU][AF_MAX+1];
  98 struct lwkt_port *rt_ports[MAXCPU];
  99
 100 static void     rt_maskedcopy (struct sockaddr *, struct sockaddr *,
 101                                struct sockaddr *);
 102 static void rtable_init(void);
 103 static void rtable_service_loop(void *dummy);
 104 static void rtinit_rtrequest_callback(int, int, struct rt_addrinfo *,
 105                                       struct rtentry *, void *);
 106
 107 static void rtredirect_msghandler(netmsg_t msg);
 108 static void rtrequest1_msghandler(netmsg_t msg);
 109 static void rtsearch_msghandler(netmsg_t msg);
 110 static void rtmask_add_msghandler(netmsg_t msg);
 111
 112 static int rt_setshims(struct rtentry *, struct sockaddr **);
 113
 114 SYSCTL_NODE(_net, OID_AUTO, route, CTLFLAG_RW, 0, "Routing");
 115
 116 #ifdef ROUTE_DEBUG
 117 static int route_debug = 1;
 118 SYSCTL_INT(_net_route, OID_AUTO, route_debug, CTLFLAG_RW,
 119            &route_debug, 0, "");
 120 #endif
 121
 122 int route_assert_owner_access = 1;
 123 SYSCTL_INT(_net_route, OID_AUTO, assert_owner_access, CTLFLAG_RW,
 124            &route_assert_owner_access, 0, "");
 125
 126 u_long route_kmalloc_limit = 0;
 127 TUNABLE_ULONG("net.route.kmalloc_limit", &route_kmalloc_limit);
 128
 129 /*
 130  * Initialize the route table(s) for protocol domains and
 131  * create a helper thread which will be responsible for updating
 132  * route table entries on each cpu.
 133  */
 134 void
 135 route_init(void)
 136 {
 137         int cpu;
 138         thread_t rtd;
 139
 140         for (cpu = 0; cpu < ncpus; ++cpu)
 141                 bzero(&rtstatistics_percpu[cpu], sizeof(struct rtstatistics));
 142         rn_init();      /* initialize all zeroes, all ones, mask table */
 143         rtable_init();  /* call dom_rtattach() on each cpu */
 144
 145         for (cpu = 0; cpu < ncpus; cpu++) {
 146                 lwkt_create(rtable_service_loop, NULL, &rtd, NULL,
 147                             0, cpu, "rtable_cpu %d", cpu);
 148                 rt_ports[cpu] = &rtd->td_msgport;
 149         }
 150
 151         if (route_kmalloc_limit)
 152                 kmalloc_raise_limit(M_RTABLE, route_kmalloc_limit);
 153 }
 154
 155 static void
 156 rtable_init_oncpu(netmsg_t msg)
 157 {
 158         struct domain *dom;
 159         int cpu = mycpuid;
 160
 161         SLIST_FOREACH(dom, &domains, dom_next) {
 162                 if (dom->dom_rtattach) {
 163                         dom->dom_rtattach(
 164                                 (void **)&rt_tables[cpu][dom->dom_family],
 165                                 dom->dom_rtoffset);
 166                 }
 167         }
 168         ifnet_forwardmsg(&msg->lmsg, cpu + 1);
 169 }
 170
 171 static void
 172 rtable_init(void)
 173 {
 174         struct netmsg_base msg;
 175
 176         netmsg_init(&msg, NULL, &curthread->td_msgport, 0, rtable_init_oncpu);
 177         ifnet_domsg(&msg.lmsg, 0);
 178 }
 179
 180 /*
 181  * Our per-cpu table management protocol thread.  All route table operations
 182  * are sequentially chained through all cpus starting at cpu #0 in order to
 183  * maintain duplicate route tables on each cpu.  Having a spearate route
 184  * table management thread allows the protocol and interrupt threads to
 185  * issue route table changes.
 186  */
 187 static void
 188 rtable_service_loop(void *dummy __unused)
 189 {
 190         netmsg_base_t msg;
 191         thread_t td = curthread;
 192
 193         while ((msg = lwkt_waitport(&td->td_msgport, 0)) != NULL) {
 194                 msg->nm_dispatch((netmsg_t)msg);
 195         }
 196 }
 197
 198 /*
 199  * Routing statistics.
 200  */
 201 static int
 202 sysctl_rtstatistics(SYSCTL_HANDLER_ARGS)
 203 {
 204         int cpu, error = 0;
 205
 206         for (cpu = 0; cpu < ncpus; ++cpu) {
 207                 if ((error = SYSCTL_OUT(req, &rtstatistics_percpu[cpu],
 208                                         sizeof(struct rtstatistics))))
 209                                 break;
 210                 if ((error = SYSCTL_IN(req, &rtstatistics_percpu[cpu],
 211                                         sizeof(struct rtstatistics))))
 212                                 break;
 213         }
 214
 215         return (error);
 216 }
 217 SYSCTL_PROC(_net_route, OID_AUTO, stats, (CTLTYPE_OPAQUE|CTLFLAG_RW),
 218         0, 0, sysctl_rtstatistics, "S,rtstatistics", "Routing statistics");
 219
 220 /*
 221  * Packet routing routines.
 222  */
 223
 224 /*
 225  * Look up and fill in the "ro_rt" rtentry field in a route structure given
 226  * an address in the "ro_dst" field.  Always send a report on a miss and
 227  * always clone routes.
 228  */
 229 void
 230 rtalloc(struct route *ro)
 231 {
 232         rtalloc_ign(ro, 0UL);
 233 }
 234
 235 /*
 236  * Look up and fill in the "ro_rt" rtentry field in a route structure given
 237  * an address in the "ro_dst" field.  Always send a report on a miss and
 238  * optionally clone routes when RTF_CLONING or RTF_PRCLONING are not being
 239  * ignored.
 240  */
 241 void
 242 rtalloc_ign(struct route *ro, u_long ignoreflags)
 243 {
 244         if (ro->ro_rt != NULL) {
 245                 if (ro->ro_rt->rt_ifp != NULL && ro->ro_rt->rt_flags & RTF_UP)
 246                         return;
 247                 rtfree(ro->ro_rt);
 248                 ro->ro_rt = NULL;
 249         }
 250         ro->ro_rt = _rtlookup(&ro->ro_dst, RTL_REPORTMSG, ignoreflags);
 251 }
 252
 253 /*
 254  * Look up the route that matches the given "dst" address.
 255  *
 256  * Route lookup can have the side-effect of creating and returning
 257  * a cloned route instead when "dst" matches a cloning route and the
 258  * RTF_CLONING and RTF_PRCLONING flags are not being ignored.
 259  *
 260  * Any route returned has its reference count incremented.
 261  */
 262 struct rtentry *
 263 _rtlookup(struct sockaddr *dst, boolean_t generate_report, u_long ignore)
 264 {
 265         struct radix_node_head *rnh = rt_tables[mycpuid][dst->sa_family];
 266         struct rtentry *rt;
 267
 268         if (rnh == NULL)
 269                 goto unreach;
 270
 271         /*
 272          * Look up route in the radix tree.
 273          */
 274         rt = (struct rtentry *) rnh->rnh_matchaddr((char *)dst, rnh);
 275         if (rt == NULL)
 276                 goto unreach;
 277
 278         /*
 279          * Handle cloning routes.
 280          */
 281         if ((rt->rt_flags & ~ignore & (RTF_CLONING | RTF_PRCLONING)) != 0) {
 282                 struct rtentry *clonedroute;
 283                 int error;
 284
 285                 clonedroute = rt;       /* copy in/copy out parameter */
 286                 error = rtrequest(RTM_RESOLVE, dst, NULL, NULL, 0,
 287                                   &clonedroute);        /* clone the route */
 288                 if (error != 0) {       /* cloning failed */
 289                         if (generate_report)
 290                                 rt_dstmsg(RTM_MISS, dst, error);
 291                         rt->rt_refcnt++;
 292                         return (rt);    /* return the uncloned route */
 293                 }
 294                 if (generate_report) {
 295                         if (clonedroute->rt_flags & RTF_XRESOLVE)
 296                                 rt_dstmsg(RTM_RESOLVE, dst, 0);
 297                         else
 298                                 rt_rtmsg(RTM_ADD, clonedroute,
 299                                          clonedroute->rt_ifp, 0);
 300                 }
 301                 return (clonedroute);   /* return cloned route */
 302         }
 303
 304         /*
 305          * Increment the reference count of the matched route and return.
 306          */
 307         rt->rt_refcnt++;
 308         return (rt);
 309
 310 unreach:
 311         rtstat.rts_unreach++;
 312         if (generate_report)
 313                 rt_dstmsg(RTM_MISS, dst, 0);
 314         return (NULL);
 315 }
 316
 317 void
 318 rtfree(struct rtentry *rt)
 319 {
 320         if (rt->rt_cpuid == mycpuid)
 321                 rtfree_oncpu(rt);
 322         else
 323                 rtfree_remote(rt);
 324 }
 325
 326 void
 327 rtfree_oncpu(struct rtentry *rt)
 328 {
 329         KKASSERT(rt->rt_cpuid == mycpuid);
 330         KASSERT(rt->rt_refcnt > 0, ("rtfree: rt_refcnt %ld", rt->rt_refcnt));
 331
 332         --rt->rt_refcnt;
 333         if (rt->rt_refcnt == 0) {
 334                 struct radix_node_head *rnh =
 335                     rt_tables[mycpuid][rt_key(rt)->sa_family];
 336
 337                 if (rnh->rnh_close)
 338                         rnh->rnh_close((struct radix_node *)rt, rnh);
 339                 if (!(rt->rt_flags & RTF_UP)) {
 340                         /* deallocate route */
 341                         if (rt->rt_ifa != NULL)
 342                                 IFAFREE(rt->rt_ifa);
 343                         if (rt->rt_parent != NULL)
 344                                 RTFREE(rt->rt_parent);  /* recursive call! */
 345                         Free(rt_key(rt));
 346                         Free(rt);
 347                 }
 348         }
 349 }
 350
 351 static void
 352 rtfree_remote_dispatch(netmsg_t msg)
 353 {
 354         struct lwkt_msg *lmsg = &msg->lmsg;
 355         struct rtentry *rt = lmsg->u.ms_resultp;
 356
 357         rtfree_oncpu(rt);
 358         lwkt_replymsg(lmsg, 0);
 359 }
 360
 361 void
 362 rtfree_remote(struct rtentry *rt)
 363 {
 364         struct netmsg_base msg;
 365         struct lwkt_msg *lmsg;
 366
 367         KKASSERT(rt->rt_cpuid != mycpuid);
 368
 369         if (route_assert_owner_access) {
 370                 panic("rt remote free rt_cpuid %d, mycpuid %d",
 371                       rt->rt_cpuid, mycpuid);
 372         } else {
 373                 kprintf("rt remote free rt_cpuid %d, mycpuid %d\n",
 374                         rt->rt_cpuid, mycpuid);
 375                 print_backtrace(-1);
 376         }
 377
 378         netmsg_init(&msg, NULL, &curthread->td_msgport,
 379                     0, rtfree_remote_dispatch);
 380         lmsg = &msg.lmsg;
 381         lmsg->u.ms_resultp = rt;
 382
 383         lwkt_domsg(rtable_portfn(rt->rt_cpuid), lmsg, 0);
 384 }
 385
 386 static int
 387 rtredirect_oncpu(struct sockaddr *dst, struct sockaddr *gateway,
 388                  struct sockaddr *netmask, int flags, struct sockaddr *src)
 389 {
 390         struct rtentry *rt = NULL;
 391         struct rt_addrinfo rtinfo;
 392         struct ifaddr *ifa;
 393         u_long *stat = NULL;
 394         int error;
 395
 396         /* verify the gateway is directly reachable */
 397         if ((ifa = ifa_ifwithnet(gateway)) == NULL) {
 398                 error = ENETUNREACH;
 399                 goto out;
 400         }
 401
 402         /*
 403          * If the redirect isn't from our current router for this destination,
 404          * it's either old or wrong.
 405          */
 406         if (!(flags & RTF_DONE) &&              /* XXX JH */
 407             (rt = rtpurelookup(dst)) != NULL &&
 408             (!sa_equal(src, rt->rt_gateway) || rt->rt_ifa != ifa)) {
 409                 error = EINVAL;
 410                 goto done;
 411         }
 412
 413         /*
 414          * If it redirects us to ourselves, we have a routing loop,
 415          * perhaps as a result of an interface going down recently.
 416          */
 417         if (ifa_ifwithaddr(gateway)) {
 418                 error = EHOSTUNREACH;
 419                 goto done;
 420         }
 421
 422         /*
 423          * Create a new entry if the lookup failed or if we got back
 424          * a wildcard entry for the default route.  This is necessary
 425          * for hosts which use routing redirects generated by smart
 426          * gateways to dynamically build the routing tables.
 427          */
 428         if (rt == NULL)
 429                 goto create;
 430         if ((rt_mask(rt) != NULL && rt_mask(rt)->sa_len < 2)) {
 431                 rtfree(rt);
 432                 goto create;
 433         }
 434
 435         /* Ignore redirects for directly connected hosts. */
 436         if (!(rt->rt_flags & RTF_GATEWAY)) {
 437                 error = EHOSTUNREACH;
 438                 goto done;
 439         }
 440
 441         if (!(rt->rt_flags & RTF_HOST) && (flags & RTF_HOST)) {
 442                 /*
 443                  * Changing from a network route to a host route.
 444                  * Create a new host route rather than smashing the
 445                  * network route.
 446                  */
 447 create:
 448                 flags |=  RTF_GATEWAY | RTF_DYNAMIC;
 449                 bzero(&rtinfo, sizeof(struct rt_addrinfo));
 450                 rtinfo.rti_info[RTAX_DST] = dst;
 451                 rtinfo.rti_info[RTAX_GATEWAY] = gateway;
 452                 rtinfo.rti_info[RTAX_NETMASK] = netmask;
 453                 rtinfo.rti_flags = flags;
 454                 rtinfo.rti_ifa = ifa;
 455                 rt = NULL;      /* copy-in/copy-out parameter */
 456                 error = rtrequest1(RTM_ADD, &rtinfo, &rt);
 457                 if (rt != NULL)
 458                         flags = rt->rt_flags;
 459                 stat = &rtstat.rts_dynamic;
 460         } else {
 461                 /*
 462                  * Smash the current notion of the gateway to this destination.
 463                  * Should check about netmask!!!
 464                  */
 465                 rt->rt_flags |= RTF_MODIFIED;
 466                 flags |= RTF_MODIFIED;
 467
 468                 /* We only need to report rtmsg on CPU0 */
 469                 rt_setgate(rt, rt_key(rt), gateway,
 470                            mycpuid == 0 ? RTL_REPORTMSG : RTL_DONTREPORT);
 471                 error = 0;
 472                 stat = &rtstat.rts_newgateway;
 473         }
 474
 475 done:
 476         if (rt != NULL)
 477                 rtfree(rt);
 478 out:
 479         if (error != 0)
 480                 rtstat.rts_badredirect++;
 481         else if (stat != NULL)
 482                 (*stat)++;
 483
 484         return error;
 485 }
 486
 487 struct netmsg_rtredirect {
 488         struct netmsg_base base;
 489         struct sockaddr *dst;
 490         struct sockaddr *gateway;
 491         struct sockaddr *netmask;
 492         int             flags;
 493         struct sockaddr *src;
 494 };
 495
 496 /*
 497  * Force a routing table entry to the specified
 498  * destination to go through the given gateway.
 499  * Normally called as a result of a routing redirect
 500  * message from the network layer.
 501  *
 502  * N.B.: must be called at splnet
 503  */
 504 void
 505 rtredirect(struct sockaddr *dst, struct sockaddr *gateway,
 506            struct sockaddr *netmask, int flags, struct sockaddr *src)
 507 {
 508         struct rt_addrinfo rtinfo;
 509         int error;
 510         struct netmsg_rtredirect msg;
 511
 512         netmsg_init(&msg.base, NULL, &curthread->td_msgport,
 513                     0, rtredirect_msghandler);
 514         msg.dst = dst;
 515         msg.gateway = gateway;
 516         msg.netmask = netmask;
 517         msg.flags = flags;
 518         msg.src = src;
 519         error = lwkt_domsg(rtable_portfn(0), &msg.base.lmsg, 0);
 520         bzero(&rtinfo, sizeof(struct rt_addrinfo));
 521         rtinfo.rti_info[RTAX_DST] = dst;
 522         rtinfo.rti_info[RTAX_GATEWAY] = gateway;
 523         rtinfo.rti_info[RTAX_NETMASK] = netmask;
 524         rtinfo.rti_info[RTAX_AUTHOR] = src;
 525         rt_missmsg(RTM_REDIRECT, &rtinfo, flags, error);
 526 }
 527
 528 static void
 529 rtredirect_msghandler(netmsg_t msg)
 530 {
 531         struct netmsg_rtredirect *rmsg = (void *)msg;
 532         int nextcpu;
 533
 534         rtredirect_oncpu(rmsg->dst, rmsg->gateway, rmsg->netmask,
 535                          rmsg->flags, rmsg->src);
 536         nextcpu = mycpuid + 1;
 537         if (nextcpu < ncpus)
 538                 lwkt_forwardmsg(rtable_portfn(nextcpu), &msg->lmsg);
 539         else
 540                 lwkt_replymsg(&msg->lmsg, 0);
 541 }
 542
 543 /*
 544 * Routing table ioctl interface.
 545 */
 546 int
 547 rtioctl(u_long req, caddr_t data, struct ucred *cred)
 548 {
 549 #ifdef INET
 550         /* Multicast goop, grrr... */
 551         return mrt_ioctl ? mrt_ioctl(req, data) : EOPNOTSUPP;
 552 #else
 553         return ENXIO;
 554 #endif
 555 }
 556
 557 struct ifaddr *
 558 ifa_ifwithroute(int flags, struct sockaddr *dst, struct sockaddr *gateway)
 559 {
 560         struct ifaddr *ifa;
 561
 562         if (!(flags & RTF_GATEWAY)) {
 563                 /*
 564                  * If we are adding a route to an interface,
 565                  * and the interface is a point-to-point link,
 566                  * we should search for the destination
 567                  * as our clue to the interface.  Otherwise
 568                  * we can use the local address.
 569                  */
 570                 ifa = NULL;
 571                 if (flags & RTF_HOST) {
 572                         ifa = ifa_ifwithdstaddr(dst);
 573                 }
 574                 if (ifa == NULL)
 575                         ifa = ifa_ifwithaddr(gateway);
 576         } else {
 577                 /*
 578                  * If we are adding a route to a remote net
 579                  * or host, the gateway may still be on the
 580                  * other end of a pt to pt link.
 581                  */
 582                 ifa = ifa_ifwithdstaddr(gateway);
 583         }
 584         if (ifa == NULL)
 585                 ifa = ifa_ifwithnet(gateway);
 586         if (ifa == NULL) {
 587                 struct rtentry *rt;
 588
 589                 rt = rtpurelookup(gateway);
 590                 if (rt == NULL)
 591                         return (NULL);
 592                 rt->rt_refcnt--;
 593                 if ((ifa = rt->rt_ifa) == NULL)
 594                         return (NULL);
 595         }
 596         if (ifa->ifa_addr->sa_family != dst->sa_family) {
 597                 struct ifaddr *oldifa = ifa;
 598
 599                 ifa = ifaof_ifpforaddr(dst, ifa->ifa_ifp);
 600                 if (ifa == NULL)
 601                         ifa = oldifa;
 602         }
 603         return (ifa);
 604 }
 605
 606 static int rt_fixdelete (struct radix_node *, void *);
 607 static int rt_fixchange (struct radix_node *, void *);
 608
 609 struct rtfc_arg {
 610         struct rtentry *rt0;
 611         struct radix_node_head *rnh;
 612 };
 613
 614 /*
 615  * Set rtinfo->rti_ifa and rtinfo->rti_ifp.
 616  */
 617 int
 618 rt_getifa(struct rt_addrinfo *rtinfo)
 619 {
 620         struct sockaddr *gateway = rtinfo->rti_info[RTAX_GATEWAY];
 621         struct sockaddr *dst = rtinfo->rti_info[RTAX_DST];
 622         struct sockaddr *ifaaddr = rtinfo->rti_info[RTAX_IFA];
 623         int flags = rtinfo->rti_flags;
 624
 625         /*
 626          * ifp may be specified by sockaddr_dl
 627          * when protocol address is ambiguous.
 628          */
 629         if (rtinfo->rti_ifp == NULL) {
 630                 struct sockaddr *ifpaddr;
 631
 632                 ifpaddr = rtinfo->rti_info[RTAX_IFP];
 633                 if (ifpaddr != NULL && ifpaddr->sa_family == AF_LINK) {
 634                         struct ifaddr *ifa;
 635
 636                         ifa = ifa_ifwithnet(ifpaddr);
 637                         if (ifa != NULL)
 638                                 rtinfo->rti_ifp = ifa->ifa_ifp;
 639                 }
 640         }
 641
 642         if (rtinfo->rti_ifa == NULL && ifaaddr != NULL)
 643                 rtinfo->rti_ifa = ifa_ifwithaddr(ifaaddr);
 644         if (rtinfo->rti_ifa == NULL) {
 645                 struct sockaddr *sa;
 646
 647                 sa = ifaaddr != NULL ? ifaaddr :
 648                     (gateway != NULL ? gateway : dst);
 649                 if (sa != NULL && rtinfo->rti_ifp != NULL)
 650                         rtinfo->rti_ifa = ifaof_ifpforaddr(sa, rtinfo->rti_ifp);
 651                 else if (dst != NULL && gateway != NULL)
 652                         rtinfo->rti_ifa = ifa_ifwithroute(flags, dst, gateway);
 653                 else if (sa != NULL)
 654                         rtinfo->rti_ifa = ifa_ifwithroute(flags, sa, sa);
 655         }
 656         if (rtinfo->rti_ifa == NULL)
 657                 return (ENETUNREACH);
 658
 659         if (rtinfo->rti_ifp == NULL)
 660                 rtinfo->rti_ifp = rtinfo->rti_ifa->ifa_ifp;
 661         return (0);
 662 }
 663
 664 /*
 665  * Do appropriate manipulations of a routing tree given
 666  * all the bits of info needed
 667  */
 668 int
 669 rtrequest(
 670         int req,
 671         struct sockaddr *dst,
 672         struct sockaddr *gateway,
 673         struct sockaddr *netmask,
 674         int flags,
 675         struct rtentry **ret_nrt)
 676 {
 677         struct rt_addrinfo rtinfo;
 678
 679         bzero(&rtinfo, sizeof(struct rt_addrinfo));
 680         rtinfo.rti_info[RTAX_DST] = dst;
 681         rtinfo.rti_info[RTAX_GATEWAY] = gateway;
 682         rtinfo.rti_info[RTAX_NETMASK] = netmask;
 683         rtinfo.rti_flags = flags;
 684         return rtrequest1(req, &rtinfo, ret_nrt);
 685 }
 686
 687 int
 688 rtrequest_global(
 689         int req,
 690         struct sockaddr *dst,
 691         struct sockaddr *gateway,
 692         struct sockaddr *netmask,
 693         int flags)
 694 {
 695         struct rt_addrinfo rtinfo;
 696
 697         bzero(&rtinfo, sizeof(struct rt_addrinfo));
 698         rtinfo.rti_info[RTAX_DST] = dst;
 699         rtinfo.rti_info[RTAX_GATEWAY] = gateway;
 700         rtinfo.rti_info[RTAX_NETMASK] = netmask;
 701         rtinfo.rti_flags = flags;
 702         return rtrequest1_global(req, &rtinfo, NULL, NULL);
 703 }
 704
 705 struct netmsg_rtq {
 706         struct netmsg_base      base;
 707         int                     req;
 708         struct rt_addrinfo      *rtinfo;
 709         rtrequest1_callback_func_t callback;
 710         void                    *arg;
 711 };
 712
 713 int
 714 rtrequest1_global(int req, struct rt_addrinfo *rtinfo,
 715                   rtrequest1_callback_func_t callback, void *arg)
 716 {
 717         int error;
 718         struct netmsg_rtq msg;
 719
 720         netmsg_init(&msg.base, NULL, &curthread->td_msgport,
 721                     0, rtrequest1_msghandler);
 722         msg.base.lmsg.ms_error = -1;
 723         msg.req = req;
 724         msg.rtinfo = rtinfo;
 725         msg.callback = callback;
 726         msg.arg = arg;
 727         error = lwkt_domsg(rtable_portfn(0), &msg.base.lmsg, 0);
 728         return (error);
 729 }
 730
 731 /*
 732  * Handle a route table request on the current cpu.  Since the route table's
 733  * are supposed to be identical on each cpu, an error occuring later in the
 734  * message chain is considered system-fatal.
 735  */
 736 static void
 737 rtrequest1_msghandler(netmsg_t msg)
 738 {
 739         struct netmsg_rtq *rmsg = (void *)msg;
 740         struct rt_addrinfo rtinfo;
 741         struct rtentry *rt = NULL;
 742         int nextcpu;
 743         int error;
 744
 745         /*
 746          * Copy the rtinfo.  We need to make sure that the original
 747          * rtinfo, which is setup by the caller, in the netmsg will
 748          * _not_ be changed; else the next CPU on the netmsg forwarding
 749          * path will see a different rtinfo than what this CPU has seen.
 750          */
 751         rtinfo = *rmsg->rtinfo;
 752
 753         error = rtrequest1(rmsg->req, &rtinfo, &rt);
 754         if (rt)
 755                 --rt->rt_refcnt;
 756         if (rmsg->callback)
 757                 rmsg->callback(rmsg->req, error, &rtinfo, rt, rmsg->arg);
 758
 759         /*
 760          * RTM_DELETE's are propogated even if an error occurs, since a
 761          * cloned route might be undergoing deletion and cloned routes
 762          * are not necessarily replicated.  An overall error is returned
 763          * only if no cpus have the route in question.
 764          */
 765         if (rmsg->base.lmsg.ms_error < 0 || error == 0)
 766                 rmsg->base.lmsg.ms_error = error;
 767
 768         nextcpu = mycpuid + 1;
 769         if (error && rmsg->req != RTM_DELETE) {
 770                 if (mycpuid != 0) {
 771                         panic("rtrequest1_msghandler: rtrequest table "
 772                               "error was cpu%d, err %d\n", mycpuid, error);
 773                 }
 774                 lwkt_replymsg(&rmsg->base.lmsg, error);
 775         } else if (nextcpu < ncpus) {
 776                 lwkt_forwardmsg(rtable_portfn(nextcpu), &rmsg->base.lmsg);
 777         } else {
 778                 lwkt_replymsg(&rmsg->base.lmsg, rmsg->base.lmsg.ms_error);
 779         }
 780 }
 781
 782 int
 783 rtrequest1(int req, struct rt_addrinfo *rtinfo, struct rtentry **ret_nrt)
 784 {
 785         struct sockaddr *dst = rtinfo->rti_info[RTAX_DST];
 786         struct rtentry *rt;
 787         struct radix_node *rn;
 788         struct radix_node_head *rnh;
 789         struct ifaddr *ifa;
 790         struct sockaddr *ndst;
 791         boolean_t reportmsg;
 792         int error = 0;
 793
 794 #define gotoerr(x) { error = x ; goto bad; }
 795
 796 #ifdef ROUTE_DEBUG
 797         if (route_debug)
 798                 rt_addrinfo_print(req, rtinfo);
 799 #endif
 800
 801         crit_enter();
 802         /*
 803          * Find the correct routing tree to use for this Address Family
 804          */
 805         if ((rnh = rt_tables[mycpuid][dst->sa_family]) == NULL)
 806                 gotoerr(EAFNOSUPPORT);
 807
 808         /*
 809          * If we are adding a host route then we don't want to put
 810          * a netmask in the tree, nor do we want to clone it.
 811          */
 812         if (rtinfo->rti_flags & RTF_HOST) {
 813                 rtinfo->rti_info[RTAX_NETMASK] = NULL;
 814                 rtinfo->rti_flags &= ~(RTF_CLONING | RTF_PRCLONING);
 815         }
 816
 817         switch (req) {
 818         case RTM_DELETE:
 819                 /* Remove the item from the tree. */
 820                 rn = rnh->rnh_deladdr((char *)rtinfo->rti_info[RTAX_DST],
 821                                       (char *)rtinfo->rti_info[RTAX_NETMASK],
 822                                       rnh);
 823                 if (rn == NULL)
 824                         gotoerr(ESRCH);
 825                 KASSERT(!(rn->rn_flags & (RNF_ACTIVE | RNF_ROOT)),
 826                         ("rnh_deladdr returned flags 0x%x", rn->rn_flags));
 827                 rt = (struct rtentry *)rn;
 828
 829                 /* ref to prevent a deletion race */
 830                 ++rt->rt_refcnt;
 831
 832                 /* Free any routes cloned from this one. */
 833                 if ((rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) &&
 834                     rt_mask(rt) != NULL) {
 835                         rnh->rnh_walktree_from(rnh, (char *)rt_key(rt),
 836                                                (char *)rt_mask(rt),
 837                                                rt_fixdelete, rt);
 838                 }
 839
 840                 if (rt->rt_gwroute != NULL) {
 841                         RTFREE(rt->rt_gwroute);
 842                         rt->rt_gwroute = NULL;
 843                 }
 844
 845                 /*
 846                  * NB: RTF_UP must be set during the search above,
 847                  * because we might delete the last ref, causing
 848                  * rt to get freed prematurely.
 849                  */
 850                 rt->rt_flags &= ~RTF_UP;
 851
 852 #ifdef ROUTE_DEBUG
 853                 if (route_debug)
 854                         rt_print(rtinfo, rt);
 855 #endif
 856
 857                 /* Give the protocol a chance to keep things in sync. */
 858                 if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
 859                         ifa->ifa_rtrequest(RTM_DELETE, rt);
 860
 861                 /*
 862                  * If the caller wants it, then it can have it,
 863                  * but it's up to it to free the rtentry as we won't be
 864                  * doing it.
 865                  */
 866                 KASSERT(rt->rt_refcnt >= 0,
 867                         ("rtrequest1(DELETE): refcnt %ld", rt->rt_refcnt));
 868                 if (ret_nrt != NULL) {
 869                         /* leave ref intact for return */
 870                         *ret_nrt = rt;
 871                 } else {
 872                         /* deref / attempt to destroy */
 873                         rtfree(rt);
 874                 }
 875                 break;
 876
 877         case RTM_RESOLVE:
 878                 if (ret_nrt == NULL || (rt = *ret_nrt) == NULL)
 879                         gotoerr(EINVAL);
 880
 881                 KASSERT(rt->rt_cpuid == mycpuid,
 882                     ("rt resolve rt_cpuid %d, mycpuid %d",
 883                      rt->rt_cpuid, mycpuid));
 884
 885                 ifa = rt->rt_ifa;
 886                 rtinfo->rti_flags =
 887                     rt->rt_flags & ~(RTF_CLONING | RTF_PRCLONING | RTF_STATIC);
 888                 rtinfo->rti_flags |= RTF_WASCLONED;
 889                 rtinfo->rti_info[RTAX_GATEWAY] = rt->rt_gateway;
 890                 if ((rtinfo->rti_info[RTAX_NETMASK] = rt->rt_genmask) == NULL)
 891                         rtinfo->rti_flags |= RTF_HOST;
 892                 rtinfo->rti_info[RTAX_MPLS1] = rt->rt_shim[0];
 893                 rtinfo->rti_info[RTAX_MPLS2] = rt->rt_shim[1];
 894                 rtinfo->rti_info[RTAX_MPLS3] = rt->rt_shim[2];
 895                 goto makeroute;
 896
 897         case RTM_ADD:
 898                 KASSERT(!(rtinfo->rti_flags & RTF_GATEWAY) ||
 899                         rtinfo->rti_info[RTAX_GATEWAY] != NULL,
 900                     ("rtrequest: GATEWAY but no gateway"));
 901
 902                 if (rtinfo->rti_ifa == NULL && (error = rt_getifa(rtinfo)))
 903                         gotoerr(error);
 904                 ifa = rtinfo->rti_ifa;
 905 makeroute:
 906                 R_Malloc(rt, struct rtentry *, sizeof(struct rtentry));
 907                 if (rt == NULL) {
 908                         if (req == RTM_ADD) {
 909                                 kprintf("rtrequest1: alloc rtentry failed on "
 910                                     "cpu%d\n", mycpuid);
 911                         }
 912                         gotoerr(ENOBUFS);
 913                 }
 914                 bzero(rt, sizeof(struct rtentry));
 915                 rt->rt_flags = RTF_UP | rtinfo->rti_flags;
 916                 rt->rt_cpuid = mycpuid;
 917
 918                 if (mycpuid != 0 && req == RTM_ADD) {
 919                         /* For RTM_ADD, we have already sent rtmsg on CPU0. */
 920                         reportmsg = RTL_DONTREPORT;
 921                 } else {
 922                         /*
 923                          * For RTM_ADD, we only send rtmsg on CPU0.
 924                          * For RTM_RESOLVE, we always send rtmsg. XXX
 925                          */
 926                         reportmsg = RTL_REPORTMSG;
 927                 }
 928                 error = rt_setgate(rt, dst, rtinfo->rti_info[RTAX_GATEWAY],
 929                                    reportmsg);
 930                 if (error != 0) {
 931                         Free(rt);
 932                         gotoerr(error);
 933                 }
 934
 935                 ndst = rt_key(rt);
 936                 if (rtinfo->rti_info[RTAX_NETMASK] != NULL)
 937                         rt_maskedcopy(dst, ndst,
 938                                       rtinfo->rti_info[RTAX_NETMASK]);
 939                 else
 940                         bcopy(dst, ndst, dst->sa_len);
 941
 942                 if (rtinfo->rti_info[RTAX_MPLS1] != NULL)
 943                         rt_setshims(rt, rtinfo->rti_info);
 944
 945                 /*
 946                  * Note that we now have a reference to the ifa.
 947                  * This moved from below so that rnh->rnh_addaddr() can
 948                  * examine the ifa and  ifa->ifa_ifp if it so desires.
 949                  */
 950                 IFAREF(ifa);
 951                 rt->rt_ifa = ifa;
 952                 rt->rt_ifp = ifa->ifa_ifp;
 953                 /* XXX mtu manipulation will be done in rnh_addaddr -- itojun */
 954
 955                 rn = rnh->rnh_addaddr((char *)ndst,
 956                                       (char *)rtinfo->rti_info[RTAX_NETMASK],
 957                                       rnh, rt->rt_nodes);
 958                 if (rn == NULL) {
 959                         struct rtentry *oldrt;
 960
 961                         /*
 962                          * We already have one of these in the tree.
 963                          * We do a special hack: if the old route was
 964                          * cloned, then we blow it away and try
 965                          * re-inserting the new one.
 966                          */
 967                         oldrt = rtpurelookup(ndst);
 968                         if (oldrt != NULL) {
 969                                 --oldrt->rt_refcnt;
 970                                 if (oldrt->rt_flags & RTF_WASCLONED) {
 971                                         rtrequest(RTM_DELETE, rt_key(oldrt),
 972                                                   oldrt->rt_gateway,
 973                                                   rt_mask(oldrt),
 974                                                   oldrt->rt_flags, NULL);
 975                                         rn = rnh->rnh_addaddr((char *)ndst,
 976                                             (char *)
 977                                                 rtinfo->rti_info[RTAX_NETMASK],
 978                                             rnh, rt->rt_nodes);
 979                                 }
 980                         }
 981                 }
 982
 983                 /*
 984                  * If it still failed to go into the tree,
 985                  * then un-make it (this should be a function).
 986                  */
 987                 if (rn == NULL) {
 988                         if (rt->rt_gwroute != NULL)
 989                                 rtfree(rt->rt_gwroute);
 990                         IFAFREE(ifa);
 991                         Free(rt_key(rt));
 992                         Free(rt);
 993                         gotoerr(EEXIST);
 994                 }
 995
 996                 /*
 997                  * If we got here from RESOLVE, then we are cloning
 998                  * so clone the rest, and note that we
 999                  * are a clone (and increment the parent's references)
1000                  */
1001                 if (req == RTM_RESOLVE) {
1002                         rt->rt_rmx = (*ret_nrt)->rt_rmx;    /* copy metrics */
1003                         rt->rt_rmx.rmx_pksent = 0;  /* reset packet counter */
1004                         if ((*ret_nrt)->rt_flags &
1005                                        (RTF_CLONING | RTF_PRCLONING)) {
1006                                 rt->rt_parent = *ret_nrt;
1007                                 (*ret_nrt)->rt_refcnt++;
1008                         }
1009                 }
1010
1011                 /*
1012                  * if this protocol has something to add to this then
1013                  * allow it to do that as well.
1014                  */
1015                 if (ifa->ifa_rtrequest != NULL)
1016                         ifa->ifa_rtrequest(req, rt);
1017
1018                 /*
1019                  * We repeat the same procedure from rt_setgate() here because
1020                  * it doesn't fire when we call it there because the node
1021                  * hasn't been added to the tree yet.
1022                  */
1023                 if (req == RTM_ADD && !(rt->rt_flags & RTF_HOST) &&
1024                     rt_mask(rt) != NULL) {
1025                         struct rtfc_arg arg = { rt, rnh };
1026
1027                         rnh->rnh_walktree_from(rnh, (char *)rt_key(rt),
1028                                                (char *)rt_mask(rt),
1029                                                rt_fixchange, &arg);
1030                 }
1031
1032 #ifdef ROUTE_DEBUG
1033                 if (route_debug)
1034                         rt_print(rtinfo, rt);
1035 #endif
1036                 /*
1037                  * Return the resulting rtentry,
1038                  * increasing the number of references by one.
1039                  */
1040                 if (ret_nrt != NULL) {
1041                         rt->rt_refcnt++;
1042                         *ret_nrt = rt;
1043                 }
1044                 break;
1045         default:
1046                 error = EOPNOTSUPP;
1047         }
1048 bad:
1049 #ifdef ROUTE_DEBUG
1050         if (route_debug) {
1051                 if (error)
1052                         kprintf("rti %p failed error %d\n", rtinfo, error);
1053                 else
1054                         kprintf("rti %p succeeded\n", rtinfo);
1055         }
1056 #endif
1057         crit_exit();
1058         return (error);
1059 }
1060
1061 /*
1062  * Called from rtrequest(RTM_DELETE, ...) to fix up the route's ``family''
1063  * (i.e., the routes related to it by the operation of cloning).  This
1064  * routine is iterated over all potential former-child-routes by way of
1065  * rnh->rnh_walktree_from() above, and those that actually are children of
1066  * the late parent (passed in as VP here) are themselves deleted.
1067  */
1068 static int
1069 rt_fixdelete(struct radix_node *rn, void *vp)
1070 {
1071         struct rtentry *rt = (struct rtentry *)rn;
1072         struct rtentry *rt0 = vp;
1073
1074         if (rt->rt_parent == rt0 &&
1075             !(rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
1076                 return rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt),
1077                                  rt->rt_flags, NULL);
1078         }
1079         return 0;
1080 }
1081
1082 /*
1083  * This routine is called from rt_setgate() to do the analogous thing for
1084  * adds and changes.  There is the added complication in this case of a
1085  * middle insert; i.e., insertion of a new network route between an older
1086  * network route and (cloned) host routes.  For this reason, a simple check
1087  * of rt->rt_parent is insufficient; each candidate route must be tested
1088  * against the (mask, value) of the new route (passed as before in vp)
1089  * to see if the new route matches it.
1090  *
1091  * XXX - it may be possible to do fixdelete() for changes and reserve this
1092  * routine just for adds.  I'm not sure why I thought it was necessary to do
1093  * changes this way.
1094  */
1095 #ifdef DEBUG
1096 static int rtfcdebug = 0;
1097 #endif
1098
1099 static int
1100 rt_fixchange(struct radix_node *rn, void *vp)
1101 {
1102         struct rtentry *rt = (struct rtentry *)rn;
1103         struct rtfc_arg *ap = vp;
1104         struct rtentry *rt0 = ap->rt0;
1105         struct radix_node_head *rnh = ap->rnh;
1106         u_char *xk1, *xm1, *xk2, *xmp;
1107         int i, len, mlen;
1108
1109 #ifdef DEBUG
1110         if (rtfcdebug)
1111                 kprintf("rt_fixchange: rt %p, rt0 %p\n", rt, rt0);
1112 #endif
1113
1114         if (rt->rt_parent == NULL ||
1115             (rt->rt_flags & (RTF_PINNED | RTF_CLONING | RTF_PRCLONING))) {
1116 #ifdef DEBUG
1117                 if (rtfcdebug) kprintf("no parent, pinned or cloning\n");
1118 #endif
1119                 return 0;
1120         }
1121
1122         if (rt->rt_parent == rt0) {
1123 #ifdef DEBUG
1124                 if (rtfcdebug) kprintf("parent match\n");
1125 #endif
1126                 return rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt),
1127                                  rt->rt_flags, NULL);
1128         }
1129
1130         /*
1131          * There probably is a function somewhere which does this...
1132          * if not, there should be.
1133          */
1134         len = imin(rt_key(rt0)->sa_len, rt_key(rt)->sa_len);
1135
1136         xk1 = (u_char *)rt_key(rt0);
1137         xm1 = (u_char *)rt_mask(rt0);
1138         xk2 = (u_char *)rt_key(rt);
1139
1140         /* avoid applying a less specific route */
1141         xmp = (u_char *)rt_mask(rt->rt_parent);
1142         mlen = rt_key(rt->rt_parent)->sa_len;
1143         if (mlen > rt_key(rt0)->sa_len) {
1144 #ifdef DEBUG
1145                 if (rtfcdebug)
1146                         kprintf("rt_fixchange: inserting a less "
1147                                "specific route\n");
1148 #endif
1149                 return 0;
1150         }
1151         for (i = rnh->rnh_treetop->rn_offset; i < mlen; i++) {
1152                 if ((xmp[i] & ~(xmp[i] ^ xm1[i])) != xmp[i]) {
1153 #ifdef DEBUG
1154                         if (rtfcdebug)
1155                                 kprintf("rt_fixchange: inserting a less "
1156                                        "specific route\n");
1157 #endif
1158                         return 0;
1159                 }
1160         }
1161
1162         for (i = rnh->rnh_treetop->rn_offset; i < len; i++) {
1163                 if ((xk2[i] & xm1[i]) != xk1[i]) {
1164 #ifdef DEBUG
1165                         if (rtfcdebug) kprintf("no match\n");
1166 #endif
1167                         return 0;
1168                 }
1169         }
1170
1171         /*
1172          * OK, this node is a clone, and matches the node currently being
1173          * changed/added under the node's mask.  So, get rid of it.
1174          */
1175 #ifdef DEBUG
1176         if (rtfcdebug) kprintf("deleting\n");
1177 #endif
1178         return rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt),
1179                          rt->rt_flags, NULL);
1180 }
1181
1182 #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
1183
1184 int
1185 rt_setgate(struct rtentry *rt0, struct sockaddr *dst, struct sockaddr *gate,
1186            boolean_t generate_report)
1187 {
1188         char *space, *oldspace;
1189         int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
1190         struct rtentry *rt = rt0;
1191         struct radix_node_head *rnh = rt_tables[mycpuid][dst->sa_family];
1192
1193         /*
1194          * A host route with the destination equal to the gateway
1195          * will interfere with keeping LLINFO in the routing
1196          * table, so disallow it.
1197          */
1198         if (((rt0->rt_flags & (RTF_HOST | RTF_GATEWAY | RTF_LLINFO)) ==
1199                               (RTF_HOST | RTF_GATEWAY)) &&
1200             dst->sa_len == gate->sa_len &&
1201             sa_equal(dst, gate)) {
1202                 /*
1203                  * The route might already exist if this is an RTM_CHANGE
1204                  * or a routing redirect, so try to delete it.
1205                  */
1206                 if (rt_key(rt0) != NULL)
1207                         rtrequest(RTM_DELETE, rt_key(rt0), rt0->rt_gateway,
1208                                   rt_mask(rt0), rt0->rt_flags, NULL);
1209                 return EADDRNOTAVAIL;
1210         }
1211
1212         /*
1213          * Both dst and gateway are stored in the same malloc'ed chunk
1214          * (If I ever get my hands on....)
1215          * if we need to malloc a new chunk, then keep the old one around
1216          * till we don't need it any more.
1217          */
1218         if (rt->rt_gateway == NULL || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
1219                 oldspace = (char *)rt_key(rt);
1220                 R_Malloc(space, char *, dlen + glen);
1221                 if (space == NULL)
1222                         return ENOBUFS;
1223                 rt->rt_nodes->rn_key = space;
1224         } else {
1225                 space = (char *)rt_key(rt);     /* Just use the old space. */
1226                 oldspace = NULL;
1227         }
1228
1229         /* Set the gateway value. */
1230         rt->rt_gateway = (struct sockaddr *)(space + dlen);
1231         bcopy(gate, rt->rt_gateway, glen);
1232
1233         if (oldspace != NULL) {
1234                 /*
1235                  * If we allocated a new chunk, preserve the original dst.
1236                  * This way, rt_setgate() really just sets the gate
1237                  * and leaves the dst field alone.
1238                  */
1239                 bcopy(dst, space, dlen);
1240                 Free(oldspace);
1241         }
1242
1243         /*
1244          * If there is already a gwroute, it's now almost definitely wrong
1245          * so drop it.
1246          */
1247         if (rt->rt_gwroute != NULL) {
1248                 RTFREE(rt->rt_gwroute);
1249                 rt->rt_gwroute = NULL;
1250         }
1251         if (rt->rt_flags & RTF_GATEWAY) {
1252                 /*
1253                  * Cloning loop avoidance: In the presence of
1254                  * protocol-cloning and bad configuration, it is
1255                  * possible to get stuck in bottomless mutual recursion
1256                  * (rtrequest rt_setgate rtlookup).  We avoid this
1257                  * by not allowing protocol-cloning to operate for
1258                  * gateways (which is probably the correct choice
1259                  * anyway), and avoid the resulting reference loops
1260                  * by disallowing any route to run through itself as
1261                  * a gateway.  This is obviously mandatory when we
1262                  * get rt->rt_output().
1263                  *
1264                  * This breaks TTCP for hosts outside the gateway!  XXX JH
1265                  */
1266                 rt->rt_gwroute = _rtlookup(gate, generate_report,
1267                                            RTF_PRCLONING);
1268                 if (rt->rt_gwroute == rt) {
1269                         rt->rt_gwroute = NULL;
1270                         --rt->rt_refcnt;
1271                         return EDQUOT; /* failure */
1272                 }
1273         }
1274
1275         /*
1276          * This isn't going to do anything useful for host routes, so
1277          * don't bother.  Also make sure we have a reasonable mask
1278          * (we don't yet have one during adds).
1279          */
1280         if (!(rt->rt_flags & RTF_HOST) && rt_mask(rt) != NULL) {
1281                 struct rtfc_arg arg = { rt, rnh };
1282
1283                 rnh->rnh_walktree_from(rnh, (char *)rt_key(rt),
1284                                        (char *)rt_mask(rt),
1285                                        rt_fixchange, &arg);
1286         }
1287
1288         return 0;
1289 }
1290
1291 static void
1292 rt_maskedcopy(
1293         struct sockaddr *src,
1294         struct sockaddr *dst,
1295         struct sockaddr *netmask)
1296 {
1297         u_char *cp1 = (u_char *)src;
1298         u_char *cp2 = (u_char *)dst;
1299         u_char *cp3 = (u_char *)netmask;
1300         u_char *cplim = cp2 + *cp3;
1301         u_char *cplim2 = cp2 + *cp1;
1302
1303         *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
1304         cp3 += 2;
1305         if (cplim > cplim2)
1306                 cplim = cplim2;
1307         while (cp2 < cplim)
1308                 *cp2++ = *cp1++ & *cp3++;
1309         if (cp2 < cplim2)
1310                 bzero(cp2, cplim2 - cp2);
1311 }
1312
1313 int
1314 rt_llroute(struct sockaddr *dst, struct rtentry *rt0, struct rtentry **drt)
1315 {
1316         struct rtentry *up_rt, *rt;
1317
1318         if (!(rt0->rt_flags & RTF_UP)) {
1319                 up_rt = rtlookup(dst);
1320                 if (up_rt == NULL)
1321                         return (EHOSTUNREACH);
1322                 up_rt->rt_refcnt--;
1323         } else
1324                 up_rt = rt0;
1325         if (up_rt->rt_flags & RTF_GATEWAY) {
1326                 if (up_rt->rt_gwroute == NULL) {
1327                         up_rt->rt_gwroute = rtlookup(up_rt->rt_gateway);
1328                         if (up_rt->rt_gwroute == NULL)
1329                                 return (EHOSTUNREACH);
1330                 } else if (!(up_rt->rt_gwroute->rt_flags & RTF_UP)) {
1331                         rtfree(up_rt->rt_gwroute);
1332                         up_rt->rt_gwroute = rtlookup(up_rt->rt_gateway);
1333                         if (up_rt->rt_gwroute == NULL)
1334                                 return (EHOSTUNREACH);
1335                 }
1336                 rt = up_rt->rt_gwroute;
1337         } else
1338                 rt = up_rt;
1339         if (rt->rt_flags & RTF_REJECT &&
1340             (rt->rt_rmx.rmx_expire == 0 ||              /* rt doesn't expire */
1341              time_second < rt->rt_rmx.rmx_expire))      /* rt not expired */
1342                 return (rt->rt_flags & RTF_HOST ?  EHOSTDOWN : EHOSTUNREACH);
1343         *drt = rt;
1344         return 0;
1345 }
1346
1347 static int
1348 rt_setshims(struct rtentry *rt, struct sockaddr **rt_shim){
1349         int i;
1350
1351         for (i=0; i<3; i++) {
1352                 struct sockaddr *shim = rt_shim[RTAX_MPLS1 + i];
1353                 int shimlen;
1354
1355                 if (shim == NULL)
1356                         break;
1357
1358                 shimlen = ROUNDUP(shim->sa_len);
1359                 R_Malloc(rt->rt_shim[i], struct sockaddr *, shimlen);
1360                 bcopy(shim, rt->rt_shim[i], shimlen);
1361         }
1362
1363         return 0;
1364 }
1365
1366 #ifdef ROUTE_DEBUG
1367
1368 /*
1369  * Print out a route table entry
1370  */
1371 void
1372 rt_print(struct rt_addrinfo *rtinfo, struct rtentry *rn)
1373 {
1374         kprintf("rti %p cpu %d route %p flags %08lx: ",
1375                 rtinfo, mycpuid, rn, rn->rt_flags);
1376         sockaddr_print(rt_key(rn));
1377         kprintf(" mask ");
1378         sockaddr_print(rt_mask(rn));
1379         kprintf(" gw ");
1380         sockaddr_print(rn->rt_gateway);
1381         kprintf(" ifc \"%s\"", rn->rt_ifp ? rn->rt_ifp->if_dname : "?");
1382         kprintf(" ifa %p\n", rn->rt_ifa);
1383 }
1384
1385 void
1386 rt_addrinfo_print(int cmd, struct rt_addrinfo *rti)
1387 {
1388         int didit = 0;
1389         int i;
1390
1391 #ifdef ROUTE_DEBUG
1392         if (cmd == RTM_DELETE && route_debug > 1)
1393                 print_backtrace(-1);
1394 #endif
1395
1396         switch(cmd) {
1397         case RTM_ADD:
1398                 kprintf("ADD ");
1399                 break;
1400         case RTM_RESOLVE:
1401                 kprintf("RES ");
1402                 break;
1403         case RTM_DELETE:
1404                 kprintf("DEL ");
1405                 break;
1406         default:
1407                 kprintf("C%02d ", cmd);
1408                 break;
1409         }
1410         kprintf("rti %p cpu %d ", rti, mycpuid);
1411         for (i = 0; i < rti->rti_addrs; ++i) {
1412                 if (rti->rti_info[i] == NULL)
1413                         continue;
1414                 if (didit)
1415                         kprintf(" ,");
1416                 switch(i) {
1417                 case RTAX_DST:
1418                         kprintf("(DST ");
1419                         break;
1420                 case RTAX_GATEWAY:
1421                         kprintf("(GWY ");
1422                         break;
1423                 case RTAX_NETMASK:
1424                         kprintf("(MSK ");
1425                         break;
1426                 case RTAX_GENMASK:
1427                         kprintf("(GEN ");
1428                         break;
1429                 case RTAX_IFP:
1430                         kprintf("(IFP ");
1431                         break;
1432                 case RTAX_IFA:
1433                         kprintf("(IFA ");
1434                         break;
1435                 case RTAX_AUTHOR:
1436                         kprintf("(AUT ");
1437                         break;
1438                 case RTAX_BRD:
1439                         kprintf("(BRD ");
1440                         break;
1441                 default:
1442                         kprintf("(?%02d ", i);
1443                         break;
1444                 }
1445                 sockaddr_print(rti->rti_info[i]);
1446                 kprintf(")");
1447                 didit = 1;
1448         }
1449         kprintf("\n");
1450 }
1451
1452 void
1453 sockaddr_print(struct sockaddr *sa)
1454 {
1455         struct sockaddr_in *sa4;
1456         struct sockaddr_in6 *sa6;
1457         int len;
1458         int i;
1459
1460         if (sa == NULL) {
1461                 kprintf("NULL");
1462                 return;
1463         }
1464
1465         len = sa->sa_len - offsetof(struct sockaddr, sa_data[0]);
1466
1467         switch(sa->sa_family) {
1468         case AF_INET:
1469         case AF_INET6:
1470         default:
1471                 switch(sa->sa_family) {
1472                 case AF_INET:
1473                         sa4 = (struct sockaddr_in *)sa;
1474                         kprintf("INET %d %d.%d.%d.%d",
1475                                 ntohs(sa4->sin_port),
1476                                 (ntohl(sa4->sin_addr.s_addr) >> 24) & 255,
1477                                 (ntohl(sa4->sin_addr.s_addr) >> 16) & 255,
1478                                 (ntohl(sa4->sin_addr.s_addr) >> 8) & 255,
1479                                 (ntohl(sa4->sin_addr.s_addr) >> 0) & 255
1480                         );
1481                         break;
1482                 case AF_INET6:
1483                         sa6 = (struct sockaddr_in6 *)sa;
1484                         kprintf("INET6 %d %04x:%04x%04x:%04x:%04x:%04x:%04x:%04x",
1485                                 ntohs(sa6->sin6_port),
1486                                 sa6->sin6_addr.s6_addr16[0],
1487                                 sa6->sin6_addr.s6_addr16[1],
1488                                 sa6->sin6_addr.s6_addr16[2],
1489                                 sa6->sin6_addr.s6_addr16[3],
1490                                 sa6->sin6_addr.s6_addr16[4],
1491                                 sa6->sin6_addr.s6_addr16[5],
1492                                 sa6->sin6_addr.s6_addr16[6],
1493                                 sa6->sin6_addr.s6_addr16[7]
1494                         );
1495                         break;
1496                 default:
1497                         kprintf("AF%d ", sa->sa_family);
1498                         while (len > 0 && sa->sa_data[len-1] == 0)
1499                                 --len;
1500
1501                         for (i = 0; i < len; ++i) {
1502                                 if (i)
1503                                         kprintf(".");
1504                                 kprintf("%d", (unsigned char)sa->sa_data[i]);
1505                         }
1506                         break;
1507                 }
1508         }
1509 }
1510
1511 #endif
1512
1513 /*
1514  * Set up a routing table entry, normally for an interface.
1515  */
1516 int
1517 rtinit(struct ifaddr *ifa, int cmd, int flags)
1518 {
1519         struct sockaddr *dst, *deldst, *netmask;
1520         struct mbuf *m = NULL;
1521         struct radix_node_head *rnh;
1522         struct radix_node *rn;
1523         struct rt_addrinfo rtinfo;
1524         int error;
1525
1526         if (flags & RTF_HOST) {
1527                 dst = ifa->ifa_dstaddr;
1528                 netmask = NULL;
1529         } else {
1530                 dst = ifa->ifa_addr;
1531                 netmask = ifa->ifa_netmask;
1532         }
1533         /*
1534          * If it's a delete, check that if it exists, it's on the correct
1535          * interface or we might scrub a route to another ifa which would
1536          * be confusing at best and possibly worse.
1537          */
1538         if (cmd == RTM_DELETE) {
1539                 /*
1540                  * It's a delete, so it should already exist..
1541                  * If it's a net, mask off the host bits
1542                  * (Assuming we have a mask)
1543                  */
1544                 if (netmask != NULL) {
1545                         m = m_get(MB_DONTWAIT, MT_SONAME);
1546                         if (m == NULL)
1547                                 return (ENOBUFS);
1548                         mbuftrackid(m, 34);
1549                         deldst = mtod(m, struct sockaddr *);
1550                         rt_maskedcopy(dst, deldst, netmask);
1551                         dst = deldst;
1552                 }
1553                 /*
1554                  * Look up an rtentry that is in the routing tree and
1555                  * contains the correct info.
1556                  */
1557                 if ((rnh = rt_tables[mycpuid][dst->sa_family]) == NULL ||
1558                     (rn = rnh->rnh_lookup((char *)dst,
1559                                           (char *)netmask, rnh)) == NULL ||
1560                     ((struct rtentry *)rn)->rt_ifa != ifa ||
1561                     !sa_equal((struct sockaddr *)rn->rn_key, dst)) {
1562                         if (m != NULL)
1563                                 m_free(m);
1564                         return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
1565                 }
1566                 /* XXX */
1567 #if 0
1568                 else {
1569                         /*
1570                          * One would think that as we are deleting, and we know
1571                          * it doesn't exist, we could just return at this point
1572                          * with an "ELSE" clause, but apparently not..
1573                          */
1574                         return (flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH);
1575                 }
1576 #endif
1577         }
1578         /*
1579          * Do the actual request
1580          */
1581         bzero(&rtinfo, sizeof(struct rt_addrinfo));
1582         rtinfo.rti_info[RTAX_DST] = dst;
1583         rtinfo.rti_info[RTAX_GATEWAY] = ifa->ifa_addr;
1584         rtinfo.rti_info[RTAX_NETMASK] = netmask;
1585         rtinfo.rti_flags = flags | ifa->ifa_flags;
1586         rtinfo.rti_ifa = ifa;
1587         error = rtrequest1_global(cmd, &rtinfo, rtinit_rtrequest_callback, ifa);
1588         if (m != NULL)
1589                 m_free(m);
1590         return (error);
1591 }
1592
1593 static void
1594 rtinit_rtrequest_callback(int cmd, int error,
1595                           struct rt_addrinfo *rtinfo, struct rtentry *rt,
1596                           void *arg)
1597 {
1598         struct ifaddr *ifa = arg;
1599
1600         if (error == 0 && rt) {
1601                 if (mycpuid == 0) {
1602                         ++rt->rt_refcnt;
1603                         rt_newaddrmsg(cmd, ifa, error, rt);
1604                         --rt->rt_refcnt;
1605                 }
1606                 if (cmd == RTM_DELETE) {
1607                         if (rt->rt_refcnt == 0) {
1608                                 ++rt->rt_refcnt;
1609                                 rtfree(rt);
1610                         }
1611                 }
1612         }
1613 }
1614
1615 struct netmsg_rts {
1616         struct netmsg_base      base;
1617         int                     req;
1618         struct rt_addrinfo      *rtinfo;
1619         rtsearch_callback_func_t callback;
1620         void                    *arg;
1621         boolean_t               exact_match;
1622         int                     found_cnt;
1623 };
1624
1625 int
1626 rtsearch_global(int req, struct rt_addrinfo *rtinfo,
1627                 rtsearch_callback_func_t callback, void *arg,
1628                 boolean_t exact_match)
1629 {
1630         struct netmsg_rts msg;
1631
1632         netmsg_init(&msg.base, NULL, &curthread->td_msgport,
1633                     0, rtsearch_msghandler);
1634         msg.req = req;
1635         msg.rtinfo = rtinfo;
1636         msg.callback = callback;
1637         msg.arg = arg;
1638         msg.exact_match = exact_match;
1639         msg.found_cnt = 0;
1640         return lwkt_domsg(rtable_portfn(0), &msg.base.lmsg, 0);
1641 }
1642
1643 static void
1644 rtsearch_msghandler(netmsg_t msg)
1645 {
1646         struct netmsg_rts *rmsg = (void *)msg;
1647         struct rt_addrinfo rtinfo;
1648         struct radix_node_head *rnh;
1649         struct rtentry *rt;
1650         int nextcpu, error;
1651
1652         /*
1653          * Copy the rtinfo.  We need to make sure that the original
1654          * rtinfo, which is setup by the caller, in the netmsg will
1655          * _not_ be changed; else the next CPU on the netmsg forwarding
1656          * path will see a different rtinfo than what this CPU has seen.
1657          */
1658         rtinfo = *rmsg->rtinfo;
1659
1660         /*
1661          * Find the correct routing tree to use for this Address Family
1662          */
1663         if ((rnh = rt_tables[mycpuid][rtinfo.rti_dst->sa_family]) == NULL) {
1664                 if (mycpuid != 0)
1665                         panic("partially initialized routing tables");
1666                 lwkt_replymsg(&rmsg->base.lmsg, EAFNOSUPPORT);
1667                 return;
1668         }
1669
1670         /*
1671          * Correct rtinfo for the host route searching.
1672          */
1673         if (rtinfo.rti_flags & RTF_HOST) {
1674                 rtinfo.rti_netmask = NULL;
1675                 rtinfo.rti_flags &= ~(RTF_CLONING | RTF_PRCLONING);
1676         }
1677
1678         rt = (struct rtentry *)
1679              rnh->rnh_lookup((char *)rtinfo.rti_dst,
1680                              (char *)rtinfo.rti_netmask, rnh);
1681
1682         /*
1683          * If we are asked to do the "exact match", we need to make sure
1684          * that host route searching got a host route while a network
1685          * route searching got a network route.
1686          */
1687         if (rt != NULL && rmsg->exact_match &&
1688             ((rt->rt_flags ^ rtinfo.rti_flags) & RTF_HOST))
1689                 rt = NULL;
1690
1691         if (rt == NULL) {
1692                 /*
1693                  * No matching routes have been found, don't count this
1694                  * as a critical error (here, we set 'error' to 0), just
1695                  * keep moving on, since at least prcloned routes are not
1696                  * duplicated onto each CPU.
1697                  */
1698                 error = 0;
1699         } else {
1700                 rmsg->found_cnt++;
1701
1702                 rt->rt_refcnt++;
1703                 error = rmsg->callback(rmsg->req, &rtinfo, rt, rmsg->arg,
1704                                       rmsg->found_cnt);
1705                 rt->rt_refcnt--;
1706
1707                 if (error == EJUSTRETURN) {
1708                         lwkt_replymsg(&rmsg->base.lmsg, 0);
1709                         return;
1710                 }
1711         }
1712
1713         nextcpu = mycpuid + 1;
1714         if (error) {
1715                 KKASSERT(rmsg->found_cnt > 0);
1716
1717                 /*
1718                  * Under following cases, unrecoverable error has
1719                  * not occured:
1720                  * o  Request is RTM_GET
1721                  * o  The first time that we find the route, but the
1722                  *    modification fails.
1723                  */
1724                 if (rmsg->req != RTM_GET && rmsg->found_cnt > 1) {
1725                         panic("rtsearch_msghandler: unrecoverable error "
1726                               "cpu %d", mycpuid);
1727                 }
1728                 lwkt_replymsg(&rmsg->base.lmsg, error);
1729         } else if (nextcpu < ncpus) {
1730                 lwkt_forwardmsg(rtable_portfn(nextcpu), &rmsg->base.lmsg);
1731         } else {
1732                 if (rmsg->found_cnt == 0) {
1733                         /* The requested route was never seen ... */
1734                         error = ESRCH;
1735                 }
1736                 lwkt_replymsg(&rmsg->base.lmsg, error);
1737         }
1738 }
1739
1740 int
1741 rtmask_add_global(struct sockaddr *mask)
1742 {
1743         struct netmsg_base msg;
1744
1745         netmsg_init(&msg, NULL, &curthread->td_msgport,
1746                     0, rtmask_add_msghandler);
1747         msg.lmsg.u.ms_resultp = mask;
1748
1749         return lwkt_domsg(rtable_portfn(0), &msg.lmsg, 0);
1750 }
1751
1752 struct sockaddr *
1753 _rtmask_lookup(struct sockaddr *mask, boolean_t search)
1754 {
1755         struct radix_node *n;
1756
1757 #define clen(s) (*(u_char *)(s))
1758         n = rn_addmask((char *)mask, search, 1, rn_cpumaskhead(mycpuid));
1759         if (n != NULL &&
1760             mask->sa_len >= clen(n->rn_key) &&
1761             bcmp((char *)mask + 1,
1762                  (char *)n->rn_key + 1, clen(n->rn_key) - 1) == 0) {
1763                 return (struct sockaddr *)n->rn_key;
1764         } else {
1765                 return NULL;
1766         }
1767 #undef clen
1768 }
1769
1770 static void
1771 rtmask_add_msghandler(netmsg_t msg)
1772 {
1773         struct lwkt_msg *lmsg = &msg->lmsg;
1774         struct sockaddr *mask = lmsg->u.ms_resultp;
1775         int error = 0, nextcpu;
1776
1777         if (rtmask_lookup(mask) == NULL)
1778                 error = ENOBUFS;
1779
1780         nextcpu = mycpuid + 1;
1781         if (!error && nextcpu < ncpus)
1782                 lwkt_forwardmsg(rtable_portfn(nextcpu), lmsg);
1783         else
1784                 lwkt_replymsg(lmsg, error);
1785 }
1786
1787 /* This must be before ip6_init2(), which is now SI_ORDER_MIDDLE */
1788 SYSINIT(route, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, route_init, 0);
1789
1790 struct rtchange_arg {
1791         struct ifaddr   *old_ifa;
1792         struct ifaddr   *new_ifa;
1793         struct rtentry  *rt;
1794         int             changed;
1795 };
1796
1797 static void
1798 rtchange_ifa(struct rtentry *rt, struct rtchange_arg *ap)
1799 {
1800         if (rt->rt_ifa->ifa_rtrequest != NULL)
1801                 rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt);
1802         IFAFREE(rt->rt_ifa);
1803
1804         IFAREF(ap->new_ifa);
1805         rt->rt_ifa = ap->new_ifa;
1806         rt->rt_ifp = ap->new_ifa->ifa_ifp;
1807         if (rt->rt_ifa->ifa_rtrequest != NULL)
1808                 rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt);
1809
1810         ap->changed = 1;
1811 }
1812
1813 static int
1814 rtchange_callback(struct radix_node *rn, void *xap)
1815 {
1816         struct rtchange_arg *ap = xap;
1817         struct rtentry *rt = (struct rtentry *)rn;
1818
1819         if (rt->rt_ifa == ap->old_ifa) {
1820                 if (rt->rt_flags & (RTF_CLONING | RTF_PRCLONING)) {
1821                         /*
1822                          * We could saw the branch off when we are
1823                          * still sitting on it, if the ifa_rtrequest
1824                          * DEL/ADD are called directly from here.
1825                          */
1826                         ap->rt = rt;
1827                         return EJUSTRETURN;
1828                 }
1829                 rtchange_ifa(rt, ap);
1830         }
1831         return 0;
1832 }
1833
1834 struct netmsg_rtchange {
1835         struct netmsg_base      base;
1836         struct ifaddr           *old_ifa;
1837         struct ifaddr           *new_ifa;
1838         int                     changed;
1839 };
1840
1841 static void
1842 rtchange_dispatch(netmsg_t msg)
1843 {
1844         struct netmsg_rtchange *rmsg = (void *)msg;
1845         struct radix_node_head *rnh;
1846         struct rtchange_arg arg;
1847         int nextcpu, cpu;
1848
1849         cpu = mycpuid;
1850
1851         memset(&arg, 0, sizeof(arg));
1852         arg.old_ifa = rmsg->old_ifa;
1853         arg.new_ifa = rmsg->new_ifa;
1854
1855         rnh = rt_tables[cpu][AF_INET];
1856         for (;;) {
1857                 int error;
1858
1859                 KKASSERT(arg.rt == NULL);
1860                 error = rnh->rnh_walktree(rnh, rtchange_callback, &arg);
1861                 if (arg.rt != NULL) {
1862                         struct rtentry *rt;
1863
1864                         rt = arg.rt;
1865                         arg.rt = NULL;
1866                         rtchange_ifa(rt, &arg);
1867                 } else {
1868                         break;
1869                 }
1870         }
1871         if (arg.changed)
1872                 rmsg->changed = 1;
1873
1874         nextcpu = cpu + 1;
1875         if (nextcpu < ncpus)
1876                 lwkt_forwardmsg(rtable_portfn(nextcpu), &rmsg->base.lmsg);
1877         else
1878                 lwkt_replymsg(&rmsg->base.lmsg, 0);
1879 }
1880
1881 int
1882 rtchange(struct ifaddr *old_ifa, struct ifaddr *new_ifa)
1883 {
1884         struct netmsg_rtchange msg;
1885
1886         /*
1887          * XXX individual requests are not independantly chained,
1888          * which means that the per-cpu route tables will not be
1889          * consistent in the middle of the operation.  If routes
1890          * related to the interface are manipulated while we are
1891          * doing this the inconsistancy could trigger a panic.
1892          */
1893         netmsg_init(&msg.base, NULL, &curthread->td_msgport, 0,
1894             rtchange_dispatch);
1895         msg.old_ifa = old_ifa;
1896         msg.new_ifa = new_ifa;
1897         msg.changed = 0;
1898         KASSERT(&curthread->td_msgport != rtable_portfn(0),
1899             ("rtchange in rtable thread"));
1900         lwkt_domsg(rtable_portfn(0), &msg.base.lmsg, 0);
1901
1902         if (msg.changed) {
1903                 old_ifa->ifa_flags &= ~IFA_ROUTE;
1904                 new_ifa->ifa_flags |= IFA_ROUTE;
1905                 return 0;
1906         } else {
1907                 return ENOENT;
1908         }
1909 }