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

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

VxWorks

开发平台：

C/C++

startup.c：源码内容
  1. /* startup.c - RIP routines for creating initial data structures */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1983, 1988, 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.  * @(#)startup.c 8.2 (Berkeley) 4/28/95
  38.  */
  40. /*
  41. modification history
  42. --------------------
  43. 01l,22mar02,niq  Merged from Synth view, tor3_x.synth branch, ver 01q
  44. 01k,24jan02,niq  SPR 68672 - Add route to the local end of the PTP link with
  45.                  the correct netmask
  46.                  SPR 72415 - Added support for Route tags
  47. 01j,15oct01,rae  merge from truestack ver 01m, base 01h (SPR #69983 etc.)
  48. 01i,10nov00,spm  merged from version 01j of tor3_x branch (SPR #29099 fix)
  49. 01h,11sep98,spm  provided fatal error handling in place of quit routine,
  50.                  replaced ripMakeAddr with optimized results (SPR #22350)
  51. 01g,01sep98,spm  modified addrouteforif to correctly support interfaces 
  52.                  with classless netmasks (SPR #22220); changed spacing
  53.                  for coding standards
  54. 01f,26jul98,spm  moved assignment from conditional to avoid compiler warnings
  55. 01e,06oct97,gnn  fixed SPR 9211 and added sendHook functionality
  56. 01d,16may97,gnn  added code to initialize hooks to NULL.
  57. 01c,07apr97,gnn  cleared up some of the more egregious warnings.
  58.                  added MIB-II interfaces and options.
  59. 01b,24feb97,gnn  added rip version 2 functionality.
  60. 01a,26nov96,gnn  created from BSD4.4 routed
  61. */
  63. /*
  64. DESCRIPTION
  65. */
  67. /*
  68.  * Routing Table Management Daemon
  69.  */
  70. #include "vxWorks.h"
  71. #include "rip/defs.h"
  72. #include "sys/ioctl.h"
  73. #include "net/if.h"
  74. #include "net/if_dl.h"
  75. #include "netinet/in.h"
  76. #include "stdlib.h"
  77. #include "logLib.h"
  78. #include "m2Lib.h"
  79. #include "sockLib.h"
  80. #ifdef VIRTUAL_STACK
  81. #include "netinet/vsLib.h"
  82. #include "netinet/vsRip.h"
  83. #endif /* VIRTUAL_STACK */
  85. #define same(a1, a2) 
  86.         (memcmp((a1)->sa_data, (a2)->sa_data, 14) == 0)
  88. /* globals */
  90. #ifndef VIRTUAL_STACK
  91. IMPORT int routedDebug;
  92. IMPORT RIP ripState;
  93. struct interface * ripIfNet;
  94. struct interface ** ifnext = &ripIfNet;
  95. #endif /* VIRTUAL_STACK */
  97. /* locals */
  99. #ifndef VIRTUAL_STACK
  100. LOCAL int foundloopback; /* valid flag for loopaddr */
  101. LOCAL struct sockaddr  loopaddr; /* our address on loopback */
  102. LOCAL struct rt_addrinfo info;
  103. #endif /* VIRTUAL_STACK */
  105. /* forward declarations */
  107. IMPORT void _ripAddrsXtract (caddr_t, caddr_t, struct rt_addrinfo *); 
  108. IMPORT int sysctl_rtable (int *, int, caddr_t, size_t *, caddr_t *, size_t);
  109. IMPORT void _ripIfShow (struct interface *);
  110. void addrouteforif(register struct interface *);
  111. LOCAL int add_ptopt_localrt (register struct interface *, int);
  114. /* defines */
  116. /* Sleazy use of local variables throughout file, warning!!!! */
  118. #define NETMASK info.rti_info[RTAX_NETMASK]
  119. #define IFAADDR info.rti_info[RTAX_IFA]
  120. #define BRDADDR info.rti_info[RTAX_BRD]
  123. /*****************************************************************************
  124. *
  125. * routedIfInit - initialize interface information
  126. *
  127. * This routine behaves differently based on the <ifindex> parameter.
  128. * If <ifIndex> is 0, this routine searches the kernel's "ifnet" interface
  129. * list for all interfaces belonging to the AF_INET family and copies the
  130. * interface data into RIP private interface table list if that interface is UP.
  131. * If <ifIndex> is non-zero then only the specified interface is queried
  132. * and its data copied if the interface is UP.
  133. *
  134. * Interfaces that are down are ignored.
  135. *
  136. * For every interface retrieved from the kernel, this routine checks if
  137. * a route for the interface address already exists in RIP's table. If it does
  138. * this signifies that RIP already knows about this interface address; hence it
  139. * skips over that entry. If a route doesn't exist, then RIP adds a route
  140. * to that interface in its own table as well as in the system Routing database.
  141. * The above procedure is repeated for each address entry present for an
  142. * interface.
  143. *
  144. * If an interface has multiple IP addresses (aliases), this routine creates
  145. * a different interface entry (virtual interface) for each address. 
  146. * For example an interface "fei0" in the system with address "100.10.1.1"
  147. * and "144.1.1.1" will result in two interfaces in RIP's interface list - 
  148. *  1) "fei0", 100.10.1.1
  149. * 2) "fei0", 144.1.1.1
  151. * The <resetFlag> parameter distinguishes the initial execution of this
  152. * routine from later executions which add new interfaces to the list. 
  153. * It is used to initialize RIP's interface list.
  154. *
  155. * If the sytem runs out of memory during uring the addition of an interface
  156. * to RIP's internal list, or if is encounters some incomplete entries, 
  157. * the "lookforinterfaces" flag is set to automatically repeat the execution
  158. * of this routine at the next timer interval. 
  159. *
  160. * The initial execution of this routine (during RIP startup) must succeed
  161. * or the session will not begin, but the session will continue regardless
  162. * of the results of later executions.
  163. *
  164. * RETURNS: OK, or ERROR if unable to process interface table.
  165. *
  166. * NOMANUAL
  167. *
  168. * INTERNAL
  169. * After the RIP session has started, the routine can be called again
  170. * within the context of either the RIP timer task or the RIP input task. 
  171. * The caller should take the ripLockSem semaphore to provide mutual
  172. * exclusion so that no message processing happens while the 
  173. * interface list is changed and any corresponding route entries are
  174. * created.
  175. */
  177. STATUS routedIfInit
  178.     (
  179.     BOOL  resetFlag,  /* build entire new list or add entries? */
  180.     long ifIndex /* particular interface to search for, 0-all */
  181.     )
  182.     {
  183.     struct interface ifs, *ifp;
  184.     size_t needed;
  185.     int mib[6], no_ipaddr = 0, flags = 0;
  186.     char *buf, *cplim, *cp;
  187.     register struct if_msghdr *ifm;
  188.     register struct ifa_msghdr *ifam;
  189.     struct sockaddr_dl *sdl = NULL;
  190.     struct sockaddr_in *sin;
  191.     struct ip_mreq ipMreq;  /* Structure for joining multicast groups. */
  192.     u_long i;
  194.     if (resetFlag)
  195.         {
  196.         /* Reset globals in case of restart after shutdown. */
  198.         foundloopback = 0;
  199.         ripIfNet = NULL;
  200.         ifnext = &ripIfNet;
  201.         }
  203.     ripState.lookforinterfaces = FALSE;
  205.     ipMreq.imr_multiaddr.s_addr = htonl (RIP_MCAST_ADDR);
  207.     /* 
  208.      * The sysctl_rtable routine provides access to internal networking data 
  209.      * according to the specified operations. The NET_RT_IFLIST operator
  210.      * traverses the entire internal "ifnet" linked list created when the
  211.      * network devices are initialized. The third argument, when non-zero,
  212.      * restricts the search to a particular unit number. In this case, all
  213.      * devices are examined. The first argument, when non-zero, limits the
  214.      * addresses to the specified address family. 
  215.      */
  217.     mib[0] = AF_INET;
  218.     mib[1] = NET_RT_IFLIST;
  219.     mib[2] = ifIndex;
  221.     /* 
  222.      * The first call to the routine determines the amount of space needed
  223.      * for the results. No data is actually copied.
  224.      */
  226.     if (sysctl_rtable(mib, 3, NULL, &needed, NULL, 0) < 0)
  227.         {
  228.         if (routedDebug)
  229.             logMsg ("Error %x estimating size of interface buffer.n", errno,
  230.                     0, 0, 0, 0, 0);
  231.         return (ERROR);
  232.         }
  234.     if (routedDebug)
  235.         logMsg ("Executing routedInit for iIndex = %d.n", ifIndex, 0, 0, 0, 0, 0);
  237.     /* 
  238.      * Allocate the required data, and repeat the system call to copy the
  239.      * actual values.
  240.      */
  242.     buf = malloc (needed);
  243.     if (buf == NULL)
  244.         {
  245.         if (routedDebug)
  246.             logMsg ("Error %x allocating interface buffer.n", errno,
  247.                     0, 0, 0, 0, 0);
  248.         return (ERROR);
  249.         }
  251.     if (sysctl_rtable(mib, 3, buf, &needed, NULL, 0) < 0)
  252.         {
  253.         if (routedDebug)
  254.             logMsg ("Error %x retrieving interface table.n", errno,
  255.                     0, 0, 0, 0, 0);
  256.         free (buf);
  257.         return (ERROR);
  258.         }
  260.     /* End of VxWorks specific stuff. */
  262.     /* 
  263.      * Analyze the retrieved data. The provided buffer now contains a 
  264.      * structure of type if_msghdr for each interface followed by zero 
  265.      * or more structures of type ifa_msghdr for each address for that
  266.      * interface. The if_msghdr structures have type fields of
  267.      * RTM_IFINFO and the address structures have type fields of 
  268.      * RTM_NEWADDR.
  269.      */
  271.     cplim = buf + needed;
  272.     for (cp = buf; cp < cplim; cp += ifm->ifm_msglen) 
  273.         {
  274.         ifm = (struct if_msghdr *)cp;
  276.         if (ifm->ifm_type == RTM_IFINFO) 
  277.             {
  278.             /* Parse the generic interface information. */
  280.             memset(&ifs, 0, sizeof(ifs));
  281.             ifs.int_flags = flags = (0xffff & ifm->ifm_flags) | IFF_INTERFACE;
  283.             /* 
  284.              * The sockaddr_dl structure containing the link-level address
  285.              * immediately follows the if_msghdr structure.
  286.              */
  288.             sdl = (struct sockaddr_dl *) (ifm + 1);
  289.             sdl->sdl_data[sdl->sdl_nlen] = 0;
  290.             no_ipaddr = 1;
  291.             continue;
  292.             }
  294.         /* 
  295.          * Only address entries should be present at this point.
  296.          * Exit if an unknown type is detected.
  297.          */
  299.         if (ifm->ifm_type != RTM_NEWADDR)
  300.             {
  301.             if (routedDebug)
  302.                 logMsg ("Unexpected entry in interface table.n", 
  303.                         0, 0, 0, 0, 0, 0);
  304.             free (buf);
  305.             return (ERROR);
  306.             }
  308.         /* If RIP is not desired on this interface, then so be it */
  310.         if (ripIfExcludeListCheck (sdl->sdl_data) == OK)
  311.             continue;
  313.         /* 
  314.          * Ignore the address information if the interface initialization
  315.          * is incomplete. Set flag to repeat the search at the next timer 
  316.          * interval.
  317.          */
  319.         if ( (flags & IFF_UP) == 0)
  320.             {
  321.             continue;
  322.             }
  324.         /* Access the address information through the ifa_msghdr structure. */
  326.         ifam = (struct ifa_msghdr *)ifm;
  328.         /* Reset the pointers to access the address pointers. */
  330.         info.rti_addrs = ifam->ifam_addrs;
  331.         _ripAddrsXtract ((char *)(ifam + 1), cp + ifam->ifam_msglen, &info);
  332.         if (IFAADDR == 0) 
  333.             {
  334.             if (routedDebug)
  335.                 logMsg ("No address for %s.n", (int)sdl->sdl_data,
  336.                         0, 0, 0, 0, 0);
  337.             continue;
  338.             }
  340.         /* Copy and process the actual address values. */
  342.         ifs.int_addr = *IFAADDR;
  343.         if (ifs.int_addr.sa_family != AF_INET)
  344.             continue;
  345.         no_ipaddr = 0;
  347.         if (ifs.int_flags & IFF_POINTOPOINT)
  348.             {
  349.             if (BRDADDR == 0)    /* No remote address specified? */
  350.                 {
  351.                 if (routedDebug)
  352.                     logMsg ("No dstaddr for %s.n", (int)sdl->sdl_data, 
  353.                             0, 0, 0, 0, 0);
  354.                 continue;
  355.                 }
  357.             if (BRDADDR->sa_family == AF_UNSPEC)
  358.                 {
  359.                 ripState.lookforinterfaces = TRUE;
  360.                 continue;
  361.                 }
  363.             /* Store the remote address for the link in the correct place. */
  365.             ifs.int_dstaddr = *BRDADDR;
  366.             }
  368.         /*
  369.          * Skip interfaces we already know about. But if there are
  370.          * other interfaces that are on the same network as the ones
  371.          * we already know about, we want to know about them as well.
  372.          */
  374.         if (ifs.int_flags & IFF_POINTOPOINT)
  375.             {
  376.             if (ripIfWithDstAddrAndIndex (&ifs.int_dstaddr, NULL, 
  377.                                           ifam->ifam_index))
  378.                 continue;
  379.             }
  380.         else if (ripIfWithAddrAndIndex (&ifs.int_addr, ifam->ifam_index))
  381.             continue;
  383.         if (ifs.int_flags & IFF_LOOPBACK)
  384.             {
  385.             ifs.int_flags |= IFF_PASSIVE;
  386.             foundloopback = 1;
  387.             loopaddr = ifs.int_addr;
  388.             for (ifp = ripIfNet; ifp; ifp = ifp->int_next)
  389.                  if (ifp->int_flags & IFF_POINTOPOINT)
  390.                      add_ptopt_localrt(ifp, 0);
  391.             }
  393.         /* Assign the broadcast address for the interface, if any. */
  395.         if (ifs.int_flags & IFF_BROADCAST)
  396.             {
  397.             if (BRDADDR == 0)
  398.                 {
  399.                 if (routedDebug)
  400.                     logMsg ("No broadcast address for %s.n",
  401.                             (int)sdl->sdl_data, 0, 0, 0, 0, 0);
  402.                 continue;
  403.                 }
  404.             ifs.int_dstaddr = *BRDADDR;
  405.             }
  407.          /*
  408.           * Use a minimum metric of one; treat the interface metric 
  409.           * (default 0) as an increment to the hop count of one.
  410.           */
  412.         ifs.int_metric = ifam->ifam_metric + 1;
  414.         /* Assign the network and subnet values. */
  416.         if (NETMASK == 0) 
  417.             {
  418.             if (routedDebug)
  419.                 logMsg ("No netmask for %s.n", (int)sdl->sdl_data,
  420.                         0, 0, 0, 0, 0);
  421.             continue;
  422.             }
  424.         /* 
  425.          * For AF_INET addresses, the int_subnetmask field copied here
  426.          * defaults to the class-based value for the associated int_addr 
  427.          * field, but will contain some other value if explicity specified.
  428.          */
  430.         sin = (struct sockaddr_in *)NETMASK;
  431.         ifs.int_subnetmask = ntohl (sin->sin_addr.s_addr);
  433.         /*
  434.          * The network number stored here may differ from the original
  435.          * value accessed through the ifnet linked list. The original value
  436.          * is equal to the class-based setting by default, but is reset
  437.          * to the same value as the int_subnetmask field if a less
  438.          * specific (i.e. supernetted) value is assigned. This value is
  439.          * always set equal to the class-based value, even if a supernet
  440.          * is specified.
  441.          */
  443.         sin = (struct sockaddr_in *)&ifs.int_addr;
  444.         i = ntohl(sin->sin_addr.s_addr);
  445.         if (IN_CLASSA(i))
  446.             ifs.int_netmask = IN_CLASSA_NET;
  447.         else if (IN_CLASSB(i))
  448.             ifs.int_netmask = IN_CLASSB_NET;
  449.         else
  450.             ifs.int_netmask = IN_CLASSC_NET;
  451.         ifs.int_net = i & ifs.int_netmask;
  453.         ifs.int_subnet = i & ifs.int_subnetmask;
  455.         /* 
  456.          * The IFF_SUBNET flag indicates that the interface does not use the
  457.          * class-based mask stored in the int_netmask field: it may be more 
  458.          * or less specific than that value.
  459.          */
  461.         if (ifs.int_subnetmask != ifs.int_netmask)
  462.             ifs.int_flags |= IFF_SUBNET;
  464.         ifp = (struct interface *)malloc (sdl->sdl_nlen + 1 + sizeof(ifs));
  465.         if (ifp == 0)
  466.             {
  467.             if (routedDebug)
  468.                 logMsg ("routedIfInit: out of memory.n", 0, 0, 0, 0, 0, 0);
  469.             ripState.lookforinterfaces = TRUE;
  470.             break;
  471.             }
  472.         *ifp = ifs;
  474.         /*
  475.          * Count the # of directly connected networks
  476.          * and point to point links which aren't looped
  477.          * back to ourself.  This is used below to
  478.          * decide if we should be a routing ``supplier''.
  479.          */
  481.         if ( (ifs.int_flags & IFF_LOOPBACK) == 0 &&
  482.             ( (ifs.int_flags & IFF_POINTOPOINT) == 0 ||
  483.              ripIfWithAddr (&ifs.int_dstaddr) == 0))
  484.             ripState.externalinterfaces++;
  486.         /*
  487.          * If we have a point-to-point link, we want to act
  488.          * as a supplier even if it's our only interface,
  489.          * as that's the only way our peer on the other end
  490.          * can tell that the link is up.
  491.          */
  493.         if ( (ifs.int_flags & IFF_POINTOPOINT) && ripState.supplier < 0)
  494.             ripState.supplier = 1;
  496.         /* 
  497.          * Copy the interface name specified in the link-level address. 
  498.          * into the space provided.
  499.          */
  501.         ifp->int_name = (char *)(ifp + 1);
  502.         strcpy (ifp->int_name, sdl->sdl_data);
  504.         /* Set the index of the interface */
  506.         ifp->int_index = ifam->ifam_index;
  508.         /* Add the given entry to the ripIfNet linked list. */
  510.         *ifnext = ifp;
  511.         ifnext = &ifp->int_next;
  513.         /* Create a route to the network reachable with the new address. */
  515.         addrouteforif (ifp);
  517.         /* Set the MIB variables for the configuration on this interface. */
  519.         bzero ( (char *)&ifp->ifStat, sizeof(ifp->ifStat));
  520.         bzero ( (char *)&ifp->ifConf, sizeof(ifp->ifConf));
  522.         sin = (struct sockaddr_in *)&ifs.int_addr;
  523.         i = sin->sin_addr.s_addr;
  524.         ifp->ifStat.rip2IfStatAddress = i;
  525.         ifp->ifConf.rip2IfConfAddress = i;
  526.         ifp->ifConf.rip2IfConfAuthType = ripState.ripConf.rip2IfConfAuthType;
  527.         bcopy (ripState.ripConf.rip2IfConfAuthKey,
  528.                ifp->ifConf.rip2IfConfAuthKey, 16);
  529.         ifp->ifConf.rip2IfConfSend = ripState.ripConf.rip2IfConfSend;
  530.         ifp->ifConf.rip2IfConfReceive = ripState.ripConf.rip2IfConfReceive;
  531.         ifp->ifConf.rip2IfConfDefaultMetric = 
  532.                                       ripState.ripConf.rip2IfConfDefaultMetric;
  533.         ifp->ifConf.rip2IfConfStatus = ripState.ripConf.rip2IfConfStatus;
  534.         ifp->authHook = NULL;
  535.         ifp->leakHook = NULL;
  536.         ifp->sendHook = NULL;
  538.         /*
  539.          * If multicasting is enabled and the interface supports it, 
  540.          * attempt to join the RIP multicast group.
  541.          */
  543.         if (ripState.multicast && (ifs.int_flags & IFF_MULTICAST))
  544.             {
  545.             ipMreq.imr_interface.s_addr = i;
  547.             if (setsockopt (ripState.s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
  548.                             (char *)&ipMreq, sizeof (ipMreq)) < 0)
  549.                 {
  550.                 if (routedDebug)
  551.                     logMsg ("setsockopt IP_ADD_MEMBERSHIP error:n",
  552.                             0, 0, 0, 0, 0, 0);
  553.                 }
  554.             }
  555.         }
  557.     if (ripState.externalinterfaces > 1 && ripState.supplier < 0)
  558.         ripState.supplier = 1;
  559.     free (buf);
  562.     return (OK);
  563.     }
  565. /*
  566.  * Add route for interface if not currently installed.
  567.  * Create route to other end if a point-to-point link,
  568.  * otherwise a route to this (sub)network.
  569.  * INTERNET SPECIFIC.
  570.  */
  571. void addrouteforif(ifp)
  572. register struct interface *ifp;
  573. {
  574. struct sockaddr_in net;
  575. struct sockaddr *dst;
  576. int state;
  577. register struct rt_entry *rt;
  578.         int refcnt_save = 0;
  579.         int subnets_cnt_save = 0;
  581.         /* Clear the fact there there are no routes for this interface */
  582.         ifp->int_flags &= ~IFF_ROUTES_DELETED;
  584.         /*
  585.          * The algorithm explained....
  586.          * We are going to add  route(s) for the interface.
  587.          * The following cases exist:
  588.          * 1) The interface is not PPP and  not-subnetted 
  589.          *    e.g, 164.10.1.1/16
  590.          *         In this case we just want to add the following route
  591.          *            164.10.0.0 255.255.0.0 --> 164.10.1.1
  592.          *         If there already exists another route for that same network,
  593.          *            if that route is not an internally generated route
  594.          *               increment rt_refcnt 
  595.          *            else
  596.          *               Delete the existing route and save its ref counts
  597.          *               Add route through this interface.
  598.          *               Set the reference counts from the previous route.
  599.          *               increment rt_refcnt and rt_subnets_cnt
  600.          *         else
  601.          *            Add the route through the inetrface
  602.          *            Set rt_refcnt and rt_subnets_cnt to zero
  603.          *
  604.          * 2) The interface is not PPP and is subnetted 
  605.          *    e.g, 164.10.2.1/24
  606.          *         In this case we want to add the following routes
  607.          *            164.10.2.0 255.255.255.0 --> 164.10.2.1
  608.          *            164.10.0.0 255.255.0.0   --> 164.10.2.1 (Internal route)
  609.          *         The internal route is used for border gateway filtering.
  610.          *
  611.          *         If there already exists another route for that same 
  612.          *          (sub)network,
  613.          *            if that route is not an internally generated route
  614.          *               increment rt_refcnt 
  615.          *            else
  616.          *               Delete the existing route and save its ref counts
  617.          *               Add route through this interface.
  618.          *               Set the reference counts from the previous route.
  619.          *               increment rt_refcnt and rt_subnets_cnt
  620.          *         else
  621.          *            Add the route through the inetrface
  622.          *            Set rt_refcnt and rt_subnets_cnt to zero
  623.          *         If there exists a route for the class based network
  624.          *            increment the rt_refcnt and rt_subnets_cnt for the route
  625.          *         else
  626.          *            Add the internal class based route. 
  627.          *            Set both the ref counts to zero.
  628.          *
  629.          * 3) The interface is PPP
  630.          *    e.g, 164.10.1.1/32 --> 124.10.2.2
  631.          *         In this case we just want to add the following routes
  632.          *            124.10.2.2   255.255.255.255  --> 164.10.1.1
  633.          *            164.10.1.1   255.255.255.255  --> 127.0.0.1
  634.          *         If there already exists another route for the destination
  635.          *            increment rt_refcnt 
  636.          *         else
  637.          *            Add the route through the inetrface
  638.          *            Set rt_refcnt and rt_subnets_cnt to zero
  639.          *         Add a route for the local address of the link thru the 
  640.          *          loopback interface.
  641.          */
  644.         /* Check if there already exists a route for the network (remote end)*/
  645. if (ifp->int_flags & IFF_POINTOPOINT)
  646. dst = &ifp->int_dstaddr;
  647. else {
  648. memset(&net, 0, sizeof (net));
  649.                 net.sin_len = sizeof (net);
  650. net.sin_family = AF_INET;
  651. net.sin_addr.s_addr = htonl (ifp->int_subnet);
  652. dst = (struct sockaddr *)&net;
  653. }
  654.         if ((rt = rtlookup(dst)) == NULL) 
  655.             rt = rtfind(dst);
  657. if (rt)
  658.             {
  659.             /* 
  660.              * If we have an indirect route to the destination, 
  661.              * delete it as we now have a direct route
  662.              */
  663.             if ((rt->rt_state & RTS_INTERFACE) == 0)
  664.                 rtdelete (rt);
  665.             else
  666.                 {
  667.                 if (ifp->int_flags & IFF_POINTOPOINT)
  668.                     {
  669.                     rt->rt_refcnt++;
  670.                     if (ifp->int_flags & IFF_POINTOPOINT && foundloopback) 
  671.                         add_ptopt_localrt(ifp, 0);
  672.                     return;
  673.                     }
  675.                 if ((rt->rt_state & (RTS_INTERFACE | RTS_INTERNAL))
  676.                         == RTS_INTERFACE)
  677.                     {
  678.                     /* The route is not an internal route */
  679.                     if (rt->rt_ifp->int_subnetmask == ifp->int_subnetmask)
  680.                         {
  681.                         /* 
  682.                          * This interface is on the same (sub)network as the
  683.                          * retrieved route. Increment the reference count.
  684.                          */
  685.                         rt->rt_refcnt++;
  687.                         /*
  688.                          * If the interface uses classless addressing, 
  689.                          * an additional entry is stored in the routing table
  690.                          * which can be correctly interpreted by RIP-1 and 
  691.                          * RIP-2 routers that are not directly connected to
  692.                          * the interface's network. The appropriate entry is
  693.                          * selected by the border gateway filtering performed
  694.                          * when updates are generated.
  695.                          */
  697.                         if (ifp->int_flags & IFF_SUBNET) 
  698.                             {
  699.                             net.sin_addr.s_addr = htonl (ifp->int_net);
  700.                             if ((rt = rtlookup(dst)) == NULL) 
  701.                                 rt = rtfind(dst);
  702.                             if (rt == 0)
  703.                                 {
  704.                                 if (routedDebug) 
  705.                                     logMsg ("Error! Didn't find classful route"
  706.                                             " for %x, interface %s.n", 
  707.                                             (int)ifp->int_net, 
  708.                                             (int)ifp->int_name, 0, 0, 0, 0);
  709.                                 }
  710.                             else 
  711.                                 {
  712.                                 rt->rt_refcnt++;
  713.                                 rt->rt_subnets_cnt++;
  714.                                 if ((rt->rt_state & (RTS_INTERNAL|RTS_SUBNET))
  715.                                     == (RTS_INTERNAL|RTS_SUBNET) && 
  716.                                     (ifp->int_metric < rt->rt_metric))
  717.                                     rtchange (rt, &ifp->int_addr, 
  718.                                               ifp->int_metric, NULL, 0, 0, 
  719.                                               ifp);
  720.                                 }
  721.                             }
  722.                         return;
  723.                         }
  724.                     }
  725.                 else
  726.                     {
  727.                     /*
  728.                      * If this was a classful route installed by an earlier
  729.                      * subnetted interface, save the reference count values
  730.                      * as we'll need to restore them on the route that will
  731.                      * be installed later
  732.                      */
  733.                     refcnt_save = rt->rt_refcnt + 1; 
  734.                     subnets_cnt_save = rt->rt_subnets_cnt + 1;
  735.                     rtdelete (rt);
  736.                     }
  737.                 }
  738.             }
  740. /*
  741.  * If the interface uses classless addressing, an additional entry
  742.          * is stored in the routing table which can be correctly interpreted
  743.          * by RIP-1 and RIP-2 routers that are not directly connected to
  744.          * the interface's network. The appropriate entry is selected by the
  745.          * border gateway filtering performed when updates are generated.
  746.  */
  748. if ((ifp->int_flags & (IFF_SUBNET|IFF_POINTOPOINT)) == IFF_SUBNET) {
  749. struct in_addr subnet;
  751. subnet = net.sin_addr;
  752. net.sin_addr.s_addr = htonl (ifp->int_net);
  753. if ((rt = rtlookup(dst)) == NULL) 
  754.     rt = rtfind(dst);
  755. if (rt == 0) 
  756.                     rt = rtadd(dst, &ifp->int_addr, ifp->int_metric,
  757.                                ((ifp->int_flags & (IFF_INTERFACE|IFF_REMOTE)) |
  758.                                 RTS_PASSIVE | RTS_INTERNAL | RTS_SUBNET), 
  759.                                NULL, M2_ipRouteProto_rip, 0, 0, ifp);
  760. else 
  761.                     {
  762.                     rt->rt_refcnt++; 
  763.                     rt->rt_subnets_cnt++; 
  764.                     if ((rt->rt_state & (RTS_INTERNAL|RTS_SUBNET)) == 
  765.                         (RTS_INTERNAL|RTS_SUBNET) && 
  766.                         (ifp->int_metric < rt->rt_metric))
  767.                         rtchange(rt, &ifp->int_addr, ifp->int_metric, NULL, 
  768.                                  0, 0, ifp);
  769.                     }
  770. net.sin_addr = subnet;
  771. }
  772. if (ifp->int_transitions++ > 0)
  773.             if (routedDebug)
  774. logMsg ("Warning! Re-installing route for interface %s.n", 
  775.                         (int)ifp->int_name, 0, 0, 0, 0, 0);
  776. state = ifp->int_flags &
  777.     (IFF_INTERFACE | IFF_PASSIVE | IFF_REMOTE | IFF_SUBNET);
  778. if (ifp->int_flags & IFF_POINTOPOINT && 
  779.             (ntohl(((struct sockaddr_in *)&ifp->int_dstaddr)->sin_addr.s_addr)
  780.              & ifp->int_netmask) != ifp->int_net)
  781. state &= ~RTS_SUBNET;
  782. if (ifp->int_flags & IFF_LOOPBACK)
  783. state |= RTS_EXTERNAL;
  784. rt = rtadd(dst, &ifp->int_addr, ifp->int_metric, state, NULL, 
  785.                    M2_ipRouteProto_rip, 0, 0, ifp);
  786.         /*
  787.          * Now set the reference counts.
  788.          * This might be a network route that replaced a previous
  789.          * classful route. If we had any references on that earlier
  790.          * route we need to transfer them here
  791.          */
  792.         rt->rt_refcnt = refcnt_save;
  793.         rt->rt_subnets_cnt = subnets_cnt_save;
  795. if (ifp->int_flags & IFF_POINTOPOINT && foundloopback)
  796.                     add_ptopt_localrt(ifp, 0);
  797.     }
  799. /*
  800.  * Add route to local end of point-to-point using loopback.
  801.  * If a route to this network is being sent to neighbors on other nets,
  802.  * mark this route as subnet so we don't have to propagate it too.
  803.  */
  804. int add_ptopt_localrt(ifp, refcnt)
  805.     register struct interface *ifp;
  806.     int refcnt;
  807.     {
  808.     struct rt_entry *rt;
  809.     struct sockaddr *dst;
  810.     struct sockaddr_in net;
  811.     int state;
  812.     struct sockaddr_in hostMask = {
  813.     sizeof (struct sockaddr_in),
  814.     AF_INET, 0, {INADDR_BROADCAST} };
  816.     state = RTS_INTERFACE | RTS_PASSIVE;
  818.     /* look for route to logical network */
  819.     memset(&net, 0, sizeof (net));
  820.     net.sin_len = sizeof (net);
  821.     net.sin_family = AF_INET;
  822.     net.sin_addr.s_addr = htonl (ifp->int_net);
  823.     dst = (struct sockaddr *)&net;
  824.     if ((rt = rtlookup(dst)) == NULL) 
  825.         rt = rtfind(dst);
  826.     if (rt && rt->rt_state & RTS_INTERNAL)
  827.         state |= RTS_SUBNET;
  829.     dst = &ifp->int_addr;
  830.     rt = rtfind (dst);
  831.     if (rt) 
  832.         {
  833.         if (rt->rt_state & RTS_INTERFACE)
  834.             {
  835.             /*
  836.              * We are piggybacking onto somebody else' route. So we
  837.              * should increment the ref count
  838.              */
  839.             if (refcnt == 0)
  840.                 refcnt = 1;
  842.             rt->rt_refcnt += refcnt; 
  843.             return (ERROR);
  844.             }
  845.         rtdelete(rt);
  846.         }
  848.     rt = rtadd(dst, &loopaddr, 1, state, (struct sockaddr *)&hostMask,
  849.                M2_ipRouteProto_rip, 0, 0, NULL);
  850.     if (rt)
  851.         rt->rt_refcnt = refcnt;
  853.     return (OK);
  854.     }
  856. /*
  857.  * Add route for interface or an internal network route for
  858.  * a subnetted interface
  859.  * This routine is called from the rtdelete() routine when an
  860.  * interface route is deleted and there exists other references to that
  861.  * route. This routine will add the route through another interface
  862.  * and adjust the reference count accordingly.
  863.  * The internalFlag is set when an internally generated classful route
  864.  * should be added. If the flag is not set, then a regular interface
  865.  * route is added.
  866.  * In the simplest of cases, wherein the route being deleted was referenced
  867.  * by another interface on the same network, a new route is added through that
  868.  * other interface.
  869.  *
  870.  * In other cases, the network route being deleted might be referenced by
  871.  * point to point interfaces on the same network: e.g
  872.  *   164.10.0.0/16  -->  164.10.1.1   (being deleted)
  873.  *   is referenced by the following PPP interface
  874.  *      src = 164.10.22.1, dst=164.10.22.2
  875.  * In the above case the rt_refcnt field of the route (prior to rtdelete)
  876.  * would be 2 and rt_subnets_cnt would be 0. On call to this routine,
  877.  * refCnt would be 1 and subnetsCnt would be 0
  878.  * This routine would need to add the following routes in response to the
  879.  * deletion of the 164.10.0.0/16  -->  164.10.1.1 route:
  880.  *    164.10.22.2/32 --> 164.10.22.1
  881.  *    164.10.22.1/32 --> 127.0.0.1
  882.  * Both the above routes should have rt_refcnt and rt_subnets_cnt set to zero
  883.  *
  884.  * There are many other cases where just the local or the remote end of the PPP
  885.  * interface may be referencing the route being deleted, or there may be
  886.  * multiple such interfaces. 
  887.  *     
  888.  * INPUT
  889.  *    pAddr     -  Destination of the interface route being deleted
  890.  *    refCnt    -  How many more references to this route exist
  891.  *    subnetsCnt-  How many subnetted interfaces exist for this network
  892.  *    internalFlag-Should an internal or a regular interface route be added
  893.  *    subnetMask-  Mask associated with the route being deleted
  894.  *
  895.  * NOMANUAL
  896.  *
  897.  * NOTE: INTERNET SPECIFIC.
  898.  */
  899. void ifRouteAdd
  900.     (
  901.     struct sockaddr * pAddr,
  902.     int refCnt,
  903.     int subnetsCnt,
  904.     BOOL internalFlag,
  905.     u_long subnetMask
  906.     )
  907.     {
  908.     register struct interface *ifp = 0;
  909.     register struct interface *pPPPIfp = 0;
  910.     register struct interface *pNetIfp = 0;
  911.     register struct interface *pSubnetIfp = 0;
  912.     register struct interface *pIfMax;
  913.     register int af = pAddr->sa_family;
  914.     register u_long dstaddr;
  915.     int addLocalRoute = 0;
  916.     int addDstRoute = 0;
  917.     int state; 
  918.     struct rt_entry *rt;
  920.     if (af >= AF_MAX) 
  921.         return;
  923.     pIfMax = 0;
  925.     dstaddr = ntohl (((struct sockaddr_in *)pAddr)->sin_addr.s_addr);
  927.     /*
  928.      * If we need to add an "internal" route (a classful route for a
  929.      * subnetted network - to be used for border gateway filtering)
  930.      * Look for a list of subnetted interfaces that are on the same network
  931.      * as the current route, and add a class based network route through
  932.      * the interface that has the least metric
  933.      */
  934.     if (internalFlag)
  935.         {
  936.         for (ifp = ripIfNet; ifp; ifp = ifp->int_next) 
  937.             {
  938.             if (ifp->int_flags & IFF_REMOTE || !(ifp->int_flags & IFF_UP) || 
  939.                 ifp->int_flags & IFF_POINTOPOINT)
  940.                 continue;
  941.             if (af != ifp->int_addr.sa_family) 
  942.                 continue;
  944.             if ((ifp->int_netmask != ifp->int_subnetmask) && 
  945.                 (dstaddr == ifp->int_net)) 
  946.                 {
  947.                 if (!pSubnetIfp || pSubnetIfp->int_metric > ifp->int_metric)
  948.                     pSubnetIfp = ifp;
  950.                 if (routedDebug > 2)
  951.                     {
  952.                     logMsg ("internalFlag: found ifp = %xn", (int)pSubnetIfp, 0,
  953.                             0, 0, 0, 0);
  954.                     _ripIfShow (pSubnetIfp);
  955.                     }
  956.                 }
  957.             }
  958.         ifp = pSubnetIfp;
  959.         }
  960.     else
  961.         {
  962.         for (ifp = ripIfNet; ifp; ifp = ifp->int_next) 
  963.             {
  964.             if (ifp->int_flags & IFF_REMOTE || !(ifp->int_flags & IFF_UP))
  965.                 continue;
  966.             if (af != ifp->int_addr.sa_family) 
  967.                 continue;
  969.             /* See if the address matches any end of the PPP links */
  970.             if ((ifp->int_flags & IFF_POINTOPOINT)) 
  971.                 {
  972.                 if (same (&ifp->int_dstaddr, pAddr) || 
  973.                     same (&ifp->int_addr, pAddr)) 
  974.                     {
  975.                     if (!pPPPIfp || pPPPIfp->int_metric > ifp->int_metric)
  976.                         pPPPIfp = ifp; 
  977.                     if (routedDebug > 2)
  978.                         {
  979.                         logMsg ("PPP: found ifp = %xn", (int)pPPPIfp, 0,
  980.                                 0, 0, 0, 0);
  981.                         _ripIfShow (pPPPIfp);
  982.                         }
  983.                     }
  984.                 }
  986.             /*
  987.              * It would seem that the two else if cases below could be
  988.              * replaced with a single if (dstaddr == ifp->int_subnet)
  989.              * but the above case will not be able to distinguish between
  990.              * 164.10.0.0/16 and 164.10.0.0/24. Hence we need to
  991.              * compare separately
  992.              */
  993.             else if ((ifp->int_netmask == ifp->int_subnetmask) &&
  994.                      (dstaddr == ifp->int_net)) 
  995.                 {
  996.                 if (!pNetIfp || pNetIfp->int_metric > ifp->int_metric)
  997.                     pNetIfp = ifp;
  998.                 if (routedDebug > 2)
  999.                     {
  1000.                     logMsg ("NET: found ifp = %xn", (int)pNetIfp, 0,
  1001.                             0, 0, 0, 0);
  1002.                     _ripIfShow (pNetIfp);
  1003.                     }
  1004.                 }
  1005.             else if ((ifp->int_netmask != ifp->int_subnetmask) &&
  1006.                      (dstaddr == ifp->int_subnet)) 
  1007.                 {
  1008.                 if (!pSubnetIfp || pSubnetIfp->int_metric > ifp->int_metric)
  1009.                     pSubnetIfp = ifp;
  1010.                 if (routedDebug > 2)
  1011.                     {
  1012.                     logMsg ("SUBNET: found ifp = %xn", (int)pSubnetIfp, 0,
  1013.                             0, 0, 0, 0);
  1014.                     _ripIfShow (pSubnetIfp);
  1015.                     }
  1016.                 }
  1017.             }
  1019.         ifp = pPPPIfp ? pPPPIfp : (pNetIfp ? pNetIfp : pSubnetIfp);
  1020.         if (ifp == NULL)
  1021.             {
  1022.             /*
  1023.              * We did not find any interface that matched the address of the
  1024.              * route being deleted. This must be the following case:
  1025.              *   164.10.0.0/16  -->  164.10.1.1   (being deleted)
  1026.              *   is referenced by the following PPP interface
  1027.              *      src = 164.10.22.1, dst=164.10.22.2
  1028.              * So now, search for PPP interfaces that lie on the same
  1029.              * network as the route being deleted. We do that by applying the
  1030.              * netmask of the route to the PPP interface address. 
  1031.              * If we have both ends of the link on the same network, then we
  1032.              * will have to add two routes:
  1033.              *   one for the remote end.
  1034.              *   one for the local end
  1035.              */
  1036.             pAddr = NULL;
  1037.             for (ifp = ripIfNet; ifp; ifp = ifp->int_next) 
  1038.                 {
  1039.                 if (ifp->int_flags & IFF_REMOTE || !(ifp->int_flags & IFF_UP))
  1040.                     continue;
  1041.                 if (af != ifp->int_addr.sa_family) 
  1042.                     continue;
  1044.                 if ((ifp->int_flags & IFF_POINTOPOINT)) 
  1045.                     {
  1046.                     if ((ntohl(((struct sockaddr_in *)
  1047.                                 &ifp->int_dstaddr)->sin_addr.s_addr) & 
  1048.                          subnetMask) == dstaddr)
  1049.                         {
  1050.                         addDstRoute = 1;
  1051.                         if (routedDebug > 2)
  1052.                             {
  1053.                             logMsg ("Add PPP dest route for %x.n", (int)ifp, 0,
  1054.                                     0, 0, 0, 0);
  1055.                             _ripIfShow (ifp);
  1056.                             }
  1057.                         if (!pPPPIfp || pPPPIfp->int_metric > ifp->int_metric)
  1058.                             pPPPIfp = ifp; 
  1059.                         pAddr = &ifp->int_dstaddr;
  1060.                         }
  1061.                     if ((ntohl(((struct sockaddr_in *)
  1062.                                 &ifp->int_addr)->sin_addr.s_addr) & 
  1063.                          subnetMask) == dstaddr)
  1064.                         {
  1065.                         addLocalRoute = 1;
  1066.                         if (routedDebug > 2)
  1067.                             {
  1068.                             logMsg ("Add PPP local route for %x.n", (int)ifp, 0,
  1069.                                     0, 0, 0, 0);
  1070.                             _ripIfShow (ifp);
  1071.                             }
  1072.                         if (!pPPPIfp || pPPPIfp->int_metric > ifp->int_metric)
  1073.                             pPPPIfp = ifp; 
  1074.                         break;
  1075.                         }
  1076.                     }
  1077.                 }
  1078.             ifp = pPPPIfp;
  1079.             }
  1080.         }
  1082.     if (ifp == NULL)
  1083.         {
  1084.         if (routedDebug > 2)
  1085.             logMsg ("No ifp foundn", 0, 0, 0, 0, 0, 0);
  1086.         return;
  1087.         }
  1089.     /*
  1090.      * If both the local and remote end were on the same network, we had
  1091.      * incremented the refcount by 2 when we added the route. So account
  1092.      * for that. rtdelete() had already decremented the refcount by 1
  1093.      */
  1094.     if (addDstRoute && addLocalRoute)
  1095.         refCnt--;
  1097.     /*
  1098.      * pAddr will be set to NULL if we just need to add a route to the
  1099.      * local end of the PPP link. In all other cases, add the route
  1100.      */
  1101.     if (pAddr)
  1102.         {
  1103.         state = ifp->int_flags &
  1104.             (IFF_INTERFACE | IFF_PASSIVE | IFF_REMOTE | IFF_SUBNET);
  1105.         if (ifp->int_flags & IFF_POINTOPOINT && 
  1106.             (same (&ifp->int_dstaddr, pAddr)) &&
  1107.             (ntohl(((struct sockaddr_in *)&ifp->int_dstaddr)->sin_addr.s_addr) 
  1108.              & ifp->int_netmask) != ifp->int_net)
  1109.                 state &= ~RTS_SUBNET;
  1111.         if (internalFlag)
  1112.             rt = rtadd(pAddr, &ifp->int_addr, ifp->int_metric,
  1113.                        ((ifp->int_flags & (IFF_INTERFACE|IFF_REMOTE)) |
  1114.                         RTS_PASSIVE | RTS_INTERNAL | RTS_SUBNET), 
  1115.                        NULL, M2_ipRouteProto_rip, 0, 0, ifp);
  1116.         else
  1117.             rt = rtadd(pAddr, &ifp->int_addr, ifp->int_metric, state, NULL, 
  1118.                        M2_ipRouteProto_rip, 0, 0, ifp);
  1119.         /*
  1120.          * Now set the reference counts.
  1121.          */
  1122.         if (rt)
  1123.             {
  1124.             rt->rt_refcnt = refCnt;
  1125.             rt->rt_subnets_cnt = subnetsCnt;
  1126.             }
  1127.         }
  1129.     /* Now add route to the local end of PPP link, if needed */
  1130.     if (addLocalRoute) 
  1131.         add_ptopt_localrt(ifp, refCnt);
  1132.         
  1133.     }