]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove ASSERT and change to if ()
[mirror_edk2.git] / MdeModulePkg / Universal / Network / UefiPxeBcDxe / PxeBcDhcp.c
1 /** @file
2 Support for PxeBc dhcp functions.
3
4 Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15
16 #include "PxeBcImpl.h"
17
18 //
19 // This is a map from the interested DHCP4 option tags' index to the tag value.
20 //
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
29 };
30
31
32 /**
33 This function initialize the DHCP4 message instance.
34
35 This function will pad each item of dhcp4 message packet.
36
37 @param Seed Pointer to the message instance of the DHCP4 packet.
38 @param Udp4 Pointer to the EFI_UDP4_PROTOCOL instance.
39
40 **/
41 VOID
42 PxeBcInitSeedPacket (
43 IN EFI_DHCP4_PACKET *Seed,
44 IN EFI_UDP4_PROTOCOL *Udp4
45 )
46 {
47 EFI_SIMPLE_NETWORK_MODE Mode;
48 EFI_DHCP4_HEADER *Header;
49
50 Udp4->GetModeData (Udp4, NULL, NULL, NULL, &Mode);
51
52 Seed->Size = sizeof (EFI_DHCP4_PACKET);
53 Seed->Length = sizeof (Seed->Dhcp4);
54
55 Header = &Seed->Dhcp4.Header;
56
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);
62
63 Seed->Dhcp4.Magik = PXEBC_DHCP4_MAGIC;
64 Seed->Dhcp4.Option[0] = PXEBC_DHCP4_TAG_EOP;
65 }
66
67
68 /**
69 Copy the DCHP4 packet from srouce to destination.
70
71 @param Dst Pointer to the EFI_DHCP4_PROTOCOL instance.
72 @param Src Pointer to the EFI_DHCP4_PROTOCOL instance.
73
74 **/
75 VOID
76 PxeBcCopyEfiDhcp4Packet (
77 IN EFI_DHCP4_PACKET *Dst,
78 IN EFI_DHCP4_PACKET *Src
79 )
80 {
81 ASSERT (Dst->Size >= Src->Length);
82
83 CopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);
84 Dst->Length = Src->Length;
85 }
86
87
88 /**
89 Copy the dhcp4 packet to the PxeBc private data and parse the dhcp4 packet.
90
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.
94
95 **/
96 VOID
97 PxeBcCopyProxyOffer (
98 IN PXEBC_PRIVATE_DATA *Private,
99 IN UINT32 OfferIndex
100 )
101 {
102 EFI_PXE_BASE_CODE_MODE *Mode;
103 EFI_DHCP4_PACKET *Offer;
104
105 ASSERT (OfferIndex < Private->NumOffers);
106 ASSERT (OfferIndex < PXEBC_MAX_OFFER_NUM);
107
108 Mode = Private->PxeBc.Mode;
109 Offer = &Private->Dhcp4Offers[OfferIndex].Packet.Offer;
110
111 PxeBcCopyEfiDhcp4Packet (&Private->ProxyOffer.Packet.Offer, Offer);
112 CopyMem (&Mode->ProxyOffer, &Offer->Dhcp4, Offer->Length);
113 Mode->ProxyOfferReceived = TRUE;
114
115 PxeBcParseCachedDhcpPacket (&Private->ProxyOffer);
116 }
117
118
119 /**
120 Parse the cached dhcp packet.
121
122 @param CachedPacket Pointer to cached dhcp packet.
123
124 @retval TRUE Succeed to parse and validation.
125 @retval FALSE Fail to parse or validation.
126
127 **/
128 BOOLEAN
129 PxeBcParseCachedDhcpPacket (
130 IN PXEBC_CACHED_DHCP4_PACKET *CachedPacket
131 )
132 {
133 EFI_DHCP4_PACKET *Offer;
134 EFI_DHCP4_PACKET_OPTION **Options;
135 EFI_DHCP4_PACKET_OPTION *Option;
136 UINT8 OfferType;
137 UINTN Index;
138 UINT8 *Ptr8;
139
140 CachedPacket->IsPxeOffer = FALSE;
141 ZeroMem (CachedPacket->Dhcp4Option, sizeof (CachedPacket->Dhcp4Option));
142 ZeroMem (&CachedPacket->PxeVendorOption, sizeof (CachedPacket->PxeVendorOption));
143
144 Offer = &CachedPacket->Packet.Offer;
145 Options = CachedPacket->Dhcp4Option;
146
147 //
148 // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
149 //
150 for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
151 Options[Index] = PxeBcParseExtendOptions (
152 Offer->Dhcp4.Option,
153 GET_OPTION_BUFFER_LEN (Offer),
154 mInterestedDhcp4Tags[Index]
155 );
156 }
157
158 //
159 // Check whether is an offer with PXEClient or not.
160 //
161 Option = Options[PXEBC_DHCP4_TAG_INDEX_CLASS_ID];
162 if ((Option != NULL) && (Option->Length >= 9) &&
163 (CompareMem (Option->Data, DEFAULT_CLASS_ID_DATA, 9) == 0)) {
164
165 CachedPacket->IsPxeOffer = TRUE;
166 }
167
168 //
169 // Parse pxe vendor options and store their content/pointers in CachedPacket->PxeVendorOption.
170 //
171 Option = Options[PXEBC_DHCP4_TAG_INDEX_VENDOR];
172 if (CachedPacket->IsPxeOffer && (Option != NULL)) {
173
174 if (!PxeBcParseVendorOptions (Option, &CachedPacket->PxeVendorOption)) {
175 return FALSE;
176 }
177 }
178
179 //
180 // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).
181 // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/
182 // serverhostname option.
183 //
184 Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];
185 if ((Option != NULL) && ((Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) != 0)) {
186
187 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseExtendOptions (
188 (UINT8 *) Offer->Dhcp4.Header.BootFileName,
189 sizeof (Offer->Dhcp4.Header.BootFileName),
190 PXEBC_DHCP4_TAG_BOOTFILE
191 );
192 //
193 // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null
194 // terminated string. So force to append null terminated character at the end of string.
195 //
196 if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
197 Ptr8 = (UINT8*)&Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];
198 Ptr8 += Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Length;
199 *Ptr8 = '\0';
200 }
201
202 } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&
203 (Offer->Dhcp4.Header.BootFileName[0] != 0)) {
204 //
205 // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
206 // And do not count dhcp option header, or else will destory the serverhostname.
207 //
208 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -
209 OFFSET_OF (EFI_DHCP4_PACKET_OPTION, Data[0]));
210
211 }
212
213 //
214 // Determine offer type of the dhcp packet.
215 //
216 Option = Options[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE];
217 if ((Option == NULL) || (Option->Data[0] == 0)) {
218 //
219 // It's a bootp offer
220 //
221 Option = CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE];
222 if (Option == NULL) {
223 //
224 // bootp offer without bootfilename, discard it.
225 //
226 return FALSE;
227 }
228
229 OfferType = DHCP4_PACKET_TYPE_BOOTP;
230
231 } else {
232
233 if (IS_VALID_DISCOVER_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
234 //
235 // It's a pxe10 offer with PXEClient and discover vendor option.
236 //
237 OfferType = DHCP4_PACKET_TYPE_PXE10;
238 } else if (IS_VALID_MTFTP_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
239 //
240 // It's a wfm11a offer with PXEClient and mtftp vendor option, and
241 // return false since mtftp not supported currently.
242 //
243 return FALSE;
244 } else {
245 //
246 // If the binl offer with only PXEClient.
247 //
248 OfferType = (UINT8) ((CachedPacket->IsPxeOffer) ? DHCP4_PACKET_TYPE_BINL : DHCP4_PACKET_TYPE_DHCP_ONLY);
249 }
250 }
251
252 CachedPacket->OfferType = OfferType;
253
254 return TRUE;
255 }
256
257
258 /**
259 Offer dhcp service with a BINL dhcp offer.
260
261 @param Private Pointer to PxeBc private data.
262 @param Index Index of cached packets as complements of pxe mode data,
263 the index is maximum offer number.
264
265 @retval TRUE Offer the service successfully under priority BINL.
266 @retval FALSE Boot Service failed, parse cached dhcp packet failed or this
267 BINL ack cannot find options set or bootfile name specified.
268
269 **/
270 BOOLEAN
271 PxeBcTryBinl (
272 IN PXEBC_PRIVATE_DATA *Private,
273 IN UINT32 Index
274 )
275 {
276 EFI_DHCP4_PACKET *Offer;
277 EFI_IP_ADDRESS ServerIp;
278 EFI_STATUS Status;
279 PXEBC_CACHED_DHCP4_PACKET *CachedPacket;
280 EFI_DHCP4_PACKET *Reply;
281
282 ASSERT (Index < PXEBC_MAX_OFFER_NUM);
283 ASSERT (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL);
284
285 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
286
287 //
288 // Use siaddr(next server) in DHCPOFFER packet header, if zero, use option 54(server identifier)
289 // in DHCPOFFER packet.
290 // (It does not comply with PXE Spec, Ver2.1)
291 //
292 if (EFI_IP4_EQUAL (&Offer->Dhcp4.Header.ServerAddr.Addr, &mZeroIp4Addr)) {
293 CopyMem (
294 &ServerIp.Addr[0],
295 Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,
296 sizeof (EFI_IPv4_ADDRESS)
297 );
298 } else {
299 CopyMem (
300 &ServerIp.Addr[0],
301 &Offer->Dhcp4.Header.ServerAddr,
302 sizeof (EFI_IPv4_ADDRESS)
303 );
304 }
305 if (ServerIp.Addr[0] == 0) {
306 return FALSE;
307 }
308
309 CachedPacket = &Private->ProxyOffer;
310 Reply = &CachedPacket->Packet.Offer;
311
312 Status = PxeBcDiscvBootService (
313 Private,
314 0,
315 NULL,
316 FALSE,
317 &ServerIp,
318 0,
319 NULL,
320 FALSE,
321 Reply
322 );
323 if (EFI_ERROR (Status)) {
324 return FALSE;
325 }
326
327 if (!PxeBcParseCachedDhcpPacket (CachedPacket)) {
328 return FALSE;
329 }
330
331 if ((CachedPacket->OfferType != DHCP4_PACKET_TYPE_PXE10) &&
332 (CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {
333 //
334 // This BINL ack doesn't have discovery options set or bootfile name
335 // specified.
336 //
337 return FALSE;
338 }
339
340 Private->PxeBc.Mode->ProxyOfferReceived = TRUE;
341 CopyMem (&Private->PxeBc.Mode->ProxyOffer, &Reply->Dhcp4, Reply->Length);
342
343 return TRUE;
344 }
345
346
347 /**
348 Offer dhcp service for each proxy with a BINL dhcp offer.
349
350 @param Private Pointer to PxeBc private data
351 @param OfferIndex Pointer to the index of cached packets as complements of
352 pxe mode data, the index is maximum offer number.
353
354 @return If there is no service needed offer return FALSE, otherwise TRUE.
355
356 **/
357 BOOLEAN
358 PxeBcTryBinlProxy (
359 IN PXEBC_PRIVATE_DATA *Private,
360 OUT UINT32 *OfferIndex
361 )
362 {
363 UINT32 Index;
364
365 for (Index = 0; Index < Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]; Index++) {
366
367 *OfferIndex = Private->BinlIndex[Index];
368 //
369 // Try this BINL proxy offer
370 //
371 if (PxeBcTryBinl (Private, *OfferIndex)) {
372 return TRUE;
373 }
374 }
375
376 return FALSE;
377 }
378
379
380 /**
381 This function is to check the selected proxy offer (include BINL dhcp offer and
382 DHCP_ONLY offer ) and set the flag and copy the DHCP packets to the Pxe base code
383 mode structure.
384
385 @param Private Pointer to PxeBc private data.
386
387 @retval EFI_SUCCESS Operational successful.
388 @retval EFI_NO_RESPONSE Offer dhcp service failed.
389
390 **/
391 EFI_STATUS
392 PxeBcCheckSelectedOffer (
393 IN PXEBC_PRIVATE_DATA *Private
394 )
395 {
396 PXEBC_CACHED_DHCP4_PACKET *SelectedOffer;
397 EFI_DHCP4_PACKET_OPTION **Options;
398 UINT32 Index;
399 EFI_DHCP4_PACKET *Offer;
400 UINT32 ProxyOfferIndex;
401 EFI_STATUS Status;
402 EFI_PXE_BASE_CODE_MODE *Mode;
403 EFI_DHCP4_PACKET *Ack;
404
405 ASSERT (Private->SelectedOffer != 0);
406
407 Status = EFI_SUCCESS;
408 SelectedOffer = &Private->Dhcp4Offers[Private->SelectedOffer - 1];
409 Options = SelectedOffer->Dhcp4Option;
410
411 if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BINL) {
412 //
413 // The addresses are acquired from a BINL dhcp offer, try BINL to get
414 // the bootfile name
415 //
416 if (!PxeBcTryBinl (Private, Private->SelectedOffer - 1)) {
417 Status = EFI_NO_RESPONSE;
418 }
419 } else if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) {
420 //
421 // The selected offer to finish the D.O.R.A. is a DHCP only offer, we need
422 // try proxy offers if there are some, othewise the bootfile name must be
423 // set in this DHCP only offer.
424 //
425 if (Private->GotProxyOffer) {
426 //
427 // Get rid of the compiler warning.
428 //
429 ProxyOfferIndex = 0;
430 if (Private->SortOffers) {
431 //
432 // The offers are sorted before selecting, the proxy offer type must be
433 // already determined.
434 //
435 ASSERT (Private->ProxyIndex[Private->ProxyOfferType] > 0);
436
437 if (Private->ProxyOfferType == DHCP4_PACKET_TYPE_BINL) {
438 //
439 // We buffer all received BINL proxy offers, try them all one by one
440 //
441 if (!PxeBcTryBinlProxy (Private, &ProxyOfferIndex)) {
442 Status = EFI_NO_RESPONSE;
443 }
444 } else {
445 //
446 // For other types, only one proxy offer is buffered.
447 //
448 ProxyOfferIndex = Private->ProxyIndex[Private->ProxyOfferType] - 1;
449 }
450 } else {
451 //
452 // The proxy offer type is not determined, choose proxy offer in the
453 // received order.
454 //
455 Status = EFI_NO_RESPONSE;
456
457 for (Index = 0; Index < Private->NumOffers; Index++) {
458
459 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
460 if (!IS_PROXY_DHCP_OFFER (Offer)) {
461 //
462 // Skip non proxy dhcp offers.
463 //
464 continue;
465 }
466
467 if (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL) {
468 //
469 // Try BINL
470 //
471 if (!PxeBcTryBinl (Private, Index)) {
472 //
473 // Failed, skip to the next offer
474 //
475 continue;
476 }
477 }
478
479 Private->ProxyOfferType = Private->Dhcp4Offers[Index].OfferType;
480 ProxyOfferIndex = Index;
481 Status = EFI_SUCCESS;
482 break;
483 }
484 }
485
486 if (!EFI_ERROR (Status) && (Private->ProxyOfferType != DHCP4_PACKET_TYPE_BINL)) {
487 //
488 // Copy the proxy offer to Mode and set the flag
489 //
490 PxeBcCopyProxyOffer (Private, ProxyOfferIndex);
491 }
492 } else {
493 //
494 // No proxy offer is received, the bootfile name MUST be set.
495 //
496 ASSERT (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL);
497 }
498 }
499
500 if (!EFI_ERROR (Status)) {
501 //
502 // Everything is OK, set the flag and copy the DHCP packets.
503 //
504 Mode = Private->PxeBc.Mode;
505 Offer = &SelectedOffer->Packet.Offer;
506
507 //
508 // The discover packet is already copied, just set flag here.
509 //
510 Mode->DhcpDiscoverValid = TRUE;
511
512 Ack = &Private->Dhcp4Ack.Packet.Ack;
513 if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BOOTP) {
514 //
515 // Other type of ACK is already cached. Bootp is special that we should
516 // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
517 //
518 PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Offer);
519 }
520
521 PxeBcParseCachedDhcpPacket (&Private->Dhcp4Ack);
522
523 Mode->DhcpAckReceived = TRUE;
524
525 //
526 // Copy the dhcp ack.
527 //
528 CopyMem (&Mode->DhcpAck, &Ack->Dhcp4, Ack->Length);
529 }
530
531 return Status;
532 }
533
534
535 /**
536 Cache the Dhcp4 packet offer, Parse and validate each option of the packet.
537
538 @param Private Pointer to PxeBc private data.
539 @param RcvdOffer Pointer to the received Dhcp proxy offer packet.
540
541 **/
542 VOID
543 PxeBcCacheDhcpOffer (
544 IN PXEBC_PRIVATE_DATA *Private,
545 IN EFI_DHCP4_PACKET *RcvdOffer
546 )
547 {
548 PXEBC_CACHED_DHCP4_PACKET *CachedOffer;
549 EFI_DHCP4_PACKET *Offer;
550 UINT8 OfferType;
551
552 CachedOffer = &Private->Dhcp4Offers[Private->NumOffers];
553 Offer = &CachedOffer->Packet.Offer;
554
555 //
556 // Cache the orignal dhcp packet
557 //
558 PxeBcCopyEfiDhcp4Packet (Offer, RcvdOffer);
559
560 //
561 // Parse and validate the options (including dhcp option and vendor option)
562 //
563 if (!PxeBcParseCachedDhcpPacket (CachedOffer)) {
564 return ;
565 }
566
567 OfferType = CachedOffer->OfferType;
568 ASSERT (OfferType < DHCP4_PACKET_TYPE_MAX);
569
570 if (OfferType == DHCP4_PACKET_TYPE_BOOTP) {
571
572 if (Private->BootpIndex != 0) {
573 //
574 // Only cache the first bootp offer, discard others.
575 //
576 return ;
577 } else {
578 //
579 // Take as a dhcp only offer, but record index specifically.
580 //
581 Private->BootpIndex = Private->NumOffers + 1;
582 }
583 } else {
584
585 if (IS_PROXY_DHCP_OFFER (Offer)) {
586 //
587 // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
588 //
589 Private->GotProxyOffer = TRUE;
590
591 if (OfferType == DHCP4_PACKET_TYPE_BINL) {
592 //
593 // Cache all binl offers.
594 //
595 Private->BinlIndex[Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]] = Private->NumOffers;
596 Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]++;
597 } else if (Private->ProxyIndex[OfferType] != 0) {
598 //
599 // Only cache the first pxe10/wfm11a offers each, discard the others.
600 //
601 return ;
602 } else {
603 //
604 // Record index of the proxy dhcp offer with type other than binl.
605 //
606 Private->ProxyIndex[OfferType] = Private->NumOffers + 1;
607 }
608 } else {
609 //
610 // It's a dhcp offer with your address.
611 //
612 ASSERT (Private->ServerCount[OfferType] < PXEBC_MAX_OFFER_NUM);
613 Private->OfferIndex[OfferType][Private->ServerCount[OfferType]] = Private->NumOffers;
614 Private->ServerCount[OfferType]++;
615 }
616 }
617
618 //
619 // Count the accepted offers.
620 //
621 Private->NumOffers++;
622 }
623
624
625 /**
626 Select the specified proxy offer, such as BINL, DHCP_ONLY and so on.
627 If the proxy does not exist, try offers with bootfile.
628
629 @param Private Pointer to PxeBc private data.
630
631 **/
632 VOID
633 PxeBcSelectOffer (
634 IN PXEBC_PRIVATE_DATA *Private
635 )
636 {
637 UINT32 Index;
638 UINT32 OfferIndex;
639 EFI_DHCP4_PACKET *Offer;
640
641 Private->SelectedOffer = 0;
642
643 if (Private->SortOffers) {
644 //
645 // Select offer according to the priority
646 //
647 if (Private->ServerCount[DHCP4_PACKET_TYPE_PXE10] > 0) {
648 //
649 // DHCP with PXE10
650 //
651 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_PXE10][0] + 1;
652
653 } else if (Private->ServerCount[DHCP4_PACKET_TYPE_WFM11A] > 0) {
654 //
655 // DHCP with WfM
656 //
657 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_WFM11A][0] + 1;
658
659 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_PXE10] > 0) &&
660 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
661 ) {
662 //
663 // DHCP only and proxy DHCP with PXE10
664 //
665 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
666 Private->ProxyOfferType = DHCP4_PACKET_TYPE_PXE10;
667
668 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_WFM11A] > 0) &&
669 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
670 ) {
671 //
672 // DHCP only and proxy DHCP with WfM
673 //
674 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
675 Private->ProxyOfferType = DHCP4_PACKET_TYPE_WFM11A;
676
677 } else if (Private->ServerCount[DHCP4_PACKET_TYPE_BINL] > 0) {
678 //
679 // DHCP with BINL
680 //
681 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_BINL][0] + 1;
682
683 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL] > 0) &&
684 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
685 ) {
686 //
687 // DHCP only and proxy DHCP with BINL
688 //
689 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
690 Private->ProxyOfferType = DHCP4_PACKET_TYPE_BINL;
691
692 } else {
693 //
694 // Try offers with bootfile
695 //
696 for (Index = 0; Index < Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY]; Index++) {
697 //
698 // Select the first DHCP only offer with bootfile
699 //
700 OfferIndex = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][Index];
701 if (Private->Dhcp4Offers[OfferIndex].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
702 Private->SelectedOffer = OfferIndex + 1;
703 break;
704 }
705 }
706
707 if (Private->SelectedOffer == 0) {
708 //
709 // Select the Bootp reply with bootfile if any
710 //
711 Private->SelectedOffer = Private->BootpIndex;
712 }
713 }
714 } else {
715 //
716 // Try the offers in the received order.
717 //
718 for (Index = 0; Index < Private->NumOffers; Index++) {
719
720 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
721
722 if (IS_PROXY_DHCP_OFFER (Offer)) {
723 //
724 // Skip proxy offers
725 //
726 continue;
727 }
728
729 if ((Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&
730 ((!Private->GotProxyOffer) && (Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL))) {
731 //
732 // DHCP only offer but no proxy offer received and no bootfile option in this offer
733 //
734 continue;
735 }
736
737 Private->SelectedOffer = Index + 1;
738 break;
739 }
740 }
741 }
742
743
744 /**
745 Callback routine.
746
747 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
748 to intercept events that occurred in the configuration process. This structure
749 provides advanced control of each state transition of the DHCP process. The
750 returned status code determines the behavior of the EFI DHCPv4 Protocol driver.
751 There are three possible returned values, which are described in the following
752 table.
753
754 @param This Pointer to the EFI DHCPv4 Protocol instance that is used to
755 configure this callback function.
756 @param Context Pointer to the context that is initialized by
757 EFI_DHCP4_PROTOCOL.Configure().
758 @param CurrentState The current operational state of the EFI DHCPv4 Protocol
759 driver.
760 @param Dhcp4Event The event that occurs in the current state, which usually means a
761 state transition.
762 @param Packet The DHCP packet that is going to be sent or already received.
763 @param NewPacket The packet that is used to replace the above Packet.
764
765 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
766 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
767 driver will continue to wait for more DHCPOFFER packets until the retry
768 timeout expires.
769 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process and
770 return to the Dhcp4Init or Dhcp4InitReboot state.
771
772 **/
773 EFI_STATUS
774 EFIAPI
775 PxeBcDhcpCallBack (
776 IN EFI_DHCP4_PROTOCOL * This,
777 IN VOID *Context,
778 IN EFI_DHCP4_STATE CurrentState,
779 IN EFI_DHCP4_EVENT Dhcp4Event,
780 IN EFI_DHCP4_PACKET * Packet OPTIONAL,
781 OUT EFI_DHCP4_PACKET **NewPacket OPTIONAL
782 )
783 {
784 PXEBC_PRIVATE_DATA *Private;
785 EFI_PXE_BASE_CODE_MODE *Mode;
786 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;
787 EFI_DHCP4_PACKET_OPTION *MaxMsgSize;
788 UINT16 Value;
789 EFI_STATUS Status;
790 BOOLEAN Received;
791 CHAR8 *SystemSerialNumber;
792 EFI_DHCP4_HEADER *DhcpHeader;
793
794 if ((Dhcp4Event != Dhcp4RcvdOffer) &&
795 (Dhcp4Event != Dhcp4SelectOffer) &&
796 (Dhcp4Event != Dhcp4SendDiscover) &&
797 (Dhcp4Event != Dhcp4RcvdAck) &&
798 (Dhcp4Event != Dhcp4SendRequest)) {
799 return EFI_SUCCESS;
800 }
801
802 Private = (PXEBC_PRIVATE_DATA *) Context;
803 Mode = Private->PxeBc.Mode;
804 Callback = Private->PxeBcCallback;
805
806 //
807 // Override the Maximum DHCP Message Size.
808 //
809 MaxMsgSize = PxeBcParseExtendOptions (
810 Packet->Dhcp4.Option,
811 GET_OPTION_BUFFER_LEN (Packet),
812 PXEBC_DHCP4_TAG_MAXMSG
813 );
814 if (MaxMsgSize != NULL) {
815 Value = HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE);
816 CopyMem (MaxMsgSize->Data, &Value, sizeof (Value));
817 }
818
819 if ((Dhcp4Event != Dhcp4SelectOffer) && (Callback != NULL)) {
820 Received = (BOOLEAN) ((Dhcp4Event == Dhcp4RcvdOffer) || (Dhcp4Event == Dhcp4RcvdAck));
821 Status = Callback->Callback (
822 Callback,
823 Private->Function,
824 Received,
825 Packet->Length,
826 (EFI_PXE_BASE_CODE_PACKET *) &Packet->Dhcp4
827 );
828 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {
829 return EFI_ABORTED;
830 }
831 }
832
833 Status = EFI_SUCCESS;
834
835 switch (Dhcp4Event) {
836
837 case Dhcp4SendDiscover:
838 case Dhcp4SendRequest:
839 if (Mode->SendGUID) {
840 //
841 // send the system GUID instead of the MAC address as the hardware address
842 // in the DHCP packet header.
843 //
844 DhcpHeader = &Packet->Dhcp4.Header;
845
846 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) DhcpHeader->ClientHwAddr, &SystemSerialNumber))) {
847 //
848 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
849 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
850 // GUID not yet set - send all 0's to show not programable
851 //
852 ZeroMem (DhcpHeader->ClientHwAddr, sizeof (EFI_GUID));
853 }
854
855 DhcpHeader->HwAddrLen = sizeof (EFI_GUID);
856 }
857
858 if (Dhcp4Event == Dhcp4SendDiscover) {
859 //
860 // Cache the dhcp discover packet, of which some information will be used later.
861 //
862 CopyMem (Mode->DhcpDiscover.Raw, &Packet->Dhcp4, Packet->Length);
863 }
864
865 break;
866
867 case Dhcp4RcvdOffer:
868 Status = EFI_NOT_READY;
869 if (Private->NumOffers < PXEBC_MAX_OFFER_NUM) {
870 //
871 // Cache the dhcp offers in Private->Dhcp4Offers[]
872 //
873 PxeBcCacheDhcpOffer (Private, Packet);
874 }
875
876 break;
877
878 case Dhcp4SelectOffer:
879 //
880 // Select an offer, if succeeded, Private->SelectedOffer points to
881 // the index of the selected one.
882 //
883 PxeBcSelectOffer (Private);
884
885 if (Private->SelectedOffer == 0) {
886 Status = EFI_ABORTED;
887 } else {
888 *NewPacket = &Private->Dhcp4Offers[Private->SelectedOffer - 1].Packet.Offer;
889 }
890
891 break;
892
893 case Dhcp4RcvdAck:
894 //
895 // Cache Ack
896 //
897 ASSERT (Private->SelectedOffer != 0);
898
899 PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Packet);
900 break;
901
902 default:
903 break;
904 }
905
906 return Status;
907 }
908
909
910 /**
911 Initialize the DHCP options and build the option list.
912
913 @param Private Pointer to PxeBc private data.
914 @param OptList Pointer to a DHCP option list.
915
916 @param IsDhcpDiscover Discover dhcp option or not.
917
918 @return The index item number of the option list.
919
920 **/
921 UINT32
922 PxeBcBuildDhcpOptions (
923 IN PXEBC_PRIVATE_DATA *Private,
924 IN EFI_DHCP4_PACKET_OPTION **OptList,
925 IN BOOLEAN IsDhcpDiscover
926 )
927 {
928 UINT32 Index;
929 PXEBC_DHCP4_OPTION_ENTRY OptEnt;
930 UINT16 Value;
931 CHAR8 *SystemSerialNumber;
932
933 Index = 0;
934 OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Private->OptionBuffer;
935
936 if (!IsDhcpDiscover) {
937 //
938 // Append message type.
939 //
940 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MSG_TYPE;
941 OptList[Index]->Length = 1;
942 OptEnt.Mesg = (PXEBC_DHCP4_OPTION_MESG *) OptList[Index]->Data;
943 OptEnt.Mesg->Type = PXEBC_DHCP4_MSG_TYPE_REQUEST;
944 Index++;
945 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
946
947 //
948 // Append max message size.
949 //
950 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MAXMSG;
951 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);
952 OptEnt.MaxMesgSize = (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE *) OptList[Index]->Data;
953 Value = NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE);
954 CopyMem (&OptEnt.MaxMesgSize->Size, &Value, sizeof (UINT16));
955 Index++;
956 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
957 }
958 //
959 // Parameter request list option.
960 //
961 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_PARA_LIST;
962 OptList[Index]->Length = 35;
963 OptEnt.Para = (PXEBC_DHCP4_OPTION_PARA *) OptList[Index]->Data;
964 OptEnt.Para->ParaList[0] = PXEBC_DHCP4_TAG_NETMASK;
965 OptEnt.Para->ParaList[1] = PXEBC_DHCP4_TAG_TIME_OFFSET;
966 OptEnt.Para->ParaList[2] = PXEBC_DHCP4_TAG_ROUTER;
967 OptEnt.Para->ParaList[3] = PXEBC_DHCP4_TAG_TIME_SERVER;
968 OptEnt.Para->ParaList[4] = PXEBC_DHCP4_TAG_NAME_SERVER;
969 OptEnt.Para->ParaList[5] = PXEBC_DHCP4_TAG_DNS_SERVER;
970 OptEnt.Para->ParaList[6] = PXEBC_DHCP4_TAG_HOSTNAME;
971 OptEnt.Para->ParaList[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN;
972 OptEnt.Para->ParaList[8] = PXEBC_DHCP4_TAG_DOMAINNAME;
973 OptEnt.Para->ParaList[9] = PXEBC_DHCP4_TAG_ROOTPATH;
974 OptEnt.Para->ParaList[10] = PXEBC_DHCP4_TAG_EXTEND_PATH;
975 OptEnt.Para->ParaList[11] = PXEBC_DHCP4_TAG_EMTU;
976 OptEnt.Para->ParaList[12] = PXEBC_DHCP4_TAG_TTL;
977 OptEnt.Para->ParaList[13] = PXEBC_DHCP4_TAG_BROADCAST;
978 OptEnt.Para->ParaList[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN;
979 OptEnt.Para->ParaList[15] = PXEBC_DHCP4_TAG_NIS_SERVER;
980 OptEnt.Para->ParaList[16] = PXEBC_DHCP4_TAG_NTP_SERVER;
981 OptEnt.Para->ParaList[17] = PXEBC_DHCP4_TAG_VENDOR;
982 OptEnt.Para->ParaList[18] = PXEBC_DHCP4_TAG_REQUEST_IP;
983 OptEnt.Para->ParaList[19] = PXEBC_DHCP4_TAG_LEASE;
984 OptEnt.Para->ParaList[20] = PXEBC_DHCP4_TAG_SERVER_ID;
985 OptEnt.Para->ParaList[21] = PXEBC_DHCP4_TAG_T1;
986 OptEnt.Para->ParaList[22] = PXEBC_DHCP4_TAG_T2;
987 OptEnt.Para->ParaList[23] = PXEBC_DHCP4_TAG_CLASS_ID;
988 OptEnt.Para->ParaList[24] = PXEBC_DHCP4_TAG_TFTP;
989 OptEnt.Para->ParaList[25] = PXEBC_DHCP4_TAG_BOOTFILE;
990 OptEnt.Para->ParaList[26] = PXEBC_PXE_DHCP4_TAG_UUID;
991 OptEnt.Para->ParaList[27] = 0x80;
992 OptEnt.Para->ParaList[28] = 0x81;
993 OptEnt.Para->ParaList[29] = 0x82;
994 OptEnt.Para->ParaList[30] = 0x83;
995 OptEnt.Para->ParaList[31] = 0x84;
996 OptEnt.Para->ParaList[32] = 0x85;
997 OptEnt.Para->ParaList[33] = 0x86;
998 OptEnt.Para->ParaList[34] = 0x87;
999 Index++;
1000 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
1001
1002 //
1003 // Append UUID/Guid-based client identifier option
1004 //
1005 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UUID;
1006 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UUID);
1007 OptEnt.Uuid = (PXEBC_DHCP4_OPTION_UUID *) OptList[Index]->Data;
1008 OptEnt.Uuid->Type = 0;
1009 Index++;
1010 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
1011
1012 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) OptEnt.Uuid->Guid, &SystemSerialNumber))) {
1013 //
1014 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
1015 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
1016 // GUID not yet set - send all 0's to show not programable
1017 //
1018 ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));
1019 }
1020
1021 //
1022 // Append client network device interface option
1023 //
1024 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UNDI;
1025 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UNDI);
1026 OptEnt.Undi = (PXEBC_DHCP4_OPTION_UNDI *) OptList[Index]->Data;
1027 if (Private->Nii != NULL) {
1028 OptEnt.Undi->Type = Private->Nii->Type;
1029 OptEnt.Undi->MajorVer = Private->Nii->MajorVer;
1030 OptEnt.Undi->MinorVer = Private->Nii->MinorVer;
1031 } else {
1032 OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;
1033 OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;
1034 OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;
1035 }
1036
1037 Index++;
1038 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
1039
1040 //
1041 // Append client system architecture option
1042 //
1043 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_ARCH;
1044 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_ARCH);
1045 OptEnt.Arch = (PXEBC_DHCP4_OPTION_ARCH *) OptList[Index]->Data;
1046 Value = HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE);
1047 CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));
1048 Index++;
1049 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
1050
1051 //
1052 // Append client system architecture option
1053 //
1054 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_CLASS_ID;
1055 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_CLID);
1056 OptEnt.Clid = (PXEBC_DHCP4_OPTION_CLID *) OptList[Index]->Data;
1057 CopyMem (OptEnt.Clid, DEFAULT_CLASS_ID_DATA, sizeof (PXEBC_DHCP4_OPTION_CLID));
1058 CvtNum (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE, OptEnt.Clid->ArchitectureType, sizeof (OptEnt.Clid->ArchitectureType));
1059
1060 if (Private->Nii != NULL) {
1061 //
1062 // If NII protocol exists, update DHCP option data
1063 //
1064 CopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));
1065 CvtNum (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));
1066 CvtNum (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));
1067 }
1068
1069 Index++;
1070
1071 return Index;
1072 }
1073
1074
1075 /**
1076 Discover the boot of service and initialize the vendor option if exists.
1077
1078 @param Private Pointer to PxeBc private data.
1079 @param Type PxeBc option boot item type
1080 @param Layer PxeBc option boot item layer
1081 @param UseBis Use BIS or not
1082 @param DestIp Ip address for server
1083 @param IpCount The total count of the server ip address
1084 @param SrvList Server list
1085 @param IsDiscv Discover the vendor or not
1086 @param Reply The dhcp4 packet of Pxe reply
1087
1088 @retval EFI_SUCCESS Operation succeeds.
1089 @retval EFI_OUT_OF_RESOURCES Allocate memory pool failed.
1090 @retval EFI_NOT_FOUND There is no vendor option exists.
1091 @retval EFI_TIMEOUT Send Pxe Discover time out.
1092
1093 **/
1094 EFI_STATUS
1095 PxeBcDiscvBootService (
1096 IN PXEBC_PRIVATE_DATA * Private,
1097 IN UINT16 Type,
1098 IN UINT16 *Layer,
1099 IN BOOLEAN UseBis,
1100 IN EFI_IP_ADDRESS * DestIp,
1101 IN UINT16 IpCount,
1102 IN EFI_PXE_BASE_CODE_SRVLIST * SrvList,
1103 IN BOOLEAN IsDiscv,
1104 OUT EFI_DHCP4_PACKET * Reply OPTIONAL
1105 )
1106 {
1107 EFI_PXE_BASE_CODE_UDP_PORT Sport;
1108 EFI_PXE_BASE_CODE_MODE *Mode;
1109 EFI_DHCP4_PROTOCOL *Dhcp4;
1110 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token;
1111 BOOLEAN IsBCast;
1112 EFI_STATUS Status;
1113 UINT16 RepIndex;
1114 UINT16 SrvIndex;
1115 UINT16 TryIndex;
1116 EFI_DHCP4_LISTEN_POINT ListenPoint;
1117 EFI_DHCP4_PACKET *Response;
1118 EFI_DHCP4_PACKET_OPTION *OptList[PXEBC_DHCP4_MAX_OPTION_NUM];
1119 UINT32 OptCount;
1120 EFI_DHCP4_PACKET_OPTION *PxeOpt;
1121 PXEBC_OPTION_BOOT_ITEM *PxeBootItem;
1122 UINT8 VendorOptLen;
1123 CHAR8 *SystemSerialNumber;
1124 EFI_DHCP4_HEADER *DhcpHeader;
1125 UINT32 Xid;
1126
1127 Mode = Private->PxeBc.Mode;
1128 Dhcp4 = Private->Dhcp4;
1129 Status = EFI_SUCCESS;
1130
1131 ZeroMem (&Token, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN));
1132
1133 if (DestIp == NULL) {
1134 Sport = PXEBC_DHCP4_S_PORT;
1135 IsBCast = TRUE;
1136 } else {
1137 Sport = PXEBC_BS_DISCOVER_PORT;
1138 IsBCast = FALSE;
1139 }
1140
1141 if (!UseBis && Layer != NULL) {
1142 *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;
1143 }
1144
1145 OptCount = PxeBcBuildDhcpOptions (Private, OptList, FALSE);
1146
1147 if (IsDiscv) {
1148 ASSERT (Layer != NULL);
1149 //
1150 // Add vendor option of PXE_BOOT_ITEM
1151 //
1152 VendorOptLen = (sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1;
1153 OptList[OptCount] = AllocatePool (VendorOptLen);
1154 if (OptList[OptCount] == NULL) {
1155 return EFI_OUT_OF_RESOURCES;
1156 }
1157
1158 OptList[OptCount]->OpCode = PXEBC_DHCP4_TAG_VENDOR;
1159 OptList[OptCount]->Length = (UINT8) (VendorOptLen - 2);
1160 PxeOpt = (EFI_DHCP4_PACKET_OPTION *) OptList[OptCount]->Data;
1161 PxeOpt->OpCode = PXEBC_VENDOR_TAG_BOOT_ITEM;
1162 PxeOpt->Length = sizeof (PXEBC_OPTION_BOOT_ITEM);
1163 PxeBootItem = (PXEBC_OPTION_BOOT_ITEM *) PxeOpt->Data;
1164 PxeBootItem->Type = HTONS (Type);
1165 PxeBootItem->Layer = HTONS (*Layer);
1166 PxeOpt->Data[PxeOpt->Length] = PXEBC_DHCP4_TAG_EOP;
1167
1168 OptCount++;
1169 }
1170
1171 Status = Dhcp4->Build (Dhcp4, &Private->SeedPacket, 0, NULL, OptCount, OptList, &Token.Packet);
1172
1173 if (IsDiscv) {
1174 FreePool (OptList[OptCount - 1]);
1175 }
1176
1177 if (EFI_ERROR (Status)) {
1178 return Status;
1179 }
1180
1181 DhcpHeader = &Token.Packet->Dhcp4.Header;
1182 if (Mode->SendGUID) {
1183 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) DhcpHeader->ClientHwAddr, &SystemSerialNumber))) {
1184 //
1185 // GUID not yet set - send all 0's to show not programable
1186 //
1187 ZeroMem (DhcpHeader->ClientHwAddr, sizeof (EFI_GUID));
1188 }
1189
1190 DhcpHeader->HwAddrLen = sizeof (EFI_GUID);
1191 }
1192
1193 Xid = NET_RANDOM (NetRandomInitSeed ());
1194 Token.Packet->Dhcp4.Header.Xid = HTONL(Xid);
1195 Token.Packet->Dhcp4.Header.Reserved = HTONS((UINT16) ((IsBCast) ? 0x8000 : 0));
1196 CopyMem (&Token.Packet->Dhcp4.Header.ClientAddr, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));
1197
1198 Token.RemotePort = Sport;
1199
1200 if (IsBCast) {
1201 SetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);
1202 } else {
1203 CopyMem (&Token.RemoteAddress, DestIp, sizeof (EFI_IPv4_ADDRESS));
1204 }
1205
1206 CopyMem (&Token.GatewayAddress, &Private->GatewayIp, sizeof (EFI_IPv4_ADDRESS));
1207
1208 if (!IsBCast) {
1209 Token.ListenPointCount = 1;
1210 Token.ListenPoints = &ListenPoint;
1211 Token.ListenPoints[0].ListenPort = PXEBC_BS_DISCOVER_PORT;
1212 CopyMem (&Token.ListenPoints[0].ListenAddress, &Private->StationIp, sizeof(EFI_IPv4_ADDRESS));
1213 CopyMem (&Token.ListenPoints[0].SubnetMask, &Private->SubnetMask, sizeof(EFI_IPv4_ADDRESS));
1214 }
1215 //
1216 // Send Pxe Discover
1217 //
1218 for (TryIndex = 1; TryIndex <= PXEBC_BOOT_REQUEST_RETRIES; TryIndex++) {
1219
1220 Token.TimeoutValue = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex);
1221 Token.Packet->Dhcp4.Header.Seconds = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * (TryIndex - 1));
1222
1223 Status = Dhcp4->TransmitReceive (Dhcp4, &Token);
1224
1225 if (Token.Status != EFI_TIMEOUT) {
1226 break;
1227 }
1228 }
1229
1230 if (TryIndex > PXEBC_BOOT_REQUEST_RETRIES) {
1231 //
1232 // No server response our PXE request
1233 //
1234 Status = EFI_TIMEOUT;
1235 }
1236
1237 if (!EFI_ERROR (Status)) {
1238 //
1239 // Find Pxe Reply
1240 //
1241 RepIndex = 0;
1242 SrvIndex = 0;
1243 Response = Token.ResponseList;
1244
1245 while (RepIndex < Token.ResponseCount) {
1246
1247 while (SrvIndex < IpCount) {
1248
1249 if (SrvList[SrvIndex].AcceptAnyResponse) {
1250 break;
1251 }
1252
1253 if ((SrvList[SrvIndex].Type == Type) && EFI_IP4_EQUAL (&(Response->Dhcp4.Header.ServerAddr), &(Private->ServerIp))) {
1254 break;
1255 }
1256
1257 SrvIndex++;
1258 }
1259
1260 if ((IpCount != SrvIndex) || (IpCount == 0)) {
1261 break;
1262 }
1263
1264 SrvIndex = 0;
1265 RepIndex++;
1266
1267 Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);
1268 }
1269
1270 if (RepIndex < Token.ResponseCount) {
1271
1272 if (Reply != NULL) {
1273 PxeBcCopyEfiDhcp4Packet (Reply, Response);
1274 }
1275
1276 if (IsDiscv) {
1277 CopyMem (&(Mode->PxeDiscover), &(Token.Packet->Dhcp4), Token.Packet->Length);
1278 Mode->PxeDiscoverValid = TRUE;
1279
1280 CopyMem (Mode->PxeReply.Raw, &Response->Dhcp4, Response->Length);
1281 Mode->PxeReplyReceived = TRUE;
1282 }
1283 } else {
1284 Status = EFI_NOT_FOUND;
1285 }
1286
1287 //
1288 // free the responselist
1289 //
1290 if (Token.ResponseList != NULL) {
1291 FreePool (Token.ResponseList);
1292 }
1293 }
1294 //
1295 // Free the dhcp packet
1296 //
1297 FreePool (Token.Packet);
1298
1299 return Status;
1300 }
1301
1302
1303 /**
1304 Parse interested dhcp options.
1305
1306 @param Buffer Pointer to the dhcp options packet.
1307 @param Length The length of the dhcp options.
1308 @param OptTag The option OpCode.
1309
1310 @return NULL if the buffer length is 0 and OpCode is not
1311 PXEBC_DHCP4_TAG_EOP, or the pointer to the buffer.
1312
1313 **/
1314 EFI_DHCP4_PACKET_OPTION *
1315 PxeBcParseExtendOptions (
1316 IN UINT8 *Buffer,
1317 IN UINT32 Length,
1318 IN UINT8 OptTag
1319 )
1320 {
1321 EFI_DHCP4_PACKET_OPTION *Option;
1322 UINT32 Offset;
1323
1324 Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;
1325 Offset = 0;
1326
1327 while (Offset < Length && Option->OpCode != PXEBC_DHCP4_TAG_EOP) {
1328
1329 if (Option->OpCode == OptTag) {
1330
1331 return Option;
1332 }
1333
1334 if (Option->OpCode == PXEBC_DHCP4_TAG_PAD) {
1335 Offset++;
1336 } else {
1337 Offset += Option->Length + 2;
1338 }
1339
1340 Option = (EFI_DHCP4_PACKET_OPTION *) (Buffer + Offset);
1341 }
1342
1343 return NULL;
1344 }
1345
1346
1347 /**
1348 This function is to parse and check vendor options.
1349
1350 @param Dhcp4Option Pointer to dhcp options
1351 @param VendorOption Pointer to vendor options
1352
1353 @return TRUE if valid for vendor options, or FALSE.
1354
1355 **/
1356 BOOLEAN
1357 PxeBcParseVendorOptions (
1358 IN EFI_DHCP4_PACKET_OPTION *Dhcp4Option,
1359 IN PXEBC_VENDOR_OPTION *VendorOption
1360 )
1361 {
1362 UINT32 *BitMap;
1363 UINT8 VendorOptionLen;
1364 EFI_DHCP4_PACKET_OPTION *PxeOption;
1365 UINT8 Offset;
1366
1367 BitMap = VendorOption->BitMap;
1368 VendorOptionLen = Dhcp4Option->Length;
1369 PxeOption = (EFI_DHCP4_PACKET_OPTION *) &Dhcp4Option->Data[0];
1370 Offset = 0;
1371
1372 while ((Offset < VendorOptionLen) && (PxeOption->OpCode != PXEBC_DHCP4_TAG_EOP)) {
1373 //
1374 // Parse every Vendor Option and set its BitMap
1375 //
1376 switch (PxeOption->OpCode) {
1377
1378 case PXEBC_VENDOR_TAG_MTFTP_IP:
1379
1380 CopyMem (&VendorOption->MtftpIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1381 break;
1382
1383 case PXEBC_VENDOR_TAG_MTFTP_CPORT:
1384
1385 CopyMem (&VendorOption->MtftpCPort, PxeOption->Data, sizeof (VendorOption->MtftpCPort));
1386 break;
1387
1388 case PXEBC_VENDOR_TAG_MTFTP_SPORT:
1389
1390 CopyMem (&VendorOption->MtftpSPort, PxeOption->Data, sizeof (VendorOption->MtftpSPort));
1391 break;
1392
1393 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT:
1394
1395 VendorOption->MtftpTimeout = *PxeOption->Data;
1396 break;
1397
1398 case PXEBC_VENDOR_TAG_MTFTP_DELAY:
1399
1400 VendorOption->MtftpDelay = *PxeOption->Data;
1401 break;
1402
1403 case PXEBC_VENDOR_TAG_DISCOVER_CTRL:
1404
1405 VendorOption->DiscoverCtrl = *PxeOption->Data;
1406 break;
1407
1408 case PXEBC_VENDOR_TAG_DISCOVER_MCAST:
1409
1410 CopyMem (&VendorOption->DiscoverMcastIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1411 break;
1412
1413 case PXEBC_VENDOR_TAG_BOOT_SERVERS:
1414
1415 VendorOption->BootSvrLen = PxeOption->Length;
1416 VendorOption->BootSvr = (PXEBC_BOOT_SVR_ENTRY *) PxeOption->Data;
1417 break;
1418
1419 case PXEBC_VENDOR_TAG_BOOT_MENU:
1420
1421 VendorOption->BootMenuLen = PxeOption->Length;
1422 VendorOption->BootMenu = (PXEBC_BOOT_MENU_ENTRY *) PxeOption->Data;
1423 break;
1424
1425 case PXEBC_VENDOR_TAG_MENU_PROMPT:
1426
1427 VendorOption->MenuPromptLen = PxeOption->Length;
1428 VendorOption->MenuPrompt = (PXEBC_MENU_PROMPT *) PxeOption->Data;
1429 break;
1430
1431 case PXEBC_VENDOR_TAG_MCAST_ALLOC:
1432
1433 CopyMem (&VendorOption->McastIpBase, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1434 CopyMem (&VendorOption->McastIpBlock, PxeOption->Data + 4, sizeof (VendorOption->McastIpBlock));
1435 CopyMem (&VendorOption->McastIpRange, PxeOption->Data + 6, sizeof (VendorOption->McastIpRange));
1436 break;
1437
1438 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES:
1439
1440 VendorOption->CredTypeLen = PxeOption->Length;
1441 VendorOption->CredType = (UINT32 *) PxeOption->Data;
1442 break;
1443
1444 case PXEBC_VENDOR_TAG_BOOT_ITEM:
1445
1446 CopyMem (&VendorOption->BootSrvType, PxeOption->Data, sizeof (VendorOption->BootSrvType));
1447 CopyMem (&VendorOption->BootSrvLayer, PxeOption->Data + 2, sizeof (VendorOption->BootSrvLayer));
1448 break;
1449 }
1450
1451 SET_VENDOR_OPTION_BIT_MAP (BitMap, PxeOption->OpCode);
1452
1453 if (PxeOption->OpCode == PXEBC_DHCP4_TAG_PAD) {
1454 Offset++;
1455 } else {
1456 Offset = (UINT8) (Offset + PxeOption->Length + 2);
1457 }
1458
1459 PxeOption = (EFI_DHCP4_PACKET_OPTION *) (Dhcp4Option->Data + Offset);
1460 }
1461
1462 //
1463 // FixMe, return falas if invalid of any vendor option
1464 //
1465
1466 return TRUE;
1467 }
1468
1469
1470 /**
1471 This function display boot item detail.
1472
1473 If the length of the boot item string over 70 Char, just display 70 Char.
1474
1475 @param Str Pointer to a string (boot item string).
1476 @param Len The length of string.
1477
1478 **/
1479 VOID
1480 PxeBcDisplayBootItem (
1481 IN UINT8 *Str,
1482 IN UINT8 Len
1483 )
1484 {
1485 UINT8 Tmp;
1486
1487 Len = (UINT8) MIN (70, Len);
1488 Tmp = Str[Len];
1489 Str[Len] = 0;
1490 AsciiPrint ("%a \n", Str);
1491 Str[Len] = Tmp;
1492 }
1493
1494
1495 /**
1496 Choose the boot prompt.
1497
1498 @param Private Pointer to PxeBc private data.
1499
1500 @retval EFI_SUCCESS Select boot prompt done.
1501 @retval EFI_TIMEOUT Select boot prompt time out.
1502 @retval EFI_NOT_FOUND The proxy offer is not Pxe10.
1503 @retval EFI_ABORTED User cancel the operation.
1504 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1505
1506 **/
1507 EFI_STATUS
1508 PxeBcSelectBootPrompt (
1509 IN PXEBC_PRIVATE_DATA *Private
1510 )
1511 {
1512 PXEBC_CACHED_DHCP4_PACKET *Packet;
1513 PXEBC_VENDOR_OPTION *VendorOpt;
1514 EFI_EVENT TimeoutEvent;
1515 EFI_EVENT DescendEvent;
1516 EFI_INPUT_KEY InputKey;
1517 EFI_STATUS Status;
1518 UINT8 Timeout;
1519 UINT8 *Prompt;
1520 UINT8 PromptLen;
1521 INT32 SecCol;
1522 INT32 SecRow;
1523
1524 TimeoutEvent = NULL;
1525 DescendEvent = NULL;
1526
1527 if (Private->PxeBc.Mode->ProxyOfferReceived) {
1528
1529 Packet = &Private->ProxyOffer;
1530 } else {
1531
1532 Packet = &Private->Dhcp4Ack;
1533 }
1534
1535 if (Packet->OfferType != DHCP4_PACKET_TYPE_PXE10) {
1536 return EFI_NOT_FOUND;
1537 }
1538
1539 VendorOpt = &Packet->PxeVendorOption;
1540
1541 if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {
1542 return EFI_SUCCESS;
1543 }
1544
1545 Timeout = VendorOpt->MenuPrompt->Timeout;
1546 Prompt = VendorOpt->MenuPrompt->Prompt;
1547 PromptLen = (UINT8) (VendorOpt->MenuPromptLen - 1);
1548
1549 if (Timeout == 0) {
1550 return EFI_SUCCESS;
1551 }
1552
1553 if (Timeout == 255) {
1554 return EFI_TIMEOUT;
1555 }
1556
1557 Status = gBS->CreateEvent (
1558 EVT_TIMER,
1559 TPL_CALLBACK,
1560 NULL,
1561 NULL,
1562 &TimeoutEvent
1563 );
1564
1565 if (EFI_ERROR (Status)) {
1566 return Status;
1567 }
1568
1569 Status = gBS->SetTimer (
1570 TimeoutEvent,
1571 TimerRelative,
1572 Timeout * TICKS_PER_SECOND
1573 );
1574
1575 if (EFI_ERROR (Status)) {
1576 goto ON_EXIT;
1577 }
1578
1579 Status = gBS->CreateEvent (
1580 EVT_TIMER,
1581 TPL_CALLBACK,
1582 NULL,
1583 NULL,
1584 &DescendEvent
1585 );
1586
1587 if (EFI_ERROR (Status)) {
1588 goto ON_EXIT;
1589 }
1590
1591 Status = gBS->SetTimer (
1592 DescendEvent,
1593 TimerPeriodic,
1594 TICKS_PER_SECOND
1595 );
1596
1597 if (EFI_ERROR (Status)) {
1598 goto ON_EXIT;
1599 }
1600
1601 SecCol = gST->ConOut->Mode->CursorColumn;
1602 SecRow = gST->ConOut->Mode->CursorRow;
1603
1604 PxeBcDisplayBootItem (Prompt, PromptLen);
1605
1606 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
1607 AsciiPrint ("(%d) ", Timeout--);
1608
1609 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1610
1611 if (!EFI_ERROR (gBS->CheckEvent (DescendEvent))) {
1612 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
1613 AsciiPrint ("(%d) ", Timeout--);
1614 }
1615
1616 if (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
1617
1618 gBS->Stall (10 * TICKS_PER_MS);
1619 continue;
1620 }
1621
1622 if (InputKey.ScanCode == 0) {
1623
1624 switch (InputKey.UnicodeChar) {
1625 case CTRL ('c'):
1626 Status = EFI_ABORTED;
1627 break;
1628
1629 case CTRL ('m'):
1630 case 'm':
1631 case 'M':
1632 Status = EFI_TIMEOUT;
1633 break;
1634
1635 default:
1636 continue;
1637 }
1638 } else {
1639
1640 switch (InputKey.ScanCode) {
1641 case SCAN_F8:
1642 Status = EFI_TIMEOUT;
1643 break;
1644
1645 case SCAN_ESC:
1646 Status = EFI_ABORTED;
1647 break;
1648
1649 default:
1650 continue;
1651 }
1652 }
1653
1654 break;
1655 }
1656
1657 gST->ConOut->SetCursorPosition (gST->ConOut, 0 , SecRow + 1);
1658
1659 ON_EXIT:
1660
1661 if (DescendEvent != NULL) {
1662 gBS->CloseEvent (DescendEvent);
1663 }
1664
1665 if (TimeoutEvent != NULL) {
1666 gBS->CloseEvent (TimeoutEvent);
1667 }
1668
1669 return Status;
1670 }
1671
1672
1673 /**
1674 Select the boot menu.
1675
1676 @param Private Pointer to PxeBc private data.
1677 @param Type The type of the menu.
1678 @param UseDefaultItem Use default item or not.
1679
1680 @retval EFI_ABORTED User cancel operation.
1681 @retval EFI_SUCCESS Select the boot menu success.
1682 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
1683
1684 **/
1685 EFI_STATUS
1686 PxeBcSelectBootMenu (
1687 IN PXEBC_PRIVATE_DATA *Private,
1688 OUT UINT16 *Type,
1689 IN BOOLEAN UseDefaultItem
1690 )
1691 {
1692 PXEBC_CACHED_DHCP4_PACKET *Packet;
1693 PXEBC_VENDOR_OPTION *VendorOpt;
1694 EFI_INPUT_KEY InputKey;
1695 UINT8 MenuSize;
1696 UINT8 MenuNum;
1697 INT32 TopRow;
1698 UINT16 Select;
1699 UINT16 LastSelect;
1700 UINT8 Index;
1701 BOOLEAN Finish;
1702 CHAR8 Blank[70];
1703 PXEBC_BOOT_MENU_ENTRY *MenuItem;
1704 PXEBC_BOOT_MENU_ENTRY *MenuArray[PXEBC_MAX_MENU_NUM];
1705
1706 Finish = FALSE;
1707 Select = 1;
1708 Index = 0;
1709 *Type = 0;
1710
1711 if (Private->PxeBc.Mode->ProxyOfferReceived) {
1712
1713 Packet = &Private->ProxyOffer;
1714 } else {
1715
1716 Packet = &Private->Dhcp4Ack;
1717 }
1718
1719 ASSERT (Packet->OfferType == DHCP4_PACKET_TYPE_PXE10);
1720
1721 VendorOpt = &Packet->PxeVendorOption;
1722
1723 if (!IS_VALID_BOOT_MENU (VendorOpt->BitMap)) {
1724 return EFI_SUCCESS;
1725 }
1726
1727 SetMem (Blank, sizeof(Blank), ' ');
1728
1729 MenuSize = VendorOpt->BootMenuLen;
1730 MenuItem = VendorOpt->BootMenu;
1731
1732 if (MenuSize == 0) {
1733 return EFI_NOT_READY;
1734 }
1735
1736 while (MenuSize > 0) {
1737 MenuArray[Index++] = MenuItem;
1738 MenuSize = (UINT8) (MenuSize - (MenuItem->DescLen + 3));
1739 MenuItem = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);
1740 if (Index >= PXEBC_MAX_MENU_NUM) {
1741 break;
1742 }
1743 }
1744
1745 if (UseDefaultItem) {
1746 *Type = MenuArray[0]->Type;
1747 *Type = NTOHS (*Type);
1748 return EFI_SUCCESS;
1749 }
1750
1751 MenuNum = Index;
1752
1753 for (Index = 0; Index < MenuNum; Index++) {
1754 PxeBcDisplayBootItem (MenuArray[Index]->DescStr, MenuArray[Index]->DescLen);
1755 }
1756
1757 TopRow = gST->ConOut->Mode->CursorRow - MenuNum;
1758
1759 do {
1760 ASSERT (Select < PXEBC_MAX_MENU_NUM);
1761 //
1762 // highlight selected row
1763 //
1764 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
1765 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + Select);
1766 Blank[MenuArray[Select]->DescLen] = 0;
1767 AsciiPrint ("%a\r", Blank);
1768 PxeBcDisplayBootItem (MenuArray[Select]->DescStr, MenuArray[Select]->DescLen);
1769 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
1770 LastSelect = Select;
1771
1772 while (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
1773 gBS->Stall (10 * TICKS_PER_MS);
1774 }
1775
1776 if (InputKey.ScanCode != 0) {
1777 switch (InputKey.UnicodeChar) {
1778 case CTRL ('c'):
1779 InputKey.ScanCode = SCAN_ESC;
1780 break;
1781
1782 case CTRL ('j'): /* linefeed */
1783 case CTRL ('m'): /* return */
1784 Finish = TRUE;
1785 break;
1786
1787 case CTRL ('i'): /* tab */
1788 case ' ':
1789 case 'd':
1790 case 'D':
1791 InputKey.ScanCode = SCAN_DOWN;
1792 break;
1793
1794 case CTRL ('h'): /* backspace */
1795 case 'u':
1796 case 'U':
1797 InputKey.ScanCode = SCAN_UP;
1798 break;
1799
1800 default:
1801 InputKey.ScanCode = 0;
1802 }
1803 }
1804
1805 switch (InputKey.ScanCode) {
1806 case SCAN_LEFT:
1807 case SCAN_UP:
1808 if (Select > 0) {
1809 --Select;
1810 }
1811
1812 break;
1813
1814 case SCAN_DOWN:
1815 case SCAN_RIGHT:
1816 if (++Select == MenuNum) {
1817 --Select;
1818 }
1819
1820 break;
1821
1822 case SCAN_PAGE_UP:
1823 case SCAN_HOME:
1824 Select = 0;
1825 break;
1826
1827 case SCAN_PAGE_DOWN:
1828 case SCAN_END:
1829 Select = (UINT16) (MenuNum - 1);
1830 break;
1831
1832 case SCAN_ESC:
1833 return EFI_ABORTED;
1834 }
1835
1836 /* unhighlight last selected row */
1837 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
1838 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + LastSelect);
1839 Blank[MenuArray[LastSelect]->DescLen] = 0;
1840 AsciiPrint ("%a\r", Blank);
1841 PxeBcDisplayBootItem (MenuArray[LastSelect]->DescStr, MenuArray[LastSelect]->DescLen);
1842 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
1843 } while (!Finish);
1844
1845 ASSERT (Select < PXEBC_MAX_MENU_NUM);
1846
1847 //
1848 // Swap the byte order
1849 //
1850 CopyMem (Type, &MenuArray[Select]->Type, sizeof (UINT16));
1851 *Type = NTOHS (*Type);
1852
1853 return EFI_SUCCESS;
1854 }
1855
EFI Development Kit II mirror for PVE