2 Support for PxeBc dhcp functions.
4 Copyright (c) 2007 - 2010, Intel Corporation.<BR>
5 All rights reserved. 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"
19 // This is a map from the interested DHCP4 option tags' index to the tag value.
21 UINT8 mInterestedDhcp4Tags
[PXEBC_DHCP4_TAG_INDEX_MAX
] = {
22 PXEBC_DHCP4_TAG_BOOTFILE_LEN
,
23 PXEBC_DHCP4_TAG_VENDOR
,
24 PXEBC_DHCP4_TAG_OVERLOAD
,
25 PXEBC_DHCP4_TAG_MSG_TYPE
,
26 PXEBC_DHCP4_TAG_SERVER_ID
,
27 PXEBC_DHCP4_TAG_CLASS_ID
,
28 PXEBC_DHCP4_TAG_BOOTFILE
33 This function initialize the DHCP4 message instance.
35 This function will pad each item of dhcp4 message packet.
37 @param Seed Pointer to the message instance of the DHCP4 packet.
38 @param Udp4 Pointer to the EFI_UDP4_PROTOCOL instance.
43 IN EFI_DHCP4_PACKET
*Seed
,
44 IN EFI_UDP4_PROTOCOL
*Udp4
47 EFI_SIMPLE_NETWORK_MODE Mode
;
48 EFI_DHCP4_HEADER
*Header
;
50 Udp4
->GetModeData (Udp4
, NULL
, NULL
, NULL
, &Mode
);
52 Seed
->Size
= sizeof (EFI_DHCP4_PACKET
);
53 Seed
->Length
= sizeof (Seed
->Dhcp4
);
55 Header
= &Seed
->Dhcp4
.Header
;
57 ZeroMem (Header
, sizeof (EFI_DHCP4_HEADER
));
58 Header
->OpCode
= PXEBC_DHCP4_OPCODE_REQUEST
;
59 Header
->HwType
= Mode
.IfType
;
60 Header
->HwAddrLen
= (UINT8
) Mode
.HwAddressSize
;
61 CopyMem (Header
->ClientHwAddr
, &Mode
.CurrentAddress
, Header
->HwAddrLen
);
63 Seed
->Dhcp4
.Magik
= PXEBC_DHCP4_MAGIC
;
64 Seed
->Dhcp4
.Option
[0] = PXEBC_DHCP4_TAG_EOP
;
69 Copy the DCHP4 packet from srouce to destination.
71 @param Dst Pointer to the EFI_DHCP4_PROTOCOL instance.
72 @param Src Pointer to the EFI_DHCP4_PROTOCOL instance.
76 PxeBcCopyEfiDhcp4Packet (
77 IN EFI_DHCP4_PACKET
*Dst
,
78 IN EFI_DHCP4_PACKET
*Src
81 ASSERT (Dst
->Size
>= Src
->Length
);
83 CopyMem (&Dst
->Dhcp4
, &Src
->Dhcp4
, Src
->Length
);
84 Dst
->Length
= Src
->Length
;
89 Copy the dhcp4 packet to the PxeBc private data and parse the dhcp4 packet.
91 @param Private Pointer to PxeBc private data.
92 @param OfferIndex Index of cached packets as complements of pxe mode data,
93 the index is maximum offer number.
98 IN PXEBC_PRIVATE_DATA
*Private
,
102 EFI_PXE_BASE_CODE_MODE
*Mode
;
103 EFI_DHCP4_PACKET
*Offer
;
105 ASSERT (OfferIndex
< Private
->NumOffers
);
106 ASSERT (OfferIndex
< PXEBC_MAX_OFFER_NUM
);
108 Mode
= Private
->PxeBc
.Mode
;
109 Offer
= &Private
->Dhcp4Offers
[OfferIndex
].Packet
.Offer
;
111 PxeBcCopyEfiDhcp4Packet (&Private
->ProxyOffer
.Packet
.Offer
, Offer
);
112 CopyMem (&Mode
->ProxyOffer
, &Offer
->Dhcp4
, Offer
->Length
);
113 Mode
->ProxyOfferReceived
= TRUE
;
115 PxeBcParseCachedDhcpPacket (&Private
->ProxyOffer
);
120 Parse the cached dhcp packet.
122 @param CachedPacket Pointer to cached dhcp packet.
124 @retval TRUE Succeed to parse and validation.
125 @retval FALSE Fail to parse or validation.
129 PxeBcParseCachedDhcpPacket (
130 IN PXEBC_CACHED_DHCP4_PACKET
*CachedPacket
133 EFI_DHCP4_PACKET
*Offer
;
134 EFI_DHCP4_PACKET_OPTION
**Options
;
135 EFI_DHCP4_PACKET_OPTION
*Option
;
139 CachedPacket
->IsPxeOffer
= FALSE
;
140 ZeroMem (CachedPacket
->Dhcp4Option
, sizeof (CachedPacket
->Dhcp4Option
));
141 ZeroMem (&CachedPacket
->PxeVendorOption
, sizeof (CachedPacket
->PxeVendorOption
));
143 Offer
= &CachedPacket
->Packet
.Offer
;
144 Options
= CachedPacket
->Dhcp4Option
;
147 // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
149 for (Index
= 0; Index
< PXEBC_DHCP4_TAG_INDEX_MAX
; Index
++) {
150 Options
[Index
] = PxeBcParseExtendOptions (
152 GET_OPTION_BUFFER_LEN (Offer
),
153 mInterestedDhcp4Tags
[Index
]
158 // Check whether is an offer with PXEClient or not.
160 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_CLASS_ID
];
161 if ((Option
!= NULL
) && (Option
->Length
>= 9) &&
162 (CompareMem (Option
->Data
, DEFAULT_CLASS_ID_DATA
, 9) == 0)) {
164 CachedPacket
->IsPxeOffer
= TRUE
;
168 // Parse pxe vendor options and store their content/pointers in CachedPacket->PxeVendorOption.
170 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_VENDOR
];
171 if (CachedPacket
->IsPxeOffer
&& (Option
!= NULL
)) {
173 if (!PxeBcParseVendorOptions (Option
, &CachedPacket
->PxeVendorOption
)) {
179 // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).
180 // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/
181 // serverhostname option.
183 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_OVERLOAD
];
184 if ((Option
!= NULL
) && ((Option
->Data
[0] & PXEBC_DHCP4_OVERLOAD_FILE
) != 0)) {
186 Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] = PxeBcParseExtendOptions (
187 (UINT8
*) Offer
->Dhcp4
.Header
.BootFileName
,
188 sizeof (Offer
->Dhcp4
.Header
.BootFileName
),
189 PXEBC_DHCP4_TAG_BOOTFILE
192 } else if ((Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
) &&
193 (Offer
->Dhcp4
.Header
.BootFileName
[0] != 0)) {
195 // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
196 // And do not count dhcp option header, or else will destory the serverhostname.
198 Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] = (EFI_DHCP4_PACKET_OPTION
*) (&Offer
->Dhcp4
.Header
.BootFileName
[0] -
199 OFFSET_OF (EFI_DHCP4_PACKET_OPTION
, Data
[0]));
204 // Determine offer type of the dhcp packet.
206 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE
];
207 if ((Option
== NULL
) || (Option
->Data
[0] == 0)) {
209 // It's a bootp offer
211 Option
= CachedPacket
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
];
212 if (Option
== NULL
) {
214 // bootp offer without bootfilename, discard it.
219 OfferType
= DHCP4_PACKET_TYPE_BOOTP
;
223 if (IS_VALID_DISCOVER_VENDOR_OPTION (CachedPacket
->PxeVendorOption
.BitMap
)) {
225 // It's a pxe10 offer with PXEClient and discover vendor option.
227 OfferType
= DHCP4_PACKET_TYPE_PXE10
;
228 } else if (IS_VALID_MTFTP_VENDOR_OPTION (CachedPacket
->PxeVendorOption
.BitMap
)) {
230 // It's a wfm11a offer with PXEClient and mtftp vendor option, and
231 // return false since mtftp not supported currently.
236 // If the binl offer with only PXEClient.
238 OfferType
= (UINT8
) ((CachedPacket
->IsPxeOffer
) ? DHCP4_PACKET_TYPE_BINL
: DHCP4_PACKET_TYPE_DHCP_ONLY
);
242 CachedPacket
->OfferType
= OfferType
;
249 Offer dhcp service with a BINL dhcp offer.
251 @param Private Pointer to PxeBc private data.
252 @param Index Index of cached packets as complements of pxe mode data,
253 the index is maximum offer number.
255 @retval TRUE Offer the service successfully under priority BINL.
256 @retval FALSE Boot Service failed, parse cached dhcp packet failed or this
257 BINL ack cannot find options set or bootfile name specified.
262 IN PXEBC_PRIVATE_DATA
*Private
,
266 EFI_DHCP4_PACKET
*Offer
;
267 EFI_IP_ADDRESS ServerIp
;
269 PXEBC_CACHED_DHCP4_PACKET
*CachedPacket
;
270 EFI_DHCP4_PACKET
*Reply
;
272 ASSERT (Index
< PXEBC_MAX_OFFER_NUM
);
273 ASSERT (Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_BINL
);
275 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
278 // Use siaddr(next server) in DHCPOFFER packet header, if zero, use option 54(server identifier)
279 // in DHCPOFFER packet.
280 // (It does not comply with PXE Spec, Ver2.1)
282 if (EFI_IP4_EQUAL (&Offer
->Dhcp4
.Header
.ServerAddr
.Addr
, &mZeroIp4Addr
)) {
285 Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_SERVER_ID
]->Data
,
286 sizeof (EFI_IPv4_ADDRESS
)
291 &Offer
->Dhcp4
.Header
.ServerAddr
,
292 sizeof (EFI_IPv4_ADDRESS
)
295 if (ServerIp
.Addr
[0] == 0) {
299 CachedPacket
= &Private
->ProxyOffer
;
300 Reply
= &CachedPacket
->Packet
.Offer
;
302 Status
= PxeBcDiscvBootService (
313 if (EFI_ERROR (Status
)) {
317 if (!PxeBcParseCachedDhcpPacket (CachedPacket
)) {
321 if ((CachedPacket
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) &&
322 (CachedPacket
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
)) {
324 // This BINL ack doesn't have discovery options set or bootfile name
330 Private
->PxeBc
.Mode
->ProxyOfferReceived
= TRUE
;
331 CopyMem (&Private
->PxeBc
.Mode
->ProxyOffer
, &Reply
->Dhcp4
, Reply
->Length
);
338 Offer dhcp service for each proxy with a BINL dhcp offer.
340 @param Private Pointer to PxeBc private data
341 @param OfferIndex Pointer to the index of cached packets as complements of
342 pxe mode data, the index is maximum offer number.
344 @return If there is no service needed offer return FALSE, otherwise TRUE.
349 IN PXEBC_PRIVATE_DATA
*Private
,
350 OUT UINT32
*OfferIndex
355 for (Index
= 0; Index
< Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]; Index
++) {
357 *OfferIndex
= Private
->BinlIndex
[Index
];
359 // Try this BINL proxy offer
361 if (PxeBcTryBinl (Private
, *OfferIndex
)) {
371 This function is to check the selected proxy offer (include BINL dhcp offer and
372 DHCP_ONLY offer ) and set the flag and copy the DHCP packets to the Pxe base code
375 @param Private Pointer to PxeBc private data.
377 @retval EFI_SUCCESS Operational successful.
378 @retval EFI_NO_RESPONSE Offer dhcp service failed.
382 PxeBcCheckSelectedOffer (
383 IN PXEBC_PRIVATE_DATA
*Private
386 PXEBC_CACHED_DHCP4_PACKET
*SelectedOffer
;
387 EFI_DHCP4_PACKET_OPTION
**Options
;
389 EFI_DHCP4_PACKET
*Offer
;
390 UINT32 ProxyOfferIndex
;
392 EFI_PXE_BASE_CODE_MODE
*Mode
;
393 EFI_DHCP4_PACKET
*Ack
;
395 ASSERT (Private
->SelectedOffer
!= 0);
397 Status
= EFI_SUCCESS
;
398 SelectedOffer
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1];
399 Options
= SelectedOffer
->Dhcp4Option
;
401 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BINL
) {
403 // The addresses are acquired from a BINL dhcp offer, try BINL to get
406 if (!PxeBcTryBinl (Private
, Private
->SelectedOffer
- 1)) {
407 Status
= EFI_NO_RESPONSE
;
409 } else if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) {
411 // The selected offer to finish the D.O.R.A. is a DHCP only offer, we need
412 // try proxy offers if there are some, othewise the bootfile name must be
413 // set in this DHCP only offer.
415 if (Private
->GotProxyOffer
) {
417 // Get rid of the compiler warning.
420 if (Private
->SortOffers
) {
422 // The offers are sorted before selecting, the proxy offer type must be
423 // already determined.
425 ASSERT (Private
->ProxyIndex
[Private
->ProxyOfferType
] > 0);
427 if (Private
->ProxyOfferType
== DHCP4_PACKET_TYPE_BINL
) {
429 // We buffer all received BINL proxy offers, try them all one by one
431 if (!PxeBcTryBinlProxy (Private
, &ProxyOfferIndex
)) {
432 Status
= EFI_NO_RESPONSE
;
436 // For other types, only one proxy offer is buffered.
438 ProxyOfferIndex
= Private
->ProxyIndex
[Private
->ProxyOfferType
] - 1;
442 // The proxy offer type is not determined, choose proxy offer in the
445 Status
= EFI_NO_RESPONSE
;
447 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
449 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
450 if (!IS_PROXY_DHCP_OFFER (Offer
)) {
452 // Skip non proxy dhcp offers.
457 if (Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_BINL
) {
461 if (!PxeBcTryBinl (Private
, Index
)) {
463 // Failed, skip to the next offer
469 Private
->ProxyOfferType
= Private
->Dhcp4Offers
[Index
].OfferType
;
470 ProxyOfferIndex
= Index
;
471 Status
= EFI_SUCCESS
;
476 if (!EFI_ERROR (Status
) && (Private
->ProxyOfferType
!= DHCP4_PACKET_TYPE_BINL
)) {
478 // Copy the proxy offer to Mode and set the flag
480 PxeBcCopyProxyOffer (Private
, ProxyOfferIndex
);
484 // No proxy offer is received, the bootfile name MUST be set.
486 ASSERT (Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
);
490 if (!EFI_ERROR (Status
)) {
492 // Everything is OK, set the flag and copy the DHCP packets.
494 Mode
= Private
->PxeBc
.Mode
;
495 Offer
= &SelectedOffer
->Packet
.Offer
;
498 // The discover packet is already copied, just set flag here.
500 Mode
->DhcpDiscoverValid
= TRUE
;
502 Ack
= &Private
->Dhcp4Ack
.Packet
.Ack
;
503 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
505 // Other type of ACK is already cached. Bootp is special that we should
506 // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
508 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Offer
);
511 PxeBcParseCachedDhcpPacket (&Private
->Dhcp4Ack
);
513 Mode
->DhcpAckReceived
= TRUE
;
516 // Copy the dhcp ack.
518 CopyMem (&Mode
->DhcpAck
, &Ack
->Dhcp4
, Ack
->Length
);
526 Cache the Dhcp4 packet offer, Parse and validate each option of the packet.
528 @param Private Pointer to PxeBc private data.
529 @param RcvdOffer Pointer to the received Dhcp proxy offer packet.
533 PxeBcCacheDhcpOffer (
534 IN PXEBC_PRIVATE_DATA
*Private
,
535 IN EFI_DHCP4_PACKET
*RcvdOffer
538 PXEBC_CACHED_DHCP4_PACKET
*CachedOffer
;
539 EFI_DHCP4_PACKET
*Offer
;
542 CachedOffer
= &Private
->Dhcp4Offers
[Private
->NumOffers
];
543 Offer
= &CachedOffer
->Packet
.Offer
;
546 // Cache the orignal dhcp packet
548 PxeBcCopyEfiDhcp4Packet (Offer
, RcvdOffer
);
551 // Parse and validate the options (including dhcp option and vendor option)
553 if (!PxeBcParseCachedDhcpPacket (CachedOffer
)) {
557 OfferType
= CachedOffer
->OfferType
;
558 ASSERT (OfferType
< DHCP4_PACKET_TYPE_MAX
);
560 if (OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
562 if (Private
->BootpIndex
!= 0) {
564 // Only cache the first bootp offer, discard others.
569 // Take as a dhcp only offer, but record index specifically.
571 Private
->BootpIndex
= Private
->NumOffers
+ 1;
575 if (IS_PROXY_DHCP_OFFER (Offer
)) {
577 // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
579 Private
->GotProxyOffer
= TRUE
;
581 if (OfferType
== DHCP4_PACKET_TYPE_BINL
) {
583 // Cache all binl offers.
585 Private
->BinlIndex
[Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]] = Private
->NumOffers
;
586 Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]++;
587 } else if (Private
->ProxyIndex
[OfferType
] != 0) {
589 // Only cache the first pxe10/wfm11a offers each, discard the others.
594 // Record index of the proxy dhcp offer with type other than binl.
596 Private
->ProxyIndex
[OfferType
] = Private
->NumOffers
+ 1;
600 // It's a dhcp offer with your address.
602 ASSERT (Private
->ServerCount
[OfferType
] < PXEBC_MAX_OFFER_NUM
);
603 Private
->OfferIndex
[OfferType
][Private
->ServerCount
[OfferType
]] = Private
->NumOffers
;
604 Private
->ServerCount
[OfferType
]++;
609 // Count the accepted offers.
611 Private
->NumOffers
++;
616 Select the specified proxy offer, such as BINL, DHCP_ONLY and so on.
617 If the proxy does not exist, try offers with bootfile.
619 @param Private Pointer to PxeBc private data.
624 IN PXEBC_PRIVATE_DATA
*Private
629 EFI_DHCP4_PACKET
*Offer
;
631 Private
->SelectedOffer
= 0;
633 if (Private
->SortOffers
) {
635 // Select offer according to the priority
637 if (Private
->ServerCount
[DHCP4_PACKET_TYPE_PXE10
] > 0) {
641 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_PXE10
][0] + 1;
643 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_WFM11A
] > 0) {
647 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_WFM11A
][0] + 1;
649 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_PXE10
] > 0) &&
650 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
653 // DHCP only and proxy DHCP with PXE10
655 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
656 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_PXE10
;
658 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_WFM11A
] > 0) &&
659 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
662 // DHCP only and proxy DHCP with WfM
664 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
665 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_WFM11A
;
667 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_BINL
] > 0) {
671 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_BINL
][0] + 1;
673 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
] > 0) &&
674 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
677 // DHCP only and proxy DHCP with BINL
679 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
680 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_BINL
;
684 // Try offers with bootfile
686 for (Index
= 0; Index
< Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
]; Index
++) {
688 // Select the first DHCP only offer with bootfile
690 OfferIndex
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][Index
];
691 if (Private
->Dhcp4Offers
[OfferIndex
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
) {
692 Private
->SelectedOffer
= OfferIndex
+ 1;
697 if (Private
->SelectedOffer
== 0) {
699 // Select the Bootp reply with bootfile if any
701 Private
->SelectedOffer
= Private
->BootpIndex
;
706 // Try the offers in the received order.
708 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
710 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
712 if (IS_PROXY_DHCP_OFFER (Offer
)) {
719 if ((Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) &&
720 ((!Private
->GotProxyOffer
) && (Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
))) {
722 // DHCP only offer but no proxy offer received and no bootfile option in this offer
727 Private
->SelectedOffer
= Index
+ 1;
737 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
738 to intercept events that occurred in the configuration process. This structure
739 provides advanced control of each state transition of the DHCP process. The
740 returned status code determines the behavior of the EFI DHCPv4 Protocol driver.
741 There are three possible returned values, which are described in the following
744 @param This Pointer to the EFI DHCPv4 Protocol instance that is used to
745 configure this callback function.
746 @param Context Pointer to the context that is initialized by
747 EFI_DHCP4_PROTOCOL.Configure().
748 @param CurrentState The current operational state of the EFI DHCPv4 Protocol
750 @param Dhcp4Event The event that occurs in the current state, which usually means a
752 @param Packet The DHCP packet that is going to be sent or already received.
753 @param NewPacket The packet that is used to replace the above Packet.
755 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
756 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
757 driver will continue to wait for more DHCPOFFER packets until the retry
759 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process and
760 return to the Dhcp4Init or Dhcp4InitReboot state.
766 IN EFI_DHCP4_PROTOCOL
* This
,
768 IN EFI_DHCP4_STATE CurrentState
,
769 IN EFI_DHCP4_EVENT Dhcp4Event
,
770 IN EFI_DHCP4_PACKET
* Packet OPTIONAL
,
771 OUT EFI_DHCP4_PACKET
**NewPacket OPTIONAL
774 PXEBC_PRIVATE_DATA
*Private
;
775 EFI_PXE_BASE_CODE_MODE
*Mode
;
776 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL
*Callback
;
777 EFI_DHCP4_PACKET_OPTION
*MaxMsgSize
;
781 CHAR8
*SystemSerialNumber
;
782 EFI_DHCP4_HEADER
*DhcpHeader
;
784 if ((Dhcp4Event
!= Dhcp4RcvdOffer
) &&
785 (Dhcp4Event
!= Dhcp4SelectOffer
) &&
786 (Dhcp4Event
!= Dhcp4SendDiscover
) &&
787 (Dhcp4Event
!= Dhcp4RcvdAck
) &&
788 (Dhcp4Event
!= Dhcp4SendRequest
)) {
792 Private
= (PXEBC_PRIVATE_DATA
*) Context
;
793 Mode
= Private
->PxeBc
.Mode
;
794 Callback
= Private
->PxeBcCallback
;
797 // Override the Maximum DHCP Message Size.
799 MaxMsgSize
= PxeBcParseExtendOptions (
800 Packet
->Dhcp4
.Option
,
801 GET_OPTION_BUFFER_LEN (Packet
),
802 PXEBC_DHCP4_TAG_MAXMSG
804 if (MaxMsgSize
!= NULL
) {
805 Value
= HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
806 CopyMem (MaxMsgSize
->Data
, &Value
, sizeof (Value
));
809 if ((Dhcp4Event
!= Dhcp4SelectOffer
) && (Callback
!= NULL
)) {
810 Received
= (BOOLEAN
) ((Dhcp4Event
== Dhcp4RcvdOffer
) || (Dhcp4Event
== Dhcp4RcvdAck
));
811 Status
= Callback
->Callback (
816 (EFI_PXE_BASE_CODE_PACKET
*) &Packet
->Dhcp4
818 if (Status
!= EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
) {
823 Status
= EFI_SUCCESS
;
825 switch (Dhcp4Event
) {
827 case Dhcp4SendDiscover
:
828 case Dhcp4SendRequest
:
829 if (Mode
->SendGUID
) {
831 // send the system GUID instead of the MAC address as the hardware address
832 // in the DHCP packet header.
834 DhcpHeader
= &Packet
->Dhcp4
.Header
;
836 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID
*) DhcpHeader
->ClientHwAddr
, &SystemSerialNumber
))) {
838 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
839 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
840 // GUID not yet set - send all 0's to show not programable
842 ZeroMem (DhcpHeader
->ClientHwAddr
, sizeof (EFI_GUID
));
845 DhcpHeader
->HwAddrLen
= sizeof (EFI_GUID
);
848 if (Dhcp4Event
== Dhcp4SendDiscover
) {
850 // Cache the dhcp discover packet, of which some information will be used later.
852 CopyMem (Mode
->DhcpDiscover
.Raw
, &Packet
->Dhcp4
, Packet
->Length
);
858 Status
= EFI_NOT_READY
;
859 if (Private
->NumOffers
< PXEBC_MAX_OFFER_NUM
) {
861 // Cache the dhcp offers in Private->Dhcp4Offers[]
863 PxeBcCacheDhcpOffer (Private
, Packet
);
868 case Dhcp4SelectOffer
:
870 // Select an offer, if succeeded, Private->SelectedOffer points to
871 // the index of the selected one.
873 PxeBcSelectOffer (Private
);
875 if (Private
->SelectedOffer
== 0) {
876 Status
= EFI_ABORTED
;
878 *NewPacket
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1].Packet
.Offer
;
887 ASSERT (Private
->SelectedOffer
!= 0);
889 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Packet
);
901 Initialize the DHCP options and build the option list.
903 @param Private Pointer to PxeBc private data.
904 @param OptList Pointer to a DHCP option list.
906 @param IsDhcpDiscover Discover dhcp option or not.
908 @return The index item number of the option list.
912 PxeBcBuildDhcpOptions (
913 IN PXEBC_PRIVATE_DATA
*Private
,
914 IN EFI_DHCP4_PACKET_OPTION
**OptList
,
915 IN BOOLEAN IsDhcpDiscover
919 PXEBC_DHCP4_OPTION_ENTRY OptEnt
;
921 CHAR8
*SystemSerialNumber
;
924 OptList
[0] = (EFI_DHCP4_PACKET_OPTION
*) Private
->OptionBuffer
;
926 if (!IsDhcpDiscover
) {
928 // Append message type.
930 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MSG_TYPE
;
931 OptList
[Index
]->Length
= 1;
932 OptEnt
.Mesg
= (PXEBC_DHCP4_OPTION_MESG
*) OptList
[Index
]->Data
;
933 OptEnt
.Mesg
->Type
= PXEBC_DHCP4_MSG_TYPE_REQUEST
;
935 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
938 // Append max message size.
940 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MAXMSG
;
941 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
);
942 OptEnt
.MaxMesgSize
= (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
*) OptList
[Index
]->Data
;
943 Value
= NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
944 CopyMem (&OptEnt
.MaxMesgSize
->Size
, &Value
, sizeof (UINT16
));
946 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
949 // Parameter request list option.
951 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_PARA_LIST
;
952 OptList
[Index
]->Length
= 35;
953 OptEnt
.Para
= (PXEBC_DHCP4_OPTION_PARA
*) OptList
[Index
]->Data
;
954 OptEnt
.Para
->ParaList
[0] = PXEBC_DHCP4_TAG_NETMASK
;
955 OptEnt
.Para
->ParaList
[1] = PXEBC_DHCP4_TAG_TIME_OFFSET
;
956 OptEnt
.Para
->ParaList
[2] = PXEBC_DHCP4_TAG_ROUTER
;
957 OptEnt
.Para
->ParaList
[3] = PXEBC_DHCP4_TAG_TIME_SERVER
;
958 OptEnt
.Para
->ParaList
[4] = PXEBC_DHCP4_TAG_NAME_SERVER
;
959 OptEnt
.Para
->ParaList
[5] = PXEBC_DHCP4_TAG_DNS_SERVER
;
960 OptEnt
.Para
->ParaList
[6] = PXEBC_DHCP4_TAG_HOSTNAME
;
961 OptEnt
.Para
->ParaList
[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN
;
962 OptEnt
.Para
->ParaList
[8] = PXEBC_DHCP4_TAG_DOMAINNAME
;
963 OptEnt
.Para
->ParaList
[9] = PXEBC_DHCP4_TAG_ROOTPATH
;
964 OptEnt
.Para
->ParaList
[10] = PXEBC_DHCP4_TAG_EXTEND_PATH
;
965 OptEnt
.Para
->ParaList
[11] = PXEBC_DHCP4_TAG_EMTU
;
966 OptEnt
.Para
->ParaList
[12] = PXEBC_DHCP4_TAG_TTL
;
967 OptEnt
.Para
->ParaList
[13] = PXEBC_DHCP4_TAG_BROADCAST
;
968 OptEnt
.Para
->ParaList
[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN
;
969 OptEnt
.Para
->ParaList
[15] = PXEBC_DHCP4_TAG_NIS_SERVER
;
970 OptEnt
.Para
->ParaList
[16] = PXEBC_DHCP4_TAG_NTP_SERVER
;
971 OptEnt
.Para
->ParaList
[17] = PXEBC_DHCP4_TAG_VENDOR
;
972 OptEnt
.Para
->ParaList
[18] = PXEBC_DHCP4_TAG_REQUEST_IP
;
973 OptEnt
.Para
->ParaList
[19] = PXEBC_DHCP4_TAG_LEASE
;
974 OptEnt
.Para
->ParaList
[20] = PXEBC_DHCP4_TAG_SERVER_ID
;
975 OptEnt
.Para
->ParaList
[21] = PXEBC_DHCP4_TAG_T1
;
976 OptEnt
.Para
->ParaList
[22] = PXEBC_DHCP4_TAG_T2
;
977 OptEnt
.Para
->ParaList
[23] = PXEBC_DHCP4_TAG_CLASS_ID
;
978 OptEnt
.Para
->ParaList
[24] = PXEBC_DHCP4_TAG_TFTP
;
979 OptEnt
.Para
->ParaList
[25] = PXEBC_DHCP4_TAG_BOOTFILE
;
980 OptEnt
.Para
->ParaList
[26] = PXEBC_PXE_DHCP4_TAG_UUID
;
981 OptEnt
.Para
->ParaList
[27] = 0x80;
982 OptEnt
.Para
->ParaList
[28] = 0x81;
983 OptEnt
.Para
->ParaList
[29] = 0x82;
984 OptEnt
.Para
->ParaList
[30] = 0x83;
985 OptEnt
.Para
->ParaList
[31] = 0x84;
986 OptEnt
.Para
->ParaList
[32] = 0x85;
987 OptEnt
.Para
->ParaList
[33] = 0x86;
988 OptEnt
.Para
->ParaList
[34] = 0x87;
990 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
993 // Append UUID/Guid-based client identifier option
995 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UUID
;
996 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_UUID
);
997 OptEnt
.Uuid
= (PXEBC_DHCP4_OPTION_UUID
*) OptList
[Index
]->Data
;
998 OptEnt
.Uuid
->Type
= 0;
1000 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1002 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID
*) OptEnt
.Uuid
->Guid
, &SystemSerialNumber
))) {
1004 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
1005 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
1006 // GUID not yet set - send all 0's to show not programable
1008 ZeroMem (OptEnt
.Uuid
->Guid
, sizeof (EFI_GUID
));
1012 // Append client network device interface option
1014 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UNDI
;
1015 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_UNDI
);
1016 OptEnt
.Undi
= (PXEBC_DHCP4_OPTION_UNDI
*) OptList
[Index
]->Data
;
1017 if (Private
->Nii
!= NULL
) {
1018 OptEnt
.Undi
->Type
= Private
->Nii
->Type
;
1019 OptEnt
.Undi
->MajorVer
= Private
->Nii
->MajorVer
;
1020 OptEnt
.Undi
->MinorVer
= Private
->Nii
->MinorVer
;
1022 OptEnt
.Undi
->Type
= DEFAULT_UNDI_TYPE
;
1023 OptEnt
.Undi
->MajorVer
= DEFAULT_UNDI_MAJOR
;
1024 OptEnt
.Undi
->MinorVer
= DEFAULT_UNDI_MINOR
;
1028 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1031 // Append client system architecture option
1033 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_ARCH
;
1034 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_ARCH
);
1035 OptEnt
.Arch
= (PXEBC_DHCP4_OPTION_ARCH
*) OptList
[Index
]->Data
;
1036 Value
= HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE
);
1037 CopyMem (&OptEnt
.Arch
->Type
, &Value
, sizeof (UINT16
));
1039 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1042 // Append client system architecture option
1044 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_CLASS_ID
;
1045 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_CLID
);
1046 OptEnt
.Clid
= (PXEBC_DHCP4_OPTION_CLID
*) OptList
[Index
]->Data
;
1047 CopyMem (OptEnt
.Clid
, DEFAULT_CLASS_ID_DATA
, sizeof (PXEBC_DHCP4_OPTION_CLID
));
1048 CvtNum (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE
, OptEnt
.Clid
->ArchitectureType
, sizeof (OptEnt
.Clid
->ArchitectureType
));
1050 if (Private
->Nii
!= NULL
) {
1052 // If NII protocol exists, update DHCP option data
1054 CopyMem (OptEnt
.Clid
->InterfaceName
, Private
->Nii
->StringId
, sizeof (OptEnt
.Clid
->InterfaceName
));
1055 CvtNum (Private
->Nii
->MajorVer
, OptEnt
.Clid
->UndiMajor
, sizeof (OptEnt
.Clid
->UndiMajor
));
1056 CvtNum (Private
->Nii
->MinorVer
, OptEnt
.Clid
->UndiMinor
, sizeof (OptEnt
.Clid
->UndiMinor
));
1066 Discover the boot of service and initialize the vendor option if exists.
1068 @param Private Pointer to PxeBc private data.
1069 @param Type PxeBc option boot item type
1070 @param Layer PxeBc option boot item layer
1071 @param UseBis Use BIS or not
1072 @param DestIp Ip address for server
1073 @param IpCount The total count of the server ip address
1074 @param SrvList Server list
1075 @param IsDiscv Discover the vendor or not
1076 @param Reply The dhcp4 packet of Pxe reply
1078 @retval EFI_SUCCESS Operation succeeds.
1079 @retval EFI_OUT_OF_RESOURCES Allocate memory pool failed.
1080 @retval EFI_NOT_FOUND There is no vendor option exists.
1081 @retval EFI_TIMEOUT Send Pxe Discover time out.
1085 PxeBcDiscvBootService (
1086 IN PXEBC_PRIVATE_DATA
* Private
,
1090 IN EFI_IP_ADDRESS
* DestIp
,
1092 IN EFI_PXE_BASE_CODE_SRVLIST
* SrvList
,
1094 OUT EFI_DHCP4_PACKET
* Reply OPTIONAL
1097 EFI_PXE_BASE_CODE_UDP_PORT Sport
;
1098 EFI_PXE_BASE_CODE_MODE
*Mode
;
1099 EFI_DHCP4_PROTOCOL
*Dhcp4
;
1100 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token
;
1106 EFI_DHCP4_LISTEN_POINT ListenPoint
;
1107 EFI_DHCP4_PACKET
*Response
;
1108 EFI_DHCP4_PACKET_OPTION
*OptList
[PXEBC_DHCP4_MAX_OPTION_NUM
];
1110 EFI_DHCP4_PACKET_OPTION
*PxeOpt
;
1111 PXEBC_OPTION_BOOT_ITEM
*PxeBootItem
;
1113 CHAR8
*SystemSerialNumber
;
1114 EFI_DHCP4_HEADER
*DhcpHeader
;
1117 Mode
= Private
->PxeBc
.Mode
;
1118 Dhcp4
= Private
->Dhcp4
;
1119 Status
= EFI_SUCCESS
;
1121 ZeroMem (&Token
, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN
));
1123 if (DestIp
== NULL
) {
1124 Sport
= PXEBC_DHCP4_S_PORT
;
1127 Sport
= PXEBC_BS_DISCOVER_PORT
;
1131 if (!UseBis
&& Layer
!= NULL
) {
1132 *Layer
&= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK
;
1135 OptCount
= PxeBcBuildDhcpOptions (Private
, OptList
, FALSE
);
1138 ASSERT (Layer
!= NULL
);
1140 // Add vendor option of PXE_BOOT_ITEM
1142 VendorOptLen
= (sizeof (EFI_DHCP4_PACKET_OPTION
) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM
) + 1;
1143 OptList
[OptCount
] = AllocatePool (VendorOptLen
);
1144 if (OptList
[OptCount
] == NULL
) {
1145 return EFI_OUT_OF_RESOURCES
;
1148 OptList
[OptCount
]->OpCode
= PXEBC_DHCP4_TAG_VENDOR
;
1149 OptList
[OptCount
]->Length
= (UINT8
) (VendorOptLen
- 2);
1150 PxeOpt
= (EFI_DHCP4_PACKET_OPTION
*) OptList
[OptCount
]->Data
;
1151 PxeOpt
->OpCode
= PXEBC_VENDOR_TAG_BOOT_ITEM
;
1152 PxeOpt
->Length
= sizeof (PXEBC_OPTION_BOOT_ITEM
);
1153 PxeBootItem
= (PXEBC_OPTION_BOOT_ITEM
*) PxeOpt
->Data
;
1154 PxeBootItem
->Type
= HTONS (Type
);
1155 PxeBootItem
->Layer
= HTONS (*Layer
);
1156 PxeOpt
->Data
[PxeOpt
->Length
] = PXEBC_DHCP4_TAG_EOP
;
1161 Status
= Dhcp4
->Build (Dhcp4
, &Private
->SeedPacket
, 0, NULL
, OptCount
, OptList
, &Token
.Packet
);
1164 FreePool (OptList
[OptCount
- 1]);
1167 if (EFI_ERROR (Status
)) {
1171 DhcpHeader
= &Token
.Packet
->Dhcp4
.Header
;
1172 if (Mode
->SendGUID
) {
1173 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID
*) DhcpHeader
->ClientHwAddr
, &SystemSerialNumber
))) {
1175 // GUID not yet set - send all 0's to show not programable
1177 ZeroMem (DhcpHeader
->ClientHwAddr
, sizeof (EFI_GUID
));
1180 DhcpHeader
->HwAddrLen
= sizeof (EFI_GUID
);
1183 Xid
= NET_RANDOM (NetRandomInitSeed ());
1184 Token
.Packet
->Dhcp4
.Header
.Xid
= HTONL(Xid
);
1185 Token
.Packet
->Dhcp4
.Header
.Reserved
= HTONS((UINT16
) ((IsBCast
) ? 0x8000 : 0));
1186 CopyMem (&Token
.Packet
->Dhcp4
.Header
.ClientAddr
, &Private
->StationIp
, sizeof (EFI_IPv4_ADDRESS
));
1188 Token
.RemotePort
= Sport
;
1191 SetMem (&Token
.RemoteAddress
, sizeof (EFI_IPv4_ADDRESS
), 0xff);
1193 CopyMem (&Token
.RemoteAddress
, DestIp
, sizeof (EFI_IPv4_ADDRESS
));
1196 CopyMem (&Token
.GatewayAddress
, &Private
->GatewayIp
, sizeof (EFI_IPv4_ADDRESS
));
1199 Token
.ListenPointCount
= 1;
1200 Token
.ListenPoints
= &ListenPoint
;
1201 Token
.ListenPoints
[0].ListenPort
= PXEBC_BS_DISCOVER_PORT
;
1202 CopyMem (&Token
.ListenPoints
[0].ListenAddress
, &Private
->StationIp
, sizeof(EFI_IPv4_ADDRESS
));
1203 CopyMem (&Token
.ListenPoints
[0].SubnetMask
, &Private
->SubnetMask
, sizeof(EFI_IPv4_ADDRESS
));
1206 // Send Pxe Discover
1208 for (TryIndex
= 1; TryIndex
<= PXEBC_BOOT_REQUEST_RETRIES
; TryIndex
++) {
1210 Token
.TimeoutValue
= (UINT16
) (PXEBC_BOOT_REQUEST_TIMEOUT
* TryIndex
);
1211 Token
.Packet
->Dhcp4
.Header
.Seconds
= (UINT16
) (PXEBC_BOOT_REQUEST_TIMEOUT
* (TryIndex
- 1));
1213 Status
= Dhcp4
->TransmitReceive (Dhcp4
, &Token
);
1215 if (Token
.Status
!= EFI_TIMEOUT
) {
1220 if (!EFI_ERROR (Status
)) {
1226 Response
= Token
.ResponseList
;
1228 while (RepIndex
< Token
.ResponseCount
) {
1230 while (SrvIndex
< IpCount
) {
1232 if (SrvList
[SrvIndex
].AcceptAnyResponse
) {
1236 if ((SrvList
[SrvIndex
].Type
== Type
) && EFI_IP4_EQUAL (&(Response
->Dhcp4
.Header
.ServerAddr
), &(Private
->ServerIp
))) {
1243 if ((IpCount
!= SrvIndex
) || (IpCount
== 0)) {
1250 Response
= (EFI_DHCP4_PACKET
*) ((UINT8
*) Response
+ Response
->Size
);
1253 if (RepIndex
< Token
.ResponseCount
) {
1255 if (Reply
!= NULL
) {
1256 PxeBcCopyEfiDhcp4Packet (Reply
, Response
);
1260 CopyMem (&(Mode
->PxeDiscover
), &(Token
.Packet
->Dhcp4
), Token
.Packet
->Length
);
1261 Mode
->PxeDiscoverValid
= TRUE
;
1263 CopyMem (Mode
->PxeReply
.Raw
, &Response
->Dhcp4
, Response
->Length
);
1264 Mode
->PxeReplyReceived
= TRUE
;
1267 Status
= EFI_NOT_FOUND
;
1271 // free the responselist
1273 if (Token
.ResponseList
!= NULL
) {
1274 FreePool (Token
.ResponseList
);
1278 // Free the dhcp packet
1280 FreePool (Token
.Packet
);
1287 Parse interested dhcp options.
1289 @param Buffer Pointer to the dhcp options packet.
1290 @param Length The length of the dhcp options.
1291 @param OptTag The option OpCode.
1293 @return NULL if the buffer length is 0 and OpCode is not
1294 PXEBC_DHCP4_TAG_EOP, or the pointer to the buffer.
1297 EFI_DHCP4_PACKET_OPTION
*
1298 PxeBcParseExtendOptions (
1304 EFI_DHCP4_PACKET_OPTION
*Option
;
1307 Option
= (EFI_DHCP4_PACKET_OPTION
*) Buffer
;
1310 while (Offset
< Length
&& Option
->OpCode
!= PXEBC_DHCP4_TAG_EOP
) {
1312 if (Option
->OpCode
== OptTag
) {
1317 if (Option
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1320 Offset
+= Option
->Length
+ 2;
1323 Option
= (EFI_DHCP4_PACKET_OPTION
*) (Buffer
+ Offset
);
1331 This function is to parse and check vendor options.
1333 @param Dhcp4Option Pointer to dhcp options
1334 @param VendorOption Pointer to vendor options
1336 @return TRUE if valid for vendor options, or FALSE.
1340 PxeBcParseVendorOptions (
1341 IN EFI_DHCP4_PACKET_OPTION
*Dhcp4Option
,
1342 IN PXEBC_VENDOR_OPTION
*VendorOption
1346 UINT8 VendorOptionLen
;
1347 EFI_DHCP4_PACKET_OPTION
*PxeOption
;
1350 BitMap
= VendorOption
->BitMap
;
1351 VendorOptionLen
= Dhcp4Option
->Length
;
1352 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) &Dhcp4Option
->Data
[0];
1355 while ((Offset
< VendorOptionLen
) && (PxeOption
->OpCode
!= PXEBC_DHCP4_TAG_EOP
)) {
1357 // Parse every Vendor Option and set its BitMap
1359 switch (PxeOption
->OpCode
) {
1361 case PXEBC_VENDOR_TAG_MTFTP_IP
:
1363 CopyMem (&VendorOption
->MtftpIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1366 case PXEBC_VENDOR_TAG_MTFTP_CPORT
:
1368 CopyMem (&VendorOption
->MtftpCPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpCPort
));
1371 case PXEBC_VENDOR_TAG_MTFTP_SPORT
:
1373 CopyMem (&VendorOption
->MtftpSPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpSPort
));
1376 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT
:
1378 VendorOption
->MtftpTimeout
= *PxeOption
->Data
;
1381 case PXEBC_VENDOR_TAG_MTFTP_DELAY
:
1383 VendorOption
->MtftpDelay
= *PxeOption
->Data
;
1386 case PXEBC_VENDOR_TAG_DISCOVER_CTRL
:
1388 VendorOption
->DiscoverCtrl
= *PxeOption
->Data
;
1391 case PXEBC_VENDOR_TAG_DISCOVER_MCAST
:
1393 CopyMem (&VendorOption
->DiscoverMcastIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1396 case PXEBC_VENDOR_TAG_BOOT_SERVERS
:
1398 VendorOption
->BootSvrLen
= PxeOption
->Length
;
1399 VendorOption
->BootSvr
= (PXEBC_BOOT_SVR_ENTRY
*) PxeOption
->Data
;
1402 case PXEBC_VENDOR_TAG_BOOT_MENU
:
1404 VendorOption
->BootMenuLen
= PxeOption
->Length
;
1405 VendorOption
->BootMenu
= (PXEBC_BOOT_MENU_ENTRY
*) PxeOption
->Data
;
1408 case PXEBC_VENDOR_TAG_MENU_PROMPT
:
1410 VendorOption
->MenuPromptLen
= PxeOption
->Length
;
1411 VendorOption
->MenuPrompt
= (PXEBC_MENU_PROMPT
*) PxeOption
->Data
;
1414 case PXEBC_VENDOR_TAG_MCAST_ALLOC
:
1416 CopyMem (&VendorOption
->McastIpBase
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1417 CopyMem (&VendorOption
->McastIpBlock
, PxeOption
->Data
+ 4, sizeof (VendorOption
->McastIpBlock
));
1418 CopyMem (&VendorOption
->McastIpRange
, PxeOption
->Data
+ 6, sizeof (VendorOption
->McastIpRange
));
1421 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES
:
1423 VendorOption
->CredTypeLen
= PxeOption
->Length
;
1424 VendorOption
->CredType
= (UINT32
*) PxeOption
->Data
;
1427 case PXEBC_VENDOR_TAG_BOOT_ITEM
:
1429 CopyMem (&VendorOption
->BootSrvType
, PxeOption
->Data
, sizeof (VendorOption
->BootSrvType
));
1430 CopyMem (&VendorOption
->BootSrvLayer
, PxeOption
->Data
+ 2, sizeof (VendorOption
->BootSrvLayer
));
1434 SET_VENDOR_OPTION_BIT_MAP (BitMap
, PxeOption
->OpCode
);
1436 if (PxeOption
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1439 Offset
= (UINT8
) (Offset
+ PxeOption
->Length
+ 2);
1442 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) (Dhcp4Option
->Data
+ Offset
);
1446 // FixMe, return falas if invalid of any vendor option
1454 This function display boot item detail.
1456 If the length of the boot item string over 70 Char, just display 70 Char.
1458 @param Str Pointer to a string (boot item string).
1459 @param Len The length of string.
1463 PxeBcDisplayBootItem (
1470 Len
= (UINT8
) MIN (70, Len
);
1473 AsciiPrint ("%a \n", Str
);
1479 Choose the boot prompt.
1481 @param Private Pointer to PxeBc private data.
1483 @retval EFI_SUCCESS Select boot prompt done.
1484 @retval EFI_TIMEOUT Select boot prompt time out.
1485 @retval EFI_NOT_FOUND The proxy offer is not Pxe10.
1486 @retval EFI_ABORTED User cancel the operation.
1487 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1491 PxeBcSelectBootPrompt (
1492 IN PXEBC_PRIVATE_DATA
*Private
1495 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1496 PXEBC_VENDOR_OPTION
*VendorOpt
;
1497 EFI_EVENT TimeoutEvent
;
1498 EFI_EVENT DescendEvent
;
1499 EFI_INPUT_KEY InputKey
;
1507 TimeoutEvent
= NULL
;
1508 DescendEvent
= NULL
;
1510 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1512 Packet
= &Private
->ProxyOffer
;
1515 Packet
= &Private
->Dhcp4Ack
;
1518 if (Packet
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) {
1519 return EFI_NOT_FOUND
;
1522 VendorOpt
= &Packet
->PxeVendorOption
;
1524 if (!IS_VALID_BOOT_PROMPT (VendorOpt
->BitMap
)) {
1528 Timeout
= VendorOpt
->MenuPrompt
->Timeout
;
1529 Prompt
= VendorOpt
->MenuPrompt
->Prompt
;
1530 PromptLen
= (UINT8
) (VendorOpt
->MenuPromptLen
- 1);
1536 if (Timeout
== 255) {
1540 Status
= gBS
->CreateEvent (
1548 if (EFI_ERROR (Status
)) {
1552 Status
= gBS
->SetTimer (
1555 Timeout
* TICKS_PER_SECOND
1558 if (EFI_ERROR (Status
)) {
1562 Status
= gBS
->CreateEvent (
1570 if (EFI_ERROR (Status
)) {
1574 Status
= gBS
->SetTimer (
1580 if (EFI_ERROR (Status
)) {
1584 SecCol
= gST
->ConOut
->Mode
->CursorColumn
;
1585 SecRow
= gST
->ConOut
->Mode
->CursorRow
;
1587 PxeBcDisplayBootItem (Prompt
, PromptLen
);
1589 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1590 AsciiPrint ("(%d) ", Timeout
--);
1592 while (EFI_ERROR (gBS
->CheckEvent (TimeoutEvent
))) {
1594 if (!EFI_ERROR (gBS
->CheckEvent (DescendEvent
))) {
1595 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1596 AsciiPrint ("(%d) ", Timeout
--);
1599 if (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1601 gBS
->Stall (10 * TICKS_PER_MS
);
1605 if (InputKey
.ScanCode
== 0) {
1607 switch (InputKey
.UnicodeChar
) {
1609 Status
= EFI_ABORTED
;
1615 Status
= EFI_TIMEOUT
;
1623 switch (InputKey
.ScanCode
) {
1625 Status
= EFI_TIMEOUT
;
1629 Status
= EFI_ABORTED
;
1640 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0 , SecRow
+ 1);
1644 if (DescendEvent
!= NULL
) {
1645 gBS
->CloseEvent (DescendEvent
);
1648 if (TimeoutEvent
!= NULL
) {
1649 gBS
->CloseEvent (TimeoutEvent
);
1657 Select the boot menu.
1659 @param Private Pointer to PxeBc private data.
1660 @param Type The type of the menu.
1661 @param UseDefaultItem Use default item or not.
1663 @retval EFI_ABORTED User cancel operation.
1664 @retval EFI_SUCCESS Select the boot menu success.
1665 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1669 PxeBcSelectBootMenu (
1670 IN PXEBC_PRIVATE_DATA
*Private
,
1672 IN BOOLEAN UseDefaultItem
1675 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1676 PXEBC_VENDOR_OPTION
*VendorOpt
;
1677 EFI_INPUT_KEY InputKey
;
1686 PXEBC_BOOT_MENU_ENTRY
*MenuItem
;
1687 PXEBC_BOOT_MENU_ENTRY
*MenuArray
[PXEBC_MAX_MENU_NUM
];
1694 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1696 Packet
= &Private
->ProxyOffer
;
1699 Packet
= &Private
->Dhcp4Ack
;
1702 ASSERT (Packet
->OfferType
== DHCP4_PACKET_TYPE_PXE10
);
1704 VendorOpt
= &Packet
->PxeVendorOption
;
1706 if (!IS_VALID_BOOT_MENU (VendorOpt
->BitMap
)) {
1710 SetMem (Blank
, sizeof(Blank
), ' ');
1712 MenuSize
= VendorOpt
->BootMenuLen
;
1713 MenuItem
= VendorOpt
->BootMenu
;
1715 if (MenuSize
== 0) {
1716 return EFI_NOT_READY
;
1719 while (MenuSize
> 0) {
1720 MenuArray
[Index
++] = MenuItem
;
1721 MenuSize
= (UINT8
) (MenuSize
- (MenuItem
->DescLen
+ 3));
1722 MenuItem
= (PXEBC_BOOT_MENU_ENTRY
*) ((UINT8
*) MenuItem
+ MenuItem
->DescLen
+ 3);
1723 if (Index
>= PXEBC_MAX_MENU_NUM
) {
1728 if (UseDefaultItem
) {
1729 *Type
= MenuArray
[0]->Type
;
1730 *Type
= NTOHS (*Type
);
1736 for (Index
= 0; Index
< MenuNum
; Index
++) {
1737 PxeBcDisplayBootItem (MenuArray
[Index
]->DescStr
, MenuArray
[Index
]->DescLen
);
1740 TopRow
= gST
->ConOut
->Mode
->CursorRow
- MenuNum
;
1743 ASSERT (Select
< PXEBC_MAX_MENU_NUM
);
1745 // highlight selected row
1747 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_BLACK
, EFI_LIGHTGRAY
));
1748 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ Select
);
1749 Blank
[MenuArray
[Select
]->DescLen
] = 0;
1750 AsciiPrint ("%a\r", Blank
);
1751 PxeBcDisplayBootItem (MenuArray
[Select
]->DescStr
, MenuArray
[Select
]->DescLen
);
1752 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1753 LastSelect
= Select
;
1755 while (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1756 gBS
->Stall (10 * TICKS_PER_MS
);
1759 if (InputKey
.ScanCode
!= 0) {
1760 switch (InputKey
.UnicodeChar
) {
1762 InputKey
.ScanCode
= SCAN_ESC
;
1765 case CTRL ('j'): /* linefeed */
1766 case CTRL ('m'): /* return */
1770 case CTRL ('i'): /* tab */
1774 InputKey
.ScanCode
= SCAN_DOWN
;
1777 case CTRL ('h'): /* backspace */
1780 InputKey
.ScanCode
= SCAN_UP
;
1784 InputKey
.ScanCode
= 0;
1788 switch (InputKey
.ScanCode
) {
1799 if (++Select
== MenuNum
) {
1810 case SCAN_PAGE_DOWN
:
1812 Select
= (UINT16
) (MenuNum
- 1);
1819 /* unhighlight last selected row */
1820 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_LIGHTGRAY
, EFI_BLACK
));
1821 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ LastSelect
);
1822 Blank
[MenuArray
[LastSelect
]->DescLen
] = 0;
1823 AsciiPrint ("%a\r", Blank
);
1824 PxeBcDisplayBootItem (MenuArray
[LastSelect
]->DescStr
, MenuArray
[LastSelect
]->DescLen
);
1825 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1829 // Swap the byte order
1831 CopyMem (Type
, &MenuArray
[Select
]->Type
, sizeof (UINT16
));
1832 *Type
= NTOHS (*Type
);