VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip4Dxe/Ip4If.c@ 106129

Last change on this file since 106129 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 35.9 KB
Line 
1/** @file
2 Implement IP4 pseudo interface.
3
4Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Ip4Impl.h"
10
11//
12// Mac address with all zero, used to determine whether the ARP
13// resolve succeeded. Failed ARP requests zero the MAC address buffer.
14//
15EFI_MAC_ADDRESS mZeroMacAddress;
16
17/**
18 Callback function when frame transmission is finished. It will
19 call the frame owner's callback function to tell it the result.
20
21 @param[in] Context Context which is point to the token.
22
23**/
24VOID
25EFIAPI
26Ip4OnFrameSentDpc (
27 IN VOID *Context
28 );
29
30/**
31 Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK.
32
33 @param[in] Event The transmit token's event.
34 @param[in] Context Context which is point to the token.
35
36**/
37VOID
38EFIAPI
39Ip4OnFrameSent (
40 IN EFI_EVENT Event,
41 IN VOID *Context
42 );
43
44/**
45 Callback function when ARP request are finished. It will cancelled
46 all the queued frame if the ARP requests failed. Or transmit them
47 if the request succeed.
48
49 @param[in] Context The context of the callback, a point to the ARP
50 queue
51
52**/
53VOID
54EFIAPI
55Ip4OnArpResolvedDpc (
56 IN VOID *Context
57 );
58
59/**
60 Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK.
61
62 @param Event The Arp request event.
63 @param Context The context of the callback, a point to the ARP
64 queue.
65
66**/
67VOID
68EFIAPI
69Ip4OnArpResolved (
70 IN EFI_EVENT Event,
71 IN VOID *Context
72 );
73
74/**
75 Received a frame from MNP, wrap it in net buffer then deliver
76 it to IP's input function. The ownship of the packet also
77 transferred to IP. When Ip is finished with this packet, it
78 will call NetbufFree to release the packet, NetbufFree will
79 again call the Ip4RecycleFrame to signal MNP's event and free
80 the token used.
81
82 @param Context Context for the callback.
83
84**/
85VOID
86EFIAPI
87Ip4OnFrameReceivedDpc (
88 IN VOID *Context
89 );
90
91/**
92 Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK.
93
94 @param Event The receive event delivered to MNP for receive.
95 @param Context Context for the callback.
96
97**/
98VOID
99EFIAPI
100Ip4OnFrameReceived (
101 IN EFI_EVENT Event,
102 IN VOID *Context
103 );
104
105/**
106 Remove all the frames on the ARP queue that pass the FrameToCancel,
107 that is, either FrameToCancel is NULL or it returns true for the frame.
108
109 @param[in] ArpQue ARP frame to remove the frames from.
110 @param[in] IoStatus The status returned to the cancelled frames'
111 callback function.
112 @param[in] FrameToCancel Function to select which frame to cancel.
113 @param[in] Context Opaque parameter to the FrameToCancel.
114
115**/
116VOID
117Ip4CancelFrameArp (
118 IN IP4_ARP_QUE *ArpQue,
119 IN EFI_STATUS IoStatus,
120 IN IP4_FRAME_TO_CANCEL FrameToCancel OPTIONAL,
121 IN VOID *Context
122 );
123
124/**
125 Wrap a transmit request into a newly allocated IP4_LINK_TX_TOKEN.
126
127 @param[in] Interface The interface to send out to.
128 @param[in] IpInstance The IpInstance that transmit the packet. NULL if
129 the packet is sent by the IP4 driver itself.
130 @param[in] Packet The packet to transmit
131 @param[in] CallBack Call back function to execute if transmission
132 finished.
133 @param[in] Context Opaque parameter to the call back.
134 @param[in] IpSb The pointer to the IP4 service binding instance.
135
136 @retval Token The wrapped token if succeed
137 @retval NULL The wrapped token if NULL
138
139**/
140IP4_LINK_TX_TOKEN *
141Ip4WrapLinkTxToken (
142 IN IP4_INTERFACE *Interface,
143 IN IP4_PROTOCOL *IpInstance OPTIONAL,
144 IN NET_BUF *Packet,
145 IN IP4_FRAME_CALLBACK CallBack,
146 IN VOID *Context,
147 IN IP4_SERVICE *IpSb
148 )
149{
150 EFI_MANAGED_NETWORK_COMPLETION_TOKEN *MnpToken;
151 EFI_MANAGED_NETWORK_TRANSMIT_DATA *MnpTxData;
152 IP4_LINK_TX_TOKEN *Token;
153 EFI_STATUS Status;
154 UINT32 Count;
155
156 Token = AllocatePool (
157 sizeof (IP4_LINK_TX_TOKEN) + \
158 (Packet->BlockOpNum - 1) * sizeof (EFI_MANAGED_NETWORK_FRAGMENT_DATA)
159 );
160
161 if (Token == NULL) {
162 return NULL;
163 }
164
165 Token->Signature = IP4_FRAME_TX_SIGNATURE;
166 InitializeListHead (&Token->Link);
167
168 Token->Interface = Interface;
169 Token->IpInstance = IpInstance;
170 Token->IpSb = IpSb;
171 Token->CallBack = CallBack;
172 Token->Packet = Packet;
173 Token->Context = Context;
174 CopyMem (&Token->DstMac, &mZeroMacAddress, sizeof (Token->DstMac));
175 CopyMem (&Token->SrcMac, &Interface->Mac, sizeof (Token->SrcMac));
176
177 MnpToken = &(Token->MnpToken);
178 MnpToken->Status = EFI_NOT_READY;
179
180 Status = gBS->CreateEvent (
181 EVT_NOTIFY_SIGNAL,
182 TPL_NOTIFY,
183 Ip4OnFrameSent,
184 Token,
185 &MnpToken->Event
186 );
187
188 if (EFI_ERROR (Status)) {
189 FreePool (Token);
190 return NULL;
191 }
192
193 MnpTxData = &Token->MnpTxData;
194 MnpToken->Packet.TxData = MnpTxData;
195
196 MnpTxData->DestinationAddress = &Token->DstMac;
197 MnpTxData->SourceAddress = &Token->SrcMac;
198 MnpTxData->ProtocolType = IP4_ETHER_PROTO;
199 MnpTxData->DataLength = Packet->TotalSize;
200 MnpTxData->HeaderLength = 0;
201
202 Count = Packet->BlockOpNum;
203
204 NetbufBuildExt (Packet, (NET_FRAGMENT *)MnpTxData->FragmentTable, &Count);
205 MnpTxData->FragmentCount = (UINT16)Count;
206
207 return Token;
208}
209
210/**
211 Free the link layer transmit token. It will close the event
212 then free the memory used.
213
214 @param[in] Token Token to free
215
216**/
217VOID
218Ip4FreeLinkTxToken (
219 IN IP4_LINK_TX_TOKEN *Token
220 )
221{
222 NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
223
224 gBS->CloseEvent (Token->MnpToken.Event);
225 FreePool (Token);
226}
227
228/**
229 Create an IP_ARP_QUE structure to request ARP service.
230
231 @param[in] Interface The interface to send ARP from.
232 @param[in] DestIp The destination IP (host byte order) to request MAC
233 for
234
235 @return Point to newly created IP4_ARP_QUE if succeed, otherwise NULL.
236
237**/
238IP4_ARP_QUE *
239Ip4CreateArpQue (
240 IN IP4_INTERFACE *Interface,
241 IN IP4_ADDR DestIp
242 )
243{
244 IP4_ARP_QUE *ArpQue;
245 EFI_STATUS Status;
246
247 ArpQue = AllocatePool (sizeof (IP4_ARP_QUE));
248
249 if (ArpQue == NULL) {
250 return NULL;
251 }
252
253 ArpQue->Signature = IP4_FRAME_ARP_SIGNATURE;
254 InitializeListHead (&ArpQue->Link);
255
256 InitializeListHead (&ArpQue->Frames);
257 ArpQue->Interface = Interface;
258
259 Status = gBS->CreateEvent (
260 EVT_NOTIFY_SIGNAL,
261 TPL_NOTIFY,
262 Ip4OnArpResolved,
263 ArpQue,
264 &ArpQue->OnResolved
265 );
266
267 if (EFI_ERROR (Status)) {
268 FreePool (ArpQue);
269 return NULL;
270 }
271
272 ArpQue->Ip = DestIp;
273 CopyMem (&ArpQue->Mac, &mZeroMacAddress, sizeof (ArpQue->Mac));
274
275 return ArpQue;
276}
277
278/**
279 Remove all the transmit requests queued on the ARP queue, then free it.
280
281 @param[in] ArpQue Arp queue to free
282 @param[in] IoStatus The transmit status returned to transmit requests'
283 callback.
284
285**/
286VOID
287Ip4FreeArpQue (
288 IN IP4_ARP_QUE *ArpQue,
289 IN EFI_STATUS IoStatus
290 )
291{
292 NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
293
294 //
295 // Remove all the frame waiting the ARP response
296 //
297 Ip4CancelFrameArp (ArpQue, IoStatus, NULL, NULL);
298
299 gBS->CloseEvent (ArpQue->OnResolved);
300 FreePool (ArpQue);
301}
302
303/**
304 Create a link layer receive token to wrap the receive request
305
306 @param[in] Interface The interface to receive from
307 @param[in] IpInstance The instance that request the receive (NULL for IP4
308 driver itself)
309 @param[in] CallBack Call back function to execute when finished.
310 @param[in] Context Opaque parameters to the callback
311
312 @return Point to created IP4_LINK_RX_TOKEN if succeed, otherwise NULL.
313
314**/
315IP4_LINK_RX_TOKEN *
316Ip4CreateLinkRxToken (
317 IN IP4_INTERFACE *Interface,
318 IN IP4_PROTOCOL *IpInstance,
319 IN IP4_FRAME_CALLBACK CallBack,
320 IN VOID *Context
321 )
322{
323 EFI_MANAGED_NETWORK_COMPLETION_TOKEN *MnpToken;
324 IP4_LINK_RX_TOKEN *Token;
325 EFI_STATUS Status;
326
327 Token = AllocatePool (sizeof (IP4_LINK_RX_TOKEN));
328 if (Token == NULL) {
329 return NULL;
330 }
331
332 Token->Signature = IP4_FRAME_RX_SIGNATURE;
333 Token->Interface = Interface;
334 Token->IpInstance = IpInstance;
335 Token->CallBack = CallBack;
336 Token->Context = Context;
337
338 MnpToken = &Token->MnpToken;
339 MnpToken->Status = EFI_NOT_READY;
340
341 Status = gBS->CreateEvent (
342 EVT_NOTIFY_SIGNAL,
343 TPL_NOTIFY,
344 Ip4OnFrameReceived,
345 Token,
346 &MnpToken->Event
347 );
348
349 if (EFI_ERROR (Status)) {
350 FreePool (Token);
351 return NULL;
352 }
353
354 MnpToken->Packet.RxData = NULL;
355 return Token;
356}
357
358/**
359 Free the link layer request token. It will close the event
360 then free the memory used.
361
362 @param[in] Token Request token to free.
363
364**/
365VOID
366Ip4FreeFrameRxToken (
367 IN IP4_LINK_RX_TOKEN *Token
368 )
369{
370 NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
371
372 gBS->CloseEvent (Token->MnpToken.Event);
373 FreePool (Token);
374}
375
376/**
377 Remove all the frames on the ARP queue that pass the FrameToCancel,
378 that is, either FrameToCancel is NULL or it returns true for the frame.
379
380 @param[in] ArpQue ARP frame to remove the frames from.
381 @param[in] IoStatus The status returned to the cancelled frames'
382 callback function.
383 @param[in] FrameToCancel Function to select which frame to cancel.
384 @param[in] Context Opaque parameter to the FrameToCancel.
385
386**/
387VOID
388Ip4CancelFrameArp (
389 IN IP4_ARP_QUE *ArpQue,
390 IN EFI_STATUS IoStatus,
391 IN IP4_FRAME_TO_CANCEL FrameToCancel OPTIONAL,
392 IN VOID *Context
393 )
394{
395 LIST_ENTRY *Entry;
396 LIST_ENTRY *Next;
397 IP4_LINK_TX_TOKEN *Token;
398
399 NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
400 Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
401
402 if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
403 RemoveEntryList (Entry);
404
405 Token->CallBack (Token->IpInstance, Token->Packet, IoStatus, 0, Token->Context);
406 Ip4FreeLinkTxToken (Token);
407 }
408 }
409}
410
411/**
412 Remove all the frames on the interface that pass the FrameToCancel,
413 either queued on ARP queues or that have already been delivered to
414 MNP and not yet recycled.
415
416 @param[in] Interface Interface to remove the frames from.
417 @param[in] IoStatus The transmit status returned to the frames'
418 callback.
419 @param[in] FrameToCancel Function to select the frame to cancel, NULL to
420 select all.
421 @param[in] Context Opaque parameters passed to FrameToCancel.
422
423**/
424VOID
425Ip4CancelFrames (
426 IN IP4_INTERFACE *Interface,
427 IN EFI_STATUS IoStatus,
428 IN IP4_FRAME_TO_CANCEL FrameToCancel OPTIONAL,
429 IN VOID *Context
430 )
431{
432 LIST_ENTRY *Entry;
433 LIST_ENTRY *Next;
434 IP4_ARP_QUE *ArpQue;
435 IP4_LINK_TX_TOKEN *Token;
436
437 //
438 // Cancel all the pending frames on ARP requests
439 //
440 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {
441 ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
442
443 Ip4CancelFrameArp (ArpQue, IoStatus, FrameToCancel, Context);
444
445 if (IsListEmpty (&ArpQue->Frames)) {
446 Interface->Arp->Cancel (Interface->Arp, &ArpQue->Ip, ArpQue->OnResolved);
447 }
448 }
449
450 //
451 // Cancel all the frames that have been delivered to MNP
452 // but not yet recycled.
453 //
454 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {
455 Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
456
457 if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {
458 Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
459 }
460 }
461}
462
463/**
464 Create an IP4_INTERFACE. Delay the creation of ARP instance until
465 the interface is configured.
466
467 @param[in] Mnp The shared MNP child of this IP4 service binding
468 instance.
469 @param[in] Controller The controller this IP4 service binding instance
470 is installed. Most like the UNDI handle.
471 @param[in] ImageHandle This driver's image handle.
472
473 @return Point to the created IP4_INTERFACE, otherwise NULL.
474
475**/
476IP4_INTERFACE *
477Ip4CreateInterface (
478 IN EFI_MANAGED_NETWORK_PROTOCOL *Mnp,
479 IN EFI_HANDLE Controller,
480 IN EFI_HANDLE ImageHandle
481 )
482{
483 IP4_INTERFACE *Interface;
484 EFI_SIMPLE_NETWORK_MODE SnpMode;
485
486 if (Mnp == NULL) {
487 return NULL;
488 }
489
490 Interface = AllocatePool (sizeof (IP4_INTERFACE));
491
492 if (Interface == NULL) {
493 return NULL;
494 }
495
496 Interface->Signature = IP4_INTERFACE_SIGNATURE;
497 InitializeListHead (&Interface->Link);
498 Interface->RefCnt = 1;
499
500 Interface->Ip = IP4_ALLZERO_ADDRESS;
501 Interface->SubnetMask = IP4_ALLZERO_ADDRESS;
502 Interface->Configured = FALSE;
503
504 Interface->Controller = Controller;
505 Interface->Image = ImageHandle;
506 Interface->Mnp = Mnp;
507 Interface->Arp = NULL;
508 Interface->ArpHandle = NULL;
509
510 InitializeListHead (&Interface->ArpQues);
511 InitializeListHead (&Interface->SentFrames);
512
513 Interface->RecvRequest = NULL;
514
515 //
516 // Get the interface's Mac address and broadcast mac address from SNP
517 //
518 if (EFI_ERROR (Mnp->GetModeData (Mnp, NULL, &SnpMode))) {
519 FreePool (Interface);
520 return NULL;
521 }
522
523 CopyMem (&Interface->Mac, &SnpMode.CurrentAddress, sizeof (Interface->Mac));
524 CopyMem (&Interface->BroadcastMac, &SnpMode.BroadcastAddress, sizeof (Interface->BroadcastMac));
525 Interface->HwaddrLen = SnpMode.HwAddressSize;
526
527 InitializeListHead (&Interface->IpInstances);
528 Interface->PromiscRecv = FALSE;
529
530 return Interface;
531}
532
533/**
534 Set the interface's address, create and configure
535 the ARP child if necessary.
536
537 @param Interface The interface to set the address.
538 @param IpAddr The interface's IP address.
539 @param SubnetMask The interface's netmask.
540
541 @retval EFI_SUCCESS The interface is configured with Ip/netmask pair,
542 and a ARP is created for it.
543 @retval Others Failed to set the interface's address.
544
545**/
546EFI_STATUS
547Ip4SetAddress (
548 IN OUT IP4_INTERFACE *Interface,
549 IN IP4_ADDR IpAddr,
550 IN IP4_ADDR SubnetMask
551 )
552{
553 EFI_ARP_CONFIG_DATA ArpConfig;
554 EFI_STATUS Status;
555
556 NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
557
558 //
559 // Set the ip/netmask, then compute the subnet broadcast
560 // and network broadcast for easy access. When computing
561 // network broadcast, the subnet mask is most like longer
562 // than the default netmask (not subneted) as defined in
563 // RFC793. If that isn't the case, we are aggregating the
564 // networks, use the subnet's mask instead.
565 //
566 Interface->Ip = IpAddr;
567 Interface->SubnetMask = SubnetMask;
568 Interface->SubnetBrdcast = (IpAddr | ~SubnetMask);
569 Interface->NetBrdcast = (IpAddr | ~SubnetMask);
570
571 //
572 // Do clean up for Arp child
573 //
574 if (Interface->ArpHandle != NULL) {
575 if (Interface->Arp != NULL) {
576 gBS->CloseProtocol (
577 Interface->ArpHandle,
578 &gEfiArpProtocolGuid,
579 Interface->Image,
580 Interface->Controller
581 );
582
583 Interface->Arp = NULL;
584 }
585
586 NetLibDestroyServiceChild (
587 Interface->Controller,
588 Interface->Image,
589 &gEfiArpServiceBindingProtocolGuid,
590 Interface->ArpHandle
591 );
592
593 Interface->ArpHandle = NULL;
594 }
595
596 //
597 // If the address is NOT all zero, create then configure an ARP child.
598 // Pay attention: DHCP configures its station address as 0.0.0.0/0
599 //
600 if (IpAddr != IP4_ALLZERO_ADDRESS) {
601 Status = NetLibCreateServiceChild (
602 Interface->Controller,
603 Interface->Image,
604 &gEfiArpServiceBindingProtocolGuid,
605 &Interface->ArpHandle
606 );
607
608 if (EFI_ERROR (Status)) {
609 return Status;
610 }
611
612 Status = gBS->OpenProtocol (
613 Interface->ArpHandle,
614 &gEfiArpProtocolGuid,
615 (VOID **)&Interface->Arp,
616 Interface->Image,
617 Interface->Controller,
618 EFI_OPEN_PROTOCOL_BY_DRIVER
619 );
620
621 if (EFI_ERROR (Status)) {
622 goto ON_ERROR;
623 }
624
625 IpAddr = HTONL (IpAddr);
626 ArpConfig.SwAddressType = IP4_ETHER_PROTO;
627 ArpConfig.SwAddressLength = 4;
628 ArpConfig.StationAddress = &IpAddr;
629 ArpConfig.EntryTimeOut = 0;
630 ArpConfig.RetryCount = 0;
631 ArpConfig.RetryTimeOut = 0;
632
633 Status = Interface->Arp->Configure (Interface->Arp, &ArpConfig);
634
635 if (EFI_ERROR (Status)) {
636 gBS->CloseProtocol (
637 Interface->ArpHandle,
638 &gEfiArpProtocolGuid,
639 Interface->Image,
640 Interface->Controller
641 );
642
643 goto ON_ERROR;
644 }
645 }
646
647 Interface->Configured = TRUE;
648 return EFI_SUCCESS;
649
650ON_ERROR:
651 NetLibDestroyServiceChild (
652 Interface->Controller,
653 Interface->Image,
654 &gEfiArpServiceBindingProtocolGuid,
655 Interface->ArpHandle
656 );
657
658 return Status;
659}
660
661/**
662 Filter function to cancel all the frame related to an IP instance.
663
664 @param[in] Frame The transmit request to test whether to cancel
665 @param[in] Context The context which is the Ip instance that issued
666 the transmit.
667
668 @retval TRUE The frame belongs to this instance and is to be
669 removed
670 @retval FALSE The frame doesn't belong to this instance.
671
672**/
673BOOLEAN
674Ip4CancelInstanceFrame (
675 IN IP4_LINK_TX_TOKEN *Frame,
676 IN VOID *Context
677 )
678{
679 if (Frame->IpInstance == (IP4_PROTOCOL *)Context) {
680 return TRUE;
681 }
682
683 return FALSE;
684}
685
686/**
687 If there is a pending receive request, cancel it. Don't call
688 the receive request's callback because this function can be only
689 called if the instance or driver is tearing itself down. It
690 doesn't make sense to call it back. But it is necessary to call
691 the transmit token's callback to give it a chance to free the
692 packet and update the upper layer's transmit request status, say
693 that from the UDP.
694
695 @param[in] Interface The interface used by the IpInstance
696
697**/
698VOID
699Ip4CancelReceive (
700 IN IP4_INTERFACE *Interface
701 )
702{
703 EFI_TPL OldTpl;
704 IP4_LINK_RX_TOKEN *Token;
705
706 if ((Token = Interface->RecvRequest) != NULL) {
707 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
708
709 Interface->RecvRequest = NULL;
710 Interface->Mnp->Cancel (Interface->Mnp, &Token->MnpToken);
711
712 gBS->RestoreTPL (OldTpl);
713 }
714}
715
716/**
717 Free the interface used by IpInstance. All the IP instance with
718 the same Ip/Netmask pair share the same interface. It is reference
719 counted. All the frames haven't been sent will be cancelled.
720 Because the IpInstance is optional, the caller must remove
721 IpInstance from the interface's instance list itself.
722
723 @param[in] Interface The interface used by the IpInstance.
724 @param[in] IpInstance The Ip instance that free the interface. NULL if
725 the Ip driver is releasing the default interface.
726
727 @retval EFI_SUCCESS The interface use IpInstance is freed.
728
729**/
730EFI_STATUS
731Ip4FreeInterface (
732 IN IP4_INTERFACE *Interface,
733 IN IP4_PROTOCOL *IpInstance OPTIONAL
734 )
735{
736 NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
737 ASSERT (Interface->RefCnt > 0);
738
739 //
740 // Remove all the pending transmit token related to this IP instance.
741 //
742 Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, IpInstance);
743
744 if (--Interface->RefCnt > 0) {
745 return EFI_SUCCESS;
746 }
747
748 //
749 // Destroy the interface if this is the last IP instance that
750 // has the address. Remove all the system transmitted packets
751 // from this interface, cancel the receive request if there is
752 // one, and destroy the ARP requests.
753 //
754 Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);
755 Ip4CancelReceive (Interface);
756
757 ASSERT (IsListEmpty (&Interface->IpInstances));
758 ASSERT (IsListEmpty (&Interface->ArpQues));
759 ASSERT (IsListEmpty (&Interface->SentFrames));
760
761 if (Interface->Arp != NULL) {
762 gBS->CloseProtocol (
763 Interface->ArpHandle,
764 &gEfiArpProtocolGuid,
765 Interface->Image,
766 Interface->Controller
767 );
768
769 NetLibDestroyServiceChild (
770 Interface->Controller,
771 Interface->Image,
772 &gEfiArpServiceBindingProtocolGuid,
773 Interface->ArpHandle
774 );
775 }
776
777 RemoveEntryList (&Interface->Link);
778 FreePool (Interface);
779
780 return EFI_SUCCESS;
781}
782
783/**
784 This function tries to send all the queued frames in ArpQue to the default gateway if
785 the ARP resolve for direct destination address is failed when using /32 subnet mask.
786
787 @param[in] ArpQue The ARP queue of a failed request.
788
789 @retval EFI_SUCCESS All the queued frames have been send to the default route.
790 @retval Others Failed to send the queued frames.
791
792**/
793EFI_STATUS
794Ip4SendFrameToDefaultRoute (
795 IN IP4_ARP_QUE *ArpQue
796 )
797{
798 LIST_ENTRY *Entry;
799 LIST_ENTRY *Next;
800 IP4_ROUTE_CACHE_ENTRY *RtCacheEntry;
801 IP4_LINK_TX_TOKEN *Token;
802 IP4_ADDR Gateway;
803 EFI_STATUS Status;
804 IP4_ROUTE_ENTRY *DefaultRoute;
805
806 //
807 // ARP resolve failed when using /32 subnet mask.
808 //
809 NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
810 RemoveEntryList (Entry);
811 Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
812 ASSERT (Token->Interface->SubnetMask == IP4_ALLONE_ADDRESS);
813 //
814 // Find the default gateway IP address. The default route was saved to the RtCacheEntry->Tag in Ip4Route().
815 //
816 RtCacheEntry = NULL;
817 if (Token->IpInstance != NULL) {
818 RtCacheEntry = Ip4FindRouteCache (Token->IpInstance->RouteTable, NTOHL (ArpQue->Ip), Token->Interface->Ip);
819 }
820
821 if (RtCacheEntry == NULL) {
822 RtCacheEntry = Ip4FindRouteCache (Token->IpSb->DefaultRouteTable, NTOHL (ArpQue->Ip), Token->Interface->Ip);
823 }
824
825 if (RtCacheEntry == NULL) {
826 Status = EFI_NO_MAPPING;
827 goto ON_ERROR;
828 }
829
830 DefaultRoute = (IP4_ROUTE_ENTRY *)RtCacheEntry->Tag;
831 if (DefaultRoute == NULL) {
832 Status = EFI_NO_MAPPING;
833 goto ON_ERROR;
834 }
835
836 //
837 // Try to send the frame to the default route.
838 //
839 Gateway = DefaultRoute->NextHop;
840 if (ArpQue->Ip == Gateway) {
841 //
842 // ARP resolve for the default route is failed, return error to caller.
843 //
844 Status = EFI_NO_MAPPING;
845 goto ON_ERROR;
846 }
847
848 RtCacheEntry->NextHop = Gateway;
849 Status = Ip4SendFrame (Token->Interface, Token->IpInstance, Token->Packet, Gateway, Token->CallBack, Token->Context, Token->IpSb);
850 if (EFI_ERROR (Status)) {
851 Status = EFI_NO_MAPPING;
852 goto ON_ERROR;
853 }
854
855 Ip4FreeRouteCacheEntry (RtCacheEntry);
856 }
857
858 return EFI_SUCCESS;
859
860ON_ERROR:
861 if (RtCacheEntry != NULL) {
862 Ip4FreeRouteCacheEntry (RtCacheEntry);
863 }
864
865 Token->CallBack (Token->IpInstance, Token->Packet, Status, 0, Token->Context);
866 Ip4FreeLinkTxToken (Token);
867 return Status;
868}
869
870/**
871 Callback function when ARP request are finished. It will cancel
872 all the queued frame if the ARP requests failed. Or transmit them
873 if the request succeed.
874
875 @param[in] Context The context of the callback, a point to the ARP
876 queue
877
878**/
879VOID
880EFIAPI
881Ip4OnArpResolvedDpc (
882 IN VOID *Context
883 )
884{
885 LIST_ENTRY *Entry;
886 LIST_ENTRY *Next;
887 IP4_ARP_QUE *ArpQue;
888 IP4_INTERFACE *Interface;
889 IP4_LINK_TX_TOKEN *Token;
890 EFI_STATUS Status;
891 EFI_STATUS IoStatus;
892
893 ArpQue = (IP4_ARP_QUE *)Context;
894 NET_CHECK_SIGNATURE (ArpQue, IP4_FRAME_ARP_SIGNATURE);
895
896 RemoveEntryList (&ArpQue->Link);
897
898 //
899 // ARP resolve failed for some reason.
900 //
901 if (NET_MAC_EQUAL (&ArpQue->Mac, &mZeroMacAddress, ArpQue->Interface->HwaddrLen)) {
902 if (ArpQue->Interface->SubnetMask != IP4_ALLONE_ADDRESS) {
903 //
904 // Release all the frame and ARP queue itself. Ip4FreeArpQue will call the frame's
905 // owner back.
906 //
907 IoStatus = EFI_NO_MAPPING;
908 } else {
909 //
910 // ARP resolve failed when using 32bit subnet mask, try to send the packets to the
911 // default route.
912 //
913 IoStatus = Ip4SendFrameToDefaultRoute (ArpQue);
914 }
915
916 goto ON_EXIT;
917 }
918
919 //
920 // ARP resolve succeeded, Transmit all the frame. Release the ARP
921 // queue. It isn't necessary for us to cache the ARP binding because
922 // we always check the ARP cache first before transmit.
923 //
924 IoStatus = EFI_SUCCESS;
925 Interface = ArpQue->Interface;
926
927 NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
928 RemoveEntryList (Entry);
929
930 Token = NET_LIST_USER_STRUCT (Entry, IP4_LINK_TX_TOKEN, Link);
931 CopyMem (&Token->DstMac, &ArpQue->Mac, sizeof (Token->DstMac));
932
933 //
934 // Insert the tx token before transmitting it via MNP as the FrameSentDpc
935 // may be called before Mnp->Transmit returns which will remove this tx
936 // token from the SentFrames list. Remove it from the list if the returned
937 // Status of Mnp->Transmit is not EFI_SUCCESS as in this case the
938 // FrameSentDpc won't be queued.
939 //
940 InsertTailList (&Interface->SentFrames, &Token->Link);
941
942 Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
943 if (EFI_ERROR (Status)) {
944 RemoveEntryList (&Token->Link);
945 Token->CallBack (Token->IpInstance, Token->Packet, Status, 0, Token->Context);
946
947 Ip4FreeLinkTxToken (Token);
948 continue;
949 }
950 }
951
952ON_EXIT:
953 Ip4FreeArpQue (ArpQue, IoStatus);
954}
955
956/**
957 Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK.
958
959 @param Event The Arp request event.
960 @param Context The context of the callback, a point to the ARP
961 queue.
962
963**/
964VOID
965EFIAPI
966Ip4OnArpResolved (
967 IN EFI_EVENT Event,
968 IN VOID *Context
969 )
970{
971 //
972 // Request Ip4OnArpResolvedDpc as a DPC at TPL_CALLBACK
973 //
974 QueueDpc (TPL_CALLBACK, Ip4OnArpResolvedDpc, Context);
975}
976
977/**
978 Callback function when frame transmission is finished. It will
979 call the frame owner's callback function to tell it the result.
980
981 @param[in] Context Context which is point to the token.
982
983**/
984VOID
985EFIAPI
986Ip4OnFrameSentDpc (
987 IN VOID *Context
988 )
989{
990 IP4_LINK_TX_TOKEN *Token;
991
992 Token = (IP4_LINK_TX_TOKEN *)Context;
993 NET_CHECK_SIGNATURE (Token, IP4_FRAME_TX_SIGNATURE);
994
995 RemoveEntryList (&Token->Link);
996
997 Token->CallBack (
998 Token->IpInstance,
999 Token->Packet,
1000 Token->MnpToken.Status,
1001 0,
1002 Token->Context
1003 );
1004
1005 Ip4FreeLinkTxToken (Token);
1006}
1007
1008/**
1009 Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK.
1010
1011 @param[in] Event The transmit token's event.
1012 @param[in] Context Context which is point to the token.
1013
1014**/
1015VOID
1016EFIAPI
1017Ip4OnFrameSent (
1018 IN EFI_EVENT Event,
1019 IN VOID *Context
1020 )
1021{
1022 //
1023 // Request Ip4OnFrameSentDpc as a DPC at TPL_CALLBACK
1024 //
1025 QueueDpc (TPL_CALLBACK, Ip4OnFrameSentDpc, Context);
1026}
1027
1028/**
1029 Send a frame from the interface. If the next hop is broadcast or
1030 multicast address, it is transmitted immediately. If the next hop
1031 is a unicast, it will consult ARP to resolve the NextHop's MAC.
1032 If some error happened, the CallBack won't be called. So, the caller
1033 must test the return value, and take action when there is an error.
1034
1035 @param[in] Interface The interface to send the frame from
1036 @param[in] IpInstance The IP child that request the transmission. NULL
1037 if it is the IP4 driver itself.
1038 @param[in] Packet The packet to transmit.
1039 @param[in] NextHop The immediate destination to transmit the packet
1040 to.
1041 @param[in] CallBack Function to call back when transmit finished.
1042 @param[in] Context Opaque parameter to the call back.
1043 @param[in] IpSb The pointer to the IP4 service binding instance.
1044
1045 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to send the frame
1046 @retval EFI_NO_MAPPING Can't resolve the MAC for the nexthop
1047 @retval EFI_SUCCESS The packet is successfully transmitted.
1048 @retval other Other error occurs.
1049
1050**/
1051EFI_STATUS
1052Ip4SendFrame (
1053 IN IP4_INTERFACE *Interface,
1054 IN IP4_PROTOCOL *IpInstance OPTIONAL,
1055 IN NET_BUF *Packet,
1056 IN IP4_ADDR NextHop,
1057 IN IP4_FRAME_CALLBACK CallBack,
1058 IN VOID *Context,
1059 IN IP4_SERVICE *IpSb
1060 )
1061{
1062 IP4_LINK_TX_TOKEN *Token;
1063 LIST_ENTRY *Entry;
1064 IP4_ARP_QUE *ArpQue;
1065 EFI_ARP_PROTOCOL *Arp;
1066 EFI_STATUS Status;
1067
1068 ASSERT (Interface->Configured);
1069
1070 Token = Ip4WrapLinkTxToken (Interface, IpInstance, Packet, CallBack, Context, IpSb);
1071
1072 if (Token == NULL) {
1073 return EFI_OUT_OF_RESOURCES;
1074 }
1075
1076 //
1077 // Get the destination MAC address for multicast and broadcasts.
1078 // Don't depend on ARP to solve the address since there maybe no
1079 // ARP at all. Ip4Output has set NextHop to 255.255.255.255 for
1080 // all the broadcasts.
1081 //
1082 if (NextHop == IP4_ALLONE_ADDRESS) {
1083 CopyMem (&Token->DstMac, &Interface->BroadcastMac, sizeof (Token->DstMac));
1084 goto SEND_NOW;
1085 } else if (IP4_IS_MULTICAST (NextHop)) {
1086 Status = Ip4GetMulticastMac (Interface->Mnp, NextHop, &Token->DstMac);
1087
1088 if (EFI_ERROR (Status)) {
1089 goto ON_ERROR;
1090 }
1091
1092 goto SEND_NOW;
1093 }
1094
1095 //
1096 // Can only send out multicast/broadcast if the IP address is zero
1097 //
1098 if ((Arp = Interface->Arp) == NULL) {
1099 Status = EFI_NO_MAPPING;
1100 goto ON_ERROR;
1101 }
1102
1103 //
1104 // First check whether this binding is in the ARP cache.
1105 //
1106 NextHop = HTONL (NextHop);
1107 Status = Arp->Request (Arp, &NextHop, NULL, &Token->DstMac);
1108
1109 if (Status == EFI_SUCCESS) {
1110 goto SEND_NOW;
1111 } else if (Status != EFI_NOT_READY) {
1112 goto ON_ERROR;
1113 }
1114
1115 //
1116 // Have to do asynchronous ARP resolution. First check
1117 // whether there is already a pending request.
1118 //
1119 ArpQue = NULL;
1120
1121 NET_LIST_FOR_EACH (Entry, &Interface->ArpQues) {
1122 ArpQue = NET_LIST_USER_STRUCT (Entry, IP4_ARP_QUE, Link);
1123
1124 if (ArpQue->Ip == NextHop) {
1125 break;
1126 }
1127 }
1128
1129 //
1130 // Found a pending ARP request, enqueue the frame then return
1131 //
1132 if (Entry != &Interface->ArpQues) {
1133 InsertTailList (&ArpQue->Frames, &Token->Link);
1134 return EFI_SUCCESS;
1135 }
1136
1137 //
1138 // First frame to NextHop, issue an asynchronous ARP requests
1139 //
1140 ArpQue = Ip4CreateArpQue (Interface, NextHop);
1141
1142 if (ArpQue == NULL) {
1143 Status = EFI_OUT_OF_RESOURCES;
1144 goto ON_ERROR;
1145 }
1146
1147 Status = Arp->Request (Arp, &ArpQue->Ip, ArpQue->OnResolved, ArpQue->Mac.Addr);
1148
1149 if (EFI_ERROR (Status) && (Status != EFI_NOT_READY)) {
1150 Ip4FreeArpQue (ArpQue, EFI_NO_MAPPING);
1151 goto ON_ERROR;
1152 }
1153
1154 InsertHeadList (&ArpQue->Frames, &Token->Link);
1155 InsertHeadList (&Interface->ArpQues, &ArpQue->Link);
1156 return EFI_SUCCESS;
1157
1158SEND_NOW:
1159 //
1160 // Insert the tx token into the SentFrames list before calling Mnp->Transmit.
1161 // Remove it if the returned status is not EFI_SUCCESS.
1162 //
1163 InsertTailList (&Interface->SentFrames, &Token->Link);
1164 Status = Interface->Mnp->Transmit (Interface->Mnp, &Token->MnpToken);
1165 if (EFI_ERROR (Status)) {
1166 RemoveEntryList (&Token->Link);
1167 goto ON_ERROR;
1168 }
1169
1170 return EFI_SUCCESS;
1171
1172ON_ERROR:
1173 Ip4FreeLinkTxToken (Token);
1174 return Status;
1175}
1176
1177/**
1178 Call back function when the received packet is freed.
1179 Check Ip4OnFrameReceived for information.
1180
1181 @param Context Context, which is the IP4_LINK_RX_TOKEN.
1182
1183**/
1184VOID
1185EFIAPI
1186Ip4RecycleFrame (
1187 IN VOID *Context
1188 )
1189{
1190 IP4_LINK_RX_TOKEN *Frame;
1191
1192 Frame = (IP4_LINK_RX_TOKEN *)Context;
1193 NET_CHECK_SIGNATURE (Frame, IP4_FRAME_RX_SIGNATURE);
1194
1195 gBS->SignalEvent (Frame->MnpToken.Packet.RxData->RecycleEvent);
1196 Ip4FreeFrameRxToken (Frame);
1197}
1198
1199/**
1200 Received a frame from MNP, wrap it in net buffer then deliver
1201 it to IP's input function. The ownship of the packet also
1202 transferred to IP. When Ip is finished with this packet, it
1203 will call NetbufFree to release the packet, NetbufFree will
1204 again call the Ip4RecycleFrame to signal MNP's event and free
1205 the token used.
1206
1207 @param Context Context for the callback.
1208
1209**/
1210VOID
1211EFIAPI
1212Ip4OnFrameReceivedDpc (
1213 IN VOID *Context
1214 )
1215{
1216 EFI_MANAGED_NETWORK_COMPLETION_TOKEN *MnpToken;
1217 EFI_MANAGED_NETWORK_RECEIVE_DATA *MnpRxData;
1218 IP4_LINK_RX_TOKEN *Token;
1219 NET_FRAGMENT Netfrag;
1220 NET_BUF *Packet;
1221 UINT32 Flag;
1222
1223 Token = (IP4_LINK_RX_TOKEN *)Context;
1224 NET_CHECK_SIGNATURE (Token, IP4_FRAME_RX_SIGNATURE);
1225
1226 //
1227 // First clear the interface's receive request in case the
1228 // caller wants to call Ip4ReceiveFrame in the callback.
1229 //
1230 Token->Interface->RecvRequest = NULL;
1231
1232 MnpToken = &Token->MnpToken;
1233 MnpRxData = MnpToken->Packet.RxData;
1234
1235 if (EFI_ERROR (MnpToken->Status) || (MnpRxData == NULL)) {
1236 Token->CallBack (Token->IpInstance, NULL, MnpToken->Status, 0, Token->Context);
1237 Ip4FreeFrameRxToken (Token);
1238
1239 return;
1240 }
1241
1242 //
1243 // Wrap the frame in a net buffer then deliver it to IP input.
1244 // IP will reassemble the packet, and deliver it to upper layer
1245 //
1246 Netfrag.Len = MnpRxData->DataLength;
1247 Netfrag.Bulk = MnpRxData->PacketData;
1248
1249 Packet = NetbufFromExt (&Netfrag, 1, 0, IP4_MAX_HEADLEN, Ip4RecycleFrame, Token);
1250
1251 if (Packet == NULL) {
1252 gBS->SignalEvent (MnpRxData->RecycleEvent);
1253
1254 Token->CallBack (Token->IpInstance, NULL, EFI_OUT_OF_RESOURCES, 0, Token->Context);
1255 Ip4FreeFrameRxToken (Token);
1256
1257 return;
1258 }
1259
1260 Flag = (MnpRxData->BroadcastFlag ? IP4_LINK_BROADCAST : 0);
1261 Flag |= (MnpRxData->MulticastFlag ? IP4_LINK_MULTICAST : 0);
1262 Flag |= (MnpRxData->PromiscuousFlag ? IP4_LINK_PROMISC : 0);
1263
1264 Token->CallBack (Token->IpInstance, Packet, EFI_SUCCESS, Flag, Token->Context);
1265}
1266
1267/**
1268 Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK.
1269
1270 @param Event The receive event delivered to MNP for receive.
1271 @param Context Context for the callback.
1272
1273**/
1274VOID
1275EFIAPI
1276Ip4OnFrameReceived (
1277 IN EFI_EVENT Event,
1278 IN VOID *Context
1279 )
1280{
1281 //
1282 // Request Ip4OnFrameReceivedDpc as a DPC at TPL_CALLBACK
1283 //
1284 QueueDpc (TPL_CALLBACK, Ip4OnFrameReceivedDpc, Context);
1285}
1286
1287/**
1288 Request to receive the packet from the interface.
1289
1290 @param[in] Interface The interface to receive the frames from.
1291 @param[in] IpInstance The instance that requests the receive. NULL for
1292 the driver itself.
1293 @param[in] CallBack Function to call when receive finished.
1294 @param[in] Context Opaque parameter to the callback.
1295
1296 @retval EFI_ALREADY_STARTED There is already a pending receive request.
1297 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource to receive.
1298 @retval EFI_SUCCESS The receive request has been started.
1299 @retval other Other error occurs.
1300
1301**/
1302EFI_STATUS
1303Ip4ReceiveFrame (
1304 IN IP4_INTERFACE *Interface,
1305 IN IP4_PROTOCOL *IpInstance OPTIONAL,
1306 IN IP4_FRAME_CALLBACK CallBack,
1307 IN VOID *Context
1308 )
1309{
1310 IP4_LINK_RX_TOKEN *Token;
1311 EFI_STATUS Status;
1312
1313 NET_CHECK_SIGNATURE (Interface, IP4_INTERFACE_SIGNATURE);
1314
1315 if (Interface->RecvRequest != NULL) {
1316 return EFI_ALREADY_STARTED;
1317 }
1318
1319 Token = Ip4CreateLinkRxToken (Interface, IpInstance, CallBack, Context);
1320
1321 if (Token == NULL) {
1322 return EFI_OUT_OF_RESOURCES;
1323 }
1324
1325 Interface->RecvRequest = Token;
1326 Status = Interface->Mnp->Receive (Interface->Mnp, &Token->MnpToken);
1327 if (EFI_ERROR (Status)) {
1328 Interface->RecvRequest = NULL;
1329 Ip4FreeFrameRxToken (Token);
1330 return Status;
1331 }
1332
1333 return EFI_SUCCESS;
1334}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette