#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
**/\r
NET_BUF *\r
NetbufAllocStruct (\r
- IN UINT32 BlockNum,\r
- IN UINT32 BlockOpNum\r
+ IN UINT32 BlockNum,\r
+ IN UINT32 BlockOpNum\r
)\r
{\r
- NET_BUF *Nbuf;\r
- NET_VECTOR *Vector;\r
+ NET_BUF *Nbuf;\r
+ NET_VECTOR *Vector;\r
\r
ASSERT (BlockOpNum >= 1);\r
\r
return NULL;\r
}\r
\r
- Nbuf->Signature = NET_BUF_SIGNATURE;\r
- Nbuf->RefCnt = 1;\r
- Nbuf->BlockOpNum = BlockOpNum;\r
+ Nbuf->Signature = NET_BUF_SIGNATURE;\r
+ Nbuf->RefCnt = 1;\r
+ Nbuf->BlockOpNum = BlockOpNum;\r
InitializeListHead (&Nbuf->List);\r
\r
if (BlockNum != 0) {\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
NET_BUF *\r
EFIAPI\r
NetbufAlloc (\r
- IN UINT32 Len\r
+ IN UINT32 Len\r
)\r
{\r
- NET_BUF *Nbuf;\r
- NET_VECTOR *Vector;\r
- UINT8 *Bulk;\r
+ NET_BUF *Nbuf;\r
+ NET_VECTOR *Vector;\r
+ UINT8 *Bulk;\r
\r
ASSERT (Len > 0);\r
\r
goto FreeNBuf;\r
}\r
\r
- Vector = Nbuf->Vector;\r
- Vector->Len = Len;\r
+ Vector = Nbuf->Vector;\r
+ Vector->Len = Len;\r
\r
- Vector->Block[0].Bulk = Bulk;\r
- Vector->Block[0].Len = Len;\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
+ 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
+ Nbuf->BlockOp[0].Head = Bulk;\r
+ Nbuf->BlockOp[0].Tail = Bulk;\r
+ Nbuf->BlockOp[0].Size = 0;\r
\r
return Nbuf;\r
\r
**/\r
VOID\r
NetbufFreeVector (\r
- IN NET_VECTOR *Vector\r
+ IN NET_VECTOR *Vector\r
)\r
{\r
- UINT32 Index;\r
+ UINT32 Index;\r
\r
ASSERT (Vector != NULL);\r
NET_CHECK_SIGNATURE (Vector, NET_VECTOR_SIGNATURE);\r
}\r
\r
Vector->Free (Vector->Arg);\r
-\r
} else {\r
//\r
// Free each memory block associated with the Vector\r
FreePool (Vector);\r
}\r
\r
-\r
/**\r
Free the net buffer and its associated NET_VECTOR.\r
\r
VOID\r
EFIAPI\r
NetbufFree (\r
- IN NET_BUF *Nbuf\r
+ IN NET_BUF *Nbuf\r
)\r
{\r
ASSERT (Nbuf != NULL);\r
}\r
}\r
\r
-\r
/**\r
Create a copy of the net buffer that shares the associated net vector.\r
\r
NET_BUF *\r
EFIAPI\r
NetbufClone (\r
- IN NET_BUF *Nbuf\r
+ IN NET_BUF *Nbuf\r
)\r
{\r
- NET_BUF *Clone;\r
+ NET_BUF *Clone;\r
\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
return NULL;\r
}\r
\r
- Clone->Signature = NET_BUF_SIGNATURE;\r
- Clone->RefCnt = 1;\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
+ Clone->Ip = Nbuf->Ip;\r
+ Clone->Tcp = Nbuf->Tcp;\r
\r
CopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\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
NET_BUF *\r
EFIAPI\r
NetbufDuplicate (\r
- IN NET_BUF *Nbuf,\r
- IN OUT NET_BUF *Duplicate OPTIONAL,\r
- IN UINT32 HeadSpace\r
+ IN NET_BUF *Nbuf,\r
+ IN OUT NET_BUF *Duplicate OPTIONAL,\r
+ IN UINT32 HeadSpace\r
)\r
{\r
- UINT8 *Dst;\r
+ UINT8 *Dst;\r
\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\r
return Duplicate;\r
}\r
\r
-\r
/**\r
Free a list of net buffers.\r
\r
VOID\r
EFIAPI\r
NetbufFreeList (\r
- IN OUT LIST_ENTRY *Head\r
+ IN OUT LIST_ENTRY *Head\r
)\r
{\r
- LIST_ENTRY *Entry;\r
- LIST_ENTRY *Next;\r
- NET_BUF *Nbuf;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ NET_BUF *Nbuf;\r
\r
Entry = Head->ForwardLink;\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
UINT8 *\r
EFIAPI\r
NetbufGetByte (\r
- IN NET_BUF *Nbuf,\r
- IN UINT32 Offset,\r
- OUT UINT32 *Index OPTIONAL\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
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Loop;\r
+ UINT32 Len;\r
\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
\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
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
VOID\r
NetbufSetBlock (\r
- IN OUT NET_BUF *Nbuf,\r
- IN UINT8 *Bulk,\r
- IN UINT32 Len,\r
- IN UINT32 Index\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
+ 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
+ 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
VOID\r
NetbufSetBlockOp (\r
- IN OUT NET_BUF *Nbuf,\r
- IN UINT8 *Bulk,\r
- IN UINT32 Len,\r
- IN UINT32 Index\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_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
+ 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
VOID\r
EFIAPI\r
NetbufGetFragmentFree (\r
- IN VOID *Arg\r
+ IN VOID *Arg\r
)\r
{\r
- NET_VECTOR *Vector;\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
NET_BUF *\r
EFIAPI\r
NetbufGetFragment (\r
- IN NET_BUF *Nbuf,\r
- IN UINT32 Offset,\r
- IN UINT32 Len,\r
- IN UINT32 HeadSpace\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
+ 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
FirstSkip = Offset - Cur;\r
FirstLen = BlockOp[Index].Size - FirstSkip;\r
\r
- Last = 0;\r
- LastLen = 0;\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
+ for ( ; Index < Nbuf->BlockOpNum; Index++) {\r
if (Offset + Len <= Cur + BlockOp[Index].Size) {\r
Last = Index;\r
LastLen = Offset + Len - Cur;\r
\r
Cur += BlockOp[Index].Size;\r
}\r
-\r
} else {\r
Last = First;\r
LastLen = Len;\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
+ 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
+ Child->BlockOp[0].Size = 0;\r
CurBlockOp++;\r
-\r
} else {\r
Child = NetbufAllocStruct (0, BlockOpNum);\r
\r
return NULL;\r
}\r
\r
-\r
-\r
/**\r
Build a NET_BUF from external blocks.\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
+ 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
+ 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
+ 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
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
+ 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
Index++;\r
break;\r
}\r
-\r
} else {\r
CopyMem (Header, ExtFragment[Index].Bulk, Len);\r
\r
- Copied += Len;\r
- TotalLen += Len;\r
+ Copied += Len;\r
+ TotalLen += Len;\r
\r
//\r
// Adjust the block structure to exclude the data copied,\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
+ SavedIndex = Index;\r
+ SavedFragment = ExtFragment[Index];\r
ExtFragment[Index].Bulk += Len;\r
ExtFragment[Index].Len -= Len;\r
break;\r
if (FirstBlockLen != 0) {\r
NetbufSetBlock (Nbuf, FirstBlock, HeadSpace + Copied, 0);\r
Nbuf->BlockOp[0].Head += HeadSpace;\r
- Nbuf->BlockOp[0].Size = Copied;\r
+ Nbuf->BlockOp[0].Size = Copied;\r
\r
CurBlock++;\r
}\r
\r
- for (; Index < ExtNum; Index++) {\r
+ for ( ; Index < ExtNum; Index++) {\r
NetbufSetBlock (Nbuf, ExtFragment[Index].Bulk, ExtFragment[Index].Len, CurBlock);\r
TotalLen += ExtFragment[Index].Len;\r
CurBlock++;\r
if (FirstBlock != NULL) {\r
FreePool (FirstBlock);\r
}\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
EFI_STATUS\r
EFIAPI\r
NetbufBuildExt (\r
- IN NET_BUF *Nbuf,\r
- IN OUT NET_FRAGMENT *ExtFragment,\r
- IN OUT UINT32 *ExtNum\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
+ UINT32 Index;\r
+ UINT32 Current;\r
\r
Current = 0;\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Build a net buffer from a list of net buffers.\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
+ 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
+ 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
+ // Compute how many blocks are there\r
//\r
FragmentNum = 0;\r
\r
}\r
\r
//\r
- //Allocate and copy block points\r
+ // Allocate and copy block points\r
//\r
Fragment = AllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);\r
\r
return Nbuf;\r
}\r
\r
-\r
/**\r
Reserve some space in the header room of the net buffer.\r
\r
VOID\r
EFIAPI\r
NetbufReserve (\r
- IN OUT NET_BUF *Nbuf,\r
- IN UINT32 Len\r
+ IN OUT NET_BUF *Nbuf,\r
+ IN UINT32 Len\r
)\r
{\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\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
or NULL if there is no sufficient space.\r
\r
**/\r
-UINT8*\r
+UINT8 *\r
EFIAPI\r
NetbufAllocSpace (\r
- IN OUT NET_BUF *Nbuf,\r
- IN UINT32 Len,\r
- IN BOOLEAN FromHead\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
+ NET_BLOCK_OP *BlockOp;\r
+ UINT32 Index;\r
+ UINT8 *SavedTail;\r
\r
Index = 0;\r
\r
} else {\r
NetbufGetByte (Nbuf, 0, &Index);\r
\r
- if ((Index != 0) && (NET_HEADSPACE(&(Nbuf->BlockOp[Index])) < Len)) {\r
+ if ((Index != 0) && (NET_HEADSPACE (&(Nbuf->BlockOp[Index])) < Len)) {\r
Index--;\r
}\r
}\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
} else {\r
NetbufGetByte (Nbuf, Nbuf->TotalSize - 1, &Index);\r
\r
- if ((NET_TAILSPACE(&(Nbuf->BlockOp[Index])) < Len) &&\r
- (Index < Nbuf->BlockOpNum - 1)) {\r
-\r
+ if ((NET_TAILSPACE (&(Nbuf->BlockOp[Index])) < Len) &&\r
+ (Index < Nbuf->BlockOpNum - 1))\r
+ {\r
Index++;\r
}\r
}\r
return NULL;\r
}\r
\r
- SavedTail = BlockOp->Tail;\r
+ SavedTail = BlockOp->Tail;\r
\r
BlockOp->Tail += Len;\r
BlockOp->Size += Len;\r
}\r
}\r
\r
-\r
/**\r
Trim a single NET_BLOCK by Len bytes from the header or tail.\r
\r
**/\r
VOID\r
NetblockTrim (\r
- IN OUT NET_BLOCK_OP *BlockOp,\r
- IN UINT32 Len,\r
- IN BOOLEAN FromHead\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
}\r
\r
-\r
/**\r
Trim Len bytes from the header or tail of the net buffer.\r
\r
UINT32\r
EFIAPI\r
NetbufTrim (\r
- IN OUT NET_BUF *Nbuf,\r
- IN UINT32 Len,\r
- IN BOOLEAN FromHead\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
+ 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
+ if ((Len == 0) || (Nbuf->TotalSize == 0)) {\r
return 0;\r
}\r
\r
Index = (FromHead ? 0 : Nbuf->BlockOpNum - 1);\r
BlockOp = Nbuf->BlockOp;\r
\r
- for (;;) {\r
+ for ( ; ;) {\r
if (BlockOp[Index].Size == 0) {\r
Index += (FromHead ? 1 : -1);\r
continue;\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
UINT32\r
EFIAPI\r
NetbufCopy (\r
- IN NET_BUF *Nbuf,\r
- IN UINT32 Offset,\r
- IN UINT32 Len,\r
- IN UINT8 *Dest\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
+ 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
// 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
+ Skip = Offset - Cur;\r
+ Left = BlockOp[Index].Size - Skip;\r
\r
if (Len <= Left) {\r
CopyMem (Dest, BlockOp[Index].Head + Skip, Len);\r
\r
Index++;\r
\r
- for (; Index < Nbuf->BlockOpNum; Index++) {\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
+ Dest += BlockOp[Index].Size;\r
} else {\r
Copied += Len;\r
CopyMem (Dest, BlockOp[Index].Head, Len);\r
return Copied;\r
}\r
\r
-\r
/**\r
Initiate the net buffer queue.\r
\r
VOID\r
EFIAPI\r
NetbufQueInit (\r
- IN OUT NET_BUF_QUEUE *NbufQue\r
+ IN OUT NET_BUF_QUEUE *NbufQue\r
)\r
{\r
- NbufQue->Signature = NET_QUE_SIGNATURE;\r
- NbufQue->RefCnt = 1;\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
+ NbufQue->BufSize = 0;\r
+ NbufQue->BufNum = 0;\r
}\r
\r
-\r
/**\r
Allocate and initialize a net buffer queue.\r
\r
VOID\r
)\r
{\r
- NET_BUF_QUEUE *NbufQue;\r
+ NET_BUF_QUEUE *NbufQue;\r
\r
NbufQue = AllocatePool (sizeof (NET_BUF_QUEUE));\r
if (NbufQue == NULL) {\r
return NbufQue;\r
}\r
\r
-\r
/**\r
Free a net buffer queue.\r
\r
VOID\r
EFIAPI\r
NetbufQueFree (\r
- IN NET_BUF_QUEUE *NbufQue\r
+ IN NET_BUF_QUEUE *NbufQue\r
)\r
{\r
ASSERT (NbufQue != NULL);\r
}\r
}\r
\r
-\r
/**\r
Append a net buffer to the net buffer queue.\r
\r
VOID\r
EFIAPI\r
NetbufQueAppend (\r
- IN OUT NET_BUF_QUEUE *NbufQue,\r
- IN OUT NET_BUF *Nbuf\r
+ IN OUT NET_BUF_QUEUE *NbufQue,\r
+ IN OUT NET_BUF *Nbuf\r
)\r
{\r
NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
NbufQue->BufNum++;\r
}\r
\r
-\r
/**\r
Remove a net buffer from the head in the specific queue and return it.\r
\r
NET_BUF *\r
EFIAPI\r
NetbufQueRemove (\r
- IN OUT NET_BUF_QUEUE *NbufQue\r
+ IN OUT NET_BUF_QUEUE *NbufQue\r
)\r
{\r
- NET_BUF *First;\r
+ NET_BUF *First;\r
\r
NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
\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
UINT32\r
EFIAPI\r
NetbufQueCopy (\r
- IN NET_BUF_QUEUE *NbufQue,\r
- IN UINT32 Offset,\r
- IN UINT32 Len,\r
- OUT UINT8 *Dest\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
+ 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
// skip to the Offset\r
//\r
- Cur = 0;\r
- Nbuf = NULL;\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
// Copy the data in the first buffer.\r
//\r
- Skip = Offset - Cur;\r
- Left = Nbuf->TotalSize - Skip;\r
+ Skip = Offset - Cur;\r
+ Left = Nbuf->TotalSize - Skip;\r
\r
if (Len < Left) {\r
return NetbufCopy (Nbuf, Skip, Len, Dest);\r
Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
\r
if (Len > Nbuf->TotalSize) {\r
- 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
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
UINT32\r
EFIAPI\r
NetbufQueTrim (\r
- IN OUT NET_BUF_QUEUE *NbufQue,\r
- IN UINT32 Len\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
+ 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
}\r
\r
NbufQue->BufSize -= Len;\r
- Trimmed = 0;\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
+ Len -= Nbuf->TotalSize;\r
\r
RemoveEntryList (Entry);\r
NetbufFree (Nbuf);\r
if (Len == 0) {\r
break;\r
}\r
-\r
} else {\r
Trimmed += NetbufTrim (Nbuf, Len, NET_BUF_HEAD);\r
break;\r
return Trimmed;\r
}\r
\r
-\r
/**\r
Flush the net buffer queue.\r
\r
VOID\r
EFIAPI\r
NetbufQueFlush (\r
- IN OUT NET_BUF_QUEUE *NbufQue\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
+ NbufQue->BufNum = 0;\r
+ NbufQue->BufSize = 0;\r
}\r
\r
-\r
/**\r
Compute the checksum for a bulk of data.\r
\r
UINT16\r
EFIAPI\r
NetblockChecksum (\r
- IN UINT8 *Bulk,\r
- IN UINT32 Len\r
+ IN UINT8 *Bulk,\r
+ IN UINT32 Len\r
)\r
{\r
- register UINT32 Sum;\r
+ register UINT32 Sum;\r
\r
Sum = 0;\r
\r
}\r
\r
while (Len > 1) {\r
- Sum += *(UINT16 *) Bulk;\r
+ Sum += *(UINT16 *)Bulk;\r
Bulk += 2;\r
- Len -= 2;\r
+ Len -= 2;\r
}\r
\r
//\r
//\r
while ((Sum >> 16) != 0) {\r
Sum = (Sum & 0xffff) + (Sum >> 16);\r
-\r
}\r
\r
- return (UINT16) Sum;\r
+ return (UINT16)Sum;\r
}\r
\r
-\r
/**\r
Add two checksums.\r
\r
UINT16\r
EFIAPI\r
NetAddChecksum (\r
- IN UINT16 Checksum1,\r
- IN UINT16 Checksum2\r
+ IN UINT16 Checksum1,\r
+ IN UINT16 Checksum2\r
)\r
{\r
- UINT32 Sum;\r
+ UINT32 Sum;\r
\r
Sum = Checksum1 + Checksum2;\r
\r
//\r
if ((Sum >> 16) != 0) {\r
Sum = (Sum & 0xffff) + 1;\r
-\r
}\r
\r
- return (UINT16) Sum;\r
+ return (UINT16)Sum;\r
}\r
\r
-\r
/**\r
Compute the checksum for a NET_BUF.\r
\r
UINT16\r
EFIAPI\r
NetbufChecksum (\r
- IN NET_BUF *Nbuf\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
+ 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
+ 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
return TotalSum;\r
}\r
\r
-\r
/**\r
Compute the checksum for TCP/UDP pseudo header.\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
+ 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
+ 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
+ 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
+ return NetblockChecksum ((UINT8 *)&Hdr, sizeof (Hdr));\r
}\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
+ 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
+ NET_IP6_PSEUDO_HDR Hdr;\r
\r
//\r
// Zero the memory to relieve align problems\r
Hdr.NextHeader = NextHeader;\r
Hdr.Len = HTONL (Len);\r
\r
- return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));\r
+ return NetblockChecksum ((UINT8 *)&Hdr, sizeof (Hdr));\r
}\r
\r
/**\r
**/\r
VOID\r
NetIpSecNetbufFree (\r
- NET_BUF *Nbuf\r
+ NET_BUF *Nbuf\r
)\r
{\r
NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\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
if ((Nbuf->Vector->Flag & NET_VECTOR_OWN_FIRST) != 0) {\r
FreePool (Nbuf->Vector->Block[0].Bulk);\r
}\r
+\r
FreePool (Nbuf->Vector);\r
FreePool (Nbuf);\r
}\r
}\r
-\r
projects / mirror_edk2.git / blobdiff