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

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

VxWorks

开发平台：

C/C++

rtsock.c：源码内容
  1. /* rtsock.c - routines for routing sockets */
  3. /* Copyright 1990 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1988, 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.  * @(#)rtsock.c 8.6 (Berkeley) 2/11/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01g,12oct01,rae  merge from truestack ver 01u, base o1f (SPR #70185 ROUTER_STACK)
  45. 01f,26aug98,n_s  added return val check for MALLOC in route_usrreq. spr #22238.
  46. 01e,04dec97,vin  moved back m_copyback and m_copydata from uipc_mbuf.c as
  47.  these are only used in rt_sock. Ifdefed m_copyback and
  48.                  m_copydata in uipc_mbuf.c these need some rework so that
  49.                  they can be tied up efficiently with the new buffering scheme.
  50. 01d,01jul97,vin  added rtSockInit, removed route_init from routedomain, it is
  51.  called from netLibInit. Added route message hooks for
  52.                  scalability.
  53. 01c,05dec96,vin  changed malloc(..) to MALLOC(..) to use only network buffers,
  54.  changed free(..) to FREE(..).
  55. 01b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
  56.  m_gethdr(..) with mHdrClGet(..), moved m_copyback(..) to 
  57.  uipc_mbuf.c
  58. 01a,03mar96,vin  created from BSD4.4lite2.
  59. */
  61. #include "net/systm.h"
  62. #include "net/mbuf.h"
  63. #include "sys/socket.h"
  64. #include "net/socketvar.h"
  65. #include "net/domain.h"
  66. #include "net/protosw.h"
  67. #include "net/unixLib.h"
  69. #include "net/if.h"
  70. #include "net/route.h"
  71. #include "net/raw_cb.h"
  72. #include "netinet/in.h"
  74. #include "routeEnhLib.h"
  76. #ifdef WV_INSTRUMENTATION
  77. #ifdef INCLUDE_WVNET
  78. #include "wvNetLib.h"
  79. #endif
  80. #endif
  82. #ifdef ROUTER_STACK
  83. #define SOCKADDR_IN(s) (((struct sockaddr_in*)(s))->sin_addr.s_addr)
  84. #endif
  86. struct walkarg {
  87. int w_op, w_arg, w_given, w_needed, w_tmemsize;
  88. caddr_t w_where, w_tmem;
  89. };
  91. #ifndef VIRTUAL_STACK
  92.     /*
  93.      * This global counts the number of routing socket listeners
  94.      * for a particular family. It is not used outside this module.
  95.      */
  97. struct  route_cb route_cb;
  98. #endif
  100. static struct sockaddr route_dst = { 2, PF_ROUTE, };
  101. static struct sockaddr route_src = { 2, PF_ROUTE, };
  103. #ifndef VIRTUAL_STACK
  104.     /*
  105.      * The following protocol structure is the only global in this module
  106.      * which differs between virtual stacks. It limits the routing messages
  107.      * based on the associated address family, if a specific protocol value
  108.      * is chosen during the socket creation.
  109.      *
  110.      * The source address variable above is read, but never altered. It
  111.      * is the preassigned remote address for all routing sockets, which
  112.      * disables the use of any alternatives when writing to a socket and
  113.      * limits the delivery of any routing message to members of the routing
  114.      * socket family.
  115.      *
  116.      * Since the bind operation is not supported, a local address can't be
  117.      * assigned to a routing socket. As a result, the preceding destination
  118.      * address variable, although passed to the routine which sends routing
  119.      * messages to any listening sockets, is never actually used.
  120.      */ 
  121.      
  122. static struct sockproto route_proto = { PF_ROUTE, };
  123. #endif /* VIRTUAL_STACK */
  125. #ifdef ROUTER_STACK
  126. IMPORT void routeIfStatusUpdate (struct ifnet *);
  127. IMPORT void routeIfAddressUpdate (int, struct ifaddr *, struct rtentry *);
  128. IMPORT void routeMissUpdate (int, struct rt_addrinfo *, int, int);
  129. #endif /* ROUTER_STACK */
  131. IMPORT int rt_fixdelete (struct radix_node *, void *);
  132. struct mbuf *
  133. rt_msg1 (int, struct rt_addrinfo *);
  134. static int rt_msg2 (int, struct rt_addrinfo *, caddr_t, 
  135.  struct walkarg *);
  136. static void rt_xaddrs (caddr_t, caddr_t, struct rt_addrinfo *);
  138. static int route_usrreq (struct socket *, int, struct mbuf *,
  139.                               struct mbuf *, struct mbuf *);
  140. void rt_ifmsg (struct ifnet *);
  141. void rt_missmsg (int, struct rt_addrinfo *, int, int);
  142. void rt_newaddrmsg (int, struct ifaddr *, int, struct rtentry *);
  143. static int route_output (struct mbuf *, struct socket *);
  144. static void rt_setmetrics (u_long, struct rt_metrics *,
  145.                                struct rt_metrics *);
  147. static void m_copyback (struct mbuf *, int, int, caddr_t);
  148. static void  m_copydata(struct mbuf *, int, int, caddr_t);
  150. #ifdef ROUTER_STACK
  151. LOCAL int routeGatewayFetch (struct rtentry *, struct rt_msghdr *);
  152. LOCAL ROUTE_ENTRY * routeMatch (struct rtentry *, short, struct sockaddr *);
  153. #endif /* ROUTER_STACK */
  155. #ifdef WV_INSTRUMENTATION
  156. #ifdef INCLUDE_WVNET
  157.     /* Set common fields of event identifiers for this module. */
  159. LOCAL UCHAR wvNetModuleId = WV_NET_RTSOCK_MODULE;   /* Value for rtsock.c */
  160. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  162. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  163. #endif    /* INCLUDE_WVNET */
  164. #endif
  166. /* Sleazy use of local variables throughout file, warning!!!! */
  167. #define dst info.rti_info[RTAX_DST]
  168. #define gate info.rti_info[RTAX_GATEWAY]
  169. #define netmask info.rti_info[RTAX_NETMASK]
  170. #define genmask info.rti_info[RTAX_GENMASK]
  171. #define ifpaddr info.rti_info[RTAX_IFP]
  172. #define ifaaddr info.rti_info[RTAX_IFA]
  173. #define brdaddr info.rti_info[RTAX_BRD]
  176. /*******************************************************************************
  177. * rtSockInit - intialize route sockets
  178. *
  179. * This function initializes the route msg hooks used in various places in the
  180. * system. The hooks are provided to scale out route sockets. The same hooks
  181. * also generate the internal callback messages for the router stack product.
  182. *
  183. * The domain_init entry point of the route socket domain calls this function.
  184. *
  185. * RETURNS: N/A
  186. *
  187. * NOMANUAL
  188. */
  190. LOCAL void rtSockInit (void)
  191.     {
  192. #ifdef WV_INSTRUMENTATION
  193. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  194.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 36, 8,
  195.                      WV_NETEVENT_RTSOCKINIT_START)
  196. #endif  /* INCLUDE_WVNET */
  197. #endif
  199.     /* Set the function hooks for receiving status changes from the stack. */
  201. #ifdef ROUTER_STACK
  202.     rtIfaceMsgHook = routeIfStatusUpdate;
  203.     rtNewAddrMsgHook = routeIfAddressUpdate;
  204.     rtMissMsgHook = routeMissUpdate;
  205. #else
  206.     rtIfaceMsgHook = rt_ifmsg;
  207.     rtNewAddrMsgHook = rt_newaddrmsg;
  208.     rtMissMsgHook = rt_missmsg;
  209. #endif /* ROUTER_STACK */
  211.     raw_init ();       /* initialize the raw control block */
  212.     }
  213.     
  214. /*ARGSUSED*/
  215. static int
  216. route_usrreq(so, req, m, nam, control)
  217. register struct socket *so;
  218. int req;
  219. struct mbuf *m, *nam, *control;
  220. {
  221. register int error = 0;
  222. register struct rawcb *rp = sotorawcb(so);
  223. int s;
  225. #ifdef WV_INSTRUMENTATION
  226. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  227.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 21, 6,
  228.                      WV_NETEVENT_ROUTEREQ_START, so->so_fd, req)
  229. #endif  /* INCLUDE_WVNET */
  230. #endif
  232. if (req == PRU_ATTACH) {
  233. MALLOC(rp, struct rawcb *, sizeof(*rp), MT_PCB, M_WAIT);
  234. if (rp == (struct rawcb *) NULL)
  235.     {
  236.     return (ENOBUFS);
  237.     }
  238. if ((so->so_pcb = (caddr_t)rp))
  239. bzero(so->so_pcb, sizeof(*rp));
  241. }
  242. if (req == PRU_DETACH && rp) {
  243. int af = rp->rcb_proto.sp_protocol;
  244. if (af == AF_INET)
  245. route_cb.ip_count--;
  246. else if (af == AF_NS)
  247. route_cb.ns_count--;
  248. else if (af == AF_ISO)
  249. route_cb.iso_count--;
  250. route_cb.any_count--;
  251. }
  252. s = splnet();
  253. error = raw_usrreq(so, req, m, nam, control);
  254. rp = sotorawcb(so);
  255. if (req == PRU_ATTACH && rp) {
  256. int af = rp->rcb_proto.sp_protocol;
  257. if (error) {
  258. FREE(rp, MT_PCB);
  259. splx(s);
  260. return (error);
  261. }
  262. if (af == AF_INET)
  263. route_cb.ip_count++;
  264. else if (af == AF_NS)
  265. route_cb.ns_count++;
  266. else if (af == AF_ISO)
  267. route_cb.iso_count++;
  268. rp->rcb_faddr = &route_src;
  269. route_cb.any_count++;
  270. soisconnected(so);
  271. so->so_options |= SO_USELOOPBACK;
  272. }
  273. splx(s);
  274. return (error);
  275. }
  277. /*ARGSUSED*/
  278. static int
  279. route_output(m, so)
  280. register struct mbuf *m;
  281. struct socket *so;
  282. {
  283. register struct rt_msghdr *rtm = 0;
  284. register struct rtentry *rt = 0;
  285. struct rtentry *saved_nrt = 0;
  286. struct radix_node_head *rnh;
  287. struct rt_addrinfo info;
  288. int len, error = 0;
  289. struct ifnet *ifp = 0;
  290. struct ifaddr *ifa = 0;
  292. #ifdef ROUTER_STACK
  293.         struct sockaddr * pGateway = 0;
  294.         short             protoId = 0;
  295.         ROUTE_ENTRY *     pRoute = NULL;
  296. #endif
  298. #define senderr(e) { error = e; goto flush;}
  300. #ifdef WV_INSTRUMENTATION
  301. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  302.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_NOTICE, 5, 5, 
  303.                      WV_NETEVENT_RTOUTPUT_START, so->so_fd)
  304. #endif  /* INCLUDE_WVNET */
  305. #endif
  307. if (m == 0 || ((m->m_len < sizeof(long)) &&
  308.        (m = m_pullup(m, sizeof(long))) == 0))
  309.             {
  310. #ifdef WV_INSTRUMENTATION
  311. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  312.             WV_NET_EVENT_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 24, 1, 
  313.                             WV_NETEVENT_RTOUT_BADMSG, WV_NET_SEND,
  314.                             so->so_fd)
  315. #endif  /* INCLUDE_WVNET */
  316. #endif
  318.             return (ENOBUFS);
  319.             }
  321. if ((m->m_flags & M_PKTHDR) == 0)
  322.             {
  323. #ifdef WV_INSTRUMENTATION
  324. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  325.             WV_NET_EVENT_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 25, 2, 
  326.                             WV_NETEVENT_RTOUT_PANIC, WV_NET_SEND,
  327.                             so->so_fd)
  328. #endif  /* INCLUDE_WVNET */
  329. #endif
  331.             panic("route_output");
  332.             }
  333. len = m->m_pkthdr.len;
  334. if (len < sizeof(*rtm) ||
  335.     len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
  336. dst = 0;
  337. senderr(EINVAL);
  338. }
  339. R_Malloc(rtm, struct rt_msghdr *, len);
  340. if (rtm == 0) {
  341. dst = 0;
  342. senderr(ENOBUFS);
  343. }
  344. m_copydata(m, 0, len, (caddr_t)rtm);
  345. if (rtm->rtm_version != RTM_VERSION) {
  346. dst = 0;
  347. senderr(EPROTONOSUPPORT);
  348. }
  349. info.rti_addrs = rtm->rtm_addrs;
  350. rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info);
  351. if (dst == 0)
  352. senderr(EINVAL);
  353. if (genmask) {
  354. struct radix_node *t;
  355. t = rn_addmask((caddr_t)genmask, 0, 1);
  356. if (t && Bcmp(genmask, t->rn_key, *(u_char *)genmask) == 0)
  357. genmask = (struct sockaddr *)(t->rn_key);
  358. else
  359. senderr(ENOBUFS);
  360. }
  361. switch (rtm->rtm_type) {
  363. case RTM_ADD:
  364. if (gate == 0)
  365. senderr(EINVAL);
  367.                 /*
  368.                  * Create the new route using the default weight value.
  369.                  * Report the change using direct callbacks, but do not
  370.                  * generate a routing socket message to avoid duplicates.
  371.                  */
  373.                 error = rtrequestAddEqui(dst, netmask, gate, rtm->rtm_flags,
  374.  M2_ipRouteProto_other, 0, TRUE,
  375.                                          FALSE, (ROUTE_ENTRY **) &saved_nrt);
  376. if (error == 0 && saved_nrt) {
  377. rt_setmetrics(rtm->rtm_inits,
  378. &rtm->rtm_rmx, &saved_nrt->rt_rmx);
  380. #ifdef ROUTER_STACK
  381.                         /* Set the initial weight value, if any. */
  383.                         if (rtm->rtm_inits & RTV_WEIGHT)
  384.                             saved_nrt->rt_rmx.weight = rtm->rtm_rmx.weight;
  385. #endif
  387. saved_nrt->rt_refcnt--;
  388. saved_nrt->rt_genmask = genmask;
  390. #ifdef ROUTER_STACK
  391.                 /* Use different message type for additional routes. */
  393.                 if ( ((ROUTE_ENTRY *)saved_nrt)->primaryRouteFlag == FALSE)
  394.                     rtm->rtm_type = RTM_ADDEXTRA;
  395. #endif
  396. }
  397. break;
  399. case RTM_DELETE:
  400.                 /*
  401.                  * Delete the matching route entry. Report the change using
  402.                  * direct callbacks, but do not generate a routing socket
  403.                  * message to avoid duplicates.
  404.                  */
  406.                 error = rtrequestDelEqui(dst, netmask, gate, rtm->rtm_flags,
  407.  M2_ipRouteProto_other, TRUE, FALSE,
  408.  (ROUTE_ENTRY **) &saved_nrt);
  409. if (error == 0) {
  410. (rt = saved_nrt)->rt_refcnt++;
  412. #ifdef ROUTER_STACK
  413.                 /* Use different message type for additional routes. */
  415.                 if ( ((ROUTE_ENTRY *)saved_nrt)->primaryRouteFlag == FALSE)
  416.                     rtm->rtm_type = RTM_DELEXTRA;
  417. #endif
  419. goto report;
  420. }
  421. break;
  423. case RTM_GET:
  424. case RTM_CHANGE:
  425. case RTM_LOCK:
  426. #ifdef ROUTER_STACK
  427.         case RTM_NEWCHANGE:
  428.         case RTM_NEWGET:
  429.         case RTM_GETALL:
  430. #endif
  431. if ((rnh = rt_tables[dst->sa_family]) == 0) {
  432. senderr(EAFNOSUPPORT);
  433. } else if ((rt = (struct rtentry *)
  434. rnh->rnh_lookup(dst, netmask, rnh)))
  435. rt->rt_refcnt++;
  436. else
  437. senderr(ESRCH);
  439. #ifdef ROUTER_STACK
  440. switch(rtm->rtm_type) {
  442.                 case RTM_GETALL:
  443.                     /*
  444.                      * Create a message containing information about all
  445.                      * routes with the matching destination and netmask.
  446.                      */
  448.                     len = routeGatewayFetch (rt, NULL);
  449.                     if (len > rtm->rtm_msglen)
  450.                         {
  451.                         struct rt_msghdr * pNewMessage;
  452.                         R_Malloc(pNewMessage, struct rt_msghdr *, len);
  453.                 if (pNewMessage == NULL)
  454.                             senderr(ENOBUFS);
  455.                         Free(rtm);
  456.                         rtm = pNewMessage;
  457. }
  458.                     routeGatewayFetch (rt, rtm);
  459.                     break;
  461.                 case RTM_NEWCHANGE:
  462. case RTM_NEWGET:
  464.                     /*
  465.                      * If the search command specifies a gateway address, use
  466.                      * that value and the included protocol ID (if any) to
  467.                      * select a matching entry from any duplicate routes.
  468.                      */
  470.                     pGateway = gate;
  471.                     if (gate)
  472.                         {
  473.                         protoId = RT_PROTO_GET (gate);
  474.                         pRoute = routeMatch (rt, protoId, gate);
  475.                         if (pRoute)
  476.                             {
  477.                             /*
  478.                              * Matching entry found. Increase the
  479.                              * reference count for the exact match.
  480.                              */
  482.                             pRoute->rtEntry.rt_refcnt++;
  483.                             }     
  484.                         else
  485.                             senderr(ESRCH);
  486.                         }
  487.                     break;
  488.                 }
  489. #endif
  491. switch(rtm->rtm_type) {
  493. case RTM_GET:
  494. #ifdef ROUTER_STACK
  495.                 case RTM_NEWGET:
  496.                         if (pGateway)
  497.                             {
  498.                             /* The command used the gateway address to get
  499.                              * an exact match. Use that entry instead of
  500.                              * the original reference to the primary route.
  501.                              */ 
  503.                             rtfree (rt);
  504.                             rt = (struct rtentry *)pRoute;
  505.                             }
  506. #endif
  507. report:
  508. dst = rt_key(rt);
  509. gate = rt->rt_gateway;
  510. netmask = rt_mask(rt);
  511. genmask = rt->rt_genmask;
  512. if ((rtm->rtm_addrs & (RTA_IFP | RTA_IFA))) {
  513. if ((ifp = rt->rt_ifp)) {
  514. ifpaddr = ifp->if_addrlist->ifa_addr;
  515. ifaaddr = rt->rt_ifa->ifa_addr;
  516. if (ifp->if_flags & IFF_POINTOPOINT)
  517. brdaddr = rt->rt_ifa->ifa_dstaddr;
  518. else
  519. brdaddr = 0;
  520. rtm->rtm_index = ifp->if_index;
  521. } else {
  522. ifpaddr = 0;
  523. ifaaddr = 0;
  524.     }
  525. }
  526. len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0,
  527. (struct walkarg *)0);
  528. if (len > rtm->rtm_msglen) {
  529. struct rt_msghdr *new_rtm;
  530. R_Malloc(new_rtm, struct rt_msghdr *, len);
  531. if (new_rtm == 0)
  532. senderr(ENOBUFS);
  533. Bcopy(rtm, new_rtm, rtm->rtm_msglen);
  534. Free(rtm); rtm = new_rtm;
  535. }
  536. (void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm,
  537. (struct walkarg *)0);
  538. rtm->rtm_flags = rt->rt_flags;
  539. rtm->rtm_rmx = rt->rt_rmx;
  540. rtm->rtm_addrs = info.rti_addrs;
  541. break;
  543. #ifdef ROUTER_STACK
  544. case RTM_NEWCHANGE:
  545.                         /*
  546.                          * Use the exact match selected with the gateway
  547.                          * address, if available. Save the primary route
  548.                          * in case the change operation alters the weight.
  549.                          */
  551.                         if (pGateway)
  552.                             {
  553.                             saved_nrt = rt;
  554.                             rt = (struct rtentry *)pRoute;
  555.                             }
  557.                     /* Access the new gateway value for a route, if any. */
  559.                     gate = info.rti_info[RTAX_AUTHOR];
  560. #endif
  561. case RTM_CHANGE:
  562. if (gate && rt_setgate(rt, rt_key(rt), gate))
  563. senderr(ENOSPC);
  565. #ifdef ROUTER_STACK
  566.        /* Only remove cloned routes when altering the primary entry. */
  567.                     if ( ((ROUTE_ENTRY *)rt)->primaryRouteFlag)
  568.                         {
  569. #endif /* ROUTER_STACK */
  570.                         if (gate && (rt_key(rt)->sa_family == AF_INET))
  571.                             {
  572.                             /*
  573.                              * Remove any cloned routes using the
  574.                              * (now obsolete) gateway.
  575.                              */
  577.                            if ( (rt->rt_flags & RTF_CLONING) && rt_mask (rt))
  578.                                rn_walksubtree (rnh, rt_key (rt), rt_mask (rt),
  579.                                                rt_fixdelete, rt);
  580.                            }
  582. #ifdef ROUTER_STACK
  583.     /* End of condition for cloned route removal */
  584.                         }
  585. #endif
  587. /* new gateway could require new ifaddr, ifp;
  588.    flags may also be different; ifp may be specified
  589.    by ll sockaddr when protocol address is ambiguous */
  590. if (ifpaddr && (ifa = ifa_ifwithnet(ifpaddr)) &&
  591.     (ifp = ifa->ifa_ifp))
  592. ifa = ifaof_ifpforaddr(ifaaddr ? ifaaddr : gate, ifp);
  593. else if ((ifaaddr && (ifa = ifa_ifwithaddr(ifaaddr))) ||
  594.  (ifa = ifa_ifwithroute(rt->rt_flags,
  595. rt_key(rt), gate)))
  596. ifp = ifa->ifa_ifp;
  597. if (ifa) {
  598. register struct ifaddr *oifa = rt->rt_ifa;
  599. if (oifa != ifa) {
  600.     if (oifa && oifa->ifa_rtrequest)
  601. oifa->ifa_rtrequest(RTM_DELETE,
  602. rt, gate);
  603.     IFAFREE(rt->rt_ifa);
  604.     rt->rt_ifa = ifa;
  605.     ifa->ifa_refcnt++;
  606.     rt->rt_ifp = ifp;
  607. }
  608. }
  610. #ifdef ROUTER_STACK
  611.     /*
  612.      * Note: Setting the metrics does not change the new weight
  613.      *       value for the selected route entry, since that
  614.      *       alteration could replace the current route before
  615.      *       completing all the changes required.
  616.      */
  617. #endif
  619. rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
  620. &rt->rt_rmx);
  621. if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
  622.        rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, gate);
  623. if (genmask)
  624. rt->rt_genmask = genmask;
  625. /*
  626.  * Fall into
  627.  */
  628. case RTM_LOCK:
  629. rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
  630. rt->rt_rmx.rmx_locks |=
  631. (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
  632. break;
  633. }
  635. #ifdef ROUTER_STACK
  636.                 /*
  637.                  * Since a weight change could replace the primary route
  638.                  * visible to the IP forwarding process and the original
  639.                  * routing socket messages, reorganizing the routes must
  640.                  * wait until after all the prior changes so that any new
  641.                  * copy of the selected route is correct.
  642.                  */
  644. switch(rtm->rtm_type) {
  645. case RTM_CHANGE:
  646. case RTM_NEWCHANGE:
  648.                     /* Do nothing if the weight did not change. */
  650.                     if ( (rtm->rtm_inits & RTV_WEIGHT) == 0)
  651.                         break;
  653.                     /*
  654.                      * Get the primary route to find the matching group
  655.                      * for an existing entry when updating the weight.
  656.                      */
  658.                     if (saved_nrt)
  659.                         {
  660.                         /*
  661.                          * The new change operation set a gateway to get
  662.                          * an exact match and saved the primary route.
  663.                          */
  665.                         pRoute = (ROUTE_ENTRY *)saved_nrt;
  666.                         }
  667.                     else
  668.                         {
  669.                         /*
  670.                          * The original change operation only modifies the
  671.                          * primary route. The new change operation also
  672.                          * alters that entry if no gateway is set.
  673.                          */
  675.                         pRoute = (ROUTE_ENTRY *)rt;
  676.                         }
  678.                     routeWeightUpdate (pRoute, protoId, (ROUTE_ENTRY *)rt, 
  679.                                        gate, rtm->rtm_rmx.weight);
  681.                     if (saved_nrt)
  682.                         {
  683.                         /*
  684.                          * Release the reference to the primary route
  685.                          * if a specified gateway used an exact match.
  686.                          */
  688.                         rtfree (saved_nrt);
  689.                         }
  691.                     break;
  692.                 }
  693. #endif /* ROUTER_STACK */
  695. break;
  697. default:
  698. senderr(EOPNOTSUPP);
  699. }
  701. flush:
  702. #ifdef WV_INSTRUMENTATION
  703. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  704.         if (error)
  705.             {
  706.             WV_NET_EVENT_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 29, 4, 
  707.                             WV_NETEVENT_RTOUTPUT_FAIL, WV_NET_SEND,
  708.                             so->so_fd, error)
  709.             }
  710. #endif  /* INCLUDE_WVNET */
  711. #endif
  713. if (rtm) {
  714. if (error)
  715. rtm->rtm_errno = error;
  716. else 
  717. rtm->rtm_flags |= RTF_DONE;
  718. }
  719. if (rt)
  720. rtfree(rt);
  721.     {
  722. register struct rawcb *rp = 0;
  723. /*
  724.  * Check to see if we don't want our own messages.
  725.  */
  726. if ((so->so_options & SO_USELOOPBACK) == 0) {
  727. if (route_cb.any_count <= 1) {
  728. if (rtm)
  729. Free(rtm);
  730. m_freem(m);
  731. return (error);
  732. }
  733. /* There is another listener, so construct message */
  734. rp = sotorawcb(so);
  735. }
  736. if (rtm) {
  737. m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm);
  738. Free(rtm);
  739. }
  740. if (rp)
  741. rp->rcb_proto.sp_family = 0; /* Avoid us */
  742. if (dst)
  743. route_proto.sp_protocol = dst->sa_family;
  744. raw_input(m, &route_proto, &route_src, &route_dst);
  745. if (rp)
  746. rp->rcb_proto.sp_family = PF_ROUTE;
  747.     }
  748. return (error);
  749. }
  751. static void
  752. rt_setmetrics(which, in, out)
  753. u_long which;
  754. register struct rt_metrics *in, *out;
  755. {
  756. #define metric(f, e) if (which & (f)) out->e = in->e;
  757. metric(RTV_RPIPE, rmx_recvpipe);
  758. metric(RTV_SPIPE, rmx_sendpipe);
  759. metric(RTV_SSTHRESH, rmx_ssthresh);
  760. metric(RTV_RTT, rmx_rtt);
  761. metric(RTV_RTTVAR, rmx_rttvar);
  762. metric(RTV_HOPCOUNT, rmx_hopcount);
  763. metric(RTV_MTU, rmx_mtu);
  764. metric(RTV_EXPIRE, rmx_expire);
  766. #ifdef ROUTER_STACK
  767.     /*
  768.      * Set the values for the new additional metrics,
  769.      * except the weight, which must be postponed when
  770.      * altering that value.
  771.      */
  773.     metric(RTV_VALUE1, value1)
  774.     metric(RTV_VALUE2, value2)
  775.     metric(RTV_VALUE3, value3)
  776.     metric(RTV_VALUE4, value4)
  777.     metric(RTV_VALUE5, value5)
  778.     metric(RTV_ROUTETAG, routeTag)
  780. #endif /* ROUTER_STACK */
  782. #undef metric
  783. }
  785. #define ROUNDUP(a) 
  786. ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
  787. #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
  789. static void
  790. rt_xaddrs(cp, cplim, rtinfo)
  791. register caddr_t cp, cplim;
  792. register struct rt_addrinfo *rtinfo;
  793. {
  794. register struct sockaddr *sa;
  795. register int i;
  797. bzero((char *)rtinfo->rti_info, sizeof(rtinfo->rti_info));
  798. for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
  799. if ((rtinfo->rti_addrs & (1 << i)) == 0)
  800. continue;
  801. rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
  802. ADVANCE(cp, sa);
  803. }
  804. }
  806. struct mbuf *
  807. rt_msg1(type, rtinfo)
  808. int type;
  809. register struct rt_addrinfo *rtinfo;
  810. {
  811. register struct rt_msghdr *rtm;
  812. register struct mbuf *m;
  813. register int i;
  814. register struct sockaddr *sa;
  815. int len, dlen;
  817. m = mHdrClGet(M_DONTWAIT, MT_DATA, CL_SIZE_128, TRUE);
  818. if (m == 0)
  819. return (m);
  820. switch (type) {
  822. case RTM_DELADDR:
  823. case RTM_NEWADDR:
  824. len = sizeof(struct ifa_msghdr);
  825. break;
  827. case RTM_IFINFO:
  828. len = sizeof(struct if_msghdr);
  829. break;
  831. default:
  832. len = sizeof(struct rt_msghdr);
  833. }
  834. if (len > m->m_extSize)
  835. panic("rt_msg1");
  836. m->m_pkthdr.len = m->m_len = len;
  837. m->m_pkthdr.rcvif = 0;
  838. rtm = mtod(m, struct rt_msghdr *);
  839. bzero((caddr_t)rtm, len);
  840. for (i = 0; i < RTAX_MAX; i++) {
  841. if ((sa = rtinfo->rti_info[i]) == NULL)
  842. continue;
  843. rtinfo->rti_addrs |= (1 << i);
  844. dlen = ROUNDUP(sa->sa_len);
  845. m_copyback(m, len, dlen, (caddr_t)sa);
  846. len += dlen;
  847. }
  848. if (m->m_pkthdr.len != len) {
  849. m_freem(m);
  850. return (NULL);
  851. }
  852. rtm->rtm_msglen = len;
  853. rtm->rtm_version = RTM_VERSION;
  854. rtm->rtm_type = type;
  855. return (m);
  856. }
  858. static int
  859. rt_msg2(type, rtinfo, cp, w)
  860. int type;
  861. register struct rt_addrinfo *rtinfo;
  862. caddr_t cp;
  863. struct walkarg *w;
  864. {
  865. register int i;
  866. int len, dlen, second_time = 0;
  867. caddr_t cp0;
  869. rtinfo->rti_addrs = 0;
  870. again:
  871. switch (type) {
  873. case RTM_DELADDR:
  874. case RTM_NEWADDR:
  875. len = sizeof(struct ifa_msghdr);
  876. break;
  878. case RTM_IFINFO:
  879. len = sizeof(struct if_msghdr);
  880. break;
  882. default:
  883. len = sizeof(struct rt_msghdr);
  884. }
  885. if ((cp0 = cp))
  886. cp += len;
  887. for (i = 0; i < RTAX_MAX; i++) {
  888. register struct sockaddr *sa;
  890. if ((sa = rtinfo->rti_info[i]) == 0)
  891. continue;
  892. rtinfo->rti_addrs |= (1 << i);
  893. dlen = ROUNDUP(sa->sa_len);
  894. if (cp) {
  895. bcopy((caddr_t)sa, cp, (unsigned)dlen);
  896. cp += dlen;
  897. }
  898. len += dlen;
  899. }
  900. if (cp == 0 && w != NULL && !second_time) {
  901. register struct walkarg *rw = w;
  903. rw->w_needed += len;
  904. if (rw->w_needed <= 0 && rw->w_where) {
  905. if (rw->w_tmemsize < len) {
  906. if (rw->w_tmem)
  907.         {
  908. FREE(rw->w_tmem, MT_RTABLE);
  909. }
  910. MALLOC(rw->w_tmem, caddr_t, len, MT_RTABLE,
  911.        M_DONTWAIT); 
  912. if (rw->w_tmem)
  913. rw->w_tmemsize = len;
  914. }
  915. if (rw->w_tmem) {
  916. cp = rw->w_tmem;
  917. second_time = 1;
  918. goto again;
  919. } else
  920. rw->w_where = 0;
  921. }
  922. }
  923. if (cp) {
  924. register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
  926. rtm->rtm_version = RTM_VERSION;
  927. rtm->rtm_type = type;
  928. rtm->rtm_msglen = len;
  929. }
  930. return (len);
  931. }
  933. /*
  934.  * This routine is called to generate a message from the routing
  935.  * socket indicating that a redirect has occured, a routing lookup
  936.  * has failed, or that a protocol has detected timeouts to a particular
  937.  * destination.
  938.  */
  939. void
  940. rt_missmsg(type, rtinfo, flags, error)
  941. int type, flags, error;
  942. register struct rt_addrinfo *rtinfo;
  943. {
  944. register struct rt_msghdr *rtm;
  945. register struct mbuf *m;
  946. struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
  948. if (route_cb.any_count == 0)
  949. return;
  950. m = rt_msg1(type, rtinfo);
  951. if (m == 0)
  952. return;
  953. rtm = mtod(m, struct rt_msghdr *);
  954. rtm->rtm_flags = RTF_DONE | flags;
  955. rtm->rtm_errno = error;
  956. rtm->rtm_addrs = rtinfo->rti_addrs;
  957. route_proto.sp_protocol = sa ? sa->sa_family : 0;
  958. raw_input(m, &route_proto, &route_src, &route_dst);
  959. }
  961. /*
  962.  * This routine is called to generate a message from the routing
  963.  * socket indicating that the status of a network interface has changed.
  964.  */
  965. void
  966. rt_ifmsg(ifp)
  967. register struct ifnet *ifp;
  968. {
  969. register struct if_msghdr *ifm;
  970. struct mbuf *m;
  971. struct rt_addrinfo info;
  973. if (route_cb.any_count == 0)
  974. return;
  975. bzero((caddr_t)&info, sizeof(info));
  976. m = rt_msg1(RTM_IFINFO, &info);
  977. if (m == 0)
  978. return;
  979. ifm = mtod(m, struct if_msghdr *);
  980. ifm->ifm_index = ifp->if_index;
  981. ifm->ifm_flags = ifp->if_flags;
  982. ifm->ifm_data = ifp->if_data;
  983. ifm->ifm_addrs = 0;
  984. route_proto.sp_protocol = 0;
  985. raw_input(m, &route_proto, &route_src, &route_dst);
  986. }
  988. /*
  989.  * This is called to generate messages from the routing socket
  990.  * indicating a network interface has had addresses associated with it.
  991.  * if we ever reverse the logic and replace messages TO the routing
  992.  * socket indicate a request to configure interfaces, then it will
  993.  * be unnecessary as the routing socket will automatically generate
  994.  * copies of it.
  995.  */
  996. void
  997. rt_newaddrmsg(cmd, ifa, error, rt)
  998. int cmd, error;
  999. register struct ifaddr *ifa;
  1000. register struct rtentry *rt;
  1001. {
  1002. struct rt_addrinfo info;
  1003. struct sockaddr *sa = NULL;
  1004. int pass;
  1005. struct mbuf *m = NULL;
  1006. struct ifnet *ifp = ifa->ifa_ifp;
  1007.         int ncmd;
  1009. if (route_cb.any_count == 0)
  1010. return;
  1011. for (pass = 1; pass < 3; pass++) {
  1012. bzero((caddr_t)&info, sizeof(info));
  1013. if ((cmd == RTM_ADD && pass == 1) ||
  1014.     (cmd == RTM_DELETE && pass == 2)) {
  1015. register struct ifa_msghdr *ifam;
  1017. ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR;
  1019. ifaaddr = sa = ifa->ifa_addr;
  1020. ifpaddr = ifp->if_addrlist->ifa_addr;
  1021. netmask = ifa->ifa_netmask;
  1022. brdaddr = ifa->ifa_dstaddr;
  1023. if ((m = rt_msg1(ncmd, &info)) == NULL)
  1024. continue;
  1025. ifam = mtod(m, struct ifa_msghdr *);
  1026. ifam->ifam_index = ifp->if_index;
  1027. ifam->ifam_metric = ifa->ifa_metric;
  1028. ifam->ifam_flags = ifa->ifa_flags;
  1029. ifam->ifam_addrs = info.rti_addrs;
  1030. }
  1031. if ((cmd == RTM_ADD && pass == 2) ||
  1032.     (cmd == RTM_DELETE && pass == 1)) {
  1033. register struct rt_msghdr *rtm;
  1035. if (rt == 0)
  1036. continue;
  1038.                         ncmd = cmd;
  1039. netmask = rt_mask(rt);
  1040. dst = sa = rt_key(rt);
  1041. gate = rt->rt_gateway;
  1043. #ifdef ROUTER_STACK
  1044.                 /* Use a different message type for additional routes. */
  1046.                 if ( ((ROUTE_ENTRY *)rt)->primaryRouteFlag == FALSE)
  1047.                     {
  1048.                     if (ncmd == RTM_ADD)
  1049.                         ncmd = RTM_ADDEXTRA;
  1050.                     else
  1051.                         ncmd = RTM_DELEXTRA;
  1052.                     }
  1053. #endif /* ROUTER_STACK */
  1055. if ((m = rt_msg1(ncmd, &info)) == NULL)
  1056. continue;
  1057. rtm = mtod(m, struct rt_msghdr *);
  1058. rtm->rtm_index = ifp->if_index;
  1059. rtm->rtm_flags |= rt->rt_flags;
  1060. rtm->rtm_errno = error;
  1061. rtm->rtm_addrs = info.rti_addrs;
  1062. }
  1063. route_proto.sp_protocol = sa ? sa->sa_family : 0;
  1064. raw_input(m, &route_proto, &route_src, &route_dst);
  1065. }
  1066. }
  1068. /*
  1069.  * This is used in dumping the kernel table via sysctl().
  1070.  */
  1071. int
  1072. sysctl_dumpentry(rn, w)
  1073. struct radix_node *rn;
  1074. register struct walkarg *w;
  1075. {
  1076. register struct rtentry *rt = (struct rtentry *)rn;
  1077. int error = 0, size;
  1078. struct rt_addrinfo info;
  1080. if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
  1081. return 0;
  1082. bzero((caddr_t)&info, sizeof(info));
  1083. dst = rt_key(rt);
  1084. gate = rt->rt_gateway;
  1085. netmask = rt_mask(rt);
  1086. genmask = rt->rt_genmask;
  1087. if (rt->rt_ifp) {
  1088. ifpaddr = rt->rt_ifp->if_addrlist->ifa_addr;
  1089. ifaaddr = rt->rt_ifa->ifa_addr;
  1090. if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
  1091. brdaddr = rt->rt_ifa->ifa_dstaddr;
  1092. }
  1093. size = rt_msg2(RTM_GET, &info, 0, w);
  1094. if (w->w_where && w->w_tmem) {
  1095. register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
  1097. rtm->rtm_flags = rt->rt_flags;
  1098. rtm->rtm_use = rt->rt_use;
  1099. rtm->rtm_rmx = rt->rt_rmx;
  1100. rtm->rtm_index = rt->rt_ifp->if_index;
  1101. rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
  1102. rtm->rtm_addrs = info.rti_addrs;
  1103. if ((error = copyout((caddr_t)rtm, w->w_where, size)))
  1104. w->w_where = NULL;
  1105. else
  1106. w->w_where += size;
  1107. }
  1108. return (error);
  1109. }
  1111. int
  1112. sysctl_iflist(af, w)
  1113. int af;
  1114. register struct walkarg *w;
  1115. {
  1116. register struct ifnet *ifp;
  1117. register struct ifaddr *ifa;
  1118. struct rt_addrinfo info;
  1119. int len, error = 0;
  1121. bzero((caddr_t)&info, sizeof(info));
  1122. #ifdef VIRTUAL_STACK
  1123. for (ifp = _ifnet; ifp; ifp = ifp->if_next) {
  1124. #else
  1125. for (ifp = ifnet; ifp; ifp = ifp->if_next) {
  1126. #endif
  1127. if (w->w_arg && w->w_arg != ifp->if_index)
  1128. continue;
  1129. ifa = ifp->if_addrlist;
  1130. ifpaddr = ifa->ifa_addr;
  1131. len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w);
  1132. ifpaddr = 0;
  1133. if (w->w_where && w->w_tmem) {
  1134. register struct if_msghdr *ifm;
  1136. ifm = (struct if_msghdr *)w->w_tmem;
  1137. ifm->ifm_index = ifp->if_index;
  1138. ifm->ifm_flags = ifp->if_flags;
  1139. ifm->ifm_data = ifp->if_data;
  1140. ifm->ifm_addrs = info.rti_addrs;
  1141. if ((error = copyout((caddr_t)ifm, w->w_where, len)))
  1142. return (error);
  1143. w->w_where += len;
  1144. }
  1145. while ((ifa = ifa->ifa_next)) {
  1146. if (af && af != ifa->ifa_addr->sa_family)
  1147. continue;
  1148. ifaaddr = ifa->ifa_addr;
  1149. netmask = ifa->ifa_netmask;
  1150. brdaddr = ifa->ifa_dstaddr;
  1151. len = rt_msg2(RTM_NEWADDR, &info, 0, w);
  1152. if (w->w_where && w->w_tmem) {
  1153. register struct ifa_msghdr *ifam;
  1155. ifam = (struct ifa_msghdr *)w->w_tmem;
  1156. ifam->ifam_index = ifa->ifa_ifp->if_index;
  1157. ifam->ifam_flags = ifa->ifa_flags;
  1158. ifam->ifam_metric = ifa->ifa_metric;
  1159. ifam->ifam_addrs = info.rti_addrs;
  1160. if ((error = copyout(w->w_tmem, w->w_where,
  1161.                                                      len)))
  1162. return (error);
  1163. w->w_where += len;
  1164. }
  1165. }
  1166. ifaaddr = netmask = brdaddr = 0;
  1167. }
  1168. return (0);
  1169. }
  1171. int
  1172. sysctl_rtable(name, namelen, where, given, new, newlen)
  1173. int *name;
  1174. int namelen;
  1175. caddr_t where;
  1176. size_t *given;
  1177. caddr_t *new;
  1178. size_t newlen;
  1179. {
  1180. register struct radix_node_head *rnh;
  1181. int i, s, error = EINVAL;
  1182. u_char  af;
  1183. struct walkarg w;
  1185. /*
  1186.  * XXX - This event does not usually occur: the sysctl_rtable() routine
  1187.  *       is typically only called by the Unix sysctl command which is not
  1188.  *       supported by VxWorks. It is also called by the RIP implementation
  1189.  *       as a legacy of the port from BSD, but that implementation detail
  1190.  *       is not of sufficient interest to include the event.
  1192. #ifdef WV_INSTRUMENTATION
  1193. #ifdef INCLUDE_WVNET    /@ WV_NET_INFO event @/
  1194.         if (namelen != 3)
  1195.             {
  1196.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 22, 7, 
  1197.                              WV_NETEVENT_ROUTEWALK_START, 0)
  1198.             }
  1199.         else
  1200.             {
  1201.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 22, 7, 
  1202.                              WV_NETEVENT_ROUTEWALK_START, name[1])
  1203.             }
  1204. #endif  /@ INCLUDE_WVNET @/
  1205. #endif
  1207.  * XXX - end of unused event
  1208.  */
  1210. if (new)
  1211. return (EPERM);
  1212. if (namelen != 3)
  1213. return (EINVAL);
  1214. af = name[0];
  1215. Bzero(&w, sizeof(w));
  1216. w.w_where = where;
  1217. w.w_given = *given;
  1218. w.w_needed = 0 - w.w_given;
  1219. w.w_op = name[1];
  1220. w.w_arg = name[2];
  1222. s = splnet();
  1223. switch (w.w_op) {
  1225. case NET_RT_DUMP:
  1226. case NET_RT_FLAGS:
  1227. for (i = 1; i <= AF_MAX; i++)
  1228. if ((rnh = rt_tables[i]) && (af == 0 || af == i) &&
  1229.     (error = rnh->rnh_walktree(rnh,
  1230. sysctl_dumpentry, &w)))
  1231. break;
  1232. break;
  1234. case NET_RT_IFLIST:
  1235. error = sysctl_iflist(af, &w);
  1236. }
  1237. splx(s);
  1238. if (w.w_tmem){
  1239. FREE(w.w_tmem, MT_RTABLE);
  1240. }
  1241. w.w_needed += w.w_given;
  1242. if (where) {
  1243. *given = w.w_where - where;
  1244. if (*given < w.w_needed)
  1245. return (ENOMEM);
  1246. } else {
  1247. *given = (11 * w.w_needed) / 10;
  1248. }
  1249. return (error);
  1250. }
  1252. /*
  1253.  * Definitions of protocols supported in the ROUTE domain.
  1254.  */
  1255. extern struct domain routedomain; /* or at least forward */
  1257. struct protosw routesw[] = {
  1258. { SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR,
  1259.   raw_input, route_output, raw_ctlinput, 0,
  1260.   route_usrreq,
  1261.   rtSockInit, 0, 0, 0,
  1262.   sysctl_rtable,
  1263. }
  1264. };
  1266. struct domain routedomain =
  1267.     { PF_ROUTE, "route", 0, 0, 0,
  1268.       routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] };
  1270. /*
  1271.  * Copy data from a buffer back into the indicated mbuf chain,
  1272.  * starting "off" bytes from the beginning, extending the mbuf
  1273.  * chain if necessary.
  1274.  */
  1275. static void
  1276. m_copyback(m0, off, len, cp)
  1277. struct mbuf *m0;
  1278. register int off;
  1279. register int len;
  1280. caddr_t cp;
  1281. {
  1282. register int mlen;
  1283. register struct mbuf *m = m0, *n;
  1284. int totlen = 0;
  1286. if (m0 == 0)
  1287. return;
  1288. while (off > (mlen = m->m_len)) {
  1289. off -= mlen;
  1290. totlen += mlen;
  1291. if (m->m_next == 0) {
  1292. n = m_getclr(M_DONTWAIT, m->m_type, CL_SIZE_128, TRUE);
  1293. if (n == 0)
  1294. goto out;
  1295. n->m_len = min(n->m_extSize, len + off);
  1296. m->m_next = n;
  1297. }
  1298. m = m->m_next;
  1299. }
  1300. while (len > 0) {
  1301. mlen = min (m->m_len - off, len);
  1302. bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen);
  1303. cp += mlen;
  1304. len -= mlen;
  1305. mlen += off;
  1306. off = 0;
  1307. totlen += mlen;
  1308. if (len == 0)
  1309. break;
  1310. if (m->m_next == 0) {
  1311. n = mBufClGet(M_DONTWAIT, m->m_type, CL_SIZE_128, TRUE);
  1312. if (n == 0)
  1313. break;
  1314. n->m_len = min(n->m_extSize, len);
  1315. m->m_next = n;
  1316. }
  1317. m = m->m_next;
  1318. }
  1319. out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
  1320. m->m_pkthdr.len = totlen;
  1321. }
  1323. /*******************************************************************************
  1324. *
  1325. * m_copydata - copy data from an mbuf chain into a buff
  1326. * Copy data from an mbuf chain starting "off" bytes from the beginning,
  1327. * continuing for "len" bytes, into the indicated buffer.
  1328. */
  1329. static void m_copydata(m, off, len, cp)
  1330.     register struct mbuf *m;
  1331.     register int off;
  1332.     register int len;
  1333.     caddr_t cp;
  1334.     {
  1335.     register unsigned count;
  1337.     if (off < 0 || len < 0)
  1338. panic("m_copydata");
  1339.     while (off > 0)
  1340. {
  1341. if (m == 0)
  1342.             {
  1343. #ifdef WV_INSTRUMENTATION
  1344. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1345.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 26, 3, 
  1346.                              WV_NETEVENT_COPYDATA_PANIC)
  1347. #endif  /* INCLUDE_WVNET */
  1348. #endif
  1350.             panic("m_copydata");
  1351.             }
  1353. if (off < m->m_len)
  1354.     break;
  1355. off -= m->m_len;
  1356. m = m->m_next;
  1357. }
  1358.     while (len > 0)
  1359. {
  1360. if (m == 0)
  1361.     panic("m_copydata");
  1362. count = min(m->m_len - off, len);
  1363. bcopy(mtod(m, caddr_t) + off, cp, count);
  1364. len -= count;
  1365. cp += count;
  1366. off = 0;
  1367. m = m->m_next;
  1368. }
  1369.     }
  1371. #ifdef ROUTER_STACK
  1372. /*******************************************************************************
  1373. *
  1374. * routeGatewayFetch - build a message which includes a list of gateways
  1375. *
  1376. * This routine constructs a routing socket message which supplies each
  1377. * next-hop router for all duplicate routes with a given destination and
  1378. * netmask. When the <pMessage> parameter is NULL, the routine simply
  1379. * counts the required length for the message. When that parameter provides
  1380. * an actual value, the routine stores the appropriate information in
  1381. * the supplied buffer. The RTAX_GATEWAY pointer for the resulting message
  1382. * accesses a series of customized address structures which include the
  1383. * protocol identifier and all additional metrics for each entry.
  1384. *
  1385. * RETURNS: Length of message for all route entries
  1386. *
  1387. * NOMANUAL
  1388. */
  1390. LOCAL int routeGatewayFetch
  1391.     (
  1392.     struct rtentry * pRoute,     /* primary route for destination/netmask */
  1393.     struct rt_msghdr * pMessage  /* list of routes for routing socket */
  1394.     )
  1395.     {
  1396.     int length;
  1397.     char * pBuffer;
  1398.     struct sockaddr * pAddress = NULL;
  1399.     struct sockaddr_gate * pGate;
  1401.     int addrlen;
  1403.     ROUTE_ENTRY * pGroup;    /* route entries for each protocol */
  1404.     ROUTE_ENTRY * pMatch;    /* current route entry for message */
  1406.     length = sizeof (struct rt_msghdr);
  1408.     if (pMessage)
  1409.         {
  1410.         /* Fill in the initial message header. */
  1412.         pMessage->rtm_version = RTM_VERSION;
  1413.         pMessage->rtm_type = RTM_GETALL;
  1415.         pMessage->rtm_flags = pRoute->rt_flags;
  1417.         pMessage->rtm_addrs = RTA_DST | RTA_GATEWAY;
  1418.         }
  1420.     pAddress = rt_key (pRoute);
  1421.     addrlen = ROUNDUP(pAddress->sa_len);
  1423.     pBuffer = (char *)pMessage;
  1424.     if (pBuffer)
  1425.         {
  1426.         /* Copy the destination address for the route entries. */
  1428.         pBuffer += length;
  1430.         bcopy ( (char *)pAddress, pBuffer, addrlen);
  1431.         pBuffer += addrlen;
  1432.         }
  1434.     length += addrlen;
  1436.     /*
  1437.      * Find the length of all entries for the specified destination
  1438.      * and netmask. Copy the relevant values if appropriate.
  1439.      */
  1441.     for (pGroup = (ROUTE_ENTRY *)pRoute; pGroup != NULL;
  1442.                  pGroup = pGroup->diffNode.pFrwd)
  1443.         {
  1444.         for (pMatch = pGroup; pMatch != NULL; pMatch = pMatch->sameNode.pFrwd)
  1445.             {
  1446.             pAddress = ROUTE_ENTRY_GATEWAY (pMatch);
  1447.             if (pAddress->sa_family == AF_LINK)
  1448.                 {
  1449.                 /*
  1450.                  * The entry contains an ARP template. Use the
  1451.                  * interface's IP address as the gateway value.
  1452.                  */
  1454.                 pAddress = pMatch->rtEntry.rt_ifa->ifa_addr;
  1455.                 }
  1457.             addrlen = ROUNDUP(sizeof (struct sockaddr_gate));
  1459.             if (pBuffer)
  1460.                 {
  1461.                 /* Copy the gateway address for the route entry. */
  1463.                 pGate = (struct sockaddr_gate *)pBuffer;
  1465.                 pGate->gate_family = pAddress->sa_family;
  1466.                 pGate->gate_addr = 
  1467.                     ( (struct sockaddr_in *)pAddress)->sin_addr.s_addr;
  1469.                 /* Set length to reflect increased size for metrics. */
  1471.                 pGate->gate_len = sizeof (struct sockaddr_gate);
  1473.                 /* Copy additional information into gateway field. */
  1475.                 pGate->routeProto = RT_PROTO_GET (ROUTE_ENTRY_KEY (pMatch));
  1476.                 pGate->weight = pMatch->rtEntry.rt_rmx.weight;
  1477.                 pGate->value1 = pMatch->rtEntry.rt_rmx.value1;
  1478.                 pGate->value2 = pMatch->rtEntry.rt_rmx.value2;
  1479.                 pGate->value3 = pMatch->rtEntry.rt_rmx.value3;
  1480.                 pGate->value4 = pMatch->rtEntry.rt_rmx.value4;
  1481.                 pGate->value5 = pMatch->rtEntry.rt_rmx.value5;
  1482.                 pGate->routeTag = pMatch->rtEntry.rt_rmx.routeTag;
  1484.                 pBuffer += addrlen;
  1485.                 }
  1487.             length += addrlen;
  1488.             }
  1489.         }
  1491.     /* Copy any netmask information for the route. */
  1493.     pAddress = rt_mask (pRoute);
  1495.     if (pAddress)
  1496.         {
  1497.         addrlen = ROUNDUP(pAddress->sa_len);
  1499.         if (pBuffer)
  1500.             {
  1501.             bcopy ( (char *)pAddress, pBuffer, addrlen);
  1502.             pBuffer += addrlen;
  1504.             /* Indicate that netmask information is present in the message. */
  1506.             pMessage->rtm_addrs |= RTA_NETMASK;
  1507.             }
  1509.         length += addrlen;
  1510.         }
  1512.     if (pMessage)
  1513.         {
  1514.         /* Set the total message length. */
  1516.         pMessage->rtm_msglen = length;
  1517.         }
  1519.     return (length);
  1520.     }
  1522. /*******************************************************************************
  1523. *
  1524. * routeMatch - find a unique entry within a set of duplicate routes
  1525. *
  1526. * This routine searches the extended lists attached to the <pRoute>
  1527. * primary route entry to find a matching route with the same next-hop
  1528. * gateway as the <pGateway> argument and a creator which matches the
  1529. * <protoId> value. That combination is unique for a particular destination
  1530. * address and netmask. This routine allows routing sockets to retrieve
  1531. * a duplicate route entry which is not visible to the IP forwarding process.
  1532. *
  1533. * RETURNS: Pointer to existing route, or NULL if none.
  1534. *
  1535. * NOMANUAL
  1536. */
  1538. LOCAL ROUTE_ENTRY * routeMatch
  1539.     (
  1540.     struct rtentry * pRoute,    /* primary route for destination/netmask */
  1541.     short protoId,              /* protocol identifer for matching route */
  1542.     struct sockaddr * pGateway  /* next hop gateway for matching route */
  1543.     )
  1544.     {
  1545.     ROUTE_ENTRY * pGroup;    /* route entries with matching protocol */
  1546.     ROUTE_ENTRY * pMatch;    /* exact match for protocol and gateway */
  1548.     if (protoId)
  1549.         {
  1550.         /* Find the list of entries for the specified protocol. */
  1552.         for (pGroup = (ROUTE_ENTRY *)pRoute; pGroup != NULL;
  1553.                  pGroup = pGroup->diffNode.pFrwd)
  1554.             {
  1555.             if (RT_PROTO_GET(ROUTE_ENTRY_KEY(pGroup)) == protoId)
  1556.                 break;
  1557.             }
  1558.         }
  1559.     else
  1560.         {
  1561.         /* No protocol ID specified: use the initial group. */
  1563.         pGroup = (ROUTE_ENTRY *)pRoute;
  1564.         }
  1566.     /* Find matching gateway if matching protocol found. */
  1568.     for (pMatch = pGroup; pMatch != NULL; pMatch = pMatch->sameNode.pFrwd)
  1569.         {
  1570.         if (ROUTE_ENTRY_GATEWAY (pMatch)->sa_family == AF_LINK)
  1571.             {
  1572.             /*
  1573.              * The gateway field contains an ARP template. The entry
  1574.              * only matches for a search using the interface's IP address
  1575.              * as the gateway.
  1576.              */
  1578.             if (SOCKADDR_IN (pMatch->rtEntry.rt_ifa->ifa_addr)
  1579.                                     == SOCKADDR_IN (pGateway))
  1580.                 {
  1581.                 /* Matching route entry found - halt search. */
  1583.                 break;
  1584.                 }
  1585.             }
  1586.         else if (SOCKADDR_IN (ROUTE_ENTRY_GATEWAY (pMatch))
  1587.                                     == SOCKADDR_IN (pGateway))
  1588.             {
  1589.             /* Matching route entry found - halt search. */
  1591.             break;
  1592.             }
  1593.         }
  1595.     return (pMatch);
  1596.     }
  1597. #endif /* ROUTER_STACK */