]>
git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Input.c
3 Copyright (c) 2005 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
27 Create a empty assemble entry for the packet identified by
28 (Dst, Src, Id, Protocol). The default life for the packet is
31 @param Dst The destination address
32 @param Src The source address
33 @param Id The ID field in IP header
34 @param Protocol The protocol field in IP header
36 @return NULL if failed to allocate memory for the entry, otherwise
37 @return the point to just created reassemble entry.
41 Ip4CreateAssembleEntry (
49 IP4_ASSEMBLE_ENTRY
*Assemble
;
51 Assemble
= AllocatePool (sizeof (IP4_ASSEMBLE_ENTRY
));
53 if (Assemble
== NULL
) {
57 InitializeListHead (&Assemble
->Link
);
58 InitializeListHead (&Assemble
->Fragments
);
63 Assemble
->Protocol
= Protocol
;
64 Assemble
->TotalLen
= 0;
66 Assemble
->Head
= NULL
;
67 Assemble
->Info
= NULL
;
68 Assemble
->Life
= IP4_FRAGMENT_LIFE
;
75 Release all the fragments of a packet, then free the assemble entry
77 @param Assemble The assemble entry to free
83 Ip4FreeAssembleEntry (
84 IN IP4_ASSEMBLE_ENTRY
*Assemble
91 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Assemble
->Fragments
) {
92 Fragment
= NET_LIST_USER_STRUCT (Entry
, NET_BUF
, List
);
94 RemoveEntryList (Entry
);
95 NetbufFree (Fragment
);
98 gBS
->FreePool (Assemble
);
103 Initialize an already allocated assemble table. This is generally
104 the assemble table embedded in the IP4 service instance.
106 @param Table The assemble table to initialize.
112 Ip4InitAssembleTable (
113 IN IP4_ASSEMBLE_TABLE
*Table
118 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
119 InitializeListHead (&Table
->Bucket
[Index
]);
125 Clean up the assemble table: remove all the fragments
126 and assemble entries.
128 @param Table The assemble table to clean up
134 Ip4CleanAssembleTable (
135 IN IP4_ASSEMBLE_TABLE
*Table
140 IP4_ASSEMBLE_ENTRY
*Assemble
;
143 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
144 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Table
->Bucket
[Index
]) {
145 Assemble
= NET_LIST_USER_STRUCT (Entry
, IP4_ASSEMBLE_ENTRY
, Link
);
147 RemoveEntryList (Entry
);
148 Ip4FreeAssembleEntry (Assemble
);
155 Trim the packet to fit in [Start, End), and update the per
158 @param Packet Packet to trim
159 @param Start The sequence of the first byte to fit in
160 @param End One beyond the sequence of last byte to fit in.
175 Info
= IP4_GET_CLIP_INFO (Packet
);
177 ASSERT (Info
->Start
+ Info
->Length
== Info
->End
);
178 ASSERT ((Info
->Start
< End
) && (Start
< Info
->End
));
180 if (Info
->Start
< Start
) {
181 Len
= Start
- Info
->Start
;
183 NetbufTrim (Packet
, (UINT32
) Len
, NET_BUF_HEAD
);
188 if (End
< Info
->End
) {
189 Len
= End
- Info
->End
;
191 NetbufTrim (Packet
, (UINT32
) Len
, NET_BUF_TAIL
);
199 Release all the fragments of the packet. This is the callback for
200 the assembled packet's OnFree. It will free the assemble entry,
201 which in turn will free all the fragments of the packet.
203 @param Arg The assemble entry to free
213 Ip4FreeAssembleEntry ((IP4_ASSEMBLE_ENTRY
*) Arg
);
218 Reassemble the IP fragments. If all the fragments of the packet
219 have been received, it will wrap the packet in a net buffer then
220 return it to caller. If the packet can't be assembled, NULL is
223 @param Table The assemble table used.
224 @param Packet The fragment to assemble
226 @return NULL if the packet can't be reassemble. The point to just assembled
227 @return packet if all the fragments of the packet have arrived.
232 IN IP4_ASSEMBLE_TABLE
*Table
,
239 IP4_ASSEMBLE_ENTRY
*Assemble
;
248 This
= IP4_GET_CLIP_INFO (Packet
);
250 ASSERT (IpHead
!= NULL
);
253 // First: find the related assemble entry
256 Index
= IP4_ASSEMBLE_HASH (IpHead
->Dst
, IpHead
->Src
, IpHead
->Id
, IpHead
->Protocol
);
258 NET_LIST_FOR_EACH (Cur
, &Table
->Bucket
[Index
]) {
259 Assemble
= NET_LIST_USER_STRUCT (Cur
, IP4_ASSEMBLE_ENTRY
, Link
);
261 if ((Assemble
->Dst
== IpHead
->Dst
) && (Assemble
->Src
== IpHead
->Src
) &&
262 (Assemble
->Id
== IpHead
->Id
) && (Assemble
->Protocol
== IpHead
->Protocol
)) {
268 // Create a new assemble entry if no assemble entry is related to this packet
270 if (Cur
== &Table
->Bucket
[Index
]) {
271 Assemble
= Ip4CreateAssembleEntry (
278 if (Assemble
== NULL
) {
282 InsertHeadList (&Table
->Bucket
[Index
], &Assemble
->Link
);
286 // Find the point to insert the packet: before the first
287 // fragment with THIS.Start < CUR.Start. the previous one
288 // has PREV.Start <= THIS.Start < CUR.Start.
290 Head
= &Assemble
->Fragments
;
292 NET_LIST_FOR_EACH (Cur
, Head
) {
293 Fragment
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
295 if (This
->Start
< IP4_GET_CLIP_INFO (Fragment
)->Start
) {
301 // Check whether the current fragment overlaps with the previous one.
302 // It holds that: PREV.Start <= THIS.Start < THIS.End. Only need to
303 // check whether THIS.Start < PREV.End for overlap. If two fragments
304 // overlaps, trim the overlapped part off THIS fragment.
306 if ((Prev
= Cur
->ForwardLink
) != Head
) {
307 Fragment
= NET_LIST_USER_STRUCT (Prev
, NET_BUF
, List
);
308 Node
= IP4_GET_CLIP_INFO (Fragment
);
310 if (This
->Start
< Node
->End
) {
311 if (This
->End
<= Node
->End
) {
316 Ip4TrimPacket (Packet
, Node
->End
, This
->End
);
321 // Insert the fragment into the packet. The fragment may be removed
322 // from the list by the following checks.
324 NetListInsertBefore (Cur
, &Packet
->List
);
327 // Check the packets after the insert point. It holds that:
328 // THIS.Start <= NODE.Start < NODE.End. The equality holds
329 // if PREV and NEXT are continuous. THIS fragment may fill
330 // several holes. Remove the completely overlapped fragments
332 while (Cur
!= Head
) {
333 Fragment
= NET_LIST_USER_STRUCT (Cur
, NET_BUF
, List
);
334 Node
= IP4_GET_CLIP_INFO (Fragment
);
337 // Remove fragments completely overlapped by this fragment
339 if (Node
->End
<= This
->End
) {
340 Cur
= Cur
->ForwardLink
;
342 RemoveEntryList (&Fragment
->List
);
343 Assemble
->CurLen
-= Node
->Length
;
345 NetbufFree (Fragment
);
350 // The conditions are: THIS.Start <= NODE.Start, and THIS.End <
351 // NODE.End. Two fragments overlaps if NODE.Start < THIS.End.
352 // If two fragments start at the same offset, remove THIS fragment
353 // because ((THIS.Start == NODE.Start) && (THIS.End < NODE.End)).
355 if (Node
->Start
< This
->End
) {
356 if (This
->Start
== Node
->Start
) {
357 RemoveEntryList (&Packet
->List
);
361 Ip4TrimPacket (Packet
, This
->Start
, Node
->Start
);
368 // Update the assemble info: increase the current length. If it is
369 // the frist fragment, update the packet's IP head and per packet
370 // info. If it is the last fragment, update the total length.
372 Assemble
->CurLen
+= This
->Length
;
374 if (This
->Start
== 0) {
376 // Once the first fragment is enqueued, it can't be removed
377 // from the fragment list. So, Assemble->Head always point
378 // to valid memory area.
380 ASSERT (Assemble
->Head
== NULL
);
382 Assemble
->Head
= IpHead
;
383 Assemble
->Info
= IP4_GET_CLIP_INFO (Packet
);
387 // Don't update the length more than once.
389 if (IP4_LAST_FRAGMENT (IpHead
->Fragment
) && (Assemble
->TotalLen
== 0)) {
390 Assemble
->TotalLen
= This
->End
;
394 // Deliver the whole packet if all the fragments received.
395 // All fragments received if:
396 // 1. received the last one, so, the totoal length is know
397 // 2. received all the data. If the last fragment on the
398 // queue ends at the total length, all data is received.
400 if ((Assemble
->TotalLen
!= 0) && (Assemble
->CurLen
>= Assemble
->TotalLen
)) {
402 RemoveEntryList (&Assemble
->Link
);
405 // If the packet is properly formated, the last fragment's End
406 // equals to the packet's total length. Otherwise, the packet
407 // is a fake, drop it now.
409 Fragment
= NET_LIST_USER_STRUCT (Head
->BackLink
, NET_BUF
, List
);
411 if (IP4_GET_CLIP_INFO (Fragment
)->End
!= Assemble
->TotalLen
) {
412 Ip4FreeAssembleEntry (Assemble
);
417 // Wrap the packet in a net buffer then deliver it up
419 NewPacket
= NetbufFromBufList (
420 &Assemble
->Fragments
,
427 if (NewPacket
== NULL
) {
428 Ip4FreeAssembleEntry (Assemble
);
432 NewPacket
->Ip
= Assemble
->Head
;
433 CopyMem (IP4_GET_CLIP_INFO (NewPacket
), Assemble
->Info
, sizeof (*IP4_GET_CLIP_INFO (NewPacket
)));
446 The IP4 input routine. It is called by the IP4_INTERFACE when a
447 IP4 fragment is received from MNP.
449 @param Ip4Instance The IP4 child that request the receive, most like
451 @param Packet The IP4 packet received.
452 @param IoStatus The return status of receive request.
453 @param Flag The link layer flag for the packet received, such
455 @param Context The IP4 service instance that own the MNP.
462 IN IP4_PROTOCOL
*Ip4Instance
,
464 IN EFI_STATUS IoStatus
,
477 IpSb
= (IP4_SERVICE
*) Context
;
479 if (EFI_ERROR (IoStatus
) || (IpSb
->State
== IP4_SERVICE_DESTORY
)) {
484 // Check that the IP4 header is correctly formated
486 if (Packet
->TotalSize
< IP4_MIN_HEADLEN
) {
490 Head
= (IP4_HEAD
*) NetbufGetByte (Packet
, 0, NULL
);
491 HeadLen
= (Head
->HeadLen
<< 2);
492 TotalLen
= NTOHS (Head
->TotalLen
);
495 // Mnp may deliver frame trailer sequence up, trim it off.
497 if (TotalLen
< Packet
->TotalSize
) {
498 NetbufTrim (Packet
, Packet
->TotalSize
- TotalLen
, FALSE
);
501 if ((Head
->Ver
!= 4) || (HeadLen
< IP4_MIN_HEADLEN
) ||
502 (TotalLen
< HeadLen
) || (TotalLen
!= Packet
->TotalSize
)) {
507 // Some OS may send IP packets without checksum.
509 Checksum
= (UINT16
) (~NetblockChecksum ((UINT8
*) Head
, HeadLen
));
511 if ((Head
->Checksum
!= 0) && (Checksum
!= 0)) {
516 // Convert the IP header to host byte order, then get the per packet info.
518 Packet
->Ip
= Ip4NtohHead (Head
);
520 Info
= IP4_GET_CLIP_INFO (Packet
);
521 Info
->LinkFlag
= Flag
;
522 Info
->CastType
= Ip4GetHostCast (IpSb
, Head
->Dst
, Head
->Src
);
523 Info
->Start
= (Head
->Fragment
& IP4_HEAD_OFFSET_MASK
) << 3;
524 Info
->Length
= Head
->TotalLen
- HeadLen
;
525 Info
->End
= Info
->Start
+ Info
->Length
;
526 Info
->Status
= EFI_SUCCESS
;
529 // The packet is destinated to us if the CastType is non-zero.
531 if ((Info
->CastType
== 0) || (Info
->End
> IP4_MAX_PACKET_SIZE
)) {
536 // Validate the options. Don't call the Ip4OptionIsValid if
537 // there is no option to save some CPU process.
539 OptionLen
= HeadLen
- IP4_MIN_HEADLEN
;
541 if ((OptionLen
> 0) && !Ip4OptionIsValid ((UINT8
*) (Head
+ 1), OptionLen
, TRUE
)) {
546 // Trim the head off, after this point, the packet is headless.
547 // and Packet->TotalLen == Info->Length.
549 NetbufTrim (Packet
, HeadLen
, TRUE
);
552 // Reassemble the packet if this is a fragment. The packet is a
553 // fragment if its head has MF (more fragment) set, or it starts
556 if ((Head
->Fragment
& IP4_HEAD_MF_MASK
) || (Info
->Start
!= 0)) {
558 // Drop the fragment if DF is set but it is fragmented. Gateway
559 // need to send a type 4 destination unreache ICMP message here.
561 if (Head
->Fragment
& IP4_HEAD_DF_MASK
) {
566 // The length of all but the last fragments is in the unit of 8 bytes.
568 if ((Head
->Fragment
& IP4_HEAD_MF_MASK
) && (Info
->Length
% 8 != 0)) {
572 Packet
= Ip4Reassemble (&IpSb
->Assemble
, Packet
);
575 // Packet assembly isn't complete, start receive more packet.
577 if (Packet
== NULL
) {
583 // Packet may have been changed. Head, HeadLen, TotalLen, and
584 // info must be reloaded bofore use. The ownership of the packet
585 // is transfered to the packet process logic.
588 IP4_GET_CLIP_INFO (Packet
)->Status
= EFI_SUCCESS
;
590 switch (Head
->Protocol
) {
592 Ip4IcmpHandle (IpSb
, Head
, Packet
);
596 Ip4IgmpHandle (IpSb
, Head
, Packet
);
600 Ip4Demultiplex (IpSb
, Head
, Packet
);
606 // Dispatch the DPCs queued by the NotifyFunction of the rx token's events
607 // which are signaled with received data.
609 NetLibDispatchDpc ();
612 Ip4ReceiveFrame (IpSb
->DefaultInterface
, NULL
, Ip4AccpetFrame
, IpSb
);
615 if (Packet
!= NULL
) {
624 Check whether this IP child accepts the packet.
626 @param IpInstance The IP child to check
627 @param Head The IP header of the packet
628 @param Packet The data of the packet
630 @return TRUE if the child wants to receive the packet, otherwise return FALSE.
634 Ip4InstanceFrameAcceptable (
635 IN IP4_PROTOCOL
*IpInstance
,
640 IP4_ICMP_ERROR_HEAD Icmp
;
641 EFI_IP4_CONFIG_DATA
*Config
;
646 Config
= &IpInstance
->ConfigData
;
649 // Dirty trick for the Tiano UEFI network stack implmentation. If
650 // ReceiveTimeout == -1, the receive of the packet for this instance
651 // is disabled. The UEFI spec don't have such captibility. We add
652 // this to improve the performance because IP will make a copy of
653 // the received packet for each accepting instance. Some IP instances
654 // used by UDP/TCP only send packets, they don't wants to receive.
656 if (Config
->ReceiveTimeout
== (UINT32
)(-1)) {
660 if (Config
->AcceptPromiscuous
) {
665 // Use protocol from the IP header embedded in the ICMP error
666 // message to filter, instead of ICMP itself. ICMP handle will
667 // can Ip4Demultiplex to deliver ICMP errors.
669 Proto
= Head
->Protocol
;
671 if (Proto
== IP4_PROTO_ICMP
) {
672 NetbufCopy (Packet
, 0, sizeof (Icmp
.Head
), (UINT8
*) &Icmp
.Head
);
674 if (mIcmpClass
[Icmp
.Head
.Type
].IcmpClass
== ICMP_ERROR_MESSAGE
) {
675 if (!Config
->AcceptIcmpErrors
) {
679 NetbufCopy (Packet
, 0, sizeof (Icmp
), (UINT8
*) &Icmp
);
680 Proto
= Icmp
.IpHead
.Protocol
;
685 // Match the protocol
687 if (!Config
->AcceptAnyProtocol
&& (Proto
!= Config
->DefaultProtocol
)) {
692 // Check for broadcast, the caller has computed the packet's
693 // cast type for this child's interface.
695 Info
= IP4_GET_CLIP_INFO (Packet
);
697 if (IP4_IS_BROADCAST (Info
->CastType
)) {
698 return Config
->AcceptBroadcast
;
702 // If it is a multicast packet, check whether we are in the group.
704 if (Info
->CastType
== IP4_MULTICAST
) {
706 // Receive the multicast if the instance wants to receive all packets.
708 if (!IpInstance
->ConfigData
.UseDefaultAddress
&& (IpInstance
->Interface
->Ip
== 0)) {
712 for (Index
= 0; Index
< IpInstance
->GroupCount
; Index
++) {
713 if (IpInstance
->Groups
[Index
] == HTONL (Head
->Dst
)) {
718 return (BOOLEAN
)(Index
< IpInstance
->GroupCount
);
726 Enqueue a shared copy of the packet to the IP4 child if the
727 packet is acceptable to it. Here the data of the packet is
728 shared, but the net buffer isn't.
730 @param IpInstance The IP4 child to enqueue the packet to
731 @param Head The IP header of the received packet
732 @param Packet The data of the received packet
734 @retval EFI_NOT_STARTED The IP child hasn't been configured.
735 @retval EFI_INVALID_PARAMETER The child doesn't want to receive the packet
736 @retval EFI_OUT_OF_RESOURCES Failed to allocate some resource
737 @retval EFI_SUCCESS A shared copy the packet is enqueued to the child.
741 Ip4InstanceEnquePacket (
742 IN IP4_PROTOCOL
*IpInstance
,
751 // Check whether the packet is acceptable to this instance.
753 if (IpInstance
->State
!= IP4_STATE_CONFIGED
) {
754 return EFI_NOT_STARTED
;
757 if (!Ip4InstanceFrameAcceptable (IpInstance
, Head
, Packet
)) {
758 return EFI_INVALID_PARAMETER
;
762 // Enque a shared copy of the packet.
764 Clone
= NetbufClone (Packet
);
767 return EFI_OUT_OF_RESOURCES
;
771 // Set the receive time out for the assembled packet. If it expires,
772 // packet will be removed from the queue.
774 Info
= IP4_GET_CLIP_INFO (Clone
);
775 Info
->Life
= IP4_US_TO_SEC (IpInstance
->ConfigData
.ReceiveTimeout
);
777 InsertTailList (&IpInstance
->Received
, &Clone
->List
);
783 The signal handle of IP4's recycle event. It is called back
784 when the upper layer release the packet.
786 @param Event The IP4's recycle event.
787 @param Context The context of the handle, which is a
800 IP4_RXDATA_WRAP
*Wrap
;
802 Wrap
= (IP4_RXDATA_WRAP
*) Context
;
804 EfiAcquireLockOrFail (&Wrap
->IpInstance
->RecycleLock
);
805 RemoveEntryList (&Wrap
->Link
);
806 EfiReleaseLock (&Wrap
->IpInstance
->RecycleLock
);
808 ASSERT (!NET_BUF_SHARED (Wrap
->Packet
));
809 NetbufFree (Wrap
->Packet
);
811 gBS
->CloseEvent (Wrap
->RxData
.RecycleSignal
);
812 gBS
->FreePool (Wrap
);
817 Wrap the received packet to a IP4_RXDATA_WRAP, which will be
818 delivered to the upper layer. Each IP4 child that accepts the
819 packet will get a not-shared copy of the packet which is wrapped
820 in the IP4_RXDATA_WRAP. The IP4_RXDATA_WRAP->RxData is passed
821 to the upper layer. Upper layer will signal the recycle event in
822 it when it is done with the packet.
824 @param IpInstance The IP4 child to receive the packet
825 @param Packet The packet to deliver up.
827 @return NULL if failed to wrap the packet, otherwise the wrapper.
832 IN IP4_PROTOCOL
*IpInstance
,
836 IP4_RXDATA_WRAP
*Wrap
;
837 EFI_IP4_RECEIVE_DATA
*RxData
;
840 Wrap
= AllocatePool (IP4_RXDATA_WRAP_SIZE (Packet
->BlockOpNum
));
846 InitializeListHead (&Wrap
->Link
);
848 Wrap
->IpInstance
= IpInstance
;
849 Wrap
->Packet
= Packet
;
850 RxData
= &Wrap
->RxData
;
852 ZeroMem (&RxData
->TimeStamp
, sizeof (EFI_TIME
));
854 Status
= gBS
->CreateEvent (
859 &RxData
->RecycleSignal
862 if (EFI_ERROR (Status
)) {
863 gBS
->FreePool (Wrap
);
867 ASSERT (Packet
->Ip
!= NULL
);
870 // The application expects a network byte order header.
872 RxData
->HeaderLength
= (Packet
->Ip
->HeadLen
<< 2);
873 RxData
->Header
= (EFI_IP4_HEADER
*) Ip4NtohHead (Packet
->Ip
);
875 RxData
->OptionsLength
= RxData
->HeaderLength
- IP4_MIN_HEADLEN
;
876 RxData
->Options
= NULL
;
878 if (RxData
->OptionsLength
!= 0) {
879 RxData
->Options
= (VOID
*) (RxData
->Header
+ 1);
882 RxData
->DataLength
= Packet
->TotalSize
;
885 // Build the fragment table to be delivered up.
887 RxData
->FragmentCount
= Packet
->BlockOpNum
;
888 NetbufBuildExt (Packet
, (NET_FRAGMENT
*) RxData
->FragmentTable
, &RxData
->FragmentCount
);
895 Deliver the received packets to upper layer if there are both received
896 requests and enqueued packets. If the enqueued packet is shared, it will
897 duplicate it to a non-shared packet, release the shared packet, then
898 deliver the non-shared packet up.
900 @param IpInstance The IP child to deliver the packet up.
902 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to deliver the
904 @retval EFI_SUCCESS All the enqueued packets that can be delivered
909 Ip4InstanceDeliverPacket (
910 IN IP4_PROTOCOL
*IpInstance
913 EFI_IP4_COMPLETION_TOKEN
*Token
;
914 IP4_RXDATA_WRAP
*Wrap
;
920 // Deliver a packet if there are both a packet and a receive token.
922 while (!IsListEmpty (&IpInstance
->Received
) &&
923 !NetMapIsEmpty (&IpInstance
->RxTokens
)) {
925 Packet
= NET_LIST_HEAD (&IpInstance
->Received
, NET_BUF
, List
);
927 if (!NET_BUF_SHARED (Packet
)) {
929 // If this is the only instance that wants the packet, wrap it up.
931 Wrap
= Ip4WrapRxData (IpInstance
, Packet
);
934 return EFI_OUT_OF_RESOURCES
;
937 RemoveEntryList (&Packet
->List
);
941 // Create a duplicated packet if this packet is shared
943 Dup
= NetbufDuplicate (Packet
, NULL
, IP4_MAX_HEADLEN
);
946 return EFI_OUT_OF_RESOURCES
;
950 // Copy the IP head over. The packet to deliver up is
951 // headless. Trim the head off after copy. The IP head
952 // may be not continuous before the data.
954 Head
= NetbufAllocSpace (Dup
, IP4_MAX_HEADLEN
, NET_BUF_HEAD
);
955 Dup
->Ip
= (IP4_HEAD
*) Head
;
957 CopyMem (Head
, Packet
->Ip
, Packet
->Ip
->HeadLen
<< 2);
958 NetbufTrim (Dup
, IP4_MAX_HEADLEN
, TRUE
);
960 Wrap
= Ip4WrapRxData (IpInstance
, Dup
);
964 return EFI_OUT_OF_RESOURCES
;
967 RemoveEntryList (&Packet
->List
);
974 // Insert it into the delivered packet, then get a user's
975 // receive token, pass the wrapped packet up.
977 EfiAcquireLockOrFail (&IpInstance
->RecycleLock
);
978 InsertHeadList (&IpInstance
->Delivered
, &Wrap
->Link
);
979 EfiReleaseLock (&IpInstance
->RecycleLock
);
981 Token
= NetMapRemoveHead (&IpInstance
->RxTokens
, NULL
);
982 Token
->Status
= IP4_GET_CLIP_INFO (Packet
)->Status
;
983 Token
->Packet
.RxData
= &Wrap
->RxData
;
985 gBS
->SignalEvent (Token
->Event
);
993 Enqueue a received packet to all the IP children that share
996 @param IpSb The IP4 service instance that receive the packet
997 @param Head The header of the received packet
998 @param Packet The data of the received packet
999 @param IpIf The interface to enqueue the packet to
1001 @return The number of the IP4 children that accepts the packet
1005 Ip4InterfaceEnquePacket (
1006 IN IP4_SERVICE
*IpSb
,
1009 IN IP4_INTERFACE
*IpIf
1012 IP4_PROTOCOL
*IpInstance
;
1013 IP4_CLIP_INFO
*Info
;
1020 // First, check that the packet is acceptable to this interface
1021 // and find the local cast type for the interface. A packet sent
1022 // to say 192.168.1.1 should NOT be delliever to 10.0.0.1 unless
1023 // promiscuous receiving.
1026 Info
= IP4_GET_CLIP_INFO (Packet
);
1028 if ((Info
->CastType
== IP4_MULTICAST
) || (Info
->CastType
== IP4_LOCAL_BROADCAST
)) {
1030 // If the CastType is multicast, don't need to filter against
1031 // the group address here, Ip4InstanceFrameAcceptable will do
1034 LocalType
= Info
->CastType
;
1038 // Check the destination againist local IP. If the station
1039 // address is 0.0.0.0, it means receiving all the IP destined
1040 // to local non-zero IP. Otherwise, it is necessary to compare
1041 // the destination to the interface's IP address.
1043 if (IpIf
->Ip
== IP4_ALLZERO_ADDRESS
) {
1044 LocalType
= IP4_LOCAL_HOST
;
1047 LocalType
= Ip4GetNetCast (Head
->Dst
, IpIf
);
1049 if ((LocalType
== 0) && IpIf
->PromiscRecv
) {
1050 LocalType
= IP4_PROMISCUOUS
;
1055 if (LocalType
== 0) {
1060 // Iterate through the ip instances on the interface, enqueue
1061 // the packet if filter passed. Save the original cast type,
1062 // and pass the local cast type to the IP children on the
1063 // interface. The global cast type will be restored later.
1065 SavedType
= Info
->CastType
;
1066 Info
->CastType
= LocalType
;
1070 NET_LIST_FOR_EACH (Entry
, &IpIf
->IpInstances
) {
1071 IpInstance
= NET_LIST_USER_STRUCT (Entry
, IP4_PROTOCOL
, AddrLink
);
1072 NET_CHECK_SIGNATURE (IpInstance
, IP4_PROTOCOL_SIGNATURE
);
1074 if (Ip4InstanceEnquePacket (IpInstance
, Head
, Packet
) == EFI_SUCCESS
) {
1079 Info
->CastType
= SavedType
;
1085 Deliver the packet for each IP4 child on the interface.
1087 @param IpSb The IP4 service instance that received the packet
1088 @param IpIf The IP4 interface to deliver the packet.
1090 @retval EFI_SUCCESS It always returns EFI_SUCCESS now
1094 Ip4InterfaceDeliverPacket (
1095 IN IP4_SERVICE
*IpSb
,
1096 IN IP4_INTERFACE
*IpIf
1099 IP4_PROTOCOL
*Ip4Instance
;
1102 NET_LIST_FOR_EACH (Entry
, &IpIf
->IpInstances
) {
1103 Ip4Instance
= NET_LIST_USER_STRUCT (Entry
, IP4_PROTOCOL
, AddrLink
);
1104 Ip4InstanceDeliverPacket (Ip4Instance
);
1112 Demultiple the packet. the packet delivery is processed in two
1113 passes. The first pass will enque a shared copy of the packet
1114 to each IP4 child that accepts the packet. The second pass will
1115 deliver a non-shared copy of the packet to each IP4 child that
1116 has pending receive requests. Data is copied if more than one
1117 child wants to consume the packet bacause each IP child need
1118 its own copy of the packet to make changes.
1120 @param IpSb The IP4 service instance that received the packet
1121 @param Head The header of the received packet
1122 @param Packet The data of the received packet
1124 @retval EFI_NOT_FOUND No IP child accepts the packet
1125 @retval EFI_SUCCESS The packet is enqueued or delivered to some IP
1131 IN IP4_SERVICE
*IpSb
,
1137 IP4_INTERFACE
*IpIf
;
1141 // Two pass delivery: first, enque a shared copy of the packet
1142 // to each instance that accept the packet.
1146 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
1147 IpIf
= NET_LIST_USER_STRUCT (Entry
, IP4_INTERFACE
, Link
);
1149 if (IpIf
->Configured
) {
1150 Enqueued
+= Ip4InterfaceEnquePacket (IpSb
, Head
, Packet
, IpIf
);
1155 // Second: deliver a duplicate of the packet to each instance.
1156 // Release the local reference first, so that the last instance
1157 // getting the packet will not copy the data.
1159 NetbufFree (Packet
);
1161 if (Enqueued
== 0) {
1162 return EFI_NOT_FOUND
;
1165 NET_LIST_FOR_EACH (Entry
, &IpSb
->Interfaces
) {
1166 IpIf
= NET_LIST_USER_STRUCT (Entry
, IP4_INTERFACE
, Link
);
1168 if (IpIf
->Configured
) {
1169 Ip4InterfaceDeliverPacket (IpSb
, IpIf
);
1178 Timeout the fragment and enqueued packets.
1180 @param IpSb The IP4 service instance to timeout
1186 Ip4PacketTimerTicking (
1187 IN IP4_SERVICE
*IpSb
1190 LIST_ENTRY
*InstanceEntry
;
1193 IP4_PROTOCOL
*IpInstance
;
1194 IP4_ASSEMBLE_ENTRY
*Assemble
;
1196 IP4_CLIP_INFO
*Info
;
1200 // First, time out the fragments. The packet's life is counting down
1201 // once the first-arrived fragment was received.
1203 for (Index
= 0; Index
< IP4_ASSEMLE_HASH_SIZE
; Index
++) {
1204 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &IpSb
->Assemble
.Bucket
[Index
]) {
1205 Assemble
= NET_LIST_USER_STRUCT (Entry
, IP4_ASSEMBLE_ENTRY
, Link
);
1207 if ((Assemble
->Life
> 0) && (--Assemble
->Life
== 0)) {
1208 RemoveEntryList (Entry
);
1209 Ip4FreeAssembleEntry (Assemble
);
1214 NET_LIST_FOR_EACH (InstanceEntry
, &IpSb
->Children
) {
1215 IpInstance
= NET_LIST_USER_STRUCT (InstanceEntry
, IP4_PROTOCOL
, Link
);
1218 // Second, time out the assembled packets enqueued on each IP child.
1220 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &IpInstance
->Received
) {
1221 Packet
= NET_LIST_USER_STRUCT (Entry
, NET_BUF
, List
);
1222 Info
= IP4_GET_CLIP_INFO (Packet
);
1224 if ((Info
->Life
> 0) && (--Info
->Life
== 0)) {
1225 RemoveEntryList (Entry
);
1226 NetbufFree (Packet
);
1231 // Third: time out the transmitted packets.
1233 NetMapIterate (&IpInstance
->TxTokens
, Ip4SentPacketTicking
, NULL
);