The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System, Second Edition

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/route.c

Version: -  FREEBSD  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
SearchContext: -  none  -  3  -  10 

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

Cache object: 62404d2123bb16e53d6c23a336f48946


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.