+/** @file\r
+ Network library functions providing net buffer operation support.\r
+\r
+Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>\r
+SPDX-License-Identifier: BSD-2-Clause-Patent\r
+**/\r
+\r
+#include <Uefi.h>\r
+\r
+#include <Library/NetLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+\r
+\r
+/**\r
+ Allocate and build up the sketch for a NET_BUF.\r
+\r
+ The net buffer allocated has the BlockOpNum's NET_BLOCK_OP, and its associated\r
+ NET_VECTOR has the BlockNum's NET_BLOCK. But all the NET_BLOCK_OP and\r
+ NET_BLOCK remain un-initialized.\r
+\r
+ @param[in] BlockNum The number of NET_BLOCK in the vector of net buffer\r
+ @param[in] BlockOpNum The number of NET_BLOCK_OP in the net buffer\r
+\r
+ @return Pointer to the allocated NET_BUF, or NULL if the\r
+ allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF *\r
+NetbufAllocStruct (\r
+ IN UINT32 BlockNum,\r
+ IN UINT32 BlockOpNum\r
+ )\r
+{\r
+ NET_BUF *Nbuf;\r
+ NET_VECTOR *Vector;\r
+\r
+ ASSERT (BlockOpNum >= 1);\r
+\r
+ //\r
+ // Allocate three memory blocks.\r
+ //\r
+ Nbuf = AllocateZeroPool (NET_BUF_SIZE (BlockOpNum));\r
+\r
+ if (Nbuf == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Nbuf->Signature = NET_BUF_SIGNATURE;\r
+ Nbuf->RefCnt = 1;\r
+ Nbuf->BlockOpNum = BlockOpNum;\r
+ InitializeListHead (&Nbuf->List);\r
+\r
+ if (BlockNum != 0) {\r
+ Vector = AllocateZeroPool (NET_VECTOR_SIZE (BlockNum));\r
+\r
+ if (Vector == NULL) {\r
+ goto FreeNbuf;\r
+ }\r
+\r
+ Vector->Signature = NET_VECTOR_SIGNATURE;\r
+ Vector->RefCnt = 1;\r
+ Vector->BlockNum = BlockNum;\r
+ Nbuf->Vector = Vector;\r
+ }\r
+\r
+ return Nbuf;\r
+\r
+FreeNbuf:\r
+\r
+ FreePool (Nbuf);\r
+ return NULL;\r
+}\r
+\r
+\r
+/**\r
+ Allocate a single block NET_BUF. Upon allocation, all the\r
+ free space is in the tail room.\r
+\r
+ @param[in] Len The length of the block.\r
+\r
+ @return Pointer to the allocated NET_BUF, or NULL if the\r
+ allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufAlloc (\r
+ IN UINT32 Len\r
+ )\r
+{\r
+ NET_BUF *Nbuf;\r
+ NET_VECTOR *Vector;\r
+ UINT8 *Bulk;\r
+\r
+ ASSERT (Len > 0);\r
+\r
+ Nbuf = NetbufAllocStruct (1, 1);\r
+\r
+ if (Nbuf == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Bulk = AllocatePool (Len);\r
+\r
+ if (Bulk == NULL) {\r
+ goto FreeNBuf;\r
+ }\r
+\r
+ Vector = Nbuf->Vector;\r
+ Vector->Len = Len;\r
+\r
+ Vector->Block[0].Bulk = Bulk;\r
+ Vector->Block[0].Len = Len;\r
+\r
+ Nbuf->BlockOp[0].BlockHead = Bulk;\r
+ Nbuf->BlockOp[0].BlockTail = Bulk + Len;\r
+\r
+ Nbuf->BlockOp[0].Head = Bulk;\r
+ Nbuf->BlockOp[0].Tail = Bulk;\r
+ Nbuf->BlockOp[0].Size = 0;\r
+\r
+ return Nbuf;\r
+\r
+FreeNBuf:\r
+ FreePool (Nbuf);\r
+ return NULL;\r
+}\r
+\r
+/**\r
+ Free the net vector.\r
+\r
+ Decrease the reference count of the net vector by one. The real resource free\r
+ operation isn't performed until the reference count of the net vector is\r
+ decreased to 0.\r
+\r
+ @param[in] Vector Pointer to the NET_VECTOR to be freed.\r
+\r
+**/\r
+VOID\r
+NetbufFreeVector (\r
+ IN NET_VECTOR *Vector\r
+ )\r
+{\r
+ UINT32 Index;\r
+\r
+ ASSERT (Vector != NULL);\r
+ NET_CHECK_SIGNATURE (Vector, NET_VECTOR_SIGNATURE);\r
+ ASSERT (Vector->RefCnt > 0);\r
+\r
+ Vector->RefCnt--;\r
+\r
+ if (Vector->RefCnt > 0) {\r
+ return;\r
+ }\r
+\r
+ if (Vector->Free != NULL) {\r
+ //\r
+ // Call external free function to free the vector if it\r
+ // isn't NULL. If NET_VECTOR_OWN_FIRST is set, release the\r
+ // first block since it is allocated by us\r
+ //\r
+ if ((Vector->Flag & NET_VECTOR_OWN_FIRST) != 0) {\r
+ gBS->FreePool (Vector->Block[0].Bulk);\r
+ }\r
+\r
+ Vector->Free (Vector->Arg);\r
+\r
+ } else {\r
+ //\r
+ // Free each memory block associated with the Vector\r
+ //\r
+ for (Index = 0; Index < Vector->BlockNum; Index++) {\r
+ gBS->FreePool (Vector->Block[Index].Bulk);\r
+ }\r
+ }\r
+\r
+ FreePool (Vector);\r
+}\r
+\r
+\r
+/**\r
+ Free the net buffer and its associated NET_VECTOR.\r
+\r
+ Decrease the reference count of the net buffer by one. Free the associated net\r
+ vector and itself if the reference count of the net buffer is decreased to 0.\r
+ The net vector free operation just decrease the reference count of the net\r
+ vector by one and do the real resource free operation when the reference count\r
+ of the net vector is 0.\r
+\r
+ @param[in] Nbuf Pointer to the NET_BUF to be freed.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufFree (\r
+ IN NET_BUF *Nbuf\r
+ )\r
+{\r
+ ASSERT (Nbuf != NULL);\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ ASSERT (Nbuf->RefCnt > 0);\r
+\r
+ Nbuf->RefCnt--;\r
+\r
+ if (Nbuf->RefCnt == 0) {\r
+ //\r
+ // Update Vector only when NBuf is to be released. That is,\r
+ // all the sharing of Nbuf increse Vector's RefCnt by one\r
+ //\r
+ NetbufFreeVector (Nbuf->Vector);\r
+ FreePool (Nbuf);\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ Create a copy of the net buffer that shares the associated net vector.\r
+\r
+ The reference count of the newly created net buffer is set to 1. The reference\r
+ count of the associated net vector is increased by one.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer to be cloned.\r
+\r
+ @return Pointer to the cloned net buffer, or NULL if the\r
+ allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufClone (\r
+ IN NET_BUF *Nbuf\r
+ )\r
+{\r
+ NET_BUF *Clone;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ Clone = AllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));\r
+\r
+ if (Clone == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Clone->Signature = NET_BUF_SIGNATURE;\r
+ Clone->RefCnt = 1;\r
+ InitializeListHead (&Clone->List);\r
+\r
+ Clone->Ip = Nbuf->Ip;\r
+ Clone->Tcp = Nbuf->Tcp;\r
+\r
+ CopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+\r
+ NET_GET_REF (Nbuf->Vector);\r
+\r
+ Clone->Vector = Nbuf->Vector;\r
+ Clone->BlockOpNum = Nbuf->BlockOpNum;\r
+ Clone->TotalSize = Nbuf->TotalSize;\r
+ CopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);\r
+\r
+ return Clone;\r
+}\r
+\r
+\r
+/**\r
+ Create a duplicated copy of the net buffer with data copied and HeadSpace\r
+ bytes of head space reserved.\r
+\r
+ The duplicated net buffer will allocate its own memory to hold the data of the\r
+ source net buffer.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer to be duplicated from.\r
+ @param[in, out] Duplicate Pointer to the net buffer to duplicate to, if\r
+ NULL a new net buffer is allocated.\r
+ @param[in] HeadSpace Length of the head space to reserve.\r
+\r
+ @return Pointer to the duplicated net buffer, or NULL if\r
+ the allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufDuplicate (\r
+ IN NET_BUF *Nbuf,\r
+ IN OUT NET_BUF *Duplicate OPTIONAL,\r
+ IN UINT32 HeadSpace\r
+ )\r
+{\r
+ UINT8 *Dst;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ if (Duplicate == NULL) {\r
+ Duplicate = NetbufAlloc (Nbuf->TotalSize + HeadSpace);\r
+ }\r
+\r
+ if (Duplicate == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Don't set the IP and TCP head point, since it is most\r
+ // like that they are pointing to the memory of Nbuf.\r
+ //\r
+ CopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+ NetbufReserve (Duplicate, HeadSpace);\r
+\r
+ Dst = NetbufAllocSpace (Duplicate, Nbuf->TotalSize, NET_BUF_TAIL);\r
+ NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dst);\r
+\r
+ return Duplicate;\r
+}\r
+\r
+\r
+/**\r
+ Free a list of net buffers.\r
+\r
+ @param[in, out] Head Pointer to the head of linked net buffers.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufFreeList (\r
+ IN OUT LIST_ENTRY *Head\r
+ )\r
+{\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ NET_BUF *Nbuf;\r
+\r
+ Entry = Head->ForwardLink;\r
+\r
+ NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ RemoveEntryList (Entry);\r
+ NetbufFree (Nbuf);\r
+ }\r
+\r
+ ASSERT (IsListEmpty (Head));\r
+}\r
+\r
+\r
+/**\r
+ Get the index of NET_BLOCK_OP that contains the byte at Offset in the net\r
+ buffer.\r
+\r
+ This can be used to, for example, retrieve the IP header in the packet. It\r
+ also can be used to get the fragment that contains the byte which is used\r
+ mainly by the library implementation itself.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer.\r
+ @param[in] Offset The offset of the byte.\r
+ @param[out] Index Index of the NET_BLOCK_OP that contains the byte at\r
+ Offset.\r
+\r
+ @return Pointer to the Offset'th byte of data in the net buffer, or NULL\r
+ if 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
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Loop;\r
+ UINT32 Len;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ if (Offset >= Nbuf->TotalSize) {\r
+ return NULL;\r
+ }\r
+\r
+ BlockOp = Nbuf->BlockOp;\r
+ Len = 0;\r
+\r
+ for (Loop = 0; Loop < Nbuf->BlockOpNum; Loop++) {\r
+\r
+ if (Len + BlockOp[Loop].Size <= Offset) {\r
+ Len += BlockOp[Loop].Size;\r
+ continue;\r
+ }\r
+\r
+ if (Index != NULL) {\r
+ *Index = Loop;\r
+ }\r
+\r
+ return BlockOp[Loop].Head + (Offset - Len);\r
+ }\r
+\r
+ return NULL;\r
+}\r
+\r
+\r
+\r
+/**\r
+ Set the NET_BLOCK and corresponding NET_BLOCK_OP in the net buffer and\r
+ corresponding net vector according to the bulk pointer and bulk length.\r
+\r
+ All the pointers in the Index'th NET_BLOCK and NET_BLOCK_OP are set to the\r
+ bulk's head and tail respectively. So, this function alone can't be used by\r
+ NetbufAlloc.\r
+\r
+ @param[in, out] Nbuf Pointer to the net buffer.\r
+ @param[in] Bulk Pointer to the data.\r
+ @param[in] Len Length of the bulk data.\r
+ @param[in] Index The data block index in the net buffer the bulk\r
+ data should belong to.\r
+\r
+**/\r
+VOID\r
+NetbufSetBlock (\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT8 *Bulk,\r
+ IN UINT32 Len,\r
+ IN UINT32 Index\r
+ )\r
+{\r
+ NET_BLOCK_OP *BlockOp;\r
+ NET_BLOCK *Block;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+ ASSERT (Index < Nbuf->BlockOpNum);\r
+\r
+ Block = &(Nbuf->Vector->Block[Index]);\r
+ BlockOp = &(Nbuf->BlockOp[Index]);\r
+ Block->Len = Len;\r
+ Block->Bulk = Bulk;\r
+ BlockOp->BlockHead = Bulk;\r
+ BlockOp->BlockTail = Bulk + Len;\r
+ BlockOp->Head = Bulk;\r
+ BlockOp->Tail = Bulk + Len;\r
+ BlockOp->Size = Len;\r
+}\r
+\r
+\r
+\r
+/**\r
+ Set the NET_BLOCK_OP in the net buffer. The corresponding NET_BLOCK\r
+ structure is left untouched.\r
+\r
+ Some times, there is no 1:1 relationship between NET_BLOCK and NET_BLOCK_OP.\r
+ For example, that in NetbufGetFragment.\r
+\r
+ @param[in, out] Nbuf Pointer to the net buffer.\r
+ @param[in] Bulk Pointer to the data.\r
+ @param[in] Len Length of the bulk data.\r
+ @param[in] Index The data block index in the net buffer the bulk\r
+ data should belong to.\r
+\r
+**/\r
+VOID\r
+NetbufSetBlockOp (\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT8 *Bulk,\r
+ IN UINT32 Len,\r
+ IN UINT32 Index\r
+ )\r
+{\r
+ NET_BLOCK_OP *BlockOp;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ ASSERT (Index < Nbuf->BlockOpNum);\r
+\r
+ BlockOp = &(Nbuf->BlockOp[Index]);\r
+ BlockOp->BlockHead = Bulk;\r
+ BlockOp->BlockTail = Bulk + Len;\r
+ BlockOp->Head = Bulk;\r
+ BlockOp->Tail = Bulk + Len;\r
+ BlockOp->Size = Len;\r
+}\r
+\r
+\r
+/**\r
+ Helper function for NetbufGetFragment. NetbufGetFragment may allocate the\r
+ first block to reserve HeadSpace bytes header space. So it needs to create a\r
+ new net vector for the first block and can avoid copy for the remaining data\r
+ by sharing the old net vector.\r
+\r
+ @param[in] Arg Point to the old NET_VECTOR.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufGetFragmentFree (\r
+ IN VOID *Arg\r
+ )\r
+{\r
+ NET_VECTOR *Vector;\r
+\r
+ Vector = (NET_VECTOR *)Arg;\r
+ NetbufFreeVector (Vector);\r
+}\r
+\r
+\r
+/**\r
+ Create a NET_BUF structure which contains Len byte data of Nbuf starting from\r
+ Offset.\r
+\r
+ A new NET_BUF structure will be created but the associated data in NET_VECTOR\r
+ is shared. This function exists to do IP packet fragmentation.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer to be extracted.\r
+ @param[in] Offset Starting point of the data to be included in the new\r
+ net buffer.\r
+ @param[in] Len Bytes of data to be included in the new net buffer.\r
+ @param[in] HeadSpace Bytes of head space to reserve for protocol header.\r
+\r
+ @return Pointer to the cloned net buffer, or NULL if the\r
+ allocation failed due to resource limit.\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
+ NET_BUF *Child;\r
+ NET_VECTOR *Vector;\r
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 CurBlockOp;\r
+ UINT32 BlockOpNum;\r
+ UINT8 *FirstBulk;\r
+ UINT32 Index;\r
+ UINT32 First;\r
+ UINT32 Last;\r
+ UINT32 FirstSkip;\r
+ UINT32 FirstLen;\r
+ UINT32 LastLen;\r
+ UINT32 Cur;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ if ((Len == 0) || (Offset + Len > Nbuf->TotalSize)) {\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // First find the first and last BlockOp that contains\r
+ // the valid data, and compute the offset of the first\r
+ // BlockOp and length of the last BlockOp\r
+ //\r
+ BlockOp = Nbuf->BlockOp;\r
+ Cur = 0;\r
+\r
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (Offset < Cur + BlockOp[Index].Size) {\r
+ break;\r
+ }\r
+\r
+ Cur += BlockOp[Index].Size;\r
+ }\r
+\r
+ //\r
+ // First is the index of the first BlockOp, FirstSkip is\r
+ // the offset of the first byte in the first BlockOp.\r
+ //\r
+ First = Index;\r
+ FirstSkip = Offset - Cur;\r
+ FirstLen = BlockOp[Index].Size - FirstSkip;\r
+\r
+ Last = 0;\r
+ LastLen = 0;\r
+\r
+ if (Len > FirstLen) {\r
+ Cur += BlockOp[Index].Size;\r
+ Index++;\r
+\r
+ for (; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (Offset + Len <= Cur + BlockOp[Index].Size) {\r
+ Last = Index;\r
+ LastLen = Offset + Len - Cur;\r
+ break;\r
+ }\r
+\r
+ Cur += BlockOp[Index].Size;\r
+ }\r
+\r
+ } else {\r
+ Last = First;\r
+ LastLen = Len;\r
+ FirstLen = Len;\r
+ }\r
+\r
+ ASSERT (Last >= First);\r
+ BlockOpNum = Last - First + 1;\r
+ CurBlockOp = 0;\r
+\r
+ if (HeadSpace != 0) {\r
+ //\r
+ // Allocate an extra block to accomdate the head space.\r
+ //\r
+ BlockOpNum++;\r
+\r
+ Child = NetbufAllocStruct (1, BlockOpNum);\r
+\r
+ if (Child == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ FirstBulk = AllocatePool (HeadSpace);\r
+\r
+ if (FirstBulk == NULL) {\r
+ goto FreeChild;\r
+ }\r
+\r
+ Vector = Child->Vector;\r
+ Vector->Free = NetbufGetFragmentFree;\r
+ Vector->Arg = Nbuf->Vector;\r
+ Vector->Flag = NET_VECTOR_OWN_FIRST;\r
+ Vector->Len = HeadSpace;\r
+\r
+ //\r
+ // Reserve the head space in the first block\r
+ //\r
+ NetbufSetBlock (Child, FirstBulk, HeadSpace, 0);\r
+ Child->BlockOp[0].Head += HeadSpace;\r
+ Child->BlockOp[0].Size = 0;\r
+ CurBlockOp++;\r
+\r
+ } else {\r
+ Child = NetbufAllocStruct (0, BlockOpNum);\r
+\r
+ if (Child == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Child->Vector = Nbuf->Vector;\r
+ }\r
+\r
+ NET_GET_REF (Nbuf->Vector);\r
+ Child->TotalSize = Len;\r
+\r
+ //\r
+ // Set all the BlockOp up, the first and last one are special\r
+ // and need special process.\r
+ //\r
+ NetbufSetBlockOp (\r
+ Child,\r
+ Nbuf->BlockOp[First].Head + FirstSkip,\r
+ FirstLen,\r
+ CurBlockOp++\r
+ );\r
+\r
+ for (Index = First + 1; Index < Last; Index++) {\r
+ NetbufSetBlockOp (\r
+ Child,\r
+ BlockOp[Index].Head,\r
+ BlockOp[Index].Size,\r
+ CurBlockOp++\r
+ );\r
+ }\r
+\r
+ if (First != Last) {\r
+ NetbufSetBlockOp (\r
+ Child,\r
+ BlockOp[Last].Head,\r
+ LastLen,\r
+ CurBlockOp\r
+ );\r
+ }\r
+\r
+ CopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+ return Child;\r
+\r
+FreeChild:\r
+\r
+ FreePool (Child);\r
+ return NULL;\r
+}\r
+\r
+\r
+\r
+/**\r
+ Build a NET_BUF from external blocks.\r
+\r
+ A new NET_BUF structure will be created from external blocks. Additional block\r
+ of memory will be allocated to hold reserved HeadSpace bytes of header room\r
+ and existing HeadLen bytes of header but the external blocks are shared by the\r
+ net buffer to avoid data copying.\r
+\r
+ @param[in] ExtFragment Pointer to the data block.\r
+ @param[in] ExtNum The number of the data blocks.\r
+ @param[in] HeadSpace The head space to be reserved.\r
+ @param[in] HeadLen The length of the protocol header, This function\r
+ will pull that number of data into a linear block.\r
+ @param[in] ExtFree Pointer to the caller provided free function.\r
+ @param[in] Arg The argument passed to ExtFree when ExtFree is\r
+ called.\r
+\r
+ @return Pointer to the net buffer built from the data blocks,\r
+ or NULL if the allocation failed due to resource\r
+ limit.\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
+ NET_BUF *Nbuf;\r
+ NET_VECTOR *Vector;\r
+ NET_FRAGMENT SavedFragment;\r
+ UINT32 SavedIndex;\r
+ UINT32 TotalLen;\r
+ UINT32 BlockNum;\r
+ UINT8 *FirstBlock;\r
+ UINT32 FirstBlockLen;\r
+ UINT8 *Header;\r
+ UINT32 CurBlock;\r
+ UINT32 Index;\r
+ UINT32 Len;\r
+ UINT32 Copied;\r
+\r
+ ASSERT ((ExtFragment != NULL) && (ExtNum > 0) && (ExtFree != NULL));\r
+\r
+ SavedFragment.Bulk = NULL;\r
+ SavedFragment.Len = 0;\r
+\r
+ FirstBlockLen = 0;\r
+ FirstBlock = NULL;\r
+ BlockNum = ExtNum;\r
+ Index = 0;\r
+ TotalLen = 0;\r
+ SavedIndex = 0;\r
+ Len = 0;\r
+ Copied = 0;\r
+\r
+ //\r
+ // No need to consolidate the header if the first block is\r
+ // longer than the header length or there is only one block.\r
+ //\r
+ if ((ExtFragment[0].Len >= HeadLen) || (ExtNum == 1)) {\r
+ HeadLen = 0;\r
+ }\r
+\r
+ //\r
+ // Allocate an extra block if we need to:\r
+ // 1. Allocate some header space\r
+ // 2. aggreate the packet header\r
+ //\r
+ if ((HeadSpace != 0) || (HeadLen != 0)) {\r
+ FirstBlockLen = HeadLen + HeadSpace;\r
+ FirstBlock = AllocatePool (FirstBlockLen);\r
+\r
+ if (FirstBlock == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ BlockNum++;\r
+ }\r
+\r
+ //\r
+ // Copy the header to the first block, reduce the NET_BLOCK\r
+ // to allocate by one for each block that is completely covered\r
+ // by the first bulk.\r
+ //\r
+ if (HeadLen != 0) {\r
+ Len = HeadLen;\r
+ Header = FirstBlock + HeadSpace;\r
+\r
+ for (Index = 0; Index < ExtNum; Index++) {\r
+ if (Len >= ExtFragment[Index].Len) {\r
+ CopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);\r
+\r
+ Copied += ExtFragment[Index].Len;\r
+ Len -= ExtFragment[Index].Len;\r
+ Header += ExtFragment[Index].Len;\r
+ TotalLen += ExtFragment[Index].Len;\r
+ BlockNum--;\r
+\r
+ if (Len == 0) {\r
+ //\r
+ // Increament the index number to point to the next\r
+ // non-empty fragment.\r
+ //\r
+ Index++;\r
+ break;\r
+ }\r
+\r
+ } else {\r
+ CopyMem (Header, ExtFragment[Index].Bulk, Len);\r
+\r
+ Copied += Len;\r
+ TotalLen += Len;\r
+\r
+ //\r
+ // Adjust the block structure to exclude the data copied,\r
+ // So, the left-over block can be processed as other blocks.\r
+ // But it must be recovered later. (SavedIndex > 0) always\r
+ // holds since we don't aggreate the header if the first block\r
+ // is bigger enough that the header is continuous\r
+ //\r
+ SavedIndex = Index;\r
+ SavedFragment = ExtFragment[Index];\r
+ ExtFragment[Index].Bulk += Len;\r
+ ExtFragment[Index].Len -= Len;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ Nbuf = NetbufAllocStruct (BlockNum, BlockNum);\r
+\r
+ if (Nbuf == NULL) {\r
+ goto FreeFirstBlock;\r
+ }\r
+\r
+ Vector = Nbuf->Vector;\r
+ Vector->Free = ExtFree;\r
+ Vector->Arg = Arg;\r
+ Vector->Flag = ((FirstBlockLen != 0) ? NET_VECTOR_OWN_FIRST : 0);\r
+\r
+ //\r
+ // Set the first block up which may contain\r
+ // some head space and aggregated header\r
+ //\r
+ CurBlock = 0;\r
+\r
+ if (FirstBlockLen != 0) {\r
+ NetbufSetBlock (Nbuf, FirstBlock, HeadSpace + Copied, 0);\r
+ Nbuf->BlockOp[0].Head += HeadSpace;\r
+ Nbuf->BlockOp[0].Size = Copied;\r
+\r
+ CurBlock++;\r
+ }\r
+\r
+ for (; Index < ExtNum; Index++) {\r
+ NetbufSetBlock (Nbuf, ExtFragment[Index].Bulk, ExtFragment[Index].Len, CurBlock);\r
+ TotalLen += ExtFragment[Index].Len;\r
+ CurBlock++;\r
+ }\r
+\r
+ Vector->Len = TotalLen + HeadSpace;\r
+ Nbuf->TotalSize = TotalLen;\r
+\r
+ if (SavedIndex != 0) {\r
+ ExtFragment[SavedIndex] = SavedFragment;\r
+ }\r
+\r
+ return Nbuf;\r
+\r
+FreeFirstBlock:\r
+ if (FirstBlock != NULL) {\r
+ FreePool (FirstBlock);\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+/**\r
+ Build a fragment table to contain the fragments in the net buffer. This is the\r
+ opposite operation of the NetbufFromExt.\r
+\r
+ @param[in] Nbuf Point to the net buffer.\r
+ @param[in, out] ExtFragment Pointer to the data block.\r
+ @param[in, out] ExtNum The number of the data blocks.\r
+\r
+ @retval EFI_BUFFER_TOO_SMALL The number of non-empty block is bigger than\r
+ ExtNum.\r
+ @retval EFI_SUCCESS Fragment table is built successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+NetbufBuildExt (\r
+ IN NET_BUF *Nbuf,\r
+ IN OUT NET_FRAGMENT *ExtFragment,\r
+ IN OUT UINT32 *ExtNum\r
+ )\r
+{\r
+ UINT32 Index;\r
+ UINT32 Current;\r
+\r
+ Current = 0;\r
+\r
+ for (Index = 0; (Index < Nbuf->BlockOpNum); Index++) {\r
+ if (Nbuf->BlockOp[Index].Size == 0) {\r
+ continue;\r
+ }\r
+\r
+ if (Current < *ExtNum) {\r
+ ExtFragment[Current].Bulk = Nbuf->BlockOp[Index].Head;\r
+ ExtFragment[Current].Len = Nbuf->BlockOp[Index].Size;\r
+ Current++;\r
+ } else {\r
+ return EFI_BUFFER_TOO_SMALL;\r
+ }\r
+ }\r
+\r
+ *ExtNum = Current;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Build a net buffer from a list of net buffers.\r
+\r
+ All the fragments will be collected from the list of NEW_BUF and then a new\r
+ net buffer will be created through NetbufFromExt.\r
+\r
+ @param[in] BufList A List of the net buffer.\r
+ @param[in] HeadSpace The head space to be reserved.\r
+ @param[in] HeaderLen The length of the protocol header, This function\r
+ will pull that number of data into a linear block.\r
+ @param[in] ExtFree Pointer to the caller provided free function.\r
+ @param[in] Arg The argument passed to ExtFree when ExtFree is called.\r
+\r
+ @return Pointer to the net buffer built from the list of net\r
+ buffers.\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
+ NET_FRAGMENT *Fragment;\r
+ UINT32 FragmentNum;\r
+ LIST_ENTRY *Entry;\r
+ NET_BUF *Nbuf;\r
+ UINT32 Index;\r
+ UINT32 Current;\r
+\r
+ //\r
+ //Compute how many blocks are there\r
+ //\r
+ FragmentNum = 0;\r
+\r
+ NET_LIST_FOR_EACH (Entry, BufList) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ FragmentNum += Nbuf->BlockOpNum;\r
+ }\r
+\r
+ //\r
+ //Allocate and copy block points\r
+ //\r
+ Fragment = AllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);\r
+\r
+ if (Fragment == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ Current = 0;\r
+\r
+ NET_LIST_FOR_EACH (Entry, BufList) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (Nbuf->BlockOp[Index].Size != 0) {\r
+ Fragment[Current].Bulk = Nbuf->BlockOp[Index].Head;\r
+ Fragment[Current].Len = Nbuf->BlockOp[Index].Size;\r
+ Current++;\r
+ }\r
+ }\r
+ }\r
+\r
+ Nbuf = NetbufFromExt (Fragment, Current, HeadSpace, HeaderLen, ExtFree, Arg);\r
+ FreePool (Fragment);\r
+\r
+ return Nbuf;\r
+}\r
+\r
+\r
+/**\r
+ Reserve some space in the header room of the net buffer.\r
+\r
+ Upon allocation, all the space are in the tail room of the buffer. Call this\r
+ function to move some space to the header room. This function is quite limited\r
+ in that it can only reserve space from the first block of an empty NET_BUF not\r
+ built from the external. But it should be enough for the network stack.\r
+\r
+ @param[in, out] Nbuf Pointer to the net buffer.\r
+ @param[in] Len The length of buffer to be reserved from the header.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufReserve (\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT32 Len\r
+ )\r
+{\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+\r
+ ASSERT ((Nbuf->BlockOpNum == 1) && (Nbuf->TotalSize == 0));\r
+ ASSERT ((Nbuf->Vector->Free == NULL) && (Nbuf->Vector->Len >= Len));\r
+\r
+ Nbuf->BlockOp[0].Head += Len;\r
+ Nbuf->BlockOp[0].Tail += Len;\r
+\r
+ ASSERT (Nbuf->BlockOp[0].Tail <= Nbuf->BlockOp[0].BlockTail);\r
+}\r
+\r
+\r
+/**\r
+ Allocate Len bytes of space from the header or tail of the buffer.\r
+\r
+ @param[in, out] Nbuf Pointer to the net buffer.\r
+ @param[in] Len The length of the buffer to be allocated.\r
+ @param[in] FromHead The flag to indicate whether reserve the data\r
+ from head (TRUE) or tail (FALSE).\r
+\r
+ @return Pointer to the first byte of the allocated buffer,\r
+ or NULL if there is no sufficient space.\r
+\r
+**/\r
+UINT8*\r
+EFIAPI\r
+NetbufAllocSpace (\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT32 Len,\r
+ IN BOOLEAN FromHead\r
+ )\r
+{\r
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Index;\r
+ UINT8 *SavedTail;\r
+\r
+ Index = 0;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+\r
+ ASSERT (Len > 0);\r
+\r
+ if (FromHead) {\r
+ //\r
+ // Allocate some space from head. If the buffer is empty,\r
+ // allocate from the first block. If it isn't, allocate\r
+ // from the first non-empty block, or the block before that.\r
+ //\r
+ if (Nbuf->TotalSize == 0) {\r
+ Index = 0;\r
+ } else {\r
+ NetbufGetByte (Nbuf, 0, &Index);\r
+\r
+ if ((NET_HEADSPACE(&(Nbuf->BlockOp[Index])) < Len) && (Index > 0)) {\r
+ Index--;\r
+ }\r
+ }\r
+\r
+ BlockOp = &(Nbuf->BlockOp[Index]);\r
+\r
+ if (NET_HEADSPACE (BlockOp) < Len) {\r
+ return NULL;\r
+ }\r
+\r
+ BlockOp->Head -= Len;\r
+ BlockOp->Size += Len;\r
+ Nbuf->TotalSize += Len;\r
+\r
+ return BlockOp->Head;\r
+\r
+ } else {\r
+ //\r
+ // Allocate some space from the tail. If the buffer is empty,\r
+ // allocate from the first block. If it isn't, allocate\r
+ // from the last non-empty block, or the block after that.\r
+ //\r
+ if (Nbuf->TotalSize == 0) {\r
+ Index = 0;\r
+ } else {\r
+ NetbufGetByte (Nbuf, Nbuf->TotalSize - 1, &Index);\r
+\r
+ if ((NET_TAILSPACE(&(Nbuf->BlockOp[Index])) < Len) &&\r
+ (Index < Nbuf->BlockOpNum - 1)) {\r
+\r
+ Index++;\r
+ }\r
+ }\r
+\r
+ BlockOp = &(Nbuf->BlockOp[Index]);\r
+\r
+ if (NET_TAILSPACE (BlockOp) < Len) {\r
+ return NULL;\r
+ }\r
+\r
+ SavedTail = BlockOp->Tail;\r
+\r
+ BlockOp->Tail += Len;\r
+ BlockOp->Size += Len;\r
+ Nbuf->TotalSize += Len;\r
+\r
+ return SavedTail;\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ Trim a single NET_BLOCK by Len bytes from the header or tail.\r
+\r
+ @param[in, out] BlockOp Pointer to the NET_BLOCK.\r
+ @param[in] Len The length of the data to be trimmed.\r
+ @param[in] FromHead The flag to indicate whether trim data from head\r
+ (TRUE) or tail (FALSE).\r
+\r
+**/\r
+VOID\r
+NetblockTrim (\r
+ IN OUT NET_BLOCK_OP *BlockOp,\r
+ IN UINT32 Len,\r
+ IN BOOLEAN FromHead\r
+ )\r
+{\r
+ ASSERT ((BlockOp != NULL) && (BlockOp->Size >= Len));\r
+\r
+ BlockOp->Size -= Len;\r
+\r
+ if (FromHead) {\r
+ BlockOp->Head += Len;\r
+ } else {\r
+ BlockOp->Tail -= Len;\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ Trim Len bytes from the header or tail of the net buffer.\r
+\r
+ @param[in, out] Nbuf Pointer to the net buffer.\r
+ @param[in] Len The length of the data to be trimmed.\r
+ @param[in] FromHead The flag to indicate whether trim data from head\r
+ (TRUE) or tail (FALSE).\r
+\r
+ @return Length of the actually trimmed data, which is possible to be less\r
+ than Len because the TotalSize of Nbuf is less than Len.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufTrim (\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT32 Len,\r
+ IN BOOLEAN FromHead\r
+ )\r
+{\r
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Index;\r
+ UINT32 Trimmed;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ if (Len == 0 || Nbuf->TotalSize == 0) {\r
+ return 0;\r
+ }\r
+\r
+ if (Len > Nbuf->TotalSize) {\r
+ Len = Nbuf->TotalSize;\r
+ }\r
+\r
+ //\r
+ // If FromTail is true, iterate backward. That\r
+ // is, init Index to NBuf->BlockNum - 1, and\r
+ // decrease it by 1 during each loop. Otherwise,\r
+ // iterate forward. That is, init Index to 0, and\r
+ // increase it by 1 during each loop.\r
+ //\r
+ Trimmed = 0;\r
+ Nbuf->TotalSize -= Len;\r
+\r
+ Index = (FromHead ? 0 : Nbuf->BlockOpNum - 1);\r
+ BlockOp = Nbuf->BlockOp;\r
+\r
+ for (;;) {\r
+ if (BlockOp[Index].Size == 0) {\r
+ Index += (FromHead ? 1 : -1);\r
+ continue;\r
+ }\r
+\r
+ if (Len > BlockOp[Index].Size) {\r
+ Len -= BlockOp[Index].Size;\r
+ Trimmed += BlockOp[Index].Size;\r
+ NetblockTrim (&BlockOp[Index], BlockOp[Index].Size, FromHead);\r
+ } else {\r
+ Trimmed += Len;\r
+ NetblockTrim (&BlockOp[Index], Len, FromHead);\r
+ break;\r
+ }\r
+\r
+ Index += (FromHead ? 1 : -1);\r
+ }\r
+\r
+ return Trimmed;\r
+}\r
+\r
+\r
+/**\r
+ Copy Len bytes of data from the specific offset of the net buffer to the\r
+ destination memory.\r
+\r
+ The Len bytes of data may cross the several fragments of the net buffer.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer.\r
+ @param[in] Offset The sequence number of the first byte to copy.\r
+ @param[in] Len Length of the data to copy.\r
+ @param[in] Dest The destination of the data to copy to.\r
+\r
+ @return The length of the actual copied data, or 0 if the offset\r
+ specified exceeds the total size of net buffer.\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
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Skip;\r
+ UINT32 Left;\r
+ UINT32 Copied;\r
+ UINT32 Index;\r
+ UINT32 Cur;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ ASSERT (Dest);\r
+\r
+ if ((Len == 0) || (Nbuf->TotalSize <= Offset)) {\r
+ return 0;\r
+ }\r
+\r
+ if (Nbuf->TotalSize - Offset < Len) {\r
+ Len = Nbuf->TotalSize - Offset;\r
+ }\r
+\r
+ BlockOp = Nbuf->BlockOp;\r
+\r
+ //\r
+ // Skip to the offset. Don't make "Offset-By-One" error here.\r
+ // Cur + BLOCK.SIZE is the first sequence number of next block.\r
+ // So, (Offset < Cur + BLOCK.SIZE) means that the first byte\r
+ // is in the current block. if (Offset == Cur + BLOCK.SIZE), the\r
+ // first byte is the next block's first byte.\r
+ //\r
+ Cur = 0;\r
+\r
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (BlockOp[Index].Size == 0) {\r
+ continue;\r
+ }\r
+\r
+ if (Offset < Cur + BlockOp[Index].Size) {\r
+ break;\r
+ }\r
+\r
+ Cur += BlockOp[Index].Size;\r
+ }\r
+\r
+ //\r
+ // Cur is the sequence number of the first byte in the block\r
+ // Offset - Cur is the number of bytes before first byte to\r
+ // to copy in the current block.\r
+ //\r
+ Skip = Offset - Cur;\r
+ Left = BlockOp[Index].Size - Skip;\r
+\r
+ if (Len <= Left) {\r
+ CopyMem (Dest, BlockOp[Index].Head + Skip, Len);\r
+ return Len;\r
+ }\r
+\r
+ CopyMem (Dest, BlockOp[Index].Head + Skip, Left);\r
+\r
+ Dest += Left;\r
+ Len -= Left;\r
+ Copied = Left;\r
+\r
+ Index++;\r
+\r
+ for (; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (Len > BlockOp[Index].Size) {\r
+ Len -= BlockOp[Index].Size;\r
+ Copied += BlockOp[Index].Size;\r
+\r
+ CopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);\r
+ Dest += BlockOp[Index].Size;\r
+ } else {\r
+ Copied += Len;\r
+ CopyMem (Dest, BlockOp[Index].Head, Len);\r
+ break;\r
+ }\r
+ }\r
+\r
+ return Copied;\r
+}\r
+\r
+\r
+/**\r
+ Initiate the net buffer queue.\r
+\r
+ @param[in, out] NbufQue Pointer to the net buffer queue to be initialized.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueInit (\r
+ IN OUT NET_BUF_QUEUE *NbufQue\r
+ )\r
+{\r
+ NbufQue->Signature = NET_QUE_SIGNATURE;\r
+ NbufQue->RefCnt = 1;\r
+ InitializeListHead (&NbufQue->List);\r
+\r
+ InitializeListHead (&NbufQue->BufList);\r
+ NbufQue->BufSize = 0;\r
+ NbufQue->BufNum = 0;\r
+}\r
+\r
+\r
+/**\r
+ Allocate and initialize a net buffer queue.\r
+\r
+ @return Pointer to the allocated net buffer queue, or NULL if the\r
+ allocation failed due to resource limit.\r
+\r
+**/\r
+NET_BUF_QUEUE *\r
+EFIAPI\r
+NetbufQueAlloc (\r
+ VOID\r
+ )\r
+{\r
+ NET_BUF_QUEUE *NbufQue;\r
+\r
+ NbufQue = AllocatePool (sizeof (NET_BUF_QUEUE));\r
+ if (NbufQue == NULL) {\r
+ return NULL;\r
+ }\r
+\r
+ NetbufQueInit (NbufQue);\r
+\r
+ return NbufQue;\r
+}\r
+\r
+\r
+/**\r
+ Free a net buffer queue.\r
+\r
+ Decrease the reference count of the net buffer queue by one. The real resource\r
+ free operation isn't performed until the reference count of the net buffer\r
+ queue is decreased to 0.\r
+\r
+ @param[in] NbufQue Pointer to the net buffer queue to be freed.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueFree (\r
+ IN NET_BUF_QUEUE *NbufQue\r
+ )\r
+{\r
+ ASSERT (NbufQue != NULL);\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+ NbufQue->RefCnt--;\r
+\r
+ if (NbufQue->RefCnt == 0) {\r
+ NetbufQueFlush (NbufQue);\r
+ FreePool (NbufQue);\r
+ }\r
+}\r
+\r
+\r
+/**\r
+ Append a net buffer to the net buffer queue.\r
+\r
+ @param[in, out] NbufQue Pointer to the net buffer queue.\r
+ @param[in, out] Nbuf Pointer to the net buffer to be appended.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueAppend (\r
+ IN OUT NET_BUF_QUEUE *NbufQue,\r
+ IN OUT NET_BUF *Nbuf\r
+ )\r
+{\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ InsertTailList (&NbufQue->BufList, &Nbuf->List);\r
+\r
+ NbufQue->BufSize += Nbuf->TotalSize;\r
+ NbufQue->BufNum++;\r
+}\r
+\r
+\r
+/**\r
+ Remove a net buffer from the head in the specific queue and return it.\r
+\r
+ @param[in, out] NbufQue Pointer to the net buffer queue.\r
+\r
+ @return Pointer to the net buffer removed from the specific queue,\r
+ or NULL if there is no net buffer in the specific queue.\r
+\r
+**/\r
+NET_BUF *\r
+EFIAPI\r
+NetbufQueRemove (\r
+ IN OUT NET_BUF_QUEUE *NbufQue\r
+ )\r
+{\r
+ NET_BUF *First;\r
+\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+ if (NbufQue->BufNum == 0) {\r
+ return NULL;\r
+ }\r
+\r
+ First = NET_LIST_USER_STRUCT (NbufQue->BufList.ForwardLink, NET_BUF, List);\r
+\r
+ NetListRemoveHead (&NbufQue->BufList);\r
+\r
+ NbufQue->BufSize -= First->TotalSize;\r
+ NbufQue->BufNum--;\r
+ return First;\r
+}\r
+\r
+\r
+/**\r
+ Copy Len bytes of data from the net buffer queue at the specific offset to the\r
+ destination memory.\r
+\r
+ The copying operation is the same as NetbufCopy but applies to the net buffer\r
+ queue instead of the net buffer.\r
+\r
+ @param[in] NbufQue Pointer to the net buffer queue.\r
+ @param[in] Offset The sequence number of the first byte to copy.\r
+ @param[in] Len Length of the data to copy.\r
+ @param[out] Dest The destination of the data to copy to.\r
+\r
+ @return The length of the actual copied data, or 0 if the offset\r
+ specified exceeds the total size of net buffer queue.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufQueCopy (\r
+ IN NET_BUF_QUEUE *NbufQue,\r
+ IN UINT32 Offset,\r
+ IN UINT32 Len,\r
+ OUT UINT8 *Dest\r
+ )\r
+{\r
+ LIST_ENTRY *Entry;\r
+ NET_BUF *Nbuf;\r
+ UINT32 Skip;\r
+ UINT32 Left;\r
+ UINT32 Cur;\r
+ UINT32 Copied;\r
+\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+ ASSERT (Dest != NULL);\r
+\r
+ if ((Len == 0) || (NbufQue->BufSize <= Offset)) {\r
+ return 0;\r
+ }\r
+\r
+ if (NbufQue->BufSize - Offset < Len) {\r
+ Len = NbufQue->BufSize - Offset;\r
+ }\r
+\r
+ //\r
+ // skip to the Offset\r
+ //\r
+ Cur = 0;\r
+ Nbuf = NULL;\r
+\r
+ NET_LIST_FOR_EACH (Entry, &NbufQue->BufList) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+ if (Offset < Cur + Nbuf->TotalSize) {\r
+ break;\r
+ }\r
+\r
+ Cur += Nbuf->TotalSize;\r
+ }\r
+\r
+ ASSERT (Nbuf != NULL);\r
+\r
+ //\r
+ // Copy the data in the first buffer.\r
+ //\r
+ Skip = Offset - Cur;\r
+ Left = Nbuf->TotalSize - Skip;\r
+\r
+ if (Len < Left) {\r
+ return NetbufCopy (Nbuf, Skip, Len, Dest);\r
+ }\r
+\r
+ NetbufCopy (Nbuf, Skip, Left, Dest);\r
+ Dest += Left;\r
+ Len -= Left;\r
+ Copied = Left;\r
+\r
+ //\r
+ // Iterate over the others\r
+ //\r
+ Entry = Entry->ForwardLink;\r
+\r
+ while ((Len > 0) && (Entry != &NbufQue->BufList)) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+ if (Len > Nbuf->TotalSize) {\r
+ Len -= Nbuf->TotalSize;\r
+ Copied += Nbuf->TotalSize;\r
+\r
+ NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dest);\r
+ Dest += Nbuf->TotalSize;\r
+\r
+ } else {\r
+ NetbufCopy (Nbuf, 0, Len, Dest);\r
+ Copied += Len;\r
+ break;\r
+ }\r
+\r
+ Entry = Entry->ForwardLink;\r
+ }\r
+\r
+ return Copied;\r
+}\r
+\r
+\r
+/**\r
+ Trim Len bytes of data from the buffer queue and free any net buffer\r
+ that is completely trimmed.\r
+\r
+ The trimming operation is the same as NetbufTrim but applies to the net buffer\r
+ queue instead of the net buffer.\r
+\r
+ @param[in, out] NbufQue Pointer to the net buffer queue.\r
+ @param[in] Len Length of the data to trim.\r
+\r
+ @return The actual length of the data trimmed.\r
+\r
+**/\r
+UINT32\r
+EFIAPI\r
+NetbufQueTrim (\r
+ IN OUT NET_BUF_QUEUE *NbufQue,\r
+ IN UINT32 Len\r
+ )\r
+{\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ NET_BUF *Nbuf;\r
+ UINT32 Trimmed;\r
+\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+ if (Len == 0) {\r
+ return 0;\r
+ }\r
+\r
+ if (Len > NbufQue->BufSize) {\r
+ Len = NbufQue->BufSize;\r
+ }\r
+\r
+ NbufQue->BufSize -= Len;\r
+ Trimmed = 0;\r
+\r
+ NET_LIST_FOR_EACH_SAFE (Entry, Next, &NbufQue->BufList) {\r
+ Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+ if (Len >= Nbuf->TotalSize) {\r
+ Trimmed += Nbuf->TotalSize;\r
+ Len -= Nbuf->TotalSize;\r
+\r
+ RemoveEntryList (Entry);\r
+ NetbufFree (Nbuf);\r
+\r
+ NbufQue->BufNum--;\r
+\r
+ if (Len == 0) {\r
+ break;\r
+ }\r
+\r
+ } else {\r
+ Trimmed += NetbufTrim (Nbuf, Len, NET_BUF_HEAD);\r
+ break;\r
+ }\r
+ }\r
+\r
+ return Trimmed;\r
+}\r
+\r
+\r
+/**\r
+ Flush the net buffer queue.\r
+\r
+ @param[in, out] NbufQue Pointer to the queue to be flushed.\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+NetbufQueFlush (\r
+ IN OUT NET_BUF_QUEUE *NbufQue\r
+ )\r
+{\r
+ NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+ NetbufFreeList (&NbufQue->BufList);\r
+\r
+ NbufQue->BufNum = 0;\r
+ NbufQue->BufSize = 0;\r
+}\r
+\r
+\r
+/**\r
+ Compute the checksum for a bulk of data.\r
+\r
+ @param[in] Bulk Pointer to the data.\r
+ @param[in] Len Length of the data, in bytes.\r
+\r
+ @return The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetblockChecksum (\r
+ IN UINT8 *Bulk,\r
+ IN UINT32 Len\r
+ )\r
+{\r
+ register UINT32 Sum;\r
+\r
+ Sum = 0;\r
+\r
+ //\r
+ // Add left-over byte, if any\r
+ //\r
+ if (Len % 2 != 0) {\r
+ Sum += *(Bulk + Len - 1);\r
+ }\r
+\r
+ while (Len > 1) {\r
+ Sum += *(UINT16 *) Bulk;\r
+ Bulk += 2;\r
+ Len -= 2;\r
+ }\r
+\r
+ //\r
+ // Fold 32-bit sum to 16 bits\r
+ //\r
+ while ((Sum >> 16) != 0) {\r
+ Sum = (Sum & 0xffff) + (Sum >> 16);\r
+\r
+ }\r
+\r
+ return (UINT16) Sum;\r
+}\r
+\r
+\r
+/**\r
+ Add two checksums.\r
+\r
+ @param[in] Checksum1 The first checksum to be added.\r
+ @param[in] Checksum2 The second checksum to be added.\r
+\r
+ @return The new checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetAddChecksum (\r
+ IN UINT16 Checksum1,\r
+ IN UINT16 Checksum2\r
+ )\r
+{\r
+ UINT32 Sum;\r
+\r
+ Sum = Checksum1 + Checksum2;\r
+\r
+ //\r
+ // two UINT16 can only add up to a carry of 1.\r
+ //\r
+ if ((Sum >> 16) != 0) {\r
+ Sum = (Sum & 0xffff) + 1;\r
+\r
+ }\r
+\r
+ return (UINT16) Sum;\r
+}\r
+\r
+\r
+/**\r
+ Compute the checksum for a NET_BUF.\r
+\r
+ @param[in] Nbuf Pointer to the net buffer.\r
+\r
+ @return The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetbufChecksum (\r
+ IN NET_BUF *Nbuf\r
+ )\r
+{\r
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Offset;\r
+ UINT16 TotalSum;\r
+ UINT16 BlockSum;\r
+ UINT32 Index;\r
+\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+ TotalSum = 0;\r
+ Offset = 0;\r
+ BlockOp = Nbuf->BlockOp;\r
+\r
+ for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+ if (BlockOp[Index].Size == 0) {\r
+ continue;\r
+ }\r
+\r
+ BlockSum = NetblockChecksum (BlockOp[Index].Head, BlockOp[Index].Size);\r
+\r
+ if ((Offset & 0x01) != 0) {\r
+ //\r
+ // The checksum starts with an odd byte, swap\r
+ // the checksum before added to total checksum\r
+ //\r
+ BlockSum = SwapBytes16 (BlockSum);\r
+ }\r
+\r
+ TotalSum = NetAddChecksum (BlockSum, TotalSum);\r
+ Offset += BlockOp[Index].Size;\r
+ }\r
+\r
+ return TotalSum;\r
+}\r
+\r
+\r
+/**\r
+ Compute the checksum for TCP/UDP pseudo header.\r
+\r
+ Src and Dst are in network byte order, and Len is in host byte order.\r
+\r
+ @param[in] Src The source address of the packet.\r
+ @param[in] Dst The destination address of the packet.\r
+ @param[in] Proto The protocol type of the packet.\r
+ @param[in] Len The length of the packet.\r
+\r
+ @return 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
+ NET_PSEUDO_HDR Hdr;\r
+\r
+ //\r
+ // Zero the memory to relieve align problems\r
+ //\r
+ ZeroMem (&Hdr, sizeof (Hdr));\r
+\r
+ Hdr.SrcIp = Src;\r
+ Hdr.DstIp = Dst;\r
+ Hdr.Protocol = Proto;\r
+ Hdr.Len = HTONS (Len);\r
+\r
+ return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));\r
+}\r
+\r
+/**\r
+ Compute the checksum for TCP6/UDP6 pseudo header.\r
+\r
+ Src and Dst are in network byte order, and Len is in host byte order.\r
+\r
+ @param[in] Src The source address of the packet.\r
+ @param[in] Dst The destination address of the packet.\r
+ @param[in] NextHeader The protocol type of the packet.\r
+ @param[in] Len The length of the packet.\r
+\r
+ @return The computed checksum.\r
+\r
+**/\r
+UINT16\r
+EFIAPI\r
+NetIp6PseudoHeadChecksum (\r
+ IN EFI_IPv6_ADDRESS *Src,\r
+ IN EFI_IPv6_ADDRESS *Dst,\r
+ IN UINT8 NextHeader,\r
+ IN UINT32 Len\r
+ )\r
+{\r
+ NET_IP6_PSEUDO_HDR Hdr;\r
+\r
+ //\r
+ // Zero the memory to relieve align problems\r
+ //\r
+ ZeroMem (&Hdr, sizeof (Hdr));\r
+\r
+ IP6_COPY_ADDRESS (&Hdr.SrcIp, Src);\r
+ IP6_COPY_ADDRESS (&Hdr.DstIp, Dst);\r
+\r
+ Hdr.NextHeader = NextHeader;\r
+ Hdr.Len = HTONL (Len);\r
+\r
+ return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));\r
+}\r
+\r
+/**\r
+ The function frees the net buffer which allocated by the IP protocol. It releases\r
+ only the net buffer and doesn't call the external free function.\r
+\r
+ This function should be called after finishing the process of mIpSec->ProcessExt()\r
+ for outbound traffic. The (EFI_IPSEC2_PROTOCOL)->ProcessExt() allocates a new\r
+ buffer for the ESP, so there needs a function to free the old net buffer.\r
+\r
+ @param[in] Nbuf The network buffer to be freed.\r
+\r
+**/\r
+VOID\r
+NetIpSecNetbufFree (\r
+ NET_BUF *Nbuf\r
+ )\r
+{\r
+ NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+ ASSERT (Nbuf->RefCnt > 0);\r
+\r
+ Nbuf->RefCnt--;\r
+\r
+ if (Nbuf->RefCnt == 0) {\r
+\r
+ //\r
+ // Update Vector only when NBuf is to be released. That is,\r
+ // all the sharing of Nbuf increse Vector's RefCnt by one\r
+ //\r
+ NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+ ASSERT (Nbuf->Vector->RefCnt > 0);\r
+\r
+ Nbuf->Vector->RefCnt--;\r
+\r
+ if (Nbuf->Vector->RefCnt > 0) {\r
+ return;\r
+ }\r
+\r
+ //\r
+ // If NET_VECTOR_OWN_FIRST is set, release the first block since it is\r
+ // allocated by us\r
+ //\r
+ if ((Nbuf->Vector->Flag & NET_VECTOR_OWN_FIRST) != 0) {\r
+ FreePool (Nbuf->Vector->Block[0].Bulk);\r
+ }\r
+ FreePool (Nbuf->Vector);\r
+ FreePool (Nbuf);\r
+ }\r
+}\r
+\r
projects / mirror_edk2.git / blobdiff