2 Support for PxeBc dhcp functions.
4 Copyright (c) 2007 - 2009, 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
)) {
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 option 54, if zero, use siaddr in header
280 ZeroMem (&ServerIp
, sizeof(EFI_IP_ADDRESS
));
281 if (Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_SERVER_ID
] != NULL
) {
284 Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_SERVER_ID
]->Data
,
285 sizeof (EFI_IPv4_ADDRESS
)
290 &Offer
->Dhcp4
.Header
.ServerAddr
,
291 sizeof (EFI_IPv4_ADDRESS
)
294 if (ServerIp
.Addr
[0] == 0) {
298 CachedPacket
= &Private
->ProxyOffer
;
299 Reply
= &CachedPacket
->Packet
.Offer
;
301 Status
= PxeBcDiscvBootService (
312 if (EFI_ERROR (Status
)) {
316 if (!PxeBcParseCachedDhcpPacket (CachedPacket
)) {
320 if ((CachedPacket
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) &&
321 (CachedPacket
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
)) {
323 // This BINL ack doesn't have discovery options set or bootfile name
329 Private
->PxeBc
.Mode
->ProxyOfferReceived
= TRUE
;
330 CopyMem (&Private
->PxeBc
.Mode
->ProxyOffer
, &Reply
->Dhcp4
, Reply
->Length
);
337 Offer dhcp service for each proxy with a BINL dhcp offer.
339 @param Private Pointer to PxeBc private data
340 @param OfferIndex Pointer to the index of cached packets as complements of
341 pxe mode data, the index is maximum offer number.
343 @return If there is no service needed offer return FALSE, otherwise TRUE.
348 IN PXEBC_PRIVATE_DATA
*Private
,
349 OUT UINT32
*OfferIndex
354 for (Index
= 0; Index
< Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]; Index
++) {
356 *OfferIndex
= Private
->BinlIndex
[Index
];
358 // Try this BINL proxy offer
360 if (PxeBcTryBinl (Private
, *OfferIndex
)) {
370 This function is to check the selected proxy offer (include BINL dhcp offer and
371 DHCP_ONLY offer ) and set the flag and copy the DHCP packets to the Pxe base code
374 @param Private Pointer to PxeBc private data.
376 @retval EFI_SUCCESS Operational successful.
377 @retval EFI_NO_RESPONSE Offer dhcp service failed.
381 PxeBcCheckSelectedOffer (
382 IN PXEBC_PRIVATE_DATA
*Private
385 PXEBC_CACHED_DHCP4_PACKET
*SelectedOffer
;
386 EFI_DHCP4_PACKET_OPTION
**Options
;
388 EFI_DHCP4_PACKET
*Offer
;
389 UINT32 ProxyOfferIndex
;
391 EFI_PXE_BASE_CODE_MODE
*Mode
;
392 EFI_DHCP4_PACKET
*Ack
;
394 ASSERT (Private
->SelectedOffer
!= 0);
396 Status
= EFI_SUCCESS
;
397 SelectedOffer
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1];
398 Options
= SelectedOffer
->Dhcp4Option
;
400 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BINL
) {
402 // The addresses are acquired from a BINL dhcp offer, try BINL to get
405 if (!PxeBcTryBinl (Private
, Private
->SelectedOffer
- 1)) {
406 Status
= EFI_NO_RESPONSE
;
408 } else if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) {
410 // The selected offer to finish the D.O.R.A. is a DHCP only offer, we need
411 // try proxy offers if there are some, othewise the bootfile name must be
412 // set in this DHCP only offer.
414 if (Private
->GotProxyOffer
) {
416 // Get rid of the compiler warning.
419 if (Private
->SortOffers
) {
421 // The offers are sorted before selecting, the proxy offer type must be
422 // already determined.
424 ASSERT (Private
->ProxyIndex
[Private
->ProxyOfferType
] > 0);
426 if (Private
->ProxyOfferType
== DHCP4_PACKET_TYPE_BINL
) {
428 // We buffer all received BINL proxy offers, try them all one by one
430 if (!PxeBcTryBinlProxy (Private
, &ProxyOfferIndex
)) {
431 Status
= EFI_NO_RESPONSE
;
435 // For other types, only one proxy offer is buffered.
437 ProxyOfferIndex
= Private
->ProxyIndex
[Private
->ProxyOfferType
] - 1;
441 // The proxy offer type is not determined, choose proxy offer in the
444 Status
= EFI_NO_RESPONSE
;
446 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
448 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
449 if (!IS_PROXY_DHCP_OFFER (Offer
)) {
451 // Skip non proxy dhcp offers.
456 if (Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_BINL
) {
460 if (!PxeBcTryBinl (Private
, Index
)) {
462 // Failed, skip to the next offer
468 Private
->ProxyOfferType
= Private
->Dhcp4Offers
[Index
].OfferType
;
469 ProxyOfferIndex
= Index
;
470 Status
= EFI_SUCCESS
;
475 if (!EFI_ERROR (Status
) && (Private
->ProxyOfferType
!= DHCP4_PACKET_TYPE_BINL
)) {
477 // Copy the proxy offer to Mode and set the flag
479 PxeBcCopyProxyOffer (Private
, ProxyOfferIndex
);
483 // No proxy offer is received, the bootfile name MUST be set.
485 ASSERT (Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
);
489 if (!EFI_ERROR (Status
)) {
491 // Everything is OK, set the flag and copy the DHCP packets.
493 Mode
= Private
->PxeBc
.Mode
;
494 Offer
= &SelectedOffer
->Packet
.Offer
;
497 // The discover packet is already copied, just set flag here.
499 Mode
->DhcpDiscoverValid
= TRUE
;
501 Ack
= &Private
->Dhcp4Ack
.Packet
.Ack
;
502 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
504 // Other type of ACK is already cached. Bootp is special that we should
505 // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
507 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Offer
);
510 PxeBcParseCachedDhcpPacket (&Private
->Dhcp4Ack
);
512 Mode
->DhcpAckReceived
= TRUE
;
515 // Copy the dhcp ack.
517 CopyMem (&Mode
->DhcpAck
, &Ack
->Dhcp4
, Ack
->Length
);
525 Cache the Dhcp4 packet offer, Parse and validate each option of the packet.
527 @param Private Pointer to PxeBc private data.
528 @param RcvdOffer Pointer to the received Dhcp proxy offer packet.
532 PxeBcCacheDhcpOffer (
533 IN PXEBC_PRIVATE_DATA
*Private
,
534 IN EFI_DHCP4_PACKET
*RcvdOffer
537 PXEBC_CACHED_DHCP4_PACKET
*CachedOffer
;
538 EFI_DHCP4_PACKET
*Offer
;
541 CachedOffer
= &Private
->Dhcp4Offers
[Private
->NumOffers
];
542 Offer
= &CachedOffer
->Packet
.Offer
;
545 // Cache the orignal dhcp packet
547 PxeBcCopyEfiDhcp4Packet (Offer
, RcvdOffer
);
550 // Parse and validate the options (including dhcp option and vendor option)
552 if (!PxeBcParseCachedDhcpPacket (CachedOffer
)) {
556 OfferType
= CachedOffer
->OfferType
;
557 ASSERT (OfferType
< DHCP4_PACKET_TYPE_MAX
);
559 if (OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
561 if (Private
->BootpIndex
!= 0) {
563 // Only cache the first bootp offer, discard others.
568 // Take as a dhcp only offer, but record index specifically.
570 Private
->BootpIndex
= Private
->NumOffers
+ 1;
574 if (IS_PROXY_DHCP_OFFER (Offer
)) {
576 // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
578 Private
->GotProxyOffer
= TRUE
;
580 if (OfferType
== DHCP4_PACKET_TYPE_BINL
) {
582 // Cache all binl offers.
584 Private
->BinlIndex
[Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]] = Private
->NumOffers
;
585 Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]++;
586 } else if (Private
->ProxyIndex
[OfferType
] != 0) {
588 // Only cache the first pxe10/wfm11a offers each, discard the others.
593 // Record index of the proxy dhcp offer with type other than binl.
595 Private
->ProxyIndex
[OfferType
] = Private
->NumOffers
+ 1;
599 // It's a dhcp offer with your address.
601 ASSERT (Private
->ServerCount
[OfferType
] < PXEBC_MAX_OFFER_NUM
);
602 Private
->OfferIndex
[OfferType
][Private
->ServerCount
[OfferType
]] = Private
->NumOffers
;
603 Private
->ServerCount
[OfferType
]++;
608 // Count the accepted offers.
610 Private
->NumOffers
++;
615 Select the specified proxy offer, such as BINL, DHCP_ONLY and so on.
616 If the proxy does not exist, try offers with bootfile.
618 @param Private Pointer to PxeBc private data.
623 IN PXEBC_PRIVATE_DATA
*Private
628 EFI_DHCP4_PACKET
*Offer
;
630 Private
->SelectedOffer
= 0;
632 if (Private
->SortOffers
) {
634 // Select offer according to the priority
636 if (Private
->ServerCount
[DHCP4_PACKET_TYPE_PXE10
] > 0) {
640 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_PXE10
][0] + 1;
642 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_WFM11A
] > 0) {
646 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_WFM11A
][0] + 1;
648 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_PXE10
] > 0) &&
649 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
652 // DHCP only and proxy DHCP with PXE10
654 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
655 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_PXE10
;
657 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_WFM11A
] > 0) &&
658 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
661 // DHCP only and proxy DHCP with WfM
663 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
664 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_WFM11A
;
666 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_BINL
] > 0) {
670 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_BINL
][0] + 1;
672 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
] > 0) &&
673 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
676 // DHCP only and proxy DHCP with BINL
678 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
679 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_BINL
;
683 // Try offers with bootfile
685 for (Index
= 0; Index
< Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
]; Index
++) {
687 // Select the first DHCP only offer with bootfile
689 OfferIndex
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][Index
];
690 if (Private
->Dhcp4Offers
[OfferIndex
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
) {
691 Private
->SelectedOffer
= OfferIndex
+ 1;
696 if (Private
->SelectedOffer
== 0) {
698 // Select the Bootp reply with bootfile if any
700 Private
->SelectedOffer
= Private
->BootpIndex
;
705 // Try the offers in the received order.
707 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
709 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
711 if (IS_PROXY_DHCP_OFFER (Offer
)) {
718 if ((Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) &&
719 ((!Private
->GotProxyOffer
) && (Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
))) {
721 // DHCP only offer but no proxy offer received and no bootfile option in this offer
726 Private
->SelectedOffer
= Index
+ 1;
736 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
737 to intercept events that occurred in the configuration process. This structure
738 provides advanced control of each state transition of the DHCP process. The
739 returned status code determines the behavior of the EFI DHCPv4 Protocol driver.
740 There are three possible returned values, which are described in the following
743 @param This Pointer to the EFI DHCPv4 Protocol instance that is used to
744 configure this callback function.
745 @param Context Pointer to the context that is initialized by
746 EFI_DHCP4_PROTOCOL.Configure().
747 @param CurrentState The current operational state of the EFI DHCPv4 Protocol
749 @param Dhcp4Event The event that occurs in the current state, which usually means a
751 @param Packet The DHCP packet that is going to be sent or already received.
752 @param NewPacket The packet that is used to replace the above Packet.
754 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
755 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
756 driver will continue to wait for more DHCPOFFER packets until the retry
758 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process and
759 return to the Dhcp4Init or Dhcp4InitReboot state.
765 IN EFI_DHCP4_PROTOCOL
* This
,
767 IN EFI_DHCP4_STATE CurrentState
,
768 IN EFI_DHCP4_EVENT Dhcp4Event
,
769 IN EFI_DHCP4_PACKET
* Packet OPTIONAL
,
770 OUT EFI_DHCP4_PACKET
**NewPacket OPTIONAL
773 PXEBC_PRIVATE_DATA
*Private
;
774 EFI_PXE_BASE_CODE_MODE
*Mode
;
775 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL
*Callback
;
776 EFI_DHCP4_PACKET_OPTION
*MaxMsgSize
;
780 CHAR8
*SystemSerialNumber
;
781 EFI_DHCP4_HEADER
*DhcpHeader
;
783 if ((Dhcp4Event
!= Dhcp4RcvdOffer
) &&
784 (Dhcp4Event
!= Dhcp4SelectOffer
) &&
785 (Dhcp4Event
!= Dhcp4SendDiscover
) &&
786 (Dhcp4Event
!= Dhcp4RcvdAck
) &&
787 (Dhcp4Event
!= Dhcp4SendRequest
)) {
791 Private
= (PXEBC_PRIVATE_DATA
*) Context
;
792 Mode
= Private
->PxeBc
.Mode
;
793 Callback
= Private
->PxeBcCallback
;
796 // Override the Maximum DHCP Message Size.
798 MaxMsgSize
= PxeBcParseExtendOptions (
799 Packet
->Dhcp4
.Option
,
800 GET_OPTION_BUFFER_LEN (Packet
),
801 PXEBC_DHCP4_TAG_MAXMSG
803 if (MaxMsgSize
!= NULL
) {
804 Value
= HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
805 CopyMem (MaxMsgSize
->Data
, &Value
, sizeof (Value
));
808 if ((Dhcp4Event
!= Dhcp4SelectOffer
) && (Callback
!= NULL
)) {
809 Received
= (BOOLEAN
) ((Dhcp4Event
== Dhcp4RcvdOffer
) || (Dhcp4Event
== Dhcp4RcvdAck
));
810 Status
= Callback
->Callback (
815 (EFI_PXE_BASE_CODE_PACKET
*) &Packet
->Dhcp4
817 if (Status
!= EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
) {
822 Status
= EFI_SUCCESS
;
824 switch (Dhcp4Event
) {
826 case Dhcp4SendDiscover
:
827 case Dhcp4SendRequest
:
828 if (Mode
->SendGUID
) {
830 // send the system GUID instead of the MAC address as the hardware address
831 // in the DHCP packet header.
833 DhcpHeader
= &Packet
->Dhcp4
.Header
;
835 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID
*) DhcpHeader
->ClientHwAddr
, &SystemSerialNumber
))) {
837 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
838 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
839 // GUID not yet set - send all 0's to show not programable
841 ZeroMem (DhcpHeader
->ClientHwAddr
, sizeof (EFI_GUID
));
844 DhcpHeader
->HwAddrLen
= sizeof (EFI_GUID
);
847 if (Dhcp4Event
== Dhcp4SendDiscover
) {
849 // Cache the dhcp discover packet, of which some information will be used later.
851 CopyMem (Mode
->DhcpDiscover
.Raw
, &Packet
->Dhcp4
, Packet
->Length
);
857 Status
= EFI_NOT_READY
;
858 if (Private
->NumOffers
< PXEBC_MAX_OFFER_NUM
) {
860 // Cache the dhcp offers in Private->Dhcp4Offers[]
862 PxeBcCacheDhcpOffer (Private
, Packet
);
867 case Dhcp4SelectOffer
:
869 // Select an offer, if succeeded, Private->SelectedOffer points to
870 // the index of the selected one.
872 PxeBcSelectOffer (Private
);
874 if (Private
->SelectedOffer
== 0) {
875 Status
= EFI_ABORTED
;
877 *NewPacket
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1].Packet
.Offer
;
886 ASSERT (Private
->SelectedOffer
!= 0);
888 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Packet
);
900 Initialize the DHCP options and build the option list.
902 @param Private Pointer to PxeBc private data.
903 @param OptList Pointer to a DHCP option list.
905 @param IsDhcpDiscover Discover dhcp option or not.
907 @return The index item number of the option list.
911 PxeBcBuildDhcpOptions (
912 IN PXEBC_PRIVATE_DATA
*Private
,
913 IN EFI_DHCP4_PACKET_OPTION
**OptList
,
914 IN BOOLEAN IsDhcpDiscover
918 PXEBC_DHCP4_OPTION_ENTRY OptEnt
;
920 CHAR8
*SystemSerialNumber
;
923 OptList
[0] = (EFI_DHCP4_PACKET_OPTION
*) Private
->OptionBuffer
;
925 if (!IsDhcpDiscover
) {
927 // Append message type.
929 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MSG_TYPE
;
930 OptList
[Index
]->Length
= 1;
931 OptEnt
.Mesg
= (PXEBC_DHCP4_OPTION_MESG
*) OptList
[Index
]->Data
;
932 OptEnt
.Mesg
->Type
= PXEBC_DHCP4_MSG_TYPE_REQUEST
;
934 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
937 // Append max message size.
939 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MAXMSG
;
940 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
);
941 OptEnt
.MaxMesgSize
= (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
*) OptList
[Index
]->Data
;
942 Value
= NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
943 CopyMem (&OptEnt
.MaxMesgSize
->Size
, &Value
, sizeof (UINT16
));
945 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
948 // Parameter request list option.
950 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_PARA_LIST
;
951 OptList
[Index
]->Length
= 35;
952 OptEnt
.Para
= (PXEBC_DHCP4_OPTION_PARA
*) OptList
[Index
]->Data
;
953 OptEnt
.Para
->ParaList
[0] = PXEBC_DHCP4_TAG_NETMASK
;
954 OptEnt
.Para
->ParaList
[1] = PXEBC_DHCP4_TAG_TIME_OFFSET
;
955 OptEnt
.Para
->ParaList
[2] = PXEBC_DHCP4_TAG_ROUTER
;
956 OptEnt
.Para
->ParaList
[3] = PXEBC_DHCP4_TAG_TIME_SERVER
;
957 OptEnt
.Para
->ParaList
[4] = PXEBC_DHCP4_TAG_NAME_SERVER
;
958 OptEnt
.Para
->ParaList
[5] = PXEBC_DHCP4_TAG_DNS_SERVER
;
959 OptEnt
.Para
->ParaList
[6] = PXEBC_DHCP4_TAG_HOSTNAME
;
960 OptEnt
.Para
->ParaList
[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN
;
961 OptEnt
.Para
->ParaList
[8] = PXEBC_DHCP4_TAG_DOMAINNAME
;
962 OptEnt
.Para
->ParaList
[9] = PXEBC_DHCP4_TAG_ROOTPATH
;
963 OptEnt
.Para
->ParaList
[10] = PXEBC_DHCP4_TAG_EXTEND_PATH
;
964 OptEnt
.Para
->ParaList
[11] = PXEBC_DHCP4_TAG_EMTU
;
965 OptEnt
.Para
->ParaList
[12] = PXEBC_DHCP4_TAG_TTL
;
966 OptEnt
.Para
->ParaList
[13] = PXEBC_DHCP4_TAG_BROADCAST
;
967 OptEnt
.Para
->ParaList
[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN
;
968 OptEnt
.Para
->ParaList
[15] = PXEBC_DHCP4_TAG_NIS_SERVER
;
969 OptEnt
.Para
->ParaList
[16] = PXEBC_DHCP4_TAG_NTP_SERVER
;
970 OptEnt
.Para
->ParaList
[17] = PXEBC_DHCP4_TAG_VENDOR
;
971 OptEnt
.Para
->ParaList
[18] = PXEBC_DHCP4_TAG_REQUEST_IP
;
972 OptEnt
.Para
->ParaList
[19] = PXEBC_DHCP4_TAG_LEASE
;
973 OptEnt
.Para
->ParaList
[20] = PXEBC_DHCP4_TAG_SERVER_ID
;
974 OptEnt
.Para
->ParaList
[21] = PXEBC_DHCP4_TAG_T1
;
975 OptEnt
.Para
->ParaList
[22] = PXEBC_DHCP4_TAG_T2
;
976 OptEnt
.Para
->ParaList
[23] = PXEBC_DHCP4_TAG_CLASS_ID
;
977 OptEnt
.Para
->ParaList
[24] = PXEBC_DHCP4_TAG_TFTP
;
978 OptEnt
.Para
->ParaList
[25] = PXEBC_DHCP4_TAG_BOOTFILE
;
979 OptEnt
.Para
->ParaList
[26] = PXEBC_PXE_DHCP4_TAG_UUID
;
980 OptEnt
.Para
->ParaList
[27] = 0x80;
981 OptEnt
.Para
->ParaList
[28] = 0x81;
982 OptEnt
.Para
->ParaList
[29] = 0x82;
983 OptEnt
.Para
->ParaList
[30] = 0x83;
984 OptEnt
.Para
->ParaList
[31] = 0x84;
985 OptEnt
.Para
->ParaList
[32] = 0x85;
986 OptEnt
.Para
->ParaList
[33] = 0x86;
987 OptEnt
.Para
->ParaList
[34] = 0x87;
989 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
992 // Append UUID/Guid-based client identifier option
994 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UUID
;
995 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_UUID
);
996 OptEnt
.Uuid
= (PXEBC_DHCP4_OPTION_UUID
*) OptList
[Index
]->Data
;
997 OptEnt
.Uuid
->Type
= 0;
999 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1001 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID
*) OptEnt
.Uuid
->Guid
, &SystemSerialNumber
))) {
1003 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
1004 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
1005 // GUID not yet set - send all 0's to show not programable
1007 ZeroMem (OptEnt
.Uuid
->Guid
, sizeof (EFI_GUID
));
1011 // Append client network device interface option
1013 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UNDI
;
1014 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_UNDI
);
1015 OptEnt
.Undi
= (PXEBC_DHCP4_OPTION_UNDI
*) OptList
[Index
]->Data
;
1016 if (Private
->Nii
!= NULL
) {
1017 OptEnt
.Undi
->Type
= Private
->Nii
->Type
;
1018 OptEnt
.Undi
->MajorVer
= Private
->Nii
->MajorVer
;
1019 OptEnt
.Undi
->MinorVer
= Private
->Nii
->MinorVer
;
1021 OptEnt
.Undi
->Type
= DEFAULT_UNDI_TYPE
;
1022 OptEnt
.Undi
->MajorVer
= DEFAULT_UNDI_MAJOR
;
1023 OptEnt
.Undi
->MinorVer
= DEFAULT_UNDI_MINOR
;
1027 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1030 // Append client system architecture option
1032 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_ARCH
;
1033 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_ARCH
);
1034 OptEnt
.Arch
= (PXEBC_DHCP4_OPTION_ARCH
*) OptList
[Index
]->Data
;
1035 Value
= HTONS (SYS_ARCH
);
1036 CopyMem (&OptEnt
.Arch
->Type
, &Value
, sizeof (UINT16
));
1038 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1041 // Append client system architecture option
1043 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_CLASS_ID
;
1044 OptList
[Index
]->Length
= sizeof (PXEBC_DHCP4_OPTION_CLID
);
1045 OptEnt
.Clid
= (PXEBC_DHCP4_OPTION_CLID
*) OptList
[Index
]->Data
;
1046 CopyMem (OptEnt
.Clid
, DEFAULT_CLASS_ID_DATA
, sizeof (PXEBC_DHCP4_OPTION_CLID
));
1047 CvtNum (SYS_ARCH
, OptEnt
.Clid
->ArchitectureType
, sizeof (OptEnt
.Clid
->ArchitectureType
));
1049 if (Private
->Nii
!= NULL
) {
1051 // If NII protocol exists, update DHCP option data
1053 CopyMem (OptEnt
.Clid
->InterfaceName
, Private
->Nii
->StringId
, sizeof (OptEnt
.Clid
->InterfaceName
));
1054 CvtNum (Private
->Nii
->MajorVer
, OptEnt
.Clid
->UndiMajor
, sizeof (OptEnt
.Clid
->UndiMajor
));
1055 CvtNum (Private
->Nii
->MinorVer
, OptEnt
.Clid
->UndiMinor
, sizeof (OptEnt
.Clid
->UndiMinor
));
1065 Discover the boot of service and initialize the vendor option if exists.
1067 @param Private Pointer to PxeBc private data.
1068 @param Type PxeBc option boot item type
1069 @param Layer PxeBc option boot item layer
1070 @param UseBis Use BIS or not
1071 @param DestIp Ip address for server
1072 @param IpCount The total count of the server ip address
1073 @param SrvList Server list
1074 @param IsDiscv Discover the vendor or not
1075 @param Reply The dhcp4 packet of Pxe reply
1077 @retval EFI_SUCCESS Operation succeeds.
1078 @retval EFI_OUT_OF_RESOURCES Allocate memory pool failed.
1079 @retval EFI_NOT_FOUND There is no vendor option exists.
1080 @retval EFI_TIMEOUT Send Pxe Discover time out.
1084 PxeBcDiscvBootService (
1085 IN PXEBC_PRIVATE_DATA
* Private
,
1089 IN EFI_IP_ADDRESS
* DestIp
,
1091 IN EFI_PXE_BASE_CODE_SRVLIST
* SrvList
,
1093 OUT EFI_DHCP4_PACKET
* Reply OPTIONAL
1096 EFI_PXE_BASE_CODE_UDP_PORT Sport
;
1097 EFI_PXE_BASE_CODE_MODE
*Mode
;
1098 EFI_DHCP4_PROTOCOL
*Dhcp4
;
1099 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token
;
1105 EFI_DHCP4_LISTEN_POINT ListenPoint
;
1106 EFI_DHCP4_PACKET
*Response
;
1107 EFI_DHCP4_PACKET_OPTION
*OptList
[PXEBC_DHCP4_MAX_OPTION_NUM
];
1109 EFI_DHCP4_PACKET_OPTION
*PxeOpt
;
1110 PXEBC_OPTION_BOOT_ITEM
*PxeBootItem
;
1112 CHAR8
*SystemSerialNumber
;
1113 EFI_DHCP4_HEADER
*DhcpHeader
;
1116 ASSERT (IsDiscv
&& (Layer
!= NULL
));
1118 Mode
= Private
->PxeBc
.Mode
;
1119 Dhcp4
= Private
->Dhcp4
;
1120 Status
= EFI_SUCCESS
;
1122 ZeroMem (&Token
, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN
));
1124 if (DestIp
== NULL
) {
1125 Sport
= PXEBC_DHCP4_S_PORT
;
1128 Sport
= PXEBC_BS_DISCOVER_PORT
;
1132 if (!UseBis
&& Layer
!= NULL
) {
1133 *Layer
&= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK
;
1136 OptCount
= PxeBcBuildDhcpOptions (Private
, OptList
, FALSE
);
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 gBS
->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((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 gBS
->FreePool (Token
.ResponseList
);
1276 // Free the dhcp packet
1278 gBS
->FreePool (Token
.Packet
);
1285 Parse interested dhcp options.
1287 @param Buffer Pointer to the dhcp options packet.
1288 @param Length The length of the dhcp options.
1289 @param OptTag The option OpCode.
1291 @return NULL if the buffer length is 0 and OpCode is not
1292 PXEBC_DHCP4_TAG_EOP, or the pointer to the buffer.
1295 EFI_DHCP4_PACKET_OPTION
*
1296 PxeBcParseExtendOptions (
1302 EFI_DHCP4_PACKET_OPTION
*Option
;
1305 Option
= (EFI_DHCP4_PACKET_OPTION
*) Buffer
;
1308 while (Offset
< Length
&& Option
->OpCode
!= PXEBC_DHCP4_TAG_EOP
) {
1310 if (Option
->OpCode
== OptTag
) {
1315 if (Option
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1318 Offset
+= Option
->Length
+ 2;
1321 Option
= (EFI_DHCP4_PACKET_OPTION
*) (Buffer
+ Offset
);
1329 This function is to parse and check vendor options.
1331 @param Dhcp4Option Pointer to dhcp options
1332 @param VendorOption Pointer to vendor options
1334 @return TRUE if valid for vendor options, or FALSE.
1338 PxeBcParseVendorOptions (
1339 IN EFI_DHCP4_PACKET_OPTION
*Dhcp4Option
,
1340 IN PXEBC_VENDOR_OPTION
*VendorOption
1344 UINT8 VendorOptionLen
;
1345 EFI_DHCP4_PACKET_OPTION
*PxeOption
;
1348 BitMap
= VendorOption
->BitMap
;
1349 VendorOptionLen
= Dhcp4Option
->Length
;
1350 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) &Dhcp4Option
->Data
[0];
1353 while ((Offset
< VendorOptionLen
) && (PxeOption
->OpCode
!= PXEBC_DHCP4_TAG_EOP
)) {
1355 // Parse every Vendor Option and set its BitMap
1357 switch (PxeOption
->OpCode
) {
1359 case PXEBC_VENDOR_TAG_MTFTP_IP
:
1361 CopyMem (&VendorOption
->MtftpIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1364 case PXEBC_VENDOR_TAG_MTFTP_CPORT
:
1366 CopyMem (&VendorOption
->MtftpCPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpCPort
));
1369 case PXEBC_VENDOR_TAG_MTFTP_SPORT
:
1371 CopyMem (&VendorOption
->MtftpSPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpSPort
));
1374 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT
:
1376 VendorOption
->MtftpTimeout
= *PxeOption
->Data
;
1379 case PXEBC_VENDOR_TAG_MTFTP_DELAY
:
1381 VendorOption
->MtftpDelay
= *PxeOption
->Data
;
1384 case PXEBC_VENDOR_TAG_DISCOVER_CTRL
:
1386 VendorOption
->DiscoverCtrl
= *PxeOption
->Data
;
1389 case PXEBC_VENDOR_TAG_DISCOVER_MCAST
:
1391 CopyMem (&VendorOption
->DiscoverMcastIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1394 case PXEBC_VENDOR_TAG_BOOT_SERVERS
:
1396 VendorOption
->BootSvrLen
= PxeOption
->Length
;
1397 VendorOption
->BootSvr
= (PXEBC_BOOT_SVR_ENTRY
*) PxeOption
->Data
;
1400 case PXEBC_VENDOR_TAG_BOOT_MENU
:
1402 VendorOption
->BootMenuLen
= PxeOption
->Length
;
1403 VendorOption
->BootMenu
= (PXEBC_BOOT_MENU_ENTRY
*) PxeOption
->Data
;
1406 case PXEBC_VENDOR_TAG_MENU_PROMPT
:
1408 VendorOption
->MenuPromptLen
= PxeOption
->Length
;
1409 VendorOption
->MenuPrompt
= (PXEBC_MENU_PROMPT
*) PxeOption
->Data
;
1412 case PXEBC_VENDOR_TAG_MCAST_ALLOC
:
1414 CopyMem (&VendorOption
->McastIpBase
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1415 CopyMem (&VendorOption
->McastIpBlock
, PxeOption
->Data
+ 4, sizeof (VendorOption
->McastIpBlock
));
1416 CopyMem (&VendorOption
->McastIpRange
, PxeOption
->Data
+ 6, sizeof (VendorOption
->McastIpRange
));
1419 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES
:
1421 VendorOption
->CredTypeLen
= PxeOption
->Length
;
1422 VendorOption
->CredType
= (UINT32
*) PxeOption
->Data
;
1425 case PXEBC_VENDOR_TAG_BOOT_ITEM
:
1427 CopyMem (&VendorOption
->BootSrvType
, PxeOption
->Data
, sizeof (VendorOption
->BootSrvType
));
1428 CopyMem (&VendorOption
->BootSrvLayer
, PxeOption
->Data
+ 2, sizeof (VendorOption
->BootSrvLayer
));
1432 SET_VENDOR_OPTION_BIT_MAP (BitMap
, PxeOption
->OpCode
);
1434 if (PxeOption
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1437 Offset
= (UINT8
) (Offset
+ PxeOption
->Length
+ 2);
1440 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) (Dhcp4Option
->Data
+ Offset
);
1444 // FixMe, return falas if invalid of any vendor option
1452 This function display boot item detail.
1454 If the length of the boot item string over 70 Char, just display 70 Char.
1456 @param Str Pointer to a string (boot item string).
1457 @param Len The length of string.
1461 PxeBcDisplayBootItem (
1468 Len
= (UINT8
) MIN (70, Len
);
1471 AsciiPrint ("%a \n", Str
);
1477 Choose the boot prompt.
1479 @param Private Pointer to PxeBc private data.
1481 @retval EFI_SUCCESS Select boot prompt done.
1482 @retval EFI_TIMEOUT Select boot prompt time out.
1483 @retval EFI_NOT_FOUND The proxy offer is not Pxe10.
1484 @retval EFI_ABORTED User cancel the operation.
1485 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1489 PxeBcSelectBootPrompt (
1490 IN PXEBC_PRIVATE_DATA
*Private
1493 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1494 PXEBC_VENDOR_OPTION
*VendorOpt
;
1495 EFI_EVENT TimeoutEvent
;
1496 EFI_EVENT DescendEvent
;
1497 EFI_INPUT_KEY InputKey
;
1505 TimeoutEvent
= NULL
;
1506 DescendEvent
= NULL
;
1508 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1510 Packet
= &Private
->ProxyOffer
;
1513 Packet
= &Private
->Dhcp4Ack
;
1516 if (Packet
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) {
1517 return EFI_NOT_FOUND
;
1520 VendorOpt
= &Packet
->PxeVendorOption
;
1522 if (!IS_VALID_BOOT_PROMPT (VendorOpt
->BitMap
)) {
1526 Timeout
= VendorOpt
->MenuPrompt
->Timeout
;
1527 Prompt
= VendorOpt
->MenuPrompt
->Prompt
;
1528 PromptLen
= (UINT8
) (VendorOpt
->MenuPromptLen
- 1);
1534 if (Timeout
== 255) {
1538 Status
= gBS
->CreateEvent (
1546 if (EFI_ERROR (Status
)) {
1550 Status
= gBS
->SetTimer (
1553 Timeout
* TICKS_PER_SECOND
1556 if (EFI_ERROR (Status
)) {
1560 Status
= gBS
->CreateEvent (
1568 if (EFI_ERROR (Status
)) {
1572 Status
= gBS
->SetTimer (
1578 if (EFI_ERROR (Status
)) {
1582 SecCol
= gST
->ConOut
->Mode
->CursorColumn
;
1583 SecRow
= gST
->ConOut
->Mode
->CursorRow
;
1585 PxeBcDisplayBootItem (Prompt
, PromptLen
);
1587 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1588 AsciiPrint ("(%d) ", Timeout
--);
1590 while (EFI_ERROR (gBS
->CheckEvent (TimeoutEvent
))) {
1592 if (!EFI_ERROR (gBS
->CheckEvent (DescendEvent
))) {
1593 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1594 AsciiPrint ("(%d) ", Timeout
--);
1597 if (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1599 gBS
->Stall (10 * TICKS_PER_MS
);
1603 if (InputKey
.ScanCode
== 0) {
1605 switch (InputKey
.UnicodeChar
) {
1607 Status
= EFI_ABORTED
;
1613 Status
= EFI_TIMEOUT
;
1621 switch (InputKey
.ScanCode
) {
1623 Status
= EFI_TIMEOUT
;
1627 Status
= EFI_ABORTED
;
1638 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0 , SecRow
+ 1);
1642 if (DescendEvent
!= NULL
) {
1643 gBS
->CloseEvent (DescendEvent
);
1646 if (TimeoutEvent
!= NULL
) {
1647 gBS
->CloseEvent (TimeoutEvent
);
1655 Select the boot menu.
1657 @param Private Pointer to PxeBc private data.
1658 @param Type The type of the menu.
1659 @param UseDefaultItem Use default item or not.
1661 @retval EFI_ABORTED User cancel operation.
1662 @retval EFI_SUCCESS Select the boot menu success.
1663 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1667 PxeBcSelectBootMenu (
1668 IN PXEBC_PRIVATE_DATA
*Private
,
1670 IN BOOLEAN UseDefaultItem
1673 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1674 PXEBC_VENDOR_OPTION
*VendorOpt
;
1675 EFI_INPUT_KEY InputKey
;
1684 PXEBC_BOOT_MENU_ENTRY
*MenuItem
;
1685 PXEBC_BOOT_MENU_ENTRY
*MenuArray
[PXEBC_MAX_MENU_NUM
];
1692 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1694 Packet
= &Private
->ProxyOffer
;
1697 Packet
= &Private
->Dhcp4Ack
;
1700 ASSERT (Packet
->OfferType
== DHCP4_PACKET_TYPE_PXE10
);
1702 VendorOpt
= &Packet
->PxeVendorOption
;
1704 if (!IS_VALID_BOOT_MENU (VendorOpt
->BitMap
)) {
1708 SetMem (Blank
, sizeof(Blank
), ' ');
1710 MenuSize
= VendorOpt
->BootMenuLen
;
1711 MenuItem
= VendorOpt
->BootMenu
;
1713 if (MenuSize
== 0) {
1714 return EFI_NOT_READY
;
1717 while (MenuSize
> 0) {
1718 MenuArray
[Index
] = MenuItem
;
1719 MenuSize
= (UINT8
) (MenuSize
- (MenuItem
->DescLen
+ 3));
1720 MenuItem
= (PXEBC_BOOT_MENU_ENTRY
*) ((UINT8
*) MenuItem
+ MenuItem
->DescLen
+ 3);
1721 if (Index
++ > (PXEBC_MAX_MENU_NUM
- 1)) {
1726 if (UseDefaultItem
) {
1727 *Type
= MenuArray
[0]->Type
;
1728 *Type
= NTOHS (*Type
);
1734 for (Index
= 0; Index
< MenuNum
; Index
++) {
1735 PxeBcDisplayBootItem (MenuArray
[Index
]->DescStr
, MenuArray
[Index
]->DescLen
);
1738 TopRow
= gST
->ConOut
->Mode
->CursorRow
- MenuNum
;
1742 // highlight selected row
1744 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_BLACK
, EFI_LIGHTGRAY
));
1745 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ Select
);
1746 Blank
[MenuArray
[Select
]->DescLen
] = 0;
1747 AsciiPrint ("%a\r", Blank
);
1748 PxeBcDisplayBootItem (MenuArray
[Select
]->DescStr
, MenuArray
[Select
]->DescLen
);
1749 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1750 LastSelect
= Select
;
1752 while (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1753 gBS
->Stall (10 * TICKS_PER_MS
);
1756 if (!InputKey
.ScanCode
) {
1757 switch (InputKey
.UnicodeChar
) {
1759 InputKey
.ScanCode
= SCAN_ESC
;
1762 case CTRL ('j'): /* linefeed */
1763 case CTRL ('m'): /* return */
1767 case CTRL ('i'): /* tab */
1771 InputKey
.ScanCode
= SCAN_DOWN
;
1774 case CTRL ('h'): /* backspace */
1777 InputKey
.ScanCode
= SCAN_UP
;
1781 InputKey
.ScanCode
= 0;
1785 switch (InputKey
.ScanCode
) {
1796 if (++Select
== MenuNum
) {
1807 case SCAN_PAGE_DOWN
:
1809 Select
= (UINT16
) (MenuNum
- 1);
1816 /* unhighlight last selected row */
1817 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_LIGHTGRAY
, EFI_BLACK
));
1818 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ LastSelect
);
1819 Blank
[MenuArray
[LastSelect
]->DescLen
] = 0;
1820 AsciiPrint ("%a\r", Blank
);
1821 PxeBcDisplayBootItem (MenuArray
[LastSelect
]->DescStr
, MenuArray
[LastSelect
]->DescLen
);
1822 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1826 // Swap the byte order
1828 CopyMem (Type
, &MenuArray
[Select
]->Type
, sizeof (UINT16
));
1829 *Type
= NTOHS (*Type
);