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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
netBufLib.h
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：19k
源码类别：

VxWorks

开发平台：

C/C++

netBufLib.h：源码内容
  1. /* netBufLib.h - network buffers header header file */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01o,05jun02,vvv  added M_EOB flag (SPR #72213)
  9. 01n,26mar02,vvv  added M_PROXY flag (SPR #74518)
  10. 01m,10oct01,rae  merge from truestack ver 01q base 01l
  11. 01l,24mar99,ann  protected some #defines by #ifndefs due to conflicts
  12.                  in project facility (all the ones defined in 00network.cdf)
  13. 01k,16mar99,spm  recovered orphaned code from tor1_0_1.sens1_1 (SPR #25770)
  14. 01j,08oct98,gnn  updated system network buffer allocations
  15. 01i,11dec97,vin  added prototype for netMblkOffsetToBufCopy part of SPR 9563.
  16. 01h,08dec97,vin  added prototype for netMblkChainDup SPR 9966.
  17. 01g,03dec97,vin  added prototype for netTupleGet(), added NUM_SYS_xxx defines
  18. 01f,13nov97,vin  added error codes and cleanup.
  19. 01e,08oct97,vin  corrected clBlkFree()
  20. 01d,30sep96,vin  added M_BLK_SZ.
  21. 01c,26sep97,vin  added NUM_XXX_MIN macros for bootroms.
  22. 01b,19sep97,vin  added cluster Blk typedef, optimized mBlk structure.
  23.  moved mExt structure out of the mBlk structure.
  24. 01a,08aug97,vin  written.
  25. */
  27. #ifndef __INCnetBufLibh
  28. #define __INCnetBufLibh
  30. #ifdef __cplusplus
  31. extern "C" {
  32. #endif
  34. #if CPU_FAMILY==I960
  35. #pragma align 1 /* tell gcc960 not to optimize alignments */
  36. #endif /* CPU_FAMILY==I960 */
  38. /* status codes */
  40. #define S_netBufLib_MEMSIZE_INVALID (M_netBufLib | 1)
  41. #define S_netBufLib_CLSIZE_INVALID (M_netBufLib | 2)
  42. #define S_netBufLib_NO_SYSTEM_MEMORY (M_netBufLib | 3)
  43. #define S_netBufLib_MEM_UNALIGNED (M_netBufLib | 4)
  44. #define S_netBufLib_MEMSIZE_UNALIGNED (M_netBufLib | 5)
  45. #define S_netBufLib_MEMAREA_INVALID (M_netBufLib | 6)
  46. #define S_netBufLib_MBLK_INVALID (M_netBufLib | 7)
  47. #define S_netBufLib_NETPOOL_INVALID (M_netBufLib | 8)
  48. #define S_netBufLib_INVALID_ARGUMENT (M_netBufLib | 9)
  49. #define S_netBufLib_NO_POOL_MEMORY (M_netBufLib | 10)
  51. #ifndef NUM_NET_MBLKS
  52. #define NUM_NET_MBLKS 400 /* no. mBlks to initialize */
  53. #endif  /* NUM_NET_MBLKS */
  55. #define MAX_MBLK_TYPES 256 /* max number of mBlk types */
  57. /* data clusters used by the network stack */
  59. #ifndef NUM_64
  60. #define NUM_64 100 /* no. 64 byte clusters */
  61. #endif  /* NUM_64 */
  63. #ifndef NUM_128
  64. #define NUM_128 100 /* no. 128 byte clusters */
  65. #endif  /* NUM_128 */
  67. #ifndef NUM_256
  68. #define NUM_256 40 /* no. 256 byte clusters */
  69. #endif  /* NUM_256 */
  71. #ifndef NUM_512
  72. #define NUM_512 40 /* no. 512 byte clusters */
  73. #endif  /* NUM_512 */
  75. #ifndef NUM_1024
  76. #define NUM_1024 25 /* no. 1024 byte clusters */
  77. #endif  /* NUM_1024 */
  79. #ifndef NUM_2048
  80. #define NUM_2048 25 /* no. 2048 byte clusters */
  81. #endif  /* NUM_2048 */
  83. #ifndef NUM_CL_BLKS
  84. #define NUM_CL_BLKS (NUM_64 + NUM_128 + NUM_256 +      
  85.  NUM_512 + NUM_1024 + NUM_2048)
  86. #endif  /* NUM_CL_BLKS */
  88. /* data clusters for a minimal configuration */
  90. #define NUM_NET_MBLKS_MIN 200 /* no. mBlks to initialize */
  92. #define NUM_64_MIN 50 /* no. 64 byte clusters */
  93. #define NUM_128_MIN 50 /* no. 128 byte clusters */
  94. #define NUM_256_MIN 10 /* no. 256 byte clusters */
  95. #define NUM_512_MIN 10 /* no. 512 byte clusters */
  96. #define NUM_1024_MIN 20 /* no. 1024 byte clusters */
  98. #define NUM_CL_BLKS_MIN (NUM_64_MIN + NUM_128_MIN + 
  99.  NUM_256_MIN + NUM_512_MIN + 
  100.                                          NUM_1024_MIN)
  102. /* system clusters for routes, interface addresses, pcbs, sockets, etc. */
  103. /* This is 61440 bytes and should allow us to open the default number */
  104. /* of sockets which is 50 (NUM_FILES) */
  105.  
  106. #ifndef NUM_SYS_64
  107. #define NUM_SYS_64 64 /*  64 byte system clusters */
  108. #endif /* NUM_SYS_64 */
  110. #ifndef NUM_SYS_128
  111. #define NUM_SYS_128 64 /* 128 byte system clusters */
  112. #endif /* NUM_SYS_128 */
  114. #ifndef NUM_SYS_256
  115. #define NUM_SYS_256 64 /* 256 byte system clusters */
  116. #endif  /* NUM_SYS_256 */
  118. #ifndef NUM_SYS_512
  119. #define NUM_SYS_512 64 /* 512 byte system clusters */
  120. #endif  /* NUM_SYS_512 */
  122. #ifndef NUM_SYS_CL_BLKS
  123. #define NUM_SYS_CL_BLKS (NUM_SYS_64  + NUM_SYS_128 + 
  124.  NUM_SYS_256 + NUM_SYS_512)
  125. #endif  /* NUM_SYS_CL_BLKS */
  127. #ifndef NUM_SYS_MBLKS
  128. #define NUM_SYS_MBLKS (2 * NUM_SYS_CL_BLKS)
  129. #endif  /* NUM_SYS_MBLKS */
  131. /* system clusters for a minimal configuration */
  133. #define NUM_SYS_64_MIN 20 /*  64 byte system clusters */
  134. #define NUM_SYS_128_MIN 15 /* 128 byte system clusters */
  135. #define NUM_SYS_256_MIN 15 /* 256 byte system clusters */
  136. #define NUM_SYS_512_MIN 10 /* 512 byte system clusters */
  138. #define NUM_SYS_CL_BLKS_MIN (NUM_SYS_64_MIN  + NUM_SYS_128_MIN + 
  139.  NUM_SYS_256_MIN + NUM_SYS_512_MIN)
  141. #define NUM_SYS_MBLKS_MIN NUM_SYS_CL_BLKS_MIN
  143. /* cluster defines */
  145. #define CL_LOG2_64 6
  146. #define CL_LOG2_128 7
  147. #define CL_LOG2_256 8
  148. #define CL_LOG2_512 9
  149. #define CL_LOG2_1024 10
  150. #define CL_LOG2_2048 11
  151. #define CL_LOG2_4096   12
  152. #define CL_LOG2_8192  13
  153. #define CL_LOG2_16384 14
  154. #define CL_LOG2_32768 15
  155. #define CL_LOG2_65536 16
  157. #define CL_SIZE_64 64
  158. #define CL_SIZE_128 128
  159. #define CL_SIZE_256 256
  160. #define CL_SIZE_512 512
  161. #define CL_SIZE_1024 1024
  162. #define CL_SIZE_2048 2048
  163. #define CL_SIZE_4096 4096
  164. #define CL_SIZE_8192 8192
  165. #define CL_SIZE_16384 16384
  166. #define CL_SIZE_32768 32768
  167. #define CL_SIZE_65536 65536
  169. #define CL_LOG2_MIN CL_LOG2_64
  170. #define CL_LOG2_MAX CL_LOG2_65536
  171. #define CL_SIZE_MAX (1 << CL_LOG2_MAX)
  172. #define CL_SIZE_MIN (1 << CL_LOG2_MIN)
  173. #define CL_INDX_MIN 0
  174. #define CL_INDX_MAX (CL_LOG2_MAX - CL_LOG2_MIN)
  175. #define CL_TBL_SIZE (CL_INDX_MAX + 1)
  178. #define CL_LOG2_TO_CL_INDEX(x) ((x) - CL_LOG2_MIN)
  179. #define CL_LOG2_TO_CL_SIZE(x) (1 << (x))
  180. #define SIZE_TO_LOG2(size) (ffsMsb((size)) - 1)
  181. #define CL_SIZE_TO_CL_INDEX(clSize)  (ffsMsb((clSize)) - (1 + CL_LOG2_MIN))
  183. /* mBlk types */
  184. #define MT_FREE 0 /* should be on free list */
  185. #define MT_DATA 1 /* dynamic (data) allocation */
  186. #define MT_HEADER 2 /* packet header */
  187. #define MT_SOCKET 3 /* socket structure */
  188. #define MT_PCB 4 /* protocol control block */
  189. #define MT_RTABLE 5 /* routing tables */
  190. #define MT_HTABLE 6 /* IMP host tables */
  191. #define MT_ATABLE 7 /* address resolution tables */
  192. #define MT_SONAME 8 /* socket name */
  193. #define MT_ZOMBIE       9       /* zombie proc status */
  194. #define MT_SOOPTS 10 /* socket options */
  195. #define MT_FTABLE 11 /* fragment reassembly header */
  196. #define MT_RIGHTS 12 /* access rights */
  197. #define MT_IFADDR 13 /* interface address */
  198. #define MT_CONTROL 14 /* extra-data protocol message */
  199. #define MT_OOBDATA 15 /* expedited data  */
  200. #define MT_IPMOPTS 16 /* internet multicast options */
  201. #define MT_IPMADDR 17 /* internet multicast address */
  202. #define MT_IFMADDR 18 /* link-level multicast address */
  203. #define MT_MRTABLE 19 /* multicast routing tables */
  205. #define NUM_MBLK_TYPES 20 /* number of mBlk types defined */
  207. /* mBlk flags */
  209. #define M_EXT 0x01 /* has an associated cluster */
  210. #define M_PKTHDR 0x02 /* start of record */
  211. #define M_EOR 0x04 /* end of record */
  212. #define M_FORWARD       0x08    /* packet to be forwarded */
  214. /* mBlk pkthdr flags, also in mFlags */
  216. #define M_BCAST 0x10 /* send/received as link-level broadcast */
  217. #define M_MCAST 0x20 /* send/received as link-level multicast */
  218. #define M_PROXY         0x40    /* broadcast forwarded through proxy */
  219. #define M_SECURE_PKT    0x80   /* already gone through security check */ 
  221. /*
  222.  * M_EOB is set when the mblk contains the last part of a large block of
  223.  * data sent by an application using TCP (a large block of data is one
  224.  * which causes sosend to issue multiple protocol send requests).
  225.  * M_EOB and M_PROXY can be used together since M_EOB is only used above
  226.  * IP and M_PROXY is only used at IP level. It is important to clear the
  227.  * M_EOB flag before the packet is sent to IP for transmission.
  228.  */
  230. #define M_EOB           M_PROXY
  232. /* flags to mClGet/mBlkGet */
  234. #define M_DONTWAIT 1 /* dont wait if buffers not available */
  235. #define M_WAIT 0 /* wait if buffers not available */
  237. /* length to copy to copy all data from the mBlk chain*/
  239. #define M_COPYALL 1000000000
  241. /* check to see if an mBlk is associated with a cluster */
  243. #define M_HASCL(pMblk) ((pMblk)->mBlkHdr.mFlags & M_EXT)
  245. #define M_BLK_SZ sizeof(struct mBlk)  /* size of an mBlk */
  246. #define MSIZE M_BLK_SZ /* size of an mBlk */
  248. #define CL_BLK_SZ sizeof(struct clBlk) /* size of cluster block */
  250. /* macro to get to the net pool ptr from the mBlk */
  252. #define MBLK_TO_NET_POOL(pMblk) (*(NET_POOL_ID *)((int)pMblk - sizeof(int)))
  254. /* macro to get to the cluster pool ptr from the cluster buffer */
  256. #define CL_BUF_TO_CL_POOL(pClBuf) (*(CL_POOL_ID *)((int)pClBuf - sizeof(int)))
  258. /* macro to get to the cluster reference count from the cluster buffer */
  260. #define CL_BUF_TO_REFCNT(pClBuf)  (UCHAR *)((int)pClBuf - (2 * sizeof(int)))
  262. /* macros for accessing the functions of net pool directly */
  264. #define poolInit(poolId,pMclBlkConfig,pClDescTbl,tblNumEnt,fromKheap)
  265.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pInitRtn)) 
  266.                  ((poolId), (pMclBlkConfig), (pClDescTbl), (tblNumEnt), 
  267.   (fromKheap))
  268.     
  269. #define mBlkFree(poolId,pMblk)
  270.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pMblkFreeRtn)) 
  271.                  ((poolId), (pMblk))
  273. #define clFree(poolId,pClBuf)
  274.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pClFreeRtn)) 
  275.                  ((poolId), (pClBuf))
  277. #define clBlkFree(poolId,pClBlk)
  278.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pClBlkFreeRtn)) 
  279.                  ((pClBlk))
  280.                     
  281. #define mBlkClFree(poolId,pMblk)
  282.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pMblkClFreeRtn)) 
  283.                  ((poolId), (pMblk))
  285. #define mBlkGet(poolId,canWait,type)
  286.                  (*(((NET_POOL_ID)(poolId))->pFuncTbl->pMblkGetRtn)) 
  287.                  ((poolId), (canWait), (type))
  289. #define clBlkGet(poolId,canWait)
  290.                  (*(((NET_POOL_ID)(poolId))->pFuncTbl->pClBlkGetRtn)) 
  291.                  ((poolId), (canWait))
  292.                     
  293. #define clusterGet(poolId,pClPool)
  294.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pClGetRtn)) 
  295.                  ((poolId), (pClPool))
  296.                     
  297. #define mClGet(poolId,pMblk,bufSize,canWait,bestFit)
  298.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pMblkClGetRtn)) 
  299.                  ((poolId), (pMblk), (bufSize), (canWait), (bestFit))
  301. #define clPoolIdGet(poolId,bufSize,bestFit)
  302.      (*(((NET_POOL_ID)(poolId))->pFuncTbl->pClPoolIdGetRtn))
  303.                  ((poolId), (bufSize), (bestFit))
  305. /*
  306.  * This structure is used to configure the number of mBlks and cluster blocks
  307.  * that are allocated in a netpool. Each cluster has a corresponding cluster
  308.  * block which manages it. An mBlk manages a cluster block and the cluster.
  309.  * When a netpool is configured there should as many cluster blocks as the
  310.  * cumulative number of clusters. The defaults are defined above, but the
  311.  * structure is defined and fileed in usrConfig.c. For TCP applications it is
  312.  * good to have two mBlks for every cluster block.
  313.  */
  315. typedef struct
  316.     {
  317.     int mBlkNum; /* number of mBlks */
  318.     int clBlkNum; /* number of cluster Blocks */
  319.     char *  memArea; /* pre allocated memory area */
  320.     int memSize; /* pre allocated memory size */
  321.     } M_CL_CONFIG;
  323. /*
  324.  *  This structure defines the way the networking code utilizes clusters.
  325.  *  A table of type CL_DESC is filled in usrNetwork.c. 
  326.  *  Clusters are also used to hold network data structures other than the 
  327.  *  regular data. The network data structures are routing table entries,
  328.  *  interface address structures, multicast address structures etc.
  329.  */
  331. typedef struct clDesc
  332.     {
  333.     int clSize; /* cluster type */
  334.     int clNum; /* number of clusters */
  335.     char * memArea; /* pre allocated memory area */
  336.     int memSize; /* pre allocated memory size */
  337.     } CL_DESC; 
  339. /* this structure defines the cluster */
  341. typedef struct clBuff
  342.     {
  343.     struct clBuff * pClNext;  /* pointer to the next clBuff */
  344.     } CL_BUF;
  346. typedef CL_BUF * CL_BUF_ID; 
  348. /* this structure defines the each cluster pool */
  350. typedef struct clPool
  351.     {
  352.     int clSize; /* cluster size */
  353.     int clLg2; /* cluster log 2 size */
  354.     int clNum;  /* number of clusters */
  355.     int clNumFree;  /* number of clusters free */
  356.     int clUsage; /* number of times used */
  357.     CL_BUF_ID pClHead; /* pointer to the cluster head */
  358.     struct netPool * pNetPool; /* pointer to the netPool */
  359.     } CL_POOL; 
  361. typedef CL_POOL * CL_POOL_ID; 
  363. /* header at beginning of each mBlk */
  365. typedef struct mHdr
  366.     {
  367.     struct mBlk * mNext; /* next buffer in chain */
  368.     struct mBlk * mNextPkt; /* next chain in queue/record */
  369.     char * mData; /* location of data */
  370.     int mLen; /* amount of data in this mBlk */
  371.     UCHAR mType; /* type of data in this mBlk */
  372.     UCHAR mFlags; /* flags; see below */
  373.     USHORT reserved; 
  374.     } M_BLK_HDR;
  376. /* record/packet header in first mBlk of chain; valid if M_PKTHDR set */
  378. typedef struct pktHdr
  379.     {
  380.     struct ifnet * rcvif; /* rcv interface */
  381.     int len; /* total packet length */
  382.     } M_PKT_HDR;
  384. typedef union clBlkList
  385.     {
  386.     struct clBlk *  pClBlkNext; /* pointer to the next clBlk */
  387.     char *  pClBuf; /* pointer to the buffer */
  388.     } CL_BLK_LIST;
  389.     
  390. /* description of external storage mapped into mBlk, valid if M_EXT set */
  392. typedef struct clBlk
  393.     {
  394.     CL_BLK_LIST  clNode; /* union of next clBlk, buffer ptr */
  395.     UINT clSize; /* cluster size */
  396.     int clRefCnt; /* reference count of the cluster */
  397.     FUNCPTR pClFreeRtn; /* pointer to cluster free routine */
  398.     int clFreeArg1; /* free routine arg 1 */
  399.     int clFreeArg2; /* free routine arg 2 */
  400.     int clFreeArg3; /* free routine arg 3 */
  401.     struct netPool * pNetPool; /* pointer to the netPool */
  402.     } CL_BLK;
  404. /* mBlk structure */
  406. typedef struct mBlk
  407.     {
  408.     M_BLK_HDR  mBlkHdr;  /* header */
  409.     M_PKT_HDR mBlkPktHdr; /* pkthdr */
  410.     CL_BLK * pClBlk; /* pointer to cluster blk */
  411.     } M_BLK;
  413. /* mBlk statistics used to show data pool by show routines */
  415. typedef struct mbstat
  416.     {
  417.     ULONG mNum; /* mBlks obtained from page pool */
  418.     ULONG mDrops; /* times failed to find space */
  419.     ULONG mWait; /* times waited for space */
  420.     ULONG mDrain; /* times drained protocols for space */
  421.     ULONG mTypes[256]; /* type specific mBlk allocations */
  422.     } M_STAT;
  424. typedef M_BLK *  M_BLK_ID;
  425. typedef CL_BLK * CL_BLK_ID;
  426. typedef struct netPool  NET_POOL;
  427. typedef struct poolFunc POOL_FUNC;
  428. typedef NET_POOL *  NET_POOL_ID;
  430. struct poolFunc /* POOL_FUNC */
  431.     {
  432.     /* pointer to the pool initialization routine */
  433.     STATUS (*pInitRtn) (NET_POOL_ID pNetPool, M_CL_CONFIG * pMclBlkConfig,
  434.                              CL_DESC * pClDescTbl, int clDescTblNumEnt,
  435.      BOOL fromKheap);
  437.     /* pointer to mBlk free routine */
  438.     void (*pMblkFreeRtn) (NET_POOL_ID pNetPool, M_BLK_ID pMblk);
  440.     /* pointer to cluster Blk free routine */
  441.     void (*pClBlkFreeRtn) (CL_BLK_ID pClBlk);
  443.     /* pointer to cluster free routine */
  444.     void (*pClFreeRtn) (NET_POOL_ID pNetPool, char * pClBuf);
  446.     /* pointer to mBlk/cluster pair free routine */
  447.     M_BLK_ID  (*pMblkClFreeRtn) (NET_POOL_ID pNetPool, M_BLK_ID pMblk);
  449.     /* pointer to mBlk get routine */
  450.     M_BLK_ID (*pMblkGetRtn) (NET_POOL_ID pNetPool, int canWait, UCHAR type);
  452.     /* pointer to cluster Blk get routine */
  453.     CL_BLK_ID (*pClBlkGetRtn) (NET_POOL_ID pNetPool, int canWait);
  454.     
  455.     /* pointer to a cluster buffer get routine */
  456.     char * (*pClGetRtn) (NET_POOL_ID pNetPool, CL_POOL_ID pClPool);
  458.     /* pointer to mBlk/cluster pair get routine */
  459.     STATUS (*pMblkClGetRtn) (NET_POOL_ID pNetPool, M_BLK_ID pMblk,
  460.                                   int bufSize, int canWait, BOOL bestFit);
  462.     /* pointer to cluster pool Id get routine */
  463.     CL_POOL_ID (*pClPoolIdGetRtn) (NET_POOL_ID pNetPool, int bufSize,
  464.                                     BOOL bestFit);
  465.     };
  467. struct netPool /* NET_POOL */
  468.     {
  469.     M_BLK_ID pmBlkHead; /* head of mBlks */
  470.     CL_BLK_ID pClBlkHead; /* head of cluster Blocks */
  471.     int mBlkCnt; /* number of mblks */
  472.     int mBlkFree; /* number of free mblks */
  473.     int clMask; /* cluster availability mask */
  474.     int clLg2Max; /* cluster log2 maximum size */
  475.     int clSizeMax; /* maximum cluster size */
  476.     int clLg2Min; /* cluster log2 minimum size */
  477.     int clSizeMin; /* minimum cluster size */
  478.     CL_POOL *  clTbl [CL_TBL_SIZE]; /* pool table */
  479.     M_STAT * pPoolStat; /* pool statistics */
  480.     POOL_FUNC * pFuncTbl; /* ptr to function ptr table */
  481.     };
  483. /* external declarations */                    
  484.                     
  485. IMPORT STATUS  netBufLibInit (void);
  486. IMPORT STATUS  netPoolInit (NET_POOL_ID pNetPool,
  487.                                      M_CL_CONFIG * pMclBlkConfig,
  488.                                      CL_DESC * pClDescTbl, int clDescTblNumEnt,
  489.                                      POOL_FUNC * pFuncTbl);
  490. IMPORT STATUS netPoolDelete (NET_POOL_ID);
  491. IMPORT void netMblkFree (NET_POOL_ID pNetPool, M_BLK_ID pMblk);
  492. IMPORT void netClBlkFree (NET_POOL_ID pNetPool, CL_BLK_ID pClBlk);
  493. IMPORT void  netClFree (NET_POOL_ID pNetPool, UCHAR * pClBuf);
  494. IMPORT M_BLK_ID  netMblkClFree (M_BLK_ID pMblk);
  495. IMPORT void netMblkClChainFree (M_BLK_ID pMblk);
  496. IMPORT M_BLK_ID  netMblkGet (NET_POOL_ID pNetPool, int canWait,
  497.                                     UCHAR type);
  498. IMPORT CL_BLK_ID netClBlkGet (NET_POOL_ID pNetPool, int canWait);
  499. IMPORT char *   netClusterGet (NET_POOL_ID pNetPool,
  500.                                        CL_POOL_ID pClPool);
  501. IMPORT STATUS    netMblkClGet (NET_POOL_ID pNetPool, M_BLK_ID pMblk,
  502.                                       int bufSize, int canWait, BOOL bestFit);
  503. IMPORT M_BLK_ID  netTupleGet (NET_POOL_ID pNetPool, int bufSize,
  504.                                      int canWait, UCHAR type, BOOL bestFit);
  506. IMPORT M_BLK_ID  netTupleGet2 (NET_POOL_ID, int, int);
  508. IMPORT CL_BLK_ID   netClBlkJoin (CL_BLK_ID pClBlk, char * pClBuf,
  509.                                       int size, FUNCPTR pFreeRtn, int arg1,
  510.                                       int arg2, int arg3);
  511. IMPORT M_BLK_ID   netMblkClJoin (M_BLK_ID pMblk, CL_BLK_ID pClBlk);
  512. IMPORT CL_POOL_ID  netClPoolIdGet (NET_POOL_ID pNetPool, int bufSize,
  513.                                         BOOL bestFit);
  515. IMPORT int  netMblkToBufCopy (M_BLK_ID pMblk, char * pBuf,
  516.                                           FUNCPTR pCopyRtn);
  517. IMPORT int netMblkOffsetToBufCopy (M_BLK_ID pMblk, int offset,
  518.                                                 char * pBuf, int len,
  519.                                                 FUNCPTR pCopyRtn);
  520. IMPORT M_BLK_ID  netMblkDup (M_BLK_ID pSrcMblk, M_BLK_ID pDestMblk);
  521. IMPORT M_BLK_ID  netMblkChainDup (NET_POOL_ID pNetPool, M_BLK_ID pMblk,
  522.                                          int offset, int len, int canWait);
  524. #if CPU_FAMILY==I960
  525. #pragma align 0 /* turn off alignment requirement */
  526. #endif /* CPU_FAMILY==I960 */
  528. #ifdef __cplusplus
  529. }
  530. #endif
  532. #endif /* __INCnetBufLibh */