开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
route.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：59k
源码类别：

VxWorks

开发平台：

C/C++

route.c：源码内容
  1. /* route.c - packet routing routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1980, 1986, 1991, 1993
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  * This product includes software developed by the University of
  21.  * California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * @(#)route.c 8.3 (Berkeley) 1/9/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01s,14mar02,vvv  fixed route addition check for dest=gateway in rt_setgate
  45.  (SPR #74244)
  46. 01r,24jan02,niq  fixed call to new address message hook (SPR #71670)
  47. 01q,03jan02,vvv  added check for rt_setgate return value in rtredirect 
  48.  (SPR #71518)
  49. 01p,05dec01,vvv  fixed NT simulator exception (SPR #71659)
  50. 01o,12oct01,rae  merge from truestack ver 02e, base 01l (SPR #69683 etc.)
  51. 01n,20feb01,ijm  corrected additional bug in rtalloc1.  Precedence bits
  52.  must be cleared before searching the table.
  53. 01m,02nov00,ijm  fixed rtalloc1 TOS bug, SPR# 30195
  54. 01l,04mar99,spm  fixed errors in SPR #23301 fix causing build failures
  55. 01k,02mar99,spm  eliminated EEXIST error caused by ARP entries (SPR #23301)
  56. 01j,26aug98,n_s  added return val check for mBufClGet in rtinit. spr #22238.
  57. 01i,07jul97,rjc  newer version of rtentry incorporated.
  58. 01h,01jul97,vin  added route socket message hooks for scalability, fixed
  59.  warnings.
  60. 01g,30jun97,rjc  restored old rtentry size.
  61. 01f,03jun97,rjc  netmask with RTF_HOST set to 0.
  62. 01e,13feb97,rjc  more changes for tos routing,
  63. 01e,05feb97,rjc  changes for tos routing,
  64. 01d,05dec96,vin  moved ifafree() to if.c
  65. 01c,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
  66. 01b,24sep96,vin  rtioctl() fixed for multicast addresses.
  67. 01a,03mar96,vin  created from BSD4.4 stuff. added rtioctl for backward
  68.  compatibility. moved ifa_ifwithroute() to if.c.
  69. */
  71. #include "vxWorks.h"
  72. #include "logLib.h"
  73. #include "sysLib.h"
  74. #include "wdLib.h"
  75. #include "net/mbuf.h"
  76. #include "net/domain.h"
  77. #include "net/protosw.h"
  78. #include "sys/socket.h"
  79. #include "sys/ioctl.h"
  80. #include "net/socketvar.h"
  81. #include "errno.h"
  83. #include "net/if.h"
  84. #include "net/if_types.h"
  85. #include "net/route.h"
  86. #include "net/systm.h"
  87. #include "net/raw_cb.h"
  89. #include "routeEnhLib.h"
  91. #include "netinet/in.h"
  92. #include "netinet/in_var.h"
  94. #ifdef VIRTUAL_STACK
  95. #include "netinet/vsLib.h"
  96. #endif
  98. #ifdef NS
  99. #include <netns/ns.h>
  100. #endif
  102. #ifdef WV_INSTRUMENTATION
  103. #ifdef INCLUDE_WVNET
  104. #include "wvNetLib.h"
  105. #endif
  106. #endif
  109. #ifdef RTALLOC_DEBUG
  110. #include "stdio.h"
  111. #include "net/if_dl.h"
  112. #include "inetLib.h"
  113. LOCAL int routeEntryDebugShow (struct radix_node * newrt);
  114. #endif /* RTALLOC_DEBUG */
  116. /* externs */
  117. int tickGet();
  119. #define SA(p) ((struct sockaddr *)(p))
  120. #define SOCKADDR_IN(s) (((struct sockaddr_in*)(s))->sin_addr.s_addr)
  122. #define ROUTE_KILL_FREQUENCY 600    /* Check for old routes every 10 minutes */
  123. #define ROUTE_PEND_MAXIMUM  3600    /* Remove old routes after 1 hour (max). */
  124. #define ROUTE_PEND_MINIMUM  10      /* 10 second minimum for old routes. */
  126. #ifndef VIRTUAL_STACK
  127. struct rtstat rtstat;
  128. struct radix_node_head *rt_tables[AF_MAX+1];
  129. #endif
  131. struct rtqk_arg
  132.     {
  133.     struct radix_node_head *rnh;
  134.     int draining;
  135.     int killed;
  136.     int found;
  137.     int updating;
  138.     ULONG nextstop;
  139.     };
  141. #ifndef VIRTUAL_STACK
  142. int rttrash; /* routes not in table but not freed */
  143. int     rtmodified = 0;  /* route table modified */
  144. struct sockaddr wildcard;  /* zero valued cookie for wildcard searches */
  146. LOCAL WDOG_ID routeKillTimer;  /* Schedules removal of expired routes. */
  147. LOCAL ULONG routeKillInterval;  /* Removal frequency, in ticks. */
  149. LOCAL int routePendInterval;  /* Time to keep unused routes, in ticks. */
  150. LOCAL int routePendMinimum;  /* Minimum preservation time. */
  152. LOCAL int routePendLimit = 128;    /*
  153.                                     * Number of unused routes before
  154.                                     * reduced removal time.
  155.                                     */
  157. LOCAL int routeExpireChange = 0;
  158.                                    /* Most recent removal time adjustment. */
  159. #endif
  161. struct radix_node * routeSwap (struct radix_node_head *, struct rtentry *,
  162.                                struct sockaddr *, struct sockaddr *);
  164. #ifdef WV_INSTRUMENTATION
  165. #ifdef INCLUDE_WVNET
  166.     /* Set common fields of event identifiers for this module. */
  168. LOCAL UCHAR wvNetModuleId = WV_NET_ROUTE_MODULE;   /* Value for route.c */
  169. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  171. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  172. #endif    /* INCLUDE_WVNET */
  173. #endif
  175. LOCAL void routeKillCheck (void);
  176. LOCAL int routeUpdate (struct radix_node *, void *);
  178. IMPORT STATUS   netJobAdd (FUNCPTR routine, int param1, int param2, int param3,
  179.                            int param4, int param5);
  181. #ifndef VIRTUAL_STACK
  182. /*
  183.  * The routeStorageCreate routine replaces this version with an implementation
  184.  * to initialize radix trees for a virtual stack.
  185.  */
  187. void
  188. rtable_init(table)
  189. void **table;
  190. {
  191. struct domain *dom;
  192. for (dom = domains; dom; dom = dom->dom_next)
  193. if (dom->dom_rtattach)
  194. dom->dom_rtattach(&table[dom->dom_family],
  195.     dom->dom_rtoffset);
  196. }
  197. #endif
  199. #ifdef VIRTUAL_STACK
  200. /*******************************************************************************
  201. *
  202. * routeStorageCreate - initialize the routing database
  203. *
  204. * This routine sets up the radix tree and initializes the routing storage
  205. * for addresses in the AF_INET family. It mimics the more generic route_init
  206. * routine which uses the domains list to create storage for any address
  207. * type. That original routine can be compiled and used if support for
  208. * other domains is needed.
  209. *
  210. * INTERNAL
  211. * Currently, this routine assumes that the caller has assigned the
  212. * correct virtual stack number allowing creation of isolated routing storage.
  213. * That process could occur internally (with the stack number as an argument)
  214. * if that approach is more convenient.
  215. *
  216. * RETURNS: OK, or ERROR if initialization failed.
  217. */
  219. STATUS routeStorageCreate (void)
  220.     {
  221.     VS_RADIX * pGlobals;
  222.     STATUS result;
  224.     pGlobals = malloc (sizeof (VS_RADIX));
  225.     if (pGlobals == NULL)
  226.         return (ERROR);
  228.     bzero ( (char *)pGlobals, sizeof (VS_RADIX));
  230.     vsTbl [myStackNum]->pRadixGlobals = pGlobals;
  232.     /*
  233.      * The radixInit() routine replaces the rn_init() routine to avoid access
  234.      * to the (currently non-virtualized) "domains" global.
  235.      */
  237.     result = radixInit (); /* initialize all zeroes, all ones, mask table */
  238.     if (result == ERROR)
  239.         {
  240.         free (pGlobals);
  241.         return (ERROR);
  242.         }
  244.    /*
  245.     * Setup any routing tables required for the available domains. 
  246.     * Originally, this initialization routine executed indirectly
  247.     * through the rtable_init() routine which searched the domains
  248.     * list. This process skips that search since the only applicable
  249.     * entry involves AF_INET addresses with an offset of 27 bits
  250.     * (originally 32). The original offset skips the length, family,
  251.     * and port fields in a sockaddr_in structure. The adjusted offset
  252.     * examines five additional bits to incorporate TOS values into
  253.     * routing lookups.
  254.     *
  255.     * NOTE: The original route_init() routine (if compiled and used)
  256.     * will use the rtable_init() routine to complete the routing
  257.     * storage setup for other domains, if that capability is necessary.
  258.     */
  260.     result = rn_inithead (&rt_tables[AF_INET], 27);
  261.     if (result == 0)
  262.         {
  263.         /* Tree creation failed: release allocated memory and return. */
  265.         Free (rn_zeros);
  266.         Free (mask_rnhead);
  268.         free (pGlobals);
  270.         return (ERROR);
  271.         }
  273.     routeKillTimer = wdCreate ();
  274.     if (routeKillTimer == NULL)
  275.         {
  276.         Free (rn_zeros);
  277.         Free (mask_rnhead);
  278.         Free (rt_tables[AF_INET]);
  280.         free (pGlobals);
  282.         return (ERROR);
  283.         }
  285.     routeKillInterval = sysClkRateGet() * ROUTE_KILL_FREQUENCY;
  286.     routePendInterval = sysClkRateGet() * ROUTE_PEND_MAXIMUM;
  287.     routePendMinimum = sysClkRateGet() * ROUTE_PEND_MINIMUM;
  289.     wdStart (routeKillTimer, routeKillInterval, netJobAdd,
  290.              (int)routeKillCheck);
  292.     return (OK);
  293.     }
  294. #else
  295. /*
  296.  * The routeStorageCreate routine replaces this version with an implementation
  297.  * which creates an isolated set of (previously global) variables for a single
  298.  * virtual stack.
  299.  */
  301. int
  302. route_init()
  303. {
  304. #ifdef WV_INSTRUMENTATION
  305. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  306.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 33, 13,
  307.                      WV_NETEVENT_ROUTEINIT_START)
  308. #endif  /* INCLUDE_WVNET */
  309. #endif
  311. rn_init(); /* initialize all zeroes, all ones, mask table */
  312. rtable_init((void **)rt_tables);
  314.         routeKillTimer = wdCreate ();
  315.         if (routeKillTimer == NULL)
  316.             return (ERROR);
  318.         routeKillInterval = sysClkRateGet() * ROUTE_KILL_FREQUENCY;
  319.         routePendInterval = sysClkRateGet() * ROUTE_PEND_MAXIMUM;
  320.         routePendMinimum = sysClkRateGet() * ROUTE_PEND_MINIMUM;
  322.         wdStart (routeKillTimer, routeKillInterval, netJobAdd, (int) routeKillCheck);
  324. return (OK);
  325. }
  326. #endif
  328. /*
  329.  * Look for cloned routes to remote destinations which are no longer in
  330.  * use. Remove any expired route entries.
  331.  */
  333. void routeKillCheck (void)
  334.     {
  335.     struct radix_node_head *pHead;
  336.     struct rtqk_arg   count;
  337.     int s;
  339.     ULONG now;
  341.     pHead = rt_tables [AF_INET];
  343.     if (pHead == NULL)    /* Missing routing table. */
  344.         return;
  346.     count.found = count.killed = 0;
  347.     count.rnh = pHead;
  348.     count.nextstop = tickGet() + routeKillInterval;
  349.     count.draining = count.updating = 0;
  351.     /* Remove any old (currently unused) routes which expired. */
  353.     s = splnet ();
  354.     rn_walktree (pHead, routeUpdate, &count);
  355.     splx (s);
  357.     if (count.found - count.killed > routePendLimit)
  358.         {
  359.         /*
  360.          * The routing table still contains excessive unused routes.
  361.          * Reduce the expiration time and try to remove more entries.
  362.          */
  364.         now = tickGet ();
  365.         if ( (now - routeExpireChange >= routeKillInterval) &&
  366.             routePendInterval > routePendMinimum)
  367.             {
  368.             routePendInterval = 2 * routePendInterval / 3;
  369.             if (routePendInterval < routePendMinimum)
  370.                 routePendInterval = routePendMinimum;
  372.             routeExpireChange = now;
  374.             /*
  375.              * Reset the expiration time for old (currently unused) routes
  376.              * to the new (smaller) value. Also update the "nextstop" field
  377.              * to the nearest (new) expiration time.
  378.              */
  380.             count.found = count.killed = 0;
  381.             count.updating = 1;
  383.             s = splnet ();
  384.             rn_walktree (pHead, routeUpdate, &count);
  385.             splx (s);
  386.             }
  387.         }
  389.     /*
  390.      * The routeUpdate() routine may reduce the "nextstop" value to the
  391.      * nearest expiration time of a pending route. Set the timer to 
  392.      * restart at that point, or after the default interval if no old routes
  393.      * are found.
  394.      */
  396.     now = count.nextstop - tickGet ();
  397.     wdStart (routeKillTimer, now, netJobAdd, (int)routeKillCheck); 
  399.     return;
  400.     }
  402. /*
  403.  * This routine performs garbage collection on unused route entries.
  404.  * The system clones those routes (from entries to remote destinations)
  405.  * to store the path MTU results. 
  406.  *
  407.  * The <pArg> argument selects the operation to perform. Normally, both
  408.  * the "draining" and "updating" fields are 0. In that case, this routine
  409.  * completes the deletion of (unused) cloned entries triggered when rtfree()
  410.  * set the RTF_DELETE flag. Since the RTF_DELETE flag and RTF_ANNOUNCE flags
  411.  * have the same value, this routine also tests the RTF_STATIC flag to prevent
  412.  * the removal of manually added proxy ARP entries.
  413.  *
  414.  * If too many routes exist, the "updating" flag reduces the lifetime of
  415.  * appropriate entries. The "draining" flag removes all entries immediately
  416.  * due to severe memory limitations.
  417.  * 
  418.  * As a side effect, this routine resets the "nextstop" field to the 
  419.  * nearest expiration time of a route entry waiting for deletion, if any.
  420.  */
  421.       
  422. LOCAL int routeUpdate
  423.     (
  424.     struct radix_node * pNode,
  425.     void * pArg
  426.     )
  427.     {
  428.     struct rtqk_arg * pCount = pArg;
  429.     struct rtentry * pRoute = (struct rtentry *)pNode;
  430.     int error;
  431.     ULONG now;
  433.     now = tickGet();
  435.     if ( (pRoute->rt_flags & RTF_DELETE) && !(pRoute->rt_flags & RTF_STATIC))
  436.         {
  437.         pCount->found++;
  439.         if (pCount->draining || pRoute->rt_rmx.rmx_expire <= now)
  440.             {
  441.             if (pRoute->rt_refcnt > 0)
  442.                 panic ("routeKill removing route in use?");
  444.             error = rtrequest (RTM_DELETE, (struct sockaddr *)rt_key (pRoute),
  445.                                pRoute->rt_gateway, rt_mask (pRoute),
  446.                                pRoute->rt_flags, 0);
  447.             if (!error)
  448.                 pCount->killed++;
  449.             }
  450.         else
  451.             {
  452.             if (pCount->updating &&
  453.                 (pRoute->rt_rmx.rmx_expire - now > routePendInterval))
  454.                 pRoute->rt_rmx.rmx_expire = now + routePendInterval;
  456.             if (pRoute->rt_rmx.rmx_expire < pCount->nextstop)
  457.                 pCount->nextstop = pRoute->rt_rmx.rmx_expire;
  458.             }
  459.         }
  460.     return (0);
  461.     }
  463.     /*
  464.      * Remove all unused routes cloned from entries to remote destinations,
  465.      * regardless of expiration time.
  466.      */
  468. void routeDrain (void)
  469.     {
  470.     struct radix_node_head *pHead;
  471.     struct rtqk_arg   count;
  472.     int s;
  474.     pHead = rt_tables [AF_INET];
  476.     if (pHead == NULL)    /* Missing routing table. */
  477.         return;
  479.     count.found = count.killed = 0;
  480.     count.rnh = pHead;
  481.     count.nextstop = 0;
  482.     count.draining = 1;
  483.     count.updating = 0;
  485.     s = splnet ();
  486.     rn_walktree (pHead, routeUpdate, &count);
  487.     splx (s);
  488.     }
  490. /*
  491.  * Packet routing routines.
  492.  */
  493. void
  494. rtalloc(ro)
  495. register struct route *ro;
  496. {
  497. if (ro->ro_rt && ro->ro_rt->rt_ifp && (ro->ro_rt->rt_flags & RTF_UP))
  498. return;  /* XXX */
  499. ro->ro_rt = rtalloc1(&ro->ro_dst, 1);
  500. }
  502. struct rtentry *
  503. rtalloc1(dst, report)
  504. register struct sockaddr *dst;
  505. int report;
  506. {
  507. register struct radix_node_head *rnh = rt_tables[dst->sa_family];
  508. register struct rtentry *rt;
  509. register struct radix_node *rn;
  510. struct rtentry *newrt = 0;
  511. struct rt_addrinfo info;
  512. u_long tosRtMask; /* TOS route mask */
  513. u_long newRtMask; /* TOS 0 route mask */
  514. int  s = splnet(), err = 0, msgtype = RTM_MISS;
  515. struct rtentry *   tosRt = NULL;
  516.         u_char     savedTos;
  518.       /* 
  519.        * save original tos since we overwrite it temporarily in the 
  520.        * dst socketaddr
  521.        */
  523.        savedTos = TOS_GET (dst);
  525.        /*
  526. * The Type of Service octet consists of three fields:
  527. *
  528. *       0     1     2     3     4     5     6     7
  529. *     +-----+-----+-----+-----+-----+-----+-----+-----+
  530. *     |                 |                       |     |
  531. *     |   PRECEDENCE    |          TOS          | MBZ |
  532. *     |                 |                       |     |
  533. *     +-----+-----+-----+-----+-----+-----+-----+-----+
  534. *
  535. * Precedence bits should not be considered when searching
  536. * the table.  An existing matching route would not be found
  537. * and if a new route were created, since dst is copied to 
  538. * generate the key, precedence bits would be part
  539. * of the new route's TOS field which is wrong.  This
  540. * would create a leak if this wrong route were created
  541. * for a local address.  ARP would hold on to a packet,
  542. * while it resolves the local address.  When the reply
  543. * comes back, since ARP does not look for routes with
  544. * TOS set, the packet would never be sent.
  545. *
  546. */
  548. TOS_SET(dst, savedTos & 0x1f);
  550. match:
  552. if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
  553.     ((rn->rn_flags & RNF_ROOT) == 0)) {
  554. newrt = rt = (struct rtentry *)rn;
  555.                 if ( (dst->sa_family == AF_INET) && (rt->rt_refcnt == 0) &&
  556.                     (rt->rt_flags & RTF_DELETE) && !(rt->rt_flags & RTF_STATIC))
  557.                     {
  558.                     /*
  559.                      * Reusing a (cloned) route to a remote destination.
  560.                      * Remove deletion tag and reset timer.
  561.                      *
  562.                      * NOTE: All manually added proxy ARP entries include
  563.                      * the RTF_ANNOUNCE flag which uses the same value as
  564.                      * the RTF_DELETE flag. The preceding test for RTF_STATIC
  565.                      * preserves the flag settings for those ARP entries,
  566.                      * even though the removal of RTF_ANNOUNCE should be
  567.                      * harmless since its only purpose is to trigger the
  568.                      * gratuitous ARP request when the entry is created.
  569.                      */
  571.                     rt->rt_flags &= ~RTF_DELETE;
  572.                     rt->rt_rmx.rmx_expire = 0;
  573.                     }
  575. if (report && (rt->rt_flags & RTF_CLONING)) {
  576. #ifdef WV_INSTRUMENTATION
  577. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  578.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 17, 9,
  579.                              WV_NETEVENT_RTALLOC_CLONE,
  580.                          ((struct sockaddr_in *)rt_key (rt))->sin_addr.s_addr, 
  581.                          ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  582. #endif  /* INCLUDE_WVNET */
  583. #endif
  585. err = rtrequest(RTM_RESOLVE, dst, SA(0),
  586.       SA(0), 0, &newrt);
  587. if (err) {
  588. newrt = rt;
  589. rt->rt_refcnt++;
  590. goto miss;
  591. }
  592. if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
  593. msgtype = RTM_RESOLVE;
  594. goto miss;
  595. }
  596. } else
  597.                       {
  598. #ifdef WV_INSTRUMENTATION
  599. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  600.         WV_NET_DSTADDROUT_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 18, 10,
  601.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr,
  602.                                     WV_NETEVENT_RTALLOC_SEARCHGOOD,
  603.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  604. #endif  /* INCLUDE_WVNET */
  605. #endif
  607.                       rt->rt_refcnt++;
  608.                       }
  609. } else {
  610. rtstat.rts_unreach++;
  611. miss:
  612. #ifdef WV_INSTRUMENTATION
  613. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  614.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_CRITICAL, 26, 5,
  615.                          WV_NETEVENT_RTALLOC_SEARCHFAIL,
  616.                          ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  617. #endif  /* INCLUDE_WVNET */
  618. #endif
  620.                 if (report) {
  621. bzero((caddr_t)&info, sizeof(info));
  622. info.rti_info[RTAX_DST] = dst;
  623.                         if (rtMissMsgHook)
  624.                             (*rtMissMsgHook) (msgtype, &info, 0, err);
  625. }
  626. }
  628.         /*
  629.          *  RFC 1583 Section 11.1:
  630.          *
  631.          * "Select the routing table entry whose value matches the TOS found
  632.          *  in the packet header.  If there is no routing table entry for
  633.          *  this TOS, select the routing table entry for TOS 0.  In other
  634.          *  words, packets requesting TOS X are routed along the TOS 0
  635.          *  path if a TOS X path does not exist."
  636.  *  See also RFC 1349, Appendix B.4.
  637.          */
  639.         if (TOS_GET (dst) != 0)
  640.             {
  641.             TOS_SET (dst, 0);
  642.             tosRt = newrt;
  643.             newrt = NULL;
  644.             goto match;
  645.             }
  647.         /*
  648.          * tosRt is the TOS route match, if any. If none exists, tosRt is the
  649.          * default route ("0.0.0.0"), if any.  Otherwise, tosRt is NULL.
  650.          * newrt is the TOS 0 route.
  651.          */
  653.         if (tosRt != NULL)
  654.             {
  655.             if (newrt != NULL)
  656.                 {
  657.                 /*
  658.                  * Host route entries created by ARP have null masks with
  659.                  * implied mask = 0xffffffff
  660.                  */
  662.                 tosRtMask =  (rt_mask (tosRt) == NULL) ? 0xffffffff :
  663.                     ((struct sockaddr_in *) rt_mask (tosRt))->sin_addr.s_addr;
  664. #ifdef RTALLOC_DEBUG
  665.                 printf("nBEST MATCHING TOS ROUTE:n"); 
  666.                 routeEntryDebugShow ((struct radix_node *)tosRt);
  667.                 printf("nTOS 0 ROUTE:n"); 
  668.                 routeEntryDebugShow ((struct radix_node *)newrt);
  669. #endif /* RTALLOC_DEBUG */
  671.                 newRtMask =  (rt_mask (newrt) == NULL) ? 0xffffffff :
  672.                     ((struct sockaddr_in *) rt_mask (newrt))->sin_addr.s_addr;
  674.                 /*
  675.                  * select the route with longest netmask. we assume
  676.                  * contiguous masks starting at the same bit position.
  677.                  * The default route has a mask = 0x00000000
  678.                  */
  680.                 if (tosRtMask >= newRtMask)
  681.                     {
  682.                     RTFREE (newrt);
  683.                     newrt = tosRt;
  684.                     }
  685.                 else
  686.                     {
  687.                     /* newrt is more specific: keep it */
  688.                     RTFREE (tosRt);
  689.                    }
  690.                 }
  691.             else /* newrt is NULL */
  692.                 {
  693.                 /*
  694.                  * Restore previously found TOS route.  Can happen if there is a
  695.                  * route entered with TOS set, but no default route exists nor
  696.                  * route match with 0 TOS.
  697.                  */
  698.                 newrt = tosRt;
  699.                 }
  700.             }
  702. #ifdef RTALLOC_DEBUG
  703. if (savedTos && newrt != NULL)
  704.     {
  705.     printf ("nSELECTED ROUTE:n");
  706.     routeEntryDebugShow ((struct radix_node *)newrt);
  707.     }
  708. #endif /* RTALLOC_DEBUG */
  710.        /* Restore the saved TOS. */ 
  712.        TOS_SET (dst, savedTos);
  714.        splx(s);
  716.        return (newrt);
  717. }
  719.     /*
  720.      * This version of the route search routine is specifically designed
  721.      * for retrieving a route when forwarding packets. Unlike the original
  722.      * case, this route search never clones routes to remote destinations.
  723.      * Those cloned routes are necessary for path MTU discovery, but should
  724.      * only exist when the Internet host originates the traffic, not when
  725.      * it forwards it as a router.
  726.      */
  728. struct rtentry *
  729. rtalloc2(dst)
  730. register struct sockaddr *dst;
  731. {
  732. register struct radix_node_head *rnh = rt_tables[dst->sa_family];
  733. register struct rtentry *rt;
  734. register struct radix_node *rn;
  735. struct rtentry *newrt = 0;
  736. struct rt_addrinfo info;
  737. int  s = splnet(), err = 0, msgtype = RTM_MISS;
  738. struct rtentry *   tosRt = NULL;
  739.         u_long tosRtMask;       /* TOS route mask */
  740.         u_long newRtMask;       /* TOS 0 route mask */
  741.         u_char     savedTos;
  743.       /* 
  744.        * save original tos since we overwrite it temporarily in the 
  745.        * dst socketaddr
  746.        */
  748.        savedTos = TOS_GET (dst);
  750. match:
  752. if (rnh && (rn = rnh->rnh_matchaddr((caddr_t)dst, rnh)) &&
  753.     ((rn->rn_flags & RNF_ROOT) == 0)) {
  754. newrt = rt = (struct rtentry *)rn;
  755.                 if ( (dst->sa_family == AF_INET) && (rt->rt_refcnt == 0) &&
  756.                     (rt->rt_flags & RTF_DELETE) && !(rt->rt_flags & RTF_STATIC))
  757.                     {
  758.                     /*
  759.                      * Reusing a (cloned) route to a remote destination.
  760.                      * Remove deletion tag and reset timer.
  761.                      *
  762.                      * NOTE: All manually added proxy ARP entries include
  763.                      * the RTF_ANNOUNCE flag which uses the same value as
  764.                      * the RTF_DELETE flag. The preceding test for RTF_STATIC
  765.                      * preserves the flag settings for those ARP entries,
  766.                      * even though the removal of RTF_ANNOUNCE should be
  767.                      * harmless since its only purpose is to trigger the
  768.                      * gratuitous ARP request when the entry is created.
  769.                      */
  771.                     rt->rt_flags &= ~RTF_DELETE;
  772.                     rt->rt_rmx.rmx_expire = 0;
  773.                     }
  775.                 /*
  776.                  * Disable cloning when forwarding data to a remote
  777.                  * destination. This search will still create a 
  778.                  * cloned entry if the destination is directly reachable
  779.                  * to hold the ARP information for the target host.
  780.                  */
  782. if ( !(rt->rt_flags & RTF_GATEWAY) &&
  783.                     (rt->rt_flags & RTF_CLONING)) {
  784. err = rtrequest(RTM_RESOLVE, dst, SA(0),
  785.       SA(0), 0, &newrt);
  786. if (err) {
  787. newrt = rt;
  788. rt->rt_refcnt++;
  789. goto miss;
  790. }
  791. if ((rt = newrt) && (rt->rt_flags & RTF_XRESOLVE)) {
  792. msgtype = RTM_RESOLVE;
  793. goto miss;
  794. }
  795. } else
  796. rt->rt_refcnt++;
  797. } else {
  798. rtstat.rts_unreach++;
  799. miss:
  800. bzero((caddr_t)&info, sizeof(info));
  801. info.rti_info[RTAX_DST] = dst;
  802.                 if (rtMissMsgHook)
  803.                     (*rtMissMsgHook) (msgtype, &info, 0, err);
  804. }
  806.     /*
  807.      *  RFC 1583 Section 11.1:
  808.      *
  809.      * "Select the routing table entry whose value matches the TOS found
  810.      *  in the packet header.  If there is no routing table entry for
  811.      *  this TOS, select the routing table entry for TOS 0.  In other
  812.      *  words, packets requesting TOS X are routed along the TOS 0
  813.      *  path if a TOS X path does not exist."
  814.      *  See also RFC 1349, Appendix B.4.
  815.      */
  817.     if (TOS_GET (dst) != 0)   
  818.         {
  819.         TOS_SET (dst, 0);
  820.         tosRt = newrt;
  821.         newrt = NULL;
  822.         goto match;
  823.         }
  825.     /*
  826.      * tosRt is the TOS route match, if any. If none exists, tosRt is the
  827.      * default route ("0.0.0.0"), if any.  Otherwise, tosRt is NULL.
  828.      * newrt is the TOS 0 route.
  829.      */
  831.     if (tosRt != NULL)
  832.         {
  833.         if (newrt != NULL)
  834.             {
  835.             /*
  836.              * Host route entries created by ARP have null masks with
  837.              * implied mask = 0xffffffff
  838.              */
  840.             tosRtMask =  (rt_mask (tosRt) == NULL) ? 0xffffffff :
  841.                 ((struct sockaddr_in *) rt_mask (tosRt))->sin_addr.s_addr;
  843.             newRtMask =  (rt_mask (newrt) == NULL) ? 0xffffffff :
  844.                 ((struct sockaddr_in *) rt_mask (newrt))->sin_addr.s_addr;
  846.             /*
  847.              * select the route with longest netmask. we assume
  848.              * contiguous masks starting at the same bit position.
  849.              * The default route has a mask = 0x00000000
  850.              */
  852.             if (tosRtMask >= newRtMask)
  853.                 {
  854.                 RTFREE (newrt);
  855.                 newrt = tosRt;
  856.                 }
  857.             else
  858.                 {
  859.                 /* newrt is more specific: keep it */
  860.                 RTFREE (tosRt);
  861.                }
  862.             }
  863.         else /* newrt is NULL */
  864.             {
  865.             /*
  866.              * Restore previously found TOS route.  Can happen if there is a
  867.              * route entered with TOS set, but no default route exists nor
  868.              * route match with 0 TOS.
  869.              */
  871.             newrt = tosRt;
  872.             }
  873.         }
  875.        /* 
  876.         * restore the saved tos. is redundant but harmless in case tos
  877.         * was default to  start with.
  878.         */
  880.         TOS_SET (dst, savedTos);
  882.         splx(s);
  884.         return (newrt);
  885.     }
  887. void
  888. rtfree(rt)
  889. register struct rtentry *rt;
  890. {
  891. register struct ifaddr *ifa;
  893. #ifdef WV_INSTRUMENTATION
  894. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  895.     if (rt)
  896.         {
  897.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 19, 11,
  898.                          WV_NETEVENT_RTFREE_START,
  899.                          ((struct sockaddr_in *)rt_key (rt))->sin_addr.s_addr,
  900.                          rt->rt_refcnt)
  901.         }
  902.     else
  903.         {
  904.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 19, 11,
  905.                          WV_NETEVENT_RTFREE_START, 0, 0)
  906.         }
  907. #endif  /* INCLUDE_WVNET */
  908. #endif
  910. if (rt == 0)
  911.             {
  912. #ifdef WV_INSTRUMENTATION
  913. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  914.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 21, 1,
  915.                      WV_NETEVENT_RTFREE_PANIC)
  916. #endif  /* INCLUDE_WVNET */
  917. #endif
  919.             panic("rtfree");
  920.             }
  921. rt->rt_refcnt--;
  923.         if (rt_key(rt)->sa_family == AF_INET)
  924.             {
  925.             /*
  926.              * If route was cloned for path MTU results, mark for later
  927.              * removal (if not reused) instead of deleting immediately.
  928.              */
  930.             if ( (rt->rt_refcnt == 0) && (rt->rt_flags & RTF_UP) &&
  931.                 (rt->rt_flags & RTF_HOST) && !(rt->rt_flags & RTF_LLINFO) &&
  932.                 (rt->rt_flags & RTF_CLONED))
  933.                 {
  934.                 rt->rt_flags |= RTF_DELETE;
  936.                 if (rt->rt_rmx.rmx_expire == 0)    /* Not yet assigned. */
  937.                     rt->rt_rmx.rmx_expire = tickGet() + routePendInterval;
  938.                 }
  939.             }
  941. if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
  942. if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
  943.                     {
  944. #ifdef WV_INSTRUMENTATION
  945. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  946.                     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 21, 1,
  947.                                      WV_NETEVENT_RTFREE_PANIC)
  948. #endif  /* INCLUDE_WVNET */
  949. #endif
  951.                     panic ("rtfree 2");
  952.                     }
  953. rttrash--;
  954. if (rt->rt_refcnt < 0) {
  955. #ifdef WV_INSTRUMENTATION
  956. #ifdef INCLUDE_WVNET    /* WV_NET_ALERT event */
  957.                     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_ALERT, 8, 4,
  958.                                      WV_NETEVENT_RTFREE_BADREFCNT)
  959. #endif  /* INCLUDE_WVNET */
  960. #endif
  962.                     logMsg ("rtfree: %x not freed (neg refs)n", (int)rt,
  963.                             0, 0, 0, 0, 0);
  964.                     return;
  965.                     }
  967. ifa = rt->rt_ifa;
  968. IFAFREE(ifa);
  969.                 if (rt->rt_parent)
  970.                     {
  971.                     RTFREE (rt->rt_parent)
  972.                     }
  973. Free(rt_key(rt));
  975. #ifdef ROUTER_STACK
  976.                 /*
  977.                  * Entries which are not directly attached to the
  978.                  * tree use a different free routine since the netmask
  979.                  * information is stored in a uniquely allocated buffer,
  980.                  * not shared among multiple route entries.
  981.                  */
  983. if ( ((ROUTE_ENTRY*)rt)->primaryRouteFlag == FALSE)
  984.     routeEntryFree ((ROUTE_ENTRY*)rt, FALSE);
  985.                 else
  986.     Free ((ROUTE_ENTRY*)rt);
  987. #else
  988.                 Free (rt);
  989. #endif /* ROUTER_STACK */
  990. }
  991. }
  993. /*
  994.  * Force a routing table entry to the specified
  995.  * destination to go through the given gateway.
  996.  * Normally called as a result of a routing redirect
  997.  * message from the network layer.
  998.  *
  999.  * N.B.: must be called at splnet
  1000.  *
  1001.  */
  1002. int
  1003. rtredirect(dst, gateway, netmask, flags, src, rtp)
  1004. struct sockaddr *dst, *gateway, *netmask, *src;
  1005. int flags;
  1006. struct rtentry **rtp;
  1007. {
  1008. register struct rtentry *rt;
  1009. int error = 0;
  1010. short *stat = 0;
  1011. struct rt_addrinfo info;
  1012. struct ifaddr *ifa;
  1014. /* verify the gateway is directly reachable */
  1015. if ((ifa = ifa_ifwithnet(gateway)) == 0) {
  1016. error = ENETUNREACH;
  1017. goto out;
  1018. }
  1019. rt = rtalloc1(dst, 0);
  1020. /*
  1021.  * If the redirect isn't from our current router for this dst,
  1022.  * it's either old or wrong.  If it redirects us to ourselves,
  1023.  * we have a routing loop, perhaps as a result of an interface
  1024.  * going down recently.
  1025.  */
  1026. #define equal(a1, a2) (bcmp((caddr_t)(a1), (caddr_t)(a2), (a1)->sa_len) == 0)
  1027. if (!(flags & RTF_DONE) && rt &&
  1028.      (!equal(src, rt->rt_gateway) || rt->rt_ifa != ifa))
  1029. error = EINVAL;
  1030. else if (ifa_ifwithaddr(gateway))
  1031. error = EHOSTUNREACH;
  1032. if (error)
  1033. goto done;
  1034. /*
  1035.  * Create a new entry if we just got back a wildcard entry
  1036.  * or the the lookup failed.  This is necessary for hosts
  1037.  * which use routing redirects generated by smart gateways
  1038.  * to dynamically build the routing tables.
  1039.  */
  1040. if ((rt == 0) || (rt_mask(rt) && rt_mask(rt)->sa_len < 2))
  1041. goto create;
  1042. /*
  1043.  * Don't listen to the redirect if it's
  1044.  * for a route to an interface. 
  1045.  */
  1046. if (rt->rt_flags & RTF_GATEWAY) {
  1047. if (((rt->rt_flags & RTF_HOST) == 0) && (flags & RTF_HOST)) {
  1048. /*
  1049.  * Changing from route to net => route to host.
  1050.  * Create new route, rather than smashing route to net.
  1051.  */
  1052. create:
  1053. flags |=  RTF_GATEWAY | RTF_DYNAMIC;
  1055.                         /*
  1056.                          * Create the new route entry using the default
  1057.                          * weight. Do not report the change since the
  1058.                          * later hook generates both types of messages.
  1059.                          */
  1061.                         error = rtrequestAddEqui (dst, netmask, gateway, flags,
  1062.                                                   M2_ipRouteProto_icmp, 0,
  1063.                                                   FALSE, FALSE, NULL);
  1065. /* error = rtrequest((int)RTM_ADD, dst, gateway,
  1066.     netmask, flags,
  1067.     (struct rtentry **)0);
  1068.                         */
  1069. stat = &rtstat.rts_dynamic;
  1070. } else {
  1071. /*
  1072.  * Smash the current notion of the gateway to
  1073.  * this destination.  Should check about netmask!!!
  1074.  */
  1076. if (!(error = rt_setgate (rt, rt_key(rt), gateway)))
  1077.     {
  1078.     rt->rt_flags |= RTF_MODIFIED;
  1079.     flags |= RTF_MODIFIED;
  1080.     stat = &rtstat.rts_newgateway;
  1081.     rt->rt_mod = tickGet();      /* last modified */
  1082.     rtmodified++; 
  1083.     }
  1084. }
  1085. } else
  1086. error = EHOSTUNREACH;
  1087. done:
  1088. if (rt) {
  1089. if (rtp && !error)
  1090. *rtp = rt;
  1091. else
  1092. rtfree(rt);
  1093. }
  1094. out:
  1095. if (error)
  1096.             {
  1097. #ifdef WV_INSTRUMENTATION
  1098. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1099.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 27, 6,
  1100.                              WV_NETEVENT_RTRESET_BADDEST,
  1101.                              error, 
  1102.                              ((struct sockaddr_in *)gateway)->sin_addr.s_addr)
  1103. #endif  /* INCLUDE_WVNET */
  1104. #endif
  1106.             rtstat.rts_badredirect++;
  1107.             }
  1108. else if (stat != NULL)
  1109. (*stat)++;
  1110. bzero((caddr_t)&info, sizeof(info));
  1111. info.rti_info[RTAX_DST] = dst;
  1112. info.rti_info[RTAX_GATEWAY] = gateway;
  1113. info.rti_info[RTAX_NETMASK] = netmask;
  1114. info.rti_info[RTAX_AUTHOR] = src;
  1115.         if (rtMissMsgHook)
  1116.             (*rtMissMsgHook) (RTM_REDIRECT, &info, flags, error);
  1118. #ifdef WV_INSTRUMENTATION
  1119. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1120.         WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_VERBOSE, 34, 14,
  1121.                          WV_NETEVENT_RTRESET_STATUS,
  1122.                          error, 
  1123.                          ((struct sockaddr_in *)dst)->sin_addr.s_addr, 
  1124.                          ((struct sockaddr_in *)gateway)->sin_addr.s_addr, 
  1125.                          ((struct sockaddr_in *)netmask)->sin_addr.s_addr)
  1126. #endif  /* INCLUDE_WVNET */
  1127. #endif
  1129. return (error); 
  1130. }
  1132. /*
  1133. * Routing table ioctl interface.
  1134. *
  1135. * WRS MODS support for this function is being for backward compatibility.
  1136. * This function has be moved else where because the routing code has 
  1137. * nothing to do with internet specific addresses since routing is independent
  1138. * of the sockaddress family.
  1139. */
  1140. int
  1141. rtioctl(req, data)
  1142. int req;
  1143. caddr_t data;
  1144. {
  1145. struct ortentry * pORE = NULL;
  1146. struct sockaddr netMask;
  1147. struct sockaddr * pNetMask = &netMask; 
  1148. register u_long i; 
  1149. register u_long net;
  1150. register struct in_ifaddr *ia;
  1152. #ifdef WV_INSTRUMENTATION
  1153. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1154.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 20, 12,
  1155.                      WV_NETEVENT_RTIOCTL_START, req)
  1156. #endif  /* INCLUDE_WVNET */
  1157. #endif
  1159.         if (req != SIOCADDRT && req != SIOCDELRT)
  1160.             {
  1161. #ifdef WV_INSTRUMENTATION
  1162. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  1163.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 37, 8,
  1164.                              WV_NETEVENT_RTIOCTL_BADREQ, req)
  1165. #endif  /* INCLUDE_WVNET */
  1166. #endif
  1168.             return (EINVAL);
  1169.             }
  1171. pORE = (struct ortentry *)data;
  1173. /* BSD4.3 to BSD4.4 conversion */
  1175. if (req == SIOCADDRT)
  1176.     req = RTM_ADD;
  1177. else
  1178.     req = RTM_DELETE;
  1180. /* 
  1181.  * Set the netmask to the netmask of the interface address.
  1182.  * This has to be removed if provision is made with routeAdd
  1183.  * to add the network mask. 
  1184.  */
  1185. bzero ((caddr_t)&netMask, sizeof (struct sockaddr));
  1187. /* check for default gateway address */
  1189. if (((struct sockaddr_in *)(&pORE->rt_dst))->sin_addr.s_addr 
  1190.     != INADDR_ANY )
  1191.     {
  1192.     i = ntohl(((struct sockaddr_in*)&pORE->rt_dst)->sin_addr.s_addr);
  1194.     pNetMask->sa_family = AF_INET; 
  1195.     pNetMask->sa_len    = 8;
  1197.     if (IN_CLASSA(i))
  1198. {
  1199. ((struct sockaddr_in *)pNetMask)->sin_addr.s_addr = 
  1200.     htonl(IN_CLASSA_NET);
  1201. net = i & IN_CLASSA_NET;
  1202. }
  1203.     else if (IN_CLASSB(i))
  1204. {
  1205. ((struct sockaddr_in *)pNetMask)->sin_addr.s_addr = 
  1206.     htonl(IN_CLASSB_NET);
  1207. net = i & IN_CLASSB_NET;
  1208. }
  1209.     else if (IN_CLASSC(i))
  1210. {
  1211. ((struct sockaddr_in *)pNetMask)->sin_addr.s_addr = 
  1212.     htonl(IN_CLASSC_NET);
  1213. net = i & IN_CLASSC_NET;
  1214. }
  1215.     else
  1216. {
  1217. ((struct sockaddr_in *)pNetMask)->sin_addr.s_addr = 
  1218.     htonl(IN_CLASSD_NET);
  1219. net = i & IN_CLASSD_NET;
  1220. }
  1221.     /*
  1222.      * Check whether network is a subnet;
  1223.      * if so, return subnet number.
  1224.      */
  1225. #ifdef VIRTUAL_STACK
  1226.     for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  1227. #else
  1228.     for (ia = in_ifaddr; ia; ia = ia->ia_next)
  1229. #endif /* VIRTUAL_STACK */
  1230. if (net == ia->ia_net)
  1231.     ((struct sockaddr_in *)pNetMask)->sin_addr.s_addr =
  1232. htonl(ia->ia_subnetmask); 
  1233.     in_socktrim ((struct sockaddr_in *)pNetMask); 
  1234.     }
  1235.        pORE->rt_flags |= RTF_GATEWAY;
  1237.        if(pORE->rt_flags & RTF_HOST)
  1238.    pNetMask=0;
  1239.  
  1240. #ifdef DEBUG
  1241.        logMsg("rtIoctl:before rtrequestAddEqui/DelEquin",0,0,0,0,0,0);
  1242. #endif
  1244.         /*
  1245.          * Add the requested route using the default weight value or delete
  1246.          * the matching entry. In either case, report the change using both
  1247.          * routing socket messages and direct callbacks.
  1248.          */
  1250.        if(req==RTM_ADD)
  1251.    return (rtrequestAddEqui (&pORE->rt_dst, pNetMask,
  1252.                                      &pORE->rt_gateway, pORE->rt_flags,
  1253.                                      M2_ipRouteProto_other, 0,
  1254.                                      TRUE, TRUE, NULL));
  1255.        else
  1256.    return (rtrequestDelEqui (&pORE->rt_dst, pNetMask,
  1257.                                      &pORE->rt_gateway, pORE->rt_flags,
  1258.                                      M2_ipRouteProto_other, TRUE, TRUE, NULL));
  1259. }
  1261. #define ROUNDUP(a) (a>0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
  1263. int rt_fixdelete (struct radix_node *, void *);
  1264. static int rt_fixchange (struct radix_node *, void *);
  1266. int
  1267. rtrequest(req, dst, gateway, netmask, flags, ret_nrt)
  1268. int req, flags;
  1269. struct sockaddr *dst, *gateway, *netmask;
  1270. struct rtentry **ret_nrt;
  1271. {
  1272. int s = splnet(); int error = 0;
  1273. register struct rtentry *rt;
  1274. register struct radix_node *rn;
  1275. register struct radix_node_head *rnh;
  1276. struct ifaddr *ifa;
  1277. struct sockaddr *ndst;
  1278. #define senderr(x) { error = x ; goto bad; }
  1280. if ((rnh = rt_tables[dst->sa_family]) == 0)
  1281. senderr(ESRCH);
  1282. if (flags & RTF_HOST)
  1283.             {
  1284.             netmask = 0;
  1285.     }
  1286.         if (netmask)
  1287.     {
  1288.     TOS_SET (netmask, 0x1f);  /* set the 5 bits in the mask corresponding
  1289.  to the TOS bits */
  1290.     }
  1291. switch (req) {
  1292. case RTM_DELETE:
  1293. if ((rn = rnh->rnh_deladdr(dst, netmask, rnh)) == 0)
  1294. senderr(ESRCH);
  1295. if (rn->rn_flags & (RNF_ACTIVE | RNF_ROOT))
  1296.                     {
  1297. #ifdef WV_INSTRUMENTATION
  1298. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1299.                     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 22, 2,
  1300.                                      WV_NETEVENT_RTREQ_PANIC)
  1301. #endif  /* INCLUDE_WVNET */
  1302. #endif
  1304.                     panic ("rtrequest delete");
  1305.                     }
  1307. rt = (struct rtentry *)rn;
  1309.                 /*
  1310.                  * Search the appropriate subtree to remove any children
  1311.                  * (created for path MTU results). This cleanup must occur
  1312.                  * before clearing the RTF_UP flag or the system might
  1313.                  * release the current node's memory prematurely if the
  1314.                  * search deletes the last reference.
  1315.                  */
  1317.                 if (dst->sa_family == AF_INET &&
  1318.                     (rt->rt_flags & RTF_CLONING) && netmask)
  1319.                     {
  1320.                     rn_walksubtree (rnh, dst, netmask, rt_fixdelete, rt);
  1321.                     }
  1323. rt->rt_flags &= ~RTF_UP;
  1325. if (rt->rt_gwroute) {
  1326. rt = rt->rt_gwroute; RTFREE(rt);
  1327. (rt = (struct rtentry *)rn)->rt_gwroute = 0;
  1328. }
  1329. if ((ifa = rt->rt_ifa) && ifa->ifa_rtrequest)
  1330. ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0));
  1331. rttrash++;
  1332. if (ret_nrt)
  1333. *ret_nrt = rt;
  1334. else if (rt->rt_refcnt <= 0) {
  1335. rt->rt_refcnt++;
  1336. rtfree(rt);
  1337. }
  1338. rtmodified++;
  1339. break;
  1341. case RTM_RESOLVE:
  1342. if (ret_nrt == 0 || (rt = *ret_nrt) == 0)
  1343.                         {
  1344. #ifdef DEBUG
  1345.                         logMsg("rtrequest: RTM_RESOLVE, EINVAL errorn",0,0,0,0,0,0);
  1346. #endif
  1347. senderr(EINVAL);
  1348.                         }
  1350. ifa = rt->rt_ifa;
  1351. flags = rt->rt_flags & ~RTF_CLONING;
  1352. gateway = rt->rt_gateway;
  1353. if ((netmask = rt->rt_genmask) == 0)
  1354. {
  1355. flags |= RTF_HOST;
  1356. }
  1358. goto makeroute;
  1360. case RTM_ADD:
  1361. if ((ifa = ifa_ifwithroute(flags, dst, gateway)) == 0)
  1362. senderr(ENETUNREACH);
  1363. makeroute:
  1364. R_Malloc(rt, struct rtentry *, sizeof(ROUTE_ENTRY));
  1365. if (rt == 0)
  1366. senderr(ENOBUFS);
  1367. Bzero(rt, sizeof (ROUTE_ENTRY));
  1368. rt->rt_flags = RTF_UP | flags;
  1369. if (rt_setgate(rt, dst, gateway)) {
  1370. Free(rt);
  1371. senderr(ENOBUFS);
  1372. }
  1373. ndst = rt_key(rt);
  1374. if (netmask) {
  1375. rt_maskedcopy(dst, ndst, netmask);
  1376. } else
  1377. Bcopy(dst, ndst, dst->sa_len);
  1379.             /* Set IP routes to create children (for path MTU results). */
  1381.             if (ndst->sa_family == AF_INET &&
  1382.                 !IN_MULTICAST
  1383.                     (ntohl ( ((struct sockaddr_in *)ndst)->sin_addr.s_addr)) &&
  1384.                 ! (rt->rt_flags & RTF_HOST))
  1385.                 {
  1386.                 if (((struct sockaddr_in *)netmask)->sin_addr.s_addr 
  1387.                          != 0xffffffff)
  1388.                     {
  1389.                     rt->rt_flags |= RTF_CLONING;
  1390.                     }
  1391.                 }
  1393. rn = rnh->rnh_addaddr((caddr_t)ndst, (caddr_t)netmask,
  1394. rnh, rt->rt_nodes);
  1395. /* update proto field of rt entry, in the gateway sockaddr */
  1396. if ((req == RTM_ADD) && (gateway->sa_family == AF_INET))
  1397.     RT_PROTO_SET (ndst, RT_PROTO_GET (dst));
  1399.                 if (rn == 0 && (rt->rt_flags & RTF_HOST))
  1400.                     {
  1401.                     /* Replace matching (cloned) entry if possible. */
  1403.                     rn = routeSwap (rnh, rt, ndst, netmask);
  1404.                     }
  1406. if (rn == 0) {
  1407. if (rt->rt_gwroute)
  1408. rtfree(rt->rt_gwroute);
  1409. Free(rt_key(rt));
  1410. Free(rt);
  1411. senderr(EEXIST);
  1412. }
  1413. ifa->ifa_refcnt++;
  1414. rt->rt_ifa = ifa;
  1415. rt->rt_ifp = ifa->ifa_ifp;
  1416. if (req == RTM_RESOLVE)
  1417.                     {
  1418.                     rt->rt_rmx = (*ret_nrt)->rt_rmx; /* copy metrics */
  1419.                     rt->rt_parent = (*ret_nrt);   /* record source route */
  1420.                     (*ret_nrt)->rt_refcnt++;
  1421.                     rt->rt_flags |= RTF_CLONED;
  1422.                     
  1423.                     /*
  1424.                      * Mark the cloned route as a representative route
  1425.                      * so that when it is deleted, Fastpath is called with
  1426.                      * ROUTE_REP_DEL operation and the entry gets removed
  1427.                      * from the Fastpath cache
  1428.                      */
  1429.  
  1430.                     ((ROUTE_ENTRY*)rt)->primaryRouteFlag = TRUE;
  1432.                     }
  1434.                 if (rt->rt_ifp->if_type == IFT_PMP)
  1435.                     {
  1436.                     /*
  1437.                      * Point-to-multipoint devices do not use a common
  1438.                      * MTU value for all destinations or perform address
  1439.                      * resolution, so cloning the interface route to store
  1440.                      * that information is not necessary.
  1441.                      */
  1443.                     rt->rt_flags &= ~RTF_CLONING;
  1444.                     }
  1446.                 /* Assign initial path MTU estimate, if enabled for route. */
  1448.                 if (!rt->rt_rmx.rmx_mtu && !(rt->rt_rmx.rmx_locks & RTV_MTU)
  1449.                     && rt->rt_ifp)
  1450.                     rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu;
  1452. if (ifa->ifa_rtrequest)
  1453. ifa->ifa_rtrequest(req, rt, SA(ret_nrt ? *ret_nrt : 0));
  1455.                 if (ndst->sa_family == AF_INET)
  1456.                     {
  1457.                     /*
  1458.                      * Remove any cloned routes which a new
  1459.                      * network route overrides.
  1460.                      */
  1462.                     if (!(rt->rt_flags & RTF_HOST) && rt_mask (rt) != 0)
  1463.                         {
  1464.                         rn_walksubtree (rnh, ndst, netmask, rt_fixchange, rt);
  1465.                         }
  1466.                     }
  1468. if (ret_nrt) {
  1469. *ret_nrt = rt;
  1470. rt->rt_refcnt++;
  1471. }
  1472. rt->rt_mod = tickGet();  /* last modified */
  1473. rtmodified++;
  1474. break;
  1475. }
  1476. bad:
  1477. #ifdef WV_INSTRUMENTATION
  1478. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1479.         if (error)
  1480.             {
  1481.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_CRITICAL, 28, 7,
  1482.                              WV_NETEVENT_RTREQ_BADROUTE,
  1483.                              error, 
  1484.                              ((struct sockaddr_in *)dst)->sin_addr.s_addr, 
  1485.                              ((struct sockaddr_in *)gateway)->sin_addr.s_addr, 
  1486.                              ((struct sockaddr_in *)netmask)->sin_addr.s_addr)
  1487.             }
  1488. #endif  /* INCLUDE_WVNET */
  1489. #endif
  1491. splx(s);
  1492. return (error);
  1493. }
  1495.  /* 
  1496.   * This routine is called when adding a host-specific route to
  1497.   * the routing tree fails. That failure can occur because an
  1498.   * ARP entry for the destination already exists in the tree.
  1499.   * Alternatively, a cloned entry to a remote destination (for
  1500.   * path MTU results) might already exist. In either case, the
  1501.   * host-specific entry is added after the existing entry is removed.
  1502.   */
  1504. struct radix_node * routeSwap
  1505.     (
  1506.     struct radix_node_head *  pNodeHead,
  1507.     struct rtentry *  pRoute,
  1508.     struct sockaddr *  pDest,
  1509.     struct sockaddr *  pNetmask
  1510.     )
  1511.     {
  1512.     struct radix_node *  pNode;
  1513.     struct rtentry *  pTwinRt;
  1514.     struct ifaddr *  pIfAddr;
  1515.     struct rtentry *  pArpRt;
  1516.     struct radix_node_head *  pTwinHead;
  1517.     struct sockaddr *  pTwinKey;
  1519.     /*
  1520.      * Existing entries will prevent the addition of
  1521.      * matching host routes. Delete the entry and try
  1522.      * to add the host route again. The search is based
  1523.      * on the rtalloc1() routine.
  1524.      */
  1526.     pNode = rn_search ((caddr_t)pDest, pNodeHead->rnh_treetop);
  1527.     if ( (pNode->rn_flags & RNF_ROOT) == 0)
  1528.         {
  1529.         /* Check leaf node for ARP information or existing child route. */
  1531.         pTwinRt = (struct rtentry *)pNode;
  1532.         if ( (pTwinRt->rt_flags & RTF_CLONED) ||
  1533.                 (pTwinRt->rt_flags & RTF_LLINFO &&
  1534.                  pTwinRt->rt_flags & RTF_HOST &&
  1535.                  pTwinRt->rt_gateway &&
  1536.                  pTwinRt->rt_gateway->sa_family == AF_LINK))
  1537.             {
  1538.             /* Mimic RTM_DELETE case from rtrequest() routine. */
  1540.             pTwinKey = (struct sockaddr *)rt_key (pTwinRt);
  1541.             pTwinHead = rt_tables [pTwinKey->sa_family];
  1542.             if (pTwinHead)
  1543.                 {
  1544.                 pNode = pTwinHead->rnh_deladdr (pTwinKey, 0, pTwinHead);
  1545.                 if (pNode)
  1546.                     {
  1547.                     pArpRt = (struct rtentry *)pNode;
  1548.                     pArpRt->rt_flags &= ~RTF_UP;
  1549.                     if (pArpRt->rt_gwroute)
  1550.                         {
  1551.                         pArpRt = pArpRt->rt_gwroute;
  1552.                         RTFREE (pArpRt);
  1553.                         pArpRt = (struct rtentry *)pNode;
  1554.                         pArpRt->rt_gwroute = 0;
  1555.                         }
  1556.                     pIfAddr = pArpRt->rt_ifa;
  1557.                     if (pIfAddr && pIfAddr->ifa_rtrequest)
  1558.                         pIfAddr->ifa_rtrequest (RTM_DELETE, pArpRt, SA(0));
  1559.                     rttrash++;
  1560.                     if (pArpRt->rt_refcnt <= 0)
  1561.                         {
  1562.                         pArpRt->rt_refcnt++;
  1563.                         rtfree (pArpRt);
  1564.                         }
  1565.                     rtmodified++;
  1566.                     }
  1567.                 }    /* RTM_DELETE completed. */
  1568.             pNode = pNodeHead->rnh_addaddr ( (caddr_t)pDest, (caddr_t)pNetmask, 
  1569.                                             pNodeHead, pRoute->rt_nodes);
  1570.             }  /* End ARP entry replacement. */
  1571.         else
  1572.             {
  1573.             /*
  1574.              * Matching node was not a host entry. Reset node reference.
  1575.              */
  1577.             pNode = 0;
  1578.             }
  1579.         }    /* End handling for RNF_ROOT != 0 */
  1580.     else
  1581.         {
  1582.         /* 
  1583.          * No valid entry found: remove reference to leftmost/rightmost node.
  1584.          */
  1586.         pNode = 0;
  1587.         }
  1588.     return (pNode);
  1589.     }
  1591. /*
  1592.  * The rt_fixchange() routine adjusts the routing tree after adding a new
  1593.  * network route. If the system inserts the route between an older network
  1594.  * route and the corresponding (cloned) host routes, the new route might
  1595.  * incorporate existing cloned entries. This routine removes those (obsolete)
  1596.  * cloned routes. Unfortunately, it also needlessly examines a subtree and
  1597.  * removes valid cloned routes when adding a new (less specific) route above
  1598.  * a pre-existing entry. Since those routes will be regenerated if still in
  1599.  * use, this (wasteful) behavior does not prevent correct operation.
  1600.  */
  1602. static int
  1603. rt_fixchange(rn, vp)
  1604.         struct radix_node *rn;
  1605.         void *vp;
  1606. {
  1607.         struct rtentry *rt = (struct rtentry *)rn;
  1608.         struct rtentry *rt0 = vp;
  1609.         struct radix_node_head *rnh = rt_tables [AF_INET];
  1610.         u_char *xk1, *xm1, *xk2;
  1611.         int i, len;
  1613.         if (!rt->rt_parent)     /* Ignore uncloned entries. */
  1614.             return 0;
  1616.         /*
  1617.          * Check if the network number of the route entry matches
  1618.          * the destination of the new route.
  1619.          */
  1621.         len = min (rt_key (rt0)->sa_len, rt_key (rt)->sa_len);
  1623.         xk1 = (u_char *)rt_key (rt0);
  1624.         xm1 = (u_char *)rt_mask (rt0);
  1625.         xk2 = (u_char *)rt_key (rt);
  1627.         for (i = rnh->rnh_treetop->rn_off; i < len; i++) {
  1628.                 if ((xk2[i] & xm1[i]) != xk1[i]) {
  1629.                         return 0;
  1630.                 }
  1631.         }
  1633.         /* Remove the cloned route which is part of the new route's network. */
  1635.         return rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0,
  1636.                          rt_mask(rt), rt->rt_flags, (struct rtentry **)0);
  1637. }
  1639. /*
  1640.  * The rt_fixdelete() routine removes any cloned routes (for storing path
  1641.  * MTU information) when the original route to the remote destination is
  1642.  * deleted or the gateway is changed. It has no affect on cloned entries
  1643.  * containing ARP information.
  1644.  */
  1646. int rt_fixdelete(rn, vp)
  1647.         struct radix_node *rn;
  1648.         void *vp;
  1649. {
  1650.         struct rtentry *rt = (struct rtentry *)rn;
  1651.         struct rtentry *rt0 = vp;
  1653.         if (rt->rt_parent == rt0 && !(rt->rt_flags & RTF_LLINFO)) {
  1654.                 return rtrequest(RTM_DELETE, rt_key(rt),
  1655.                                  (struct sockaddr *)0, rt_mask(rt),
  1656.                                  rt->rt_flags, (struct rtentry **)0);
  1657.         }
  1658.         return 0;
  1659. }
  1661. int
  1662. rt_setgate(rt0, dst, gate)
  1663. struct rtentry *rt0;
  1664. struct sockaddr *dst, *gate;
  1665. {
  1666. caddr_t new, old;
  1667. int dlen = ROUNDUP(dst->sa_len), glen = ROUNDUP(gate->sa_len);
  1668. register struct rtentry *rt = rt0;
  1670.         /*
  1671.  * Prevent addition of a host route with destination equal to
  1672.          * the gateway. Addition of such a route can cause infinite
  1673.  * recursion while doing a route search using rtalloc which might
  1674.  * result in stack overflow in tNetTask.
  1675.  */
  1677. if (((rt0->rt_flags & (RTF_HOST | RTF_GATEWAY | RTF_LLINFO)) ==
  1678.      (RTF_HOST | RTF_GATEWAY)) && (dst->sa_len == gate->sa_len) &&
  1679.      (((struct sockaddr_in *) dst)->sin_addr.s_addr ==
  1680.       ((struct sockaddr_in *) gate)->sin_addr.s_addr))
  1681.     return 1;
  1683. if (rt->rt_gateway == 0 || glen > ROUNDUP(rt->rt_gateway->sa_len)) {
  1684. old = (caddr_t)rt_key(rt);
  1685. R_Malloc(new, caddr_t, dlen + glen);
  1686. if (new == 0)
  1687.                     {
  1688. #ifdef WV_INSTRUMENTATION
  1689. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1690.                     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 23, 3,
  1691.                                      WV_NETEVENT_RTSET_NOBUFS)
  1692. #endif  /* INCLUDE_WVNET */
  1693. #endif
  1695.                    return 1;
  1696.                    }
  1697. rt->rt_nodes->rn_key = new;
  1698. } else {
  1699. new = rt->rt_nodes->rn_key;
  1700. old = 0;
  1701. }
  1702. Bcopy(gate, (rt->rt_gateway = (struct sockaddr *)(new + dlen)), glen);
  1703. if (old) {
  1704. Bcopy(dst, new, dlen);
  1705. Free(old);
  1706. }
  1707. if (rt->rt_gwroute) {
  1708. rt = rt->rt_gwroute; RTFREE(rt);
  1709. rt = rt0; rt->rt_gwroute = 0;
  1710. }
  1711. if (rt->rt_flags & RTF_GATEWAY) {
  1712. rt->rt_gwroute = rtalloc1(gate, 1);
  1713. }
  1714. return 0;
  1715. }
  1717. void
  1718. rt_maskedcopy(src, dst, netmask)
  1719. struct sockaddr *src, *dst, *netmask;
  1720. {
  1721. register u_char *cp1 = (u_char *)src;
  1722. register u_char *cp2 = (u_char *)dst;
  1723. register u_char *cp3 = (u_char *)netmask;
  1724. u_char *cplim = cp2 + *cp3;
  1725. u_char *cplim2 = cp2 + *cp1;
  1727. *cp2++ = *cp1++; *cp2++ = *cp1++; /* copies sa_len & sa_family */
  1728. cp3 += 2;
  1729. if (cplim > cplim2)
  1730. cplim = cplim2;
  1731. while (cp2 < cplim)
  1732. *cp2++ = *cp1++ & *cp3++;
  1733. if (cp2 < cplim2)
  1734. bzero((caddr_t)cp2, (unsigned)(cplim2 - cp2));
  1735. }
  1737. /*
  1738.  * Set up a routing table entry, normally
  1739.  * for an interface.
  1740.  */
  1741. int
  1742. rtinit(ifa, cmd, flags)
  1743. register struct ifaddr *ifa;
  1744. int cmd, flags;
  1745. {
  1746. register struct rtentry *rt;
  1747. register struct sockaddr *dst;
  1748. register struct sockaddr *deldst;
  1749. struct mbuf *m = 0;
  1750. struct rtentry *nrt = 0;
  1751. int error=0;
  1753. dst = flags & RTF_HOST ? ifa->ifa_dstaddr : ifa->ifa_addr;
  1755. #ifdef WV_INSTRUMENTATION
  1756. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1757.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 35, 15,
  1758.                          WV_NETEVENT_RTINIT_START, cmd, 
  1759.                          ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  1760. #endif  /* INCLUDE_WVNET */
  1761. #endif
  1763. if (cmd == RTM_DELETE) {
  1764. if ((flags & RTF_HOST) == 0 && ifa->ifa_netmask) {
  1765. m = mBufClGet(M_WAIT, MT_SONAME, CL_SIZE_128, TRUE);
  1766. if (m == (struct mbuf *) NULL)
  1767.     {
  1768.     return (ENOBUFS);
  1769.     }
  1770. deldst = mtod(m, struct sockaddr *);
  1771. rt_maskedcopy(dst, deldst, ifa->ifa_netmask);
  1772. dst = deldst;
  1773. }
  1774. if ((rt = rtalloc1(dst, 0))) {
  1775. rt->rt_refcnt--;
  1776. if (rt->rt_ifa != ifa) {
  1777. if (m)
  1778. (void) m_free(m);
  1779. return (flags & RTF_HOST ? EHOSTUNREACH
  1780. : ENETUNREACH);
  1781. }
  1782. }
  1783. }
  1785.         /*
  1786.          * Create the new route using the default weight value or delete
  1787.          * the matching entry. In either case, do not report the change
  1788.          * since the later hook generates both types of messages.
  1789.          */
  1791.        if(cmd==RTM_ADD)
  1792.    error=rtrequestAddEqui(dst, ifa->ifa_netmask, ifa->ifa_addr, 
  1793.               flags | ifa->ifa_flags,
  1794.                                   M2_ipRouteProto_local, 0, FALSE, FALSE,
  1795.   (ROUTE_ENTRY**)&nrt);
  1796.        if(cmd==RTM_DELETE)
  1797.    error=rtrequestDelEqui(dst, ifa->ifa_netmask, ifa->ifa_addr,
  1798.           flags | ifa->ifa_flags,
  1799.                                   M2_ipRouteProto_local, FALSE, FALSE,
  1800.   (ROUTE_ENTRY**)&nrt);
  1802. if (m)
  1803. (void) m_free(m);
  1805. if (cmd == RTM_DELETE && error == 0 && (rt = nrt)) {
  1806.          if (rtNewAddrMsgHook) 
  1807. #ifdef ROUTER_STACK
  1808.                     (*rtNewAddrMsgHook) (cmd, ifa, nrt);
  1809. #else
  1810.                     (*rtNewAddrMsgHook) (cmd, ifa, error, nrt);
  1811. #endif /* ROUTER_STACK */
  1812. if (rt->rt_refcnt <= 0) {
  1813. rt->rt_refcnt++;
  1814. rtfree(rt);
  1815. }
  1816. }
  1817. if (cmd == RTM_ADD && error == 0 && (rt = nrt)) {
  1818. rt->rt_refcnt--;
  1819. if (rt->rt_ifa != ifa) {
  1820. logMsg("rtinit: wrong ifa (%x) was (%x)n", (int) ifa,
  1821. (int) rt->rt_ifa, 0, 0, 0, 0);
  1822. if (rt->rt_ifa->ifa_rtrequest)
  1823.     rt->rt_ifa->ifa_rtrequest(RTM_DELETE, rt, SA(0));
  1824. IFAFREE(rt->rt_ifa);
  1825. rt->rt_ifa = ifa;
  1826. rt->rt_ifp = ifa->ifa_ifp;
  1827. ifa->ifa_refcnt++;
  1828. if (ifa->ifa_rtrequest)
  1829.     ifa->ifa_rtrequest(RTM_ADD, rt, SA(0));
  1830. }
  1831. if (rtNewAddrMsgHook)
  1832. #ifdef ROUTER_STACK
  1833.                     (*rtNewAddrMsgHook) (cmd, ifa, nrt);
  1834. #else
  1835.                     (*rtNewAddrMsgHook) (cmd, ifa, error, nrt);
  1836. #endif /* ROUTER_STACK */
  1837. }
  1838. return (error);
  1839. }
  1841. #ifdef RTALLOC_DEBUG
  1842. /*******************************************************************************
  1843. *
  1844. * routeEntryDebugShow - print an entry of the routing table
  1845. *
  1846. * This routine prints a routing table entry, displaying its mask, protocol,
  1847. * and type of service.
  1848. *
  1849. * RETURNS: OK or ERROR.
  1850. *
  1851. * NOMANUAL
  1852. */
  1854. LOCAL int routeEntryDebugShow
  1855.     (
  1856.     struct radix_node * rn              /* pointer to the node structure */
  1857.     )
  1858.     {
  1860.     FAST struct sockaddr *      destAddr = NULL;
  1861.     FAST struct sockaddr *      gateAddr;
  1862.     FAST struct rtentry *       pRt;
  1863.     char                        aStr [INET_ADDR_LEN];
  1864.     uint32_t                    mask;
  1865.     FAST UCHAR *                pChr;
  1866.  
  1868.     pRt = (struct rtentry *)rn;
  1870.     destAddr = rt_key(pRt);             /* get the destination address */
  1871.     gateAddr = pRt->rt_gateway;         /* get the gateway address */
  1874.     /*  arp entries */
  1875.     /*if ((gateAddr->sa_family == AF_LINK) && (pRt->rt_flags & RTF_HOST))
  1876.         return (0);*/
  1878.     /* print destination internet address */
  1880.     inet_ntoa_b (((struct sockaddr_in *)destAddr)->sin_addr, aStr);
  1881.     printf ("if_name: %s%dn",  pRt->rt_ifp->if_name, pRt->rt_ifp->if_unit);
  1882.     printf ("destination: %-16sn", (destAddr->sa_family == AF_INET) ?
  1883.                       aStr : "not AF_INETn");
  1885.     /* print netmask */
  1887.     if (rt_mask (pRt) == NULL)
  1888.         {
  1889.         mask = 0xffffffff;
  1890.         }
  1891.     else
  1892.         {
  1893.         mask = ((struct sockaddr_in *) rt_mask (pRt))->sin_addr.s_addr;
  1894.         mask = ntohl (mask);
  1895.         }
  1897.     printf ("mask: %-10lxn", mask);
  1899.     /* print the gateway address which: internet or linklevel */
  1901.     if (gateAddr->sa_family == AF_LINK)
  1902.         {
  1903.         if ( ((struct sockaddr_dl *)gateAddr)->sdl_alen == 6)
  1904.             {
  1905.             pChr = (UCHAR *)(LLADDR((struct sockaddr_dl *)gateAddr));
  1906.             printf ("ARP ROUTE: %02x:%02x:%02x:%02x:%02x:%-6xn",
  1907.                 pChr[0], pChr[1], pChr[2], pChr[3], pChr[4], pChr[5]);
  1909.             }
  1910.         else if ( ((struct sockaddr_dl *)gateAddr)->sdl_alen == 0)
  1911.             {
  1912.             printf("ARP Interface Route Entryn");
  1913.             }
  1914.         else
  1915.             {
  1916.             printf("Unknown Entryn");
  1917.             return(0);
  1918.             }
  1919.         }
  1920.     else
  1921.         {
  1922.         inet_ntoa_b (((struct sockaddr_in *)gateAddr)->sin_addr, aStr);
  1923.         printf ("Gateway: %-20s n", aStr);
  1924.         }
  1926.     /* print type of service */
  1927.     printf ("tos: %-5xn", TOS_GET (destAddr));
  1929.     printf ("flags: ");
  1930.     if (pRt->rt_flags & RTF_UP)
  1931.         printf("U");
  1933.     if (pRt->rt_flags & RTF_HOST)
  1934.         printf("H");
  1936.     if (pRt->rt_flags & RTF_LLINFO)
  1937.         printf("L");
  1939.     if (pRt->rt_flags & RTF_CLONING)
  1940.         printf("C ");
  1942.     if (pRt->rt_flags & RTF_STATIC)
  1943.         printf("S");
  1945.     if (pRt->rt_flags & RTF_GATEWAY)
  1946.         {
  1947.         printf("G");
  1948.         if (pRt->rt_gwroute)
  1949.             printf(": Gateway route entry = %p ", pRt->rt_gwroute);
  1950.         }
  1952.     printf ("n");
  1954.     printf ("refCnt: %-7dn",   pRt->rt_refcnt);
  1955.     printf ("rt_use: %-7ldn",  pRt->rt_use);
  1956.     printf ("proto: %-5dn",  RT_PROTO_GET (destAddr));
  1958.     return (0);
  1959.     }
  1960. #endif /* RTALLOC_DEBUG */