+/**\r
+ Create a child of the service that is identified by ServiceBindingGuid.\r
+\r
+ @param ControllerHandle The controller which has the service installed.\r
+ @param ImageHandle The image handle used to open service.\r
+ @param ServiceBindingGuid The service's Guid.\r
+ @param ChildHandle The handle to receive the create child\r
+\r
+ @retval EFI_SUCCESS The child is successfully created.\r
+ @retval Others Failed to create the child.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibCreateServiceChild (\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_GUID *ServiceBindingGuid,\r
+ OUT EFI_HANDLE *ChildHandle\r
+ );\r
+\r
+/**\r
+ Destory a child of the service that is identified by ServiceBindingGuid.\r
+\r
+ @param ControllerHandle The controller which has the service installed.\r
+ @param ImageHandle The image handle used to open service.\r
+ @param ServiceBindingGuid The service's Guid.\r
+ @param ChildHandle The child to destory\r
+\r
+ @retval EFI_SUCCESS The child is successfully destoried.\r
+ @retval Others Failed to destory the child.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibDestroyServiceChild (\r
+ IN EFI_HANDLE ControllerHandle,\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_GUID *ServiceBindingGuid,\r
+ IN EFI_HANDLE ChildHandle\r
+ );\r
+\r
+/**\r
+ Convert the mac address of the simple network protocol installed on\r
+ SnpHandle to a unicode string. Callers are responsible for freeing the\r
+ string storage.\r
+\r
+ @param SnpHandle The handle where the simple network protocol is\r
+ installed on.\r
+ @param ImageHandle The image handle used to act as the agent handle to\r
+ get the simple network protocol.\r
+ @param MacString The pointer to store the address of the string\r
+ representation of the mac address.\r
+\r
+ @retval EFI_OUT_OF_RESOURCES There are not enough memory resource.\r
+ @retval other Failed to open the simple network protocol.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibGetMacString (\r
+ IN EFI_HANDLE SnpHandle,\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN OUT CHAR16 **MacString\r
+ );\r
+\r
+/**\r
+ Create an IPv4 device path node.\r
+\r
+ @param Node Pointer to the IPv4 device path node.\r
+ @param Controller The handle where the NIC IP4 config protocol resides.\r
+ @param LocalIp The local IPv4 address.\r
+ @param LocalPort The local port.\r
+ @param RemoteIp The remote IPv4 address.\r
+ @param RemotePort The remote port.\r
+ @param Protocol The protocol type in the IP header.\r
+ @param UseDefaultAddress Whether this instance is using default address or not.\r
+\r
+ @retval None\r
+**/\r
+VOID\r
+EFIAPI\r
+NetLibCreateIPv4DPathNode (\r
+ IN OUT IPv4_DEVICE_PATH *Node,\r
+ IN EFI_HANDLE Controller,\r
+ IN IP4_ADDR LocalIp,\r
+ IN UINT16 LocalPort,\r
+ IN IP4_ADDR RemoteIp,\r
+ IN UINT16 RemotePort,\r
+ IN UINT16 Protocol,\r
+ IN BOOLEAN UseDefaultAddress\r
+ );\r
+\r
+/**\r
+ Find the UNDI/SNP handle from controller and protocol GUID.\r
+ For example, IP will open a MNP child to transmit/receive\r
+ packets, when MNP is stopped, IP should also be stopped. IP\r
+ needs to find its own private data which is related the IP's\r
+ service binding instance that is install on UNDI/SNP handle.\r
+ Now, the controller is either a MNP or ARP child handle. But\r
+ IP opens these handle BY_DRIVER, use that info, we can get the\r
+ UNDI/SNP handle.\r
+\r
+ @param Controller Then protocol handle to check\r
+ @param ProtocolGuid The protocol that is related with the handle.\r
+\r
+ @return The UNDI/SNP handle or NULL.\r
+\r
+**/\r
+EFI_HANDLE\r
+EFIAPI\r
+NetLibGetNicHandle (\r
+ IN EFI_HANDLE Controller,\r
+ IN EFI_GUID *ProtocolGuid\r
+ );\r
+\r
+/**\r
+ Add a Deferred Procedure Call to the end of the DPC queue.\r
+\r
+ @param DpcTpl The EFI_TPL that the DPC should be invoked.\r
+ @param DpcProcedure Pointer to the DPC's function.\r
+ @param DpcContext Pointer to the DPC's context. Passed to DpcProcedure\r
+ when DpcProcedure is invoked.\r
+\r
+ @retval EFI_SUCCESS The DPC was queued.\r
+ @retval EFI_INVALID_PARAMETER DpcTpl is not a valid EFI_TPL.\r
+ DpcProcedure is NULL.\r
+ @retval EFI_OUT_OF_RESOURCES There are not enough resources available to\r
+ add the DPC to the queue.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibQueueDpc (\r
+ IN EFI_TPL DpcTpl,\r
+ IN EFI_DPC_PROCEDURE DpcProcedure,\r
+ IN VOID *DpcContext OPTIONAL\r
+ );\r
+\r
+/**\r
+ Add a Deferred Procedure Call to the end of the DPC queue.\r
+\r
+ @retval EFI_SUCCESS One or more DPCs were invoked.\r
+ @retval EFI_NOT_FOUND No DPCs were invoked.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibDispatchDpc (\r
+ VOID\r
+ );\r
+\r
+/**\r
+ This is the default unload handle for all the network drivers.\r
+\r
+ @param ImageHandle The drivers' driver image.\r
+\r
+ @retval EFI_SUCCESS The image is unloaded.\r
+ @retval Others Failed to unload the image.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetLibDefaultUnload (\r
+ IN EFI_HANDLE ImageHandle\r
+ );\r
+\r
+typedef enum {\r
+ //\r
+ //Various signatures\r
+ //\r
+ NET_BUF_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),\r
+ NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),\r
+ NET_QUE_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),\r
+\r
+\r
+ NET_PROTO_DATA = 64, // Opaque buffer for protocols\r
+ NET_BUF_HEAD = 1, // Trim or allocate space from head\r
+ NET_BUF_TAIL = 0, // Trim or allocate space from tail\r
+ NET_VECTOR_OWN_FIRST = 0x01 // We allocated the 1st block in the vector\r
+} NET_SIGNATURE_TYPE;\r
+\r
+#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \\r
+ ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))\r
+\r
+#define NET_SWAP_SHORT(Value) \\r
+ ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff))\r
+\r
+//\r
+// Single memory block in the vector.\r
+//\r
+typedef struct {\r
+ UINT32 Len; // The block's length\r
+ UINT8 *Bulk; // The block's Data\r
+} NET_BLOCK;\r
+\r
+typedef VOID (*NET_VECTOR_EXT_FREE) (VOID *Arg);\r
+\r
+//\r
+//NET_VECTOR contains several blocks to hold all packet's\r
+//fragments and other house-keeping stuff for sharing. It\r
+//doesn't specify the where actual packet fragment begins.\r
+//\r
+typedef struct {\r
+ UINT32 Signature;\r
+ INTN RefCnt; // Reference count to share NET_VECTOR.\r
+ NET_VECTOR_EXT_FREE Free; // external function to free NET_VECTOR\r
+ VOID *Arg; // opeque argument to Free\r
+ UINT32 Flag; // Flags, NET_VECTOR_OWN_FIRST\r
+ UINT32 Len; // Total length of the assocated BLOCKs\r
+\r
+ UINT32 BlockNum;\r
+ NET_BLOCK Block[1];\r
+} NET_VECTOR;\r
+\r
+//\r
+//NET_BLOCK_OP operate on the NET_BLOCK, It specifies\r
+//where the actual fragment begins and where it ends\r
+//\r
+typedef struct {\r
+ UINT8 *BlockHead; // Block's head, or the smallest valid Head\r
+ UINT8 *BlockTail; // Block's tail. BlockTail-BlockHead=block length\r
+ UINT8 *Head; // 1st byte of the data in the block\r
+ UINT8 *Tail; // Tail of the data in the block, Tail-Head=Size\r
+ UINT32 Size; // The size of the data\r
+} NET_BLOCK_OP;\r
+\r
+\r
+//\r
+//NET_BUF is the buffer manage structure used by the\r
+//network stack. Every network packet may be fragmented,\r
+//and contains multiple fragments. The Vector points to\r
+//memory blocks used by the each fragment, and BlockOp\r
+//specifies where each fragment begins and ends.\r
+//\r
+//It also contains a opaque area for protocol to store\r
+//per-packet informations. Protocol must be caution not\r
+//to overwrite the members after that.\r
+//\r
+typedef struct {\r
+ UINT32 Signature;\r
+ INTN RefCnt;\r
+ LIST_ENTRY List; // The List this NET_BUF is on\r
+\r
+ IP4_HEAD *Ip; // Network layer header, for fast access\r
+ TCP_HEAD *Tcp; // Transport layer header, for fast access\r
+ UINT8 ProtoData [NET_PROTO_DATA]; //Protocol specific data\r
+\r
+ NET_VECTOR *Vector; // The vector containing the packet\r
+\r
+ UINT32 BlockOpNum; // Total number of BlockOp in the buffer\r
+ UINT32 TotalSize; // Total size of the actual packet\r
+ NET_BLOCK_OP BlockOp[1]; // Specify the position of actual packet\r
+} NET_BUF;\r
+\r
+\r
+//\r
+//A queue of NET_BUFs, It is just a thin extension of\r
+//NET_BUF functions.\r
+//\r
+typedef struct {\r
+ UINT32 Signature;\r
+ INTN RefCnt;\r
+ LIST_ENTRY List; // The List this buffer queue is on\r
+\r
+ LIST_ENTRY BufList; // list of queued buffers\r
+ UINT32 BufSize; // total length of DATA in the buffers\r
+ UINT32 BufNum; // total number of buffers on the chain\r
+} NET_BUF_QUEUE;\r
+\r
+//\r
+// Pseudo header for TCP and UDP checksum\r
+//\r
+#pragma pack(1)\r
+typedef struct {\r
+ IP4_ADDR SrcIp;\r
+ IP4_ADDR DstIp;\r
+ UINT8 Reserved;\r
+ UINT8 Protocol;\r
+ UINT16 Len;\r
+} NET_PSEUDO_HDR;\r
+#pragma pack()\r
+\r
+//\r
+// The fragment entry table used in network interfaces. This is\r
+// the same as NET_BLOCK now. Use two different to distinguish\r
+// the two in case that NET_BLOCK be enhanced later.\r
+//\r
+typedef struct {\r
+ UINT32 Len;\r
+ UINT8 *Bulk;\r
+} NET_FRAGMENT;\r
+\r
+#define NET_GET_REF(PData) ((PData)->RefCnt++)\r
+#define NET_PUT_REF(PData) ((PData)->RefCnt--)\r
+#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)\r
+\r
+#define NET_BUF_SHARED(Buf) \\r
+ (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1))\r
+\r
+#define NET_VECTOR_SIZE(BlockNum) \\r
+ (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))\r
+\r
+#define NET_BUF_SIZE(BlockOpNum) \\r
+ (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))\r
+\r
+#define NET_HEADSPACE(BlockOp) \\r
+ (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)\r
+\r
+#define NET_TAILSPACE(BlockOp) \\r
+ (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)\r
+\r
+/**\r
+ Allocate a single block NET_BUF. Upon allocation, all the\r
+ free space is in the tail room.\r
+\r
+ @param Len The length of the block.\r
+\r
+ @retval * Pointer to the allocated NET_BUF. If NULL the\r
+ allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufAlloc (\r
+ IN UINT32 Len\r
+ );\r
+\r
+/**\r
+ Free the buffer and its associated NET_VECTOR.\r
+\r
+ @param Nbuf Pointer to the NET_BUF to be freed.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufFree (\r
+ IN NET_BUF *Nbuf\r
+ );\r
+\r
+/**\r
+ Get the position of some byte in the net buffer. This can be used\r
+ to, for example, retrieve the IP header in the packet. It also\r
+ returns the fragment that contains the byte which is used mainly by\r
+ the buffer implementation itself.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+ @param Offset The index or offset of the byte\r
+ @param Index Index of the fragment that contains the block\r
+\r
+ @retval * Pointer to the nth byte of data in the net buffer.\r
+ If NULL, there is no such data in the net buffer.\r
+\r
+**/\r
+UINT8 *\r
+EFIAPI\r
+NetbufGetByte (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Offset,\r
+ OUT UINT32 *Index OPTIONAL\r
+ );\r
+\r
+/**\r
+ Create a copy of NET_BUF that share the associated NET_DATA.\r
+\r
+ @param Nbuf Pointer to the net buffer to be cloned.\r
+\r
+ @retval * Pointer to the cloned net buffer.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufClone (\r
+ IN NET_BUF *Nbuf\r
+ );\r
+\r
+/**\r
+ Create a duplicated copy of Nbuf, data is copied. Also leave some\r
+ head space before the data.\r
+\r
+ @param Nbuf Pointer to the net buffer to be cloned.\r
+ @param Duplicate Pointer to the net buffer to duplicate to, if NULL\r
+ a new net buffer is allocated.\r
+ @param HeadSpace Length of the head space to reserve\r
+\r
+ @retval * Pointer to the duplicated net buffer.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufDuplicate (\r
+ IN NET_BUF *Nbuf,\r
+ IN NET_BUF *Duplicate OPTIONAL,\r
+ IN UINT32 HeadSpace\r
+ );\r
+\r
+/**\r
+ Create a NET_BUF structure which contains Len byte data of\r
+ Nbuf starting from Offset. A new NET_BUF structure will be\r
+ created but the associated data in NET_VECTOR is shared.\r
+ This function exists to do IP packet fragmentation.\r
+\r
+ @param Nbuf Pointer to the net buffer to be cloned.\r
+ @param Offset Starting point of the data to be included in new\r
+ buffer.\r
+ @param Len How many data to include in new data\r
+ @param HeadSpace How many bytes of head space to reserve for\r
+ protocol header\r
+\r
+ @retval * Pointer to the cloned net buffer.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufGetFragment (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Offset,\r
+ IN UINT32 Len,\r
+ IN UINT32 HeadSpace\r
+ );\r
+\r
+/**\r
+ Reserve some space in the header room of the buffer.\r
+ Upon allocation, all the space are in the tail room\r
+ of the buffer. Call this function to move some space\r
+ to the header room. This function is quite limited in\r
+ that it can only reserver space from the first block\r
+ of an empty NET_BUF not built from the external. But\r
+ it should be enough for the network stack.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+ @param Len The length of buffer to be reserverd.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufReserve (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Len\r
+ );\r
+\r
+/**\r
+ Allocate some space from the header or tail of the buffer.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+ @param Len The length of the buffer to be allocated.\r
+ @param FromHead The flag to indicate whether reserve the data from\r
+ head or tail. TRUE for from head, and FALSE for\r
+ from tail.\r
+\r
+ @retval * Pointer to the first byte of the allocated buffer.\r
+\r
+**/\r
+UINT8 *\r
+EFIAPI\r
+NetbufAllocSpace (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Len,\r
+ IN BOOLEAN FromHead\r
+ );\r
+\r
+/**\r
+ Trim some data from the header or tail of the buffer.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+ @param Len The length of the data to be trimmed.\r
+ @param FromHead The flag to indicate whether trim data from head or\r
+ tail. TRUE for from head, and FALSE for from tail.\r
+\r
+ @retval UINTN Length of the actually trimmed data.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufTrim (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Len,\r
+ IN BOOLEAN FromHead\r
+ );\r
+\r
+/**\r
+ Copy the data from the specific offset to the destination.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+ @param Offset The sequence number of the first byte to copy.\r
+ @param Len Length of the data to copy.\r
+ @param Dest The destination of the data to copy to.\r
+\r
+ @retval UINTN The length of the copied data.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufCopy (\r
+ IN NET_BUF *Nbuf,\r
+ IN UINT32 Offset,\r
+ IN UINT32 Len,\r
+ IN UINT8 *Dest\r
+ );\r
+\r
+/**\r
+ Build a NET_BUF from external blocks.\r
+\r
+ @param ExtFragment Pointer to the data block.\r
+ @param ExtNum The number of the data block.\r
+ @param HeadSpace The head space to be reserved.\r
+ @param HeadLen The length of the protocol header, This function\r
+ will pull that number of data into a linear block.\r
+ @param ExtFree Pointer to the caller provided free function.\r
+ @param Arg The argument passed to ExtFree when ExtFree is\r
+ called.\r
+\r
+ @retval * Pointer to the net buffer built from the data\r
+ blocks.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufFromExt (\r
+ IN NET_FRAGMENT *ExtFragment,\r
+ IN UINT32 ExtNum,\r
+ IN UINT32 HeadSpace,\r
+ IN UINT32 HeadLen,\r
+ IN NET_VECTOR_EXT_FREE ExtFree,\r
+ IN VOID *Arg OPTIONAL\r
+ );\r
+\r
+/**\r
+ Build a fragment table to contain the fragments in the\r
+ buffer. This is the opposite of the NetbufFromExt.\r
+\r
+ @param Nbuf Point to the net buffer\r
+ @param ExtFragment Pointer to the data block.\r
+ @param ExtNum The number of the data block.\r
+\r
+ @retval EFI_BUFFER_TOO_SMALL The number of non-empty block is bigger than ExtNum\r
+ @retval EFI_SUCCESS Fragment table built.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetbufBuildExt (\r
+ IN NET_BUF *Nbuf,\r
+ IN NET_FRAGMENT *ExtFragment,\r
+ IN UINT32 *ExtNum\r
+ );\r
+\r
+/**\r
+ Build a NET_BUF from a list of NET_BUF.\r
+\r
+ @param BufList A List of NET_BUF.\r
+ @param HeadSpace The head space to be reserved.\r
+ @param HeaderLen The length of the protocol header, This function\r
+ will pull that number of data into a linear block.\r
+ @param ExtFree Pointer to the caller provided free function.\r
+ @param Arg The argument passed to ExtFree when ExtFree is\r
+ called.\r
+\r
+ @retval * Pointer to the net buffer built from the data\r
+ blocks.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufFromBufList (\r
+ IN LIST_ENTRY *BufList,\r
+ IN UINT32 HeadSpace,\r
+ IN UINT32 HeaderLen,\r
+ IN NET_VECTOR_EXT_FREE ExtFree,\r
+ IN VOID *Arg OPTIONAL\r
+ );\r
+\r
+/**\r
+ Free a list of net buffers.\r
+\r
+ @param Head Pointer to the head of linked net buffers.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufFreeList (\r
+ IN LIST_ENTRY *Head\r
+ );\r
+\r
+/**\r
+ Initiate the net buffer queue.\r
+\r
+ @param NbufQue Pointer to the net buffer queue to be initiated.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueInit (\r
+ IN NET_BUF_QUEUE *NbufQue\r
+ );\r
+\r
+/**\r
+ Allocate an initialized net buffer queue.\r
+\r
+ None.\r
+\r
+ @retval * Pointer to the allocated net buffer queue.\r
+\r
+**/\r
+NET_BUF_QUEUE *\r
+EFIAPI\r
+NetbufQueAlloc (\r
+ VOID\r
+ );\r
+\r
+/**\r
+ Free a net buffer queue.\r
+\r
+ @param NbufQue Poitner to the net buffer queue to be freed.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueFree (\r
+ IN NET_BUF_QUEUE *NbufQue\r
+ );\r
+\r
+/**\r
+ Remove a net buffer from head in the specific queue.\r
+\r
+ @param NbufQue Pointer to the net buffer queue.\r
+\r
+ @retval * Pointer to the net buffer removed from the specific\r
+ queue.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufQueRemove (\r
+ IN NET_BUF_QUEUE *NbufQue\r
+ );\r
+\r
+/**\r
+ Append a buffer to the end of the queue.\r
+\r
+ @param NbufQue Pointer to the net buffer queue.\r
+ @param Nbuf Pointer to the net buffer to be appended.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueAppend (\r
+ IN NET_BUF_QUEUE *NbufQue,\r
+ IN NET_BUF *Nbuf\r
+ );\r
+\r
+/**\r
+ Copy some data from the buffer queue to the destination.\r
+\r
+ @param NbufQue Pointer to the net buffer queue.\r
+ @param Offset The sequence number of the first byte to copy.\r
+ @param Len Length of the data to copy.\r
+ @param Dest The destination of the data to copy to.\r
+\r
+ @retval UINTN The length of the copied data.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufQueCopy (\r
+ IN NET_BUF_QUEUE *NbufQue,\r
+ IN UINT32 Offset,\r
+ IN UINT32 Len,\r
+ IN UINT8 *Dest\r
+ );\r
+\r
+/**\r
+ Trim some data from the queue header, release the buffer if\r
+ whole buffer is trimmed.\r
+\r
+ @param NbufQue Pointer to the net buffer queue.\r
+ @param Len Length of the data to trim.\r
+\r
+ @retval UINTN The length of the data trimmed.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufQueTrim (\r
+ IN NET_BUF_QUEUE *NbufQue,\r
+ IN UINT32 Len\r
+ );\r
+\r
+\r
+/**\r
+ Flush the net buffer queue.\r
+\r
+ @param NbufQue Pointer to the queue to be flushed.\r
+\r
+ @return None.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueFlush (\r
+ IN NET_BUF_QUEUE *NbufQue\r
+ );\r
+\r
+/**\r
+ Compute checksum for a bulk of data.\r
+\r
+ @param Bulk Pointer to the data.\r
+ @param Len Length of the data, in bytes.\r
+\r
+ @retval UINT16 The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetblockChecksum (\r
+ IN UINT8 *Bulk,\r
+ IN UINT32 Len\r
+ );\r
+\r
+/**\r
+ Add two checksums.\r
+\r
+ @param Checksum1 The first checksum to be added.\r
+ @param Checksum2 The second checksum to be added.\r
+\r
+ @retval UINT16 The new checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetAddChecksum (\r
+ IN UINT16 Checksum1,\r
+ IN UINT16 Checksum2\r
+ );\r
+\r
+/**\r
+ Compute the checksum for a NET_BUF.\r
+\r
+ @param Nbuf Pointer to the net buffer.\r
+\r
+ @retval UINT16 The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetbufChecksum (\r
+ IN NET_BUF *Nbuf\r
+ );\r
+\r
+/**\r
+ Compute the checksum for TCP/UDP pseudo header.\r
+ Src, Dst are in network byte order. and Len is\r
+ in host byte order.\r
+\r
+ @param Src The source address of the packet.\r
+ @param Dst The destination address of the packet.\r
+ @param Proto The protocol type of the packet.\r
+ @param Len The length of the packet.\r
+\r
+ @retval UINT16 The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetPseudoHeadChecksum (\r
+ IN IP4_ADDR Src,\r
+ IN IP4_ADDR Dst,\r
+ IN UINT8 Proto,\r
+ IN UINT16 Len\r
+ );\r
+\r
+#endif\r