4 Copyright (c) 2005 - 2010, Intel Corporation.<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 Create an empty assemble entry for the packet identified by
20 (Dst, Src, Id, Protocol). The default life for the packet is
23 @param[in] Dst The destination address
24 @param[in] Src The source address
25 @param[in] Id The ID field in IP header
26 @param[in] Protocol The protocol field in IP header
28 @return NULL if failed to allocate memory for the entry, otherwise
29 the point to just created reassemble entry.
33 Ip4CreateAssembleEntry (
41 IP4_ASSEMBLE_ENTRY
*Assemble
;
43 Assemble
= AllocatePool (sizeof (IP4_ASSEMBLE_ENTRY
));
45 if (Assemble
== NULL
) {
49 InitializeListHead (&Assemble
->Link
);
50 InitializeListHead (&Assemble
->Fragments
);
55 Assemble
->Protocol
= Protocol
;
56 Assemble
->TotalLen
= 0;
58 Assemble
->Head
= NULL
;
59 Assemble
->Info
= NULL
;
60 Assemble
->Life
= IP4_FRAGMENT_LIFE
;
67 Release all the fragments of a packet, then free the assemble entry.
69 @param[in] Assemble The assemble entry to free
73 Ip4FreeAssembleEntry (
74 IN IP4_ASSEMBLE_ENTRY
*Assemble
81 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Assemble
->Fragments
) {
82 Fragment
= NET_LIST_USER_STRUCT (Entry
, NET_BUF
, List
);
84 RemoveEntryList (Entry
);
85 NetbufFree (Fragment
);
93 Initialize an already allocated assemble table. This is generally
94 the assemble table embedded in the IP4 service instance.
96 @param[in, out] Table The assemble table to initialize.
100 Ip4InitAssembleTable (
101 IN OUT IP4_ASSEMBLE_TABLE
*Table
106 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
107 InitializeListHead (&Table
->Bucket
[Index
]);
113 Clean up the assemble table: remove all the fragments
114 and assemble entries.
116 @param[in] Table The assemble table to clean up
120 Ip4CleanAssembleTable (
121 IN IP4_ASSEMBLE_TABLE
*Table
126 IP4_ASSEMBLE_ENTRY
*Assemble
;
129 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
130 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Table
->Bucket
[Index
]) {
131 Assemble
= NET_LIST_USER_STRUCT (Entry
, IP4_ASSEMBLE_ENTRY
, Link
);
133 RemoveEntryList (Entry
);
134 Ip4FreeAssembleEntry (Assemble
);
141 Trim the packet to fit in [Start, End), and update the per
144 @param Packet Packet to trim
145 @param Start The sequence of the first byte to fit in
146 @param End One beyond the sequence of last byte to fit in.
151 IN OUT NET_BUF
*Packet
,
159 Info
= IP4_GET_CLIP_INFO (Packet
);
161 ASSERT (Info
->Start
+ Info
->Length
== Info
->End
);
162 ASSERT ((Info
->Start
< End
) && (Start
< Info
->End
));
164 if (Info
->Start
< Start
) {
165 Len
= Start
- Info
->Start
;
167 NetbufTrim (Packet
, (UINT32
) Len
, NET_BUF_HEAD
);
172 if (End
< Info
->End
) {
173 Len
= End
- Info
->End
;
175 NetbufTrim (Packet
, (UINT32
) Len
, NET_BUF_TAIL
);
183 Release all the fragments of the packet. This is the callback for
184 the assembled packet's OnFree. It will free the assemble entry,
185 which in turn will free all the fragments of the packet.
187 @param[in] Arg The assemble entry to free
196 Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY
*) Arg
);
201 Reassemble the IP fragments. If all the fragments of the packet
202 have been received, it will wrap the packet in a net buffer then
203 return it to caller. If the packet can't be assembled, NULL is
206 @param Table The assemble table used. New assemble entry will be created
207 if the Packet is from a new chain of fragments.
208 @param Packet The fragment to assemble. It might be freed if the fragment
209 can't be re-assembled.
211 @return NULL if the packet can't be reassemble. The point to just assembled
212 packet if all the fragments of the packet have arrived.
217 IN OUT IP4_ASSEMBLE_TABLE
*Table
,
218 IN OUT NET_BUF
*Packet
224 IP4_ASSEMBLE_ENTRY
*Assemble
;
232 IpHead
= Packet
->Ip
.Ip4
;
233 This
= IP4_GET_CLIP_INFO (Packet
);
235 ASSERT (IpHead
!= NULL
);
238 // First: find the related assemble entry
241 Index
= IP4_ASSEMBLE_HASH (IpHead
->Dst
, IpHead
->Src
, IpHead
->Id
, IpHead
->Protocol
);
243 NET_LIST_FOR_EACH (Cur
, &Table
->Bucket
[Index
]) {
244 Assemble
= NET_LIST_USER_STRUCT (Cur
, IP4_ASSEMBLE_ENTRY
, Link
);
246 if ((Assemble
->Dst
== IpHead
->Dst
) && (Assemble
->Src
== IpHead
->Src
) &&
247 (Assemble
->Id
== IpHead
->Id
) && (Assemble
->Protocol
== IpHead
->Protocol
)) {
253 // Create a new assemble entry if no assemble entry is related to this packet
255 if (Cur
== &Table
->Bucket
[Index
]) {
256 Assemble
= Ip4CreateAssembleEntry (
263 if (Assemble
== NULL
) {
267 InsertHeadList (&Table
->Bucket
[Index
], &Assemble
->Link
);
270 // Assemble shouldn't be NULL here
272 ASSERT (Assemble
!= NULL
);
275 // Find the point to insert the packet: before the first
276 // fragment with THIS.Start < CUR.Start. the previous one
277 // has PREV.Start <= THIS.Start < CUR.Start.
279 Head
= &Assemble
->Fragments
;
281 NET_LIST_FOR_EACH (Cur
, Head
) {
282 Fragment
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
284 if (This
->Start
< IP4_GET_CLIP_INFO (Fragment
)->Start
) {
290 // Check whether the current fragment overlaps with the previous one.
291 // It holds that: PREV.Start <= THIS.Start < THIS.End. Only need to
292 // check whether THIS.Start < PREV.End for overlap. If two fragments
293 // overlaps, trim the overlapped part off THIS fragment.
295 if ((Prev
= Cur
->ForwardLink
) != Head
) {
296 Fragment
= NET_LIST_USER_STRUCT (Prev
, NET_BUF
, List
);
297 Node
= IP4_GET_CLIP_INFO (Fragment
);
299 if (This
->Start
< Node
->End
) {
300 if (This
->End
<= Node
->End
) {
305 Ip4TrimPacket (Packet
, Node
->End
, This
->End
);
310 // Insert the fragment into the packet. The fragment may be removed
311 // from the list by the following checks.
313 NetListInsertBefore (Cur
, &Packet
->List
);
316 // Check the packets after the insert point. It holds that:
317 // THIS.Start <= NODE.Start < NODE.End. The equality holds
318 // if PREV and NEXT are continuous. THIS fragment may fill
319 // several holes. Remove the completely overlapped fragments
321 while (Cur
!= Head
) {
322 Fragment
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
323 Node
= IP4_GET_CLIP_INFO (Fragment
);
326 // Remove fragments completely overlapped by this fragment
328 if (Node
->End
<= This
->End
) {
329 Cur
= Cur
->ForwardLink
;
331 RemoveEntryList (&Fragment
->List
);
332 Assemble
->CurLen
-= Node
->Length
;
334 NetbufFree (Fragment
);
339 // The conditions are: THIS.Start <= NODE.Start, and THIS.End <
340 // NODE.End. Two fragments overlaps if NODE.Start < THIS.End.
341 // If two fragments start at the same offset, remove THIS fragment
342 // because ((THIS.Start == NODE.Start) && (THIS.End < NODE.End)).
344 if (Node
->Start
< This
->End
) {
345 if (This
->Start
== Node
->Start
) {
346 RemoveEntryList (&Packet
->List
);
350 Ip4TrimPacket (Packet
, This
->Start
, Node
->Start
);
357 // Update the assemble info: increase the current length. If it is
358 // the frist fragment, update the packet's IP head and per packet
359 // info. If it is the last fragment, update the total length.
361 Assemble
->CurLen
+= This
->Length
;
363 if (This
->Start
== 0) {
365 // Once the first fragment is enqueued, it can't be removed
366 // from the fragment list. So, Assemble->Head always point
367 // to valid memory area.
369 ASSERT (Assemble
->Head
== NULL
);
371 Assemble
->Head
= IpHead
;
372 Assemble
->Info
= IP4_GET_CLIP_INFO (Packet
);
376 // Don't update the length more than once.
378 if (IP4_LAST_FRAGMENT (IpHead
->Fragment
) && (Assemble
->TotalLen
== 0)) {
379 Assemble
->TotalLen
= This
->End
;
383 // Deliver the whole packet if all the fragments received.
384 // All fragments received if:
385 // 1. received the last one, so, the total length is know
386 // 2. received all the data. If the last fragment on the
387 // queue ends at the total length, all data is received.
389 if ((Assemble
->TotalLen
!= 0) && (Assemble
->CurLen
>= Assemble
->TotalLen
)) {
391 RemoveEntryList (&Assemble
->Link
);
394 // If the packet is properly formated, the last fragment's End
395 // equals to the packet's total length. Otherwise, the packet
396 // is a fake, drop it now.
398 Fragment
= NET_LIST_USER_STRUCT (Head
->BackLink
, NET_BUF
, List
);
400 if (IP4_GET_CLIP_INFO (Fragment
)->End
!= Assemble
->TotalLen
) {
401 Ip4FreeAssembleEntry (Assemble
);
406 // Wrap the packet in a net buffer then deliver it up
408 NewPacket
= NetbufFromBufList (
409 &Assemble
->Fragments
,
416 if (NewPacket
== NULL
) {
417 Ip4FreeAssembleEntry (Assemble
);
421 NewPacket
->Ip
.Ip4
= Assemble
->Head
;
422 CopyMem (IP4_GET_CLIP_INFO (NewPacket
), Assemble
->Info
, sizeof (*IP4_GET_CLIP_INFO (NewPacket
)));
434 The callback function for the net buffer which wraps the packet processed by
435 IPsec. It releases the wrap packet and also signals IPsec to free the resources.
437 @param[in] Arg The wrap context
446 IP4_IPSEC_WRAP
*Wrap
;
448 Wrap
= (IP4_IPSEC_WRAP
*) Arg
;
450 if (Wrap
->IpSecRecycleSignal
!= NULL
) {
451 gBS
->SignalEvent (Wrap
->IpSecRecycleSignal
);
454 NetbufFree (Wrap
->Packet
);
462 The work function to locate IPsec protocol to process the inbound or
463 outbound IP packets. The process routine handls the packet with following
464 actions: bypass the packet, discard the packet, or protect the packet.
466 @param[in] IpSb The IP4 service instance
467 @param[in] Head The The caller supplied IP4 header.
468 @param[in, out] Netbuf The IP4 packet to be processed by IPsec
469 @param[in] Options The caller supplied options
470 @param[in] OptionsLen The length of the option
471 @param[in] Direction The directionality in an SPD entry,
472 EfiIPsecInBound or EfiIPsecOutBound
473 @param[in] Context The token's wrap
475 @retval EFI_SUCCESS The IPsec protocol is not available or disabled.
476 @retval EFI_SUCCESS The packet was bypassed and all buffers remain the same.
477 @retval EFI_SUCCESS The packet was protected.
478 @retval EFI_ACCESS_DENIED The packet was discarded.
479 @retval EFI_OUT_OF_RESOURCES There is no suffcient resource to complete the operation.
480 @retval EFI_BUFFER_TOO_SMALL The number of non-empty block is bigger than the
481 number of input data blocks when build a fragment table.
485 Ip4IpSecProcessPacket (
486 IN IP4_SERVICE
*IpSb
,
488 IN OUT NET_BUF
**Netbuf
,
490 IN UINT32 OptionsLen
,
491 IN EFI_IPSEC_TRAFFIC_DIR Direction
,
495 NET_FRAGMENT
*FragmentTable
;
496 UINT32 FragmentCount
;
497 EFI_EVENT RecycleEvent
;
499 IP4_TXTOKEN_WRAP
*TxWrap
;
500 IP4_IPSEC_WRAP
*IpSecWrap
;
503 Status
= EFI_SUCCESS
;
507 FragmentTable
= NULL
;
508 TxWrap
= (IP4_TXTOKEN_WRAP
*) Context
;
509 FragmentCount
= Packet
->BlockOpNum
;
511 if (mIpSec
== NULL
) {
512 gBS
->LocateProtocol (&gEfiIpSecProtocolGuid
, NULL
, (VOID
**) &mIpSec
);
513 if (mIpSec
!= NULL
) {
515 // Save the original MTU
517 IpSb
->OldMaxPacketSize
= IpSb
->MaxPacketSize
;
522 // Check whether the IPsec protocol is available.
524 if (mIpSec
== NULL
) {
528 // Check whether the IPsec enable variable is set.
530 if (mIpSec
->DisabledFlag
) {
532 // If IPsec is disabled, restore the original MTU
534 IpSb
->MaxPacketSize
= IpSb
->OldMaxPacketSize
;
538 // If IPsec is enabled, use the MTU which reduce the IPsec header length.
540 IpSb
->MaxPacketSize
= IpSb
->OldMaxPacketSize
- IP4_MAX_IPSEC_HEADLEN
;
544 // Rebuild fragment table from netbuf to ease IPsec process.
546 FragmentTable
= AllocateZeroPool (FragmentCount
* sizeof (NET_FRAGMENT
));
548 if (FragmentTable
== NULL
) {
549 Status
= EFI_OUT_OF_RESOURCES
;
553 Status
= NetbufBuildExt (Packet
, FragmentTable
, &FragmentCount
);
555 if (EFI_ERROR (Status
)) {
556 FreePool (FragmentTable
);
561 // Convert host byte order to network byte order
565 Status
= mIpSec
->Process (
573 (EFI_IPSEC_FRAGMENT_DATA
**) (&FragmentTable
),
579 // Convert back to host byte order
583 if (EFI_ERROR (Status
)) {
587 if (Direction
== EfiIPsecOutBound
&& TxWrap
!= NULL
) {
589 TxWrap
->IpSecRecycleSignal
= RecycleEvent
;
590 TxWrap
->Packet
= NetbufFromExt (
598 if (TxWrap
->Packet
== NULL
) {
599 Status
= EFI_OUT_OF_RESOURCES
;
603 *Netbuf
= TxWrap
->Packet
;
607 IpSecWrap
= AllocateZeroPool (sizeof (IP4_IPSEC_WRAP
));
609 if (IpSecWrap
== NULL
) {
613 IpSecWrap
->IpSecRecycleSignal
= RecycleEvent
;
614 IpSecWrap
->Packet
= Packet
;
615 Packet
= NetbufFromExt (
624 if (Packet
== NULL
) {
625 Status
= EFI_OUT_OF_RESOURCES
;
629 if (Direction
== EfiIPsecInBound
) {
630 Ip4PrependHead (Packet
, Head
, Options
, OptionsLen
);
631 Ip4NtohHead (Packet
->Ip
.Ip4
);
632 NetbufTrim (Packet
, (Head
->HeadLen
<< 2), TRUE
);
635 IP4_GET_CLIP_INFO (Packet
),
636 IP4_GET_CLIP_INFO (IpSecWrap
->Packet
),
637 sizeof (IP4_CLIP_INFO
)
649 The IP4 input routine. It is called by the IP4_INTERFACE when a
650 IP4 fragment is received from MNP.
652 @param[in] Ip4Instance The IP4 child that request the receive, most like
654 @param[in] Packet The IP4 packet received.
655 @param[in] IoStatus The return status of receive request.
656 @param[in] Flag The link layer flag for the packet received, such
658 @param[in] Context The IP4 service instance that own the MNP.
663 IN IP4_PROTOCOL
*Ip4Instance
,
665 IN EFI_STATUS IoStatus
,
679 IpSb
= (IP4_SERVICE
*) Context
;
681 if (EFI_ERROR (IoStatus
) || (IpSb
->State
== IP4_SERVICE_DESTORY
)) {
686 // Check that the IP4 header is correctly formatted
688 if (Packet
->TotalSize
< IP4_MIN_HEADLEN
) {
692 Head
= (IP4_HEAD
*) NetbufGetByte (Packet
, 0, NULL
);
693 HeadLen
= (Head
->HeadLen
<< 2);
694 TotalLen
= NTOHS (Head
->TotalLen
);
697 // Mnp may deliver frame trailer sequence up, trim it off.
699 if (TotalLen
< Packet
->TotalSize
) {
700 NetbufTrim (Packet
, Packet
->TotalSize
- TotalLen
, FALSE
);
703 if ((Head
->Ver
!= 4) || (HeadLen
< IP4_MIN_HEADLEN
) ||
704 (TotalLen
< HeadLen
) || (TotalLen
!= Packet
->TotalSize
)) {
709 // Some OS may send IP packets without checksum.
711 Checksum
= (UINT16
) (~NetblockChecksum ((UINT8
*) Head
, HeadLen
));
713 if ((Head
->Checksum
!= 0) && (Checksum
!= 0)) {
718 // Convert the IP header to host byte order, then get the per packet info.
720 Packet
->Ip
.Ip4
= Ip4NtohHead (Head
);
722 Info
= IP4_GET_CLIP_INFO (Packet
);
723 Info
->LinkFlag
= Flag
;
724 Info
->CastType
= Ip4GetHostCast (IpSb
, Head
->Dst
, Head
->Src
);
725 Info
->Start
= (Head
->Fragment
& IP4_HEAD_OFFSET_MASK
) << 3;
726 Info
->Length
= Head
->TotalLen
- HeadLen
;
727 Info
->End
= Info
->Start
+ Info
->Length
;
728 Info
->Status
= EFI_SUCCESS
;
731 // The packet is destinated to us if the CastType is non-zero.
733 if ((Info
->CastType
== 0) || (Info
->End
> IP4_MAX_PACKET_SIZE
)) {
738 // Validate the options. Don't call the Ip4OptionIsValid if
739 // there is no option to save some CPU process.
741 OptionLen
= HeadLen
- IP4_MIN_HEADLEN
;
743 if ((OptionLen
> 0) && !Ip4OptionIsValid ((UINT8
*) (Head
+ 1), OptionLen
, TRUE
)) {
748 // Trim the head off, after this point, the packet is headless.
749 // and Packet->TotalLen == Info->Length.
751 NetbufTrim (Packet
, HeadLen
, TRUE
);
754 // Reassemble the packet if this is a fragment. The packet is a
755 // fragment if its head has MF (more fragment) set, or it starts
758 if (((Head
->Fragment
& IP4_HEAD_MF_MASK
) != 0) || (Info
->Start
!= 0)) {
760 // Drop the fragment if DF is set but it is fragmented. Gateway
761 // need to send a type 4 destination unreache ICMP message here.
763 if ((Head
->Fragment
& IP4_HEAD_DF_MASK
) != 0) {
768 // The length of all but the last fragments is in the unit of 8 bytes.
770 if (((Head
->Fragment
& IP4_HEAD_MF_MASK
) != 0) && (Info
->Length
% 8 != 0)) {
774 Packet
= Ip4Reassemble (&IpSb
->Assemble
, Packet
);
777 // Packet assembly isn't complete, start receive more packet.
779 if (Packet
== NULL
) {
785 // After trim off, the packet is a esp/ah/udp/tcp/icmp6 net buffer,
786 // and no need consider any other ahead ext headers.
788 Status
= Ip4IpSecProcessPacket (
798 if (EFI_ERROR(Status
)) {
801 // Packet may have been changed. Head, HeadLen, TotalLen, and
802 // info must be reloaded bofore use. The ownership of the packet
803 // is transfered to the packet process logic.
805 Head
= Packet
->Ip
.Ip4
;
806 IP4_GET_CLIP_INFO (Packet
)->Status
= EFI_SUCCESS
;
808 switch (Head
->Protocol
) {
809 case EFI_IP_PROTO_ICMP
:
810 Ip4IcmpHandle (IpSb
, Head
, Packet
);
814 Ip4IgmpHandle (IpSb
, Head
, Packet
);
818 Ip4Demultiplex (IpSb
, Head
, Packet
);
824 // Dispatch the DPCs queued by the NotifyFunction of the rx token's events
825 // which are signaled with received data.
830 Ip4ReceiveFrame (IpSb
->DefaultInterface
, NULL
, Ip4AccpetFrame
, IpSb
);
833 if (Packet
!= NULL
) {
842 Check whether this IP child accepts the packet.
844 @param[in] IpInstance The IP child to check
845 @param[in] Head The IP header of the packet
846 @param[in] Packet The data of the packet
848 @retval TRUE If the child wants to receive the packet.
849 @retval FALSE Otherwise.
853 Ip4InstanceFrameAcceptable (
854 IN IP4_PROTOCOL
*IpInstance
,
859 IP4_ICMP_ERROR_HEAD Icmp
;
860 EFI_IP4_CONFIG_DATA
*Config
;
865 Config
= &IpInstance
->ConfigData
;
868 // Dirty trick for the Tiano UEFI network stack implmentation. If
869 // ReceiveTimeout == -1, the receive of the packet for this instance
870 // is disabled. The UEFI spec don't have such capability. We add
871 // this to improve the performance because IP will make a copy of
872 // the received packet for each accepting instance. Some IP instances
873 // used by UDP/TCP only send packets, they don't wants to receive.
875 if (Config
->ReceiveTimeout
== (UINT32
)(-1)) {
879 if (Config
->AcceptPromiscuous
) {
884 // Use protocol from the IP header embedded in the ICMP error
885 // message to filter, instead of ICMP itself. ICMP handle will
886 // call Ip4Demultiplex to deliver ICMP errors.
888 Proto
= Head
->Protocol
;
890 if ((Proto
== EFI_IP_PROTO_ICMP
) && (!Config
->AcceptAnyProtocol
) && (Proto
!= Config
->DefaultProtocol
)) {
891 NetbufCopy (Packet
, 0, sizeof (Icmp
.Head
), (UINT8
*) &Icmp
.Head
);
893 if (mIcmpClass
[Icmp
.Head
.Type
].IcmpClass
== ICMP_ERROR_MESSAGE
) {
894 if (!Config
->AcceptIcmpErrors
) {
898 NetbufCopy (Packet
, 0, sizeof (Icmp
), (UINT8
*) &Icmp
);
899 Proto
= Icmp
.IpHead
.Protocol
;
904 // Match the protocol
906 if (!Config
->AcceptAnyProtocol
&& (Proto
!= Config
->DefaultProtocol
)) {
911 // Check for broadcast, the caller has computed the packet's
912 // cast type for this child's interface.
914 Info
= IP4_GET_CLIP_INFO (Packet
);
916 if (IP4_IS_BROADCAST (Info
->CastType
)) {
917 return Config
->AcceptBroadcast
;
921 // If it is a multicast packet, check whether we are in the group.
923 if (Info
->CastType
== IP4_MULTICAST
) {
925 // Receive the multicast if the instance wants to receive all packets.
927 if (!IpInstance
->ConfigData
.UseDefaultAddress
&& (IpInstance
->Interface
->Ip
== 0)) {
931 for (Index
= 0; Index
< IpInstance
->GroupCount
; Index
++) {
932 if (IpInstance
->Groups
[Index
] == HTONL (Head
->Dst
)) {
937 return (BOOLEAN
)(Index
< IpInstance
->GroupCount
);
945 Enqueue a shared copy of the packet to the IP4 child if the
946 packet is acceptable to it. Here the data of the packet is
947 shared, but the net buffer isn't.
949 @param[in] IpInstance The IP4 child to enqueue the packet to
950 @param[in] Head The IP header of the received packet
951 @param[in] Packet The data of the received packet
953 @retval EFI_NOT_STARTED The IP child hasn't been configured.
954 @retval EFI_INVALID_PARAMETER The child doesn't want to receive the packet
955 @retval EFI_OUT_OF_RESOURCES Failed to allocate some resource
956 @retval EFI_SUCCESS A shared copy the packet is enqueued to the child.
960 Ip4InstanceEnquePacket (
961 IN IP4_PROTOCOL
*IpInstance
,
970 // Check whether the packet is acceptable to this instance.
972 if (IpInstance
->State
!= IP4_STATE_CONFIGED
) {
973 return EFI_NOT_STARTED
;
976 if (!Ip4InstanceFrameAcceptable (IpInstance
, Head
, Packet
)) {
977 return EFI_INVALID_PARAMETER
;
981 // Enque a shared copy of the packet.
983 Clone
= NetbufClone (Packet
);
986 return EFI_OUT_OF_RESOURCES
;
990 // Set the receive time out for the assembled packet. If it expires,
991 // packet will be removed from the queue.
993 Info
= IP4_GET_CLIP_INFO (Clone
);
994 Info
->Life
= IP4_US_TO_SEC (IpInstance
->ConfigData
.ReceiveTimeout
);
996 InsertTailList (&IpInstance
->Received
, &Clone
->List
);
1002 The signal handle of IP4's recycle event. It is called back
1003 when the upper layer release the packet.
1005 @param Event The IP4's recycle event.
1006 @param Context The context of the handle, which is a
1012 Ip4OnRecyclePacket (
1017 IP4_RXDATA_WRAP
*Wrap
;
1019 Wrap
= (IP4_RXDATA_WRAP
*) Context
;
1021 EfiAcquireLockOrFail (&Wrap
->IpInstance
->RecycleLock
);
1022 RemoveEntryList (&Wrap
->Link
);
1023 EfiReleaseLock (&Wrap
->IpInstance
->RecycleLock
);
1025 ASSERT (!NET_BUF_SHARED (Wrap
->Packet
));
1026 NetbufFree (Wrap
->Packet
);
1028 gBS
->CloseEvent (Wrap
->RxData
.RecycleSignal
);
1034 Wrap the received packet to a IP4_RXDATA_WRAP, which will be
1035 delivered to the upper layer. Each IP4 child that accepts the
1036 packet will get a not-shared copy of the packet which is wrapped
1037 in the IP4_RXDATA_WRAP. The IP4_RXDATA_WRAP->RxData is passed
1038 to the upper layer. Upper layer will signal the recycle event in
1039 it when it is done with the packet.
1041 @param[in] IpInstance The IP4 child to receive the packet
1042 @param[in] Packet The packet to deliver up.
1044 @retval Wrap if warp the packet succeed.
1045 @retval NULL failed to wrap the packet .
1050 IN IP4_PROTOCOL
*IpInstance
,
1054 IP4_RXDATA_WRAP
*Wrap
;
1055 EFI_IP4_RECEIVE_DATA
*RxData
;
1058 Wrap
= AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet
->BlockOpNum
));
1064 InitializeListHead (&Wrap
->Link
);
1066 Wrap
->IpInstance
= IpInstance
;
1067 Wrap
->Packet
= Packet
;
1068 RxData
= &Wrap
->RxData
;
1070 ZeroMem (&RxData
->TimeStamp
, sizeof (EFI_TIME
));
1072 Status
= gBS
->CreateEvent (
1077 &RxData
->RecycleSignal
1080 if (EFI_ERROR (Status
)) {
1085 ASSERT (Packet
->Ip
.Ip4
!= NULL
);
1088 // The application expects a network byte order header.
1090 RxData
->HeaderLength
= (Packet
->Ip
.Ip4
->HeadLen
<< 2);
1091 RxData
->Header
= (EFI_IP4_HEADER
*) Ip4NtohHead (Packet
->Ip
.Ip4
);
1093 RxData
->OptionsLength
= RxData
->HeaderLength
- IP4_MIN_HEADLEN
;
1094 RxData
->Options
= NULL
;
1096 if (RxData
->OptionsLength
!= 0) {
1097 RxData
->Options
= (VOID
*) (RxData
->Header
+ 1);
1100 RxData
->DataLength
= Packet
->TotalSize
;
1103 // Build the fragment table to be delivered up.
1105 RxData
->FragmentCount
= Packet
->BlockOpNum
;
1106 NetbufBuildExt (Packet
, (NET_FRAGMENT
*) RxData
->FragmentTable
, &RxData
->FragmentCount
);
1113 Deliver the received packets to upper layer if there are both received
1114 requests and enqueued packets. If the enqueued packet is shared, it will
1115 duplicate it to a non-shared packet, release the shared packet, then
1116 deliver the non-shared packet up.
1118 @param[in] IpInstance The IP child to deliver the packet up.
1120 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to deliver the
1122 @retval EFI_SUCCESS All the enqueued packets that can be delivered
1127 Ip4InstanceDeliverPacket (
1128 IN IP4_PROTOCOL
*IpInstance
1131 EFI_IP4_COMPLETION_TOKEN
*Token
;
1132 IP4_RXDATA_WRAP
*Wrap
;
1138 // Deliver a packet if there are both a packet and a receive token.
1140 while (!IsListEmpty (&IpInstance
->Received
) &&
1141 !NetMapIsEmpty (&IpInstance
->RxTokens
)) {
1143 Packet
= NET_LIST_HEAD (&IpInstance
->Received
, NET_BUF
, List
);
1145 if (!NET_BUF_SHARED (Packet
)) {
1147 // If this is the only instance that wants the packet, wrap it up.
1149 Wrap
= Ip4WrapRxData (IpInstance
, Packet
);
1152 return EFI_OUT_OF_RESOURCES
;
1155 RemoveEntryList (&Packet
->List
);
1159 // Create a duplicated packet if this packet is shared
1161 Dup
= NetbufDuplicate (Packet
, NULL
, IP4_MAX_HEADLEN
);
1164 return EFI_OUT_OF_RESOURCES
;
1168 // Copy the IP head over. The packet to deliver up is
1169 // headless. Trim the head off after copy. The IP head
1170 // may be not continuous before the data.
1172 Head
= NetbufAllocSpace (Dup
, IP4_MAX_HEADLEN
, NET_BUF_HEAD
);
1173 Dup
->Ip
.Ip4
= (IP4_HEAD
*) Head
;
1175 CopyMem (Head
, Packet
->Ip
.Ip4
, Packet
->Ip
.Ip4
->HeadLen
<< 2);
1176 NetbufTrim (Dup
, IP4_MAX_HEADLEN
, TRUE
);
1178 Wrap
= Ip4WrapRxData (IpInstance
, Dup
);
1182 return EFI_OUT_OF_RESOURCES
;
1185 RemoveEntryList (&Packet
->List
);
1186 NetbufFree (Packet
);
1192 // Insert it into the delivered packet, then get a user's
1193 // receive token, pass the wrapped packet up.
1195 EfiAcquireLockOrFail (&IpInstance
->RecycleLock
);
1196 InsertHeadList (&IpInstance
->Delivered
, &Wrap
->Link
);
1197 EfiReleaseLock (&IpInstance
->RecycleLock
);
1199 Token
= NetMapRemoveHead (&IpInstance
->RxTokens
, NULL
);
1200 Token
->Status
= IP4_GET_CLIP_INFO (Packet
)->Status
;
1201 Token
->Packet
.RxData
= &Wrap
->RxData
;
1203 gBS
->SignalEvent (Token
->Event
);
1211 Enqueue a received packet to all the IP children that share
1214 @param[in] IpSb The IP4 service instance that receive the packet
1215 @param[in] Head The header of the received packet
1216 @param[in] Packet The data of the received packet
1217 @param[in] IpIf The interface to enqueue the packet to
1219 @return The number of the IP4 children that accepts the packet
1223 Ip4InterfaceEnquePacket (
1224 IN IP4_SERVICE
*IpSb
,
1227 IN IP4_INTERFACE
*IpIf
1230 IP4_PROTOCOL
*IpInstance
;
1231 IP4_CLIP_INFO
*Info
;
1238 // First, check that the packet is acceptable to this interface
1239 // and find the local cast type for the interface. A packet sent
1240 // to say 192.168.1.1 should NOT be delliever to 10.0.0.1 unless
1241 // promiscuous receiving.
1244 Info
= IP4_GET_CLIP_INFO (Packet
);
1246 if ((Info
->CastType
== IP4_MULTICAST
) || (Info
->CastType
== IP4_LOCAL_BROADCAST
)) {
1248 // If the CastType is multicast, don't need to filter against
1249 // the group address here, Ip4InstanceFrameAcceptable will do
1252 LocalType
= Info
->CastType
;
1256 // Check the destination againist local IP. If the station
1257 // address is 0.0.0.0, it means receiving all the IP destined
1258 // to local non-zero IP. Otherwise, it is necessary to compare
1259 // the destination to the interface's IP address.
1261 if (IpIf
->Ip
== IP4_ALLZERO_ADDRESS
) {
1262 LocalType
= IP4_LOCAL_HOST
;
1265 LocalType
= Ip4GetNetCast (Head
->Dst
, IpIf
);
1267 if ((LocalType
== 0) && IpIf
->PromiscRecv
) {
1268 LocalType
= IP4_PROMISCUOUS
;
1273 if (LocalType
== 0) {
1278 // Iterate through the ip instances on the interface, enqueue
1279 // the packet if filter passed. Save the original cast type,
1280 // and pass the local cast type to the IP children on the
1281 // interface. The global cast type will be restored later.
1283 SavedType
= Info
->CastType
;
1284 Info
->CastType
= LocalType
;
1288 NET_LIST_FOR_EACH (Entry
, &IpIf
->IpInstances
) {
1289 IpInstance
= NET_LIST_USER_STRUCT (Entry
, IP4_PROTOCOL
, AddrLink
);
1290 NET_CHECK_SIGNATURE (IpInstance
, IP4_PROTOCOL_SIGNATURE
);
1292 if (Ip4InstanceEnquePacket (IpInstance
, Head
, Packet
) == EFI_SUCCESS
) {
1297 Info
->CastType
= SavedType
;
1303 Deliver the packet for each IP4 child on the interface.
1305 @param[in] IpSb The IP4 service instance that received the packet
1306 @param[in] IpIf The IP4 interface to deliver the packet.
1308 @retval EFI_SUCCESS It always returns EFI_SUCCESS now
1312 Ip4InterfaceDeliverPacket (
1313 IN IP4_SERVICE
*IpSb
,
1314 IN IP4_INTERFACE
*IpIf
1317 IP4_PROTOCOL
*Ip4Instance
;
1320 NET_LIST_FOR_EACH (Entry
, &IpIf
->IpInstances
) {
1321 Ip4Instance
= NET_LIST_USER_STRUCT (Entry
, IP4_PROTOCOL
, AddrLink
);
1322 Ip4InstanceDeliverPacket (Ip4Instance
);
1330 Demultiple the packet. the packet delivery is processed in two
1331 passes. The first pass will enque a shared copy of the packet
1332 to each IP4 child that accepts the packet. The second pass will
1333 deliver a non-shared copy of the packet to each IP4 child that
1334 has pending receive requests. Data is copied if more than one
1335 child wants to consume the packet because each IP child needs
1336 its own copy of the packet to make changes.
1338 @param[in] IpSb The IP4 service instance that received the packet
1339 @param[in] Head The header of the received packet
1340 @param[in] Packet The data of the received packet
1342 @retval EFI_NOT_FOUND No IP child accepts the packet
1343 @retval EFI_SUCCESS The packet is enqueued or delivered to some IP
1349 IN IP4_SERVICE
*IpSb
,
1355 IP4_INTERFACE
*IpIf
;
1359 // Two pass delivery: first, enque a shared copy of the packet
1360 // to each instance that accept the packet.
1364 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
1365 IpIf
= NET_LIST_USER_STRUCT (Entry
, IP4_INTERFACE
, Link
);
1367 if (IpIf
->Configured
) {
1368 Enqueued
+= Ip4InterfaceEnquePacket (IpSb
, Head
, Packet
, IpIf
);
1373 // Second: deliver a duplicate of the packet to each instance.
1374 // Release the local reference first, so that the last instance
1375 // getting the packet will not copy the data.
1377 NetbufFree (Packet
);
1379 if (Enqueued
== 0) {
1380 return EFI_NOT_FOUND
;
1383 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
1384 IpIf
= NET_LIST_USER_STRUCT (Entry
, IP4_INTERFACE
, Link
);
1386 if (IpIf
->Configured
) {
1387 Ip4InterfaceDeliverPacket (IpSb
, IpIf
);
1396 Timeout the fragment and enqueued packets.
1398 @param[in] IpSb The IP4 service instance to timeout
1402 Ip4PacketTimerTicking (
1403 IN IP4_SERVICE
*IpSb
1406 LIST_ENTRY
*InstanceEntry
;
1409 IP4_PROTOCOL
*IpInstance
;
1410 IP4_ASSEMBLE_ENTRY
*Assemble
;
1412 IP4_CLIP_INFO
*Info
;
1416 // First, time out the fragments. The packet's life is counting down
1417 // once the first-arrived fragment was received.
1419 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
1420 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &IpSb
->Assemble
.Bucket
[Index
]) {
1421 Assemble
= NET_LIST_USER_STRUCT (Entry
, IP4_ASSEMBLE_ENTRY
, Link
);
1423 if ((Assemble
->Life
> 0) && (--Assemble
->Life
== 0)) {
1424 RemoveEntryList (Entry
);
1425 Ip4FreeAssembleEntry (Assemble
);
1430 NET_LIST_FOR_EACH (InstanceEntry
, &IpSb
->Children
) {
1431 IpInstance
= NET_LIST_USER_STRUCT (InstanceEntry
, IP4_PROTOCOL
, Link
);
1434 // Second, time out the assembled packets enqueued on each IP child.
1436 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &IpInstance
->Received
) {
1437 Packet
= NET_LIST_USER_STRUCT (Entry
, NET_BUF
, List
);
1438 Info
= IP4_GET_CLIP_INFO (Packet
);
1440 if ((Info
->Life
> 0) && (--Info
->Life
== 0)) {
1441 RemoveEntryList (Entry
);
1442 NetbufFree (Packet
);
1447 // Third: time out the transmitted packets.
1449 NetMapIterate (&IpInstance
->TxTokens
, Ip4SentPacketTicking
, NULL
);