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

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

VxWorks

开发平台：

C/C++

if_ether.c：源码内容
  1. /* if_ether.c - network Ethernet address resolution protocol */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 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.  *
  38.  * @(#)if_ether.c 8.2 (Berkeley) 9/26/94
  39.  */
  41. /*
  42.  * Ethernet address resolution protocol.
  43.  * TODO:
  44.  * add "inuse/lock" bit (or ref. count) along with valid bit
  45.  */
  47. /*
  48. modification history
  49. --------------------
  50. 01u,24jun02,wap  optimize away some bcopy()s in arpresolve()
  51. 01t,21may02,vvv  fixed ARP timer overflow problem (SPR #63908)
  52. 01s,24jan02,vvv  fixed arpintr memory leak (SPR #72577)
  53. 01r,18dec01,vvv  fixed build error from previous check-in
  54. 01q,18dec01,vvv  fixed shared-memory booting problem (SPR #71023)
  55. 01p,10dec01,vvv  allow send to any address assigned to an interface (SPR #71836)
  56. 01o,01nov01,rae  compiler warnings, modified arpresolve error message (SPR #71242)
  57. 01n,12oct01,rae  merge from truestack ver 01z base 01j (SPRs 63006, 68954,
  58.                  69112 ... plus Fastpath, revarp, etc.)
  59. 01m,07feb01,spm  added merge record for 30jan01 update from version 01i of
  60.                  tor2_0_x branch (base 01h) and fixed modification history
  61. 01l,30jan01,ijm  merged SPR# 28602 fixes (proxy ARP services are obsolete);
  62.                  fixed deleting ARP entries when proxy flag set
  63. 01j,08nov99,pul  merging T2 cumulative patch 2
  64. 01k,08Nov98,pul  changed the argument ordering to ipEtherResolveRtn
  65. 01i,29apr99,pul  Upgraded NPT phase3 code to tor2.0.0
  66. 01h,10may99,spm  fixed SIOCSARP handling to support ATF_PUBL flag (SPR #24397)
  67. 01g,03sep98,n_s  fixed handling of IFF_NOARP flag in arpresolve. spr #22280
  68. 01g,13jul98,n_s  added arpRxmitTicks.  spr # 21577
  69. 01f,10jul97,vin  ifdefed revarp code, fixed warnings.
  70. 01e,23apr97,vin  fixed SPR8445, rt_expire for arp route entry being set to 0.
  71. 01d,29jan97,vin  fixed a bug in arpioctl(), sdl_alen field.
  72. 01c,16dec96,vin  removed unnecessary htons in arprequest() and arpinput().
  73. 01b,31oct96,vin  changed m_gethdr(..) to mHdrClGet(..).  
  74. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02n of if_ether.c
  75. */
  77. /*
  78.  * Ethernet address resolution protocol.
  79.  * TODO:
  80.  *      run at splnet (add ARP protocol intr.)
  81.  *      link entries onto hash chains, keep free list
  82.  *      add "inuse/lock" bit (or ref. count) along with valid bit
  83.  */
  84. #include "vxWorks.h"
  85. #include "logLib.h"
  86. #include "stdio.h"
  88. #include "net/mbuf.h"
  89. #include "sys/socket.h"
  90. #include "errno.h"
  91. #include "sys/ioctl.h"
  93. #include "net/if.h"
  94. #include "net/if_dl.h"
  95. #include "net/route.h"
  96. #include "netinet/in.h"
  97. #include "netinet/in_systm.h"
  98. #include "netinet/in_var.h"
  99. #include "netinet/ip.h"
  100. #include "netinet/if_ether.h"
  101. #include "wdLib.h"
  102. #include "tickLib.h"
  103. #include "net/systm.h"
  105. #ifdef VIRTUAL_STACK
  106. #include "netinet/vsLib.h"
  107. #endif /* VIRTUAL_STACK */
  109. #ifdef ROUTER_STACK
  110. #include "wrn/fastPath/fastPathLib.h"
  111. #include "wrn/fastPath/fastPathIpP.h"
  112. #endif /* ROUTER_STACK */
  114. #ifdef INET
  116. #ifdef WV_INSTRUMENTATION
  117. #ifdef INCLUDE_WVNET
  118. #include "wvNetLib.h"
  119. #endif /* INCLUDE_WVNET */
  120. #endif
  122. /* defines */
  124. /* defines */
  126. #define ENET_SIZE 6 /* Ethernet address size */
  128. #define DDB
  130. #define PROXY_HOOK /* include proxy hook code */
  132. #define SIN(s) ((struct sockaddr_in *)s)
  133. #define SDL(s) ((struct sockaddr_dl *)s)
  134. #define SRP(s) ((struct sockaddr_inarp *)s)
  136. /*
  137.  * ARP trailer negotiation.  Trailer protocol is not IP specific,
  138.  * but ARP request/response use IP addresses.
  139.  */
  140. #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
  142. #define rt_expire rt_rmx.rmx_expire
  144. #define ARP_RXMIT_TICKS_DFLT sysClkRateGet ()      /* Minimum number of ticks */
  145.            /* between retransmission  */
  146.    /* of ARP request          */
  147. #define TICK_GEQ(t1,t2) ((long)((t1) - (t2)) >= 0)
  149. /* externs */
  151. IMPORT STATUS netJobAdd (FUNCPTR, int, int, int, int, int);
  152. IMPORT int sysClkRateGet ();
  155. #ifndef VIRTUAL_STACK
  156. extern struct ifnet loif[];
  157. #endif /* VIRTUAL_STACK */
  159. extern  void _insque ();
  160. extern  void _remque ();
  161. int arpMaxEntries = 12;                      /* sensible default */
  163. /* globals */
  165. void arptfree (struct llinfo_arp *);
  167. #ifndef VIRTUAL_STACK
  168. struct llinfo_arp llinfo_arp = {&llinfo_arp, &llinfo_arp};
  169. int arp_inuse, arp_allocated, arp_intimer;
  170. int arpinit_done = 0;
  171. #endif /* VIRTUAL_STACK */
  173. struct ifqueue arpintrq = {0, 0, 0, 50};
  175. int useloopback = 1;
  176. int arp_maxtries = 5; /* use loopback interface for local traffic */
  178. /* timer values */
  179. int arpt_prune = (1*60); /* walk list every 1 minutes */
  180. int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */
  181. int arpt_down = 20; /* once declared down, don't send for 20 secs */
  183. #ifndef VIRTUAL_STACK
  184. int arpRxmitTicks = -1;  /* Minimum number of ticks between */
  185. /* retranmission of ARP request    */
  186. #endif /* VIRTUAL_STACK */
  188. /* proxy arp hook */
  190. #ifdef PROXY_HOOK
  191. FUNCPTR  proxyArpHook = NULL;
  192. #endif
  194. /* locals */
  196. #ifndef VIRTUAL_STACK
  197. LOCAL WDOG_ID arptimerWd; /* watchdog timer for arptimer routine */
  198. #endif /* VIRTUAL_STACK */
  200. static char  digits[] = "0123456789abcdef";
  202. #ifdef WV_INSTRUMENTATION
  203. #ifdef INCLUDE_WVNET
  204.     /* Set common fields of event identifiers for this module. */
  206. LOCAL UCHAR wvNetModuleId = WV_NET_IFETHER_MODULE;   /* Value for if_ether.c */
  207. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;  /* Available event filter */
  209. LOCAL ULONG wvNetEventId; /* Event identifier: see wvNetLib.h */
  210. #endif    /* INCLUDE_WVNET */
  211. #endif
  213. /* forward declarations */
  215. #ifdef VIRTUAL_STACK
  216. void arptimer (int);
  217. #else
  218. static void arptimer (void *);
  219. #endif /* VIRTUAL_STACK */
  220. static void arprequest (struct arpcom *, u_long *, u_long *, u_char *);
  221. static struct llinfo_arp *arplookup (u_long, int, int);
  222. static void in_arpinput (struct mbuf *);
  223. static  void arpEntryDelete (void);
  225. /*
  226.  * Timeout routine.  Age arp_tab entries periodically.
  227.  */
  228. /* ARGSUSED */
  229. #ifdef VIRTUAL_STACK
  230. /* must have a helper routine because of argument limitations */
  231. /* in WdStart */
  232. void arptimerRestart
  233.     (
  234.     int stackNum
  235.     )
  236.     {
  237.     netJobAdd ((FUNCPTR)arptimer, stackNum, 0, 0, 0, 0);
  238.     }
  240. void arptimer
  241.     (
  242.     int stackNum    /* used to set the stack correctly in wd routine*/
  243.     )
  244.     {
  245.     int s;
  246.     register struct llinfo_arp *la;
  247.     virtualStackNumTaskIdSet(stackNum);
  249.     s = splnet();
  251.     la = _llinfo_arp.la_next;
  252.     wdStart (arptimerWd, arpt_prune * sysClkRateGet(),
  253.              (FUNCPTR) arptimerRestart, (int) stackNum);
  254.     while (la != &_llinfo_arp)
  255.         {
  256. register struct rtentry *rt = la->la_rt;
  257. la = la->la_next;
  258. if (rt->rt_expire && rt->rt_expire <= tickGet())
  259.     {
  260.     arptfree(la->la_prev); /* timer has expired; clear */
  261.     }
  262. }
  263.     splx (s);
  264.     }
  266. #else  /* just use original version */
  267. static void
  268. arptimer(arg)
  269. void *arg;
  270.     {
  271.     int s = splnet();
  272.     register struct llinfo_arp *la = llinfo_arp.la_next;
  274.     wdStart (arptimerWd, arpt_prune * sysClkRateGet(), (FUNCPTR) netJobAdd,
  275.      (int)arptimer);
  277.     while (la != &llinfo_arp) 
  278. {
  279. register struct rtentry *rt = la->la_rt;
  280. la = la->la_next;
  281. if (rt->rt_expire && TICK_GEQ (tickGet(), rt->rt_expire))
  282.     {
  283. #ifdef WV_INSTRUMENTATION
  284. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  285.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_INFO, 2, 15,
  286.                              WV_NETEVENT_ARPTIMER_FREE)
  287. #endif  /* INCLUDE_WVNET */
  288. #endif
  290.     arptfree(la->la_prev); /* timer has expired; clear */
  291.     }
  292. }
  293.     splx (s);
  294.     }
  295. #endif /* VIRTUAL_STACK */
  297. /* IP multicast address to Ethernet mulitcast address mapping */
  299. void ipToEtherMCastMap
  300.      ( 
  301.      struct in_addr * ipaddr,
  302.      u_char *         enaddr
  303.      )
  304.      {
  305.      enaddr[0] = 0x01;
  306.      enaddr[1] = 0x00;
  307.      enaddr[2] = 0x5e;
  308.      enaddr[3] = ((u_char *)ipaddr)[1] & 0x7f;
  309.      enaddr[4] = ((u_char *)ipaddr)[2];
  310.      enaddr[5] = ((u_char *)ipaddr)[3];
  311.      return;
  312.      }
  314. /* IP to Ethernet address resolution protocol. This is just a wrapper for arpresolve
  315. * being called from ipOutput. This routine calls arpresolve with the appropriate
  316. * set of arguments. 
  317. *
  318. * Returns 1 if the address is resolved and 0 if the address is not resolved.
  319. */
  321. int ipEtherResolvRtn
  322.     (
  323.     FUNCPTR           ipArpCallBackRtn,
  324.     struct mbuf *     pMbuf,
  325.     struct sockaddr * dstIpAddr,
  326.     struct ifnet *    ifp,
  327.     struct rtentry *  rt,
  328.     char *            dstBuff
  329.     )
  330.     {
  331.     return(arpresolve ((struct arpcom *)ifp, rt, pMbuf, dstIpAddr, dstBuff));
  332.     }
  335. /*
  336.  * Parallel to llc_rtrequest.
  337.  */
  338. void
  339. arp_rtrequest(req, rt, sa)
  340. int req;
  341. register struct rtentry *rt;
  342. struct sockaddr *sa;
  343. {
  344. register struct sockaddr *gate = rt->rt_gateway;
  345. register struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
  346. static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
  347. struct ifaddr *ifAddr = NULL;
  349. #ifdef WV_INSTRUMENTATION
  350. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  351.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 7, 17,
  352.                          WV_NETEVENT_ARPRTREQ_START, req)
  353. #endif  /* INCLUDE_WVNET */
  354. #endif
  356. #ifndef VIRTUAL_STACK
  357. if (!arpinit_done) {
  358. /*
  359.  * if this routine is executed for the first time, then 
  360.  * create the watch dog timer and kick of the arp timer.
  361.  */
  362. arpinit_done = 1;
  363. arptimerWd = wdCreate ();
  364. netJobAdd ((FUNCPTR)arptimer, 0, 0, 0, 0, 0);
  365. }
  366. #endif /* VIRTUAL_STACK */
  367. if (rt->rt_flags & RTF_GATEWAY)
  368. return;
  369. switch (req) {
  371. case RTM_ADD:
  372. /*
  373.  * XXX: If this is a manually added route to interface
  374.  * such as older version of routed or gated might provide,
  375.  * restore cloning bit.
  376.  */
  377. if ((rt->rt_flags & RTF_HOST) == 0 &&
  378.     SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
  379. rt->rt_flags |= RTF_CLONING;
  381. if (rt->rt_flags & RTF_CLONING) {
  382. /*
  383.  * Case 1: This route should come from a route to iface.
  384.  */
  386. rt_setgate(rt, rt_key(rt),
  387. (struct sockaddr *)&null_sdl);
  388. gate = rt->rt_gateway;
  389. SDL(gate)->sdl_type = rt->rt_ifp->if_type;
  390. SDL(gate)->sdl_index = rt->rt_ifp->if_index;
  391. /*
  392.  * Give this route an expiration time, even though
  393.  * it's a "permanent" route, so that routes cloned
  394.  * from it do not need their expiration time set.
  395.  */
  396. rt->rt_expire = tickGet();
  397.                         /*
  398.                          * rt_expire could be zero if the interface is
  399.                          * initialized before the first tick of the system
  400.                          * typically 1/60th of a second.
  401.                          * All the arp routes cloned from this route will
  402.                          * inherit all the route metrics properties.
  403.                          * if rt_expire is 0 for an arp route entry,
  404.                          * it never kicks in arpwhohas () in arpresolve ().
  405.                          * This would result in not generating an arp request
  406.                          * for the host. This problem was seen on the MIPS
  407.                          * board p4000. --- Vinai. Fix for SPR 8445
  408.                          */
  409.                         if (rt->rt_expire == 0)
  410.                             rt->rt_expire++;
  412. break;
  413. }
  414. /* Announce a new entry if requested. */
  415. if (rt->rt_flags & RTF_ANNOUNCE)
  416. arprequest((struct arpcom *)rt->rt_ifp,
  417.     &SIN(rt_key(rt))->sin_addr.s_addr,
  418.     &SIN(rt_key(rt))->sin_addr.s_addr,
  419.     (u_char *)LLADDR(SDL(gate)));
  420. /*FALLTHROUGH*/
  421. case RTM_RESOLVE:
  422. if (gate->sa_family != AF_LINK ||
  423.     gate->sa_len < sizeof(null_sdl)) {
  424. #ifdef WV_INSTRUMENTATION
  425. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  426.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_WARNING, 1, 8,
  427.                                  WV_NETEVENT_ARPRTREQ_BADGATE,
  428.                                  gate->sa_family, gate->sa_len)
  429. #endif  /* INCLUDE_WVNET */
  430. #endif
  432. logMsg("arp_rtrequest: bad gateway value",0,0,0,0,0,0);
  433. break;
  434. }
  435. SDL(gate)->sdl_type = rt->rt_ifp->if_type;
  436. SDL(gate)->sdl_index = rt->rt_ifp->if_index;
  437. if (la != 0)
  438. break; /* This happens on a route change */
  440. /*
  441.  * Case 2:  This route may come from cloning, or a manual route
  442.  * add with a LL address.
  443.  */
  445. if (arp_inuse >= arpMaxEntries) 
  446.                   arpEntryDelete ();
  447. R_Malloc(la, struct llinfo_arp *, sizeof(*la));
  448. rt->rt_llinfo = (caddr_t)la;
  449. if (la == 0) {
  450. #ifdef WV_INSTRUMENTATION
  451. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  452.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 1, 1,
  453.                              WV_NETEVENT_ARPRTREQ_FAIL)
  454. #endif  /* INCLUDE_WVNET */
  455. #endif
  457. logMsg("arp_rtrequest: malloc failedn",0,0,0,0,0,0);
  458. break;
  459. }
  460. arp_inuse++, arp_allocated++;
  461. Bzero(la, sizeof(*la));
  462. la->la_rt = rt;
  463. rt->rt_flags |= RTF_LLINFO;
  464. #ifdef VIRTUAL_STACK
  465. insque(la, &_llinfo_arp);
  466. #else
  467. insque(la, &llinfo_arp);
  468. #endif /* VIRTUAL_STACK */
  470. ifAddr = rt->rt_ifp->if_addrlist;
  472. /* 
  473.  * Find destination address in list of addresses assigned to
  474.  * interface.
  475.  */
  477. while (ifAddr)
  478.     {
  479.     if (SIN(rt_key(rt))->sin_addr.s_addr ==
  480.         (IA_SIN(ifAddr))->sin_addr.s_addr) 
  481. {
  482.     /*
  483.      * This test used to be
  484.      * if (loif.if_flags & IFF_UP)
  485.      * It allowed local traffic to be forced
  486.      * through the hardware by configuring the loopback down.
  487.      * However, it causes problems during network configuration
  488.      * for boards that can't receive packets they send.
  489.      * It is now necessary to clear "useloopback" and remove
  490.      * the route to force traffic out to the hardware.
  491.      */
  492. rt->rt_expire = 0;
  493. Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr,
  494. LLADDR(SDL(gate)), SDL(gate)->sdl_alen = 6);
  495. if (useloopback)
  496. rt->rt_ifp = loif;
  497.                         break;
  498. }
  499.                     ifAddr = ifAddr->ifa_next;
  500.     }
  501. break;
  503. case RTM_DELETE:
  504. if (la == 0)
  505. break;
  506. arp_inuse--;
  507. remque(la);
  508. rt->rt_llinfo = 0;
  509. rt->rt_flags &= ~RTF_LLINFO;
  510. if (la->la_hold)
  511. m_freem(la->la_hold);
  512. Free((caddr_t)la);
  513. }
  514. }
  516. /*
  517.  * Broadcast an ARP packet, asking who has addr on interface ac.
  518.  */
  519. void
  520. arpwhohas(ac, addr)
  521. register struct arpcom *ac;
  522. register struct in_addr *addr;
  523. {
  524. arprequest(ac, &ac->ac_ipaddr.s_addr, &addr->s_addr, ac->ac_enaddr);
  525. }
  527. /*
  528.  * Broadcast an ARP request. Caller specifies:
  529.  * - arp header source ip address
  530.  * - arp header target ip address
  531.  * - arp header source ethernet address
  532.  */
  533. static void
  534. arprequest(ac, sip, tip, enaddr)
  535. register struct arpcom *ac;
  536. register u_long *sip, *tip;
  537. register u_char *enaddr;
  538. {
  539. register struct mbuf *m;
  540. register struct ether_header *eh;
  541. register struct ether_arp *ea;
  542. struct sockaddr sa;
  544. if ((m = mHdrClGet(M_DONTWAIT, MT_DATA, 
  545.    sizeof(*ea), TRUE)) == NULL)
  546.             {
  547. #ifdef WV_INSTRUMENTATION
  548. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  549.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 2, 2,
  550.                              WV_NETEVENT_ARPREQ_FAIL)
  551. #endif  /* INCLUDE_WVNET */
  552. #endif
  554.     return;
  555.             }
  557. m->m_len = sizeof(*ea);
  558. m->m_pkthdr.len = sizeof(*ea);
  559. MH_ALIGN(m, sizeof(*ea));
  560. ea = mtod(m, struct ether_arp *);
  561. eh = (struct ether_header *)sa.sa_data;
  562. bzero((caddr_t)ea, sizeof (*ea));
  563. bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  564.     sizeof(eh->ether_dhost));
  565. eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */
  566. ea->arp_hrd = htons(ARPHRD_ETHER);
  567. ea->arp_pro = htons(ETHERTYPE_IP);
  568. ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
  569. ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
  570. ea->arp_op = htons(ARPOP_REQUEST);
  571. bcopy((caddr_t)enaddr, (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
  572. bcopy((caddr_t)sip, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
  573. bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));
  574. sa.sa_family = AF_UNSPEC;
  575. sa.sa_len = sizeof(sa);
  576. (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
  578. #ifdef WV_INSTRUMENTATION
  579. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  580.         WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 8, 18,
  581.                          WV_NETEVENT_ARPREQ_SEND)
  582. #endif  /* INCLUDE_WVNET */
  583. #endif
  584. }
  586. /*
  587.  * Resolve an IP address into an ethernet address.  If success,
  588.  * desten is filled in.  If there is no entry in arptab,
  589.  * set one up and broadcast a request for the IP address.
  590.  * Hold onto this mbuf and resend it once the address
  591.  * is finally resolved.  A return value of 1 indicates
  592.  * that desten has been filled in and the packet should be sent
  593.  * normally; a 0 return indicates that the packet has been
  594.  * taken over here, either now or for later transmission.
  595.  */
  596. int
  597. arpresolve(ac, rt, m, dst, desten)
  598. register struct arpcom *ac;
  599. register struct rtentry *rt;
  600. struct mbuf *m;
  601. register struct sockaddr *dst;
  602. register u_char *desten;
  603. {
  604. register struct llinfo_arp *la;
  605. struct sockaddr_dl *sdl;
  606. int alen;                          /* Length of MAC address */
  607. u_long lna;                        /* Host portion if IP address */
  608. struct ifnet *pIf = &ac->ac_if;
  609. USHORT *pSrc = NULL;
  610. USHORT *pDst = NULL;
  612. #ifdef WV_INSTRUMENTATION
  613. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  614.             WV_NET_DSTADDROUT_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 9, 19,
  615.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr,
  616.                                         WV_NETEVENT_ARPRESOLV_START,
  617.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  618. #endif  /* INCLUDE_WVNET */
  619. #endif
  621. if (m != NULL) /* check if mbuf is not null */
  622.     {
  623.     if (m->m_flags & M_BCAST)
  624. { /* broadcast */
  625. pDst = (USHORT *)desten;
  626. pDst[0] = 0xFFFF;
  627. pDst[1] = 0xFFFF;
  628. pDst[2] = 0xFFFF;
  629. return (1);
  630. }
  631.     if (m->m_flags & M_MCAST)
  632. { /* multicast */
  633. ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
  634. return(1);
  635. }
  636.     }
  638. if (rt)
  639. la = (struct llinfo_arp *)rt->rt_llinfo;
  640. else {
  641. if ((la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)))
  642. rt = la->la_rt;
  643. }
  644. if (la == 0 || rt == 0) {
  645. #ifdef WV_INSTRUMENTATION
  646. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  647.             WV_NET_DSTADDROUT_EVENT_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 3, 3,
  648.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr,
  649.                                     WV_NETEVENT_ARPLOOK_FAIL, WV_NET_SEND,
  650.                                ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  651. #endif  /* INCLUDE_WVNET */
  652. #endif
  654. logMsg ("arpresolve: lookup failed (resource shortage or n 
  655. network configuration error -- check netmask)n",0,0,0,0,0,0);
  656. m_freem(m);
  657. return (0);
  658. }
  659. sdl = SDL(rt->rt_gateway);
  660. /*
  661.  * Check the address family and length is valid, the address
  662.  * is resolved; otherwise, try to resolve.
  663.  */
  664. if ((rt->rt_expire == 0 || !TICK_GEQ (tickGet(), rt->rt_expire)) &&
  665.     sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
  666. pSrc = (USHORT *)LLADDR(sdl);
  667. pDst = (USHORT *)desten;
  668. pDst[0] = pSrc[0];
  669. pDst[1] = pSrc[1];
  670. pDst[2] = pSrc[2];
  671. return 1;
  672. }
  674.         /*
  675.  * For shared memory interface using a BSD driver, resolve using
  676.  * smNetAddrResolve. All other BSD drivers will have if_resolve
  677.  * equal to NULL.
  678.  */
  680. if ((pIf->pCookie == NULL) && (pIf->if_resolve) &&
  681.     ((*pIf->if_resolve) (pIf, (struct in_addr *) &(SIN(dst)->sin_addr),
  682.  desten, NULL) == 0))
  683.     return (1);
  685. /* If IFF_NOARP then make LL addr from IP host addr */
  686.  
  687. if (ac->ac_if.if_flags & IFF_NOARP) 
  688.     {
  690.     /* Set expiration of Route/ARP entry */
  692.     if (rt->rt_expire == 0)
  693. {
  694. rt->rt_expire = tickGet ();
  695. }
  697.     /* Set length of MAC address.  Default to Ethernet length. */
  699.     alen = (sdl->sdl_alen > 0 ? sdl->sdl_alen : 
  700.     sizeof (struct ether_addr));
  702.     if (alen < 3)
  703. {
  704. return (0);
  705. }
  707.     bcopy((caddr_t)ac->ac_enaddr, (char *)desten, alen - 3);
  709.     lna = in_lnaof(SIN(dst)->sin_addr);
  710.     desten[alen - 1]     = lna & 0xff;
  711.     desten[alen - 1 - 1] = (lna >> 8) & 0xff;
  712.     desten[alen - 1 - 2] = (lna >> 16) & 0x7f;
  713.     return (1);
  714.     }
  716. /*
  717.  * There is an arptab entry, but no ethernet address
  718.  * response yet.  Replace the held mbuf with this
  719.  * latest one.
  720.  */
  721. if (la->la_hold)
  722. m_freem(la->la_hold);
  723. la->la_hold = m;
  724. if (rt->rt_expire) {
  725. rt->rt_flags &= ~RTF_REJECT;
  726. if (arpRxmitTicks < 0)
  727.     arpRxmitTicks = ARP_RXMIT_TICKS_DFLT;
  728. if (la->la_asked == 0 || 
  729.     (tickGet () - rt->rt_expire >= arpRxmitTicks)) {
  730. rt->rt_expire = tickGet();
  731. if (la->la_asked++ < arp_maxtries)
  732. arpwhohas(ac, &(SIN(dst)->sin_addr));
  733. else {
  734. rt->rt_flags |= RTF_REJECT;
  735. rt->rt_expire += (sysClkRateGet() * arpt_down);
  736. la->la_asked = 0;
  737. }
  738. }
  739. }
  740. return (0);
  741. }
  743. /*
  744.  * Common length and type checks are done here,
  745.  * then the protocol-specific routine is called.
  746.  */
  748. #ifdef VIRTUAL_STACK
  749. void arpintr
  750.     (
  751.     int stackNum
  752.     )
  753. #else
  754. void arpintr()
  755. #endif /* VIRTUAL_STACK */
  756.     {
  757.     register struct mbuf *m;
  758.     register struct arphdr *ar;
  759.     int s;
  761. #ifdef WV_INSTRUMENTATION
  762. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  763.         WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 10, 20,
  764.                              WV_NETEVENT_ARPINTR_START)
  765. #endif  /* INCLUDE_WVNET */
  766. #endif
  768. #ifdef VIRTUAL_STACK
  769.     /* Set the correct virtual stack context for the input processing. */
  771.     virtualStackNumTaskIdSet (stackNum);
  772. #endif /* VIRTUAL_STACK */
  774.     s = splnet ();
  776.     while (arpintrq.ifq_head)
  777.         {
  778.         IF_DEQUEUE (&arpintrq, m);
  779.         if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
  780.             {
  781. #ifdef WV_INSTRUMENTATION
  782. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  783.             WV_NET_EVENT_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 4, 4,
  784.                             WV_NETEVENT_ARPINTR_FAIL, WV_NET_RECV)
  785. #endif  /* INCLUDE_WVNET */
  786. #endif
  788.             panic("arpintr");
  789.             }
  791. #ifdef VIRTUAL_STACK
  792.                 /*
  793.                  * (tNetTask) Set the virtual stack ID so the received
  794.                  * packet will be processed by the correct stack.
  795.                  */
  796.                 virtualStackNumTaskIdSet(m->m_pkthdr.rcvif->vsNum);
  797. #endif /* VIRTUAL_STACK */
  799.         if (m->m_len >= sizeof(struct arphdr) &&
  800.                 (ar = mtod(m, struct arphdr *)) &&
  801.                  ntohs(ar->ar_hrd) == ARPHRD_ETHER &&
  802.             m->m_len >= sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
  803.             {
  804.             switch (ntohs(ar->ar_pro))
  805.                 {
  806.                 case ETHERTYPE_IP:
  807.                 case ETHERTYPE_IPTRAILERS:
  808. #ifdef PROXY_HOOK
  809.                     if (proxyArpHook == NULL ||
  810.                         (* proxyArpHook)
  811.                          ( (struct arpcom *)m->m_pkthdr.rcvif, m) == FALSE)
  812. #endif
  813.                         in_arpinput(m);
  814.                     continue;
  815.                 }
  816.             }
  817.         m_freem(m);
  818.         }
  819.     splx (s);
  820.     }
  822. /*
  823.  * ARP for Internet protocols on 10 Mb/s Ethernet.
  824.  * Algorithm is that given in RFC 826.
  825.  * In addition, a sanity check is performed on the sender
  826.  * protocol address, to catch impersonators.
  827.  * We no longer handle negotiations for use of trailer protocol:
  828.  * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
  829.  * along with IP replies if we wanted trailers sent to us,
  830.  * and also sent them in response to IP replies.
  831.  * This allowed either end to announce the desire to receive
  832.  * trailer packets.
  833.  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
  834.  * but formerly didn't normally send requests.
  835.  */
  836. static void
  837. in_arpinput(m)
  838. struct mbuf *m;
  839. {
  840. register struct ether_arp *ea;
  841. register struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif;
  842. struct ether_header *eh;
  843. register struct llinfo_arp *la = 0;
  844. register struct rtentry *rt;
  845. struct in_ifaddr *ia, *maybe_ia = 0;
  846. struct sockaddr_dl *sdl;
  847. struct sockaddr sa;
  848. struct in_addr isaddr, itaddr, myaddr;
  849. int op;
  851. #ifdef WV_INSTRUMENTATION
  852. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  853.         WV_NET_EVENT_0 (NET_AUX_EVENT, WV_NET_NOTICE, 0, 12,
  854.                          WV_NETEVENT_ARPIN_START, WV_NET_RECV)
  855. #endif  /* INCLUDE_WVNET */
  856. #endif
  858. ea = mtod(m, struct ether_arp *);
  859. op = ntohs(ea->arp_op);
  860. bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr));
  861. bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr));
  862. #ifdef VIRTUAL_STACK
  863. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  864. #else
  865. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  866. #endif /* VIRTUAL_STACK */
  867. if (ia->ia_ifp == &ac->ac_if) {
  868. maybe_ia = ia;
  869. if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) ||
  870.      (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr))
  871. break;
  872. }
  873. if (maybe_ia == 0)
  874. goto out;
  875. myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr;
  876. if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr,
  877.     sizeof (ea->arp_sha)))
  878. goto out; /* it's from me, ignore it. */
  879. if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
  880.     sizeof (ea->arp_sha))) {
  881. #ifdef WV_INSTRUMENTATION
  882. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  883.                 WV_NET_DSTADDRIN_EVENT_1 (NET_AUX_EVENT, WV_NET_WARNING, 2, 9,
  884.                                           isaddr.s_addr,
  885.                                        WV_NETEVENT_ARPIN_BADADDR, WV_NET_RECV,
  886.                                           isaddr.s_addr)
  887. #endif  /* INCLUDE_WVNET */
  888. #endif
  890. logMsg (
  891.     "arp: ether address is broadcast for IP address %x!n",
  892.     (int)ntohl(isaddr.s_addr), 0,0,0,0,0);
  893. goto out;
  894. }
  896. if (ETHER_MULTICAST(ea->arp_sha))
  897.     {
  898. #ifdef WV_INSTRUMENTATION
  899. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  900. WV_NET_DSTADDRIN_EVENT_1 (NET_AUX_EVENT, WV_NET_WARNING, 2, 9,
  901.   isaddr.s_addr,
  902.        WV_NETEVENT_ARPIN_BADADDR, WV_NET_RECV,
  903.   isaddr.s_addr)
  904. #endif  /* INCLUDE_WVNET */
  905. #endif
  907.      logMsg ("arp: ether address is multicast for IP address %x!n",
  908.      (int)ntohl (isaddr.s_addr), 0, 0, 0, 0, 0);
  909.      goto out;
  910.      }
  912. if (isaddr.s_addr == myaddr.s_addr) {
  913. #ifdef WV_INSTRUMENTATION
  914. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  915.                 WV_NET_DSTADDRIN_EVENT_1 (NET_AUX_EVENT, WV_NET_WARNING, 3, 10,
  916.                                           isaddr.s_addr,
  917.                                        WV_NETEVENT_ARPIN_BADADDR2, WV_NET_RECV,
  918.                                           isaddr.s_addr)
  919. #endif  /* INCLUDE_WVNET */
  920. #endif
  922. logMsg(
  923.    "duplicate IP address %08x sent from ethernet address %sn",
  924.    (int)ntohl(isaddr.s_addr), (int)ether_sprintf(ea->arp_sha),
  925.    0,0,0,0);
  926. itaddr = myaddr;
  927. goto reply;
  928. }
  929. la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
  930. if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
  931. if (sdl->sdl_alen &&
  932.     bcmp((caddr_t)ea->arp_sha, LLADDR(sdl), sdl->sdl_alen))
  933.                     {
  934. #ifdef WV_INSTRUMENTATION
  935. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  936.                 WV_NET_DSTADDRIN_EVENT_1 (NET_AUX_EVENT, WV_NET_WARNING, 4, 11,
  937.                                           isaddr.s_addr,
  938.                                        WV_NETEVENT_ARPIN_BADADDR3, WV_NET_RECV,
  939.                                           isaddr.s_addr)
  940. #endif  /* INCLUDE_WVNET */
  941. #endif
  943. logMsg("arp info overwritten for %08x by %sn",
  944.     (int) ntohl(isaddr.s_addr), 
  945.     (int) ether_sprintf(ea->arp_sha),0,0,0,0);
  946.                     }
  947. bcopy((caddr_t)ea->arp_sha, LLADDR(sdl),
  948.     sdl->sdl_alen = sizeof(ea->arp_sha));
  949. if (rt->rt_expire)
  950. rt->rt_expire = tickGet() + (sysClkRateGet() * 
  951.      arpt_keep);
  952. rt->rt_flags &= ~RTF_REJECT;
  953. la->la_asked = 0;
  954. if (la->la_hold) {
  955. #ifdef WV_INSTRUMENTATION
  956. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  957.                    WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_NOTICE, 1, 13,
  958.                                    WV_NETEVENT_ARPIN_DELAYEDSEND, WV_NET_SEND,
  959.                                    isaddr.s_addr)
  960. #endif  /* INCLUDE_WVNET */
  961. #endif
  963. (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold,
  964. rt_key(rt), rt);
  965. la->la_hold = 0;
  966. }
  967. }
  968. reply:
  969. if (op != ARPOP_REQUEST) {
  970. out:
  971. m_freem(m);
  972. return;
  973. }
  974. if (itaddr.s_addr == myaddr.s_addr) {
  975. /* I am the target */
  976. bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
  977.     sizeof(ea->arp_sha));
  978. bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
  979.     sizeof(ea->arp_sha));
  980. } else {
  981. la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
  982. if (la == 0)
  983. goto out;
  984. rt = la->la_rt;
  985. bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
  986.     sizeof(ea->arp_sha));
  987. sdl = SDL(rt->rt_gateway);
  989.                 /*
  990.                  * ARP entries added by a proxy server use a "wildcard"
  991.                  * hardware address (equal to the sending interface) to
  992.                  * support multiple proxy networks.
  993.                  */
  995.                 if (rt->rt_flags & RTF_PROTO1)
  996.                     bcopy ((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
  997.                            sizeof(ea->arp_sha));
  998.                 else
  999.                     bcopy (LLADDR(sdl), (caddr_t)ea->arp_sha,
  1000.                            sizeof(ea->arp_sha));
  1001. }
  1003. bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, sizeof(ea->arp_spa));
  1004. bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
  1005. ea->arp_op = htons(ARPOP_REPLY);
  1006. ea->arp_pro = htons(ETHERTYPE_IP); /* let's be sure! */
  1007. eh = (struct ether_header *)sa.sa_data;
  1008. bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,
  1009.     sizeof(eh->ether_dhost));
  1010. eh->ether_type = ETHERTYPE_ARP;
  1011. sa.sa_family = AF_UNSPEC;
  1012. sa.sa_len = sizeof(sa);
  1014. #ifdef WV_INSTRUMENTATION
  1015. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  1016.         WV_NET_ADDROUT_EVENT_2 (NET_AUX_EVENT, WV_NET_NOTICE, 2, 14,
  1017.                                 isaddr.s_addr, itaddr.s_addr,
  1018.                                 WV_NETEVENT_ARPIN_REPLYSEND, WV_NET_SEND,
  1019.                                 itaddr.s_addr, isaddr.s_addr)
  1020. #endif  /* INCLUDE_WVNET */
  1021. #endif
  1023. (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
  1024. return;
  1025. }
  1027. /*
  1028.  * Free an arp entry.
  1029.  */
  1030. void
  1031. arptfree(la)
  1032. register struct llinfo_arp *la;
  1033. {
  1034. register struct rtentry *rt = la->la_rt;
  1035. register struct sockaddr_dl *sdl;
  1037. if (rt == 0)
  1038.             {
  1039. #ifdef WV_INSTRUMENTATION
  1040. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1041.             WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 5, 5,
  1042.                              WV_NETEVENT_ARPTFREE_PANIC)
  1043. #endif  /* INCLUDE_WVNET */
  1044. #endif
  1046. panic("arptfree");
  1047.             }
  1049.         if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
  1050.             sdl->sdl_family == AF_LINK) {
  1051.                 sdl->sdl_alen = 0;
  1052.                 la->la_asked = 0;
  1053.                 rt->rt_flags |= RTF_REJECT;
  1054.         }
  1055.  
  1056. #ifdef ROUTER_STACK
  1057.         /* Let Fastpath know that the entry is being deleted */
  1059.         FFL_CALL (ffLibMacEntryDeleted, 
  1060.                   (GET_IPV4_FF_ID, rt_key(rt), rt->rt_gateway));
  1061. #endif /* ROUTER_STACK */
  1063. rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
  1064.     0, (struct rtentry **)0);
  1065. }
  1067. /*
  1068.  * Lookup or enter a new address in arptab.
  1069.  */
  1070. static struct llinfo_arp *
  1071. arplookup(addr, create, proxy)
  1072. u_long addr;
  1073. int create, proxy;
  1074. {
  1075. register struct rtentry *rt;
  1076. #ifndef VIRTUAL_STACK
  1077. static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
  1079. sin.sin_addr.s_addr = addr;
  1080. sin.sin_other = proxy ? SIN_PROXY : 0;
  1081. rt = rtalloc1((struct sockaddr *)&sin, create);
  1082. #else
  1083. arpSin.sin_len    = sizeof(arpSin);
  1084.         arpSin.sin_family = AF_INET;
  1086. arpSin.sin_addr.s_addr = addr;
  1087. arpSin.sin_other = proxy ? SIN_PROXY : 0;
  1088. rt = rtalloc1((struct sockaddr *)&arpSin, create);
  1089. #endif /* VIRTUAL_STACK */
  1090. if (rt == 0)
  1091. return (0);
  1092. rt->rt_refcnt--;
  1093. if ((rt->rt_flags & RTF_GATEWAY) || (rt->rt_flags & RTF_LLINFO) == 0 ||
  1094.     rt->rt_gateway->sa_family != AF_LINK) {
  1095. if (create)
  1096. logMsg("arptnew failed on %xn", (int)ntohl(addr),
  1097. 0,0,0,0,0);
  1098. return (0);
  1099. }
  1100. return ((struct llinfo_arp *)rt->rt_llinfo);
  1101. }
  1104. int arpioctl
  1105.     (
  1106.     int  cmd,
  1107.     caddr_t data
  1108.     )
  1109.     {
  1110.     register struct arpreq * ar = (struct arpreq *)data;
  1111.     register struct sockaddr_in * soInAddr;
  1113.     register struct llinfo_arp * la = NULL;
  1114.     register struct rtentry * rt = NULL;
  1115.     struct rtentry *  pNewRt;
  1116.     struct sockaddr_dl *  sdl = NULL;
  1117.     struct sockaddr_in  rtmask;
  1118.     struct sockaddr_in *  pMask;
  1120.     struct sockaddr_inarp  ipaddr;
  1121.     struct sockaddr_dl  arpaddr;
  1123.     int error = OK;
  1124.     int flags = 0;
  1125.     BOOL proxy = FALSE;
  1126.     BOOL export = FALSE;
  1128. #ifdef WV_INSTRUMENTATION
  1129. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  1130.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 3, 16,
  1131.                      WV_NETEVENT_ARPIOCTL_START, cmd)
  1132. #endif  /* INCLUDE_WVNET */
  1133. #endif
  1135.     if (ar->arp_pa.sa_family != AF_INET ||
  1136. ar->arp_ha.sa_family != AF_UNSPEC)
  1137.         {
  1138. #ifdef WV_INSTRUMENTATION
  1139. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  1140.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 2, 7,
  1141.                          WV_NETEVENT_ARPIOCTL_NOTSUPP,
  1142.                          ar->arp_pa.sa_family, ar->arp_ha.sa_family)
  1143. #endif  /* INCLUDE_WVNET */
  1144. #endif
  1146. return (EAFNOSUPPORT);
  1147.         }
  1149.     soInAddr = (struct sockaddr_in *)&ar->arp_pa;
  1151.     switch ((u_int) cmd) 
  1152. {
  1153. case SIOCSARP:
  1154.             if (ar->arp_flags & ATF_PUBL)
  1155.                 {
  1156.                 flags |= RTF_ANNOUNCE;
  1157.                 proxy = TRUE;
  1158.                 }
  1160.             /* Use a "wildcard" hardware address for proxy server entries. */
  1162.             if (ar->arp_flags & ATF_PROXY)
  1163.                 flags |= RTF_PROTO1;
  1165.             /* Search for existing entry with same address. */
  1166.    
  1167.             bzero ( (char *)&ipaddr, sizeof (ipaddr));
  1168.             ipaddr.sin_len = sizeof (ipaddr);
  1169.             ipaddr.sin_family = AF_INET;
  1170.             ipaddr.sin_addr.s_addr = soInAddr->sin_addr.s_addr;
  1172.             rt = rtalloc1 ((struct sockaddr *)&ipaddr, 0);
  1173.     if (!rt)
  1174.                 {
  1175. #ifdef WV_INSTRUMENTATION
  1176. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1177.                 WV_NET_EVENT_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 1, 6,
  1178.                                 WV_NETEVENT_ARPIOCTL_SEARCHFAIL, WV_NET_SEND,
  1179.                                 cmd, soInAddr->sin_addr.s_addr)
  1180. #endif  /* INCLUDE_WVNET */
  1181. #endif
  1183.                 return (ENETUNREACH);
  1184.                 }
  1186.   
  1187.             if (rt && !(ar->arp_flags & ATF_INCOMPLETE)) 
  1188.                 {
  1189.                 rt->rt_refcnt--;
  1190.                 if (soInAddr->sin_addr.s_addr ==
  1191.                         ((struct sockaddr_in *)rt_key (rt))->sin_addr.s_addr)
  1192.                     {
  1193.                     /* Matching entry found. Check address type. */
  1194.                     if ( (rt->rt_flags & RTF_GATEWAY) || 
  1195.                               (rt->rt_flags & RTF_LLINFO) == 0 || 
  1196.                                      rt->rt_gateway->sa_family != AF_LINK)
  1197.                         {
  1198.                         /* Host entry found: must create proxy entry. */
  1200.                         if ( !(ar->arp_flags & ATF_PUBL))
  1201.                             return (EINVAL);
  1203.                         /* 
  1204.                          * Set flag to prevent replacement of current entry 
  1205.                          * by creating entry which includes SIN_PROXY flag.
  1206.                          */
  1208.                         export = TRUE;
  1209.                         }
  1210.                     }
  1211.                 /*
  1212.                  * For remote hosts or networks, the gateway's associated
  1213.                  * route entry contains the interface values.
  1214.                  */
  1216.                 if (rt->rt_flags & RTF_GATEWAY)
  1217.                     {
  1218.                     if (rt->rt_gwroute == 0)
  1219.                         return (EHOSTUNREACH);
  1220.                     else
  1221.                         sdl = SDL (rt->rt_gwroute->rt_gateway);
  1222.                     }
  1223.                 else
  1224.                     sdl = SDL (rt->rt_gateway);
  1226.                 if (sdl->sdl_family != AF_LINK)
  1227.                     return (EINVAL);
  1228.         }
  1230.             bzero ( (char *)&rtmask, sizeof (rtmask));
  1231.             rtmask.sin_len = 8;
  1232.             rtmask.sin_addr.s_addr = 0xffffffff;
  1234.             bzero ( (char *)&ipaddr, sizeof (ipaddr));
  1235.             ipaddr.sin_len = sizeof (ipaddr);
  1236.             ipaddr.sin_family = AF_INET;
  1237.             ipaddr.sin_addr.s_addr = soInAddr->sin_addr.s_addr;
  1239.             bzero ( (char *)&arpaddr, sizeof (arpaddr));
  1240.     arpaddr.sdl_len = sizeof (arpaddr);
  1241.             arpaddr.sdl_family = AF_LINK;
  1242.     
  1243.     if (ar->arp_flags & ATF_INCOMPLETE)
  1244.         {
  1245.         arpaddr.sdl_type = rt->rt_ifp->if_type;
  1246.         arpaddr.sdl_index = rt->rt_ifp->if_index;
  1247. }
  1248.     else
  1249. {
  1250.                 arpaddr.sdl_type = sdl->sdl_type;
  1251.                 arpaddr.sdl_index = sdl->sdl_index;
  1252. }
  1253.  
  1254.     bcopy ((caddr_t)ar->arp_ha.sa_data, LLADDR (&arpaddr),
  1255.   arpaddr.sdl_alen = sizeof (struct ether_addr)); 
  1257.             flags |= (RTF_HOST | RTF_STATIC);
  1259.             /* 
  1260.              * A netmask of 0 compares each route entry against the entire
  1261.              * key during lookups. If an overlapping network route already
  1262.              * exists, set it to all ones so that queries with SIN_PROXY set
  1263.              * will still succeed. If a matching host route exists, set the
  1264.              * SIN_PROXY flag in the new entry instead.
  1265.              */
  1267.             pMask = NULL;
  1268.             if (proxy)
  1269.                 {
  1270.                 if (export)
  1271.                     ipaddr.sin_other = SIN_PROXY;
  1272.                 else
  1273.                     {
  1274.                     pMask = &rtmask;
  1275.                     flags &= ~RTF_HOST;
  1276.                     }
  1277.                 }
  1279.     if (ar->arp_flags & ATF_INCOMPLETE)
  1280.         {
  1281.         pNewRt = rt;
  1283. /* The gateway entry needs to be converted to an AF_LINK type */
  1284.         error = rt_setgate (rt, (struct sockaddr *)&ipaddr, 
  1285.     (struct sockaddr *)&arpaddr);
  1286. if (error)
  1287.     break;
  1289. /* The llinfo_arp structure needs to be allocated */
  1291. if (rt->rt_ifa->ifa_rtrequest)
  1292.     rt->rt_ifa->ifa_rtrequest (RTM_RESOLVE, rt,
  1293. (struct sockaddr *)&arpaddr);
  1294. else
  1295.     arp_rtrequest (RTM_RESOLVE, rt,
  1296. (struct sockaddr *)&arpaddr);
  1297. }
  1298.     else
  1299.                 error = rtrequest (RTM_ADD, (struct sockaddr *)&ipaddr,
  1300.                                (struct sockaddr *)&arpaddr,
  1301.                                (struct sockaddr *)pMask, flags, &pNewRt);
  1303.             if (error == 0 && pNewRt)
  1304.                 {
  1305.         if (ar->arp_flags & ATF_PERM)
  1306.     pNewRt->rt_expire = 0; 
  1307.         else 
  1308.     pNewRt->rt_expire = tickGet() + (sysClkRateGet() *
  1309.                                                      arpt_keep);
  1310.                 pNewRt->rt_refcnt--;
  1311.                 }
  1312.     break;
  1314. case SIOCDARP: /* delete entry */
  1315.     if ((la = arplookup(soInAddr->sin_addr.s_addr, 0, 0)) == NULL)
  1316.                 {
  1317. #ifdef WV_INSTRUMENTATION
  1318. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1319.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 1, 6,
  1320.                                  WV_NETEVENT_ARPIOCTL_SEARCHFAIL,
  1321.                                  cmd, soInAddr->sin_addr.s_addr)
  1322. #endif  /* INCLUDE_WVNET */
  1323. #endif
  1325. return (EADDRNOTAVAIL); 
  1326.                 }
  1327.     arptfree(la);
  1328.     break;
  1330. case SIOCGARP: /* get entry */
  1331.     if ((la = arplookup(soInAddr->sin_addr.s_addr, 0, 0)) == NULL)
  1332.                 {
  1333. #ifdef WV_INSTRUMENTATION
  1334. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1335.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 1, 6,
  1336.                                  WV_NETEVENT_ARPIOCTL_SEARCHFAIL,
  1337.                                  cmd, soInAddr->sin_addr.s_addr)
  1338. #endif  /* INCLUDE_WVNET */
  1339. #endif
  1341. return (EADDRNOTAVAIL); 
  1342.                 }
  1343.     rt = la->la_rt; 
  1344.             sdl = SDL(rt->rt_gateway);
  1345.     ar->arp_flags = 0;  /* initialize the flags */
  1347.     if (sdl->sdl_alen)
  1348. {
  1349. bcopy(LLADDR(sdl), (caddr_t)ar->arp_ha.sa_data, sdl->sdl_alen);
  1350. ar->arp_flags |= ATF_COM; 
  1351. }
  1352.     else
  1353.                 {
  1354. #ifdef WV_INSTRUMENTATION
  1355. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1356.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_CRITICAL, 1, 6,
  1357.                                  WV_NETEVENT_ARPIOCTL_SEARCHFAIL,
  1358.                                  cmd, soInAddr->sin_addr.s_addr)
  1359. #endif  /* INCLUDE_WVNET */
  1360. #endif
  1362. return (EADDRNOTAVAIL); 
  1363.                 }
  1365.     if (rt->rt_flags & RTF_UP)
  1366. ar->arp_flags |= ATF_INUSE; 
  1368.     if (rt->rt_flags & RTF_ANNOUNCE)
  1369. ar->arp_flags |= ATF_PUBL; 
  1371.             if (rt->rt_flags & RTF_PROTO1)
  1372.                 ar->arp_flags |= ATF_PROXY; 
  1374.     if (rt->rt_expire == 0) 
  1375. ar->arp_flags |= ATF_PERM;
  1377.     break;
  1379. default : 
  1380.     return (EINVAL); 
  1381. }
  1382.     return (error); 
  1383.     }
  1385. /*******************************************************************************
  1386. *
  1387. * _arpCmd - issues an internal ARP command
  1388. *
  1389. * This routine directly call the arpioctl call for an ARP command. Expected
  1390. * values for the <cmd> parameter are SIOCSARP, SIOCGARP, or SIOCDARP. 
  1391. * The <pIpAddr> parameter specifies the IP address of the host. The
  1392. * <pHwAddr> pointer provides the corresponding link-level address in
  1393. * binary form. That parameter is only used with SIOCSARP, and is limited
  1394. * to the 6-byte maximum required for Ethernet addresses. The <pFlags> 
  1395. * argument provides any flag settings for the entry.
  1396. *
  1397. * RETURNS: OK, or ERROR if unsuccessful.
  1398. *
  1399. * NOMANUAL
  1400. *
  1401. * INTERNAL
  1402. * This routine should be called from inside the stack as from the
  1403. * ifAllRoutesDelete() routine to delete ARP entries.
  1404. */
  1406. STATUS _arpCmd
  1407.     (
  1408.     int                 cmd, /* arp command */
  1409.     struct in_addr *    pIpAddr, /* ip address */
  1410.     u_char *            pHwAddr, /* hardware address */
  1411.     int *               pFlags /* arp flags  */
  1412.     )
  1414.     {
  1415.     struct arpreq       arpRequest; /* arp request struct */
  1416.     STATUS              status = ERROR; /* return status  */
  1418.     /* fill in arp request structure */
  1420.     bzero ((caddr_t) &arpRequest, sizeof (struct arpreq));
  1421.     arpRequest.arp_pa.sa_family = AF_INET;
  1422.     ((struct sockaddr_in *)
  1423. &(arpRequest.arp_pa))->sin_addr.s_addr = pIpAddr->s_addr;
  1424.     arpRequest.arp_ha.sa_family = AF_UNSPEC;
  1426.     if (pHwAddr != NULL)
  1427.         bcopy ((caddr_t) pHwAddr ,(caddr_t) arpRequest.arp_ha.sa_data,
  1428.        ENET_SIZE);
  1430.     if (pFlags != NULL)
  1431.      arpRequest.arp_flags = *pFlags;
  1433.     if ((status = arpioctl (cmd, (caddr_t) &arpRequest)) == OK)
  1434.         {
  1435.         if (pHwAddr != NULL)
  1436.             bcopy ((caddr_t) arpRequest.arp_ha.sa_data, (caddr_t) pHwAddr,
  1437.                     ENET_SIZE);
  1439.         if (pFlags != NULL)
  1440.             *pFlags = arpRequest.arp_flags;
  1441.         }
  1443.     return (status);
  1444.     }
  1447. /*****************************************************************************
  1448. *
  1449. * arpEntryDelete - delete the oldest entry in ARP table
  1450. *
  1451. * This routine deletes the oldest non-permanent entry in the ARP table
  1452. *
  1453. * RETURNS: N/A
  1454. *
  1455. * NOMANUAL
  1456. */
  1458. static void arpEntryDelete ()
  1459.     {
  1460.     register struct llinfo_arp *la;
  1461. #ifdef VIRTUAL_STACK
  1462.     la = _llinfo_arp.la_prev;
  1463. #else
  1464.     la = llinfo_arp.la_prev;
  1465. #endif
  1467. #ifdef VIRTUAL_STACK
  1468.     while (la != &_llinfo_arp)
  1469. #else
  1470.     while (la != &llinfo_arp)
  1471. #endif
  1472.         {
  1473.         register struct rtentry *rt = la->la_rt;
  1475.         if (rt->rt_expire)
  1476.             {
  1477.             arptfree (la);
  1478.             break;
  1479.             }
  1480.         la = la->la_prev;
  1481.         }
  1482.     }
  1483.     
  1485. /*
  1486.  * Convert Ethernet address to printable (loggable) representation.
  1487.  */
  1488. char *
  1489. ether_sprintf(ap)
  1490. register u_char *ap;
  1491. {
  1492. register int i;
  1493. #ifndef VIRTUAL_STACK
  1494. static char etherbuf[18];
  1495. #endif /* VIRTUAL_STACK */
  1496. register char *cp = etherbuf;
  1498. for (i = 0; i < 6; i++) {
  1499. *cp++ = digits[*ap >> 4];
  1500. *cp++ = digits[*ap++ & 0xf];
  1501. *cp++ = ':';
  1502. }
  1503. *--cp = 0;
  1504. return (etherbuf);
  1505. }
  1507. #define db_printf printf
  1508. void
  1509. db_print_sa(sa)
  1510. struct sockaddr *sa;
  1511. {
  1512. int len;
  1513. u_char *p;
  1515. if (sa == 0) {
  1516. db_printf("[NULL]n");
  1517. return;
  1518. }
  1520. p = (u_char*)sa;
  1521. len = sa->sa_len;
  1522. db_printf("[");
  1523. while (len > 0) {
  1524. db_printf("%d", *p);
  1525. p++; len--;
  1526. if (len) db_printf(",");
  1527. }
  1528. db_printf("]n");
  1529. }
  1530. #ifdef DDB
  1532. static void
  1533. db_print_ifa(ifa)
  1534. struct ifaddr *ifa;
  1535. {
  1536. if (ifa == 0)
  1537. return;
  1538. db_printf("  ifa_addr=");
  1539. db_print_sa(ifa->ifa_addr);
  1540. db_printf("  ifa_dsta=");
  1541. db_print_sa(ifa->ifa_dstaddr);
  1542. db_printf("  ifa_mask=");
  1543. db_print_sa(ifa->ifa_netmask);
  1544. db_printf("  flags=0x%x,refcnt=%d,metric=%dn",
  1545.   ifa->ifa_flags,
  1546.   ifa->ifa_refcnt,
  1547.   ifa->ifa_metric);
  1548. }
  1550. static void
  1551. db_print_llinfo(li)
  1552. caddr_t li;
  1553. {
  1554. struct llinfo_arp *la;
  1556. if (li == 0)
  1557. return;
  1558. la = (struct llinfo_arp *)li;
  1559. db_printf("  la_rt=0x%x la_hold=0x%x, la_asked=0x%lxn",
  1560.   (u_int) la->la_rt, (u_int) la->la_hold, la->la_asked);
  1561. }
  1562. /*
  1563.  * Function to pass to rn_walktree().
  1564.  * Return non-zero error to abort walk.
  1565.  */
  1567. static int
  1568. db_show_radix_node(rn, w)
  1569. struct radix_node *rn;
  1570. void *w;
  1571. {
  1572. struct rtentry *rt = (struct rtentry *)rn;
  1574. db_printf("rtentry=0x%x", (u_int) rt);
  1576. db_printf(" flags=0x%x refcnt=%d use=%ld expire=%ldn",
  1577.   rt->rt_flags, rt->rt_refcnt,
  1578.   rt->rt_use, rt->rt_expire);
  1580. db_printf(" key="); db_print_sa(rt_key(rt));
  1581. db_printf(" mask="); db_print_sa(rt_mask(rt));
  1582. db_printf(" gw="); db_print_sa(rt->rt_gateway);
  1584. db_printf(" ifp=0x%x ", (u_int) rt->rt_ifp);
  1585. if (rt->rt_ifp)
  1586. db_printf("(%s%d)",
  1587.   rt->rt_ifp->if_name,
  1588.   rt->rt_ifp->if_unit);
  1589. else
  1590. db_printf("(NULL)");
  1592. db_printf(" ifa=0x%xn", (u_int) rt->rt_ifa);
  1593. db_print_ifa(rt->rt_ifa);
  1595. db_printf(" genmask="); db_print_sa(rt->rt_genmask);
  1597. db_printf(" gwroute=0x%x llinfo=0x%xn",
  1598.   (u_int) rt->rt_gwroute, (u_int) rt->rt_llinfo);
  1599. db_print_llinfo(rt->rt_llinfo);
  1601. return (0);
  1602. }
  1604. /*
  1605.  * Internal Function to print the route tree.
  1606.  * Given the radix tree head.
  1607.  */
  1608. int
  1609. _db_show_arptab(struct radix_node_head *rnh)
  1610. {
  1611. db_printf("Route tree for AF_INETn");
  1612. if (rnh == NULL) {
  1613. db_printf(" (not initialized)n");
  1614. return (0);
  1615. }
  1616. rn_walktree(rnh, db_show_radix_node, NULL);
  1617. return (0);
  1618. }
  1620. /*
  1621.  * Function to print all the route trees.
  1622.  * Use this from ddb:  "call db_show_arptab"
  1623.  */
  1624. int
  1625. db_show_arptab()
  1626. {
  1627. struct radix_node_head *rnh;
  1628. rnh = rt_tables[AF_INET];
  1629. return _db_show_arptab(rnh);
  1630. }
  1632. #ifdef ROUTER_STACK
  1633. /*
  1634.  * Function to print all the route trees for the fast forwarder.
  1635.  * Use this from ddb:  "call db_show_arptab_ff"
  1636.  */
  1637. int
  1638. db_show_arptab_ff()
  1639. {
  1640. return _db_show_arptab ((struct radix_node_head *)(IPV4_FF_CACHE_COOKIE (GET_IPV4_FF_ID)));
  1641. }
  1642. #endif /* ROUTER_STACK */
  1644. #endif /* DDB */
  1645. #endif /* INET */