2 Interface routines for PxeBc.
4 Copyright (c) 2007 - 2010, 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
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.
16 #include "PxeBcImpl.h"
18 UINT32 mPxeDhcpTimeout
[4] = { 4, 8, 16, 32 };
21 Get and record the arp cache.
23 @param This Pointer to EFI_PXE_BC_PROTOCOL
25 @retval EFI_SUCCESS Arp cache updated successfully
26 @retval others If error occurs when getting arp cache
31 IN EFI_PXE_BASE_CODE_PROTOCOL
* This
34 PXEBC_PRIVATE_DATA
*Private
;
35 EFI_PXE_BASE_CODE_MODE
*Mode
;
39 EFI_ARP_FIND_DATA
*Entries
;
42 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
43 Mode
= Private
->PxeBc
.Mode
;
45 Status
= Private
->Arp
->Find (
54 if (EFI_ERROR (Status
)) {
58 Mode
->ArpCacheEntries
= MIN (
60 EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES
62 for (Index
= 0; Index
< Mode
->ArpCacheEntries
; Index
++) {
64 &Mode
->ArpCache
[Index
].IpAddr
,
66 Entries
->SwAddressLength
69 &Mode
->ArpCache
[Index
].MacAddr
,
70 (UINT8
*) (Entries
+ 1) + Entries
->SwAddressLength
,
71 Entries
->HwAddressLength
74 // Slip to the next FindData.
76 Entries
= (EFI_ARP_FIND_DATA
*) ((UINT8
*) Entries
+ EntryLength
);
83 Timeout routine to update arp cache.
85 @param Event Pointer to EFI_PXE_BC_PROTOCOL
86 @param Context Context of the timer event
91 ArpCacheUpdateTimeout (
96 UpdateArpCache ((EFI_PXE_BASE_CODE_PROTOCOL
*) Context
);
100 Do arp resolution from arp cache in PxeBcMode.
102 @param PxeBcMode The PXE BC mode to look into.
103 @param Ip4Addr The Ip4 address for resolution.
104 @param MacAddress The resoluted MAC address if the resolution is successful.
105 The value is undefined if resolution fails.
107 @retval TRUE The resolution is successful.
108 @retval FALSE Otherwise.
113 IN EFI_PXE_BASE_CODE_MODE
*PxeBcMode
,
114 IN EFI_IPv4_ADDRESS
*Ip4Addr
,
115 OUT EFI_MAC_ADDRESS
*MacAddress
120 for (Index
= 0; Index
< PxeBcMode
->ArpCacheEntries
; Index
++) {
121 if (EFI_IP4_EQUAL (&PxeBcMode
->ArpCache
[Index
].IpAddr
.v4
, Ip4Addr
)) {
124 &PxeBcMode
->ArpCache
[Index
].MacAddr
,
125 sizeof (EFI_MAC_ADDRESS
)
135 Notify function for the ICMP receive token, used to process
136 the received ICMP packets.
138 @param Context The PXEBC private data.
143 IcmpErrorListenHandlerDpc (
148 EFI_IP4_RECEIVE_DATA
*RxData
;
149 EFI_IP4_PROTOCOL
*Ip4
;
150 PXEBC_PRIVATE_DATA
*Private
;
151 EFI_PXE_BASE_CODE_MODE
*Mode
;
154 UINT8
*CopiedPointer
;
156 Private
= (PXEBC_PRIVATE_DATA
*) Context
;
157 Mode
= &Private
->Mode
;
158 Status
= Private
->IcmpErrorRcvToken
.Status
;
159 RxData
= Private
->IcmpErrorRcvToken
.Packet
.RxData
;
162 if (Status
== EFI_ABORTED
) {
164 // The reception is actively aborted by the consumer, directly return.
169 if (EFI_ERROR (Status
) || (RxData
== NULL
)) {
171 // Only process the normal packets and the icmp error packets, if RxData is NULL
172 // with Status == EFI_SUCCESS or EFI_ICMP_ERROR, just resume the receive although
173 // this should be a bug of the low layer (IP).
178 if (EFI_IP4 (RxData
->Header
->SourceAddress
) != 0 &&
179 !NetIp4IsUnicast (EFI_NTOHL (RxData
->Header
->SourceAddress
), 0)) {
181 // The source address is not zero and it's not a unicast IP address, discard it.
186 if (!EFI_IP4_EQUAL (&RxData
->Header
->DestinationAddress
, &Mode
->StationIp
.v4
)) {
188 // The dest address is not equal to Station Ip address, discard it.
194 // Constructor ICMP error packet
197 CopiedPointer
= (UINT8
*) &Mode
->IcmpError
;
199 for (Index
= 0; Index
< RxData
->FragmentCount
; Index
++) {
200 CopiedLen
+= RxData
->FragmentTable
[Index
].FragmentLength
;
201 if (CopiedLen
<= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR
)) {
204 RxData
->FragmentTable
[Index
].FragmentBuffer
,
205 RxData
->FragmentTable
[Index
].FragmentLength
210 RxData
->FragmentTable
[Index
].FragmentBuffer
,
211 CopiedLen
- sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR
)
214 CopiedPointer
+= CopiedLen
;
220 gBS
->SignalEvent (RxData
->RecycleSignal
);
223 Ip4
->Receive (Ip4
, &(Private
->IcmpErrorRcvToken
));
227 Request IcmpErrorListenHandlerDpc as a DPC at TPL_CALLBACK
229 @param Event The event signaled.
230 @param Context The context passed in by the event notifier.
235 IcmpErrorListenHandler (
241 // Request IpIoListenHandlerDpc as a DPC at TPL_CALLBACK
243 QueueDpc (TPL_CALLBACK
, IcmpErrorListenHandlerDpc
, Context
);
247 Enables the use of the PXE Base Code Protocol functions.
249 This function enables the use of the PXE Base Code Protocol functions. If the
250 Started field of the EFI_PXE_BASE_CODE_MODE structure is already TRUE, then
251 EFI_ALREADY_STARTED will be returned. If UseIpv6 is TRUE, then IPv6 formatted
252 addresses will be used in this session. If UseIpv6 is FALSE, then IPv4 formatted
253 addresses will be used in this session. If UseIpv6 is TRUE, and the Ipv6Supported
254 field of the EFI_PXE_BASE_CODE_MODE structure is FALSE, then EFI_UNSUPPORTED will
255 be returned. If there is not enough memory or other resources to start the PXE
256 Base Code Protocol, then EFI_OUT_OF_RESOURCES will be returned. Otherwise, the
257 PXE Base Code Protocol will be started, and all of the fields of the EFI_PXE_BASE_CODE_MODE
258 structure will be initialized as follows:
260 Ipv6SupportedUnchanged.
261 Ipv6AvailableUnchanged.
262 UsingIpv6Set to UseIpv6.
263 BisSupportedUnchanged.
264 BisDetectedUnchanged.
266 SendGUIDSet to FALSE.
267 TTLSet to DEFAULT_TTL.
268 ToSSet to DEFAULT_ToS.
269 DhcpCompletedSet to FALSE.
270 ProxyOfferReceivedSet to FALSE.
271 StationIpSet to an address of all zeros.
272 SubnetMaskSet to a subnet mask of all zeros.
273 DhcpDiscoverZero-filled.
275 ProxyOfferZero-filled.
276 PxeDiscoverValidSet to FALSE.
277 PxeDiscoverZero-filled.
278 PxeReplyValidSet to FALSE.
280 PxeBisReplyValidSet to FALSE.
281 PxeBisReplyZero-filled.
282 IpFilterSet the Filters field to 0 and the IpCnt field to 0.
283 ArpCacheEntriesSet to 0.
285 RouteTableEntriesSet to 0.
286 RouteTableZero-filled.
287 IcmpErrorReceivedSet to FALSE.
288 IcmpErrorZero-filled.
289 TftpErroReceivedSet to FALSE.
290 TftpErrorZero-filled.
291 MakeCallbacksSet to TRUE if the PXE Base Code Callback Protocol is available.
292 Set to FALSE if the PXE Base Code Callback Protocol is not available.
294 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
295 @param UseIpv6 Specifies the type of IP addresses that are to be used during the session
296 that is being started. Set to TRUE for IPv6 addresses, and FALSE for
299 @retval EFI_SUCCESS The PXE Base Code Protocol was started.
300 @retval EFI_DEVICE_ERROR The network device encountered an error during this oper
301 @retval EFI_UNSUPPORTED UseIpv6 is TRUE, but the Ipv6Supported field of the
302 EFI_PXE_BASE_CODE_MODE structure is FALSE.
303 @retval EFI_ALREADY_STARTED The PXE Base Code Protocol is already in the started state.
304 @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
305 EFI_PXE_BASE_CODE_PROTOCOL structure.
306 @retval EFI_OUT_OF_RESOURCES Could not allocate enough memory or other resources to start the
307 PXE Base Code Protocol.
313 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
317 PXEBC_PRIVATE_DATA
*Private
;
318 EFI_PXE_BASE_CODE_MODE
*Mode
;
322 return EFI_INVALID_PARAMETER
;
325 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
326 Mode
= Private
->PxeBc
.Mode
;
329 return EFI_ALREADY_STARTED
;
334 // IPv6 is not supported now.
336 return EFI_UNSUPPORTED
;
340 // Configure the udp4 instance to let it receive data
342 Status
= Private
->Udp4Read
->Configure (
344 &Private
->Udp4CfgData
346 if (EFI_ERROR (Status
)) {
352 // Configure block size for TFTP as a default value to handle all link layers.
354 Private
->BlockSize
= (UINTN
) (MIN (Private
->Ip4MaxPacketSize
, PXEBC_DEFAULT_PACKET_SIZE
) -
355 PXEBC_DEFAULT_UDP_OVERHEAD_SIZE
- PXEBC_DEFAULT_TFTP_OVERHEAD_SIZE
);
357 // If PcdTftpBlockSize is set to non-zero, override the default value.
359 if (PcdGet64 (PcdTftpBlockSize
) != 0) {
360 Private
->BlockSize
= (UINTN
) PcdGet64 (PcdTftpBlockSize
);
363 Private
->AddressIsOk
= FALSE
;
365 ZeroMem (Mode
, sizeof (EFI_PXE_BASE_CODE_MODE
));
367 Mode
->Started
= TRUE
;
368 Mode
->TTL
= DEFAULT_TTL
;
369 Mode
->ToS
= DEFAULT_ToS
;
370 Mode
->AutoArp
= TRUE
;
373 // Create the event for Arp Cache checking.
375 Status
= gBS
->CreateEvent (
376 EVT_TIMER
| EVT_NOTIFY_SIGNAL
,
378 ArpCacheUpdateTimeout
,
380 &Private
->GetArpCacheEvent
382 if (EFI_ERROR (Status
)) {
387 // Start the timeout timer event.
389 Status
= gBS
->SetTimer (
390 Private
->GetArpCacheEvent
,
395 if (EFI_ERROR (Status
)) {
400 // Create ICMP error receiving event
402 Status
= gBS
->CreateEvent (
405 IcmpErrorListenHandler
,
407 &(Private
->IcmpErrorRcvToken
.Event
)
409 if (EFI_ERROR (Status
)) {
413 Status
= Private
->Ip4
->Configure (Private
->Ip4
, &Private
->Ip4ConfigData
);
414 if (EFI_ERROR (Status
)) {
419 // start to listen incoming packet
421 Status
= Private
->Ip4
->Receive (Private
->Ip4
, &Private
->IcmpErrorRcvToken
);
422 if (!EFI_ERROR (Status
)) {
427 Private
->Ip4
->Configure (Private
->Ip4
, NULL
);
429 if (Private
->IcmpErrorRcvToken
.Event
!= NULL
) {
430 gBS
->CloseEvent (Private
->IcmpErrorRcvToken
.Event
);
433 if (Private
->GetArpCacheEvent
!= NULL
) {
434 gBS
->SetTimer (Private
->GetArpCacheEvent
, TimerCancel
, 0);
435 gBS
->CloseEvent (Private
->GetArpCacheEvent
);
438 Mode
->Started
= FALSE
;
441 Mode
->AutoArp
= FALSE
;
448 Disables the use of the PXE Base Code Protocol functions.
450 This function stops all activity on the network device. All the resources allocated
451 in Start() are released, the Started field of the EFI_PXE_BASE_CODE_MODE structure is
452 set to FALSE and EFI_SUCCESS is returned. If the Started field of the EFI_PXE_BASE_CODE_MODE
453 structure is already FALSE, then EFI_NOT_STARTED will be returned.
455 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
457 @retval EFI_SUCCESS The PXE Base Code Protocol was stopped.
458 @retval EFI_NOT_STARTED The PXE Base Code Protocol is already in the stopped state.
459 @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
460 EFI_PXE_BASE_CODE_PROTOCOL structure.
461 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
467 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
470 PXEBC_PRIVATE_DATA
*Private
;
471 EFI_PXE_BASE_CODE_MODE
*Mode
;
474 return EFI_INVALID_PARAMETER
;
477 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
478 Mode
= Private
->PxeBc
.Mode
;
480 if (!Mode
->Started
) {
481 return EFI_NOT_STARTED
;
484 Private
->Ip4
->Cancel (Private
->Ip4
, NULL
);
486 // Dispatch the DPCs queued by the NotifyFunction of the canceled rx token's
491 Private
->Ip4
->Configure (Private
->Ip4
, NULL
);
494 // Close the ICMP error receiving event.
496 gBS
->CloseEvent (Private
->IcmpErrorRcvToken
.Event
);
499 // Cancel the TimeoutEvent timer.
501 gBS
->SetTimer (Private
->GetArpCacheEvent
, TimerCancel
, 0);
504 // Close the TimeoutEvent event.
506 gBS
->CloseEvent (Private
->GetArpCacheEvent
);
508 Mode
->Started
= FALSE
;
510 Private
->CurrentUdpSrcPort
= 0;
511 Private
->Udp4Write
->Configure (Private
->Udp4Write
, NULL
);
512 Private
->Udp4Read
->Groups (Private
->Udp4Read
, FALSE
, NULL
);
513 Private
->Udp4Read
->Configure (Private
->Udp4Read
, NULL
);
515 Private
->Dhcp4
->Stop (Private
->Dhcp4
);
516 Private
->Dhcp4
->Configure (Private
->Dhcp4
, NULL
);
518 Private
->FileSize
= 0;
525 Attempts to complete a DHCPv4 D.O.R.A. (discover / offer / request / acknowledge) or DHCPv6
526 S.A.R.R (solicit / advertise / request / reply) sequence.
528 This function attempts to complete the DHCP sequence. If this sequence is completed,
529 then EFI_SUCCESS is returned, and the DhcpCompleted, ProxyOfferReceived, StationIp,
530 SubnetMask, DhcpDiscover, DhcpAck, and ProxyOffer fields of the EFI_PXE_BASE_CODE_MODE
531 structure are filled in.
532 If SortOffers is TRUE, then the cached DHCP offer packets will be sorted before
533 they are tried. If SortOffers is FALSE, then the cached DHCP offer packets will
534 be tried in the order in which they are received. Please see the Preboot Execution
535 Environment (PXE) Specification for additional details on the implementation of DHCP.
536 This function can take at least 31 seconds to timeout and return control to the
537 caller. If the DHCP sequence does not complete, then EFI_TIMEOUT will be returned.
538 If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
539 then the DHCP sequence will be stopped and EFI_ABORTED will be returned.
541 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
542 @param SortOffers TRUE if the offers received should be sorted. Set to FALSE to try the
543 offers in the order that they are received.
545 @retval EFI_SUCCESS Valid DHCP has completed.
546 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
547 @retval EFI_INVALID_PARAMETER The This parameter is NULL or does not point to a valid
548 EFI_PXE_BASE_CODE_PROTOCOL structure.
549 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
550 @retval EFI_OUT_OF_RESOURCES Could not allocate enough memory to complete the DHCP Protocol.
551 @retval EFI_ABORTED The callback function aborted the DHCP Protocol.
552 @retval EFI_TIMEOUT The DHCP Protocol timed out.
553 @retval EFI_ICMP_ERROR An ICMP error packet was received during the DHCP session.
554 @retval EFI_NO_RESPONSE Valid PXE offer was not received.
560 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
561 IN BOOLEAN SortOffers
564 PXEBC_PRIVATE_DATA
*Private
;
565 EFI_PXE_BASE_CODE_MODE
*Mode
;
566 EFI_DHCP4_PROTOCOL
*Dhcp4
;
567 EFI_DHCP4_CONFIG_DATA Dhcp4CfgData
;
568 EFI_DHCP4_MODE_DATA Dhcp4Mode
;
569 EFI_DHCP4_PACKET_OPTION
*OptList
[PXEBC_DHCP4_MAX_OPTION_NUM
];
572 EFI_ARP_CONFIG_DATA ArpConfigData
;
575 return EFI_INVALID_PARAMETER
;
578 Status
= EFI_SUCCESS
;
579 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
580 Mode
= Private
->PxeBc
.Mode
;
581 Dhcp4
= Private
->Dhcp4
;
582 Private
->Function
= EFI_PXE_BASE_CODE_FUNCTION_DHCP
;
583 Private
->SortOffers
= SortOffers
;
585 if (!Mode
->Started
) {
586 return EFI_NOT_STARTED
;
589 Mode
->IcmpErrorReceived
= FALSE
;
592 // Initialize the DHCP options and build the option list
594 OptCount
= PxeBcBuildDhcpOptions (Private
, OptList
, TRUE
);
597 // Set the DHCP4 config data.
598 // The four discovery timeouts are 4, 8, 16, 32 seconds respectively.
600 ZeroMem (&Dhcp4CfgData
, sizeof (EFI_DHCP4_CONFIG_DATA
));
601 Dhcp4CfgData
.OptionCount
= OptCount
;
602 Dhcp4CfgData
.OptionList
= OptList
;
603 Dhcp4CfgData
.Dhcp4Callback
= PxeBcDhcpCallBack
;
604 Dhcp4CfgData
.CallbackContext
= Private
;
605 Dhcp4CfgData
.DiscoverTryCount
= 4;
606 Dhcp4CfgData
.DiscoverTimeout
= mPxeDhcpTimeout
;
608 Status
= Dhcp4
->Configure (Dhcp4
, &Dhcp4CfgData
);
609 if (EFI_ERROR (Status
)) {
614 // Zero those arrays to record the varies numbers of DHCP OFFERS.
616 Private
->GotProxyOffer
= FALSE
;
617 Private
->NumOffers
= 0;
618 Private
->BootpIndex
= 0;
619 ZeroMem (Private
->ServerCount
, sizeof (Private
->ServerCount
));
620 ZeroMem (Private
->ProxyIndex
, sizeof (Private
->ProxyIndex
));
622 Status
= Dhcp4
->Start (Dhcp4
, NULL
);
623 if (EFI_ERROR (Status
)) {
624 if (Status
== EFI_ICMP_ERROR
) {
625 Mode
->IcmpErrorReceived
= TRUE
;
630 Status
= Dhcp4
->GetModeData (Dhcp4
, &Dhcp4Mode
);
631 if (EFI_ERROR (Status
)) {
635 ASSERT (Dhcp4Mode
.State
== Dhcp4Bound
);
637 CopyMem (&Private
->StationIp
, &Dhcp4Mode
.ClientAddress
, sizeof (EFI_IPv4_ADDRESS
));
638 CopyMem (&Private
->SubnetMask
, &Dhcp4Mode
.SubnetMask
, sizeof (EFI_IPv4_ADDRESS
));
639 CopyMem (&Private
->GatewayIp
, &Dhcp4Mode
.RouterAddress
, sizeof (EFI_IPv4_ADDRESS
));
641 CopyMem (&Mode
->StationIp
, &Private
->StationIp
, sizeof (EFI_IPv4_ADDRESS
));
642 CopyMem (&Mode
->SubnetMask
, &Private
->SubnetMask
, sizeof (EFI_IPv4_ADDRESS
));
645 // Check the selected offer to see whether BINL is required, if no or BINL is
646 // finished, set the various Mode members.
648 Status
= PxeBcCheckSelectedOffer (Private
);
649 if (!EFI_ERROR (Status
)) {
654 if (EFI_ERROR (Status
)) {
656 Dhcp4
->Configure (Dhcp4
, NULL
);
659 // Remove the previously configured option list and callback function
661 ZeroMem (&Dhcp4CfgData
, sizeof (EFI_DHCP4_CONFIG_DATA
));
662 Dhcp4
->Configure (Dhcp4
, &Dhcp4CfgData
);
664 Private
->AddressIsOk
= TRUE
;
666 if (!Mode
->UsingIpv6
) {
668 // If in IPv4 mode, configure the corresponding ARP with this new
669 // station IP address.
671 ZeroMem (&ArpConfigData
, sizeof (EFI_ARP_CONFIG_DATA
));
673 ArpConfigData
.SwAddressType
= 0x0800;
674 ArpConfigData
.SwAddressLength
= sizeof (EFI_IPv4_ADDRESS
);
675 ArpConfigData
.StationAddress
= &Private
->StationIp
.v4
;
677 Private
->Arp
->Configure (Private
->Arp
, NULL
);
678 Private
->Arp
->Configure (Private
->Arp
, &ArpConfigData
);
681 // Updated the route table. Fill the first entry.
683 Mode
->RouteTableEntries
= 1;
684 Mode
->RouteTable
[0].IpAddr
.Addr
[0] = Private
->StationIp
.Addr
[0] & Private
->SubnetMask
.Addr
[0];
685 Mode
->RouteTable
[0].SubnetMask
.Addr
[0] = Private
->SubnetMask
.Addr
[0];
686 Mode
->RouteTable
[0].GwAddr
.Addr
[0] = 0;
689 // Create the default route entry if there is a default router.
691 if (Private
->GatewayIp
.Addr
[0] != 0) {
692 Mode
->RouteTableEntries
= 2;
693 Mode
->RouteTable
[1].IpAddr
.Addr
[0] = 0;
694 Mode
->RouteTable
[1].SubnetMask
.Addr
[0] = 0;
695 Mode
->RouteTable
[1].GwAddr
.Addr
[0] = Private
->GatewayIp
.Addr
[0];
705 Attempts to complete the PXE Boot Server and/or boot image discovery sequence.
707 This function attempts to complete the PXE Boot Server and/or boot image discovery
708 sequence. If this sequence is completed, then EFI_SUCCESS is returned, and the
709 PxeDiscoverValid, PxeDiscover, PxeReplyReceived, and PxeReply fields of the
710 EFI_PXE_BASE_CODE_MODE structure are filled in. If UseBis is TRUE, then the
711 PxeBisReplyReceived and PxeBisReply fields of the EFI_PXE_BASE_CODE_MODE structure
712 will also be filled in. If UseBis is FALSE, then PxeBisReplyValid will be set to FALSE.
713 In the structure referenced by parameter Info, the PXE Boot Server list, SrvList[],
714 has two uses: It is the Boot Server IP address list used for unicast discovery
715 (if the UseUCast field is TRUE), and it is the list used for Boot Server verification
716 (if the MustUseList field is TRUE). Also, if the MustUseList field in that structure
717 is TRUE and the AcceptAnyResponse field in the SrvList[] array is TRUE, any Boot
718 Server reply of that type will be accepted. If the AcceptAnyResponse field is
719 FALSE, only responses from Boot Servers with matching IP addresses will be accepted.
720 This function can take at least 10 seconds to timeout and return control to the
721 caller. If the Discovery sequence does not complete, then EFI_TIMEOUT will be
722 returned. Please see the Preboot Execution Environment (PXE) Specification for
723 additional details on the implementation of the Discovery sequence.
724 If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
725 then the Discovery sequence is stopped and EFI_ABORTED will be returned.
727 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
728 @param Type The type of bootstrap to perform.
729 @param Layer Pointer to the boot server layer number to discover, which must be
730 PXE_BOOT_LAYER_INITIAL when a new server type is being
732 @param UseBis TRUE if Boot Integrity Services are to be used. FALSE otherwise.
733 @param Info Pointer to a data structure that contains additional information on the
734 type of discovery operation that is to be performed.
736 @retval EFI_SUCCESS The Discovery sequence has been completed.
737 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
738 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
739 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
740 @retval EFI_OUT_OF_RESOURCES Could not allocate enough memory to complete Discovery.
741 @retval EFI_ABORTED The callback function aborted the Discovery sequence.
742 @retval EFI_TIMEOUT The Discovery sequence timed out.
743 @retval EFI_ICMP_ERROR An ICMP error packet was received during the PXE discovery
750 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
754 IN EFI_PXE_BASE_CODE_DISCOVER_INFO
*Info OPTIONAL
757 PXEBC_PRIVATE_DATA
*Private
;
758 EFI_PXE_BASE_CODE_MODE
*Mode
;
759 EFI_PXE_BASE_CODE_DISCOVER_INFO DefaultInfo
;
760 EFI_PXE_BASE_CODE_DISCOVER_INFO
*CreatedInfo
;
761 EFI_PXE_BASE_CODE_SRVLIST
*SrvList
;
762 EFI_PXE_BASE_CODE_SRVLIST DefaultSrvList
;
763 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
764 PXEBC_VENDOR_OPTION
*VendorOpt
;
767 PXEBC_BOOT_SVR_ENTRY
*BootSvrEntry
;
770 return EFI_INVALID_PARAMETER
;
773 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
774 Mode
= Private
->PxeBc
.Mode
;
778 Status
= EFI_DEVICE_ERROR
;
779 Private
->Function
= EFI_PXE_BASE_CODE_FUNCTION_DISCOVER
;
781 if (!Private
->AddressIsOk
) {
782 return EFI_INVALID_PARAMETER
;
785 if (!Mode
->Started
) {
786 return EFI_NOT_STARTED
;
789 Mode
->IcmpErrorReceived
= FALSE
;
792 // If layer isn't EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL,
793 // use the previous setting;
794 // If info isn't offered,
795 // use the cached DhcpAck and ProxyOffer packets.
797 if (*Layer
!= EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL
) {
799 if (!Mode
->PxeDiscoverValid
|| !Mode
->PxeReplyReceived
|| (!Mode
->PxeBisReplyReceived
&& UseBis
)) {
801 return EFI_INVALID_PARAMETER
;
804 DefaultInfo
.IpCnt
= 1;
805 DefaultInfo
.UseUCast
= TRUE
;
807 DefaultSrvList
.Type
= Type
;
808 DefaultSrvList
.AcceptAnyResponse
= FALSE
;
809 DefaultSrvList
.IpAddr
.Addr
[0] = Private
->ServerIp
.Addr
[0];
811 SrvList
= &DefaultSrvList
;
813 } else if (Info
== NULL
) {
815 // Create info by the cached packet before
817 Packet
= (Mode
->ProxyOfferReceived
) ? &Private
->ProxyOffer
: &Private
->Dhcp4Ack
;
818 VendorOpt
= &Packet
->PxeVendorOption
;
820 if (!Mode
->DhcpAckReceived
|| !IS_VALID_DISCOVER_VENDOR_OPTION (VendorOpt
->BitMap
)) {
822 // Address is not acquired or no discovery options.
824 return EFI_INVALID_PARAMETER
;
827 DefaultInfo
.UseMCast
= (BOOLEAN
)!IS_DISABLE_MCAST_DISCOVER (VendorOpt
->DiscoverCtrl
);
828 DefaultInfo
.UseBCast
= (BOOLEAN
)!IS_DISABLE_BCAST_DISCOVER (VendorOpt
->DiscoverCtrl
);
829 DefaultInfo
.MustUseList
= (BOOLEAN
) IS_ENABLE_USE_SERVER_LIST (VendorOpt
->DiscoverCtrl
);
830 DefaultInfo
.UseUCast
= DefaultInfo
.MustUseList
;
832 if (DefaultInfo
.UseMCast
) {
834 // Get the multicast discover ip address from vendor option.
837 &DefaultInfo
.ServerMCastIp
.Addr
,
838 &VendorOpt
->DiscoverMcastIp
,
839 sizeof (EFI_IPv4_ADDRESS
)
843 DefaultInfo
.IpCnt
= 0;
845 SrvList
= Info
->SrvList
;
847 if (DefaultInfo
.MustUseList
) {
848 BootSvrEntry
= VendorOpt
->BootSvr
;
849 Status
= EFI_INVALID_PARAMETER
;
851 while (((UINT8
) (BootSvrEntry
- VendorOpt
->BootSvr
)) < VendorOpt
->BootSvrLen
) {
853 if (BootSvrEntry
->Type
== HTONS (Type
)) {
854 Status
= EFI_SUCCESS
;
858 BootSvrEntry
= GET_NEXT_BOOT_SVR_ENTRY (BootSvrEntry
);
861 if (EFI_ERROR (Status
)) {
865 DefaultInfo
.IpCnt
= BootSvrEntry
->IpCnt
;
867 if (DefaultInfo
.IpCnt
>= 1) {
868 CreatedInfo
= AllocatePool (sizeof (DefaultInfo
) + (DefaultInfo
.IpCnt
- 1) * sizeof (*SrvList
));
869 if (CreatedInfo
== NULL
) {
870 return EFI_OUT_OF_RESOURCES
;
873 CopyMem (CreatedInfo
, &DefaultInfo
, sizeof (DefaultInfo
));
875 SrvList
= Info
->SrvList
;
878 for (Index
= 0; Index
< DefaultInfo
.IpCnt
; Index
++) {
879 CopyMem (&SrvList
[Index
].IpAddr
, &BootSvrEntry
->IpAddr
[Index
], sizeof (EFI_IPv4_ADDRESS
));
880 SrvList
[Index
].AcceptAnyResponse
= FALSE
;
881 SrvList
[Index
].Type
= BootSvrEntry
->Type
;
887 SrvList
= Info
->SrvList
;
889 if (!SrvList
[0].AcceptAnyResponse
) {
891 for (Index
= 1; Index
< Info
->IpCnt
; Index
++) {
892 if (SrvList
[Index
].AcceptAnyResponse
) {
897 if (Index
!= Info
->IpCnt
) {
898 return EFI_INVALID_PARAMETER
;
903 if ((!Info
->UseUCast
&& !Info
->UseBCast
&& !Info
->UseMCast
) || (Info
->MustUseList
&& Info
->IpCnt
== 0)) {
905 return EFI_INVALID_PARAMETER
;
908 // Execute discover by UniCast/BroadCast/MultiCast
910 if (Info
->UseUCast
) {
912 for (Index
= 0; Index
< Info
->IpCnt
; Index
++) {
914 if (BootSvrEntry
== NULL
) {
915 Private
->ServerIp
.Addr
[0] = SrvList
[Index
].IpAddr
.Addr
[0];
919 &BootSvrEntry
->IpAddr
[Index
],
920 sizeof (EFI_IPv4_ADDRESS
)
924 Status
= PxeBcDiscvBootService (
929 &SrvList
[Index
].IpAddr
,
933 &Private
->PxeReply
.Packet
.Ack
935 if (!EFI_ERROR (Status
)) {
940 } else if (Info
->UseMCast
) {
942 Status
= PxeBcDiscvBootService (
947 &Info
->ServerMCastIp
,
951 &Private
->PxeReply
.Packet
.Ack
954 } else if (Info
->UseBCast
) {
956 Status
= PxeBcDiscvBootService (
965 &Private
->PxeReply
.Packet
.Ack
969 if (EFI_ERROR (Status
) || !Mode
->PxeReplyReceived
|| (!Mode
->PxeBisReplyReceived
&& UseBis
)) {
970 if (Status
== EFI_ICMP_ERROR
) {
971 Mode
->IcmpErrorReceived
= TRUE
;
973 Status
= EFI_DEVICE_ERROR
;
976 PxeBcParseCachedDhcpPacket (&Private
->PxeReply
);
979 if (Mode
->PxeBisReplyReceived
) {
982 &Mode
->PxeReply
.Dhcpv4
.BootpSiAddr
,
983 sizeof (EFI_IPv4_ADDRESS
)
987 if (CreatedInfo
!= NULL
) {
988 FreePool (CreatedInfo
);
996 Used to perform TFTP and MTFTP services.
998 This function is used to perform TFTP and MTFTP services. This includes the
999 TFTP operations to get the size of a file, read a directory, read a file, and
1000 write a file. It also includes the MTFTP operations to get the size of a file,
1001 read a directory, and read a file. The type of operation is specified by Operation.
1002 If the callback function that is invoked during the TFTP/MTFTP operation does
1003 not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, then EFI_ABORTED will
1005 For read operations, the return data will be placed in the buffer specified by
1006 BufferPtr. If BufferSize is too small to contain the entire downloaded file,
1007 then EFI_BUFFER_TOO_SMALL will be returned and BufferSize will be set to zero
1008 or the size of the requested file (the size of the requested file is only returned
1009 if the TFTP server supports TFTP options). If BufferSize is large enough for the
1010 read operation, then BufferSize will be set to the size of the downloaded file,
1011 and EFI_SUCCESS will be returned. Applications using the PxeBc.Mtftp() services
1012 should use the get-file-size operations to determine the size of the downloaded
1013 file prior to using the read-file operations-especially when downloading large
1014 (greater than 64 MB) files-instead of making two calls to the read-file operation.
1015 Following this recommendation will save time if the file is larger than expected
1016 and the TFTP server does not support TFTP option extensions. Without TFTP option
1017 extension support, the client has to download the entire file, counting and discarding
1018 the received packets, to determine the file size.
1019 For write operations, the data to be sent is in the buffer specified by BufferPtr.
1020 BufferSize specifies the number of bytes to send. If the write operation completes
1021 successfully, then EFI_SUCCESS will be returned.
1022 For TFTP "get file size" operations, the size of the requested file or directory
1023 is returned in BufferSize, and EFI_SUCCESS will be returned. If the TFTP server
1024 does not support options, the file will be downloaded into a bit bucket and the
1025 length of the downloaded file will be returned. For MTFTP "get file size" operations,
1026 if the MTFTP server does not support the "get file size" option, EFI_UNSUPPORTED
1028 This function can take up to 10 seconds to timeout and return control to the caller.
1029 If the TFTP sequence does not complete, EFI_TIMEOUT will be returned.
1030 If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
1031 then the TFTP sequence is stopped and EFI_ABORTED will be returned.
1032 The format of the data returned from a TFTP read directory operation is a null-terminated
1033 filename followed by a null-terminated information string, of the form
1034 "size year-month-day hour:minute:second" (i.e. %d %d-%d-%d %d:%d:%f - note that
1035 the seconds field can be a decimal number), where the date and time are UTC. For
1036 an MTFTP read directory command, there is additionally a null-terminated multicast
1037 IP address preceding the filename of the form %d.%d.%d.%d for IP v4. The final
1038 entry is itself null-terminated, so that the final information string is terminated
1039 with two null octets.
1041 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
1042 @param Operation The type of operation to perform.
1043 @param BufferPtr A pointer to the data buffer.
1044 @param Overwrite Only used on write file operations. TRUE if a file on a remote server can
1046 @param BufferSize For get-file-size operations, *BufferSize returns the size of the
1048 @param BlockSize The requested block size to be used during a TFTP transfer.
1049 @param ServerIp The TFTP / MTFTP server IP address.
1050 @param Filename A Null-terminated ASCII string that specifies a directory name or a file
1052 @param Info Pointer to the MTFTP information.
1053 @param DontUseBuffer Set to FALSE for normal TFTP and MTFTP read file operation.
1055 @retval EFI_SUCCESS The TFTP/MTFTP operation was completed.
1056 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
1057 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1058 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1059 @retval EFI_BUFFER_TOO_SMALL The buffer is not large enough to complete the read operation.
1060 @retval EFI_ABORTED The callback function aborted the TFTP/MTFTP operation.
1061 @retval EFI_TIMEOUT The TFTP/MTFTP operation timed out.
1062 @retval EFI_ICMP_ERROR An ICMP error packet was received during the MTFTP session.
1063 @retval EFI_TFTP_ERROR A TFTP error packet was received during the MTFTP session.
1069 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
1070 IN EFI_PXE_BASE_CODE_TFTP_OPCODE Operation
,
1071 IN OUT VOID
*BufferPtr
,
1072 IN BOOLEAN Overwrite
,
1073 IN OUT UINT64
*BufferSize
,
1074 IN UINTN
*BlockSize OPTIONAL
,
1075 IN EFI_IP_ADDRESS
*ServerIp
,
1077 IN EFI_PXE_BASE_CODE_MTFTP_INFO
*Info OPTIONAL
,
1078 IN BOOLEAN DontUseBuffer
1081 PXEBC_PRIVATE_DATA
*Private
;
1082 EFI_MTFTP4_CONFIG_DATA Mtftp4Config
;
1084 EFI_PXE_BASE_CODE_MODE
*Mode
;
1085 EFI_MAC_ADDRESS TempMacAddr
;
1087 if ((This
== NULL
) ||
1088 (Filename
== NULL
) ||
1089 (BufferSize
== NULL
) ||
1090 ((ServerIp
== NULL
) || !NetIp4IsUnicast (NTOHL (ServerIp
->Addr
[0]), 0)) ||
1091 ((BufferPtr
== NULL
) && DontUseBuffer
) ||
1092 ((BlockSize
!= NULL
) && (*BlockSize
< 512))) {
1094 return EFI_INVALID_PARAMETER
;
1097 Status
= EFI_DEVICE_ERROR
;
1098 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
1099 Mode
= &Private
->Mode
;
1101 if (!Mode
->AutoArp
) {
1103 // If AutoArp is set false, check arp cache
1105 UpdateArpCache (This
);
1106 if (!FindInArpCache (Mode
, &ServerIp
->v4
, &TempMacAddr
)) {
1107 return EFI_DEVICE_ERROR
;
1111 Mode
->TftpErrorReceived
= FALSE
;
1112 Mode
->IcmpErrorReceived
= FALSE
;
1114 Mtftp4Config
.UseDefaultSetting
= FALSE
;
1115 Mtftp4Config
.TimeoutValue
= PXEBC_MTFTP_TIMEOUT
;
1116 Mtftp4Config
.TryCount
= PXEBC_MTFTP_RETRIES
;
1119 &Mtftp4Config
.StationIp
,
1120 &Private
->StationIp
,
1121 sizeof (EFI_IPv4_ADDRESS
)
1124 &Mtftp4Config
.SubnetMask
,
1125 &Private
->SubnetMask
,
1126 sizeof (EFI_IPv4_ADDRESS
)
1129 &Mtftp4Config
.GatewayIp
,
1130 &Private
->GatewayIp
,
1131 sizeof (EFI_IPv4_ADDRESS
)
1134 &Mtftp4Config
.ServerIp
,
1136 sizeof (EFI_IPv4_ADDRESS
)
1139 switch (Operation
) {
1141 case EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE
:
1143 Status
= PxeBcTftpGetFileSize (
1153 case EFI_PXE_BASE_CODE_TFTP_READ_FILE
:
1155 Status
= PxeBcTftpReadFile (
1167 case EFI_PXE_BASE_CODE_TFTP_WRITE_FILE
:
1169 Status
= PxeBcTftpWriteFile (
1181 case EFI_PXE_BASE_CODE_TFTP_READ_DIRECTORY
:
1183 Status
= PxeBcTftpReadDirectory (
1195 case EFI_PXE_BASE_CODE_MTFTP_GET_FILE_SIZE
:
1196 case EFI_PXE_BASE_CODE_MTFTP_READ_FILE
:
1197 case EFI_PXE_BASE_CODE_MTFTP_READ_DIRECTORY
:
1198 Status
= EFI_UNSUPPORTED
;
1203 Status
= EFI_INVALID_PARAMETER
;
1207 if (Status
== EFI_ICMP_ERROR
) {
1208 Mode
->IcmpErrorReceived
= TRUE
;
1216 Writes a UDP packet to the network interface.
1218 This function writes a UDP packet specified by the (optional HeaderPtr and)
1219 BufferPtr parameters to the network interface. The UDP header is automatically
1220 built by this routine. It uses the parameters OpFlags, DestIp, DestPort, GatewayIp,
1221 SrcIp, and SrcPort to build this header. If the packet is successfully built and
1222 transmitted through the network interface, then EFI_SUCCESS will be returned.
1223 If a timeout occurs during the transmission of the packet, then EFI_TIMEOUT will
1224 be returned. If an ICMP error occurs during the transmission of the packet, then
1225 the IcmpErrorReceived field is set to TRUE, the IcmpError field is filled in and
1226 EFI_ICMP_ERROR will be returned. If the Callback Protocol does not return
1227 EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE, then EFI_ABORTED will be returned.
1229 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
1230 @param OpFlags The UDP operation flags.
1231 @param DestIp The destination IP address.
1232 @param DestPort The destination UDP port number.
1233 @param GatewayIp The gateway IP address.
1234 @param SrcIp The source IP address.
1235 @param SrcPort The source UDP port number.
1236 @param HeaderSize An optional field which may be set to the length of a header at
1237 HeaderPtr to be prefixed to the data at BufferPtr.
1238 @param HeaderPtr If HeaderSize is not NULL, a pointer to a header to be prefixed to the
1240 @param BufferSize A pointer to the size of the data at BufferPtr.
1241 @param BufferPtr A pointer to the data to be written.
1243 @retval EFI_SUCCESS The UDP Write operation was completed.
1244 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
1245 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1246 @retval EFI_BAD_BUFFER_SIZE The buffer is too long to be transmitted.
1247 @retval EFI_ABORTED The callback function aborted the UDP Write operation.
1248 @retval EFI_TIMEOUT The UDP Write operation timed out.
1249 @retval EFI_ICMP_ERROR An ICMP error packet was received during the UDP write session.
1255 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
1257 IN EFI_IP_ADDRESS
*DestIp
,
1258 IN EFI_PXE_BASE_CODE_UDP_PORT
*DestPort
,
1259 IN EFI_IP_ADDRESS
*GatewayIp OPTIONAL
,
1260 IN EFI_IP_ADDRESS
*SrcIp OPTIONAL
,
1261 IN OUT EFI_PXE_BASE_CODE_UDP_PORT
*SrcPort OPTIONAL
,
1262 IN UINTN
*HeaderSize OPTIONAL
,
1263 IN VOID
*HeaderPtr OPTIONAL
,
1264 IN UINTN
*BufferSize
,
1268 PXEBC_PRIVATE_DATA
*Private
;
1269 EFI_UDP4_PROTOCOL
*Udp4
;
1270 EFI_UDP4_COMPLETION_TOKEN Token
;
1271 EFI_UDP4_TRANSMIT_DATA
*Udp4TxData
;
1274 EFI_UDP4_SESSION_DATA Udp4Session
;
1277 EFI_PXE_BASE_CODE_MODE
*Mode
;
1278 EFI_MAC_ADDRESS TempMacAddr
;
1282 if ((This
== NULL
) || (DestIp
== NULL
) || (DestPort
== NULL
)) {
1283 return EFI_INVALID_PARAMETER
;
1286 if ((GatewayIp
!= NULL
) && !NetIp4IsUnicast (NTOHL (GatewayIp
->Addr
[0]), 0)) {
1288 // Gateway is provided but it's not a unicast IP address.
1290 return EFI_INVALID_PARAMETER
;
1293 if ((HeaderSize
!= NULL
) && ((*HeaderSize
== 0) || (HeaderPtr
== NULL
))) {
1295 // The HeaderSize ptr isn't NULL and: 1. the value is zero; or 2. the HeaderPtr
1298 return EFI_INVALID_PARAMETER
;
1301 if ((BufferSize
== NULL
) || ((*BufferSize
!= 0) && (BufferPtr
== NULL
))) {
1302 return EFI_INVALID_PARAMETER
;
1305 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
1306 Udp4
= Private
->Udp4Write
;
1307 Mode
= &Private
->Mode
;
1308 if (!Mode
->Started
) {
1309 return EFI_NOT_STARTED
;
1312 if (!Private
->AddressIsOk
&& (SrcIp
== NULL
)) {
1313 return EFI_INVALID_PARAMETER
;
1316 if (!Mode
->AutoArp
) {
1318 // If AutoArp is set false, check arp cache
1320 UpdateArpCache (This
);
1321 if (!FindInArpCache (Mode
, &DestIp
->v4
, &TempMacAddr
)) {
1322 return EFI_DEVICE_ERROR
;
1326 Mode
->IcmpErrorReceived
= FALSE
;
1328 if ((Private
->CurrentUdpSrcPort
== 0) ||
1329 ((SrcPort
!= NULL
) && (*SrcPort
!= Private
->CurrentUdpSrcPort
))) {
1331 // Port is changed, (re)configure the Udp4Write instance
1333 if (SrcPort
!= NULL
) {
1334 Private
->CurrentUdpSrcPort
= *SrcPort
;
1337 Status
= PxeBcConfigureUdpWriteInstance (
1339 &Private
->StationIp
.v4
,
1340 &Private
->SubnetMask
.v4
,
1341 &Private
->GatewayIp
.v4
,
1342 &Private
->CurrentUdpSrcPort
1344 if (EFI_ERROR (Status
)) {
1345 Private
->CurrentUdpSrcPort
= 0;
1346 return EFI_INVALID_PARAMETER
;
1350 ZeroMem (&Token
, sizeof (EFI_UDP4_COMPLETION_TOKEN
));
1351 ZeroMem (&Udp4Session
, sizeof (EFI_UDP4_SESSION_DATA
));
1353 CopyMem (&Udp4Session
.DestinationAddress
, DestIp
, sizeof (EFI_IPv4_ADDRESS
));
1354 Udp4Session
.DestinationPort
= *DestPort
;
1355 if (SrcIp
!= NULL
) {
1356 CopyMem (&Udp4Session
.SourceAddress
, SrcIp
, sizeof (EFI_IPv4_ADDRESS
));
1358 if (SrcPort
!= NULL
) {
1359 Udp4Session
.SourcePort
= *SrcPort
;
1362 FragCount
= (HeaderSize
!= NULL
) ? 2 : 1;
1363 Udp4TxData
= (EFI_UDP4_TRANSMIT_DATA
*) AllocateZeroPool (sizeof (EFI_UDP4_TRANSMIT_DATA
) + (FragCount
- 1) * sizeof (EFI_UDP4_FRAGMENT_DATA
));
1364 if (Udp4TxData
== NULL
) {
1365 return EFI_OUT_OF_RESOURCES
;
1368 Udp4TxData
->FragmentCount
= FragCount
;
1369 Udp4TxData
->FragmentTable
[FragCount
- 1].FragmentLength
= (UINT32
) *BufferSize
;
1370 Udp4TxData
->FragmentTable
[FragCount
- 1].FragmentBuffer
= BufferPtr
;
1371 DataLength
= (UINT32
) *BufferSize
;
1373 if (FragCount
== 2) {
1375 Udp4TxData
->FragmentTable
[0].FragmentLength
= (UINT32
) *HeaderSize
;
1376 Udp4TxData
->FragmentTable
[0].FragmentBuffer
= HeaderPtr
;
1377 DataLength
+= (UINT32
) *HeaderSize
;
1380 if (GatewayIp
!= NULL
) {
1381 Udp4TxData
->GatewayAddress
= (EFI_IPv4_ADDRESS
*) GatewayIp
;
1383 Udp4TxData
->UdpSessionData
= &Udp4Session
;
1384 Udp4TxData
->DataLength
= DataLength
;
1385 Token
.Packet
.TxData
= Udp4TxData
;
1387 Status
= gBS
->CreateEvent (
1394 if (EFI_ERROR (Status
)) {
1398 Status
= Udp4
->Transmit (Udp4
, &Token
);
1399 if (EFI_ERROR (Status
)) {
1400 if (Status
== EFI_ICMP_ERROR
) {
1401 Mode
->IcmpErrorReceived
= TRUE
;
1411 Status
= Token
.Status
;
1415 if (Token
.Event
!= NULL
) {
1416 gBS
->CloseEvent (Token
.Event
);
1419 FreePool (Udp4TxData
);
1425 Decide whether the incoming UDP packet is acceptable per IP filter settings
1426 in provided PxeBcMode.
1428 @param PxeBcMode Pointer to EFI_PXE_BASE_CODE_MODE.
1429 @param Session Received UDP session.
1431 @retval TRUE The UDP package matches IP filters.
1432 @retval FALSE The UDP package doesn't matches IP filters.
1437 IN EFI_PXE_BASE_CODE_MODE
*PxeBcMode
,
1438 IN EFI_UDP4_SESSION_DATA
*Session
1442 EFI_IPv4_ADDRESS Ip4Address
;
1443 EFI_IPv4_ADDRESS DestIp4Address
;
1445 if ((PxeBcMode
->IpFilter
.Filters
& EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS
) != 0) {
1449 CopyMem (&DestIp4Address
, &Session
->DestinationAddress
, sizeof (DestIp4Address
));
1450 if (((PxeBcMode
->IpFilter
.Filters
& EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST
) != 0) &&
1451 IP4_IS_MULTICAST (EFI_NTOHL (DestIp4Address
))
1456 if (((PxeBcMode
->IpFilter
.Filters
& EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST
) != 0) &&
1457 IP4_IS_LOCAL_BROADCAST (EFI_NTOHL (DestIp4Address
))
1462 CopyMem (&Ip4Address
, &PxeBcMode
->StationIp
.v4
, sizeof (Ip4Address
));
1463 if (((PxeBcMode
->IpFilter
.Filters
& EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP
) != 0) &&
1464 EFI_IP4_EQUAL (&Ip4Address
, &DestIp4Address
)
1469 ASSERT (PxeBcMode
->IpFilter
.IpCnt
< EFI_PXE_BASE_CODE_MAX_IPCNT
);
1471 for (Index
= 0; Index
< PxeBcMode
->IpFilter
.IpCnt
; Index
++) {
1474 &PxeBcMode
->IpFilter
.IpList
[Index
].v4
,
1477 if (EFI_IP4_EQUAL (&Ip4Address
, &DestIp4Address
)) {
1486 Reads a UDP packet from the network interface.
1488 This function reads a UDP packet from a network interface. The data contents
1489 are returned in (the optional HeaderPtr and) BufferPtr, and the size of the
1490 buffer received is returned in BufferSize . If the input BufferSize is smaller
1491 than the UDP packet received (less optional HeaderSize), it will be set to the
1492 required size, and EFI_BUFFER_TOO_SMALL will be returned. In this case, the
1493 contents of BufferPtr are undefined, and the packet is lost. If a UDP packet is
1494 successfully received, then EFI_SUCCESS will be returned, and the information
1495 from the UDP header will be returned in DestIp, DestPort, SrcIp, and SrcPort if
1496 they are not NULL. Depending on the values of OpFlags and the DestIp, DestPort,
1497 SrcIp, and SrcPort input values, different types of UDP packet receive filtering
1498 will be performed. The following tables summarize these receive filter operations.
1500 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
1501 @param OpFlags The UDP operation flags.
1502 @param DestIp The destination IP address.
1503 @param DestPort The destination UDP port number.
1504 @param SrcIp The source IP address.
1505 @param SrcPort The source UDP port number.
1506 @param HeaderSize An optional field which may be set to the length of a header at
1507 HeaderPtr to be prefixed to the data at BufferPtr.
1508 @param HeaderPtr If HeaderSize is not NULL, a pointer to a header to be prefixed to the
1510 @param BufferSize A pointer to the size of the data at BufferPtr.
1511 @param BufferPtr A pointer to the data to be read.
1513 @retval EFI_SUCCESS The UDP Read operation was completed.
1514 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
1515 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1516 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1517 @retval EFI_BUFFER_TOO_SMALL The packet is larger than Buffer can hold.
1518 @retval EFI_ABORTED The callback function aborted the UDP Read operation.
1519 @retval EFI_TIMEOUT The UDP Read operation timed out.
1525 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
1527 IN OUT EFI_IP_ADDRESS
*DestIp OPTIONAL
,
1528 IN OUT EFI_PXE_BASE_CODE_UDP_PORT
*DestPort OPTIONAL
,
1529 IN OUT EFI_IP_ADDRESS
*SrcIp OPTIONAL
,
1530 IN OUT EFI_PXE_BASE_CODE_UDP_PORT
*SrcPort OPTIONAL
,
1531 IN UINTN
*HeaderSize OPTIONAL
,
1532 IN VOID
*HeaderPtr OPTIONAL
,
1533 IN OUT UINTN
*BufferSize
,
1537 PXEBC_PRIVATE_DATA
*Private
;
1538 EFI_PXE_BASE_CODE_MODE
*Mode
;
1539 EFI_UDP4_PROTOCOL
*Udp4
;
1540 EFI_UDP4_COMPLETION_TOKEN Token
;
1541 EFI_UDP4_RECEIVE_DATA
*RxData
;
1542 EFI_UDP4_SESSION_DATA
*Session
;
1548 if (This
== NULL
|| DestIp
== NULL
|| DestPort
== NULL
) {
1549 return EFI_INVALID_PARAMETER
;
1552 if (((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT
) == 0 && (DestPort
== NULL
)) ||
1553 ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT
) == 0 && (SrcIp
== NULL
)) ||
1554 ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT
) == 0 && (SrcPort
== NULL
))) {
1555 return EFI_INVALID_PARAMETER
;
1558 if (((HeaderSize
!= NULL
) && (*HeaderSize
== 0)) || ((HeaderSize
!= NULL
) && (HeaderPtr
== NULL
))) {
1559 return EFI_INVALID_PARAMETER
;
1562 if ((BufferSize
== NULL
) || (BufferPtr
== NULL
)) {
1563 return EFI_INVALID_PARAMETER
;
1566 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
1567 Mode
= Private
->PxeBc
.Mode
;
1568 Udp4
= Private
->Udp4Read
;
1570 if (!Mode
->Started
) {
1571 return EFI_NOT_STARTED
;
1574 Mode
->IcmpErrorReceived
= FALSE
;
1576 Status
= gBS
->CreateEvent (
1583 if (EFI_ERROR (Status
)) {
1584 return EFI_OUT_OF_RESOURCES
;
1590 Status
= Udp4
->Receive (Udp4
, &Token
);
1591 if (EFI_ERROR (Status
)) {
1592 if (Status
== EFI_ICMP_ERROR
) {
1593 Mode
->IcmpErrorReceived
= TRUE
;
1601 Status
= EFI_TIMEOUT
;
1605 // check whether this packet matches the filters
1607 if (EFI_ERROR (Token
.Status
)){
1611 RxData
= Token
.Packet
.RxData
;
1612 Session
= &RxData
->UdpSession
;
1616 if ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER
) != 0) {
1619 // Check UDP package by IP filter settings
1621 if (CheckIpByFilter (Mode
, Session
)) {
1630 // Match the destination ip of the received udp dgram
1632 if ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP
) != 0) {
1635 if (DestIp
!= NULL
) {
1636 CopyMem (DestIp
, &Session
->DestinationAddress
, sizeof (EFI_IPv4_ADDRESS
));
1639 if (DestIp
!= NULL
) {
1640 if (EFI_IP4_EQUAL (DestIp
, &Session
->DestinationAddress
)) {
1644 if (EFI_IP4_EQUAL (&Private
->StationIp
, &Session
->DestinationAddress
)) {
1653 // Match the destination port of the received udp dgram
1655 if ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT
) != 0) {
1657 if (DestPort
!= NULL
) {
1658 *DestPort
= Session
->DestinationPort
;
1662 if (*DestPort
!= Session
->DestinationPort
) {
1670 // Match the source ip of the received udp dgram
1672 if ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP
) != 0) {
1674 if (SrcIp
!= NULL
) {
1675 CopyMem (SrcIp
, &Session
->SourceAddress
, sizeof (EFI_IPv4_ADDRESS
));
1679 if (!EFI_IP4_EQUAL (SrcIp
, &Session
->SourceAddress
)) {
1687 // Match the source port of the received udp dgram
1689 if ((OpFlags
& EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT
) != 0) {
1691 if (SrcPort
!= NULL
) {
1692 *SrcPort
= Session
->SourcePort
;
1696 if (*SrcPort
!= Session
->SourcePort
) {
1706 if (HeaderSize
!= NULL
) {
1707 CopyLen
= MIN (*HeaderSize
, RxData
->DataLength
);
1708 CopyMem (HeaderPtr
, RxData
->FragmentTable
[0].FragmentBuffer
, CopyLen
);
1709 *HeaderSize
= CopyLen
;
1712 if (RxData
->DataLength
- CopyLen
> *BufferSize
) {
1714 Status
= EFI_BUFFER_TOO_SMALL
;
1717 *BufferSize
= RxData
->DataLength
- CopyLen
;
1720 (UINT8
*) RxData
->FragmentTable
[0].FragmentBuffer
+ CopyLen
,
1726 Status
= EFI_TIMEOUT
;
1730 // Recycle the RxData
1732 gBS
->SignalEvent (RxData
->RecycleSignal
);
1741 Udp4
->Cancel (Udp4
, &Token
);
1743 gBS
->CloseEvent (Token
.Event
);
1749 Updates the IP receive filters of a network device and enables software filtering.
1751 The NewFilter field is used to modify the network device's current IP receive
1752 filter settings and to enable a software filter. This function updates the IpFilter
1753 field of the EFI_PXE_BASE_CODE_MODE structure with the contents of NewIpFilter.
1754 The software filter is used when the USE_FILTER in OpFlags is set to UdpRead().
1755 The current hardware filter remains in effect no matter what the settings of OpFlags
1756 are, so that the meaning of ANY_DEST_IP set in OpFlags to UdpRead() is from those
1757 packets whose reception is enabled in hardware-physical NIC address (unicast),
1758 broadcast address, logical address or addresses (multicast), or all (promiscuous).
1759 UdpRead() does not modify the IP filter settings.
1760 Dhcp(), Discover(), and Mtftp() set the IP filter, and return with the IP receive
1761 filter list emptied and the filter set to EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP.
1762 If an application or driver wishes to preserve the IP receive filter settings,
1763 it will have to preserve the IP receive filter settings before these calls, and
1764 use SetIpFilter() to restore them after the calls. If incompatible filtering is
1765 requested (for example, PROMISCUOUS with anything else) or if the device does not
1766 support a requested filter setting and it cannot be accommodated in software
1767 (for example, PROMISCUOUS not supported), EFI_INVALID_PARAMETER will be returned.
1768 The IPlist field is used to enable IPs other than the StationIP. They may be
1769 multicast or unicast. If IPcnt is set as well as EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP,
1770 then both the StationIP and the IPs from the IPlist will be used.
1772 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
1773 @param NewFilter Pointer to the new set of IP receive filters.
1775 @retval EFI_SUCCESS The IP receive filter settings were updated.
1776 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
1777 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1782 EfiPxeBcSetIpFilter (
1783 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
1784 IN EFI_PXE_BASE_CODE_IP_FILTER
*NewFilter
1788 PXEBC_PRIVATE_DATA
*Private
;
1789 EFI_PXE_BASE_CODE_MODE
*Mode
;
1791 BOOLEAN PromiscuousNeed
;
1794 DEBUG ((EFI_D_ERROR
, "This == NULL.\n"));
1795 return EFI_INVALID_PARAMETER
;
1798 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
1799 Mode
= Private
->PxeBc
.Mode
;
1801 if (NewFilter
== NULL
) {
1802 DEBUG ((EFI_D_ERROR
, "NewFilter == NULL.\n"));
1803 return EFI_INVALID_PARAMETER
;
1806 if (NewFilter
->IpCnt
> EFI_PXE_BASE_CODE_MAX_IPCNT
) {
1807 DEBUG ((EFI_D_ERROR
, "NewFilter->IpCnt > %d.\n", EFI_PXE_BASE_CODE_MAX_IPCNT
));
1808 return EFI_INVALID_PARAMETER
;
1811 if (!Mode
->Started
) {
1812 DEBUG ((EFI_D_ERROR
, "BC was not started.\n"));
1813 return EFI_NOT_STARTED
;
1816 PromiscuousNeed
= FALSE
;
1818 for (Index
= 0; Index
< NewFilter
->IpCnt
; ++Index
) {
1819 if (IP4_IS_LOCAL_BROADCAST (EFI_IP4 (NewFilter
->IpList
[Index
].v4
))) {
1821 // The IP is a broadcast address.
1823 DEBUG ((EFI_D_ERROR
, "There is broadcast address in NewFilter.\n"));
1824 return EFI_INVALID_PARAMETER
;
1826 if (NetIp4IsUnicast (EFI_IP4 (NewFilter
->IpList
[Index
].v4
), 0) &&
1827 ((NewFilter
->Filters
& EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP
) != 0)
1830 // If EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP is set and IP4 address is in IpList,
1831 // promiscuous mode is needed.
1833 PromiscuousNeed
= TRUE
;
1838 // Clear the UDP instance configuration, all joined groups will be left
1839 // during the operation.
1841 Private
->Udp4Read
->Configure (Private
->Udp4Read
, NULL
);
1842 Private
->Udp4CfgData
.AcceptPromiscuous
= FALSE
;
1843 Private
->Udp4CfgData
.AcceptBroadcast
= FALSE
;
1845 if (PromiscuousNeed
||
1846 ((NewFilter
->Filters
& EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS
) != 0) ||
1847 ((NewFilter
->Filters
& EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST
) != 0)
1850 // Configure the udp4 filter to receive all packages
1852 Private
->Udp4CfgData
.AcceptPromiscuous
= TRUE
;
1855 // Configure the UDP instance with the new configuration.
1857 Status
= Private
->Udp4Read
->Configure (Private
->Udp4Read
, &Private
->Udp4CfgData
);
1858 if (EFI_ERROR (Status
)) {
1864 if ((NewFilter
->Filters
& EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST
) != 0) {
1866 // Configure the udp4 filter to receive all broadcast packages
1868 Private
->Udp4CfgData
.AcceptBroadcast
= TRUE
;
1872 // Configure the UDP instance with the new configuration.
1874 Status
= Private
->Udp4Read
->Configure (Private
->Udp4Read
, &Private
->Udp4CfgData
);
1875 if (EFI_ERROR (Status
)) {
1879 if ((NewFilter
->Filters
& EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP
) != 0) {
1881 for (Index
= 0; Index
< NewFilter
->IpCnt
; ++Index
) {
1882 if (IP4_IS_MULTICAST (EFI_NTOHL (NewFilter
->IpList
[Index
].v4
))) {
1884 // Join the mutilcast group
1886 Status
= Private
->Udp4Read
->Groups (Private
->Udp4Read
, TRUE
, &NewFilter
->IpList
[Index
].v4
);
1887 if (EFI_ERROR (Status
)) {
1897 // Save the new filter.
1899 CopyMem (&Mode
->IpFilter
, NewFilter
, sizeof (Mode
->IpFilter
));
1906 Uses the ARP protocol to resolve a MAC address.
1908 This function uses the ARP protocol to resolve a MAC address. The UsingIpv6 field
1909 of the EFI_PXE_BASE_CODE_MODE structure is used to determine if IPv4 or IPv6
1910 addresses are being used. The IP address specified by IpAddr is used to resolve
1911 a MAC address. If the ARP protocol succeeds in resolving the specified address,
1912 then the ArpCacheEntries and ArpCache fields of the EFI_PXE_BASE_CODE_MODE structure
1913 are updated, and EFI_SUCCESS is returned. If MacAddr is not NULL, the resolved
1914 MAC address is placed there as well. If the PXE Base Code protocol is in the
1915 stopped state, then EFI_NOT_STARTED is returned. If the ARP protocol encounters
1916 a timeout condition while attempting to resolve an address, then EFI_TIMEOUT is
1917 returned. If the Callback Protocol does not return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
1918 then EFI_ABORTED is returned.
1920 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
1921 @param IpAddr Pointer to the IP address that is used to resolve a MAC address.
1922 @param MacAddr If not NULL, a pointer to the MAC address that was resolved with the
1925 @retval EFI_SUCCESS The IP or MAC address was resolved.
1926 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
1927 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
1928 @retval EFI_DEVICE_ERROR The network device encountered an error during this operation.
1929 @retval EFI_ICMP_ERROR Something error occur with the ICMP packet message.
1935 IN EFI_PXE_BASE_CODE_PROTOCOL
* This
,
1936 IN EFI_IP_ADDRESS
* IpAddr
,
1937 IN EFI_MAC_ADDRESS
* MacAddr OPTIONAL
1940 PXEBC_PRIVATE_DATA
*Private
;
1941 EFI_PXE_BASE_CODE_MODE
*Mode
;
1943 EFI_MAC_ADDRESS TempMacAddr
;
1945 if (This
== NULL
|| IpAddr
== NULL
) {
1946 return EFI_INVALID_PARAMETER
;
1949 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
1950 Mode
= Private
->PxeBc
.Mode
;
1952 if (!Mode
->Started
) {
1953 return EFI_NOT_STARTED
;
1956 if (!Private
->AddressIsOk
|| Mode
->UsingIpv6
) {
1958 // We can't resolve the IP address if we don't have a local address now.
1959 // Don't have ARP for IPv6.
1961 return EFI_INVALID_PARAMETER
;
1964 Mode
->IcmpErrorReceived
= FALSE
;
1966 if (!Mode
->AutoArp
) {
1968 // If AutoArp is set false, check arp cache
1970 UpdateArpCache (This
);
1971 if (!FindInArpCache (Mode
, &IpAddr
->v4
, &TempMacAddr
)) {
1972 return EFI_DEVICE_ERROR
;
1975 Status
= Private
->Arp
->Request (Private
->Arp
, &IpAddr
->v4
, NULL
, &TempMacAddr
);
1976 if (EFI_ERROR (Status
)) {
1977 if (Status
== EFI_ICMP_ERROR
) {
1978 Mode
->IcmpErrorReceived
= TRUE
;
1984 if (MacAddr
!= NULL
) {
1985 CopyMem (MacAddr
, &TempMacAddr
, sizeof (EFI_MAC_ADDRESS
));
1992 Updates the parameters that affect the operation of the PXE Base Code Protocol.
1994 This function sets parameters that affect the operation of the PXE Base Code Protocol.
1995 The parameter specified by NewAutoArp is used to control the generation of ARP
1996 protocol packets. If NewAutoArp is TRUE, then ARP Protocol packets will be generated
1997 as required by the PXE Base Code Protocol. If NewAutoArp is FALSE, then no ARP
1998 Protocol packets will be generated. In this case, the only mappings that are
1999 available are those stored in the ArpCache of the EFI_PXE_BASE_CODE_MODE structure.
2000 If there are not enough mappings in the ArpCache to perform a PXE Base Code Protocol
2001 service, then the service will fail. This function updates the AutoArp field of
2002 the EFI_PXE_BASE_CODE_MODE structure to NewAutoArp.
2003 The SetParameters() call must be invoked after a Callback Protocol is installed
2004 to enable the use of callbacks.
2006 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
2007 @param NewAutoArp If not NULL, a pointer to a value that specifies whether to replace the
2008 current value of AutoARP.
2009 @param NewSendGUID If not NULL, a pointer to a value that specifies whether to replace the
2010 current value of SendGUID.
2011 @param NewTTL If not NULL, a pointer to be used in place of the current value of TTL,
2012 the "time to live" field of the IP header.
2013 @param NewToS If not NULL, a pointer to be used in place of the current value of ToS,
2014 the "type of service" field of the IP header.
2015 @param NewMakeCallback If not NULL, a pointer to a value that specifies whether to replace the
2016 current value of the MakeCallback field of the Mode structure.
2018 @retval EFI_SUCCESS The new parameters values were updated.
2019 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
2020 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
2025 EfiPxeBcSetParameters (
2026 IN EFI_PXE_BASE_CODE_PROTOCOL
*This
,
2027 IN BOOLEAN
*NewAutoArp OPTIONAL
,
2028 IN BOOLEAN
*NewSendGUID OPTIONAL
,
2029 IN UINT8
*NewTTL OPTIONAL
,
2030 IN UINT8
*NewToS OPTIONAL
,
2031 IN BOOLEAN
*NewMakeCallback
// OPTIONAL
2034 PXEBC_PRIVATE_DATA
*Private
;
2035 EFI_PXE_BASE_CODE_MODE
*Mode
;
2038 Status
= EFI_SUCCESS
;
2041 Status
= EFI_INVALID_PARAMETER
;
2045 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
2046 Mode
= Private
->PxeBc
.Mode
;
2048 if (NewSendGUID
!= NULL
&& *NewSendGUID
) {
2050 // FixMe, cann't locate SendGuid
2054 if (NewMakeCallback
!= NULL
&& *NewMakeCallback
) {
2056 Status
= gBS
->HandleProtocol (
2057 Private
->Controller
,
2058 &gEfiPxeBaseCodeCallbackProtocolGuid
,
2059 (VOID
**) &Private
->PxeBcCallback
2061 if (EFI_ERROR (Status
) || (Private
->PxeBcCallback
->Callback
== NULL
)) {
2063 Status
= EFI_INVALID_PARAMETER
;
2068 if (!Mode
->Started
) {
2069 Status
= EFI_NOT_STARTED
;
2073 if (NewMakeCallback
!= NULL
) {
2075 if (*NewMakeCallback
) {
2077 // Update the Callback protocol.
2079 Status
= gBS
->HandleProtocol (
2080 Private
->Controller
,
2081 &gEfiPxeBaseCodeCallbackProtocolGuid
,
2082 (VOID
**) &Private
->PxeBcCallback
2085 if (EFI_ERROR (Status
) || (Private
->PxeBcCallback
->Callback
== NULL
)) {
2086 Status
= EFI_INVALID_PARAMETER
;
2090 Private
->PxeBcCallback
= NULL
;
2093 Mode
->MakeCallbacks
= *NewMakeCallback
;
2096 if (NewAutoArp
!= NULL
) {
2097 Mode
->AutoArp
= *NewAutoArp
;
2100 if (NewSendGUID
!= NULL
) {
2101 Mode
->SendGUID
= *NewSendGUID
;
2104 if (NewTTL
!= NULL
) {
2105 Mode
->TTL
= *NewTTL
;
2108 if (NewToS
!= NULL
) {
2109 Mode
->ToS
= *NewToS
;
2117 Updates the station IP address and/or subnet mask values of a network device.
2119 This function updates the station IP address and/or subnet mask values of a network
2120 device. The NewStationIp field is used to modify the network device's current IP address.
2121 If NewStationIP is NULL, then the current IP address will not be modified. Otherwise,
2122 this function updates the StationIp field of the EFI_PXE_BASE_CODE_MODE structure
2123 with NewStationIp. The NewSubnetMask field is used to modify the network device's current subnet
2124 mask. If NewSubnetMask is NULL, then the current subnet mask will not be modified.
2125 Otherwise, this function updates the SubnetMask field of the EFI_PXE_BASE_CODE_MODE
2126 structure with NewSubnetMask.
2128 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
2129 @param NewStationIp Pointer to the new IP address to be used by the network device.
2130 @param NewSubnetMask Pointer to the new subnet mask to be used by the network device.
2132 @retval EFI_SUCCESS The new station IP address and/or subnet mask were updated.
2133 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
2134 @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
2139 EfiPxeBcSetStationIP (
2140 IN EFI_PXE_BASE_CODE_PROTOCOL
* This
,
2141 IN EFI_IP_ADDRESS
* NewStationIp OPTIONAL
,
2142 IN EFI_IP_ADDRESS
* NewSubnetMask OPTIONAL
2145 PXEBC_PRIVATE_DATA
*Private
;
2146 EFI_PXE_BASE_CODE_MODE
*Mode
;
2147 EFI_ARP_CONFIG_DATA ArpConfigData
;
2150 return EFI_INVALID_PARAMETER
;
2153 if (NewStationIp
!= NULL
&& !NetIp4IsUnicast (NTOHL (NewStationIp
->Addr
[0]), 0)) {
2154 return EFI_INVALID_PARAMETER
;
2157 if (NewSubnetMask
!= NULL
&& !IP4_IS_VALID_NETMASK (NTOHL (NewSubnetMask
->Addr
[0]))) {
2158 return EFI_INVALID_PARAMETER
;
2161 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
2162 Mode
= Private
->PxeBc
.Mode
;
2164 if (!Mode
->Started
) {
2165 return EFI_NOT_STARTED
;
2168 if (NewStationIp
!= NULL
) {
2169 CopyMem (&Mode
->StationIp
, NewStationIp
, sizeof (EFI_IP_ADDRESS
));
2170 CopyMem (&Private
->StationIp
, NewStationIp
, sizeof (EFI_IP_ADDRESS
));
2173 if (NewSubnetMask
!= NULL
) {
2174 CopyMem (&Mode
->SubnetMask
, NewSubnetMask
, sizeof (EFI_IP_ADDRESS
));
2175 CopyMem (&Private
->SubnetMask
,NewSubnetMask
, sizeof (EFI_IP_ADDRESS
));
2178 Private
->AddressIsOk
= TRUE
;
2180 if (!Mode
->UsingIpv6
) {
2182 // If in IPv4 mode, configure the corresponding ARP with this new
2183 // station IP address.
2185 ZeroMem (&ArpConfigData
, sizeof (EFI_ARP_CONFIG_DATA
));
2187 ArpConfigData
.SwAddressType
= 0x0800;
2188 ArpConfigData
.SwAddressLength
= sizeof (EFI_IPv4_ADDRESS
);
2189 ArpConfigData
.StationAddress
= &Private
->StationIp
.v4
;
2191 Private
->Arp
->Configure (Private
->Arp
, NULL
);
2192 Private
->Arp
->Configure (Private
->Arp
, &ArpConfigData
);
2195 // Update the route table.
2197 Mode
->RouteTableEntries
= 1;
2198 Mode
->RouteTable
[0].IpAddr
.Addr
[0] = Private
->StationIp
.Addr
[0] & Private
->SubnetMask
.Addr
[0];
2199 Mode
->RouteTable
[0].SubnetMask
.Addr
[0] = Private
->SubnetMask
.Addr
[0];
2200 Mode
->RouteTable
[0].GwAddr
.Addr
[0] = 0;
2207 Updates the contents of the cached DHCP and Discover packets.
2209 The pointers to the new packets are used to update the contents of the cached
2210 packets in the EFI_PXE_BASE_CODE_MODE structure.
2212 @param This Pointer to the EFI_PXE_BASE_CODE_PROTOCOL instance.
2213 @param NewDhcpDiscoverValid Pointer to a value that will replace the current
2214 DhcpDiscoverValid field.
2215 @param NewDhcpAckReceived Pointer to a value that will replace the current
2216 DhcpAckReceived field.
2217 @param NewProxyOfferReceived Pointer to a value that will replace the current
2218 ProxyOfferReceived field.
2219 @param NewPxeDiscoverValid Pointer to a value that will replace the current
2220 ProxyOfferReceived field.
2221 @param NewPxeReplyReceived Pointer to a value that will replace the current
2222 PxeReplyReceived field.
2223 @param NewPxeBisReplyReceived Pointer to a value that will replace the current
2224 PxeBisReplyReceived field.
2225 @param NewDhcpDiscover Pointer to the new cached DHCP Discover packet contents.
2226 @param NewDhcpAck Pointer to the new cached DHCP Ack packet contents.
2227 @param NewProxyOffer Pointer to the new cached Proxy Offer packet contents.
2228 @param NewPxeDiscover Pointer to the new cached PXE Discover packet contents.
2229 @param NewPxeReply Pointer to the new cached PXE Reply packet contents.
2230 @param NewPxeBisReply Pointer to the new cached PXE BIS Reply packet contents.
2232 @retval EFI_SUCCESS The cached packet contents were updated.
2233 @retval EFI_NOT_STARTED The PXE Base Code Protocol is in the stopped state.
2234 @retval EFI_INVALID_PARAMETER This is NULL or not point to a valid EFI_PXE_BASE_CODE_PROTOCOL structure.
2239 EfiPxeBcSetPackets (
2240 IN EFI_PXE_BASE_CODE_PROTOCOL
* This
,
2241 IN BOOLEAN
* NewDhcpDiscoverValid OPTIONAL
,
2242 IN BOOLEAN
* NewDhcpAckReceived OPTIONAL
,
2243 IN BOOLEAN
* NewProxyOfferReceived OPTIONAL
,
2244 IN BOOLEAN
* NewPxeDiscoverValid OPTIONAL
,
2245 IN BOOLEAN
* NewPxeReplyReceived OPTIONAL
,
2246 IN BOOLEAN
* NewPxeBisReplyReceived OPTIONAL
,
2247 IN EFI_PXE_BASE_CODE_PACKET
* NewDhcpDiscover OPTIONAL
,
2248 IN EFI_PXE_BASE_CODE_PACKET
* NewDhcpAck OPTIONAL
,
2249 IN EFI_PXE_BASE_CODE_PACKET
* NewProxyOffer OPTIONAL
,
2250 IN EFI_PXE_BASE_CODE_PACKET
* NewPxeDiscover OPTIONAL
,
2251 IN EFI_PXE_BASE_CODE_PACKET
* NewPxeReply OPTIONAL
,
2252 IN EFI_PXE_BASE_CODE_PACKET
* NewPxeBisReply OPTIONAL
2255 PXEBC_PRIVATE_DATA
*Private
;
2256 EFI_PXE_BASE_CODE_MODE
*Mode
;
2259 return EFI_INVALID_PARAMETER
;
2262 Private
= PXEBC_PRIVATE_DATA_FROM_PXEBC (This
);
2263 Mode
= Private
->PxeBc
.Mode
;
2265 if (!Mode
->Started
) {
2266 return EFI_NOT_STARTED
;
2269 if (NewDhcpDiscoverValid
!= NULL
) {
2270 Mode
->DhcpDiscoverValid
= *NewDhcpDiscoverValid
;
2273 if (NewDhcpAckReceived
!= NULL
) {
2274 Mode
->DhcpAckReceived
= *NewDhcpAckReceived
;
2277 if (NewProxyOfferReceived
!= NULL
) {
2278 Mode
->ProxyOfferReceived
= *NewProxyOfferReceived
;
2281 if (NewPxeDiscoverValid
!= NULL
) {
2282 Mode
->PxeDiscoverValid
= *NewPxeDiscoverValid
;
2285 if (NewPxeReplyReceived
!= NULL
) {
2286 Mode
->PxeReplyReceived
= *NewPxeReplyReceived
;
2289 if (NewPxeBisReplyReceived
!= NULL
) {
2290 Mode
->PxeBisReplyReceived
= *NewPxeBisReplyReceived
;
2293 if (NewDhcpDiscover
!= NULL
) {
2294 CopyMem (&Mode
->DhcpDiscover
, NewDhcpDiscover
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2297 if (NewDhcpAck
!= NULL
) {
2298 CopyMem (&Mode
->DhcpAck
, NewDhcpAck
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2301 if (NewProxyOffer
!= NULL
) {
2302 CopyMem (&Mode
->ProxyOffer
, NewProxyOffer
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2305 if (NewPxeDiscover
!= NULL
) {
2306 CopyMem (&Mode
->PxeDiscover
, NewPxeDiscover
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2309 if (NewPxeReply
!= NULL
) {
2310 CopyMem (&Mode
->PxeReply
, NewPxeReply
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2313 if (NewPxeBisReply
!= NULL
) {
2314 CopyMem (&Mode
->PxeBisReply
, NewPxeBisReply
, sizeof (EFI_PXE_BASE_CODE_PACKET
));
2320 EFI_PXE_BASE_CODE_PROTOCOL mPxeBcProtocolTemplate
= {
2321 EFI_PXE_BASE_CODE_PROTOCOL_REVISION
,
2329 EfiPxeBcSetIpFilter
,
2331 EfiPxeBcSetParameters
,
2332 EfiPxeBcSetStationIP
,
2338 Callback function that is invoked when the PXE Base Code Protocol is about to transmit, has
2339 received, or is waiting to receive a packet.
2341 This function is invoked when the PXE Base Code Protocol is about to transmit, has received,
2342 or is waiting to receive a packet. Parameters Function and Received specify the type of event.
2343 Parameters PacketLen and Packet specify the packet that generated the event. If these fields
2344 are zero and NULL respectively, then this is a status update callback. If the operation specified
2345 by Function is to continue, then CALLBACK_STATUS_CONTINUE should be returned. If the operation
2346 specified by Function should be aborted, then CALLBACK_STATUS_ABORT should be returned. Due to
2347 the polling nature of UEFI device drivers, a callback function should not execute for more than 5 ms.
2348 The SetParameters() function must be called after a Callback Protocol is installed to enable the
2351 @param This Pointer to the EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL instance.
2352 @param Function The PXE Base Code Protocol function that is waiting for an event.
2353 @param Received TRUE if the callback is being invoked due to a receive event. FALSE if
2354 the callback is being invoked due to a transmit event.
2355 @param PacketLength The length, in bytes, of Packet. This field will have a value of zero if
2356 this is a wait for receive event.
2357 @param PacketPtr If Received is TRUE, a pointer to the packet that was just received;
2358 otherwise a pointer to the packet that is about to be transmitted.
2360 @retval EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE if Function specifies a continue operation
2361 @retval EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT if Function specifies an abort operation
2364 EFI_PXE_BASE_CODE_CALLBACK_STATUS
2366 EfiPxeLoadFileCallback (
2367 IN EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL
* This
,
2368 IN EFI_PXE_BASE_CODE_FUNCTION Function
,
2369 IN BOOLEAN Received
,
2370 IN UINT32 PacketLength
,
2371 IN EFI_PXE_BASE_CODE_PACKET
* PacketPtr OPTIONAL
2378 // Catch Ctrl-C or ESC to abort.
2380 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
2382 if (!EFI_ERROR (Status
)) {
2384 if (Key
.ScanCode
== SCAN_ESC
|| Key
.UnicodeChar
== (0x1F & 'c')) {
2386 return EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT
;
2390 // No print if receive packet
2393 return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
;
2396 // Print only for three functions
2400 case EFI_PXE_BASE_CODE_FUNCTION_MTFTP
:
2402 // Print only for open MTFTP packets, not every MTFTP packets
2404 if (PacketLength
!= 0 && PacketPtr
!= NULL
) {
2405 if (PacketPtr
->Raw
[0x1C] != 0x00 || PacketPtr
->Raw
[0x1D] != 0x01) {
2406 return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
;
2411 case EFI_PXE_BASE_CODE_FUNCTION_DHCP
:
2412 case EFI_PXE_BASE_CODE_FUNCTION_DISCOVER
:
2416 return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
;
2419 if (PacketLength
!= 0 && PacketPtr
!= NULL
) {
2421 // Print '.' when transmit a packet
2427 return EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
;
2430 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL mPxeBcCallBackTemplate
= {
2431 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION
,
2432 EfiPxeLoadFileCallback
2439 @param Private Pointer to PxeBc private data.
2440 @param BufferSize Pointer to buffer size.
2441 @param Buffer Pointer to buffer.
2443 @retval EFI_SUCCESS Discover the boot file successfully.
2444 @retval EFI_TIMEOUT The TFTP/MTFTP operation timed out.
2445 @retval EFI_ABORTED PXE bootstrap server, so local boot need abort.
2446 @retval EFI_BUFFER_TOO_SMALL The buffer is too small to load the boot file.
2451 IN PXEBC_PRIVATE_DATA
*Private
,
2452 IN OUT UINT64
*BufferSize
,
2456 EFI_PXE_BASE_CODE_PROTOCOL
*PxeBc
;
2457 EFI_PXE_BASE_CODE_MODE
*Mode
;
2462 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
2465 PxeBc
= &Private
->PxeBc
;
2467 Type
= EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP
;
2468 Layer
= EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL
;
2473 Status
= PxeBc
->Dhcp (PxeBc
, TRUE
);
2474 if (EFI_ERROR (Status
)) {
2479 // Select a boot server
2481 Status
= PxeBcSelectBootPrompt (Private
);
2483 if (Status
== EFI_SUCCESS
) {
2484 Status
= PxeBcSelectBootMenu (Private
, &Type
, TRUE
);
2485 } else if (Status
== EFI_TIMEOUT
) {
2486 Status
= PxeBcSelectBootMenu (Private
, &Type
, FALSE
);
2489 if (!EFI_ERROR (Status
)) {
2491 if (Type
== EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP
) {
2493 // Local boot(PXE bootstrap server) need abort
2498 UseBis
= (BOOLEAN
) (Mode
->BisSupported
&& Mode
->BisDetected
);
2499 Status
= PxeBc
->Discover (PxeBc
, Type
, &Layer
, UseBis
, NULL
);
2500 if (EFI_ERROR (Status
)) {
2508 // Get bootfile name and (m)tftp server ip addresss
2510 if (Mode
->PxeReplyReceived
) {
2511 Packet
= &Private
->PxeReply
;
2512 } else if (Mode
->ProxyOfferReceived
) {
2513 Packet
= &Private
->ProxyOffer
;
2515 Packet
= &Private
->Dhcp4Ack
;
2519 // Use siaddr(next server) in DHCPOFFER packet header, if zero, use option 54(server identifier)
2520 // in DHCPOFFER packet.
2521 // (It does not comply with PXE Spec, Ver2.1)
2523 if (EFI_IP4_EQUAL (&Packet
->Packet
.Offer
.Dhcp4
.Header
.ServerAddr
, &mZeroIp4Addr
)) {
2526 Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_SERVER_ID
]->Data
,
2527 sizeof (EFI_IPv4_ADDRESS
)
2532 &Packet
->Packet
.Offer
.Dhcp4
.Header
.ServerAddr
,
2533 sizeof (EFI_IPv4_ADDRESS
)
2536 if (Private
->ServerIp
.Addr
[0] == 0) {
2537 return EFI_DEVICE_ERROR
;
2540 ASSERT (Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
);
2545 Private
->BootFileName
= (CHAR8
*) (Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
]->Data
);
2547 if (Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN
] != NULL
) {
2549 // Already have the bootfile length option, compute the file size
2551 CopyMem (&Value
, Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN
]->Data
, sizeof (Value
));
2552 Value
= NTOHS (Value
);
2553 *BufferSize
= 512 * Value
;
2554 Status
= EFI_BUFFER_TOO_SMALL
;
2557 // Get the bootfile size from tftp
2559 Status
= PxeBc
->Mtftp (
2561 EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE
,
2565 &Private
->BlockSize
,
2567 (UINT8
*) Private
->BootFileName
,
2573 Private
->FileSize
= (UINTN
) *BufferSize
;
2579 Causes the driver to load a specified file.
2581 @param This Protocol instance pointer.
2582 @param FilePath The device specific path of the file to load.
2583 @param BootPolicy If TRUE, indicates that the request originates from the
2584 boot manager is attempting to load FilePath as a boot
2585 selection. If FALSE, then FilePath must match as exact file
2587 @param BufferSize On input the size of Buffer in bytes. On output with a return
2588 code of EFI_SUCCESS, the amount of data transferred to
2589 Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
2590 the size of Buffer required to retrieve the requested file.
2591 @param Buffer The memory buffer to transfer the file to. IF Buffer is NULL,
2592 then no the size of the requested file is returned in
2595 @retval EFI_SUCCESS The file was loaded.
2596 @retval EFI_UNSUPPORTED The device does not support the provided BootPolicy
2597 @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or
2599 @retval EFI_NO_MEDIA No medium was present to load the file.
2600 @retval EFI_DEVICE_ERROR The file was not loaded due to a device error.
2601 @retval EFI_NO_RESPONSE The remote system did not respond.
2602 @retval EFI_NOT_FOUND The file was not found.
2603 @retval EFI_ABORTED The file load process was manually cancelled.
2609 IN EFI_LOAD_FILE_PROTOCOL
* This
,
2610 IN EFI_DEVICE_PATH_PROTOCOL
* FilePath
,
2611 IN BOOLEAN BootPolicy
,
2612 IN OUT UINTN
*BufferSize
,
2613 IN VOID
*Buffer OPTIONAL
2616 PXEBC_PRIVATE_DATA
*Private
;
2617 EFI_PXE_BASE_CODE_PROTOCOL
*PxeBc
;
2618 BOOLEAN NewMakeCallback
;
2621 BOOLEAN MediaPresent
;
2623 Private
= PXEBC_PRIVATE_DATA_FROM_LOADFILE (This
);
2624 PxeBc
= &Private
->PxeBc
;
2625 NewMakeCallback
= FALSE
;
2626 Status
= EFI_DEVICE_ERROR
;
2628 if (This
== NULL
|| BufferSize
== NULL
) {
2630 return EFI_INVALID_PARAMETER
;
2634 // Only support BootPolicy
2637 return EFI_UNSUPPORTED
;
2641 // Check media status before PXE start
2643 MediaPresent
= TRUE
;
2644 NetLibDetectMedia (Private
->Controller
, &MediaPresent
);
2645 if (!MediaPresent
) {
2646 return EFI_NO_MEDIA
;
2649 Status
= PxeBc
->Start (PxeBc
, FALSE
);
2650 if (EFI_ERROR (Status
) && (Status
!= EFI_ALREADY_STARTED
)) {
2654 Status
= gBS
->HandleProtocol (
2655 Private
->Controller
,
2656 &gEfiPxeBaseCodeCallbackProtocolGuid
,
2657 (VOID
**) &Private
->PxeBcCallback
2659 if (Status
== EFI_UNSUPPORTED
) {
2661 CopyMem (&Private
->LoadFileCallback
, &mPxeBcCallBackTemplate
, sizeof (Private
->LoadFileCallback
));
2663 Status
= gBS
->InstallProtocolInterface (
2664 &Private
->Controller
,
2665 &gEfiPxeBaseCodeCallbackProtocolGuid
,
2666 EFI_NATIVE_INTERFACE
,
2667 &Private
->LoadFileCallback
2670 NewMakeCallback
= (BOOLEAN
) (Status
== EFI_SUCCESS
);
2672 Status
= PxeBc
->SetParameters (PxeBc
, NULL
, NULL
, NULL
, NULL
, &NewMakeCallback
);
2673 if (EFI_ERROR (Status
)) {
2674 PxeBc
->Stop (PxeBc
);
2679 if (Private
->FileSize
== 0) {
2681 Status
= DiscoverBootFile (Private
, &TmpBufSize
, Buffer
);
2683 if (sizeof (UINTN
) < sizeof (UINT64
) && (TmpBufSize
> 0xFFFFFFFF)) {
2684 Status
= EFI_DEVICE_ERROR
;
2685 } else if (TmpBufSize
> 0 && *BufferSize
>= (UINTN
) TmpBufSize
&& Buffer
!= NULL
) {
2686 *BufferSize
= (UINTN
) TmpBufSize
;
2687 Status
= PxeBc
->Mtftp (
2689 EFI_PXE_BASE_CODE_TFTP_READ_FILE
,
2693 &Private
->BlockSize
,
2695 (UINT8
*) Private
->BootFileName
,
2699 } else if (TmpBufSize
> 0) {
2700 *BufferSize
= (UINTN
) TmpBufSize
;
2701 Status
= EFI_BUFFER_TOO_SMALL
;
2703 } else if (Buffer
== NULL
|| Private
->FileSize
> *BufferSize
) {
2704 *BufferSize
= Private
->FileSize
;
2705 Status
= EFI_BUFFER_TOO_SMALL
;
2708 // Download the file.
2710 TmpBufSize
= (UINT64
) (*BufferSize
);
2711 Status
= PxeBc
->Mtftp (
2713 EFI_PXE_BASE_CODE_TFTP_READ_FILE
,
2717 &Private
->BlockSize
,
2719 (UINT8
*) Private
->BootFileName
,
2725 // If we added a callback protocol, now is the time to remove it.
2727 if (NewMakeCallback
) {
2729 NewMakeCallback
= FALSE
;
2731 PxeBc
->SetParameters (PxeBc
, NULL
, NULL
, NULL
, NULL
, &NewMakeCallback
);
2733 gBS
->UninstallProtocolInterface (
2734 Private
->Controller
,
2735 &gEfiPxeBaseCodeCallbackProtocolGuid
,
2736 &Private
->LoadFileCallback
2741 // Check download status
2743 if (Status
== EFI_SUCCESS
) {
2745 // The functionality of PXE Base Code protocol will not be stopped,
2746 // when downloading is successfully.
2750 } else if (Status
== EFI_BUFFER_TOO_SMALL
) {
2751 if (Buffer
!= NULL
) {
2752 AsciiPrint ("PXE-E05: Download buffer is smaller than requested file.\n");
2755 // The functionality of PXE Base Code protocol will not be stopped.
2760 } else if (Status
== EFI_DEVICE_ERROR
) {
2761 AsciiPrint ("PXE-E07: Network device error.\n");
2763 } else if (Status
== EFI_OUT_OF_RESOURCES
) {
2764 AsciiPrint ("PXE-E09: Could not allocate I/O buffers.\n");
2766 } else if (Status
== EFI_NO_MEDIA
) {
2767 AsciiPrint ("PXE-E12: Could not detect network connection.\n");
2769 } else if (Status
== EFI_NO_RESPONSE
) {
2770 AsciiPrint ("PXE-E16: No offer received.\n");
2772 } else if (Status
== EFI_TIMEOUT
) {
2773 AsciiPrint ("PXE-E18: Server response timeout.\n");
2775 } else if (Status
== EFI_ABORTED
) {
2776 AsciiPrint ("PXE-E21: Remote boot cancelled.\n");
2778 } else if (Status
== EFI_ICMP_ERROR
) {
2779 AsciiPrint ("PXE-E22: Client received ICMP error from server.\n");
2781 } else if (Status
== EFI_TFTP_ERROR
) {
2782 AsciiPrint ("PXE-E23: Client received TFTP error from server.\n");
2785 AsciiPrint ("PXE-E99: Unexpected network error.\n");
2788 PxeBc
->Stop (PxeBc
);
2793 EFI_LOAD_FILE_PROTOCOL mLoadFileProtocolTemplate
= { EfiPxeLoadFile
};