2 Support for PxeBc dhcp functions.
4 Copyright (c) 2013, Red Hat, Inc.
5 Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "PxeBcImpl.h"
20 // This is a map from the interested DHCP4 option tags' index to the tag value.
22 UINT8 mInterestedDhcp4Tags
[PXEBC_DHCP4_TAG_INDEX_MAX
] = {
23 PXEBC_DHCP4_TAG_BOOTFILE_LEN
,
24 PXEBC_DHCP4_TAG_VENDOR
,
25 PXEBC_DHCP4_TAG_OVERLOAD
,
26 PXEBC_DHCP4_TAG_MSG_TYPE
,
27 PXEBC_DHCP4_TAG_SERVER_ID
,
28 PXEBC_DHCP4_TAG_CLASS_ID
,
29 PXEBC_DHCP4_TAG_BOOTFILE
34 This function initialize the DHCP4 message instance.
36 This function will pad each item of dhcp4 message packet.
38 @param Seed Pointer to the message instance of the DHCP4 packet.
39 @param Udp4 Pointer to the EFI_UDP4_PROTOCOL instance.
44 IN EFI_DHCP4_PACKET
*Seed
,
45 IN EFI_UDP4_PROTOCOL
*Udp4
48 EFI_SIMPLE_NETWORK_MODE Mode
;
49 EFI_DHCP4_HEADER
*Header
;
51 Udp4
->GetModeData (Udp4
, NULL
, NULL
, NULL
, &Mode
);
53 Seed
->Size
= sizeof (EFI_DHCP4_PACKET
);
54 Seed
->Length
= sizeof (Seed
->Dhcp4
);
56 Header
= &Seed
->Dhcp4
.Header
;
58 ZeroMem (Header
, sizeof (EFI_DHCP4_HEADER
));
59 Header
->OpCode
= PXEBC_DHCP4_OPCODE_REQUEST
;
60 Header
->HwType
= Mode
.IfType
;
61 Header
->HwAddrLen
= (UINT8
) Mode
.HwAddressSize
;
62 CopyMem (Header
->ClientHwAddr
, &Mode
.CurrentAddress
, Header
->HwAddrLen
);
64 Seed
->Dhcp4
.Magik
= PXEBC_DHCP4_MAGIC
;
65 Seed
->Dhcp4
.Option
[0] = PXEBC_DHCP4_TAG_EOP
;
70 Copy the DCHP4 packet from srouce to destination.
72 @param Dst Pointer to the EFI_DHCP4_PROTOCOL instance.
73 @param Src Pointer to the EFI_DHCP4_PROTOCOL instance.
77 PxeBcCopyEfiDhcp4Packet (
78 IN EFI_DHCP4_PACKET
*Dst
,
79 IN EFI_DHCP4_PACKET
*Src
82 ASSERT (Dst
->Size
>= Src
->Length
);
84 CopyMem (&Dst
->Dhcp4
, &Src
->Dhcp4
, Src
->Length
);
85 Dst
->Length
= Src
->Length
;
90 Copy the dhcp4 packet to the PxeBc private data and parse the dhcp4 packet.
92 @param Private Pointer to PxeBc private data.
93 @param OfferIndex Index of cached packets as complements of pxe mode data,
94 the index is maximum offer number.
99 IN PXEBC_PRIVATE_DATA
*Private
,
103 EFI_PXE_BASE_CODE_MODE
*Mode
;
104 EFI_DHCP4_PACKET
*Offer
;
106 ASSERT (OfferIndex
< Private
->NumOffers
);
107 ASSERT (OfferIndex
< PXEBC_MAX_OFFER_NUM
);
109 Mode
= Private
->PxeBc
.Mode
;
110 Offer
= &Private
->Dhcp4Offers
[OfferIndex
].Packet
.Offer
;
112 PxeBcCopyEfiDhcp4Packet (&Private
->ProxyOffer
.Packet
.Offer
, Offer
);
113 CopyMem (&Mode
->ProxyOffer
, &Offer
->Dhcp4
, Offer
->Length
);
114 Mode
->ProxyOfferReceived
= TRUE
;
116 PxeBcParseCachedDhcpPacket (&Private
->ProxyOffer
);
121 Parse the cached dhcp packet.
123 @param CachedPacket Pointer to cached dhcp packet.
125 @retval TRUE Succeed to parse and validation.
126 @retval FALSE Fail to parse or validation.
130 PxeBcParseCachedDhcpPacket (
131 IN PXEBC_CACHED_DHCP4_PACKET
*CachedPacket
134 EFI_DHCP4_PACKET
*Offer
;
135 EFI_DHCP4_PACKET_OPTION
**Options
;
136 EFI_DHCP4_PACKET_OPTION
*Option
;
141 CachedPacket
->IsPxeOffer
= FALSE
;
142 ZeroMem (CachedPacket
->Dhcp4Option
, sizeof (CachedPacket
->Dhcp4Option
));
143 ZeroMem (&CachedPacket
->PxeVendorOption
, sizeof (CachedPacket
->PxeVendorOption
));
145 Offer
= &CachedPacket
->Packet
.Offer
;
146 Options
= CachedPacket
->Dhcp4Option
;
149 // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
150 // First, try to parse DHCPv4 options from the DHCP optional parameters field.
152 for (Index
= 0; Index
< PXEBC_DHCP4_TAG_INDEX_MAX
; Index
++) {
153 Options
[Index
] = PxeBcParseExtendOptions (
155 GET_OPTION_BUFFER_LEN (Offer
),
156 mInterestedDhcp4Tags
[Index
]
160 // Second, Check if bootfilename and serverhostname is overloaded to carry DHCP options refers to rfc-2132.
161 // If yes, try to parse options from the BootFileName field, then ServerName field.
163 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_OVERLOAD
];
164 if (Option
!= NULL
) {
165 if ((Option
->Data
[0] & PXEBC_DHCP4_OVERLOAD_FILE
) != 0) {
166 for (Index
= 0; Index
< PXEBC_DHCP4_TAG_INDEX_MAX
; Index
++) {
167 if (Options
[Index
] == NULL
) {
168 Options
[Index
] = PxeBcParseExtendOptions (
169 (UINT8
*) Offer
->Dhcp4
.Header
.BootFileName
,
170 sizeof (Offer
->Dhcp4
.Header
.BootFileName
),
171 mInterestedDhcp4Tags
[Index
]
176 if ((Option
->Data
[0] & PXEBC_DHCP4_OVERLOAD_SERVER_NAME
) != 0) {
177 for (Index
= 0; Index
< PXEBC_DHCP4_TAG_INDEX_MAX
; Index
++) {
178 if (Options
[Index
] == NULL
) {
179 Options
[Index
] = PxeBcParseExtendOptions (
180 (UINT8
*) Offer
->Dhcp4
.Header
.ServerName
,
181 sizeof (Offer
->Dhcp4
.Header
.ServerName
),
182 mInterestedDhcp4Tags
[Index
]
190 // Check whether is an offer with PXEClient or not.
192 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_CLASS_ID
];
193 if ((Option
!= NULL
) && (Option
->Length
>= 9) &&
194 (CompareMem (Option
->Data
, DEFAULT_CLASS_ID_DATA
, 9) == 0)) {
196 CachedPacket
->IsPxeOffer
= TRUE
;
200 // Parse pxe vendor options and store their content/pointers in CachedPacket->PxeVendorOption.
202 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_VENDOR
];
203 if (CachedPacket
->IsPxeOffer
&& (Option
!= NULL
)) {
205 if (!PxeBcParseVendorOptions (Option
, &CachedPacket
->PxeVendorOption
)) {
212 // Parse PXE boot file name:
213 // According to PXE spec, boot file name should be read from DHCP option 67 (bootfile name) if present.
214 // Otherwise, read from boot file field in DHCP header.
216 if (Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
) {
218 // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null
219 // terminated string. So force to append null terminated character at the end of string.
221 Ptr8
= (UINT8
*)&Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
]->Data
[0];
222 Ptr8
+= Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
]->Length
;
223 if (*(Ptr8
- 1) != '\0') {
226 } else if (Offer
->Dhcp4
.Header
.BootFileName
[0] != 0) {
228 // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
229 // And do not count dhcp option header, or else will destroy the serverhostname.
231 Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] = (EFI_DHCP4_PACKET_OPTION
*) (&Offer
->Dhcp4
.Header
.BootFileName
[0] -
232 OFFSET_OF (EFI_DHCP4_PACKET_OPTION
, Data
[0]));
237 // Determine offer type of the dhcp packet.
239 Option
= Options
[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE
];
240 if ((Option
== NULL
) || (Option
->Data
[0] == 0)) {
242 // It's a bootp offer
244 Option
= CachedPacket
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
];
245 if (Option
== NULL
) {
247 // bootp offer without bootfilename, discard it.
252 OfferType
= DHCP4_PACKET_TYPE_BOOTP
;
256 if (IS_VALID_DISCOVER_VENDOR_OPTION (CachedPacket
->PxeVendorOption
.BitMap
)) {
258 // It's a pxe10 offer with PXEClient and discover vendor option.
260 OfferType
= DHCP4_PACKET_TYPE_PXE10
;
261 } else if (IS_VALID_MTFTP_VENDOR_OPTION (CachedPacket
->PxeVendorOption
.BitMap
)) {
263 // It's a wfm11a offer with PXEClient and mtftp vendor option, and
264 // return false since mtftp not supported currently.
269 // If the binl offer with only PXEClient.
271 OfferType
= (UINT8
) ((CachedPacket
->IsPxeOffer
) ? DHCP4_PACKET_TYPE_BINL
: DHCP4_PACKET_TYPE_DHCP_ONLY
);
275 CachedPacket
->OfferType
= OfferType
;
282 Offer dhcp service with a BINL dhcp offer.
284 @param Private Pointer to PxeBc private data.
285 @param Index Index of cached packets as complements of pxe mode data,
286 the index is maximum offer number.
288 @retval TRUE Offer the service successfully under priority BINL.
289 @retval FALSE Boot Service failed, parse cached dhcp packet failed or this
290 BINL ack cannot find options set or bootfile name specified.
295 IN PXEBC_PRIVATE_DATA
*Private
,
299 EFI_DHCP4_PACKET
*Offer
;
300 EFI_IP_ADDRESS ServerIp
;
302 PXEBC_CACHED_DHCP4_PACKET
*CachedPacket
;
303 EFI_DHCP4_PACKET
*Reply
;
305 ASSERT (Index
< PXEBC_MAX_OFFER_NUM
);
306 ASSERT (Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_BINL
);
308 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
311 // Use siaddr(next server) in DHCPOFFER packet header, if zero, use option 54(server identifier)
312 // in DHCPOFFER packet.
313 // (It does not comply with PXE Spec, Ver2.1)
315 if (EFI_IP4_EQUAL (&Offer
->Dhcp4
.Header
.ServerAddr
.Addr
, &mZeroIp4Addr
)) {
318 Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_SERVER_ID
]->Data
,
319 sizeof (EFI_IPv4_ADDRESS
)
324 &Offer
->Dhcp4
.Header
.ServerAddr
,
325 sizeof (EFI_IPv4_ADDRESS
)
328 if (ServerIp
.Addr
[0] == 0) {
332 CachedPacket
= &Private
->ProxyOffer
;
333 Reply
= &CachedPacket
->Packet
.Offer
;
335 Status
= PxeBcDiscvBootService (
346 if (EFI_ERROR (Status
)) {
350 if (!PxeBcParseCachedDhcpPacket (CachedPacket
)) {
354 if ((CachedPacket
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) &&
355 (CachedPacket
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
)) {
357 // This BINL ack doesn't have discovery options set or bootfile name
363 Private
->PxeBc
.Mode
->ProxyOfferReceived
= TRUE
;
364 CopyMem (&Private
->PxeBc
.Mode
->ProxyOffer
, &Reply
->Dhcp4
, Reply
->Length
);
371 Offer dhcp service for each proxy with a BINL dhcp offer.
373 @param Private Pointer to PxeBc private data
374 @param OfferIndex Pointer to the index of cached packets as complements of
375 pxe mode data, the index is maximum offer number.
377 @return If there is no service needed offer return FALSE, otherwise TRUE.
382 IN PXEBC_PRIVATE_DATA
*Private
,
383 OUT UINT32
*OfferIndex
388 for (Index
= 0; Index
< Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]; Index
++) {
390 *OfferIndex
= Private
->BinlIndex
[Index
];
392 // Try this BINL proxy offer
394 if (PxeBcTryBinl (Private
, *OfferIndex
)) {
404 This function is to check the selected proxy offer (include BINL dhcp offer and
405 DHCP_ONLY offer ) and set the flag and copy the DHCP packets to the Pxe base code
408 @param Private Pointer to PxeBc private data.
410 @retval EFI_SUCCESS Operational successful.
411 @retval EFI_NO_RESPONSE Offer dhcp service failed.
415 PxeBcCheckSelectedOffer (
416 IN PXEBC_PRIVATE_DATA
*Private
419 PXEBC_CACHED_DHCP4_PACKET
*SelectedOffer
;
420 EFI_DHCP4_PACKET_OPTION
**Options
;
422 EFI_DHCP4_PACKET
*Offer
;
423 UINT32 ProxyOfferIndex
;
425 EFI_PXE_BASE_CODE_MODE
*Mode
;
426 EFI_DHCP4_PACKET
*Ack
;
428 ASSERT (Private
->SelectedOffer
!= 0);
430 Status
= EFI_SUCCESS
;
431 SelectedOffer
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1];
432 Options
= SelectedOffer
->Dhcp4Option
;
434 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BINL
) {
436 // The addresses are acquired from a BINL dhcp offer, try BINL to get
439 if (!PxeBcTryBinl (Private
, Private
->SelectedOffer
- 1)) {
440 Status
= EFI_NO_RESPONSE
;
442 } else if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) {
444 // The selected offer to finish the D.O.R.A. is a DHCP only offer, we need
445 // try proxy offers if there are some, othewise the bootfile name must be
446 // set in this DHCP only offer.
448 if (Private
->GotProxyOffer
) {
450 // Get rid of the compiler warning.
453 if (Private
->SortOffers
) {
455 // The offers are sorted before selecting, the proxy offer type must be
456 // already determined.
458 ASSERT (Private
->ProxyIndex
[Private
->ProxyOfferType
] > 0);
460 if (Private
->ProxyOfferType
== DHCP4_PACKET_TYPE_BINL
) {
462 // We buffer all received BINL proxy offers, try them all one by one
464 if (!PxeBcTryBinlProxy (Private
, &ProxyOfferIndex
)) {
465 Status
= EFI_NO_RESPONSE
;
469 // For other types, only one proxy offer is buffered.
471 ProxyOfferIndex
= Private
->ProxyIndex
[Private
->ProxyOfferType
] - 1;
475 // The proxy offer type is not determined, choose proxy offer in the
478 Status
= EFI_NO_RESPONSE
;
480 ASSERT (Private
->NumOffers
< PXEBC_MAX_OFFER_NUM
);
481 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
483 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
484 if (!IS_PROXY_DHCP_OFFER (Offer
)) {
486 // Skip non proxy dhcp offers.
491 if (Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_BINL
) {
495 if (!PxeBcTryBinl (Private
, Index
)) {
497 // Failed, skip to the next offer
503 Private
->ProxyOfferType
= Private
->Dhcp4Offers
[Index
].OfferType
;
504 ProxyOfferIndex
= Index
;
505 Status
= EFI_SUCCESS
;
510 if (!EFI_ERROR (Status
) && (Private
->ProxyOfferType
!= DHCP4_PACKET_TYPE_BINL
)) {
512 // Copy the proxy offer to Mode and set the flag
514 PxeBcCopyProxyOffer (Private
, ProxyOfferIndex
);
518 // No proxy offer is received, the bootfile name MUST be set.
520 ASSERT (Options
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
);
524 if (!EFI_ERROR (Status
)) {
526 // Everything is OK, set the flag and copy the DHCP packets.
528 Mode
= Private
->PxeBc
.Mode
;
529 Offer
= &SelectedOffer
->Packet
.Offer
;
532 // The discover packet is already copied, just set flag here.
534 Mode
->DhcpDiscoverValid
= TRUE
;
536 Ack
= &Private
->Dhcp4Ack
.Packet
.Ack
;
537 if (SelectedOffer
->OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
539 // Other type of ACK is already cached. Bootp is special that we should
540 // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
542 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Offer
);
545 PxeBcParseCachedDhcpPacket (&Private
->Dhcp4Ack
);
547 Mode
->DhcpAckReceived
= TRUE
;
550 // Copy the dhcp ack.
552 CopyMem (&Mode
->DhcpAck
, &Ack
->Dhcp4
, Ack
->Length
);
560 Cache the Dhcp4 packet offer, Parse and validate each option of the packet.
562 @param Private Pointer to PxeBc private data.
563 @param RcvdOffer Pointer to the received Dhcp proxy offer packet.
567 PxeBcCacheDhcpOffer (
568 IN PXEBC_PRIVATE_DATA
*Private
,
569 IN EFI_DHCP4_PACKET
*RcvdOffer
572 PXEBC_CACHED_DHCP4_PACKET
*CachedOffer
;
573 EFI_DHCP4_PACKET
*Offer
;
576 CachedOffer
= &Private
->Dhcp4Offers
[Private
->NumOffers
];
577 Offer
= &CachedOffer
->Packet
.Offer
;
580 // Cache the orignal dhcp packet
582 PxeBcCopyEfiDhcp4Packet (Offer
, RcvdOffer
);
585 // Parse and validate the options (including dhcp option and vendor option)
587 if (!PxeBcParseCachedDhcpPacket (CachedOffer
)) {
591 OfferType
= CachedOffer
->OfferType
;
592 if (OfferType
>= DHCP4_PACKET_TYPE_MAX
) {
596 if (OfferType
== DHCP4_PACKET_TYPE_BOOTP
) {
598 if (Private
->BootpIndex
!= 0) {
600 // Only cache the first bootp offer, discard others.
605 // Take as a dhcp only offer, but record index specifically.
607 Private
->BootpIndex
= Private
->NumOffers
+ 1;
611 if (IS_PROXY_DHCP_OFFER (Offer
)) {
613 // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
615 Private
->GotProxyOffer
= TRUE
;
617 if (OfferType
== DHCP4_PACKET_TYPE_BINL
) {
619 // Cache all binl offers.
621 Private
->BinlIndex
[Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]] = Private
->NumOffers
;
622 Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
]++;
623 } else if (Private
->ProxyIndex
[OfferType
] != 0) {
625 // Only cache the first pxe10/wfm11a offers each, discard the others.
630 // Record index of the proxy dhcp offer with type other than binl.
632 Private
->ProxyIndex
[OfferType
] = Private
->NumOffers
+ 1;
636 // It's a dhcp offer with your address.
638 ASSERT (Private
->ServerCount
[OfferType
] < PXEBC_MAX_OFFER_NUM
);
639 Private
->OfferIndex
[OfferType
][Private
->ServerCount
[OfferType
]] = Private
->NumOffers
;
640 Private
->ServerCount
[OfferType
]++;
645 // Count the accepted offers.
647 Private
->NumOffers
++;
651 Switch the Ip4 policy to static.
653 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.
655 @retval EFI_SUCCESS The policy is already configured to static.
656 @retval Others Other error as indicated..
661 IN PXEBC_PRIVATE_DATA
*Private
665 EFI_IP4_CONFIG2_PROTOCOL
*Ip4Config2
;
666 EFI_IP4_CONFIG2_POLICY Policy
;
669 Ip4Config2
= Private
->Ip4Config2
;
670 DataSize
= sizeof (EFI_IP4_CONFIG2_POLICY
);
671 Status
= Ip4Config2
->GetData (
673 Ip4Config2DataTypePolicy
,
677 if (EFI_ERROR (Status
)) {
681 if (Policy
!= Ip4Config2PolicyStatic
) {
682 Policy
= Ip4Config2PolicyStatic
;
683 Status
= Ip4Config2
->SetData (
685 Ip4Config2DataTypePolicy
,
686 sizeof (EFI_IP4_CONFIG2_POLICY
),
689 if (EFI_ERROR (Status
)) {
699 Select the specified proxy offer, such as BINL, DHCP_ONLY and so on.
700 If the proxy does not exist, try offers with bootfile.
702 @param Private Pointer to PxeBc private data.
707 IN PXEBC_PRIVATE_DATA
*Private
712 EFI_DHCP4_PACKET
*Offer
;
714 Private
->SelectedOffer
= 0;
716 if (Private
->SortOffers
) {
718 // Select offer according to the priority
720 if (Private
->ServerCount
[DHCP4_PACKET_TYPE_PXE10
] > 0) {
724 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_PXE10
][0] + 1;
726 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_WFM11A
] > 0) {
730 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_WFM11A
][0] + 1;
732 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_PXE10
] > 0) &&
733 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
736 // DHCP only and proxy DHCP with PXE10
738 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
739 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_PXE10
;
741 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_WFM11A
] > 0) &&
742 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
745 // DHCP only and proxy DHCP with WfM
747 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
748 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_WFM11A
;
750 } else if (Private
->ServerCount
[DHCP4_PACKET_TYPE_BINL
] > 0) {
754 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_BINL
][0] + 1;
756 } else if ((Private
->ProxyIndex
[DHCP4_PACKET_TYPE_BINL
] > 0) &&
757 (Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
] > 0)
760 // DHCP only and proxy DHCP with BINL
762 Private
->SelectedOffer
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][0] + 1;
763 Private
->ProxyOfferType
= DHCP4_PACKET_TYPE_BINL
;
767 // Try offers with bootfile
769 for (Index
= 0; Index
< Private
->ServerCount
[DHCP4_PACKET_TYPE_DHCP_ONLY
]; Index
++) {
771 // Select the first DHCP only offer with bootfile
773 OfferIndex
= Private
->OfferIndex
[DHCP4_PACKET_TYPE_DHCP_ONLY
][Index
];
774 if (Private
->Dhcp4Offers
[OfferIndex
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
) {
775 Private
->SelectedOffer
= OfferIndex
+ 1;
780 if (Private
->SelectedOffer
== 0) {
782 // Select the Bootp reply with bootfile if any
784 Private
->SelectedOffer
= Private
->BootpIndex
;
789 // Try the offers in the received order.
791 for (Index
= 0; Index
< Private
->NumOffers
; Index
++) {
793 Offer
= &Private
->Dhcp4Offers
[Index
].Packet
.Offer
;
795 if (IS_PROXY_DHCP_OFFER (Offer
)) {
802 if ((Private
->Dhcp4Offers
[Index
].OfferType
== DHCP4_PACKET_TYPE_DHCP_ONLY
) &&
803 ((!Private
->GotProxyOffer
) && (Private
->Dhcp4Offers
[Index
].Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] == NULL
))) {
805 // DHCP only offer but no proxy offer received and no bootfile option in this offer
810 Private
->SelectedOffer
= Index
+ 1;
820 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
821 to intercept events that occurred in the configuration process. This structure
822 provides advanced control of each state transition of the DHCP process. The
823 returned status code determines the behavior of the EFI DHCPv4 Protocol driver.
824 There are three possible returned values, which are described in the following
827 @param This Pointer to the EFI DHCPv4 Protocol instance that is used to
828 configure this callback function.
829 @param Context Pointer to the context that is initialized by
830 EFI_DHCP4_PROTOCOL.Configure().
831 @param CurrentState The current operational state of the EFI DHCPv4 Protocol
833 @param Dhcp4Event The event that occurs in the current state, which usually means a
835 @param Packet The DHCP packet that is going to be sent or already received.
836 @param NewPacket The packet that is used to replace the above Packet.
838 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
839 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
840 driver will continue to wait for more DHCPOFFER packets until the retry
842 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process and
843 return to the Dhcp4Init or Dhcp4InitReboot state.
849 IN EFI_DHCP4_PROTOCOL
* This
,
851 IN EFI_DHCP4_STATE CurrentState
,
852 IN EFI_DHCP4_EVENT Dhcp4Event
,
853 IN EFI_DHCP4_PACKET
* Packet OPTIONAL
,
854 OUT EFI_DHCP4_PACKET
**NewPacket OPTIONAL
857 PXEBC_PRIVATE_DATA
*Private
;
858 EFI_PXE_BASE_CODE_MODE
*Mode
;
859 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL
*Callback
;
860 EFI_DHCP4_PACKET_OPTION
*MaxMsgSize
;
864 EFI_DHCP4_HEADER
*DhcpHeader
;
866 if ((Dhcp4Event
!= Dhcp4RcvdOffer
) &&
867 (Dhcp4Event
!= Dhcp4SelectOffer
) &&
868 (Dhcp4Event
!= Dhcp4SendDiscover
) &&
869 (Dhcp4Event
!= Dhcp4RcvdAck
) &&
870 (Dhcp4Event
!= Dhcp4SendRequest
)) {
874 Private
= (PXEBC_PRIVATE_DATA
*) Context
;
875 Mode
= Private
->PxeBc
.Mode
;
876 Callback
= Private
->PxeBcCallback
;
879 // Override the Maximum DHCP Message Size.
881 MaxMsgSize
= PxeBcParseExtendOptions (
882 Packet
->Dhcp4
.Option
,
883 GET_OPTION_BUFFER_LEN (Packet
),
884 PXEBC_DHCP4_TAG_MAXMSG
886 if (MaxMsgSize
!= NULL
) {
887 Value
= HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
888 CopyMem (MaxMsgSize
->Data
, &Value
, sizeof (Value
));
891 if ((Dhcp4Event
!= Dhcp4SelectOffer
) && (Callback
!= NULL
)) {
892 Received
= (BOOLEAN
) ((Dhcp4Event
== Dhcp4RcvdOffer
) || (Dhcp4Event
== Dhcp4RcvdAck
));
893 Status
= Callback
->Callback (
898 (EFI_PXE_BASE_CODE_PACKET
*) &Packet
->Dhcp4
900 if (Status
!= EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE
) {
905 Status
= EFI_SUCCESS
;
907 switch (Dhcp4Event
) {
909 case Dhcp4SendDiscover
:
910 case Dhcp4SendRequest
:
911 if (Mode
->SendGUID
) {
913 // send the system GUID instead of the MAC address as the hardware address
914 // in the DHCP packet header.
916 DhcpHeader
= &Packet
->Dhcp4
.Header
;
918 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID
*) DhcpHeader
->ClientHwAddr
))) {
920 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
921 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
922 // GUID not yet set - send all 0's to show not programable
924 ZeroMem (DhcpHeader
->ClientHwAddr
, sizeof (EFI_GUID
));
927 DhcpHeader
->HwAddrLen
= (UINT8
) sizeof (EFI_GUID
);
930 if (Dhcp4Event
== Dhcp4SendDiscover
) {
932 // Cache the dhcp discover packet, of which some information will be used later.
934 CopyMem (Mode
->DhcpDiscover
.Raw
, &Packet
->Dhcp4
, Packet
->Length
);
940 Status
= EFI_NOT_READY
;
941 if (Private
->NumOffers
< PXEBC_MAX_OFFER_NUM
) {
943 // Cache the dhcp offers in Private->Dhcp4Offers[]
945 PxeBcCacheDhcpOffer (Private
, Packet
);
950 case Dhcp4SelectOffer
:
952 // Select an offer, if succeeded, Private->SelectedOffer points to
953 // the index of the selected one.
955 PxeBcSelectOffer (Private
);
957 if (Private
->SelectedOffer
== 0) {
958 Status
= EFI_ABORTED
;
960 *NewPacket
= &Private
->Dhcp4Offers
[Private
->SelectedOffer
- 1].Packet
.Offer
;
969 ASSERT (Private
->SelectedOffer
!= 0);
971 PxeBcCopyEfiDhcp4Packet (&Private
->Dhcp4Ack
.Packet
.Ack
, Packet
);
983 Initialize the DHCP options and build the option list.
985 @param Private Pointer to PxeBc private data.
986 @param OptList Pointer to a DHCP option list.
988 @param IsDhcpDiscover Discover dhcp option or not.
990 @return The index item number of the option list.
994 PxeBcBuildDhcpOptions (
995 IN PXEBC_PRIVATE_DATA
*Private
,
996 IN EFI_DHCP4_PACKET_OPTION
**OptList
,
997 IN BOOLEAN IsDhcpDiscover
1001 PXEBC_DHCP4_OPTION_ENTRY OptEnt
;
1005 OptList
[0] = (EFI_DHCP4_PACKET_OPTION
*) Private
->OptionBuffer
;
1007 if (!IsDhcpDiscover
) {
1009 // Append message type.
1011 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MSG_TYPE
;
1012 OptList
[Index
]->Length
= 1;
1013 OptEnt
.Mesg
= (PXEBC_DHCP4_OPTION_MESG
*) OptList
[Index
]->Data
;
1014 OptEnt
.Mesg
->Type
= PXEBC_DHCP4_MSG_TYPE_REQUEST
;
1016 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1019 // Append max message size.
1021 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_MAXMSG
;
1022 OptList
[Index
]->Length
= (UINT8
) sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
);
1023 OptEnt
.MaxMesgSize
= (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE
*) OptList
[Index
]->Data
;
1024 Value
= NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE
);
1025 CopyMem (&OptEnt
.MaxMesgSize
->Size
, &Value
, sizeof (UINT16
));
1027 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1030 // Parameter request list option.
1032 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_PARA_LIST
;
1033 OptList
[Index
]->Length
= 35;
1034 OptEnt
.Para
= (PXEBC_DHCP4_OPTION_PARA
*) OptList
[Index
]->Data
;
1035 OptEnt
.Para
->ParaList
[0] = PXEBC_DHCP4_TAG_NETMASK
;
1036 OptEnt
.Para
->ParaList
[1] = PXEBC_DHCP4_TAG_TIME_OFFSET
;
1037 OptEnt
.Para
->ParaList
[2] = PXEBC_DHCP4_TAG_ROUTER
;
1038 OptEnt
.Para
->ParaList
[3] = PXEBC_DHCP4_TAG_TIME_SERVER
;
1039 OptEnt
.Para
->ParaList
[4] = PXEBC_DHCP4_TAG_NAME_SERVER
;
1040 OptEnt
.Para
->ParaList
[5] = PXEBC_DHCP4_TAG_DNS_SERVER
;
1041 OptEnt
.Para
->ParaList
[6] = PXEBC_DHCP4_TAG_HOSTNAME
;
1042 OptEnt
.Para
->ParaList
[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN
;
1043 OptEnt
.Para
->ParaList
[8] = PXEBC_DHCP4_TAG_DOMAINNAME
;
1044 OptEnt
.Para
->ParaList
[9] = PXEBC_DHCP4_TAG_ROOTPATH
;
1045 OptEnt
.Para
->ParaList
[10] = PXEBC_DHCP4_TAG_EXTEND_PATH
;
1046 OptEnt
.Para
->ParaList
[11] = PXEBC_DHCP4_TAG_EMTU
;
1047 OptEnt
.Para
->ParaList
[12] = PXEBC_DHCP4_TAG_TTL
;
1048 OptEnt
.Para
->ParaList
[13] = PXEBC_DHCP4_TAG_BROADCAST
;
1049 OptEnt
.Para
->ParaList
[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN
;
1050 OptEnt
.Para
->ParaList
[15] = PXEBC_DHCP4_TAG_NIS_SERVER
;
1051 OptEnt
.Para
->ParaList
[16] = PXEBC_DHCP4_TAG_NTP_SERVER
;
1052 OptEnt
.Para
->ParaList
[17] = PXEBC_DHCP4_TAG_VENDOR
;
1053 OptEnt
.Para
->ParaList
[18] = PXEBC_DHCP4_TAG_REQUEST_IP
;
1054 OptEnt
.Para
->ParaList
[19] = PXEBC_DHCP4_TAG_LEASE
;
1055 OptEnt
.Para
->ParaList
[20] = PXEBC_DHCP4_TAG_SERVER_ID
;
1056 OptEnt
.Para
->ParaList
[21] = PXEBC_DHCP4_TAG_T1
;
1057 OptEnt
.Para
->ParaList
[22] = PXEBC_DHCP4_TAG_T2
;
1058 OptEnt
.Para
->ParaList
[23] = PXEBC_DHCP4_TAG_CLASS_ID
;
1059 OptEnt
.Para
->ParaList
[24] = PXEBC_DHCP4_TAG_TFTP
;
1060 OptEnt
.Para
->ParaList
[25] = PXEBC_DHCP4_TAG_BOOTFILE
;
1061 OptEnt
.Para
->ParaList
[26] = PXEBC_PXE_DHCP4_TAG_UUID
;
1062 OptEnt
.Para
->ParaList
[27] = 0x80;
1063 OptEnt
.Para
->ParaList
[28] = 0x81;
1064 OptEnt
.Para
->ParaList
[29] = 0x82;
1065 OptEnt
.Para
->ParaList
[30] = 0x83;
1066 OptEnt
.Para
->ParaList
[31] = 0x84;
1067 OptEnt
.Para
->ParaList
[32] = 0x85;
1068 OptEnt
.Para
->ParaList
[33] = 0x86;
1069 OptEnt
.Para
->ParaList
[34] = 0x87;
1071 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1074 // Append UUID/Guid-based client identifier option
1076 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UUID
;
1077 OptList
[Index
]->Length
= (UINT8
) sizeof (PXEBC_DHCP4_OPTION_UUID
);
1078 OptEnt
.Uuid
= (PXEBC_DHCP4_OPTION_UUID
*) OptList
[Index
]->Data
;
1079 OptEnt
.Uuid
->Type
= 0;
1081 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1083 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID
*) OptEnt
.Uuid
->Guid
))) {
1085 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
1086 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
1087 // GUID not yet set - send all 0's to show not programable
1089 ZeroMem (OptEnt
.Uuid
->Guid
, sizeof (EFI_GUID
));
1093 // Append client network device interface option
1095 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_UNDI
;
1096 OptList
[Index
]->Length
= (UINT8
) sizeof (PXEBC_DHCP4_OPTION_UNDI
);
1097 OptEnt
.Undi
= (PXEBC_DHCP4_OPTION_UNDI
*) OptList
[Index
]->Data
;
1098 if (Private
->Nii
!= NULL
) {
1099 OptEnt
.Undi
->Type
= Private
->Nii
->Type
;
1100 OptEnt
.Undi
->MajorVer
= Private
->Nii
->MajorVer
;
1101 OptEnt
.Undi
->MinorVer
= Private
->Nii
->MinorVer
;
1103 OptEnt
.Undi
->Type
= DEFAULT_UNDI_TYPE
;
1104 OptEnt
.Undi
->MajorVer
= DEFAULT_UNDI_MAJOR
;
1105 OptEnt
.Undi
->MinorVer
= DEFAULT_UNDI_MINOR
;
1109 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1112 // Append client system architecture option
1114 OptList
[Index
]->OpCode
= PXEBC_PXE_DHCP4_TAG_ARCH
;
1115 OptList
[Index
]->Length
= (UINT8
) sizeof (PXEBC_DHCP4_OPTION_ARCH
);
1116 OptEnt
.Arch
= (PXEBC_DHCP4_OPTION_ARCH
*) OptList
[Index
]->Data
;
1117 Value
= HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE
);
1118 CopyMem (&OptEnt
.Arch
->Type
, &Value
, sizeof (UINT16
));
1120 OptList
[Index
] = GET_NEXT_DHCP_OPTION (OptList
[Index
- 1]);
1123 // Append client system architecture option
1125 OptList
[Index
]->OpCode
= PXEBC_DHCP4_TAG_CLASS_ID
;
1126 OptList
[Index
]->Length
= (UINT8
) sizeof (PXEBC_DHCP4_OPTION_CLID
);
1127 OptEnt
.Clid
= (PXEBC_DHCP4_OPTION_CLID
*) OptList
[Index
]->Data
;
1128 CopyMem (OptEnt
.Clid
, DEFAULT_CLASS_ID_DATA
, sizeof (PXEBC_DHCP4_OPTION_CLID
));
1129 CvtNum (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE
, OptEnt
.Clid
->ArchitectureType
, sizeof (OptEnt
.Clid
->ArchitectureType
));
1131 if (Private
->Nii
!= NULL
) {
1133 // If NII protocol exists, update DHCP option data
1135 CopyMem (OptEnt
.Clid
->InterfaceName
, Private
->Nii
->StringId
, sizeof (OptEnt
.Clid
->InterfaceName
));
1136 CvtNum (Private
->Nii
->MajorVer
, OptEnt
.Clid
->UndiMajor
, sizeof (OptEnt
.Clid
->UndiMajor
));
1137 CvtNum (Private
->Nii
->MinorVer
, OptEnt
.Clid
->UndiMinor
, sizeof (OptEnt
.Clid
->UndiMinor
));
1147 Discover the boot of service and initialize the vendor option if exists.
1149 @param Private Pointer to PxeBc private data.
1150 @param Type PxeBc option boot item type
1151 @param Layer PxeBc option boot item layer
1152 @param UseBis Use BIS or not
1153 @param DestIp Ip address for server
1154 @param IpCount The total count of the server ip address
1155 @param SrvList Server list
1156 @param IsDiscv Discover the vendor or not
1157 @param Reply The dhcp4 packet of Pxe reply
1159 @retval EFI_SUCCESS Operation succeeds.
1160 @retval EFI_OUT_OF_RESOURCES Allocate memory pool failed.
1161 @retval EFI_NOT_FOUND There is no vendor option exists.
1162 @retval EFI_TIMEOUT Send Pxe Discover time out.
1166 PxeBcDiscvBootService (
1167 IN PXEBC_PRIVATE_DATA
* Private
,
1171 IN EFI_IP_ADDRESS
* DestIp
,
1173 IN EFI_PXE_BASE_CODE_SRVLIST
* SrvList
,
1175 OUT EFI_DHCP4_PACKET
* Reply OPTIONAL
1178 EFI_PXE_BASE_CODE_UDP_PORT Sport
;
1179 EFI_PXE_BASE_CODE_MODE
*Mode
;
1180 EFI_DHCP4_PROTOCOL
*Dhcp4
;
1181 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token
;
1187 EFI_DHCP4_LISTEN_POINT ListenPoint
;
1188 EFI_DHCP4_PACKET
*Response
;
1189 EFI_DHCP4_PACKET_OPTION
*OptList
[PXEBC_DHCP4_MAX_OPTION_NUM
];
1191 EFI_DHCP4_PACKET_OPTION
*PxeOpt
;
1192 PXEBC_OPTION_BOOT_ITEM
*PxeBootItem
;
1194 EFI_DHCP4_HEADER
*DhcpHeader
;
1197 Mode
= Private
->PxeBc
.Mode
;
1198 Dhcp4
= Private
->Dhcp4
;
1199 Status
= EFI_SUCCESS
;
1201 ZeroMem (&Token
, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN
));
1203 if (DestIp
== NULL
) {
1204 Sport
= PXEBC_DHCP4_S_PORT
;
1207 Sport
= PXEBC_BS_DISCOVER_PORT
;
1211 if (!UseBis
&& Layer
!= NULL
) {
1212 *Layer
&= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK
;
1215 OptCount
= PxeBcBuildDhcpOptions (Private
, OptList
, FALSE
);
1218 ASSERT (Layer
!= NULL
);
1220 // Add vendor option of PXE_BOOT_ITEM
1222 VendorOptLen
= (UINT8
) ((sizeof (EFI_DHCP4_PACKET_OPTION
) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM
) + 1);
1223 OptList
[OptCount
] = AllocatePool (VendorOptLen
);
1224 if (OptList
[OptCount
] == NULL
) {
1225 return EFI_OUT_OF_RESOURCES
;
1228 OptList
[OptCount
]->OpCode
= PXEBC_DHCP4_TAG_VENDOR
;
1229 OptList
[OptCount
]->Length
= (UINT8
) (VendorOptLen
- 2);
1230 PxeOpt
= (EFI_DHCP4_PACKET_OPTION
*) OptList
[OptCount
]->Data
;
1231 PxeOpt
->OpCode
= PXEBC_VENDOR_TAG_BOOT_ITEM
;
1232 PxeOpt
->Length
= (UINT8
) sizeof (PXEBC_OPTION_BOOT_ITEM
);
1233 PxeBootItem
= (PXEBC_OPTION_BOOT_ITEM
*) PxeOpt
->Data
;
1234 PxeBootItem
->Type
= HTONS (Type
);
1235 PxeBootItem
->Layer
= HTONS (*Layer
);
1236 PxeOpt
->Data
[PxeOpt
->Length
] = PXEBC_DHCP4_TAG_EOP
;
1241 Status
= Dhcp4
->Build (Dhcp4
, &Private
->SeedPacket
, 0, NULL
, OptCount
, OptList
, &Token
.Packet
);
1244 FreePool (OptList
[OptCount
- 1]);
1247 if (EFI_ERROR (Status
)) {
1251 DhcpHeader
= &Token
.Packet
->Dhcp4
.Header
;
1252 if (Mode
->SendGUID
) {
1253 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID
*) DhcpHeader
->ClientHwAddr
))) {
1255 // GUID not yet set - send all 0's to show not programable
1257 ZeroMem (DhcpHeader
->ClientHwAddr
, sizeof (EFI_GUID
));
1260 DhcpHeader
->HwAddrLen
= (UINT8
) sizeof (EFI_GUID
);
1263 Xid
= NET_RANDOM (NetRandomInitSeed ());
1264 Token
.Packet
->Dhcp4
.Header
.Xid
= HTONL(Xid
);
1265 Token
.Packet
->Dhcp4
.Header
.Reserved
= HTONS((UINT16
) ((IsBCast
) ? 0x8000 : 0));
1266 CopyMem (&Token
.Packet
->Dhcp4
.Header
.ClientAddr
, &Private
->StationIp
, sizeof (EFI_IPv4_ADDRESS
));
1268 Token
.RemotePort
= Sport
;
1271 SetMem (&Token
.RemoteAddress
, sizeof (EFI_IPv4_ADDRESS
), 0xff);
1273 CopyMem (&Token
.RemoteAddress
, DestIp
, sizeof (EFI_IPv4_ADDRESS
));
1276 CopyMem (&Token
.GatewayAddress
, &Private
->GatewayIp
, sizeof (EFI_IPv4_ADDRESS
));
1279 Token
.ListenPointCount
= 1;
1280 Token
.ListenPoints
= &ListenPoint
;
1281 Token
.ListenPoints
[0].ListenPort
= PXEBC_BS_DISCOVER_PORT
;
1282 CopyMem (&Token
.ListenPoints
[0].ListenAddress
, &Private
->StationIp
, sizeof(EFI_IPv4_ADDRESS
));
1283 CopyMem (&Token
.ListenPoints
[0].SubnetMask
, &Private
->SubnetMask
, sizeof(EFI_IPv4_ADDRESS
));
1286 // Send Pxe Discover
1288 for (TryIndex
= 1; TryIndex
<= PXEBC_BOOT_REQUEST_RETRIES
; TryIndex
++) {
1290 Token
.TimeoutValue
= (UINT16
) (PXEBC_BOOT_REQUEST_TIMEOUT
* TryIndex
);
1291 Token
.Packet
->Dhcp4
.Header
.Seconds
= (UINT16
) (PXEBC_BOOT_REQUEST_TIMEOUT
* (TryIndex
- 1));
1293 Status
= Dhcp4
->TransmitReceive (Dhcp4
, &Token
);
1295 if (Token
.Status
!= EFI_TIMEOUT
) {
1300 if (TryIndex
> PXEBC_BOOT_REQUEST_RETRIES
) {
1302 // No server response our PXE request
1304 Status
= EFI_TIMEOUT
;
1307 if (!EFI_ERROR (Status
)) {
1313 Response
= Token
.ResponseList
;
1315 while (RepIndex
< Token
.ResponseCount
) {
1317 while (SrvIndex
< IpCount
) {
1319 if (SrvList
[SrvIndex
].AcceptAnyResponse
) {
1323 if ((SrvList
[SrvIndex
].Type
== Type
) && EFI_IP4_EQUAL (&(Response
->Dhcp4
.Header
.ServerAddr
), &(Private
->ServerIp
))) {
1330 if ((IpCount
!= SrvIndex
) || (IpCount
== 0)) {
1337 Response
= (EFI_DHCP4_PACKET
*) ((UINT8
*) Response
+ Response
->Size
);
1340 if (RepIndex
< Token
.ResponseCount
) {
1342 if (Reply
!= NULL
) {
1343 PxeBcCopyEfiDhcp4Packet (Reply
, Response
);
1347 CopyMem (&(Mode
->PxeDiscover
), &(Token
.Packet
->Dhcp4
), Token
.Packet
->Length
);
1348 Mode
->PxeDiscoverValid
= TRUE
;
1350 CopyMem (Mode
->PxeReply
.Raw
, &Response
->Dhcp4
, Response
->Length
);
1351 Mode
->PxeReplyReceived
= TRUE
;
1354 Status
= EFI_NOT_FOUND
;
1358 // free the responselist
1360 if (Token
.ResponseList
!= NULL
) {
1361 FreePool (Token
.ResponseList
);
1365 // Free the dhcp packet
1367 FreePool (Token
.Packet
);
1374 Parse interested dhcp options.
1376 @param Buffer Pointer to the dhcp options packet.
1377 @param Length The length of the dhcp options.
1378 @param OptTag The option OpCode.
1380 @return NULL if the buffer length is 0 and OpCode is not
1381 PXEBC_DHCP4_TAG_EOP, or the pointer to the buffer.
1384 EFI_DHCP4_PACKET_OPTION
*
1385 PxeBcParseExtendOptions (
1391 EFI_DHCP4_PACKET_OPTION
*Option
;
1394 Option
= (EFI_DHCP4_PACKET_OPTION
*) Buffer
;
1397 while (Offset
< Length
&& Option
->OpCode
!= PXEBC_DHCP4_TAG_EOP
) {
1399 if (Option
->OpCode
== OptTag
) {
1404 if (Option
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1407 Offset
+= Option
->Length
+ 2;
1410 Option
= (EFI_DHCP4_PACKET_OPTION
*) (Buffer
+ Offset
);
1418 This function is to parse and check vendor options.
1420 @param Dhcp4Option Pointer to dhcp options
1421 @param VendorOption Pointer to vendor options
1423 @return TRUE if valid for vendor options, or FALSE.
1427 PxeBcParseVendorOptions (
1428 IN EFI_DHCP4_PACKET_OPTION
*Dhcp4Option
,
1429 IN PXEBC_VENDOR_OPTION
*VendorOption
1433 UINT8 VendorOptionLen
;
1434 EFI_DHCP4_PACKET_OPTION
*PxeOption
;
1437 BitMap
= VendorOption
->BitMap
;
1438 VendorOptionLen
= Dhcp4Option
->Length
;
1439 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) &Dhcp4Option
->Data
[0];
1442 while ((Offset
< VendorOptionLen
) && (PxeOption
->OpCode
!= PXEBC_DHCP4_TAG_EOP
)) {
1444 // Parse every Vendor Option and set its BitMap
1446 switch (PxeOption
->OpCode
) {
1448 case PXEBC_VENDOR_TAG_MTFTP_IP
:
1450 CopyMem (&VendorOption
->MtftpIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1453 case PXEBC_VENDOR_TAG_MTFTP_CPORT
:
1455 CopyMem (&VendorOption
->MtftpCPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpCPort
));
1458 case PXEBC_VENDOR_TAG_MTFTP_SPORT
:
1460 CopyMem (&VendorOption
->MtftpSPort
, PxeOption
->Data
, sizeof (VendorOption
->MtftpSPort
));
1463 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT
:
1465 VendorOption
->MtftpTimeout
= *PxeOption
->Data
;
1468 case PXEBC_VENDOR_TAG_MTFTP_DELAY
:
1470 VendorOption
->MtftpDelay
= *PxeOption
->Data
;
1473 case PXEBC_VENDOR_TAG_DISCOVER_CTRL
:
1475 VendorOption
->DiscoverCtrl
= *PxeOption
->Data
;
1478 case PXEBC_VENDOR_TAG_DISCOVER_MCAST
:
1480 CopyMem (&VendorOption
->DiscoverMcastIp
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1483 case PXEBC_VENDOR_TAG_BOOT_SERVERS
:
1485 VendorOption
->BootSvrLen
= PxeOption
->Length
;
1486 VendorOption
->BootSvr
= (PXEBC_BOOT_SVR_ENTRY
*) PxeOption
->Data
;
1489 case PXEBC_VENDOR_TAG_BOOT_MENU
:
1491 VendorOption
->BootMenuLen
= PxeOption
->Length
;
1492 VendorOption
->BootMenu
= (PXEBC_BOOT_MENU_ENTRY
*) PxeOption
->Data
;
1495 case PXEBC_VENDOR_TAG_MENU_PROMPT
:
1497 VendorOption
->MenuPromptLen
= PxeOption
->Length
;
1498 VendorOption
->MenuPrompt
= (PXEBC_MENU_PROMPT
*) PxeOption
->Data
;
1501 case PXEBC_VENDOR_TAG_MCAST_ALLOC
:
1503 CopyMem (&VendorOption
->McastIpBase
, PxeOption
->Data
, sizeof (EFI_IPv4_ADDRESS
));
1504 CopyMem (&VendorOption
->McastIpBlock
, PxeOption
->Data
+ 4, sizeof (VendorOption
->McastIpBlock
));
1505 CopyMem (&VendorOption
->McastIpRange
, PxeOption
->Data
+ 6, sizeof (VendorOption
->McastIpRange
));
1508 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES
:
1510 VendorOption
->CredTypeLen
= PxeOption
->Length
;
1511 VendorOption
->CredType
= (UINT32
*) PxeOption
->Data
;
1514 case PXEBC_VENDOR_TAG_BOOT_ITEM
:
1516 CopyMem (&VendorOption
->BootSrvType
, PxeOption
->Data
, sizeof (VendorOption
->BootSrvType
));
1517 CopyMem (&VendorOption
->BootSrvLayer
, PxeOption
->Data
+ 2, sizeof (VendorOption
->BootSrvLayer
));
1521 SET_VENDOR_OPTION_BIT_MAP (BitMap
, PxeOption
->OpCode
);
1523 if (PxeOption
->OpCode
== PXEBC_DHCP4_TAG_PAD
) {
1526 Offset
= (UINT8
) (Offset
+ PxeOption
->Length
+ 2);
1529 PxeOption
= (EFI_DHCP4_PACKET_OPTION
*) (Dhcp4Option
->Data
+ Offset
);
1533 // FixMe, return falas if invalid of any vendor option
1541 This function display boot item detail.
1543 If the length of the boot item string over 70 Char, just display 70 Char.
1545 @param Str Pointer to a string (boot item string).
1546 @param Len The length of string.
1550 PxeBcDisplayBootItem (
1557 Len
= (UINT8
) MIN (70, Len
);
1560 AsciiPrint ("%a \n", Str
);
1566 Choose the boot prompt.
1568 @param Private Pointer to PxeBc private data.
1570 @retval EFI_SUCCESS Select boot prompt done.
1571 @retval EFI_TIMEOUT Select boot prompt time out.
1572 @retval EFI_NOT_FOUND The proxy offer is not Pxe10.
1573 @retval EFI_ABORTED User cancel the operation.
1574 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1578 PxeBcSelectBootPrompt (
1579 IN PXEBC_PRIVATE_DATA
*Private
1582 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1583 PXEBC_VENDOR_OPTION
*VendorOpt
;
1584 EFI_EVENT TimeoutEvent
;
1585 EFI_EVENT DescendEvent
;
1586 EFI_INPUT_KEY InputKey
;
1594 TimeoutEvent
= NULL
;
1595 DescendEvent
= NULL
;
1597 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1599 Packet
= &Private
->ProxyOffer
;
1602 Packet
= &Private
->Dhcp4Ack
;
1605 if (Packet
->OfferType
!= DHCP4_PACKET_TYPE_PXE10
) {
1606 return EFI_NOT_FOUND
;
1609 VendorOpt
= &Packet
->PxeVendorOption
;
1611 // According to the PXE specification 2.1, Table 2-1 PXE DHCP Options (Full
1612 // List), we must not consider a boot prompt or boot menu if all of the
1614 // - the PXE_DISCOVERY_CONTROL PXE tag is present inside the Vendor Options
1615 // (=43) DHCP tag, and
1616 // - the PXE_DISCOVERY_CONTROL PXE tag has bit 3 set, and
1617 // - a boot file name has been presented with DHCP option 67.
1619 if (IS_DISABLE_PROMPT_MENU (VendorOpt
->DiscoverCtrl
) &&
1620 Packet
->Dhcp4Option
[PXEBC_DHCP4_TAG_INDEX_BOOTFILE
] != NULL
) {
1624 if (!IS_VALID_BOOT_PROMPT (VendorOpt
->BitMap
)) {
1628 Timeout
= VendorOpt
->MenuPrompt
->Timeout
;
1629 Prompt
= VendorOpt
->MenuPrompt
->Prompt
;
1630 PromptLen
= (UINT8
) (VendorOpt
->MenuPromptLen
- 1);
1636 if (Timeout
== 255) {
1640 Status
= gBS
->CreateEvent (
1648 if (EFI_ERROR (Status
)) {
1652 Status
= gBS
->SetTimer (
1655 Timeout
* TICKS_PER_SECOND
1658 if (EFI_ERROR (Status
)) {
1662 Status
= gBS
->CreateEvent (
1670 if (EFI_ERROR (Status
)) {
1674 Status
= gBS
->SetTimer (
1680 if (EFI_ERROR (Status
)) {
1684 SecCol
= gST
->ConOut
->Mode
->CursorColumn
;
1685 SecRow
= gST
->ConOut
->Mode
->CursorRow
;
1687 PxeBcDisplayBootItem (Prompt
, PromptLen
);
1689 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1690 AsciiPrint ("(%d) ", Timeout
--);
1692 while (EFI_ERROR (gBS
->CheckEvent (TimeoutEvent
))) {
1694 if (!EFI_ERROR (gBS
->CheckEvent (DescendEvent
))) {
1695 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, SecCol
+ PromptLen
, SecRow
);
1696 AsciiPrint ("(%d) ", Timeout
--);
1699 if (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1701 gBS
->Stall (10 * TICKS_PER_MS
);
1705 if (InputKey
.ScanCode
== 0) {
1707 switch (InputKey
.UnicodeChar
) {
1709 Status
= EFI_ABORTED
;
1715 Status
= EFI_TIMEOUT
;
1723 switch (InputKey
.ScanCode
) {
1725 Status
= EFI_TIMEOUT
;
1729 Status
= EFI_ABORTED
;
1740 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0 , SecRow
+ 1);
1744 if (DescendEvent
!= NULL
) {
1745 gBS
->CloseEvent (DescendEvent
);
1748 if (TimeoutEvent
!= NULL
) {
1749 gBS
->CloseEvent (TimeoutEvent
);
1757 Select the boot menu.
1759 @param Private Pointer to PxeBc private data.
1760 @param Type The type of the menu.
1761 @param UseDefaultItem Use default item or not.
1763 @retval EFI_ABORTED User cancel operation.
1764 @retval EFI_SUCCESS Select the boot menu success.
1765 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1769 PxeBcSelectBootMenu (
1770 IN PXEBC_PRIVATE_DATA
*Private
,
1772 IN BOOLEAN UseDefaultItem
1775 PXEBC_CACHED_DHCP4_PACKET
*Packet
;
1776 PXEBC_VENDOR_OPTION
*VendorOpt
;
1777 EFI_INPUT_KEY InputKey
;
1786 PXEBC_BOOT_MENU_ENTRY
*MenuItem
;
1787 PXEBC_BOOT_MENU_ENTRY
*MenuArray
[PXEBC_MAX_MENU_NUM
];
1794 if (Private
->PxeBc
.Mode
->ProxyOfferReceived
) {
1796 Packet
= &Private
->ProxyOffer
;
1799 Packet
= &Private
->Dhcp4Ack
;
1802 ASSERT (Packet
->OfferType
== DHCP4_PACKET_TYPE_PXE10
);
1804 VendorOpt
= &Packet
->PxeVendorOption
;
1806 if (!IS_VALID_BOOT_MENU (VendorOpt
->BitMap
)) {
1810 SetMem (Blank
, sizeof(Blank
), ' ');
1812 MenuSize
= VendorOpt
->BootMenuLen
;
1813 MenuItem
= VendorOpt
->BootMenu
;
1815 if (MenuSize
== 0) {
1816 return EFI_NOT_READY
;
1819 while (MenuSize
> 0) {
1820 MenuArray
[Index
++] = MenuItem
;
1821 MenuSize
= (UINT8
) (MenuSize
- (MenuItem
->DescLen
+ 3));
1822 MenuItem
= (PXEBC_BOOT_MENU_ENTRY
*) ((UINT8
*) MenuItem
+ MenuItem
->DescLen
+ 3);
1823 if (Index
>= PXEBC_MAX_MENU_NUM
) {
1828 if (UseDefaultItem
) {
1829 *Type
= MenuArray
[0]->Type
;
1830 *Type
= NTOHS (*Type
);
1836 for (Index
= 0; Index
< MenuNum
; Index
++) {
1837 PxeBcDisplayBootItem (MenuArray
[Index
]->DescStr
, MenuArray
[Index
]->DescLen
);
1840 TopRow
= gST
->ConOut
->Mode
->CursorRow
- MenuNum
;
1843 ASSERT (Select
< PXEBC_MAX_MENU_NUM
);
1845 // highlight selected row
1847 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_BLACK
, EFI_LIGHTGRAY
));
1848 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ Select
);
1849 Blank
[MenuArray
[Select
]->DescLen
] = 0;
1850 AsciiPrint ("%a\r", Blank
);
1851 PxeBcDisplayBootItem (MenuArray
[Select
]->DescStr
, MenuArray
[Select
]->DescLen
);
1852 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1853 LastSelect
= Select
;
1855 while (gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &InputKey
) == EFI_NOT_READY
) {
1856 gBS
->Stall (10 * TICKS_PER_MS
);
1859 if (InputKey
.ScanCode
!= 0) {
1860 switch (InputKey
.UnicodeChar
) {
1862 InputKey
.ScanCode
= SCAN_ESC
;
1865 case CTRL ('j'): /* linefeed */
1866 case CTRL ('m'): /* return */
1870 case CTRL ('i'): /* tab */
1874 InputKey
.ScanCode
= SCAN_DOWN
;
1877 case CTRL ('h'): /* backspace */
1880 InputKey
.ScanCode
= SCAN_UP
;
1884 InputKey
.ScanCode
= 0;
1888 switch (InputKey
.ScanCode
) {
1899 if (++Select
== MenuNum
) {
1910 case SCAN_PAGE_DOWN
:
1912 Select
= (UINT16
) (MenuNum
- 1);
1919 /* unhighlight last selected row */
1920 gST
->ConOut
->SetAttribute (gST
->ConOut
, EFI_TEXT_ATTR (EFI_LIGHTGRAY
, EFI_BLACK
));
1921 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ LastSelect
);
1922 Blank
[MenuArray
[LastSelect
]->DescLen
] = 0;
1923 AsciiPrint ("%a\r", Blank
);
1924 PxeBcDisplayBootItem (MenuArray
[LastSelect
]->DescStr
, MenuArray
[LastSelect
]->DescLen
);
1925 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, TopRow
+ MenuNum
);
1928 ASSERT (Select
< PXEBC_MAX_MENU_NUM
);
1931 // Swap the byte order
1933 CopyMem (Type
, &MenuArray
[Select
]->Type
, sizeof (UINT16
));
1934 *Type
= NTOHS (*Type
);