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.
19 Implement IP4 pesudo interface.
27 // Mac address with all zero, used to determine whethter the ARP
28 // resolve succeeded. Failed ARP requests zero the MAC address buffer.
30 STATIC EFI_MAC_ADDRESS mZeroMacAddress
;
59 IN IP4_ARP_QUE
*ArpQue
,
60 IN EFI_STATUS IoStatus
,
61 IN IP4_FRAME_TO_CANCEL FrameToCancel
, OPTIONAL
67 Wrap a transmit request into a newly allocated IP4_LINK_TX_TOKEN.
69 @param Interface The interface to send out from
70 @param IpInstance The IpInstance that transmit the packet. NULL if
71 the packet is sent by the IP4 driver itself.
72 @param Packet The packet to transmit
73 @param CallBack Call back function to execute if transmission
75 @param Context Opaque parameter to the call back.
77 @return The wrapped token if succeed or NULL
83 IN IP4_INTERFACE
*Interface
,
84 IN IP4_PROTOCOL
*IpInstance
, OPTIONAL
86 IN IP4_FRAME_CALLBACK CallBack
,
90 EFI_MANAGED_NETWORK_COMPLETION_TOKEN
*MnpToken
;
91 EFI_MANAGED_NETWORK_TRANSMIT_DATA
*MnpTxData
;
92 IP4_LINK_TX_TOKEN
*Token
;
96 Token
= NetAllocatePool (sizeof (IP4_LINK_TX_TOKEN
) + \
97 (Packet
->BlockOpNum
- 1) * sizeof (EFI_MANAGED_NETWORK_FRAGMENT_DATA
));
103 Token
->Signature
= IP4_FRAME_TX_SIGNATURE
;
104 NetListInit (&Token
->Link
);
106 Token
->Interface
= Interface
;
107 Token
->IpInstance
= IpInstance
;
108 Token
->CallBack
= CallBack
;
109 Token
->Packet
= Packet
;
110 Token
->Context
= Context
;
111 CopyMem (&Token
->DstMac
, &mZeroMacAddress
, sizeof (Token
->DstMac
));
112 CopyMem (&Token
->SrcMac
, &Interface
->Mac
, sizeof (Token
->SrcMac
));
114 MnpToken
= &(Token
->MnpToken
);
115 MnpToken
->Status
= EFI_NOT_READY
;
117 Status
= gBS
->CreateEvent (
125 if (EFI_ERROR (Status
)) {
130 MnpTxData
= &Token
->MnpTxData
;
131 MnpToken
->Packet
.TxData
= MnpTxData
;
133 MnpTxData
->DestinationAddress
= &Token
->DstMac
;
134 MnpTxData
->SourceAddress
= &Token
->SrcMac
;
135 MnpTxData
->ProtocolType
= IP4_ETHER_PROTO
;
136 MnpTxData
->DataLength
= Packet
->TotalSize
;
137 MnpTxData
->HeaderLength
= 0;
139 Count
= Packet
->BlockOpNum
;
141 NetbufBuildExt (Packet
, (NET_FRAGMENT
*) MnpTxData
->FragmentTable
, &Count
);
142 MnpTxData
->FragmentCount
= (UINT16
)Count
;
149 Free the link layer transmit token. It will close the event
150 then free the memory used.
152 @param Token Token to free
160 IN IP4_LINK_TX_TOKEN
*Token
163 NET_CHECK_SIGNATURE (Token
, IP4_FRAME_TX_SIGNATURE
);
165 gBS
->CloseEvent (Token
->MnpToken
.Event
);
171 Create an IP_ARP_QUE structure to request ARP service.
173 @param Interface The interface to send ARP from.
174 @param DestIp The destination IP (host byte order) to request MAC
177 @return Point to newly created IP4_ARP_QUE if succeed, otherwise NULL.
183 IN IP4_INTERFACE
*Interface
,
190 ArpQue
= NetAllocatePool (sizeof (IP4_ARP_QUE
));
192 if (ArpQue
== NULL
) {
196 ArpQue
->Signature
= IP4_FRAME_ARP_SIGNATURE
;
197 NetListInit (&ArpQue
->Link
);
199 NetListInit (&ArpQue
->Frames
);
200 ArpQue
->Interface
= Interface
;
202 Status
= gBS
->CreateEvent (
210 if (EFI_ERROR (Status
)) {
211 NetFreePool (ArpQue
);
216 CopyMem (&ArpQue
->Mac
, &mZeroMacAddress
, sizeof (ArpQue
->Mac
));
223 Remove all the transmit requests queued on the ARP queue, then free it.
225 @param ArpQue Arp queue to free
226 @param IoStatus The transmit status returned to transmit requests'
235 IN IP4_ARP_QUE
*ArpQue
,
236 IN EFI_STATUS IoStatus
239 NET_CHECK_SIGNATURE (ArpQue
, IP4_FRAME_ARP_SIGNATURE
);
242 // Remove all the frame waiting the ARP response
244 Ip4CancelFrameArp (ArpQue
, IoStatus
, NULL
, NULL
);
246 gBS
->CloseEvent (ArpQue
->OnResolved
);
247 NetFreePool (ArpQue
);
252 Create a link layer receive token to wrap the receive request
254 @param Interface The interface to receive from
255 @param IpInstance The instance that request the receive (NULL for IP4
257 @param CallBack Call back function to execute when finished.
258 @param Context Opaque parameters to the callback
260 @return Point to created IP4_LINK_RX_TOKEN if succeed, otherwise NULL.
265 Ip4CreateLinkRxToken (
266 IN IP4_INTERFACE
*Interface
,
267 IN IP4_PROTOCOL
*IpInstance
,
268 IN IP4_FRAME_CALLBACK CallBack
,
272 EFI_MANAGED_NETWORK_COMPLETION_TOKEN
*MnpToken
;
273 IP4_LINK_RX_TOKEN
*Token
;
276 Token
= NetAllocatePool (sizeof (IP4_LINK_RX_TOKEN
));
281 Token
->Signature
= IP4_FRAME_RX_SIGNATURE
;
282 Token
->Interface
= Interface
;
283 Token
->IpInstance
= IpInstance
;
284 Token
->CallBack
= CallBack
;
285 Token
->Context
= Context
;
287 MnpToken
= &Token
->MnpToken
;
288 MnpToken
->Status
= EFI_NOT_READY
;
290 Status
= gBS
->CreateEvent (
298 if (EFI_ERROR (Status
)) {
303 MnpToken
->Packet
.RxData
= NULL
;
309 Free the link layer request token. It will close the event
310 then free the memory used.
312 @param Token Request token to free
319 Ip4FreeFrameRxToken (
320 IN IP4_LINK_RX_TOKEN
*Token
324 NET_CHECK_SIGNATURE (Token
, IP4_FRAME_RX_SIGNATURE
);
326 gBS
->CloseEvent (Token
->MnpToken
.Event
);
332 Remove all the frames on the ARP queue that pass the FrameToCancel,
333 that is, either FrameToCancel is NULL or it returns true for the frame.
335 @param ArpQue ARP frame to remove the frames from.
336 @param IoStatus The status returned to the cancelled frames'
338 @param FrameToCancel Function to select which frame to cancel.
339 @param Context Opaque parameter to the FrameToCancel.
347 IN IP4_ARP_QUE
*ArpQue
,
348 IN EFI_STATUS IoStatus
,
349 IN IP4_FRAME_TO_CANCEL FrameToCancel
, OPTIONAL
353 NET_LIST_ENTRY
*Entry
;
354 NET_LIST_ENTRY
*Next
;
355 IP4_LINK_TX_TOKEN
*Token
;
357 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &ArpQue
->Frames
) {
358 Token
= NET_LIST_USER_STRUCT (Entry
, IP4_LINK_TX_TOKEN
, Link
);
360 if ((FrameToCancel
== NULL
) || FrameToCancel (Token
, Context
)) {
361 NetListRemoveEntry (Entry
);
363 Token
->CallBack (Token
->IpInstance
, Token
->Packet
, IoStatus
, 0, Token
->Context
);
364 Ip4FreeLinkTxToken (Token
);
371 Remove all the frames on the interface that pass the FrameToCancel,
372 either queued on ARP queues or that have already been delivered to
373 MNP and not yet recycled.
375 @param Interface Interface to remove the frames from
376 @param IoStatus The transmit status returned to the frames'
378 @param FrameToCancel Function to select the frame to cancel, NULL to
380 @param Context Opaque parameters passed to FrameToCancel
387 IN IP4_INTERFACE
*Interface
,
388 IN EFI_STATUS IoStatus
,
389 IN IP4_FRAME_TO_CANCEL FrameToCancel
, OPTIONAL
393 NET_LIST_ENTRY
*Entry
;
394 NET_LIST_ENTRY
*Next
;
396 IP4_LINK_TX_TOKEN
*Token
;
399 // Cancel all the pending frames on ARP requests
401 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Interface
->ArpQues
) {
402 ArpQue
= NET_LIST_USER_STRUCT (Entry
, IP4_ARP_QUE
, Link
);
404 Ip4CancelFrameArp (ArpQue
, IoStatus
, FrameToCancel
, Context
);
406 if (NetListIsEmpty (&ArpQue
->Frames
)) {
407 NetListRemoveEntry (Entry
);
409 Interface
->Arp
->Cancel (Interface
->Arp
, &ArpQue
->Ip
, ArpQue
->OnResolved
);
410 Ip4FreeArpQue (ArpQue
, EFI_ABORTED
);
415 // Cancel all the frames that have been delivered to MNP
416 // but not yet recycled.
418 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &Interface
->SentFrames
) {
419 Token
= NET_LIST_USER_STRUCT (Entry
, IP4_LINK_TX_TOKEN
, Link
);
421 if ((FrameToCancel
== NULL
) || FrameToCancel (Token
, Context
)) {
422 NetListRemoveEntry (Entry
);
424 Interface
->Mnp
->Cancel (Interface
->Mnp
, &Token
->MnpToken
);
425 Token
->CallBack (Token
->IpInstance
, Token
->Packet
, IoStatus
, 0, Token
->Context
);
426 Ip4FreeLinkTxToken (Token
);
433 Create an IP4_INTERFACE. Delay the creation of ARP instance until
434 the interface is configured.
436 @param Mnp The shared MNP child of this IP4 service binding
438 @param Controller The controller this IP4 service binding instance
439 is installed. Most like the UNDI handle.
440 @param ImageHandle This driver's image handle
442 @return Point to the created IP4_INTERFACE, otherwise NULL.
447 IN EFI_MANAGED_NETWORK_PROTOCOL
*Mnp
,
448 IN EFI_HANDLE Controller
,
449 IN EFI_HANDLE ImageHandle
452 IP4_INTERFACE
*Interface
;
453 EFI_SIMPLE_NETWORK_MODE SnpMode
;
455 Interface
= NetAllocatePool (sizeof (IP4_INTERFACE
));
457 if ((Interface
== NULL
) || (Mnp
== NULL
)) {
461 Interface
->Signature
= IP4_INTERFACE_SIGNATURE
;
462 NetListInit (&Interface
->Link
);
463 Interface
->RefCnt
= 1;
465 Interface
->Ip
= IP4_ALLZERO_ADDRESS
;
466 Interface
->SubnetMask
= IP4_ALLZERO_ADDRESS
;
467 Interface
->Configured
= FALSE
;
469 Interface
->Controller
= Controller
;
470 Interface
->Image
= ImageHandle
;
471 Interface
->Mnp
= Mnp
;
472 Interface
->Arp
= NULL
;
473 Interface
->ArpHandle
= NULL
;
475 NetListInit (&Interface
->ArpQues
);
476 NetListInit (&Interface
->SentFrames
);
478 Interface
->RecvRequest
= NULL
;
481 // Get the interface's Mac address and broadcast mac address from SNP
483 if (EFI_ERROR (Mnp
->GetModeData (Mnp
, NULL
, &SnpMode
))) {
484 NetFreePool (Interface
);
488 CopyMem (&Interface
->Mac
, &SnpMode
.CurrentAddress
, sizeof (Interface
->Mac
));
489 CopyMem (&Interface
->BroadcastMac
, &SnpMode
.BroadcastAddress
, sizeof (Interface
->BroadcastMac
));
490 Interface
->HwaddrLen
= SnpMode
.HwAddressSize
;
492 NetListInit (&Interface
->IpInstances
);
493 Interface
->PromiscRecv
= FALSE
;
500 Set the interface's address, create and configure
501 the ARP child if necessary.
503 @param Interface The interface to set the address
504 @param IpAddr The interface's IP address
505 @param SubnetMask The interface's netmask
507 @retval EFI_SUCCESS The interface is configured with Ip/netmask pair,
508 and a ARP is created for it.
509 @retval Others Failed to set the interface's address.
514 IN IP4_INTERFACE
*Interface
,
516 IN IP4_ADDR SubnetMask
519 EFI_ARP_CONFIG_DATA ArpConfig
;
525 NET_CHECK_SIGNATURE (Interface
, IP4_INTERFACE_SIGNATURE
);
527 ASSERT (!Interface
->Configured
);
530 // Set the ip/netmask, then compute the subnet broadcast
531 // and network broadcast for easy access. When computing
532 // nework broadcast, the subnet mask is most like longer
533 // than the default netmask (not subneted) as defined in
534 // RFC793. If that isn't the case, we are aggregating the
535 // networks, use the subnet's mask instead.
537 Interface
->Ip
= IpAddr
;
538 Interface
->SubnetMask
= SubnetMask
;
539 Interface
->SubnetBrdcast
= (IpAddr
| ~SubnetMask
);
541 Type
= NetGetIpClass (IpAddr
);
542 Len
= NetGetMaskLength (SubnetMask
);
543 Netmask
= mIp4AllMasks
[NET_MIN (Len
, Type
<< 3)];
544 Interface
->NetBrdcast
= (IpAddr
| ~Netmask
);
547 // If the address is NOT all zero, create then configure an ARP child.
548 // Pay attention: DHCP configures its station address as 0.0.0.0/0
550 Interface
->Arp
= NULL
;
551 Interface
->ArpHandle
= NULL
;
553 if (IpAddr
!= IP4_ALLZERO_ADDRESS
) {
554 Status
= NetLibCreateServiceChild (
555 Interface
->Controller
,
557 &gEfiArpServiceBindingProtocolGuid
,
558 &Interface
->ArpHandle
561 if (EFI_ERROR (Status
)) {
565 Status
= gBS
->OpenProtocol (
566 Interface
->ArpHandle
,
567 &gEfiArpProtocolGuid
,
568 (VOID
**) &Interface
->Arp
,
570 Interface
->Controller
,
571 EFI_OPEN_PROTOCOL_BY_DRIVER
574 if (EFI_ERROR (Status
)) {
578 IpAddr
= HTONL (IpAddr
);
579 ArpConfig
.SwAddressType
= IP4_ETHER_PROTO
;
580 ArpConfig
.SwAddressLength
= 4;
581 ArpConfig
.StationAddress
= &IpAddr
;
582 ArpConfig
.EntryTimeOut
= 0;
583 ArpConfig
.RetryCount
= 0;
584 ArpConfig
.RetryTimeOut
= 0;
586 Status
= Interface
->Arp
->Configure (Interface
->Arp
, &ArpConfig
);
588 if (EFI_ERROR (Status
)) {
590 Interface
->ArpHandle
,
591 &gEfiArpProtocolGuid
,
593 Interface
->Controller
600 Interface
->Configured
= TRUE
;
604 NetLibDestroyServiceChild (
605 Interface
->Controller
,
607 &gEfiArpServiceBindingProtocolGuid
,
608 &Interface
->ArpHandle
616 Fileter function to cancel all the frame related to an IP instance.
618 @param Frame The transmit request to test whether to cancel
619 @param Context The context which is the Ip instance that issued
622 @retval TRUE The frame belongs to this instance and is to be
624 @retval FALSE The frame doesn't belong to this instance.
629 Ip4CancelInstanceFrame (
630 IN IP4_LINK_TX_TOKEN
*Frame
,
634 if (Frame
->IpInstance
== (IP4_PROTOCOL
*) Context
) {
644 If there is a pending receive request, cancel it. Don't call
645 the receive request's callback because this function can be only
646 called if the instance or driver is tearing itself down. It
647 doesn't make sense to call it back. But it is necessary to call
648 the transmit token's callback to give it a chance to free the
649 packet and update the upper layer's transmit request status, say
652 @param Interface The interface used by the IpInstance
659 IN IP4_INTERFACE
*Interface
663 IP4_LINK_RX_TOKEN
*Token
;
665 if ((Token
= Interface
->RecvRequest
) != NULL
) {
666 OldTpl
= NET_RAISE_TPL (NET_TPL_LOCK
);
668 Interface
->RecvRequest
= NULL
;
669 Interface
->Mnp
->Cancel (Interface
->Mnp
, &Token
->MnpToken
);
670 Ip4FreeFrameRxToken (Token
);
672 NET_RESTORE_TPL (OldTpl
);
678 Free the interface used by IpInstance. All the IP instance with
679 the same Ip/Netmask pair share the same interface. It is reference
680 counted. All the frames haven't been sent will be cancelled.
681 Because the IpInstance is optional, the caller must remove
682 IpInstance from the interface's instance list itself.
684 @param Interface The interface used by the IpInstance
685 @param IpInstance The Ip instance that free the interface. NULL if
686 the Ip driver is releasing the default interface.
688 @retval EFI_SUCCESS The interface use IpInstance is freed.
693 IN IP4_INTERFACE
*Interface
,
694 IN IP4_PROTOCOL
*IpInstance OPTIONAL
697 NET_CHECK_SIGNATURE (Interface
, IP4_INTERFACE_SIGNATURE
);
698 ASSERT (Interface
->RefCnt
> 0);
701 // Remove all the pending transmit token related to this IP instance.
703 Ip4CancelFrames (Interface
, EFI_ABORTED
, Ip4CancelInstanceFrame
, IpInstance
);
705 if (--Interface
->RefCnt
> 0) {
710 // Destory the interface if this is the last IP instance that
711 // has the address. Remove all the system transmitted packets
712 // from this interface, cancel the receive request if there is
713 // one, and destory the ARP requests.
715 Ip4CancelFrames (Interface
, EFI_ABORTED
, Ip4CancelInstanceFrame
, NULL
);
716 Ip4CancelReceive (Interface
);
718 ASSERT (NetListIsEmpty (&Interface
->IpInstances
));
719 ASSERT (NetListIsEmpty (&Interface
->ArpQues
));
720 ASSERT (NetListIsEmpty (&Interface
->SentFrames
));
722 if (Interface
->Arp
!= NULL
) {
724 Interface
->ArpHandle
,
725 &gEfiArpProtocolGuid
,
727 Interface
->Controller
730 NetLibDestroyServiceChild (
731 Interface
->Controller
,
733 &gEfiArpServiceBindingProtocolGuid
,
738 NetListRemoveEntry (&Interface
->Link
);
739 NetFreePool (Interface
);
746 Callback function when ARP request are finished. It will cancelled
747 all the queued frame if the ARP requests failed. Or transmit them
748 if the request succeed.
750 @param Event The Arp request event
751 @param Context The context of the callback, a point to the ARP
765 NET_LIST_ENTRY
*Entry
;
766 NET_LIST_ENTRY
*Next
;
768 IP4_INTERFACE
*Interface
;
769 IP4_LINK_TX_TOKEN
*Token
;
772 ArpQue
= (IP4_ARP_QUE
*) Context
;
773 NET_CHECK_SIGNATURE (ArpQue
, IP4_FRAME_ARP_SIGNATURE
);
775 NetListRemoveEntry (&ArpQue
->Link
);
778 // ARP resolve failed for some reason. Release all the frame
779 // and ARP queue itself. Ip4FreeArpQue will call the frame's
782 if (NET_MAC_EQUAL (&ArpQue
->Mac
, &mZeroMacAddress
, ArpQue
->Interface
->HwaddrLen
)) {
783 Ip4FreeArpQue (ArpQue
, EFI_NO_MAPPING
);
789 // ARP resolve succeeded, Transmit all the frame. Release the ARP
790 // queue. It isn't necessary for us to cache the ARP binding because
791 // we always check the ARP cache first before transmit.
793 Interface
= ArpQue
->Interface
;
795 NET_LIST_FOR_EACH_SAFE (Entry
, Next
, &ArpQue
->Frames
) {
796 NetListRemoveEntry (Entry
);
798 Token
= NET_LIST_USER_STRUCT (Entry
, IP4_LINK_TX_TOKEN
, Link
);
799 CopyMem (&Token
->DstMac
, &ArpQue
->Mac
, sizeof (Token
->DstMac
));
801 Status
= Interface
->Mnp
->Transmit (Interface
->Mnp
, &Token
->MnpToken
);
803 if (EFI_ERROR (Status
)) {
804 Token
->CallBack (Token
->IpInstance
, Token
->Packet
, Status
, 0, Token
->Context
);
806 Ip4FreeLinkTxToken (Token
);
810 NetListInsertTail (&Interface
->SentFrames
, &Token
->Link
);
813 Ip4FreeArpQue (ArpQue
, EFI_SUCCESS
);
818 Callback funtion when frame transmission is finished. It will
819 call the frame owner's callback function to tell it the result.
821 @param Event The transmit token's event
822 @param Context Context which is point to the token.
835 IP4_LINK_TX_TOKEN
*Token
;
837 Token
= (IP4_LINK_TX_TOKEN
*) Context
;
838 NET_CHECK_SIGNATURE (Token
, IP4_FRAME_TX_SIGNATURE
);
840 NetListRemoveEntry (&Token
->Link
);
845 Token
->MnpToken
.Status
,
850 Ip4FreeLinkTxToken (Token
);
856 Send a frame from the interface. If the next hop is broadcast or
857 multicast address, it is transmitted immediately. If the next hop
858 is a unicast, it will consult ARP to resolve the NextHop's MAC.
859 If some error happened, the CallBack won't be called. So, the caller
860 must test the return value, and take action when there is an error.
862 @param Interface The interface to send the frame from
863 @param IpInstance The IP child that request the transmission. NULL
864 if it is the IP4 driver itself.
865 @param Packet The packet to transmit.
866 @param NextHop The immediate destination to transmit the packet
868 @param CallBack Function to call back when transmit finished.
869 @param Context Opaque parameter to the call back.
871 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to send the frame
872 @retval EFI_NO_MAPPING Can't resolve the MAC for the nexthop
873 @retval EFI_SUCCESS The packet is successfully transmitted.
878 IN IP4_INTERFACE
*Interface
,
879 IN IP4_PROTOCOL
*IpInstance
, OPTIONAL
882 IN IP4_FRAME_CALLBACK CallBack
,
886 IP4_LINK_TX_TOKEN
*Token
;
887 NET_LIST_ENTRY
*Entry
;
889 EFI_ARP_PROTOCOL
*Arp
;
892 ASSERT (Interface
->Configured
);
894 Token
= Ip4WrapLinkTxToken (Interface
, IpInstance
, Packet
, CallBack
, Context
);
897 return EFI_OUT_OF_RESOURCES
;
901 // Get the destination MAC address for multicast and broadcasts.
902 // Don't depend on ARP to solve the address since there maybe no
903 // ARP at all. Ip4Output has set NextHop to 255.255.255.255 for
904 // all the broadcasts.
906 if (NextHop
== IP4_ALLONE_ADDRESS
) {
907 CopyMem (&Token
->DstMac
, &Interface
->BroadcastMac
, sizeof (Token
->DstMac
));
910 } else if (IP4_IS_MULTICAST (NextHop
)) {
912 Status
= Ip4GetMulticastMac (Interface
->Mnp
, NextHop
, &Token
->DstMac
);
914 if (EFI_ERROR (Status
)) {
922 // Can only send out multicast/broadcast if the IP address is zero
924 if ((Arp
= Interface
->Arp
) == NULL
) {
925 Status
= EFI_NO_MAPPING
;
930 // First check whether this binding is in the ARP cache.
932 NextHop
= HTONL (NextHop
);
933 Status
= Arp
->Request (Arp
, &NextHop
, NULL
, &Token
->DstMac
);
935 if (Status
== EFI_SUCCESS
) {
938 } else if (Status
!= EFI_NOT_READY
) {
943 // Have to do asynchronous ARP resolution. First check
944 // whether there is already a pending request.
948 NET_LIST_FOR_EACH (Entry
, &Interface
->ArpQues
) {
949 ArpQue
= NET_LIST_USER_STRUCT (Entry
, IP4_ARP_QUE
, Link
);
951 if (ArpQue
->Ip
== NextHop
) {
957 // Found a pending ARP request, enqueue the frame then return
959 if (Entry
!= &Interface
->ArpQues
) {
960 NetListInsertTail (&ArpQue
->Frames
, &Token
->Link
);
965 // First frame to NextHop, issue an asynchronous ARP requests
967 ArpQue
= Ip4CreateArpQue (Interface
, NextHop
);
969 if (ArpQue
== NULL
) {
970 Status
= EFI_OUT_OF_RESOURCES
;
974 Status
= Arp
->Request (Arp
, &ArpQue
->Ip
, ArpQue
->OnResolved
, ArpQue
->Mac
.Addr
);
976 if (EFI_ERROR (Status
) && (Status
!= EFI_NOT_READY
)) {
977 Ip4FreeArpQue (ArpQue
, EFI_NO_MAPPING
);
981 NetListInsertHead (&ArpQue
->Frames
, &Token
->Link
);
982 NetListInsertHead (&Interface
->ArpQues
, &ArpQue
->Link
);
986 Status
= Interface
->Mnp
->Transmit (Interface
->Mnp
, &Token
->MnpToken
);
988 if (EFI_ERROR (Status
)) {
992 NetListInsertTail (&Interface
->SentFrames
, &Token
->Link
);
996 Ip4FreeLinkTxToken (Token
);
1002 Call back function when the received packet is freed.
1003 Check Ip4OnFrameReceived for information.
1005 @param Context Context, which is the IP4_LINK_RX_TOKEN.
1016 IP4_LINK_RX_TOKEN
*Frame
;
1018 Frame
= (IP4_LINK_RX_TOKEN
*) Context
;
1019 NET_CHECK_SIGNATURE (Frame
, IP4_FRAME_RX_SIGNATURE
);
1021 gBS
->SignalEvent (Frame
->MnpToken
.Packet
.RxData
->RecycleEvent
);
1022 Ip4FreeFrameRxToken (Frame
);
1027 Received a frame from MNP, wrap it in net buffer then deliver
1028 it to IP's input function. The ownship of the packet also
1029 transferred to IP. When Ip is finished with this packet, it
1030 will call NetbufFree to release the packet, NetbufFree will
1031 again call the Ip4RecycleFrame to signal MNP's event and free
1034 @param Event The receive event delivered to MNP for receive.
1035 @param Context Context for the callback.
1043 Ip4OnFrameReceived (
1048 EFI_MANAGED_NETWORK_COMPLETION_TOKEN
*MnpToken
;
1049 EFI_MANAGED_NETWORK_RECEIVE_DATA
*MnpRxData
;
1050 IP4_LINK_RX_TOKEN
*Token
;
1051 NET_FRAGMENT Netfrag
;
1055 Token
= (IP4_LINK_RX_TOKEN
*) Context
;
1056 NET_CHECK_SIGNATURE (Token
, IP4_FRAME_RX_SIGNATURE
);
1059 // First clear the interface's receive request in case the
1060 // caller wants to call Ip4ReceiveFrame in the callback.
1062 Token
->Interface
->RecvRequest
= NULL
;
1064 MnpToken
= &Token
->MnpToken
;
1065 MnpRxData
= MnpToken
->Packet
.RxData
;
1067 if (EFI_ERROR (MnpToken
->Status
) || (MnpRxData
== NULL
)) {
1068 Token
->CallBack (Token
->IpInstance
, NULL
, MnpToken
->Status
, 0, Token
->Context
);
1069 Ip4FreeFrameRxToken (Token
);
1075 // Wrap the frame in a net buffer then deliever it to IP input.
1076 // IP will reassemble the packet, and deliver it to upper layer
1078 Netfrag
.Len
= MnpRxData
->DataLength
;
1079 Netfrag
.Bulk
= MnpRxData
->PacketData
;
1081 Packet
= NetbufFromExt (&Netfrag
, 1, 0, IP4_MAX_HEADLEN
, Ip4RecycleFrame
, Token
);
1083 if (Packet
== NULL
) {
1084 gBS
->SignalEvent (MnpRxData
->RecycleEvent
);
1086 Token
->CallBack (Token
->IpInstance
, NULL
, EFI_OUT_OF_RESOURCES
, 0, Token
->Context
);
1087 Ip4FreeFrameRxToken (Token
);
1092 Flag
= (MnpRxData
->BroadcastFlag
? IP4_LINK_BROADCAST
: 0);
1093 Flag
|= (MnpRxData
->MulticastFlag
? IP4_LINK_MULTICAST
: 0);
1094 Flag
|= (MnpRxData
->PromiscuousFlag
? IP4_LINK_PROMISC
: 0);
1096 Token
->CallBack (Token
->IpInstance
, Packet
, EFI_SUCCESS
, Flag
, Token
->Context
);
1101 Request to receive the packet from the interface.
1103 @param Interface The interface to receive the frames from
1104 @param IpInstance The instance that requests the receive. NULL for
1106 @param CallBack Function to call when receive finished.
1107 @param Context Opaque parameter to the callback
1109 @retval EFI_ALREADY_STARTED There is already a pending receive request.
1110 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to receive
1111 @retval EFI_SUCCESS The recieve request has been started.
1116 IN IP4_INTERFACE
*Interface
,
1117 IN IP4_PROTOCOL
*IpInstance
, OPTIONAL
1118 IN IP4_FRAME_CALLBACK CallBack
,
1122 IP4_LINK_RX_TOKEN
*Token
;
1125 NET_CHECK_SIGNATURE (Interface
, IP4_INTERFACE_SIGNATURE
);
1127 if (Interface
->RecvRequest
!= NULL
) {
1128 return EFI_ALREADY_STARTED
;
1131 Token
= Ip4CreateLinkRxToken (Interface
, IpInstance
, CallBack
, Context
);
1133 if (Token
== NULL
) {
1134 return EFI_OUT_OF_RESOURCES
;
1137 Status
= Interface
->Mnp
->Receive (Interface
->Mnp
, &Token
->MnpToken
);
1139 if (EFI_ERROR (Status
)) {
1140 Ip4FreeFrameRxToken (Token
);
1144 Interface
->RecvRequest
= Token
;