\r
#include "Ip4Impl.h"\r
\r
-\r
/**\r
Create an empty assemble entry for the packet identified by\r
(Dst, Src, Id, Protocol). The default life for the packet is\r
**/\r
IP4_ASSEMBLE_ENTRY *\r
Ip4CreateAssembleEntry (\r
- IN IP4_ADDR Dst,\r
- IN IP4_ADDR Src,\r
- IN UINT16 Id,\r
- IN UINT8 Protocol\r
+ IN IP4_ADDR Dst,\r
+ IN IP4_ADDR Src,\r
+ IN UINT16 Id,\r
+ IN UINT8 Protocol\r
)\r
{\r
-\r
- IP4_ASSEMBLE_ENTRY *Assemble;\r
+ IP4_ASSEMBLE_ENTRY *Assemble;\r
\r
Assemble = AllocatePool (sizeof (IP4_ASSEMBLE_ENTRY));\r
\r
return Assemble;\r
}\r
\r
-\r
/**\r
Release all the fragments of a packet, then free the assemble entry.\r
\r
**/\r
VOID\r
Ip4FreeAssembleEntry (\r
- IN IP4_ASSEMBLE_ENTRY *Assemble\r
+ IN IP4_ASSEMBLE_ENTRY *Assemble\r
)\r
{\r
- LIST_ENTRY *Entry;\r
- LIST_ENTRY *Next;\r
- NET_BUF *Fragment;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ NET_BUF *Fragment;\r
\r
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Assemble->Fragments) {\r
Fragment = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
FreePool (Assemble);\r
}\r
\r
-\r
/**\r
Initialize an already allocated assemble table. This is generally\r
the assemble table embedded in the IP4 service instance.\r
**/\r
VOID\r
Ip4InitAssembleTable (\r
- IN OUT IP4_ASSEMBLE_TABLE *Table\r
+ IN OUT IP4_ASSEMBLE_TABLE *Table\r
)\r
{\r
- UINT32 Index;\r
+ UINT32 Index;\r
\r
for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {\r
InitializeListHead (&Table->Bucket[Index]);\r
}\r
}\r
\r
-\r
/**\r
Clean up the assemble table: remove all the fragments\r
and assemble entries.\r
**/\r
VOID\r
Ip4CleanAssembleTable (\r
- IN IP4_ASSEMBLE_TABLE *Table\r
+ IN IP4_ASSEMBLE_TABLE *Table\r
)\r
{\r
- LIST_ENTRY *Entry;\r
- LIST_ENTRY *Next;\r
- IP4_ASSEMBLE_ENTRY *Assemble;\r
- UINT32 Index;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ IP4_ASSEMBLE_ENTRY *Assemble;\r
+ UINT32 Index;\r
\r
for (Index = 0; Index < IP4_ASSEMLE_HASH_SIZE; Index++) {\r
NET_LIST_FOR_EACH_SAFE (Entry, Next, &Table->Bucket[Index]) {\r
}\r
}\r
\r
-\r
/**\r
Trim the packet to fit in [Start, End), and update the per\r
packet information.\r
**/\r
VOID\r
Ip4TrimPacket (\r
- IN OUT NET_BUF *Packet,\r
- IN INTN Start,\r
- IN INTN End\r
+ IN OUT NET_BUF *Packet,\r
+ IN INTN Start,\r
+ IN INTN End\r
)\r
{\r
- IP4_CLIP_INFO *Info;\r
- INTN Len;\r
+ IP4_CLIP_INFO *Info;\r
+ INTN Len;\r
\r
Info = IP4_GET_CLIP_INFO (Packet);\r
\r
ASSERT (Info->Start + Info->Length == Info->End);\r
ASSERT ((Info->Start < End) && (Start < Info->End));\r
\r
- if (Info->Start < Start) {\r
+ if (Info->Start < Start) {\r
Len = Start - Info->Start;\r
\r
- NetbufTrim (Packet, (UINT32) Len, NET_BUF_HEAD);\r
+ NetbufTrim (Packet, (UINT32)Len, NET_BUF_HEAD);\r
Info->Start = Start;\r
Info->Length -= Len;\r
}\r
if (End < Info->End) {\r
Len = End - Info->End;\r
\r
- NetbufTrim (Packet, (UINT32) Len, NET_BUF_TAIL);\r
+ NetbufTrim (Packet, (UINT32)Len, NET_BUF_TAIL);\r
Info->End = End;\r
Info->Length -= Len;\r
}\r
}\r
\r
-\r
/**\r
Release all the fragments of the packet. This is the callback for\r
the assembled packet's OnFree. It will free the assemble entry,\r
VOID\r
EFIAPI\r
Ip4OnFreeFragments (\r
- IN VOID *Arg\r
+ IN VOID *Arg\r
)\r
{\r
- Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY *) Arg);\r
+ Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY *)Arg);\r
}\r
\r
-\r
/**\r
Reassemble the IP fragments. If all the fragments of the packet\r
have been received, it will wrap the packet in a net buffer then\r
**/\r
NET_BUF *\r
Ip4Reassemble (\r
- IN OUT IP4_ASSEMBLE_TABLE *Table,\r
- IN OUT NET_BUF *Packet\r
+ IN OUT IP4_ASSEMBLE_TABLE *Table,\r
+ IN OUT NET_BUF *Packet\r
)\r
{\r
- IP4_HEAD *IpHead;\r
- IP4_CLIP_INFO *This;\r
- IP4_CLIP_INFO *Node;\r
- IP4_ASSEMBLE_ENTRY *Assemble;\r
- LIST_ENTRY *Head;\r
- LIST_ENTRY *Prev;\r
- LIST_ENTRY *Cur;\r
- NET_BUF *Fragment;\r
- NET_BUF *NewPacket;\r
- INTN Index;\r
-\r
- IpHead = Packet->Ip.Ip4;\r
- This = IP4_GET_CLIP_INFO (Packet);\r
+ IP4_HEAD *IpHead;\r
+ IP4_CLIP_INFO *This;\r
+ IP4_CLIP_INFO *Node;\r
+ IP4_ASSEMBLE_ENTRY *Assemble;\r
+ LIST_ENTRY *Head;\r
+ LIST_ENTRY *Prev;\r
+ LIST_ENTRY *Cur;\r
+ NET_BUF *Fragment;\r
+ NET_BUF *NewPacket;\r
+ INTN Index;\r
+\r
+ IpHead = Packet->Ip.Ip4;\r
+ This = IP4_GET_CLIP_INFO (Packet);\r
\r
ASSERT (IpHead != NULL);\r
\r
//\r
// First: find the related assemble entry\r
//\r
- Assemble = NULL;\r
- Index = IP4_ASSEMBLE_HASH (IpHead->Dst, IpHead->Src, IpHead->Id, IpHead->Protocol);\r
+ Assemble = NULL;\r
+ Index = IP4_ASSEMBLE_HASH (IpHead->Dst, IpHead->Src, IpHead->Id, IpHead->Protocol);\r
\r
NET_LIST_FOR_EACH (Cur, &Table->Bucket[Index]) {\r
Assemble = NET_LIST_USER_STRUCT (Cur, IP4_ASSEMBLE_ENTRY, Link);\r
\r
if ((Assemble->Dst == IpHead->Dst) && (Assemble->Src == IpHead->Src) &&\r
- (Assemble->Id == IpHead->Id) && (Assemble->Protocol == IpHead->Protocol)) {\r
+ (Assemble->Id == IpHead->Id) && (Assemble->Protocol == IpHead->Protocol))\r
+ {\r
break;\r
}\r
}\r
\r
InsertHeadList (&Table->Bucket[Index], &Assemble->Link);\r
}\r
+\r
//\r
// Assemble shouldn't be NULL here\r
//\r
// overlaps, trim the overlapped part off THIS fragment.\r
//\r
if ((Prev = Cur->BackLink) != Head) {\r
- Fragment = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);\r
- Node = IP4_GET_CLIP_INFO (Fragment);\r
+ Fragment = NET_LIST_USER_STRUCT (Prev, NET_BUF, List);\r
+ Node = IP4_GET_CLIP_INFO (Fragment);\r
\r
if (This->Start < Node->End) {\r
if (This->End <= Node->End) {\r
//\r
ASSERT (Assemble->Head == NULL);\r
\r
- Assemble->Head = IpHead;\r
- Assemble->Info = IP4_GET_CLIP_INFO (Packet);\r
+ Assemble->Head = IpHead;\r
+ Assemble->Info = IP4_GET_CLIP_INFO (Packet);\r
}\r
\r
//\r
// queue ends at the total length, all data is received.\r
//\r
if ((Assemble->TotalLen != 0) && (Assemble->CurLen >= Assemble->TotalLen)) {\r
-\r
RemoveEntryList (&Assemble->Link);\r
\r
//\r
VOID\r
EFIAPI\r
Ip4IpSecFree (\r
- IN VOID *Arg\r
+ IN VOID *Arg\r
)\r
{\r
- IP4_IPSEC_WRAP *Wrap;\r
+ IP4_IPSEC_WRAP *Wrap;\r
\r
- Wrap = (IP4_IPSEC_WRAP *) Arg;\r
+ Wrap = (IP4_IPSEC_WRAP *)Arg;\r
\r
if (Wrap->IpSecRecycleSignal != NULL) {\r
gBS->SignalEvent (Wrap->IpSecRecycleSignal);\r
IN VOID *Context\r
)\r
{\r
- NET_FRAGMENT *FragmentTable;\r
- NET_FRAGMENT *OriginalFragmentTable;\r
- UINT32 FragmentCount;\r
- UINT32 OriginalFragmentCount;\r
- EFI_EVENT RecycleEvent;\r
- NET_BUF *Packet;\r
- IP4_TXTOKEN_WRAP *TxWrap;\r
- IP4_IPSEC_WRAP *IpSecWrap;\r
- EFI_STATUS Status;\r
- IP4_HEAD ZeroHead;\r
-\r
- Status = EFI_SUCCESS;\r
+ NET_FRAGMENT *FragmentTable;\r
+ NET_FRAGMENT *OriginalFragmentTable;\r
+ UINT32 FragmentCount;\r
+ UINT32 OriginalFragmentCount;\r
+ EFI_EVENT RecycleEvent;\r
+ NET_BUF *Packet;\r
+ IP4_TXTOKEN_WRAP *TxWrap;\r
+ IP4_IPSEC_WRAP *IpSecWrap;\r
+ EFI_STATUS Status;\r
+ IP4_HEAD ZeroHead;\r
+\r
+ Status = EFI_SUCCESS;\r
\r
if (!mIpSec2Installed) {\r
goto ON_EXIT;\r
}\r
+\r
ASSERT (mIpSec != NULL);\r
\r
Packet = *Netbuf;\r
RecycleEvent = NULL;\r
IpSecWrap = NULL;\r
FragmentTable = NULL;\r
- TxWrap = (IP4_TXTOKEN_WRAP *) Context;\r
+ TxWrap = (IP4_TXTOKEN_WRAP *)Context;\r
FragmentCount = Packet->BlockOpNum;\r
\r
ZeroMem (&ZeroHead, sizeof (IP4_HEAD));\r
mIpSec,\r
IpSb->Controller,\r
IP_VERSION_4,\r
- (VOID *) (*Head),\r
+ (VOID *)(*Head),\r
&(*Head)->Protocol,\r
- (VOID **) Options,\r
+ (VOID **)Options,\r
OptionsLen,\r
- (EFI_IPSEC_FRAGMENT_DATA **) (&FragmentTable),\r
+ (EFI_IPSEC_FRAGMENT_DATA **)(&FragmentTable),\r
&FragmentCount,\r
Direction,\r
&RecycleEvent\r
goto ON_EXIT;\r
}\r
\r
- if (OriginalFragmentTable == FragmentTable && OriginalFragmentCount == FragmentCount) {\r
+ if ((OriginalFragmentTable == FragmentTable) && (OriginalFragmentCount == FragmentCount)) {\r
//\r
// For ByPass Packet\r
//\r
FreePool (OriginalFragmentTable);\r
}\r
\r
- if (Direction == EfiIPsecOutBound && TxWrap != NULL) {\r
-\r
+ if ((Direction == EfiIPsecOutBound) && (TxWrap != NULL)) {\r
TxWrap->IpSecRecycleSignal = RecycleEvent;\r
TxWrap->Packet = NetbufFromExt (\r
FragmentTable,\r
// the TxWrap.\r
//\r
TxWrap->Packet = *Netbuf;\r
- Status = EFI_OUT_OF_RESOURCES;\r
+ Status = EFI_OUT_OF_RESOURCES;\r
goto ON_EXIT;\r
}\r
\r
//\r
NetIpSecNetbufFree (*Netbuf);\r
*Netbuf = TxWrap->Packet;\r
-\r
} else {\r
-\r
IpSecWrap = AllocateZeroPool (sizeof (IP4_IPSEC_WRAP));\r
\r
if (IpSecWrap == NULL) {\r
goto ON_EXIT;\r
}\r
\r
- if (Direction == EfiIPsecInBound && 0 != CompareMem (*Head, &ZeroHead, sizeof (IP4_HEAD))) {\r
+ if ((Direction == EfiIPsecInBound) && (0 != CompareMem (*Head, &ZeroHead, sizeof (IP4_HEAD)))) {\r
Ip4PrependHead (Packet, *Head, *Options, *OptionsLen);\r
Ip4NtohHead (Packet->Ip.Ip4);\r
NetbufTrim (Packet, ((*Head)->HeadLen << 2), TRUE);\r
sizeof (IP4_CLIP_INFO)\r
);\r
}\r
+\r
*Netbuf = Packet;\r
}\r
\r
**/\r
EFI_STATUS\r
Ip4PreProcessPacket (\r
- IN IP4_SERVICE *IpSb,\r
- IN OUT NET_BUF **Packet,\r
- IN IP4_HEAD *Head,\r
- IN UINT8 *Option,\r
- IN UINT32 OptionLen,\r
- IN UINT32 Flag\r
+ IN IP4_SERVICE *IpSb,\r
+ IN OUT NET_BUF **Packet,\r
+ IN IP4_HEAD *Head,\r
+ IN UINT8 *Option,\r
+ IN UINT32 OptionLen,\r
+ IN UINT32 Flag\r
)\r
{\r
- IP4_CLIP_INFO *Info;\r
- UINT32 HeadLen;\r
- UINT32 TotalLen;\r
- UINT16 Checksum;\r
+ IP4_CLIP_INFO *Info;\r
+ UINT32 HeadLen;\r
+ UINT32 TotalLen;\r
+ UINT16 Checksum;\r
\r
//\r
// Check if the IP4 header is correctly formatted.\r
}\r
\r
if ((Head->Ver != 4) || (HeadLen < IP4_MIN_HEADLEN) ||\r
- (TotalLen < HeadLen) || (TotalLen != (*Packet)->TotalSize)) {\r
+ (TotalLen < HeadLen) || (TotalLen != (*Packet)->TotalSize))\r
+ {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
//\r
// Some OS may send IP packets without checksum.\r
//\r
- Checksum = (UINT16) (~NetblockChecksum ((UINT8 *) Head, HeadLen));\r
+ Checksum = (UINT16)(~NetblockChecksum ((UINT8 *)Head, HeadLen));\r
\r
if ((Head->Checksum != 0) && (Checksum != 0)) {\r
return EFI_INVALID_PARAMETER;\r
//\r
// Convert the IP header to host byte order, then get the per packet info.\r
//\r
- (*Packet)->Ip.Ip4 = Ip4NtohHead (Head);\r
+ (*Packet)->Ip.Ip4 = Ip4NtohHead (Head);\r
\r
- Info = IP4_GET_CLIP_INFO (*Packet);\r
- Info->LinkFlag = Flag;\r
- Info->CastType = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);\r
- Info->Start = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;\r
- Info->Length = Head->TotalLen - HeadLen;\r
- Info->End = Info->Start + Info->Length;\r
- Info->Status = EFI_SUCCESS;\r
+ Info = IP4_GET_CLIP_INFO (*Packet);\r
+ Info->LinkFlag = Flag;\r
+ Info->CastType = Ip4GetHostCast (IpSb, Head->Dst, Head->Src);\r
+ Info->Start = (Head->Fragment & IP4_HEAD_OFFSET_MASK) << 3;\r
+ Info->Length = Head->TotalLen - HeadLen;\r
+ Info->End = Info->Start + Info->Length;\r
+ Info->Status = EFI_SUCCESS;\r
\r
//\r
// The packet is destinated to us if the CastType is non-zero.\r
**/\r
BOOLEAN\r
Ip4IsValidPacketLength (\r
- IN NET_BUF *Packet\r
+ IN NET_BUF *Packet\r
)\r
{\r
//\r
**/\r
VOID\r
Ip4AccpetFrame (\r
- IN IP4_PROTOCOL *Ip4Instance,\r
- IN NET_BUF *Packet,\r
- IN EFI_STATUS IoStatus,\r
- IN UINT32 Flag,\r
- IN VOID *Context\r
+ IN IP4_PROTOCOL *Ip4Instance,\r
+ IN NET_BUF *Packet,\r
+ IN EFI_STATUS IoStatus,\r
+ IN UINT32 Flag,\r
+ IN VOID *Context\r
)\r
{\r
- IP4_SERVICE *IpSb;\r
- IP4_HEAD *Head;\r
- EFI_STATUS Status;\r
- IP4_HEAD ZeroHead;\r
- UINT8 *Option;\r
- UINT32 OptionLen;\r
-\r
- IpSb = (IP4_SERVICE *) Context;\r
+ IP4_SERVICE *IpSb;\r
+ IP4_HEAD *Head;\r
+ EFI_STATUS Status;\r
+ IP4_HEAD ZeroHead;\r
+ UINT8 *Option;\r
+ UINT32 OptionLen;\r
+\r
+ IpSb = (IP4_SERVICE *)Context;\r
Option = NULL;\r
\r
if (EFI_ERROR (IoStatus) || (IpSb->State == IP4_SERVICE_DESTROY)) {\r
goto RESTART;\r
}\r
\r
- Head = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
+ Head = (IP4_HEAD *)NetbufGetByte (Packet, 0, NULL);\r
ASSERT (Head != NULL);\r
OptionLen = (Head->HeadLen << 2) - IP4_MIN_HEADLEN;\r
if (OptionLen > 0) {\r
- Option = (UINT8 *) (Head + 1);\r
+ Option = (UINT8 *)(Head + 1);\r
}\r
\r
//\r
goto RESTART;\r
}\r
\r
- Head = (IP4_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
+ Head = (IP4_HEAD *)NetbufGetByte (Packet, 0, NULL);\r
ASSERT (Head != NULL);\r
Status = Ip4PreProcessPacket (\r
IpSb,\r
}\r
\r
ASSERT (Packet != NULL);\r
- Head = Packet->Ip.Ip4;\r
+ Head = Packet->Ip.Ip4;\r
IP4_GET_CLIP_INFO (Packet)->Status = EFI_SUCCESS;\r
\r
switch (Head->Protocol) {\r
- case EFI_IP_PROTO_ICMP:\r
- Ip4IcmpHandle (IpSb, Head, Packet);\r
- break;\r
+ case EFI_IP_PROTO_ICMP:\r
+ Ip4IcmpHandle (IpSb, Head, Packet);\r
+ break;\r
\r
- case IP4_PROTO_IGMP:\r
- Ip4IgmpHandle (IpSb, Head, Packet);\r
- break;\r
+ case IP4_PROTO_IGMP:\r
+ Ip4IgmpHandle (IpSb, Head, Packet);\r
+ break;\r
\r
- default:\r
- Ip4Demultiplex (IpSb, Head, Packet, Option, OptionLen);\r
+ default:\r
+ Ip4Demultiplex (IpSb, Head, Packet, Option, OptionLen);\r
}\r
\r
Packet = NULL;\r
NetbufFree (Packet);\r
}\r
\r
- return ;\r
+ return;\r
}\r
\r
-\r
/**\r
Check whether this IP child accepts the packet.\r
\r
**/\r
BOOLEAN\r
Ip4InstanceFrameAcceptable (\r
- IN IP4_PROTOCOL *IpInstance,\r
- IN IP4_HEAD *Head,\r
- IN NET_BUF *Packet\r
+ IN IP4_PROTOCOL *IpInstance,\r
+ IN IP4_HEAD *Head,\r
+ IN NET_BUF *Packet\r
)\r
{\r
- IP4_ICMP_ERROR_HEAD Icmp;\r
- EFI_IP4_CONFIG_DATA *Config;\r
- IP4_CLIP_INFO *Info;\r
- UINT16 Proto;\r
- UINT32 Index;\r
+ IP4_ICMP_ERROR_HEAD Icmp;\r
+ EFI_IP4_CONFIG_DATA *Config;\r
+ IP4_CLIP_INFO *Info;\r
+ UINT16 Proto;\r
+ UINT32 Index;\r
\r
Config = &IpInstance->ConfigData;\r
\r
Proto = Head->Protocol;\r
\r
if ((Proto == EFI_IP_PROTO_ICMP) && (!Config->AcceptAnyProtocol) && (Proto != Config->DefaultProtocol)) {\r
- NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *) &Icmp.Head);\r
+ NetbufCopy (Packet, 0, sizeof (Icmp.Head), (UINT8 *)&Icmp.Head);\r
\r
if (mIcmpClass[Icmp.Head.Type].IcmpClass == ICMP_ERROR_MESSAGE) {\r
if (!Config->AcceptIcmpErrors) {\r
return FALSE;\r
}\r
\r
- NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *) &Icmp);\r
+ NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);\r
Proto = Icmp.IpHead.Protocol;\r
}\r
}\r
return TRUE;\r
}\r
\r
-\r
/**\r
Enqueue a shared copy of the packet to the IP4 child if the\r
packet is acceptable to it. Here the data of the packet is\r
**/\r
EFI_STATUS\r
Ip4InstanceEnquePacket (\r
- IN IP4_PROTOCOL *IpInstance,\r
- IN IP4_HEAD *Head,\r
- IN NET_BUF *Packet\r
+ IN IP4_PROTOCOL *IpInstance,\r
+ IN IP4_HEAD *Head,\r
+ IN NET_BUF *Packet\r
)\r
{\r
- IP4_CLIP_INFO *Info;\r
- NET_BUF *Clone;\r
+ IP4_CLIP_INFO *Info;\r
+ NET_BUF *Clone;\r
\r
//\r
// Check whether the packet is acceptable to this instance.\r
// Set the receive time out for the assembled packet. If it expires,\r
// packet will be removed from the queue.\r
//\r
- Info = IP4_GET_CLIP_INFO (Clone);\r
- Info->Life = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);\r
+ Info = IP4_GET_CLIP_INFO (Clone);\r
+ Info->Life = IP4_US_TO_SEC (IpInstance->ConfigData.ReceiveTimeout);\r
\r
InsertTailList (&IpInstance->Received, &Clone->List);\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
The signal handle of IP4's recycle event. It is called back\r
when the upper layer release the packet.\r
VOID\r
EFIAPI\r
Ip4OnRecyclePacket (\r
- IN EFI_EVENT Event,\r
- IN VOID *Context\r
+ IN EFI_EVENT Event,\r
+ IN VOID *Context\r
)\r
{\r
- IP4_RXDATA_WRAP *Wrap;\r
+ IP4_RXDATA_WRAP *Wrap;\r
\r
- Wrap = (IP4_RXDATA_WRAP *) Context;\r
+ Wrap = (IP4_RXDATA_WRAP *)Context;\r
\r
EfiAcquireLockOrFail (&Wrap->IpInstance->RecycleLock);\r
RemoveEntryList (&Wrap->Link);\r
FreePool (Wrap);\r
}\r
\r
-\r
/**\r
Wrap the received packet to a IP4_RXDATA_WRAP, which will be\r
delivered to the upper layer. Each IP4 child that accepts the\r
**/\r
IP4_RXDATA_WRAP *\r
Ip4WrapRxData (\r
- IN IP4_PROTOCOL *IpInstance,\r
- IN NET_BUF *Packet\r
+ IN IP4_PROTOCOL *IpInstance,\r
+ IN NET_BUF *Packet\r
)\r
{\r
- IP4_RXDATA_WRAP *Wrap;\r
- EFI_IP4_RECEIVE_DATA *RxData;\r
- EFI_STATUS Status;\r
- BOOLEAN RawData;\r
+ IP4_RXDATA_WRAP *Wrap;\r
+ EFI_IP4_RECEIVE_DATA *RxData;\r
+ EFI_STATUS Status;\r
+ BOOLEAN RawData;\r
\r
Wrap = AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet->BlockOpNum));\r
\r
\r
InitializeListHead (&Wrap->Link);\r
\r
- Wrap->IpInstance = IpInstance;\r
- Wrap->Packet = Packet;\r
- RxData = &Wrap->RxData;\r
+ Wrap->IpInstance = IpInstance;\r
+ Wrap->Packet = Packet;\r
+ RxData = &Wrap->RxData;\r
\r
ZeroMem (RxData, sizeof (EFI_IP4_RECEIVE_DATA));\r
\r
//\r
if (!RawData) {\r
RxData->HeaderLength = (Packet->Ip.Ip4->HeadLen << 2);\r
- RxData->Header = (EFI_IP4_HEADER *) Ip4NtohHead (Packet->Ip.Ip4);\r
+ RxData->Header = (EFI_IP4_HEADER *)Ip4NtohHead (Packet->Ip.Ip4);\r
RxData->OptionsLength = RxData->HeaderLength - IP4_MIN_HEADLEN;\r
RxData->Options = NULL;\r
\r
if (RxData->OptionsLength != 0) {\r
- RxData->Options = (VOID *) (RxData->Header + 1);\r
+ RxData->Options = (VOID *)(RxData->Header + 1);\r
}\r
}\r
\r
- RxData->DataLength = Packet->TotalSize;\r
+ RxData->DataLength = Packet->TotalSize;\r
\r
//\r
// Build the fragment table to be delivered up.\r
//\r
RxData->FragmentCount = Packet->BlockOpNum;\r
- NetbufBuildExt (Packet, (NET_FRAGMENT *) RxData->FragmentTable, &RxData->FragmentCount);\r
+ NetbufBuildExt (Packet, (NET_FRAGMENT *)RxData->FragmentTable, &RxData->FragmentCount);\r
\r
return Wrap;\r
}\r
\r
-\r
/**\r
Deliver the received packets to upper layer if there are both received\r
requests and enqueued packets. If the enqueued packet is shared, it will\r
**/\r
EFI_STATUS\r
Ip4InstanceDeliverPacket (\r
- IN IP4_PROTOCOL *IpInstance\r
+ IN IP4_PROTOCOL *IpInstance\r
)\r
{\r
EFI_IP4_COMPLETION_TOKEN *Token;\r
// Deliver a packet if there are both a packet and a receive token.\r
//\r
while (!IsListEmpty (&IpInstance->Received) &&\r
- !NetMapIsEmpty (&IpInstance->RxTokens)) {\r
-\r
+ !NetMapIsEmpty (&IpInstance->RxTokens))\r
+ {\r
Packet = NET_LIST_HEAD (&IpInstance->Received, NET_BUF, List);\r
\r
if (!NET_BUF_SHARED (Packet)) {\r
}\r
\r
RemoveEntryList (&Packet->List);\r
-\r
} else {\r
//\r
// Create a duplicated packet if this packet is shared\r
Head = NetbufAllocSpace (Dup, IP4_MAX_HEADLEN, NET_BUF_HEAD);\r
ASSERT (Head != NULL);\r
\r
- Dup->Ip.Ip4 = (IP4_HEAD *) Head;\r
+ Dup->Ip.Ip4 = (IP4_HEAD *)Head;\r
\r
CopyMem (Head, Packet->Ip.Ip4, Packet->Ip.Ip4->HeadLen << 2);\r
NetbufTrim (Dup, IP4_MAX_HEADLEN, TRUE);\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Enqueue a received packet to all the IP children that share\r
the same interface.\r
**/\r
INTN\r
Ip4InterfaceEnquePacket (\r
- IN IP4_SERVICE *IpSb,\r
- IN IP4_HEAD *Head,\r
- IN NET_BUF *Packet,\r
- IN UINT8 *Option,\r
- IN UINT32 OptionLen,\r
- IN IP4_INTERFACE *IpIf\r
+ IN IP4_SERVICE *IpSb,\r
+ IN IP4_HEAD *Head,\r
+ IN NET_BUF *Packet,\r
+ IN UINT8 *Option,\r
+ IN UINT32 OptionLen,\r
+ IN IP4_INTERFACE *IpIf\r
)\r
{\r
- IP4_PROTOCOL *IpInstance;\r
- IP4_CLIP_INFO *Info;\r
- LIST_ENTRY *Entry;\r
- INTN Enqueued;\r
- INTN LocalType;\r
- INTN SavedType;\r
+ IP4_PROTOCOL *IpInstance;\r
+ IP4_CLIP_INFO *Info;\r
+ LIST_ENTRY *Entry;\r
+ INTN Enqueued;\r
+ INTN LocalType;\r
+ INTN SavedType;\r
\r
//\r
// First, check that the packet is acceptable to this interface\r
// that later.\r
//\r
LocalType = Info->CastType;\r
-\r
} else {\r
//\r
// Check the destination against local IP. If the station\r
//\r
if (IpIf->Ip == IP4_ALLZERO_ADDRESS) {\r
LocalType = IP4_LOCAL_HOST;\r
-\r
} else {\r
LocalType = Ip4GetNetCast (Head->Dst, IpIf);\r
\r
// and pass the local cast type to the IP children on the\r
// interface. The global cast type will be restored later.\r
//\r
- SavedType = Info->CastType;\r
- Info->CastType = LocalType;\r
+ SavedType = Info->CastType;\r
+ Info->CastType = LocalType;\r
\r
- Enqueued = 0;\r
+ Enqueued = 0;\r
\r
NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {\r
IpInstance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);\r
//\r
// In RawData mode, add IPv4 headers and options back to packet.\r
//\r
- if ((IpInstance->ConfigData.RawData) && (Option != NULL) && (OptionLen != 0)){\r
+ if ((IpInstance->ConfigData.RawData) && (Option != NULL) && (OptionLen != 0)) {\r
Ip4PrependHead (Packet, Head, Option, OptionLen);\r
}\r
\r
return Enqueued;\r
}\r
\r
-\r
/**\r
Deliver the packet for each IP4 child on the interface.\r
\r
**/\r
EFI_STATUS\r
Ip4InterfaceDeliverPacket (\r
- IN IP4_SERVICE *IpSb,\r
- IN IP4_INTERFACE *IpIf\r
+ IN IP4_SERVICE *IpSb,\r
+ IN IP4_INTERFACE *IpIf\r
)\r
{\r
- IP4_PROTOCOL *Ip4Instance;\r
- LIST_ENTRY *Entry;\r
+ IP4_PROTOCOL *Ip4Instance;\r
+ LIST_ENTRY *Entry;\r
\r
NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {\r
Ip4Instance = NET_LIST_USER_STRUCT (Entry, IP4_PROTOCOL, AddrLink);\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Demultiple the packet. the packet delivery is processed in two\r
passes. The first pass will enqueue a shared copy of the packet\r
**/\r
EFI_STATUS\r
Ip4Demultiplex (\r
- IN IP4_SERVICE *IpSb,\r
- IN IP4_HEAD *Head,\r
- IN NET_BUF *Packet,\r
- IN UINT8 *Option,\r
- IN UINT32 OptionLen\r
+ IN IP4_SERVICE *IpSb,\r
+ IN IP4_HEAD *Head,\r
+ IN NET_BUF *Packet,\r
+ IN UINT8 *Option,\r
+ IN UINT32 OptionLen\r
)\r
{\r
- LIST_ENTRY *Entry;\r
- IP4_INTERFACE *IpIf;\r
- INTN Enqueued;\r
+ LIST_ENTRY *Entry;\r
+ IP4_INTERFACE *IpIf;\r
+ INTN Enqueued;\r
\r
//\r
// Two pass delivery: first, enqueue a shared copy of the packet\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Timeout the fragment and enqueued packets.\r
\r
**/\r
VOID\r
Ip4PacketTimerTicking (\r
- IN IP4_SERVICE *IpSb\r
+ IN IP4_SERVICE *IpSb\r
)\r
{\r
- LIST_ENTRY *InstanceEntry;\r
- LIST_ENTRY *Entry;\r
- LIST_ENTRY *Next;\r
- IP4_PROTOCOL *IpInstance;\r
- IP4_ASSEMBLE_ENTRY *Assemble;\r
- NET_BUF *Packet;\r
- IP4_CLIP_INFO *Info;\r
- UINT32 Index;\r
+ LIST_ENTRY *InstanceEntry;\r
+ LIST_ENTRY *Entry;\r
+ LIST_ENTRY *Next;\r
+ IP4_PROTOCOL *IpInstance;\r
+ IP4_ASSEMBLE_ENTRY *Assemble;\r
+ NET_BUF *Packet;\r
+ IP4_CLIP_INFO *Info;\r
+ UINT32 Index;\r
\r
//\r
// First, time out the fragments. The packet's life is counting down\r
projects / mirror_edk2.git / blobdiff