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