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

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

VxWorks

开发平台：

C/C++

if_subr.c：源码内容
  1. /* if_subr.c - common routines for network interface drivers */
  3. /* Copyright 1990 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1989, 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_ethersubr.c 8.1 (Berkeley) 6/10/93
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01q,23may02,vvv  removed unnecessary m_copy from ether_output (SPR #77775)
  45. 01p,22apr02,wap  call ip_mloopback() rather than calling looutput() directly
  46.                  (SPR #72246)
  47. 01o,15apr02,wap  reinstate netJobAdd removal changes
  48. 01n,29mar02,wap  back out the previous change (needs more investigation)
  49. 01m,21mar02,rae  remove unecessary netJobAdd() SPR #
  50. 01l,21mar02,vvv  updated man page for copyFromMbufs (SPR #20787)
  51. 01k,01nov01,rae  fixed compile warnings, corrected WV event (SPR #71284)
  52. 01j,12oct01,rae  merge from truestack ver 01o, base 01h (SPR #69112 etc.)
  53. 01i,17oct00,spm  updated ether_attach to report memory allocation failures
  54. 01h,21aug98,n_s  updated if_omcast in ether_output () if_noproto in 
  55.                  do_protocol_with_type (). spr21074
  56. 01f,19sep97,vin  modified build_cluster to incorporate cluster blks,
  57.  removed pointers to refcounts.
  58. 01g,11aug97,vin  changed mBlkGet to use _pNetDpool.
  59. 01e,10jul97,vin  removed unsupported revarpinput() code.
  60. 01f,05jun97,vin  corrected processing for promiscuous interfaces in
  61.  ether_input.
  62. 01e,02jun97,spm  updated man page for bcopy_to_mbufs()
  63. 01d,15may97,vin  reworked ether_input, cleanup, added copyFromMbufs().
  64.  removed support for check_trailer().
  65. 01c,16dec96,vin  removed unnecessary ntohs(). 
  66. 01b,13nov96,vin  replaced m_gethdr with mBlkGet() in buildCluster.
  67. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02p of if_subr.c
  68. */
  70. #include "vxWorks.h"
  71. #include "stdlib.h"
  72. #include "stdio.h"
  73. #include "tickLib.h"
  74. #include "logLib.h"
  75. #include "errno.h"
  76. #include "netinet/in.h"
  77. #include "netinet/in_systm.h"
  78. #include "netinet/in_var.h"
  79. #include "netinet/ip.h"
  80. #include "net/if.h"
  81. #include "net/if_arp.h"
  82. #include "netinet/if_ether.h"
  83. #include "net/if_subr.h"
  84. #include "netinet/in_var.h"
  85. #include "netinet/ip_var.h"    /* for ipintr() prototype */
  86. #include "net/mbuf.h"
  87. #include "net/route.h"
  88. #include "net/if_llc.h"
  89. #include "net/if_dl.h"
  90. #include "net/if_types.h"
  91. #include "lstLib.h"
  92. #include "netLib.h"
  93. #include "muxLib.h"
  94. #include "memPartLib.h"
  96. #ifdef WV_INSTRUMENTATION
  97. #ifdef INCLUDE_WVNET
  98. #include "wvNetLib.h"
  99. #endif /* INCLUDE_WVNET */
  100. #endif
  102. #ifdef VIRTUAL_STACK
  103. #include "netinet/vsLib.h"
  104. #endif
  106. typedef struct net_type
  107.     {
  108.     NODE      node;
  109.     FUNCPTR     inputRtn;
  110.     int      etherType;
  111.     } NET_TYPE;
  113. #ifdef WV_INSTRUMENTATION
  114. #ifdef INCLUDE_WVNET
  115.     /* Set common fields of event identifiers for this module. */
  117. LOCAL UCHAR wvNetModuleId = WV_NET_IFSUBR_MODULE;   /* Value for if_subr.c */
  118. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  120. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  121. #endif    /* INCLUDE_WVNET */
  122. #endif
  124. /* externs */
  126. #ifndef VIRTUAL_STACK
  127. extern struct ifnet loif;
  128. extern  void ip_mloopback(struct ifnet *, struct mbuf *, struct sockaddr_in *,
  129.                           struct rtentry *rt);
  130. #endif /* VIRTUAL_STACK */
  132. u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  133. u_char ether_ipmulticast_min[6] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 };
  134. u_char ether_ipmulticast_max[6] = { 0x01, 0x00, 0x5e, 0x7f, 0xff, 0xff };
  136. #define senderr(e) { error = (e); goto bad;}
  138. LOCAL LIST netTypeList;
  140. /*
  141.  * Ethernet output routine.
  142.  * Encapsulate a packet of type family for the local net.
  143.  * Use trailer local net encapsulation if enough data in first
  144.  * packet leaves a multiple of 512 bytes of data in remainder.
  145.  * Assumes that ifp is actually pointer to arpcom structure.
  146.  */
  147. int
  148. ether_output(ifp, m0, dst, rt0)
  149. register struct ifnet *ifp;
  150. struct mbuf *m0;
  151. struct sockaddr *dst;
  152. struct rtentry *rt0;
  153. {
  154. u_short etype;
  155. int s, error = 0;
  156.   u_char edst[6];
  157. register struct mbuf *m = m0;
  158. register struct rtentry *rt;
  159. register struct ether_header *eh;
  160. int off, len = m->m_pkthdr.len;
  161. struct arpcom *ac = (struct arpcom *)ifp;
  163. if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
  164.             {
  165. #ifdef WV_INSTRUMENTATION
  166. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  167.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 2, 3,
  168.                             WV_NETEVENT_ETHEROUT_IFDOWN, WV_NET_SEND, ifp)
  169. #endif  /* INCLUDE_WVNET */
  170. #endif
  172.             senderr(ENETDOWN);
  173.             }
  174. ifp->if_lastchange = tickGet();
  175. if ((rt = rt0)) {
  176. if ((rt->rt_flags & RTF_UP) == 0) {
  177. if ((rt0 = rt = rtalloc1(dst, 1)))
  178. rt->rt_refcnt--;
  179. else {
  180. #ifdef WV_INSTRUMENTATION
  181. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  182.             WV_NET_DSTADDROUT_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 4, 5,
  183.                             ((struct sockaddr_in *)dst)->sin_addr.s_addr,
  184.                             WV_NETEVENT_ETHEROUT_NOROUTE, WV_NET_SEND,
  185.                             ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  186. #endif  /* INCLUDE_WVNET */
  187. #endif
  189.                              senderr(EHOSTUNREACH);
  190.                              }
  191. }
  192. if (rt->rt_flags & RTF_GATEWAY) {
  193. if (rt->rt_gwroute == 0)
  194. goto lookup;
  195. if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
  196. rtfree(rt); rt = rt0;
  197. lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
  198. if ((rt = rt->rt_gwroute) == 0) {
  199. #ifdef WV_INSTRUMENTATION
  200. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  201.             WV_NET_DSTADDROUT_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 4, 5,
  202.                        ((struct sockaddr_in *)rt->rt_gateway)->sin_addr.s_addr,
  203.                                     WV_NETEVENT_ETHEROUT_NOROUTE, WV_NET_SEND,
  204.                        ((struct sockaddr_in *)rt->rt_gateway)->sin_addr.s_addr)
  205. #endif  /* INCLUDE_WVNET */
  206. #endif
  207.                                     senderr(EHOSTUNREACH);
  208.                                 }
  209. }
  210. }
  211. if (rt->rt_flags & RTF_REJECT)
  212. if (rt->rt_rmx.rmx_expire == 0 ||
  213.     tickGet() < rt->rt_rmx.rmx_expire) {
  214. #ifdef WV_INSTRUMENTATION
  215. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  216.         WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_CRITICAL, 5, 6,
  217.                         WV_NETEVENT_ETHEROUT_RTREJECT, WV_NET_SEND)
  218. #endif  /* INCLUDE_WVNET */
  219. #endif
  220.                             senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
  221.                             }
  222. }
  223. switch (dst->sa_family) {
  225. #ifdef INET
  226. case AF_INET:
  227. if (!arpresolve(ac, rt, m, dst, edst))
  228. return (0); /* if not yet resolved */
  229. /* If broadcasting on a simplex interface, loopback a copy */
  230. if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
  231. ip_mloopback (ifp, m, (struct sockaddr_in *)dst,
  232.       (struct rtentry*)rt);
  233. off = m->m_pkthdr.len - m->m_len;
  234. etype = ETHERTYPE_IP;
  235. break;
  236. #endif
  237. case AF_UNSPEC:
  238. eh = (struct ether_header *)dst->sa_data;
  239.   bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
  240. etype = eh->ether_type;
  241. break;
  243. default:
  244. printf("%s%d: can't handle af%dn", ifp->if_name, ifp->if_unit,
  245. dst->sa_family);
  246. #ifdef WV_INSTRUMENTATION
  247. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  248.                 WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_ERROR, 3, 7,
  249.                                 WV_NETEVENT_ETHEROUT_AFNOTSUPP, WV_NET_SEND,
  250.                                 dst->sa_family)
  251. #endif  /* INCLUDE_WVNET */
  252. #endif
  253. senderr(EAFNOSUPPORT);
  254. }
  256. /*
  257.  * Add local net header.  If no space in first mbuf,
  258.  * allocate another.
  259.  */
  260. M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
  262. if (m == 0)
  263.             {
  264. #ifdef WV_INSTRUMENTATION
  265. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  266.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 3, 4,
  267.                             WV_NETEVENT_ETHEROUT_NOBUFS, WV_NET_SEND, ifp)
  268. #endif  /* INCLUDE_WVNET */
  269. #endif
  271.             senderr(ENOBUFS);
  272.             }
  274. eh = mtod(m, struct ether_header *);
  275. etype = htons(etype);
  276. bcopy((caddr_t)&etype,(caddr_t)&eh->ether_type,
  277. sizeof(eh->ether_type));
  278.   bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
  279.   bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
  280.     sizeof(eh->ether_shost));
  281. s = splimp();
  282. /*
  283.  * Queue message on interface, and start output if interface
  284.  * not yet active.
  285.  */
  286. if (IF_QFULL(&ifp->if_snd)) {
  287. IF_DROP(&ifp->if_snd);
  288. splx(s);
  289. #ifdef WV_INSTRUMENTATION
  290. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  291.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 3, 4,
  292.                             WV_NETEVENT_ETHEROUT_NOBUFS, WV_NET_SEND, ifp)
  293. #endif  /* INCLUDE_WVNET */
  294. #endif
  296. senderr(ENOBUFS);
  297. }
  298. IF_ENQUEUE(&ifp->if_snd, m);
  300. if ((ifp->if_flags & IFF_OACTIVE) == 0)
  301. (*ifp->if_start)(ifp);
  302. splx(s);
  303. ifp->if_obytes += len + sizeof (struct ether_header);
  304. if (m->m_flags & M_MCAST || m->m_flags & M_BCAST)
  305. ifp->if_omcasts++;
  307. #ifdef WV_INSTRUMENTATION
  308. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  309.         WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_NOTICE, 3, 12,
  310.                         WV_NETEVENT_ETHEROUT_FINISH, WV_NET_SEND, ifp, error)
  311. #endif  /* INCLUDE_WVNET */
  312. #endif
  313. return (error);
  315. bad:
  316. if (m)
  317. m_freem(m);
  318. return (error);
  319. }
  321. /*******************************************************************************
  322. *
  323. * do_protocol - check the link-level type field and process IP and ARP data
  324. *
  325. * This routine must not be called at interrupt level.
  326. * Process a received Ethernet packet;
  327. * the packet is in the mbuf chain m without
  328. * the ether header, which is provided separately.
  329. *
  330. * NOMANUAL
  331. */
  333. void
  334. ether_input(ifp, eh, m)
  335. struct ifnet *ifp;
  336. register struct ether_header *eh;
  337. struct mbuf *m;
  338. {
  339. u_short  etype;
  340. struct arpcom * ac = (struct arpcom *)ifp;
  342. #ifdef WV_INSTRUMENTATION
  343. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  344.         WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_NOTICE, 4, 13,
  345.                         WV_NETEVENT_ETHERIN_START, WV_NET_RECV, ifp)
  346. #endif  /* INCLUDE_WVNET */
  347. #endif
  349. if ((ifp->if_flags & IFF_UP) == 0) {
  350. m_freem(m);
  351. return;
  352. }
  353. ifp->if_lastchange = tickGet();
  354. ifp->if_ibytes += m->m_pkthdr.len + sizeof (*eh);
  355. if (eh->ether_dhost[0] & 1) {
  356. if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  357.     sizeof(etherbroadcastaddr)) == 0)
  358. m->m_flags |= M_BCAST;
  359. else
  360. m->m_flags |= M_MCAST;
  361. ifp->if_imcasts++;
  362. }
  364.         if (ifp->if_flags & IFF_PROMISC)
  365.             {
  366.             /*
  367.              * do not hand over the non multicast packets to the ip stack
  368.              * if they are not destined to us, orelse it confuses the
  369.              * ip forwarding logic and keeps sending unnecessary redirects.
  370.              * If packets destined for other hosts have to be snooped they
  371.              * have to done through driver level hooks.
  372.              */
  373.             
  374.             if (!(m->m_flags & (M_BCAST | M_MCAST)))
  375.                 {
  376.                 if (bcmp ((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_dhost,
  377.                           sizeof(eh->ether_dhost)) != 0)
  378.                     {
  379.                     m_freem (m);  /* free the packet chain */
  380.                     return; 
  381.                     }
  382.                 }
  383.             }
  384.         
  385. etype = ntohs(eh->ether_type);
  387.         /* add code here to process IEEE802.3 LLC format, Hook!! */
  389.         /* demux the packet and hand off the ip layer */
  390.         do_protocol_with_type (etype, m , ac, m->m_pkthdr.len); 
  391. }
  393. /*
  394.  * Perform common duties while attaching to interface list
  395.  */
  396. void
  397. ether_ifattach(ifp)
  398. register struct ifnet *ifp;
  399. {
  400. register struct ifaddr *ifa;
  401. register struct sockaddr_dl *sdl;
  403. #ifdef WV_INSTRUMENTATION
  404. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  405.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 11, 14,
  406.                          WV_NETEVENT_ETHERIFATTACH_START, ifp)
  407. #endif  /* INCLUDE_WVNET */
  408. #endif
  410. ifp->if_type = IFT_ETHER;
  411. ifp->if_addrlen = 6;
  412. ifp->if_hdrlen = 14;
  413. ifp->if_mtu = ETHERMTU;
  414. for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
  415. if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) &&
  416.     sdl->sdl_family == AF_LINK) {
  417. sdl->sdl_type = IFT_ETHER;
  418. sdl->sdl_alen = ifp->if_addrlen;
  419. bcopy((caddr_t)((struct arpcom *)ifp)->ac_enaddr,
  420.       LLADDR(sdl), ifp->if_addrlen);
  421. break;
  422. }
  423. }
  425. /*
  426.  * Add an Ethernet multicast address or range of addresses to the list for a
  427.  * given interface.
  428.  */
  429. int
  430. ether_addmulti(ifr, ac)
  431. struct ifreq *ifr;
  432. register struct arpcom *ac;
  433. {
  434. register struct ether_multi *enm;
  435. struct sockaddr_in *sin;
  436. u_char addrlo[6];
  437. u_char addrhi[6];
  438. int s = splimp();
  440. /*
  441.  * XXX - This event cannot currently occur: the ether_addmulti() routine
  442.  *       provides multicasting support which is not available for VxWorks
  443.  *       BSD Ethernet drivers.
  445. #ifdef WV_INSTRUMENTATION
  446. #ifdef INCLUDE_WVNET    /@ WV_NET_VERBOSE event @/
  447.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 12, 15,
  448.                          WV_NETEVENT_ADDMULT_START, ac->ac_if)
  449. #endif  /@ INCLUDE_WVNET @/
  450. #endif
  452.  * XXX - end of unused event
  453.  */
  455. switch (ifr->ifr_addr.sa_family) {
  457. case AF_UNSPEC:
  458. bcopy((char *)ifr->ifr_addr.sa_data, (char *)addrlo, 6);
  459. bcopy((char *) addrlo, (char *)addrhi, 6);
  460. break;
  462. #ifdef INET
  463. case AF_INET:
  464. sin = (struct sockaddr_in *)&(ifr->ifr_addr);
  465. if (sin->sin_addr.s_addr == INADDR_ANY) {
  466. /*
  467.  * An IP address of INADDR_ANY means listen to all
  468.  * of the Ethernet multicast addresses used for IP.
  469.  * (This is for the sake of IP multicast routers.)
  470.  */
  471. bcopy((char *)ether_ipmulticast_min, (char *)addrlo, 6);
  472. bcopy((char *)ether_ipmulticast_max, (char *)addrhi, 6);
  473. }
  474. else {
  475. ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
  476. bcopy((char *)addrlo, (char *)addrhi, 6);
  477. }
  478. break;
  479. #endif
  481. default:
  482. splx(s);
  483. #ifdef WV_INSTRUMENTATION
  484. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  485.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 4, 8,
  486.                                 WV_NETEVENT_ADDMULT_AFNOTSUPP,
  487.                                 ifr->ifr_addr.sa_family) 
  488. #endif  /* INCLUDE_WVNET */
  489. #endif
  490. return (EAFNOSUPPORT);
  491. }
  493. /*
  494.  * Verify that we have valid Ethernet multicast addresses.
  495.  */
  496. if ((addrlo[0] & 0x01) != 1 || (addrhi[0] & 0x01) != 1) {
  497. splx(s);
  498. #ifdef WV_INSTRUMENTATION
  499. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  500.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 5, 9,
  501.                                 WV_NETEVENT_ADDMULT_BADADDR,
  502.                                 ac->ac_if) 
  503. #endif  /* INCLUDE_WVNET */
  504. #endif
  506. return (EINVAL);
  507. }
  508. /*
  509.  * See if the address range is already in the list.
  510.  */
  511. ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
  512. if (enm != NULL) {
  513. /*
  514.  * Found it; just increment the reference count.
  515.  */
  516. ++enm->enm_refcount;
  517. splx(s);
  518. return (0);
  519. }
  520. /*
  521.  * New address or range; malloc a new multicast record
  522.  * and link it into the interface's multicast list.
  523.  */
  524.         MALLOC (enm, struct ether_multi *, sizeof(*enm), MT_IFMADDR, 
  525. M_DONTWAIT);
  526. if (enm == NULL) {
  527. splx(s);
  529. #ifdef WV_INSTRUMENTATION
  530. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  531.                 WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_EMERGENCY, 6, 1,
  532.                                  WV_NETEVENT_ADDMULT_NOBUFS)
  533. #endif  /* INCLUDE_WVNET */
  534. #endif
  535. return (ENOBUFS);
  536. }
  537. bcopy((char *)addrlo, (char *)enm->enm_addrlo, 6);
  538. bcopy((char *)addrhi, (char *)enm->enm_addrhi, 6);
  539. enm->enm_ac = ac;
  540. enm->enm_refcount = 1;
  541. enm->enm_next = ac->ac_multiaddrs;
  542. ac->ac_multiaddrs = enm;
  543. ac->ac_multicnt++;
  544. splx(s);
  545. /*
  546.  * Return ENETRESET to inform the driver that the list has changed
  547.  * and its reception filter should be adjusted accordingly.
  548.  */
  549. return (ENETRESET);
  550. }
  552. /*
  553.  * Delete a multicast address record.
  554.  */
  555. int
  556. ether_delmulti(ifr, ac)
  557. struct ifreq *ifr;
  558. register struct arpcom *ac;
  559. {
  560. register struct ether_multi *enm;
  561. register struct ether_multi **p;
  562. struct sockaddr_in *sin;
  563. u_char addrlo[6];
  564. u_char addrhi[6];
  565. int s = splimp();
  567. /*
  568.  * XXX - This event cannot currently occur: the ether_delmulti() routine
  569.  *       provides multicasting support which is not available for VxWorks
  570.  *       BSD Ethernet drivers.
  572. #ifdef WV_INSTRUMENTATION
  573. #ifdef INCLUDE_WVNET    /@ WV_NET_VERBOSE event @/
  574.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 13, 16,
  575.                             WV_NETEVENT_DELMULT_START, ac->ac_if)
  576. #endif  /@ INCLUDE_WVNET @/
  577. #endif
  579.  * XXX - end of unused event
  580.  */
  582. switch (ifr->ifr_addr.sa_family) {
  584. case AF_UNSPEC:
  585. bcopy((char *)ifr->ifr_addr.sa_data, (char *)addrlo, 6);
  586. bcopy((char *)addrlo, (char *)addrhi, 6);
  587. break;
  589. #ifdef INET
  590. case AF_INET:
  591. sin = (struct sockaddr_in *)&(ifr->ifr_addr);
  592. if (sin->sin_addr.s_addr == INADDR_ANY) {
  593. /*
  594.  * An IP address of INADDR_ANY means stop listening
  595.  * to the range of Ethernet multicast addresses used
  596.  * for IP.
  597.  */
  598. bcopy((char *)ether_ipmulticast_min, (char *)addrlo, 6);
  599. bcopy((char *)ether_ipmulticast_max, (char *)addrhi, 6);
  600. }
  601. else {
  602. ETHER_MAP_IP_MULTICAST(&sin->sin_addr, addrlo);
  603. bcopy((char *)addrlo, (char *)addrhi, 6);
  604. }
  605. break;
  606. #endif
  608. default:
  609. splx(s);
  610. #ifdef WV_INSTRUMENTATION
  611. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  612.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 6, 10,
  613.                                  WV_NETEVENT_DELMULT_AFNOTSUPP,
  614.                                  ifr->ifr_addr.sa_family)
  615. #endif  /* INCLUDE_WVNET */
  616. #endif
  617. return (EAFNOSUPPORT);
  618. }
  620. /*
  621.  * Look up the address in our list.
  622.  */
  623. ETHER_LOOKUP_MULTI(addrlo, addrhi, ac, enm);
  624. if (enm == NULL) {
  625. splx(s);
  626. #ifdef WV_INSTRUMENTATION
  627. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  628.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 7, 11,
  629.                                  WV_NETEVENT_DELMULT_BADADDR, ac->ac_if)
  630. #endif  /* INCLUDE_WVNET */
  631. #endif
  632. return (ENXIO);
  633. }
  634. if (--enm->enm_refcount != 0) {
  635. /*
  636.  * Still some claims to this record.
  637.  */
  638. splx(s);
  639. return (0);
  640. }
  641. /*
  642.  * No remaining claims to this record; unlink and free it.
  643.  */
  644. for (p = &enm->enm_ac->ac_multiaddrs;
  645.      *p != enm;
  646.      p = &(*p)->enm_next)
  647. continue;
  648. *p = (*p)->enm_next;
  649. FREE(enm, MT_IFMADDR);
  650. ac->ac_multicnt--;
  651. splx(s);
  652. /*
  653.  * Return ENETRESET to inform the driver that the list has changed
  654.  * and its reception filter should be adjusted accordingly.
  655.  */
  656. return (ENETRESET);
  657. }
  659. /*******************************************************************************
  660. *
  661. * check_trailer - check ethernet frames that have trailers following them
  662. *
  663. * Decypher the ethernet frames that are encoded via trailer protocol which
  664. * has a link level type field that contains a value which is an encoding of
  665. * the size of the data portion.  The original BSD 4.2 and 4.3 TCP/IP
  666. * implementations use the trailer protocol to accomplish more efficient
  667. * copying of data.  Basically the idea was to put the variable lenght protocol
  668. * headers (TCP, UDP, IP headers) at the end of a page aligned data and use
  669. * the link-level type field (ethernet type) to indicate both the use of a
  670. * specialized framing protocol as well as the length of the data following
  671. * the ethernet header.  The original link-level type field and the length
  672. * of the protocol headers following the data portion are attached between
  673. * the data portion (which should be of length multiple of 512 bytes) and
  674. * protocol headers.  (size of data portion == (type - 0x1000) * 415)
  675. *
  676. * Upon return, 'pOff' will contain NULL if trailer protocol is not being
  677. * used.  Otherwise, 'pOff' points to the trailer header and 'pLen'
  678. * will contain the size of the frame.
  679. *
  680. * NOMANUAL
  681. */
  683. void check_trailer (eh, pData, pLen, pOff, ifp)
  684.     FAST struct ether_header  *eh; /* ethernet header */
  685.     FAST unsigned char  *pData; /* data immediately after 'eh' */
  686.     FAST int  *pLen; /* value/result input data length */
  687.     FAST int  *pOff; /* result -- points to trailer header */
  688.     FAST struct ifnet  *ifp; /* network interface */
  690.     {
  691. #if 0 /* XXX No support for trailers in BSD44 vxWorks */    
  692.     FAST int resid;
  694.     eh->ether_type = ntohs((u_short)eh->ether_type);
  696.     if ((eh->ether_type >= ETHERTYPE_TRAIL)  &&
  697. (eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER))
  698. {
  699. *pOff = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
  701. if (*pOff >= ifp->if_mtu)
  702.     return; /* sanity */
  704. eh->ether_type = ntohs (*(u_short *) (pData + *pOff));
  705. resid          = ntohs (*(u_short *) (pData + *pOff + 2));
  707. if ((*pOff + resid) > *pLen)
  708.     return; /* sanity */
  710. *pLen = *pOff + resid;
  711. }
  712.     else
  713. *pOff = 0;
  714. #endif /* XXX No trailer support in BSD44 */    
  715.     }
  717. /*******************************************************************************
  718. *
  719. * bcopy_to_mbufs - copy data into mbuf chain
  720. *
  721. * Copies up to <totlen> bytes of data from <buf0> into a freshly allocated
  722. * mbuf. The <off0> parameter indicates the amount of trailer encapsulation,
  723. * which was formerly handled according to the trailer protocol described in
  724. * check_trailer(). Since trailer encapsulation is not supported in BSD 4.4,
  725. * that parameter is unused. The <width> argument supports machines which 
  726. * have special byte alignment requirements when copying data from device 
  727. * I/O buffers to main memory.  A macro function called 'copy_to_mbufs' is 
  728. * provided in the "mbuf.h" file for compatability with SunOS, which doesn't 
  729. * support the <width> parameter. This function uses mbuf clusters when possible
  730. * to enhance network throughput.
  731. *
  732. * RETURNS: first mbuf or 0 if error
  733. *
  734. * NOMANUAL
  735. */
  737. struct mbuf *bcopy_to_mbufs (buf0, totlen, off0, ifp, width)
  738.     u_char *buf0; /* buffer to be copied into mbufs */
  739.     int totlen; /* number of bytes to be copied */
  740.     int off0; /* trailer protocol indicative */
  741.     struct ifnet *ifp; /* network interface */
  742.     int width; /* copy data by this unit width */
  744.     {
  745.     return (m_devget ((char *) buf0, totlen, width, ifp, NULL));
  746.     }
  748. /*******************************************************************************
  749. * copyFromMbufs - copy data from an mbuf chain
  750. *
  751. * This routine copies data from an mbuf chain into a given buffer.
  752. * The length of the data copied from the mbuf chain is returned.
  753. * The argument width is provided for machines that have special byte alignment
  754. * requirements when copying data to an I/O buffer of the device from main
  755. * memory. This routine frees the mbuf chain passed to it. 
  756. *
  757. * This routine should not be used since it can cause unaligned memory accesses
  758. * resulting in target crashes.
  759. * 
  760. * RETURNS: length of data copied.
  761. *
  762. * NOMANUAL
  763. */
  765. int copyFromMbufs
  766.     (
  767.     char *  pIoBuf, /* buffer to copy mbufs into */
  768.     struct mbuf *  pMbuf, /* pointer to an mbuf chain */
  769.     int width /* width of the copy */
  770.     )
  771.     {
  772.     FAST char * pBuf = (char *) (pIoBuf);
  773.     FAST struct mbuf *  pMbufHead = pMbuf;
  774.     FAST char * adjBuf;
  775.     FAST int  adjLen;
  776.     FAST int  odd = 0;
  777.     FAST int  ix;
  778.     char  temp [4];
  780.     if (width == NONE)
  781.         {
  782.         for (; pMbuf != NULL; pBuf += pMbuf->m_len, pMbuf = pMbuf->m_next)
  783.             bcopy (mtod (pMbuf, char *), pBuf, pMbuf->m_len);
  784.         }
  786.     else if (width == 1)
  787.         {
  788. for (; pMbuf != NULL; pBuf += pMbuf->m_len, pMbuf = pMbuf->m_next)
  789.     bcopyBytes (mtod (pMbuf, char *), pBuf, pMbuf->m_len);
  790.         }
  791.     
  792.     else if (width == 2)
  793.         {
  794. for (; pMbuf != NULL; pMbuf = pMbuf->m_next)
  795.     {
  796.     adjLen = pMbuf->m_len;
  797.     adjBuf = mtod(pMbuf, char *);
  798.     if (odd > 0)
  799. {
  800. --pBuf;
  801. *((UINT16 *) temp) = *((UINT16 *) pBuf);
  802. temp [1] = *adjBuf++;
  803. --adjLen;
  804. *((UINT16 *) pBuf) = *((UINT16 *) temp);
  805. pBuf += 2;
  806. }
  807.     bcopyWords (adjBuf, pBuf, (adjLen + 1) >> 1);
  808.     pBuf += adjLen;
  809.             odd = adjLen & 0x1;
  810.     }
  811.         }
  813.     else if (width == 4)
  814.         {
  815. for (; pMbuf != NULL; pMbuf = pMbuf->m_next)
  816.     {
  817.     adjLen = pMbuf->m_len;
  818.     adjBuf = mtod(pMbuf, char *);
  819.     if (odd > 0)
  820. {
  821. pBuf -= odd;
  822. *((UINT32 *) temp) = *((UINT32 *) pBuf);
  823. for (ix = odd; ix < 4; ix++, adjBuf++, --adjLen)
  824.     temp [ix] = *adjBuf;
  825. *((UINT32 *) pBuf) = *((UINT32 *) temp);
  826. pBuf += 4;
  827. }
  828.     bcopyLongs (adjBuf, pBuf, (adjLen + 3) >> 2);
  829.     pBuf += adjLen;
  830.             odd = adjLen & 0x3;
  831.     }
  832.         }
  834.     else
  835.         {
  836.         panic ("copyFromMbufs");
  837.         }
  839.     m_freem (pMbufHead);  /* free the mbuf chain */
  840.     
  841.     return ((int) pBuf - (int) pIoBuf); /* return length copied */
  842.     }
  844. /*******************************************************************************
  845. *
  846. * build_cluster - encapsulate a passed buffer into a cluster mbuf.
  847. *
  848. * This routine is used to surround the passed buffer <buf0> with a
  849. * mbuf header and make it a pseudo cluster.  It is used primarily by the
  850. * network interface drivers to avoid copying large chunk of data incoming
  851. * from the network.  Network interface device drivers typically call this
  852. * routine with a pointer to the memory location where the IP data reside.
  853. * This buffer pointer is used as a cluster buffer pointer and inserted
  854. * into mbuf along with other relevant pieces information such as the
  855. * index into the reference count array, pointer to the reference count
  856. * array and the driver level free routine.
  857. *
  858. * RETURNS: NULL if unsuccessful, pointer to <struct mbuf> if successful.
  859. *
  860. * SEE ALSO: do_protocol_with_type(), uipc_mbuf.c
  861. *
  862. * NOMANUAL
  863. */
  865. struct mbuf *build_cluster (buf0, totlen, ifp, ctype, pRefCnt,
  866.     freeRtn, arg1, arg2, arg3)
  867.     u_char  *buf0; /* the buffer containing data */
  868.     int totlen; /* len of the buffer */
  869.     struct ifnet *ifp; /* network interface device pointer */
  870.     u_char ctype; /* type of this cluster being built */
  871.     u_char *pRefCnt; /* type-specific ref count array */
  872.     FUNCPTR freeRtn; /* driver level free callback routine */
  873.     int arg1; /* first argument to freeRtn() */
  874.     int arg2; /* second argument to freeRtn() */
  875.     int arg3; /* third argument to freeRtn() */
  877.     {
  878.     FAST struct mbuf    *m;
  879.     CL_BLK_ID pClBlk;
  881.     /* get an mbuf header, header will have ifp info in the packet header */
  883.     m = mBlkGet(_pNetDpool, M_DONTWAIT, MT_DATA);
  885.     if (m == NULL) /* out of mbufs! */
  886. return (NULL);
  888.     pClBlk = clBlkGet (_pNetDpool, M_DONTWAIT); 
  889.     
  890.     if (pClBlk == NULL) /* out of cl Blks */
  891.         {
  892.         m_free (m); 
  893. return (NULL);
  894.         }
  896.     /* intialize the header */
  898.     m->m_pkthdr.rcvif = ifp;
  899.     m->m_pkthdr.len = totlen;
  901.     m->m_data = (caddr_t) buf0; 
  902.     m->m_len = m->m_pkthdr.len;
  903.     m->m_flags = (M_EXT | M_PKTHDR) ;
  904.     m->pClBlk = pClBlk;
  905.     m->m_extBuf = (caddr_t) buf0;
  906.     m->m_extSize = m->m_pkthdr.len;
  907.     m->m_extFreeRtn = freeRtn;
  908.     m->m_extArg1 = arg1;
  909.     m->m_extArg2 = arg2;
  910.     m->m_extArg3 = arg3;
  911.     m->m_extRefCnt = 1;
  913.     return (m);
  914.     }
  916. /*******************************************************************************
  917. *
  918. * do_protocol_with_type - demultiplex incoming packet to the protocol handlers
  919. *
  920. * Demultiplexes the incoming packet to the associated protocol handler.  This
  921. * version supports IP, ARP, and a generic mechanism via an external lookup
  922. * table.
  923. *
  924. * This routine differs from do_protocol() in that the link-level frame type
  925. * is passed directly, instead of passing a pointer to an Ethernet header,
  926. * respectively.
  927. *
  928. * This routine must not be called interrupt level.
  929. *
  930. * NOMANUAL
  931. */
  933. void do_protocol_with_type
  934.     (
  935.     u_short         type, /* the frame type field */
  936.     struct mbuf * pMbuf, /* the frame data, in mbuf chain */
  937.     struct arpcom * pArpcom, /* the source interface information */
  938.     int len /* length of the mbuf data */
  939.     )
  940.     {
  941.     int s;
  942.     FAST struct ifqueue * inq;
  943.     FUNCPTR  pInputFunc;  /* message handler */
  945.     switch (type)
  946.         {
  947. case ETHERTYPE_IP:
  948.             ipintr(pMbuf);
  949.     return;
  950. case ETHERTYPE_ARP:
  951.             inq = &arpintrq;
  952.             pInputFunc = (FUNCPTR) arpintr;
  953.             break;
  954.         default:
  955.             {
  956.     /* No protocol. Drop packet */
  957.     
  958.     ((struct ifnet *) pArpcom)->if_noproto++;
  959.     m_freem (pMbuf); /* free the mbuf chain */
  960.     return;
  961.             }
  962.         }
  964.     s = splnet ();
  966.     if (IF_QFULL(inq))
  967.         {
  968.         IF_DROP (inq);
  969.         m_freem (pMbuf); /* free the mbuf chain */
  970. splx (s);
  971. }
  972.     else
  973.         {
  974.         IF_ENQUEUE (inq, pMbuf); /* put the mbuf chain in the packet queue */
  975. splx (s);
  977.         /* Schedule a new job to finish the handling of the IP or ARP data. */
  979. #ifdef VIRTUAL_STACK
  980.         netJobAdd (pInputFunc, pArpcom->ac_if.vsNum, 0, 0, 0, 0);
  981. #else
  982. arpintr();
  983. #endif /* VIRTUAL_STACK */
  984.         }
  985.     }
  987. /*******************************************************************************
  988. *
  989. * set_if_addr - handle SIOCSIFADDR ioctl
  990. *
  991. * Sets a protocol address associated with this network interface.
  992. * This function is called by various ioctl handlers in each of the network
  993. * interface drivers.
  994. *
  995. * RETURNS: 0 or appropriate errno
  996. *
  997. * NOMANUAL
  998. */
  1000. int set_if_addr (ifp, data, enaddr)
  1001.     struct ifnet  *ifp;   /* interface */
  1002.     char  *data;  /* usually "struct ifaddr *" */
  1003.     u_char  *enaddr;/* ethernet address */
  1005.     {
  1006.     int  error = 0;
  1007.     FAST struct ifaddr *ifa = (struct ifaddr *) data;
  1009.     ifp->if_flags |= IFF_UP;
  1011.     if ((error = (*ifp->if_init) (ifp->if_unit)) != 0)
  1012.         return (error);
  1014.     switch (ifa->ifa_addr->sa_family)
  1015.         {
  1016. #ifdef  INET
  1017.         case AF_INET:
  1018.             ((struct arpcom *) ifp)->ac_ipaddr = IA_SIN (ifa)->sin_addr;
  1019.             arpwhohas ((struct arpcom *) ifp, &IA_SIN (ifa)->sin_addr);
  1020.             break;
  1021. #endif /* INET */
  1022. default:
  1023.     logMsg ("eh: set_if_addr unknown family 0x%xn",
  1024. ifa->ifa_addr->sa_family,0,0,0,0,0);
  1025.     break;
  1026.         }
  1028.     return (0);
  1029.     }
  1031. /*******************************************************************************
  1032. *
  1033. * ether_attach - attach a new network interface to the network layer.
  1034. *
  1035. * Fill in the ifnet structure and pass it off to if_attach () routine
  1036. * which will attach the network interface described in that structure
  1037. * to the network layer software for future use in routing, packet reception,
  1038. * and transmisison.
  1039. *
  1040. * NOMANUAL
  1041. */
  1043. STATUS ether_attach (ifp, unit, name, initRtn, ioctlRtn, outputRtn, resetRtn)
  1044.     struct ifnet  *ifp; /* network interface data structure */
  1045.     int  unit; /* unit number */
  1046.     char  *name; /* name of the interface */
  1047.     FUNCPTR  initRtn; /* initialization routine */
  1048.     FUNCPTR  ioctlRtn; /* ioctl handler */
  1049.     FUNCPTR  outputRtn; /* output routine */
  1050.     FUNCPTR  resetRtn; /* reset routine */
  1052.     {
  1053. #ifdef WV_INSTRUMENTATION
  1054. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1055.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 14, 17,
  1056.                      WV_NETEVENT_ETHERATTACH_START, ifp)
  1057. #endif  /* INCLUDE_WVNET */
  1058. #endif
  1060.     bzero ((char *) ifp, sizeof (*ifp));
  1062.     ifp->if_unit   = unit;
  1063.     ifp->if_name   = name;
  1064.     ifp->if_mtu    = ETHERMTU;
  1065.     ifp->if_init   = initRtn;
  1066.     ifp->if_ioctl  = ioctlRtn;
  1067.     ifp->if_output = outputRtn;
  1068.     ifp->if_reset  = resetRtn;
  1069.     ifp->if_flags  = IFF_BROADCAST;
  1071.     return (if_attach (ifp));
  1072.     }
  1074. /*******************************************************************************
  1075. *
  1076. * netTypeAdd - add a network type to list of network types.
  1077. *
  1078. * RETURNS: OK if successful, otherwise ERROR.
  1079. *
  1080. * NOMANUAL
  1081. */
  1083. STATUS netTypeAdd (etherType, inputRtn)
  1084.     int              etherType; /* ethernet type */
  1085.     FUNCPTR             inputRtn; /* input routine */
  1087.     {
  1088.     NET_TYPE *          pType;
  1090.     if ((pType = (NET_TYPE *) KHEAP_ALLOC(sizeof(NET_TYPE))) == NULL)
  1091.         {
  1092. #ifdef WV_INSTRUMENTATION
  1093. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1094.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 7, 2,
  1095.                          WV_NETEVENT_TYPEADD_FAIL, etherType)
  1096. #endif  /* INCLUDE_WVNET */
  1097. #endif
  1099.         return (ERROR);
  1100.         }
  1101.     bzero((char *)pType, sizeof (NET_TYPE));
  1103.     pType->etherType    = etherType;
  1104.     pType->inputRtn     = inputRtn;
  1105.     lstAdd (&netTypeList, &pType->node);
  1106.     return (OK);
  1107.     }
  1109. /*******************************************************************************
  1110. *
  1111. * netTypeDelete - delete a network type from the list of network types.
  1112. *
  1113. * RETURNS: OK if successful, otherwise ERROR.
  1114. *
  1115. * NOMANUAL
  1116. */
  1118. STATUS netTypeDelete (etherType)
  1119.     int etherType; /* ethernet type */
  1121.     {
  1122.     NET_TYPE * pType;
  1124.     for (pType = (NET_TYPE *) lstFirst (&netTypeList);
  1125.          pType != NULL; pType = (NET_TYPE *) lstNext (&pType->node))
  1126. {
  1127.         if (etherType == pType->etherType)
  1128.             {
  1129.             lstDelete (&netTypeList, &pType->node);
  1130.     KHEAP_FREE((caddr_t)pType);
  1131.             return (OK);
  1132.             }
  1133. }
  1134.     return (ERROR);
  1135.     }
  1137. /*******************************************************************************
  1138. *
  1139. * netTypeInit - initialize list of network types.
  1140. *
  1141. * RETURNS: N/A
  1142. *
  1143. * NOMANUAL
  1144. */
  1146. void netTypeInit ()
  1147.     {
  1148.     lstInit (&netTypeList);
  1149.     }