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

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

VxWorks

开发平台：

C/C++

ipProto.c：源码内容
  1. /* ipProto.c - an interface between the BSD IP protocol and the MUX */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 03k,15may02,tcr  Make WV_NETEVENT_ETHEROUT_NOBUFS match uses elsewhere
  9. 03j,24apr02,rae  Fixed muxTxRestart race condition (SPR #74565)
  10. 03i,19apr02,wap  call ip_mloopback() rather than calling looutput() directly
  11.                  (SPR #72246)
  12. 03h,26mar02,vvv  fixed proxy broadcast storm (SPR #74518)
  13. 03g,02jan02,vvv  changed ipAttach failure message when device not found
  14. 03f,01nov01,rae  ipError frees buffers on END_ERR_NO_BUF (SPR #70545)
  15. 03e,15oct01,rae  merge from truestack ver 03r, base 02r(1) (SPRs 69573, 69112,
  16.                  29668, ROUTER_STACK etc.)
  17. 03d,24jul01,r_s  changed code to be ANSI compatible so that it compiles with
  18.                  diab. made asm macro changes for diab
  19. 03f,12jun01,rae  ipDetach checks for npt
  20. 03e,01jun01,rae  fix problem with last checkin
  21. 03d,08may01,rae  limited ARP binding to appropriate device types (SPR #33657)
  22. 03c,07feb01,spm  fixed modification history for branches and merges
  23. 03b,22nov00,rae  fixed problem with zeros in ethernet address (SPR# 29152)
  24. 03a,14nov00,rae  fix SIOC[ADD,DEL]MULTI for non-ethernet devices (SPR# 35459)
  25. 02z,13nov00,niq  merged from version 03o of tor2_0.open_stack-f1 brranh:
  26.                  added RFC 2233 support
  27. 02y,10nov00,ham  enhanced sanity check for memory allocation (SPR #62262)
  28. 02x,07nov00,spm  moved nptFlag from END_OBJ for T2 END binary compatibility
  29. 02w,23oct00,spm  removed duplicate free (corrects SPR #22324 fix) (SPR #30465)
  30. 02v,17oct00,spm  removed modification history from tor2_0_0.toolkit branch;
  31.                  merged from ver. 02z of tor3_0_x branch (base 02t): corrected
  32.                  attach routine (SPR #31351), added backward compatibility for
  33.                  END devices, and included general code cleanup
  34. 02u,17oct00,spm  updated for new if_attach: reports memory allocation failures
  35. 02t,17mar99,spm  added support for identical unit numbers (SPR #20913)
  36. 02s,16mar99,spm  recovered orphaned code from version 02q of tor2_0_x branch
  37.                  (base version 02n) (SPR #25570)
  38. 02r,03mar99,spm  eliminated buffer overflow when attaching device (SPR #22679);
  39.                  cleaned up mod history list
  40. 02q,03mar99,pul  update the driver flag during ipAttach(), SPR# 24287
  41. 02p,02mar99,pul  update ifp->if_baudrate during ipAttach(): SPR# 24256
  42. 02o,25feb99,pul  fixed multicast mapping to invoke resolution func spr#24255
  43. 02n,08aug98,n_s  fixed ipReceiveRtn to handle M_BLK chains (SPR #22324)
  44. 02m,26aug98,fle  doc : put library description next line
  45. 02l,24aug98,ann  fixed copy of ifSpeed field in ipIoctl() spr # 22198
  46. 02k,21aug98,n_s  fixed if_omcast increment in ipOutout (). spr # 21074
  47. 02j,16jul98,n_s  fixed ipIoctl () SIOCSIFFLAGS. SPR 21124
  48. 02i,15jun98,n_s  seperated ipDetach () into ipShutdownRtn () and 
  49.                  arpShutdownRtn ().  spr # 21545
  50. 02h,11dec97,gnn  removed IFF_SCAT and IFF_LOAN references.
  51. 02g,08dec97,gnn  END code review fixes.
  52. 02f,17oct97,vin  changes reflecting protocol recieveRtn changes.
  53. 02e,09oct97,vin  added break statements to ipIoctl(). fixed ipReceive().
  54. 02d,03oct97,gnn  added an error routine
  55. 02c,25sep97,gnn  SENS beta feedback fixes
  56. 02b,03sep97,gnn  implemented dropping of packets if the queue is full
  57. 02a,29aug97,jag  fixed bad parameter causing failure in txRestart routine.
  58. 01z,25aug97,gnn  documentation fixes for mangen.
  59. 01y,25aug97,gnn  added a check for attached in the TxRestart routine.
  60. 01x,19aug97,gnn  changes due to new buffering scheme.
  61. 01w,12aug97,gnn  name change and changes necessitated by MUX/END update.
  62. 01v,06jun97,vin  made enhancements, fixed arpReceive for multiple units.
  63. 01u,02jun97,gnn  put in stuff to deal with memory widths.
  64. 01t,20may97,gnn  fixed SPR 8627 so that multiple units are possible.
  65. 01s,15may97,gnn  modified muxUnbind to follow new prototype.
  66. 01r,30apr97,gnn  put a logMsg behind a debug check.
  67.                  cleaned up warnings.
  68. 01q,25apr97,gnn  fixed SPR 8461 about SNMP ioctls.
  69. 01p,09apr97,gnn  pass through for IFFLAGS.
  70. 01o,20mar97,map  Fixed problems in buffer loaning.
  71.                  Added gratuitous arp on SIOCSIFADDR.
  72. 01n,03feb97,gnn  Changed the way in which muxBufAlloc is used.
  73. 01m,30jan97,gnn  Fixed a bug in the call to build_cluster.
  74. 01l,24jan97,gnn  Modified vector code to handle holes in mbuf chains.
  75. 01k,24jan97,gnn  Fixed the bug where we were not checking the length of
  76.                  data in an mbuf as well as the next pointer.
  77.                  Fixed a bug in initialising for buffer loaning.
  78. 01j,22jan97,gnn  Added new private flags that is seperate from if flags.
  79. 01i,21jan97,gnn  Added code to handle scatter/gather.
  80.                  Changed the way send is done to deal with freeing buffers.
  81.                  Made receive routines return a value for SNARFing.
  82. 01h,20dec96,vin  fixed problems in send (added semGive, m_freem) 
  83.                  and recv routines (cleaned up). cleanup ifdefs.
  84. 01j,17dec96,gnn  added new drvCtrl structures.
  85. 01i,27nov96,gnn  added MIB 2 if_type handling.
  86. 01h,07nov96,gnn  fixed the bug where we were getting the flags wrong.
  87. 01g,23oct96,gnn  removed bcopy hack in initialization.
  88. 01f,22oct96,gnn  name changes to follow coding standards.
  89.                  cleanup of some compilation warnings.
  90. 01e,22oct96,gnn  removed ENET_HDR definition.
  91. 01d,22oct96,gnn  Changed all netVectors to netBuffers.
  92.                  Removed all private buffer loaning stuff.  That's all now
  93.                  in the MUX.
  94. 01c,23sep96,gnn  Added new buffering scheme information.
  95. 01b,13sep96,vin  fixed a bug in ipEtherIoctl for SIOCADDMULTI & SIOCDELMULTI 
  96. 01a,16may96,gnn  written.
  97. */
  98.  
  99. /*
  100. DESCRIPTION
  101. This library provides an interface between the Berkeley protocol stack
  102. and the MUX interface for both NPT and END devices. The ipAttach() routine
  103. binds the IP protocol to a specific device. It is called automatically
  104. during network initialization if INCLUDE_END is defined. The ipDetach()
  105. routine removes an existing binding to an END device.
  107. NOTE: The library can only transmit data to link-level destination addresses
  108.       less than or equal to 64 bytes in length.
  110. INCLUDE FILES: end.h muxLib.h etherMultiLib.h sys/ioctl.h
  111. */
  113. /* includes */
  115. #include "vxWorks.h"
  116. #include "stdio.h"
  117. #include "logLib.h"
  118. #include "semLib.h"
  119. #include "errnoLib.h"
  120. #include "tickLib.h"
  121. #include "intLib.h"
  122. #include "m2Lib.h"
  123. #include "private/m2LibP.h"
  124. #include "end.h"
  125. #include "muxLib.h"
  126. #include "private/muxLibP.h"
  127. #include "muxTkLib.h"
  128. #include "etherMultiLib.h"
  130. #include "sys/ioctl.h"
  132. #include "net/protosw.h"
  133. #include "sys/socket.h"
  134. #include "errno.h"
  136. #include "netinet/in_systm.h"
  137. #include "netinet/in_var.h"
  138. #include "netinet/ip.h"
  139. #include "netinet/if_ether.h"
  140. #include "net/if_subr.h"
  141. #include "net/if_dl.h"
  142. #include "net/if_llc.h"
  143. #include "net/mbuf.h"
  144. #include "ipProto.h"
  145. #include "netinet/ip_var.h"
  146. #include "stdlib.h"
  147. #include "memPartLib.h"
  149. #ifdef VIRTUAL_STACK
  150. #include "netinet/vsLib.h"
  151. #endif /* VIRTUAL_STACK */
  153. #ifdef ROUTER_STACK
  154. #include "wrn/fastPath/fastPathLib.h"
  155. #endif /* ROUTER_STACK */
  157. #ifdef WV_INSTRUMENTATION
  158. #ifdef INCLUDE_WVNET
  159. #include "wvNetLib.h"
  160. #endif /* INCLUDE_WVNET */
  161. #endif /* WV_INSTRUMENTATION */
  163. #ifdef WV_INSTRUMENTATION
  164. #ifdef INCLUDE_WVNET
  165.     /* Set common fields of event identifiers for this module. */
  167. LOCAL UCHAR wvNetModuleId = WV_NET_IPPROTO_MODULE;   /* Value for ipProto.c */
  168. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  170. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  171. #endif    /* INCLUDE_WVNET */
  172. #endif   /* WV_INSTRUMENTATION */
  174. /* defines */
  176. #define MAX_ADDRLEN 64  /* Largest link-level destination for NPT devices. */
  178. #define senderr(e) { error = (e); goto bad;}
  180. /* typedefs */
  182. typedef struct arpcom IDR;
  183. typedef struct mbuf MBUF;
  184. typedef struct ifnet IFNET;                 /* real Interface Data Record */
  185. typedef struct sockaddr SOCK;
  187. /* externs */
  189. IMPORT void if_dettach(struct ifnet *ifp);
  191. IMPORT void ip_mloopback(struct ifnet *, struct mbuf *, struct sockaddr_in *,
  192.                     struct rtentry *rt);
  194. /* globals */
  196. #ifdef ROUTER_STACK
  198. /*
  199.  * Pointer to the Fastpath library function table. This is set to
  200.  * point to the function table inside of ffLibInit() when it is called
  201.  */
  203. FF_LIB_FUNCTIONS * pFFLibFuncs = NULL;
  204. #endif /* ROUTER_STACK */
  207. /* locals */
  209. /* forward declarations */
  210. LOCAL BOOL ipReceiveRtn (void * pCookie, long type, M_BLK_ID pBuff,
  211.                          LL_HDR_INFO * pLinkHdrInfo, void * pSpare);
  212. LOCAL BOOL ipTkReceiveRtn (void * callbackId ,long type, M_BLK_ID pBuff,
  213.                           void * pSpareData);
  214. LOCAL STATUS ipShutdownRtn (void * pCookie, void * pSpare);
  215. LOCAL STATUS ipTkShutdownRtn (void * callbackId);
  216. LOCAL STATUS arpShutdownRtn (void * pCookie, void * pSpare);
  217. LOCAL STATUS arpTkShutdownRtn (void * callbackId);
  218. LOCAL void ipTxStartup (IP_DRV_CTRL* pDrvCtrl);
  219. LOCAL int ipIoctl (IDR * ifp, int cmd, caddr_t data );
  220. LOCAL int ipTxRestart (void * pCookie, IP_DRV_CTRL* pDrvCtrl);
  221. LOCAL int ipTkTxRestart (void * pSpare);
  223. LOCAL int ipOutput (register struct ifnet *ifp, struct mbuf *m0,
  224.                         struct sockaddr *dst, struct rtentry *rt0);
  225. LOCAL void ipError (END_OBJ* pEnd, END_ERR* pError, void * pSpare);
  226. LOCAL int ipOutputResume (struct mbuf*, struct sockaddr*, void*, void*);
  227. LOCAL int ipMcastResume (struct mbuf* pMbuf, struct sockaddr* ipDstAddr,
  228.                              void* pIfp, void* rt);
  230. #ifdef IP_DEBUG
  231. int ipDebug  = FALSE;
  232. #endif
  234. /******************************************************************************
  235. *
  236. * ipReceiveRtn - Send a packet from the MUX to the Protocol
  237. * 
  238. * This routine deals with  calling the upper layer protocol.
  239. *
  240. * RETURNS: always TRUE.
  241. *
  242. * NOMANUAL
  243. */
  245. BOOL ipReceiveRtn
  246.     (
  247.     void *  pCookie,   /* protocol/device binding from muxBind() */
  248.     long                type,           /* Protocol type.  */
  249.     M_BLK_ID  pMblk,         /* The whole packet. */
  250.     LL_HDR_INFO * pLinkHdrInfo, /* pointer to link level header info */
  251.     void *  pSpare  /* ip Drv ctrl */
  252.     )
  253.     {
  254.     END_OBJ *  pEnd;
  255.     struct ifnet *  pIfp;
  256.     M_BLK_ID            pMblkOrig;
  257.     IP_DRV_CTRL *  pDrvCtrl = (IP_DRV_CTRL *)pSpare;
  259. #ifdef ROUTER_STACK
  260.     struct ip* pIpHdr;
  261.     ULONG ipAddr=0;
  262.     struct sockaddr_in dstIpAddr;
  263. #endif  /* ROUTER_STACK */
  265.     if (pDrvCtrl == NULL)
  266.         {
  267.         logMsg ("ipProto: unknown devicen", 0, 0, 0, 0, 0, 0);
  268.         goto ipReceiveError;
  269.         }
  270.     
  271.     pIfp = &pDrvCtrl->idr.ac_if;
  273. #ifdef WV_INSTRUMENTATION
  274. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  275.     WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_NOTICE, 4, 13,
  276.                     WV_NETEVENT_ETHERIN_START, WV_NET_RECV, pIfp)
  277. #endif  /* INCLUDE_WVNET */
  278. #endif
  280.     if ((pIfp->if_flags & IFF_UP) == 0)
  281.         {
  282.         pIfp->if_ierrors++;
  283.         goto ipReceiveError;
  284.         }
  286.     pIfp->if_ipackets++;          /* bump statistic */
  287.     pIfp->if_lastchange = tickGet();
  288.     pIfp->if_ibytes += pMblk->mBlkPktHdr.len;
  290.     /* Make sure the entire Link Hdr is in the first M_BLK */
  292.     pMblkOrig = pMblk;
  293.     if (pMblk->mBlkHdr.mLen < pLinkHdrInfo->dataOffset
  294.         && (pMblk = m_pullup (pMblk, pLinkHdrInfo->dataOffset)) == NULL)
  295.         {
  296.         pMblk = pMblkOrig;
  297.         goto ipReceiveError;
  298.         }
  300.     switch (pIfp->if_type)
  301.         {
  302.         case M2_ifType_ethernetCsmacd:
  303.         case M2_ifType_iso88023Csmacd:
  304.         case M2_ifType_iso88024_tokenBus:
  305.         case M2_ifType_iso88025_tokenRing:
  306.         case M2_ifType_iso88026_man:
  307.         case M2_ifType_fddi:                  
  308.             if (pMblk->mBlkHdr.mData[0] & 1)
  309.                 {
  310.                 if (bcmp((caddr_t)etherbroadcastaddr,
  311.                          (caddr_t)pMblk->mBlkHdr.mData,
  312.                          sizeof(etherbroadcastaddr)) == 0)
  313.                     pMblk->mBlkHdr.mFlags |= M_BCAST;
  314.                 else
  315.                     pMblk->mBlkHdr.mFlags |= M_MCAST;
  316.                 pIfp->if_imcasts++;
  317.                 }
  318.             
  319.             if (pIfp->if_flags & IFF_PROMISC)
  320.                 {
  322. #ifdef ROUTER_STACK /* UNNUMBERED_SUPPORT */
  323. /* No point to reject if we are on an unnumbered P2P network */
  324. if (pIfp->if_flags & IFF_UNNUMBERED)
  325.     break;
  326. #endif /* ROUTER_STACK */
  328.                 /*
  329.                  * do not hand over the non multicast packets to the ip stack
  330.                  * if they are not destined to us, orelse it confuses the
  331.                  * ip forwarding logic and keeps sending unnecessary redirects.
  332.                  * If packets destined for other hosts have to be snooped they
  333.                  * have to done through driver level hooks.
  334.                  */
  335.                 
  336.                 if (!(pMblk->mBlkHdr.mFlags & (M_BCAST | M_MCAST)))
  337.                     {
  338.                     pEnd = PCOOKIE_TO_ENDOBJ(pCookie);
  340.                     if (pEnd->flags & END_MIB_2233)
  341.                         {
  342.                         if (bcmp ((char *)END_ALT_HADDR (pEnd),
  343.                                   (caddr_t)pMblk->mBlkHdr.mData,
  344.                                   END_ALT_HADDR_LEN (pEnd)) != 0)
  345.                             goto ipReceiveError;
  346.                         }
  347.                     else /* (RFC1213 style of counters supported) XXX */
  348.                         {
  349.                         if (bcmp ((char *)END_HADDR (pEnd),
  350.                                   (caddr_t)pMblk->mBlkHdr.mData,
  351.                                   END_HADDR_LEN (pEnd)) != 0)
  352.                             goto ipReceiveError;
  353.                         }
  354.                     }
  355.                 }
  356.             break;
  357.         default:
  358.             break;
  359.         }
  361.     /* point to the ip header, and adjust the length */
  362.     pMblk->mBlkHdr.mData  += pLinkHdrInfo->dataOffset;
  363.     pMblk->mBlkHdr.mLen   -= pLinkHdrInfo->dataOffset;
  364.     pMblk->mBlkPktHdr.len    -= pLinkHdrInfo->dataOffset;
  365.     pMblk->mBlkPktHdr.rcvif  = &pDrvCtrl->idr.ac_if;
  367. #ifdef VIRTUAL_STACK
  368.      /* Set the virtual stack ID so the received packet
  369.       * will be processed by the correct stack.
  370.       */
  372.       virtualStackNumTaskIdSet(pMblk->mBlkPktHdr.rcvif->vsNum);
  373. #endif /* VIRTUAL_STACK */
  375. #ifdef ROUTER_STACK
  376.     /*
  377.      * The algorithm explained...
  378.      * Check if Fastpath is enabled and this is an Ip packet.
  379.      * If so hand the packet over to the Fastpath code.
  380.      * If Fastpath is not enabled or if the Fastpath packet send function
  381.      * returns false, hand over the packet to tNetTask for normal processing.
  382.      */
  384.     if (SHOULD_GIVE_PACKET_TO_FF (GET_IPV4_FF_ID, pIfp) && 
  385.         type == ETHERTYPE_IP)
  386.         {
  387.         pIpHdr=mtod(pMblk, struct ip*);
  388.         ipAddr=pIpHdr->ip_dst.s_addr;
  389.         bzero((char*)&dstIpAddr, sizeof(struct sockaddr_in));
  390.         dstIpAddr.sin_len = sizeof(struct sockaddr_in);
  391.         dstIpAddr.sin_family=AF_INET;
  392.         dstIpAddr.sin_addr.s_addr=(ipAddr);
  394.         if (FF_NC_CALL (GET_IPV4_FF_ID, ffPktSend, (GET_IPV4_FF_ID, (struct sockaddr*)&dstIpAddr, pMblk, ETHERTYPE_IP, pIfp)) == OK)
  395.             {
  396. #ifdef DEBUG
  397.             logMsg("ipReceiveRtn: packet forwarded by Fastpathn",0,0,0,0,0,0);
  398. #endif /* DEBUG */
  399.             return (TRUE);
  400.             }
  401.         }
  402. #endif /* ROUTER_STACK */
  404.     do_protocol_with_type (type, pMblk , &pDrvCtrl->idr, 
  405.                            pMblk->mBlkPktHdr.len);
  406.     return (TRUE);
  408. ipReceiveError:
  409.     if (pMblk != NULL)
  410.         netMblkClChainFree (pMblk);
  412.     return (TRUE);
  413.     }
  415. /******************************************************************************
  416. *
  417. * ipTkReceiveRtn - send a packet to the protocol from an NPT device
  418. *
  419. * This routine transfers data to IP when an NPT device receives a packet
  420. * from a toolkit driver. The data contained in the <pMblk> argument is an
  421. * IP packet (without a link-level header). A toolkit driver updates the
  422. * flags in the mBlk to indicate a multicast or broadcast link-level frame.
  423. *
  424. * RETURNS: TRUE, always.
  425. *
  426. * NOMANUAL
  427. */
  429. LOCAL BOOL ipTkReceiveRtn
  430.     (
  431.     void * ipCallbackId,      /* Sent down in muxTkBind call. */
  432.     long         type,        /* Protocol type.  */
  433.     M_BLK_ID     pMblk,       /* The whole packet. */
  434.     void *       pSpareData   /* out of band data */
  435.     )
  436.     {
  437.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)ipCallbackId;
  438.     struct ifnet *  pIfp;
  440. #ifdef ROUTER_STACK
  441.     struct ip* pIpHdr;
  442.     ULONG ipAddr=0;
  443.     struct sockaddr_in dstIpAddr;
  444. #endif  /* ROUTER_STACK */
  446.     if (pDrvCtrl == NULL)
  447.         {
  448.         logMsg ("ipProto: unknown devicen", 0, 0, 0, 0, 0, 0);
  449.         goto ipReceiveError;
  450.         }
  452. #ifdef IP_DEBUG
  453.     if (ipDebug)
  454.         logMsg("start of ipTkReceiveRtn!n", 0, 0, 0, 0, 0, 0);
  455. #endif /* IP_DEBUG */
  457.     pIfp = (struct ifnet *)&pDrvCtrl->idr;
  459.     if ((pIfp->if_flags & IFF_UP) == 0)
  460.         {
  461.         pIfp->if_ierrors++;
  462.         goto ipReceiveError;
  463.         }
  465.     /* bump statistic */
  467.     pIfp->if_ipackets++;        
  468.     pIfp->if_lastchange = tickGet();
  469.     pIfp->if_ibytes += pMblk->mBlkPktHdr.len;
  471.     if(pMblk->mBlkHdr.mFlags & M_MCAST)
  472.         pIfp->if_imcasts++;
  474.     pMblk->mBlkPktHdr.rcvif     = pIfp;
  476.     /* hand off the packet to ip layer */
  478. #ifdef ROUTER_STACK
  479.     /* Check to see if Fastpath is enabled on the received interface */
  481.     if (SHOULD_GIVE_PACKET_TO_FF (GET_IPV4_FF_ID, pIfp) && 
  482.         type == ETHERTYPE_IP)
  483.         {
  484.         pIpHdr=mtod(pMblk, struct ip*);
  485.         ipAddr=pIpHdr->ip_dst.s_addr;
  486.         bzero((char*)&dstIpAddr, sizeof(struct sockaddr_in));
  487.         dstIpAddr.sin_len = sizeof(struct sockaddr_in);
  488.         dstIpAddr.sin_family=AF_INET;
  489.         dstIpAddr.sin_addr.s_addr=NTOHL(ipAddr);
  491.         if (FF_NC_CALL (GET_IPV4_FF_ID, ffPktSend, 
  492.                         (GET_IPV4_FF_ID, (struct sockaddr*)&dstIpAddr, 
  493.                          pMblk, ETHERTYPE_IP, pIfp)) == OK)
  494.             {
  495. #ifdef DEBUG
  496.             logMsg("ipTkReceiveRtn: packet forwarded by Fastpathn",0,0,0,0,0,0);
  497. #endif /* DEBUG */
  498.             return (TRUE);
  499.             }
  500.         }
  501. #endif /* ROUTER_STACK */
  503.     do_protocol_with_type (type, pMblk , (struct arpcom* )pIfp, 
  504.                            pMblk->mBlkHdr.mLen);
  506.     return (TRUE);
  508.     ipReceiveError:
  509.          {
  510.          if (pMblk != NULL)
  511.              netMblkClChainFree (pMblk);
  512.          }
  514.     return (TRUE);
  515.     }
  517. /******************************************************************************
  518. *
  519. * ipShutdownRtn - Shutdown the NULL protocol stack gracefully.
  520. * 
  521. * This routine is called by the lower layer upon muxDevUnload or a similar
  522. * condition to tell the protocol to shut itself down.
  523. *
  524. * RETURNS: OK, or ERROR if muxUnbind routine fails.
  525. *
  526. * NOMANUAL
  527. */
  529. LOCAL STATUS ipShutdownRtn
  530.     (
  531.     void *  pCookie,  /* protocol/device binding from muxBind() */
  532.     void *  pSpare  /* spare pointer from muxBind() */
  533.     )
  534.     {
  535.     IP_DRV_CTRL *  pDrvCtrl = (IP_DRV_CTRL *)pSpare;
  537.     if (!pDrvCtrl->attached)
  538. return (ERROR);
  540.     if_dettach(&pDrvCtrl->idr.ac_if);
  542.     KHEAP_FREE(pDrvCtrl->idr.ac_if.if_name);
  544.     netMblkFree (_pNetDpool, pDrvCtrl->pSrc);
  545.     netClFree (_pNetDpool, pDrvCtrl->pDstAddr);
  546.     netMblkFree (_pNetDpool, pDrvCtrl->pDst);
  548.     if (muxUnbind (pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipReceiveRtn) != OK)
  549. {
  550. logMsg ("Could not un-bind from the IP MUX!", 0, 0, 0, 0, 0, 0);
  551. return (ERROR);
  552. }
  554.     if (pDrvCtrl->pArpCookie == NULL)
  555.         {
  556.         pDrvCtrl->attached = FALSE;
  557.         }
  559.     pDrvCtrl->pIpCookie = NULL;
  561.     return (OK);
  562.     }
  564. /******************************************************************************
  565. *
  566. * arpShutdownRtn - Shutdown the NULL protocol stack gracefully.
  567. * 
  568. * This routine is called by the lower layer upon muxDevUnload or a similar
  569. * condition to tell the protocol to shut itself down.
  570. *
  571. * RETURNS: OK or ERROR.
  572. *
  573. * NOMANUAL
  574. */
  576. LOCAL STATUS arpShutdownRtn
  577.     (
  578.     void *  pCookie,  /* protocol/device binding from muxBind() */
  579.     void *  pSpare  /* spare pointer from muxBind() */
  580.     )
  581.     {
  582.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)pSpare;
  584.     if (pDrvCtrl == NULL)
  585.         return (ERROR);
  586.             
  587.     if (!pDrvCtrl->attached)
  588. return (ERROR);
  590.     if (muxUnbind (pDrvCtrl->pArpCookie, ETHERTYPE_ARP, ipReceiveRtn) != OK)
  591. {
  592. logMsg ("Could not un-bind from the ARP MUX!", 0, 0, 0, 0, 0, 0);
  593. return (ERROR);
  594. }
  596.     if (pDrvCtrl->pIpCookie == NULL)
  597.         {
  598.         pDrvCtrl->attached = FALSE;
  599.         }
  601.     pDrvCtrl->pArpCookie = NULL;
  603.     return (OK);
  604.     }
  606. /******************************************************************************
  607. *
  608. * ipTkShutdownRtn - Shutdown the protocol stack bound to a toolkit driver
  609. *
  610. * This routine is called by the lower layer upon muxDevUnload or a similar
  611. * condition to tell the protocol to shut itself down.
  612. *
  613. * RETURNS: OK or ERROR depending on ipDetach.
  614. *
  615. * NOMANUAL
  616. */
  618. LOCAL STATUS ipTkShutdownRtn
  619.     (
  620.     void * ipCallbackId       /* protocol/device binding from muxTkBind() */
  621.     )
  622.     {
  623.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)ipCallbackId;
  625.     if (pDrvCtrl == NULL)
  626.         return (ERROR);
  627.     
  628.     if (!pDrvCtrl->attached)
  629.         return (ERROR);
  631.     if_dettach(&pDrvCtrl->idr.ac_if);
  633.     KHEAP_FREE(pDrvCtrl->idr.ac_if.if_name);
  635.     netClFree (_pNetDpool, pDrvCtrl->pDstAddr);
  637.     if (muxUnbind(pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipTkReceiveRtn) != OK)
  638.         {
  639.         logMsg("Could not un-bind from the IP MUX!", 1, 2, 3, 4, 5, 6);
  640.         return (ERROR);
  641.         }
  643.     if (pDrvCtrl->pArpCookie == NULL)
  644.         {
  645.         pDrvCtrl->attached = FALSE;
  646.         }
  648.     pDrvCtrl->pIpCookie=NULL;
  650.     return (OK);
  651.     }
  653. /******************************************************************************
  654. *
  655. * arpTkShutdownRtn - shutdown the protocol stack bound to a toolkit driver. 
  656. *
  657. * This routine is called by the lower layer upon muxDevUnload or a similar
  658. * condition to tell the protocol to shut itself down.
  659. *
  660. * RETURNS: OK or ERROR.
  661. *
  662. * NOMANUAL
  663. */
  665. LOCAL STATUS arpTkShutdownRtn
  666.     (
  667.     void * ipCallbackId       /* Sent down in muxTkBind call. */
  668.     )
  669.     {
  670.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)ipCallbackId;
  672.     if (pDrvCtrl == NULL)
  673.         return (ERROR);
  675.     if (!pDrvCtrl->attached)
  676.         return (ERROR);
  678.     if (muxUnbind(pDrvCtrl->pArpCookie, ETHERTYPE_ARP, ipTkReceiveRtn) != OK)
  679.         {
  680.         logMsg("Could not un-bind from the ARP MUX!", 1, 2, 3, 4, 5, 6);
  681.         return (ERROR);
  682.         }
  684.     if (pDrvCtrl->pIpCookie == NULL)
  685.         {
  686.         pDrvCtrl->attached = FALSE;
  687.         }
  689.     pDrvCtrl->pArpCookie=NULL;
  691.     return (OK);
  692.     }
  694. /******************************************************************************
  695. *
  696. * ipTkError - a routine to deal with toolkit device errors
  697. *
  698. * This routine is called by the lower layer to handle a toolkit device error.
  699. *
  700. * RETURNS: N/A
  701. *
  702. * NOMANUAL
  703. *
  704. */
  706. void ipTkError
  707.     (
  708.     void * ipCallbackId,  /* Sent down in muxTkBind call. */
  709.     END_ERR* pError       /* Error message */
  710.     )
  711.     {
  712.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)ipCallbackId;
  713.     END_OBJ * pEnd  = NULL;
  715.     if (pDrvCtrl)
  716.  pEnd = PCOOKIE_TO_ENDOBJ (pDrvCtrl->pIpCookie);
  718.     if (pDrvCtrl == NULL || pEnd == NULL)
  719.         return;
  721.     ipError (pEnd, pError, pDrvCtrl);
  723.     return;
  724.     }
  726. /******************************************************************************
  727. *
  728. * ipError - a routine to deal with device errors
  729. *
  730. * This routine handles all errors from NPT and END drivers.
  731. *
  732. * RETURNS: N/A
  733. *
  734. * NOMANUAL
  735. */
  737. LOCAL void ipError
  738.     (
  739.     END_OBJ *  pEnd,  /* END reporting the error */
  740.     END_ERR *  pError,  /* the error message */
  741.     void *  pSpare  /* spare pointer from muxBind() */
  742.     )
  743.     {
  744.     int s;
  745.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)pSpare;
  746.     struct ifnet * pIfp;
  747.     USHORT newFlags;
  749.     if (pEnd == NULL || pDrvCtrl == NULL)
  750.      return;
  752.     pIfp = (struct ifnet *)&pDrvCtrl->idr;
  754.     switch (pError->errCode)
  755.         {
  756. #ifdef IP_DEBUG
  757.         case END_ERR_INFO:
  758.             if (ipDebug && pError->pMesg != NULL)
  759.                 logMsg ("INFO: Device: %s Unit: %d Msg: %sn",
  760.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  761.                         (int)pError->pMesg, 0, 0, 0);
  762.                 break;
  763.         case END_ERR_WARN:
  764.             if (ipDebug && pError->pMesg != NULL)
  765.                 logMsg ("WARN: Device: %s Unit: %d Msg: %sn",
  766.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  767.                         (int)pError->pMesg, 0, 0, 0);
  768.                 break;
  769. #endif /* IP_DEBUG */
  771.         case END_ERR_RESET:
  772. #ifdef IP_DEBUG
  773.             if (ipDebug && pError->pMesg != NULL)
  774.                 logMsg ("RESET: Device: %s Unit: %d Msg: %sn",
  775.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  776.                         (int)pError->pMesg, 0, 0, 0);
  777. #endif /* IP_DEBUG */
  779.             pDrvCtrl->idr.ac_if.if_lastchange = tickGet();
  780.             break;
  782.         case END_ERR_UP:
  783. #ifdef IP_DEBUG
  784.             if (ipDebug && pError->pMesg != NULL)
  785.                 logMsg ("UP: Device: %s Unit: %d Msg: %sn",
  786.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  787.                         (int)pError->pMesg, 0, 0, 0);
  788. #endif /* IP_DEBUG */
  790.             if ( (pIfp->if_flags & IFF_UP) == 0)
  791.                 {
  792.                 s = splimp ();
  793.                 if_up (pIfp);
  794.                 splx (s);
  795.                 }
  797.             pDrvCtrl->idr.ac_if.if_lastchange = tickGet();
  798.             ((IFNET *)&pDrvCtrl->idr)->if_flags |= (IFF_UP| IFF_RUNNING);
  799.             break;
  800.         case END_ERR_DOWN:
  801. #ifdef IP_DEBUG
  802.             if (ipDebug && pError->pMesg != NULL)
  803.                 logMsg ("DOWN: Device: %s Unit: %d Msg: %sn",
  804.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  805.                         (int)pError->pMesg, 0, 0, 0);
  806. #endif /* IP_DEBUG */
  808.             if ( (pIfp->if_flags & IFF_UP))
  809.                 {
  810.                 s = splimp ();
  811.                 if_down (pIfp);
  812.                 splx (s);
  813.                 }
  815.             pDrvCtrl->idr.ac_if.if_lastchange = tickGet();
  816.             ((IFNET *)&pDrvCtrl->idr)->if_flags &= ~(IFF_UP| IFF_RUNNING);
  817.             break;
  819.         case END_ERR_FLAGS:
  820. #ifdef IP_DEBUG
  821.             if (ipDebug && pError->pMesg != NULL)
  822.                 logMsg ("ipError:Msg from device %s Unit: %d Msg: %sn",
  823.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  824.                         (int)pError->pMesg, 0, 0, 0);
  825. #endif /* IP_DEBUG */
  827.             newFlags = (USHORT) ( (UINT32)pError->pSpare);
  829.             if ( (pIfp->if_flags & IFF_UP) ^ (newFlags & IFF_UP))
  830.                 {
  831.                 s = splimp ();
  833.                 if ( (pIfp->if_flags & IFF_UP) == 0)
  834.                     if_up (pIfp);
  835.                 else
  836.                     if_down (pIfp);
  838.                 splx (s);
  839.                 }
  841.             /* Set interface flags to new values, if allowed. */
  843.             newFlags = newFlags & ~IFF_CANTCHANGE;
  844.             pIfp->if_flags &= IFF_CANTCHANGE;
  845.             pIfp->if_flags = pIfp->if_flags | newFlags;
  847.             break;
  848.         case END_ERR_NO_BUF:
  849. #ifdef IP_DEBUG
  850.             if (ipDebug && pError->pMesg != NULL)
  851.                 logMsg ("NO_BUF: Device: %s Unit: %d Msg: %sn",
  852.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  853.                         (int)pError->pMesg, 0, 0, 0);
  854. #endif /* IP_DEBUG */
  855.             ip_drain();                      /* empty the fragment Q */
  857.             break;
  858.         default:
  859. #ifdef IP_DEBUG
  860.             if (ipDebug && pError->pMesg != NULL)
  861.                 logMsg ("UNKOWN ERROR: Device: %s Unit: %d Msg: %sn",
  862.                         (int)pEnd->devObject.name, pEnd->devObject.unit,
  863.                         (int)pError->pMesg, 0, 0, 0);
  864. #endif /* IP_DEBUG */
  865.             
  866. break;
  867.         }
  868.     }
  870. /******************************************************************************
  871. *
  872. * ipAttach - a generic attach routine for the TCP/IP network stack
  873. *
  874. * This routine takes the unit number and device name of an END or NPT
  875. * driver (e.g., "ln0", "ei0", etc.) and attaches the IP protocol to
  876. * the corresponding device. Following a successful attachment IP will
  877. * begin receiving packets from the devices.
  878. *
  879. * RETURNS: OK or ERROR
  880. */
  882. int ipAttach
  883.     (
  884.     int unit,                   /* Unit number  */
  885.     char *pDevice /* Device name (i.e. ln, ei etc.). */
  886.     )
  887.     {
  888.     long flags;
  889.     M2_INTERFACETBL mib2Tbl;
  890.     M2_ID * pM2ID; 
  891.     IP_DRV_CTRL* pDrvCtrl;
  892. #ifndef VIRTUAL_STACK
  893.     IMPORT int          ipMaxUnits;
  894. #endif
  895.     struct ifnet* pIfp = NULL;
  896.     char *pName = NULL;
  897.     END_OBJ* pEnd;
  898.     struct ifaddr *pIfa;
  899.     struct sockaddr_dl *pSdl;
  900.     CL_POOL_ID pClPoolId;
  901.     int ifHdrLen;
  902.     
  903.     int count;
  904.     int limit = ipMaxUnits;
  905.     int freeslot = -1;
  906.     
  907.     pEnd = endFindByName (pDevice, unit);
  908.     if (pEnd == NULL)
  909.         {
  910.         logMsg ("ipAttach: Can't attach %s (unit %d). It is not an END device.n",
  911.                 (int)pDevice, unit, 0, 0, 0, 0);
  912.         return (ERROR);
  913.         }
  914.     
  915.     for (count = 0; count < limit; count++)
  916.         {
  917.         pDrvCtrl = &ipDrvCtrl [count];
  918.         
  919.         if (pDrvCtrl->attached)
  920.             {
  921.             /* Already attached to requested device? */
  922.             
  923.             if (PCOOKIE_TO_ENDOBJ (pDrvCtrl->pIpCookie) == pEnd)
  924.                 return (OK);
  925.             }
  926.         else if (freeslot == -1)
  927.             freeslot = count;
  928.         }
  929.     
  930.     if (freeslot == -1)
  931.         {
  932.         /* Too many attach attempts. */
  933.         
  934.         logMsg ("Protocol is out of space. Increase IP_MAX_UNITS.n",
  935.                 0, 0, 0, 0, 0, 0);
  936.         
  937.         return (ERROR);
  938.         }
  939.     
  940.     pDrvCtrl = &ipDrvCtrl [freeslot];
  941.     bzero ( (char *)pDrvCtrl, sizeof (IP_DRV_CTRL));
  942.     
  943.     /*
  944.      * Bind IP to the device using the appropriate routines for the driver
  945.      * type. NPT devices use a different receive routine since those drivers
  946.      * remove the link-level header before handing incoming data to the MUX
  947.      * layer.
  948.      */
  949.     
  950.     pDrvCtrl->nptFlag = FALSE;
  951.     
  952.     if (pEnd->pFuncTable->ioctl)
  953.         {
  954.         if ( (pEnd->pFuncTable->ioctl (pEnd, EIOCGNPT, NULL)) == OK)
  955.             {
  956.             /* NPT device. */
  957.             pDrvCtrl->nptFlag = TRUE;
  958.             }
  959.         }
  960.     
  961.     if (pDrvCtrl->nptFlag)
  962.         {
  963.         /* NPT device */
  964.         pDrvCtrl->pIpCookie = muxTkBind (pDevice, unit, ipTkReceiveRtn,
  965.                                          ipTkShutdownRtn, ipTkTxRestart,
  966.                                          ipTkError, ETHERTYPE_IP, 
  967.                                          "IP 4.4 TCP/IP",
  968.                                          pDrvCtrl, NULL, NULL);
  969.         
  970.         if (pDrvCtrl->pIpCookie == NULL)
  971.             {
  972.             logMsg ("TCP/IP could not bind to the MUX: muxTkBind! %s",
  973.                     (int)pDevice, 0, 0, 0, 0, 0);
  974.             goto ipAttachError;
  975.             }
  976.         }
  977.     else
  978.         {
  979.         /* END device */
  980.         pDrvCtrl->pIpCookie = muxBind (pDevice, unit, (FUNCPTR) ipReceiveRtn,
  981.                                        (FUNCPTR) ipShutdownRtn, 
  982.                                        (FUNCPTR) ipTxRestart,
  983.                                        (VOIDFUNCPTR) ipError, ETHERTYPE_IP,
  984.                                        "IP 4.4 TCP/IP", (void *) pDrvCtrl);
  985.         if (pDrvCtrl->pIpCookie == NULL)
  986.             {
  987.             logMsg ("TCP/IP could not bind to the MUX! %s", (int)pDevice,
  988.                     0, 0, 0, 0, 0);
  989.             goto ipAttachError;
  990.             }
  991.         
  992.         
  993.         /*
  994.          * END devices require additional memory to construct a
  995.          * link-level header for outgoing data.
  996.          */
  997.         
  998.         pDrvCtrl->pSrc = netMblkGet (_pNetDpool, M_DONTWAIT, MT_DATA);
  999.         if (pDrvCtrl->pSrc == NULL)
  1000.             {
  1001.             goto ipAttachError;
  1002.             }
  1003.         
  1004.         pDrvCtrl->pDst = netMblkGet (_pNetDpool, M_DONTWAIT, MT_DATA);
  1005.         if (pDrvCtrl->pDst == NULL)
  1006.             {
  1007.             goto ipAttachError;
  1008.             }
  1009.         }
  1010.         
  1011.     /* Get storage for link-level destination addresses. */
  1012.     
  1013.     pClPoolId = netClPoolIdGet (_pNetDpool, MAX_ADDRLEN, TRUE);
  1014.     if (pClPoolId == NULL)
  1015.         {
  1016.         goto ipAttachError;
  1017.         }
  1018.     
  1019.     pDrvCtrl->pDstAddr = netClusterGet (_pNetDpool, pClPoolId);
  1020.     if (pDrvCtrl->pDstAddr == NULL)
  1021.         {
  1022.         goto ipAttachError;
  1023.         }
  1024.     
  1025.     /* Set the internal mBlk to access the link-level information. */
  1026.     
  1027.     if (!pDrvCtrl->nptFlag)
  1028.         pDrvCtrl->pDst->m_data = pDrvCtrl->pDstAddr;
  1029.     
  1030.     pName = KHEAP_ALLOC( (strlen (pDevice) + 1));    /* +1: EOS character */
  1031.     if (pName == NULL)
  1032.         {
  1033.         goto ipAttachError;
  1034.         }
  1035.     bzero (pName, strlen (pDevice) + 1);
  1036.     strcpy (pName, pDevice);
  1038.     /* Get all necessary lower-level device information. */
  1039.     
  1040.     muxIoctl (pDrvCtrl->pIpCookie, EIOCGFLAGS, (caddr_t)&flags);
  1041.     
  1042.     if (pEnd->flags & END_MIB_2233)
  1043.         {
  1044.         if (muxIoctl(pDrvCtrl->pIpCookie, EIOCGMIB2233,
  1045.                      (caddr_t)&pM2ID) == ERROR)
  1046.     {
  1047.     logMsg("ipAttach: could not get MIB2 Table for device %s #%dn",
  1048.                    (int)pDevice,unit,3,4,5,6);
  1049.             
  1050.     goto ipAttachError;
  1051.     }
  1052.         
  1053.         memcpy(&mib2Tbl, &(pM2ID->m2Data.mibIfTbl), sizeof(M2_INTERFACETBL));
  1054.         }
  1055.     else /* (RFC1213 style of counters supported) XXX */
  1056.         {
  1057.         if (muxIoctl(pDrvCtrl->pIpCookie, EIOCGMIB2,
  1058.                      (caddr_t)&mib2Tbl) == ERROR)
  1059.     {
  1060.     logMsg("ipAttach: could not get MIB2 Table for device %s #%dn",
  1061.                    (int)pDevice,unit,3,4,5,6);
  1062.             
  1063.     goto ipAttachError;
  1064.     }
  1065.         }
  1067.     pIfp = (IFNET *)&pDrvCtrl->idr;
  1068.     
  1069.     /* Hook up the interface pointers etc. */
  1070.     
  1071. #ifdef WV_INSTRUMENTATION
  1072. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1073.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 14, 17, 
  1074.                      WV_NETEVENT_ETHERATTACH_START, pIfp)
  1075. #endif  /* INCLUDE_WVNET */
  1076. #endif
  1077.         
  1078.         bzero ((char *) pIfp, sizeof (*pIfp));
  1079.     
  1080. #ifdef VIRTUAL_STACK
  1081.     virtualStackIdCheck();  /* make sure the myStackNum exists */
  1082.     pIfp->vsNum = myStackNum;
  1083. #endif /* VIRTUAL_STACK */
  1084.     
  1085.     pIfp->if_unit   = unit;
  1086.     pIfp->if_name   = pName;
  1087.     pIfp->if_mtu    = mib2Tbl.ifMtu;
  1088.     pIfp->if_baudrate = mib2Tbl.ifSpeed;
  1089.     pIfp->if_init   = NULL;
  1090.     pIfp->if_ioctl  = (FUNCPTR) ipIoctl;
  1091.     pIfp->if_output = ipOutput;
  1092.     pIfp->if_reset  = NULL;
  1093.     pIfp->if_resolve = muxAddrResFuncGet (mib2Tbl.ifType, ETHERTYPE_IP);
  1094.     pIfp->if_flags  = flags;
  1095.     pIfp->if_type = mib2Tbl.ifType;
  1096.     pIfp->if_addrlen = mib2Tbl.ifPhysAddress.addrLength;
  1097.     pIfp->pCookie = (void *)pDrvCtrl;
  1099.     /*
  1100.      * Store address information for supported devices (802.x addressing)
  1101.      * and bind ARP to the device using the appropriate receive routine.
  1102.      */
  1104.     switch (mib2Tbl.ifType)
  1105.         {
  1106.         case M2_ifType_ethernet_csmacd:
  1107.         case M2_ifType_iso88023_csmacd:
  1108.         case M2_ifType_iso88024_tokenBus:
  1109.         case M2_ifType_iso88025_tokenRing:
  1110.         case M2_ifType_iso88026_man:
  1111.         case M2_ifType_fddi:
  1113.             bcopy (mib2Tbl.ifPhysAddress.phyAddress, pDrvCtrl->idr.ac_enaddr,
  1114.                    pIfp->if_addrlen);
  1115.             
  1116.             if (pDrvCtrl->nptFlag)
  1117.                 {
  1118.                 pDrvCtrl->pArpCookie = muxTkBind (pDevice, unit,
  1119.                                                   ipTkReceiveRtn,
  1120.                                                   arpTkShutdownRtn,
  1121.                                                   ipTkTxRestart,
  1122.                                                   NULL, ETHERTYPE_ARP, 
  1123.                                                   "IP 4.4 ARP",
  1124.                                                   pDrvCtrl, NULL, NULL);
  1125.                 if (pDrvCtrl->pArpCookie == NULL)
  1126.                     {
  1127.                     logMsg ("ARP could not bind to the MUX: muxTkBind! %s",
  1128.                             (int)pDevice, 0, 0, 0, 0, 0);
  1129.                     goto ipAttachError;
  1130.                     }
  1131.                 }
  1132.             else     /* END device */
  1133.                 {
  1134.                 pDrvCtrl->pArpCookie = muxBind (pDevice, unit,
  1135.                                                 (FUNCPTR) ipReceiveRtn,
  1136.                                                 (FUNCPTR) arpShutdownRtn, 
  1137.                                                 (FUNCPTR) ipTxRestart,
  1138.                                                 NULL, ETHERTYPE_ARP, 
  1139.                                                 "IP 4.4 ARP",
  1140.                                                 pDrvCtrl);
  1141.                 if (pDrvCtrl->pArpCookie == NULL)
  1142.                     {
  1143.                     logMsg ("ARP could not bind to the MUX! %s", (int)pDevice,
  1144.                             0, 0, 0, 0, 0);
  1145.                     goto ipAttachError;
  1146.                     }
  1147.                 }
  1148.             break;
  1150.         default:
  1151.             break;
  1152.         }
  1153.     
  1154.     /* Get the length of the header. */
  1156.     if (muxIoctl (pDrvCtrl->pIpCookie, EIOCGHDRLEN, (caddr_t)&ifHdrLen) != OK)
  1157.         pIfp->if_hdrlen = 0;
  1158.     else
  1159.         pIfp->if_hdrlen = (short)ifHdrLen;
  1161.     
  1162.     /* Attach the interface. */
  1163.     /* NOTE: if_attach must come before "common duties" below.  see spr# 29152 */
  1164.     
  1165.     if (if_attach (pIfp) == ERROR)
  1166.         goto ipAttachError;
  1167.     
  1168.     /*
  1169.      * Perform common duties while attaching to interface list
  1170.      */
  1172.     for (pIfa = pIfp->if_addrlist; pIfa; pIfa = pIfa->ifa_next)
  1173.         {
  1174.         if ((pSdl = (struct sockaddr_dl *)pIfa->ifa_addr) &&
  1175.             pSdl->sdl_family == AF_LINK)
  1176.             {
  1177.             pSdl->sdl_type = pIfp->if_type;
  1178.             pSdl->sdl_alen = pIfp->if_addrlen;
  1179.             bcopy (mib2Tbl.ifPhysAddress.phyAddress,
  1180.                    LLADDR (pSdl), pSdl->sdl_alen);
  1181.             break;
  1182.             }
  1183.         }
  1184.     
  1185.     pIfp->if_start = (FUNCPTR)ipTxStartup;
  1186.     
  1187.     pDrvCtrl->attached = TRUE;
  1188.     
  1189.     return (OK);
  1191.     ipAttachError:
  1192.     
  1193.     /* Cleanup by removing any bound protocols and/or allocated memory. */
  1194.     
  1195.     if (pDrvCtrl->pDstAddr)
  1196.         netClFree (_pNetDpool, pDrvCtrl->pDstAddr);
  1197.     
  1198.     if (pDrvCtrl->nptFlag)
  1199.         {
  1200.         if (pDrvCtrl->pIpCookie)
  1201.             muxUnbind (pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipTkReceiveRtn);
  1202.         
  1203.         if (pDrvCtrl->pArpCookie)
  1204.             muxUnbind (pDrvCtrl->pArpCookie, ETHERTYPE_IP, ipTkReceiveRtn);
  1205.         }
  1206.     else
  1207.         {
  1208.         if (pDrvCtrl->pIpCookie)
  1209.             muxUnbind (pDrvCtrl->pIpCookie, ETHERTYPE_IP, ipReceiveRtn);
  1210.         
  1211.         if (pDrvCtrl->pArpCookie)
  1212.             muxUnbind (pDrvCtrl->pArpCookie, ETHERTYPE_IP, ipReceiveRtn);
  1213.         }
  1214.     
  1215.     if (pDrvCtrl->pSrc)
  1216.         netMblkFree (_pNetDpool, pDrvCtrl->pSrc);
  1217.     
  1218.     if (pDrvCtrl->pDst)
  1219.         netMblkFree (_pNetDpool, pDrvCtrl->pDst);
  1220.     
  1221.     return (ERROR);
  1222.     }
  1224. /*******************************************************************************
  1225. *
  1226. * ipTxRestart - restart routine 
  1227. *
  1228. * NOMANUAL
  1229. */
  1231. LOCAL int ipTxRestart
  1232.     (
  1233.     void * pCookie, /* device identifier (from muxDevLoad) */
  1234.     IP_DRV_CTRL * pDrvCtrl
  1235.     )
  1236.     {
  1237.     if (pDrvCtrl == NULL)
  1238.         return (ERROR);
  1239.     
  1240.     ipTxStartup (pDrvCtrl);
  1241.     
  1242.     return (OK);
  1243.     }
  1245. /*******************************************************************************
  1246. *
  1247. * ipTkTxRestart - restart routine registered with a toolkit driver. 
  1248. *
  1249. * NOMANUAL
  1250. */
  1252. LOCAL int ipTkTxRestart
  1253.     (
  1254.     void * ipCallbackId       /* Sent down in muxTkBind call. */
  1255.     )
  1256.     {
  1257.     IP_DRV_CTRL * pDrvCtrl = (IP_DRV_CTRL *)ipCallbackId;
  1259.     if (pDrvCtrl == NULL)
  1260.         return (ERROR);
  1262.     ipTxStartup (pDrvCtrl);
  1264.     return (OK);
  1265.     }
  1267. /*******************************************************************************
  1268. *
  1269. * ipTxStartup - start output on the lower layer
  1270. *
  1271. * Looks for any action on the queue, and begins output if there is anything
  1272. * there.  This routine is called from several possible threads.  Each will be
  1273. * described below.
  1274. *
  1275. * The first, and most common thread, is when a user task requests the
  1276. * transmission of data.  This will cause muxSend() to be called, which will
  1277. * cause ether_output() to be called, which will cause this routine to be
  1278. * called (usually).  This routine will not be called if ether_output() finds
  1279. * that our interface output queue is full.  In this case, the outgoing data
  1280. * will be thrown out.
  1281. *
  1282. * The second, and most obscure thread, is when the reception of certain
  1283. * packets causes an immediate (attempted) response.  For example, ICMP echo
  1284. * packets (ping), and ICMP "no listener on that port" notifications.  All
  1285. * functions in this driver that handle the reception side are executed in the
  1286. * context of netTask().  Always.  So, in the case being discussed, netTask() 
  1287. * will receive these certain packets, cause IP to be stimulated, and cause the
  1288. * generation of a response to be sent.  We then find ourselves following the
  1289. * thread explained in the second example, with the important distinction that
  1290. * the context is that of netTask().
  1291. *
  1292. * This routine is also called from ipTxRestart() and ipTkTxRestart().
  1293. *
  1294. * NOMANUAL
  1295. */
  1297. void ipTxStartup
  1298.     (
  1299.     IP_DRV_CTRL * pDrvCtrl /* pointer to the drv control */
  1300.     )
  1301.     {
  1302.     M_BLK_ID      pMblk;
  1303.     STATUS        status = OK;
  1305.     struct ifnet *  pIf;
  1306.     BOOL  nptFlag;
  1308.     USHORT netType = 0;
  1309.     char dstAddrBuf [MAX_ADDRLEN];
  1310.     M_BLK_ID pNetPkt = NULL;
  1311.     int s;
  1313.     if (pDrvCtrl == NULL)
  1314.         return;
  1316.     if (!pDrvCtrl->attached)
  1317.         {
  1318. #ifdef IP_DEBUG
  1319.         if (ipDebug)
  1320.             logMsg ("ipTxStartup not attached!n", 0, 0, 0, 0, 0, 0);
  1321. #endif /* IP_DEBUG */
  1322.         return;
  1323.         }
  1324.     s = splnet();
  1325.     nptFlag = pDrvCtrl->nptFlag;
  1327.     pIf = (struct ifnet *)&pDrvCtrl->idr;
  1329.     /*
  1330.      * Loop until there are no more packets ready to send or we
  1331.      * have insufficient resources left to send another one.
  1332.      */
  1334.     while (pIf->if_snd.ifq_head)
  1335.         {
  1336.         /* Dequeue a packet. */
  1338.         IF_DEQUEUE (&pIf->if_snd, pMblk);  
  1340. #ifdef ETHER_OUTPUT_HOOKS
  1341.         if ((etherOutputHookRtn != NULL) &&
  1342.             (* etherOutputHookRtn)
  1343.           (&pDrvCtrl->idr, (struct ether_header *)pMblk->m_data,pMblk->m_len))
  1344.             {
  1345.             continue;
  1346.             }
  1347. #endif /* ETHER_OUTPUT_HOOKS */
  1349.         if (nptFlag)
  1350.             {
  1351.             /*
  1352.              * For NPT devices, the output processing adds the network packet
  1353.              * type (and the link-level destination address, if any) to the
  1354.              * start of the packet. Retrieve that information and pass it to
  1355.              * the NPT transmit routine.
  1356.              */
  1358.             netType = pMblk->mBlkHdr.reserved;
  1359.             bzero (dstAddrBuf, MAX_ADDRLEN);
  1360.             pNetPkt = pMblk;
  1362.             if (pIf->if_addrlen)
  1363.                 {
  1364.                 /* Save the dest. address to protect it from driver changes. */
  1366.                 bcopy (pMblk->mBlkHdr.mData, dstAddrBuf, pIf->if_addrlen);
  1368.                 /* Restore original network packet data pointers and length. */
  1370.                 m_adj (pMblk, pIf->if_addrlen);
  1372.                 if (pMblk->mBlkHdr.mLen == 0)
  1373.                     {
  1374.                     /*
  1375.                      * The destination address used a new mBlk in the chain.
  1376.                      * Access the next entry containing the network packet
  1377.                      * and restore the header flag setting.
  1378.                      */
  1380.                     pNetPkt = pMblk->mBlkHdr.mNext;
  1382.                     if (pMblk->mBlkHdr.mFlags & M_PKTHDR)
  1383.                         {
  1384.                         pNetPkt->mBlkHdr.mFlags |= M_PKTHDR;
  1385.                         }
  1386.                     }
  1387.                 }
  1389.             /* Attempt to send the packet. */
  1391.             status = muxTkSend (pDrvCtrl->pIpCookie, pNetPkt, dstAddrBuf,
  1392.                                 netType, NULL);
  1393.             }
  1394.         else
  1395.             {
  1396.             /*
  1397.              * For END devices, the transmit queue contains a complete
  1398.              * link-level frame. Attempt to send that data.
  1399.              */
  1401.             status = muxSend (pDrvCtrl->pIpCookie, pMblk);
  1402.             }
  1404.         if (status == END_ERR_BLOCK)
  1405.             {
  1406.             /*
  1407.              * The device is currently unable to transmit. Return the
  1408.              * packet or frame to the queue to retry later.
  1409.              */
  1411. #ifdef IP_DEBUG
  1412.             if (ipDebug)
  1413.                 logMsg ("Transmit error!n", 0, 0, 0, 0, 0, 0);
  1414. #endif /* IP_DEBUG */
  1416.             if (nptFlag && pIf->if_addrlen)
  1417.                 {
  1418.                 /*
  1419.                  * For NPT devices, restore the link-level destination
  1420.                  * address, in case the driver processing altered it.
  1421.                  */
  1423.                 if (pMblk == pNetPkt)
  1424.                     {
  1425.                     /*
  1426.                      * The destination address used the initial mBlk in the
  1427.                      * chain. Change the data pointer to provide copy space.
  1428.                      */
  1430.                     pMblk->mBlkHdr.mData -= pIf->if_addrlen;
  1431.                     }
  1433.                 bcopy (dstAddrBuf, pMblk->mBlkHdr.mData, pIf->if_addrlen);
  1434.                 pMblk->mBlkHdr.mLen += pIf->if_addrlen;
  1436.                 if (pMblk->mBlkHdr.mFlags & M_PKTHDR)
  1437.                     pMblk->mBlkPktHdr.len += pIf->if_addrlen;
  1438.                 }
  1440.     /* If we are transmitting make a new copy and PREPEND it. */
  1442.     if (IF_QFULL(&pDrvCtrl->idr.ac_if.if_snd))
  1443.         {
  1444.         IF_DROP(&pDrvCtrl->idr.ac_if.if_snd);
  1445.         netMblkClChainFree (pMblk);
  1446.         ++pDrvCtrl->idr.ac_if.if_oerrors;          
  1447.                 }
  1448.     else
  1449.         IF_PREPEND (&pDrvCtrl->idr.ac_if.if_snd, pMblk);
  1450.             break;
  1451.             }
  1452.         else     /* Successful handoff to driver for transmission. */
  1453.            {
  1454.            ++pDrvCtrl->idr.ac_if.if_opackets;
  1456.             /* For NPT devices, free any Mblk prepended for the link-level
  1457.              * destination address.  */
  1458.            if (nptFlag && (pMblk != pNetPkt))
  1459.                {
  1460.                netMblkClFree(pMblk);
  1461.                }
  1462.            }
  1463.         
  1464. #ifdef IP_DEBUG
  1465.         if (ipDebug)
  1466.             logMsg("ipTxStartup done!n", 0, 0, 0, 0, 0, 0);
  1467. #endif /* IP_DEBUG */
  1468.         }
  1469.     splx(s);
  1470.     }
  1472. /*******************************************************************************
  1473. *
  1474. * ipDetach - a generic detach routine for the TCP/IP network stack
  1475. *
  1476. * This routine removes the TCP/IP stack from the MUX. If completed
  1477. * successfully, the IP protocol will no longer receive packets
  1478. * from the named END driver. 
  1479. *
  1480. * RETURNS: OK or ERROR
  1481. */
  1483. STATUS ipDetach
  1484.     (
  1485.     int unit,                   /* Unit number  */
  1486.     char *pDevice /* Device name (i.e. ln, ei etc.). */
  1487.     )
  1488.     {
  1489.     END_OBJ *  pEnd;
  1490.     IP_DRV_CTRL* pDrvCtrl = NULL;
  1491.     int error;                 /* return error status */
  1492.     int count;
  1493. #ifndef VIRTUAL_STACK
  1494.     IMPORT int          ipMaxUnits;
  1495. #endif
  1496.     int limit = ipMaxUnits;
  1497.     char        ifName[IFNAMSIZ];               /* if name, e.g. "en0" */
  1500.     /* Check if device is valid. */
  1502.     pEnd = endFindByName (pDevice, unit);
  1503.     if (pEnd == NULL)
  1504.         return (ERROR);
  1506.     for (count = 0; count < limit; count++)
  1507.         {
  1508.         pDrvCtrl = &ipDrvCtrl [count];
  1510.         if (pDrvCtrl->attached &&
  1511.                 PCOOKIE_TO_ENDOBJ (pDrvCtrl->pIpCookie) == pEnd)
  1512.             break;
  1513.         }
  1515.     if (count == limit)
  1516.         {
  1517.         /* Device not attached. */
  1519.         return (ERROR);
  1520.         }
  1522.     /* Now bring down the interface */
  1523.  
  1524.     sprintf (ifName,"%s%d",pDevice, unit);
  1525.     ifFlagChange(ifName, IFF_UP, 0);
  1526.  
  1527.     /* Now remove the interface route */
  1528.  
  1529.     ifRouteDelete(pDevice, unit);
  1530.     
  1531.     if (pDrvCtrl->nptFlag)       /* npt device, call npt routines */
  1532.         {
  1533.         error = ipTkShutdownRtn (pDrvCtrl);
  1534.         if (pDrvCtrl->pArpCookie)
  1535.             error |= arpTkShutdownRtn (pDrvCtrl);
  1536.         }
  1537.     else
  1538.         {
  1539.         error = ipShutdownRtn (pDrvCtrl->pIpCookie, pDrvCtrl);
  1540.         if (pDrvCtrl->pArpCookie)
  1541.             error |= arpShutdownRtn (pDrvCtrl->pArpCookie, pDrvCtrl);
  1542.         }
  1543.     
  1544.     return (error);
  1545.     }
  1547. /*******************************************************************************
  1548. *
  1549. * ipIoctl - the IP I/O control routine
  1550. *
  1551. * Process an ioctl request.
  1552. *
  1553. * NOMANUAL
  1554. */
  1556. LOCAL int ipIoctl
  1557.     (
  1558.     IDR  *ifp,
  1559.     int            cmd,
  1560.     caddr_t        data
  1561.     )
  1562.     {
  1563.     int error = OK;
  1565.     struct ifreq *ifr;
  1566.     IP_DRV_CTRL* pDrvCtrl;
  1567.     register struct in_ifaddr* pIa = 0;
  1568.     M2_INTERFACETBL mib2Tbl;
  1569.     struct sockaddr* inetaddr;
  1570.     char   mapMCastBuff[128];
  1571.     long flagsMask;
  1572.     register M2_NETDRVCNFG *pm2DrvCnfg = (M2_NETDRVCNFG *)data;
  1573.     register M2_NETDRVCNTRS *pm2DrvCntr = (M2_NETDRVCNTRS *)data;
  1574.     u_long dt_saddr = ((struct in_ifaddr *)data)->ia_addr.sin_addr.s_addr;
  1575.     struct mBlk* pMblk;
  1577.     pDrvCtrl = (IP_DRV_CTRL *)(ifp->ac_if.pCookie);
  1579.     if (pDrvCtrl->pIpCookie == NULL)
  1580.         return (EINVAL);
  1582.     switch ((u_int) cmd)
  1583. {
  1584. case SIOCSIFADDR:
  1585. #ifdef VIRTUAL_STACK
  1586.             for (pIa = _in_ifaddr; pIa; pIa = pIa->ia_next)
  1587. #else
  1588.             for (pIa = in_ifaddr; pIa; pIa = pIa->ia_next)
  1589. #endif /* VIRTUAL_STACK */
  1590.                 if ((pIa->ia_ifp == (struct ifnet *)ifp) &&
  1591.                     (pIa->ia_addr.sin_addr.s_addr == dt_saddr))
  1592.                     break;
  1594.             /*
  1595.              * For devices with 802.x addressing, setup ARP processing
  1596.              * for the IP address.
  1597.              */
  1599.             switch (ifp->ac_if.if_type)
  1600.                 {
  1601.                 case M2_ifType_ethernet_csmacd:
  1602.                 case M2_ifType_iso88023_csmacd:
  1603.                 case M2_ifType_iso88024_tokenBus:
  1604.                 case M2_ifType_iso88025_tokenRing:
  1605.                 case M2_ifType_iso88026_man:
  1606.                 case M2_ifType_fddi:
  1608. #ifdef ROUTER_STACK /* UNNUMBERED_SUPPORT */ 
  1609.             if (pIa->ia_ifp->if_flags & IFF_UNNUMBERED)
  1610.         {
  1611.         pIa->ia_ifa.ifa_rtrequest = NULL;
  1612.         pIa->ia_ifa.ifa_flags &= ~RTF_CLONING;
  1613.         ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
  1614.         break;
  1615.         }
  1616. #endif /* ROUTER_STACK */
  1618.                     pIa->ia_ifa.ifa_rtrequest = arp_rtrequest;
  1619.                     pIa->ia_ifa.ifa_flags |= RTF_CLONING;
  1620.                     ifp->ac_ipaddr = IA_SIN (data)->sin_addr;
  1622.                     /* Generate gratuitous ARP requests only for ethernet devices. */
  1623.                     arpwhohas ((struct arpcom*) ifp, &IA_SIN (data)->sin_addr);
  1625.                     break;
  1627.                 default:
  1628.                     break;
  1629.                 }
  1631.     break;
  1633.         case SIOCGMIB2CNFG:
  1634.     error = muxIoctl (pDrvCtrl->pIpCookie, EIOCGMIB2,
  1635.                               (caddr_t)&mib2Tbl);
  1636.             if (error != OK)
  1637.                 return (EINVAL);
  1638.             pm2DrvCnfg->ifType = mib2Tbl.ifType; /* ppp type */
  1639.             if (mib2Tbl.ifSpecific.idLength)
  1640.                 {
  1641.                 pm2DrvCnfg->ifSpecific.idLength = mib2Tbl.ifSpecific.idLength;
  1642.                 memcpy (&pm2DrvCnfg->ifSpecific.idArray[0],
  1643.                             &mib2Tbl.ifSpecific.idArray[0],
  1644.                             mib2Tbl.ifSpecific.idLength * sizeof (long));
  1645.                 }
  1646.             else
  1647.                 pm2DrvCnfg->ifSpecific.idLength = 0;
  1649.             break;
  1650.             
  1651.         case SIOCGMIB2CNTRS: /* fill in counters */
  1652.     error = muxIoctl (pDrvCtrl->pIpCookie, EIOCGMIB2,
  1653.                               (caddr_t)&mib2Tbl);
  1654.             if (error != OK)
  1655.                 return (EINVAL);
  1656.     pm2DrvCntr->ifSpeed = mib2Tbl.ifSpeed;
  1657.             pm2DrvCntr->ifInOctets = mib2Tbl.ifInOctets;
  1658.             pm2DrvCntr->ifInNUcastPkts = mib2Tbl.ifInNUcastPkts;
  1659.             pm2DrvCntr->ifInDiscards = mib2Tbl.ifInDiscards;
  1660.             pm2DrvCntr->ifInUnknownProtos = mib2Tbl.ifInUnknownProtos;
  1661.             pm2DrvCntr->ifOutOctets = mib2Tbl.ifOutOctets;
  1662.             pm2DrvCntr->ifOutNUcastPkts = mib2Tbl.ifOutNUcastPkts;
  1663.             pm2DrvCntr->ifOutDiscards = mib2Tbl.ifOutDiscards;
  1664.             break;
  1666.         case SIOCGMIB2233:
  1667.             error = muxIoctl (pDrvCtrl->pIpCookie, EIOCGMIB2233, data);
  1668.             if (error != OK)
  1669.                 return (EINVAL);
  1670.             break;
  1672.         case SIOCSMIB2233:
  1673.             error = muxIoctl (pDrvCtrl->pIpCookie, EIOCSMIB2233, data);
  1674.             if (error != OK)
  1675.                 return (EINVAL);
  1676.             break;
  1677.             
  1678.         case SIOCADDMULTI:
  1679.             /* Don't allow group membership on non-multicast
  1680.                interfaces. */
  1681.             if ((ifp->ac_if.if_flags & IFF_MULTICAST) == 0)
  1682.                 return EOPNOTSUPP;
  1683.             
  1684.             if (ifp->ac_if.if_resolve)
  1685.                 {
  1686.                 pDrvCtrl = (IP_DRV_CTRL*)ifp->ac_if.pCookie;
  1687.                 ifr = (struct ifreq *)data;
  1688.                 inetaddr = &ifr->ifr_addr;
  1690.                 pMblk = KHEAP_ALLOC(sizeof(M_BLK));
  1691.                 if (pMblk == NULL)
  1692.                     {
  1693.                     error = ENOBUFS;
  1694.                     break;
  1695.                     }
  1696.                 bzero ( (char *)pMblk, sizeof (M_BLK));
  1698.                 pMblk->mBlkHdr.mFlags |= M_MCAST;
  1700.                 /*
  1701.                  * call the registered address resolution function
  1702.                  * to do the mapping
  1703.                  */
  1705.                 if (ifp->ac_if.if_resolve (&ipMcastResume, pMblk, inetaddr,
  1706.                                            &ifp->ac_if, SIOCADDMULTI, &mapMCastBuff) == 0)
  1707.     {
  1708.     KHEAP_FREE( (char *)pMblk);
  1709.     break; /* not yet resolved */
  1710.     }
  1711.                 KHEAP_FREE( (char *)pMblk);
  1713.                 /* register the mapped multicast MAC address */
  1715.                 error = muxMCastAddrAdd (pDrvCtrl->pIpCookie,
  1716.                                          (char *)&mapMCastBuff);
  1717.                 }
  1718.             break;           /* if no resolve function, return OK */
  1720.         case SIOCDELMULTI:
  1721.             /* Don't allow group membership on non-multicast interfaces. */
  1722.             if ((ifp->ac_if.if_flags & IFF_MULTICAST) == 0)
  1723.                 return EOPNOTSUPP;
  1724.             
  1725.             if (ifp->ac_if.if_resolve)
  1726.                 {
  1727.                 pDrvCtrl = ifp->ac_if.pCookie;
  1728.                 ifr = (struct ifreq *)data;
  1729.                 inetaddr = (&ifr->ifr_addr);
  1730.                 
  1731.                 pMblk = KHEAP_ALLOC(sizeof (M_BLK));
  1732.                 if (pMblk == NULL)
  1733.                     {
  1734.                     error = ENOBUFS;
  1735.                     break;
  1736.                     }
  1737.                 bzero ( (char *)pMblk, sizeof (M_BLK));
  1739.                 pMblk->mBlkHdr.mFlags |= M_MCAST;
  1741.                 /*
  1742.                  * call the registered address resolution function to do
  1743.                  * the mapping
  1744.                  */
  1745.                 
  1746.                 if (ifp->ac_if.if_resolve (&ipMcastResume, pMblk, inetaddr,
  1747.                                      &ifp->ac_if, SIOCDELMULTI, &mapMCastBuff) == 0)
  1748.     {
  1749.     KHEAP_FREE( (char *)pMblk);
  1750.     break; /* not yet resolved */
  1751.     }
  1752. KHEAP_FREE( (char *)pMblk);
  1753.                 
  1754. /* delete the mapped multicast MAC address */
  1755.                 
  1756. error = muxMCastAddrDel (pDrvCtrl->pIpCookie,
  1757.                                          (char *)&mapMCastBuff);
  1758. }
  1759.             break;            /* if no resolve routine, return OK */
  1760.             
  1761. case SIOCGETMULTI:
  1762.     break;
  1763.             
  1764. case SIOCSIFFLAGS:
  1765.     ifr = (struct ifreq *) data;
  1766.     
  1767.     /* 
  1768.      * Turn off all flags that are disabled in the request 
  1769.      * correcting for the conversion from short to long 
  1770.      */
  1771.     
  1772.     flagsMask = (unsigned short) (~ ifr->ifr_flags);
  1774.     /* Two's complement used to disable flags by muxIoctl () */
  1775.     
  1776.     flagsMask = -flagsMask - 1;
  1777.     error = muxIoctl (pDrvCtrl->pIpCookie, EIOCSFLAGS,
  1778.                               (caddr_t) flagsMask);
  1780.     /* 
  1781.      * Next set all flags that are set in request correcting for 
  1782.      * the conversion from short to long. 
  1783.      */
  1785.     flagsMask = (unsigned short) ifr->ifr_flags;
  1787.     error |= muxIoctl (pDrvCtrl->pIpCookie, EIOCSFLAGS,
  1788.                                (caddr_t) flagsMask);
  1789.     break;
  1791.         case SIOCGMCASTLIST:
  1792.             error = muxIoctl (pDrvCtrl->pIpCookie, EIOCGMCASTLIST, data);
  1793.             if (error != OK)
  1794.                 return (EINVAL);
  1795.             break;
  1797. default:
  1798.     error = muxIoctl (pDrvCtrl->pIpCookie, cmd, data);
  1799.     break;
  1800. }
  1802.     return (error);
  1803.     }
  1805. /******************************************************************************
  1806. *
  1807. * ipOutput - transmit routine for IP packets using END or NPT devices.
  1808. *
  1809. * This routine handles the final processing before transferring a
  1810. * network packet (contained in the <m0> argument) to the transmit
  1811. * device.
  1812. *
  1813. * For END devices, it encapsulates a packet in the link-level frame
  1814. * before transferring it to the driver. The output processing constructs
  1815. * Ethernet frames unless the device provides a custom routine to form the
  1816. * appropriate frame header.
  1817. *
  1818. * For NPT devices, the routine just inserts the destination link-level
  1819. * address at the front of the mBlk chain. Later processing hands that
  1820. * address to the driver along with an mBlk chain containing the network
  1821. * packet (with no link-level header).
  1822. *
  1823. * NOTE: It assumes that ifp is actually a pointer to an arpcom structure.
  1824. *
  1825. * NOMANUAL
  1826. */
  1828. int ipOutput
  1829.     (
  1830.     register struct ifnet *ifp,
  1831.     struct mbuf *m0,
  1832.     struct sockaddr *dst,
  1833.     struct rtentry *rt0
  1834.     )
  1835.     {
  1836.     u_short etype = 0;
  1837.     int s, error = 0;
  1838.     register struct mbuf *m = m0;
  1839.     register struct rtentry *rt;
  1840.     int off;
  1841.     struct arpcom *ac = (struct arpcom *)ifp;
  1842.     struct ether_header* eh;
  1843.     IP_DRV_CTRL* pDrvCtrl;
  1845. #ifdef ROUTER_STACK
  1846.     struct ip* pIpHdr;
  1847.     END_OBJ* pEnd;
  1848.     struct sockaddr_in* pNetMask;
  1849. #endif  /* ROUTER_STACK */
  1850.  
  1851.     pDrvCtrl = (IP_DRV_CTRL *)ifp->pCookie;
  1852.     if (pDrvCtrl->pIpCookie == NULL)
  1853.         senderr (EINVAL);
  1855.     if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
  1856.         {
  1857. #ifdef WV_INSTRUMENTATION
  1858. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1859.         WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 2, 3, 
  1860.                         WV_NETEVENT_ETHEROUT_IFDOWN, WV_NET_SEND, ifp)
  1861. #endif  /* INCLUDE_WVNET */
  1862. #endif
  1864.         senderr(ENETDOWN);
  1865.         }
  1867.     ifp->if_lastchange = tickGet();
  1868.     if ((rt = rt0))
  1869.         {
  1870.         if ((rt->rt_flags & RTF_UP) == 0)
  1871.             {
  1872.             if ((rt0 = rt = rtalloc1(dst, 1)))
  1873.                 rt->rt_refcnt--;
  1874.             else
  1875.                 {
  1876. #ifdef WV_INSTRUMENTATION
  1877. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1878.                 WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 4, 5, 
  1879.                                 WV_NETEVENT_ETHEROUT_NOROUTE, WV_NET_SEND,
  1880.                                 ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  1881. #endif  /* INCLUDE_WVNET */
  1882. #endif
  1884.                 senderr(EHOSTUNREACH);
  1885.                 }
  1886.             }
  1887.         if (rt->rt_flags & RTF_GATEWAY)
  1888.             {
  1889.             if (rt->rt_gwroute == 0)
  1890.                 goto lookup;
  1891.             if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0)
  1892.                 {
  1893.                 rtfree(rt); rt = rt0;
  1894.                 lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1);
  1895.                 if ((rt = rt->rt_gwroute) == 0)
  1896.                     {
  1897. #ifdef WV_INSTRUMENTATION
  1898. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1899.                     WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 4, 5, 
  1900.                                     WV_NETEVENT_ETHEROUT_NOROUTE, WV_NET_SEND,
  1901.                      ((struct sockaddr_in *)rt->rt_gateway)->sin_addr.s_addr)
  1902. #endif  /* INCLUDE_WVNET */
  1903. #endif
  1905.                     senderr(EHOSTUNREACH);
  1906.                     }
  1907.                 }
  1908.             }
  1909.         if (rt->rt_flags & RTF_REJECT)
  1910.             {
  1911.             if (rt->rt_rmx.rmx_expire == 0 ||
  1912.                 tickGet() < rt->rt_rmx.rmx_expire)
  1913.                 {
  1914. #ifdef WV_INSTRUMENTATION
  1915. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  1916.                 WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_CRITICAL, 5, 6, 
  1917.                                 WV_NETEVENT_ETHEROUT_RTREJECT, WV_NET_SEND)
  1918. #endif  /* INCLUDE_WVNET */
  1919. #endif
  1921.                 senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
  1922.                 }
  1923.             }
  1924.         } /* if (rt = rt0) */
  1926.     switch (dst->sa_family)
  1927.         {
  1928.         case AF_INET:
  1929.             if (ifp->if_resolve != NULL)
  1930.                 if (!ifp->if_resolve (&ipOutputResume, m, dst, ifp, rt,
  1931.                                       pDrvCtrl->pDstAddr))
  1932.                     return (0); /* if not yet resolved */
  1934. #ifdef ROUTER_STACK
  1935.             if ((m->m_flags & M_FORWARD)) 
  1936.                 {
  1938.                 /*
  1939.                  * If we are forwarding this packet, and Fastpath is
  1940.                  * enabled both at the module and interface level,
  1941.                  * supply the Fastpath module with the additional
  1942.                  * forwarding information (the MAC address etc.)
  1943.                  */
  1945.                 if (SHOULD_MAKE_CALLS_TO_FF (GET_IPV4_FF_ID) && 
  1946.                     FF_MOD_ENABLED (GET_IPV4_FF_ID) &&
  1947.                     FF_INTF_ENABLED (GET_IPV4_FF_ID, ifp))
  1948.                     {
  1949.                     pEnd = PCOOKIE_TO_ENDOBJ(pDrvCtrl->pIpCookie);
  1950.                     pIpHdr= mtod(m, struct ip *);
  1951.                     pNetMask=(struct sockaddr_in*)(rt_mask(rt0));
  1953. #ifdef DEBUG
  1954.                     logMsg ("ipOutput: dst IP addr %xn", pIpHdr->ip_dst.s_addr,
  1955.                             0, 0, 0, 0, 0);
  1956.                     logMsg ("ipOutput: rt0 is %x. rt is %x.n", rt0, rt,
  1957.                             0, 0, 0, 0);
  1958. #endif /* DEBUG */
  1960.                     /*
  1961.                      * if indirect route pass the 'key' of the
  1962.                      * routing entry as the destination IP address.
  1963.                      * If not pass the host
  1964.                      * IP address as the destination IP address.
  1965.                      */
  1967.                     if (rt0->rt_flags & RTF_GATEWAY)
  1968.                         {
  1969.                         if (rt0->rt_flags & RTF_CLONED) 
  1970.                             rt0 = rt0->rt_parent;
  1971.                         if (rt0) 
  1972.                             FFL_CALL (ffLibRouteMoreInfo, 
  1973.                                       (GET_IPV4_FF_ID, rt_key(rt0), 
  1974.                                        rt_mask(rt0), rt0->rt_gateway, 
  1975.                                        pDrvCtrl->pDstAddr, ifp->if_addrlen, 
  1976.                                        rt0->rt_flags, ifp->if_mtu, 
  1977.                                        ifp->if_index, ifp));
  1978.                         }
  1979.                     else 
  1980.                         {
  1981.                         FFL_CALL (ffLibRouteMoreInfo, 
  1982.                                   (GET_IPV4_FF_ID, dst, 
  1983.                                    0, dst, 
  1984.                                    pDrvCtrl->pDstAddr, ifp->if_addrlen, 
  1985.                                    rt0->rt_flags, ifp->if_mtu, 
  1986.                                    ifp->if_index, ifp));
  1987.                         }
  1988.                     }
  1989.                 }
  1990. #endif /* ROUTER_STACK */
  1992.             /* If broadcasting on a simplex interface, loopback a copy */
  1994.             if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
  1995. !(m->m_flags & M_PROXY))
  1996.                 ip_mloopback (ifp, m, (struct sockaddr_in *)dst,
  1997.                               (struct rtentry*)rt);
  1999.             off = m->m_pkthdr.len - m->m_len;
  2000.             etype = ETHERTYPE_IP;
  2001.             break;
  2002.         case AF_UNSPEC:
  2003.             /*
  2004.              * WARNING: At the moment this code ONLY handles 14 byte
  2005.              * headers of the type like Ethernet.
  2006.              */
  2008.             switch (ifp->if_type)
  2009.                 {
  2010.                 case M2_ifType_ethernet_csmacd:
  2011.                 case M2_ifType_iso88023_csmacd:
  2012.                 case M2_ifType_iso88024_tokenBus:
  2013.                 case M2_ifType_iso88025_tokenRing:
  2014.                 case M2_ifType_iso88026_man:
  2015.                 case M2_ifType_fddi:
  2017.                     eh = (struct ether_header *)dst->sa_data;
  2018.     bcopy((caddr_t)eh->ether_dhost, 
  2019.           (caddr_t)pDrvCtrl->pDstAddr, ifp->if_addrlen);
  2020.                     etype = eh->ether_type;
  2021.                     break;
  2023.                 default:
  2024.                     error=ERROR;
  2025. }
  2026.              
  2027.              if(!error)
  2028.                  break;
  2029.              /* fall-through */
  2031.         default:
  2032.             logMsg ("%s%d: can't handle af%dn", (int)ifp->if_name,
  2033.                     ifp->if_unit, dst->sa_family, 0, 0, 0);
  2034. #ifdef WV_INSTRUMENTATION
  2035. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  2036.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_ERROR, 3, 7, 
  2037.                             WV_NETEVENT_ETHEROUT_AFNOTSUPP, WV_NET_SEND,
  2038.                             dst->sa_family)
  2039. #endif  /* INCLUDE_WVNET */
  2040. #endif
  2042.             senderr(EAFNOSUPPORT);
  2043.         }
  2044.     
  2045.     etype = htons(etype);
  2047.     if (pDrvCtrl->nptFlag)
  2048.         {
  2049.         /*
  2050.          * For NPT devices, insert the destination address (if any) and
  2051.          * network protocol type at the beginning of the network packet
  2052.          * for later use.
  2053.          */
  2055.         if (ifp->if_addrlen)
  2056.             {
  2057.             M_PREPEND(m, ifp->if_addrlen, M_DONTWAIT);
  2059.             if (m == NULL)
  2060.                 {
  2061.                 senderr(ENOBUFS);
  2062.                 }
  2064.             ((M_BLK_ID)m)->mBlkPktHdr.rcvif = 0;
  2066.             /* Store the destination address. */
  2068.             bcopy (pDrvCtrl->pDstAddr, m->m_data, ifp->if_addrlen);
  2069.             }
  2070.     
  2071.         /* Save the network protocol type. */
  2073.         ((M_BLK_ID)m)->mBlkHdr.reserved = etype;
  2074.         }
  2075.     else
  2076.         {
  2077.         /*
  2078.          * For END devices, build and prepend the complete frame instead.
  2079.          * NOTE: currently, the ac_enaddr field is only valid for specific
  2080.          * device types. (See the ipAttach routine).
  2081.          */
  2083.         pDrvCtrl->pSrc->m_data = (char *)&ac->ac_enaddr;
  2084.         pDrvCtrl->pDst->mBlkHdr.reserved = etype;
  2085.         pDrvCtrl->pSrc->mBlkHdr.reserved = etype;
  2087.         m = muxAddressForm (pDrvCtrl->pIpCookie, m,
  2088.                             pDrvCtrl->pSrc, pDrvCtrl->pDst);
  2089.         if (m == NULL)
  2090.             {
  2091. #ifdef WV_INSTRUMENTATION
  2092. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  2093.             WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 3, 4, 
  2094.                             WV_NETEVENT_ETHEROUT_NOBUFS, WV_NET_SEND, ifp)
  2095. #endif  /* INCLUDE_WVNET */
  2096. #endif
  2097.             senderr(ENOBUFS);
  2098.             }
  2099.         }
  2101.     s = splimp();
  2103.     /*
  2104.      * Queue message on interface, and start output if interface
  2105.      * not yet active.
  2106.      */
  2108.     if (IF_QFULL(&ifp->if_snd))
  2109.         {
  2110.         IF_DROP(&ifp->if_snd);
  2111.         splx(s);
  2112. #ifdef WV_INSTRUMENTATION
  2113. #ifdef INCLUDE_WVNET    /* WV_NET_CRITICAL event */
  2114.         WV_NET_EVENT_1 (NET_CORE_EVENT, WV_NET_CRITICAL, 3, 4, 
  2115.                         WV_NETEVENT_ETHEROUT_NOBUFS, WV_NET_SEND, ifp)
  2116. #endif  /* INCLUDE_WVNET */
  2117. #endif
  2119.         senderr(ENOBUFS);
  2120.         }
  2121.     IF_ENQUEUE(&ifp->if_snd, m);
  2123.     (*ifp->if_start)(ifp);
  2125.     splx(s);
  2126.     ifp->if_obytes += m->mBlkHdr.mLen;
  2127.     if (m->m_flags & M_MCAST || m->m_flags & M_BCAST)
  2128.         ifp->if_omcasts++;
  2130. #ifdef WV_INSTRUMENTATION
  2131. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  2132.     WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_NOTICE, 3, 12, 
  2133.                     WV_NETEVENT_ETHEROUT_FINISH, WV_NET_SEND, ifp, error)
  2134. #endif  /* INCLUDE_WVNET */
  2135. #endif
  2137.     return (error);
  2138.     
  2139.     bad:
  2140.     if (m)
  2141.         netMblkClChainFree(m);
  2142.     return (error);
  2144.     }
  2146. /*******************************************************************************
  2147. *
  2148. * ipOutputResume - transmit routine called after delayed address resolution
  2149. *
  2150. * When sending an IP packet, all address resolution functions responsible
  2151. * for converting an IP address to a link-layer address receive a pointer to
  2152. * this routine as their first argument. If a resolution routine is unable to
  2153. * supply the required link-level address immediately from a cache, it may 
  2154. * calls this routine after finishing the necessary network transactions (such
  2155. * as an ARP request and reply) to resume the transmit process.
  2156. *
  2157. * RETURNS: results of ipOutput() routine.
  2158. *
  2159. * INTERNAL
  2160. * This callback routine is actually never used. The ipOutput() routine is
  2161. * already capable of resuming the transmit process. The arpresolve() routine
  2162. * (which is the default resolution routine for this library) calls ipOutput
  2163. * directly. This callback routine is only included to comply with the existing
  2164. * NPT interface. The prototype for resolution routines should be changed to
  2165. * eliminate the callback method.
  2166. *
  2167. * NOMANUAL
  2168. */
  2170. int ipOutputResume
  2171.      (
  2172.      struct mbuf* pMBuf,
  2173.      struct sockaddr* ipDstAddr,
  2174.      void* ifp,
  2175.      void* rt
  2176.      )
  2177.      {
  2178.      return (
  2179.          ipOutput ( (struct ifnet*)ifp,
  2180.                    pMBuf, ipDstAddr, (struct rtentry*)rt)
  2181.             );
  2182.      }
  2183.  
  2184. /*******************************************************************************
  2185. *
  2186. * ipMcastResume - internal routine called after delayed mcast address mapping
  2187. *
  2188. * All IP multicast addresses also correspond to a particular link-level
  2189. * address.  The registered address resolution routine is responsible for
  2190. * performing that mapping.
  2191. *
  2192. * All address resolution routines receive a pointer to this routine as their
  2193. * first argument when determining a link-level multicast address. If the
  2194. * resolution routine is unable to determine the link-level address immediately,
  2195. * it calls this routine once the address is available.
  2196. *
  2197. * INTERNAL
  2198. * This callback routine is actually never used, which is fortunate since the
  2199. * <rt> parameter is not valid for the ipIoctl routine it executes.
  2200. * 
  2201. * The multicast conversions for Ethernet addresses are statically mapped, so
  2202. * they are always available immediately and the arpresolve() routine (which
  2203. * is the default resolution routine for this library) does not require the
  2204. * callback argument. This callback routine is only included to comply with
  2205. * the existing NPT interface. The prototype for resolution routines should
  2206. * be changed to eliminate the callback method.
  2207. *
  2208. * RETURNS: results of ipIoctl routine
  2209. *
  2210. * NOMANUAL
  2211. */
  2213. LOCAL int ipMcastResume
  2214.     (
  2215.     struct mbuf* pMbuf,
  2216.     struct sockaddr* ipDstAddr,
  2217.     void* pIfp,
  2218.     void* rt
  2219.     )
  2220.     {
  2221.     struct ifreq ifr;
  2223.     bcopy(ipDstAddr->sa_data, ifr.ifr_addr.sa_data, ipDstAddr->sa_len);
  2224.     ifr.ifr_addr.sa_family=ipDstAddr->sa_family;
  2226.     return(ipIoctl ((IDR *) pIfp, (int) rt, (caddr_t) &ifr));
  2227.     }
  2229. /****************************************************************************
  2230. *
  2231. * ipMuxCookieGet - Given an interface index returns the MUX cookie
  2232. *
  2233. * This routine returns the MUX cookie associated with an interface described
  2234. * by the <ifIndex> parameter. <ifIndex> is the interface index.
  2235. * This routine is called by the Fastpath module to retrieve the MUX cookie
  2236. * needed for sending packets out if Fastpath is done in software.
  2237. *
  2238. * <ifIndex> specifies the interface index whose MUX cookie is being
  2239. * retrieved.
  2240. *
  2241. * RETURNS: The MUX cookie if the interface exists and is bound; NULL otherwise
  2242. *
  2243. * NOMANUAL
  2244. */
  2246. void * ipMuxCookieGet 
  2247.     (
  2248.     unsigned short  ifIndex /* Interface index whose MUX cookie */
  2249.      /* is being retrieved */
  2250.     )
  2251.     {
  2252.     FAST struct ifnet * ifp;
  2254.     if ((ifp = ifIndexToIfp (ifIndex)) == NULL)
  2255.         return (NULL);
  2256.     return (((IP_DRV_CTRL *)ifp->pCookie)->pIpCookie);
  2257.     }