]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update PXE driver to support PXE forced mode.
[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcBoot.c
1 /** @file
2 Boot functions implementation for UefiPxeBc Driver.
3
4 Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
5
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.
10
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.
13
14 **/
15
16 #include "PxeBcImpl.h"
17
18
19 /**
20 Display the string of the boot item.
21
22 If the length of the boot item string beyond 70 Char, just display 70 Char.
23
24 @param[in] Str The pointer to the string.
25 @param[in] Len The length of the string.
26
27 **/
28 VOID
29 PxeBcDisplayBootItem (
30 IN UINT8 *Str,
31 IN UINT8 Len
32 )
33 {
34 UINT8 Tmp;
35
36 //
37 // Cut off the chars behind 70th.
38 //
39 Len = (UINT8) MIN (PXEBC_DISPLAY_MAX_LINE, Len);
40 Tmp = Str[Len];
41 Str[Len] = 0;
42 AsciiPrint ("%a \n", Str);
43
44 //
45 // Restore the original 70th char.
46 //
47 Str[Len] = Tmp;
48 }
49
50
51 /**
52 Select and maintain the boot prompt if needed.
53
54 @param[in] Private Pointer to PxeBc private data.
55
56 @retval EFI_SUCCESS Selected boot prompt done.
57 @retval EFI_TIMEOUT Selected boot prompt timed out.
58 @retval EFI_NOT_FOUND The proxy offer is not Pxe10.
59 @retval EFI_ABORTED User cancelled the operation.
60 @retval EFI_NOT_READY Reading the input key from the keyboard has not finish.
61
62 **/
63 EFI_STATUS
64 PxeBcSelectBootPrompt (
65 IN PXEBC_PRIVATE_DATA *Private
66 )
67 {
68 PXEBC_DHCP_PACKET_CACHE *Cache;
69 PXEBC_VENDOR_OPTION *VendorOpt;
70 EFI_PXE_BASE_CODE_MODE *Mode;
71 EFI_EVENT TimeoutEvent;
72 EFI_EVENT DescendEvent;
73 EFI_INPUT_KEY InputKey;
74 EFI_STATUS Status;
75 UINT32 OfferType;
76 UINT8 Timeout;
77 UINT8 *Prompt;
78 UINT8 PromptLen;
79 INT32 SecCol;
80 INT32 SecRow;
81
82 TimeoutEvent = NULL;
83 DescendEvent = NULL;
84 Mode = Private->PxeBc.Mode;
85 Cache = Mode->ProxyOfferReceived ? &Private->ProxyOffer : &Private->DhcpAck;
86 OfferType = Mode->UsingIpv6 ? Cache->Dhcp6.OfferType : Cache->Dhcp4.OfferType;
87
88 //
89 // Only DhcpPxe10 and ProxyPxe10 offer needs boot prompt.
90 //
91 if (OfferType != PxeOfferTypeProxyPxe10 && OfferType != PxeOfferTypeDhcpPxe10) {
92 return EFI_NOT_FOUND;
93 }
94
95 //
96 // There is no specified ProxyPxe10 for IPv6 in PXE and UEFI spec.
97 //
98 ASSERT (!Mode->UsingIpv6);
99
100 VendorOpt = &Cache->Dhcp4.VendorOpt;
101 //
102 // According to the PXE specification 2.1, Table 2-1 PXE DHCP Options,
103 // we must not consider a boot prompt or boot menu if all of the following hold:
104 // - the PXE_DISCOVERY_CONTROL tag(6) is present inside the Vendor Options(43), and has bit 3 set
105 // - a boot file name has been presented in the initial DHCP or ProxyDHCP offer packet.
106 //
107 if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) &&
108 Cache->Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
109 return EFI_ABORTED;
110 }
111
112 if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {
113 return EFI_TIMEOUT;
114 }
115
116 Timeout = VendorOpt->MenuPrompt->Timeout;
117 Prompt = VendorOpt->MenuPrompt->Prompt;
118 PromptLen = (UINT8) (VendorOpt->MenuPromptLen - 1);
119
120 //
121 // The valid scope of Timeout refers to PXE2.1 spec.
122 //
123 if (Timeout == 0) {
124 return EFI_TIMEOUT;
125 }
126 if (Timeout == 255) {
127 return EFI_SUCCESS;
128 }
129
130 //
131 // Create and start a timer as timeout event.
132 //
133 Status = gBS->CreateEvent (
134 EVT_TIMER,
135 TPL_CALLBACK,
136 NULL,
137 NULL,
138 &TimeoutEvent
139 );
140 if (EFI_ERROR (Status)) {
141 return Status;
142 }
143
144 Status = gBS->SetTimer (
145 TimeoutEvent,
146 TimerRelative,
147 Timeout * TICKS_PER_SECOND
148 );
149 if (EFI_ERROR (Status)) {
150 goto ON_EXIT;
151 }
152
153 //
154 // Create and start a periodic timer as descend event by second.
155 //
156 Status = gBS->CreateEvent (
157 EVT_TIMER,
158 TPL_CALLBACK,
159 NULL,
160 NULL,
161 &DescendEvent
162 );
163 if (EFI_ERROR (Status)) {
164 goto ON_EXIT;
165 }
166
167 Status = gBS->SetTimer (
168 DescendEvent,
169 TimerPeriodic,
170 TICKS_PER_SECOND
171 );
172 if (EFI_ERROR (Status)) {
173 goto ON_EXIT;
174 }
175
176 //
177 // Display the boot item and cursor on the screen.
178 //
179 SecCol = gST->ConOut->Mode->CursorColumn;
180 SecRow = gST->ConOut->Mode->CursorRow;
181
182 PxeBcDisplayBootItem (Prompt, PromptLen);
183
184 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
185 AsciiPrint ("(%d) ", Timeout--);
186
187 Status = EFI_TIMEOUT;
188 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
189 if (!EFI_ERROR (gBS->CheckEvent (DescendEvent))) {
190 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
191 AsciiPrint ("(%d) ", Timeout--);
192 }
193 if (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
194 gBS->Stall (10 * TICKS_PER_MS);
195 continue;
196 }
197 //
198 // Parse the input key by user.
199 // If <F8> or <Ctrl> + <M> is pressed, return success to display the boot menu.
200 //
201 if (InputKey.ScanCode == 0) {
202
203 switch (InputKey.UnicodeChar) {
204
205 case CTRL ('c'):
206 Status = EFI_ABORTED;
207 break;
208
209 case CTRL ('m'):
210 case 'm':
211 case 'M':
212 Status = EFI_SUCCESS;
213 break;
214
215 default:
216 continue;
217 }
218
219 } else {
220
221 switch (InputKey.ScanCode) {
222
223 case SCAN_F8:
224 Status = EFI_SUCCESS;
225 break;
226
227 case SCAN_ESC:
228 Status = EFI_ABORTED;
229 break;
230
231 default:
232 continue;
233 }
234 }
235
236 break;
237 }
238
239 //
240 // Reset the cursor on the screen.
241 //
242 gST->ConOut->SetCursorPosition (gST->ConOut, 0 , SecRow + 1);
243
244 ON_EXIT:
245 if (DescendEvent != NULL) {
246 gBS->CloseEvent (DescendEvent);
247 }
248 if (TimeoutEvent != NULL) {
249 gBS->CloseEvent (TimeoutEvent);
250 }
251
252 return Status;
253 }
254
255
256 /**
257 Select the boot menu by user's input.
258
259 @param[in] Private Pointer to PxeBc private data.
260 @param[out] Type The type of the menu.
261 @param[in] UseDefaultItem Use default item or not.
262
263 @retval EFI_ABORTED User cancel operation.
264 @retval EFI_SUCCESS Select the boot menu success.
265 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.
266
267 **/
268 EFI_STATUS
269 PxeBcSelectBootMenu (
270 IN PXEBC_PRIVATE_DATA *Private,
271 OUT UINT16 *Type,
272 IN BOOLEAN UseDefaultItem
273 )
274 {
275 EFI_PXE_BASE_CODE_MODE *Mode;
276 PXEBC_DHCP_PACKET_CACHE *Cache;
277 PXEBC_VENDOR_OPTION *VendorOpt;
278 EFI_INPUT_KEY InputKey;
279 UINT32 OfferType;
280 UINT8 MenuSize;
281 UINT8 MenuNum;
282 INT32 TopRow;
283 UINT16 Select;
284 UINT16 LastSelect;
285 UINT8 Index;
286 BOOLEAN Finish;
287 CHAR8 Blank[PXEBC_DISPLAY_MAX_LINE];
288 PXEBC_BOOT_MENU_ENTRY *MenuItem;
289 PXEBC_BOOT_MENU_ENTRY *MenuArray[PXEBC_MENU_MAX_NUM];
290
291 Finish = FALSE;
292 Select = 0;
293 Index = 0;
294 *Type = 0;
295 Mode = Private->PxeBc.Mode;
296 Cache = Mode->ProxyOfferReceived ? &Private->ProxyOffer : &Private->DhcpAck;
297 OfferType = Mode->UsingIpv6 ? Cache->Dhcp6.OfferType : Cache->Dhcp4.OfferType;
298
299 //
300 // There is no specified DhcpPxe10/ProxyPxe10 for IPv6 in PXE and UEFI spec.
301 //
302 ASSERT (!Mode->UsingIpv6);
303 ASSERT (OfferType == PxeOfferTypeProxyPxe10 || OfferType == PxeOfferTypeDhcpPxe10);
304
305 VendorOpt = &Cache->Dhcp4.VendorOpt;
306 if (!IS_VALID_BOOT_MENU (VendorOpt->BitMap)) {
307 return EFI_SUCCESS;
308 }
309
310 //
311 // Display the boot menu on the screen.
312 //
313 SetMem (Blank, sizeof(Blank), ' ');
314
315 MenuSize = VendorOpt->BootMenuLen;
316 MenuItem = VendorOpt->BootMenu;
317
318 if (MenuSize == 0) {
319 return EFI_DEVICE_ERROR;
320 }
321
322 while (MenuSize > 0 && Index < PXEBC_MENU_MAX_NUM) {
323 ASSERT (MenuItem != NULL);
324 MenuArray[Index] = MenuItem;
325 MenuSize = (UINT8) (MenuSize - (MenuItem->DescLen + 3));
326 MenuItem = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);
327 Index++;
328 }
329
330 if (UseDefaultItem) {
331 ASSERT (MenuArray[0] != NULL);
332 CopyMem (Type, &MenuArray[0]->Type, sizeof (UINT16));
333 *Type = NTOHS (*Type);
334 return EFI_SUCCESS;
335 }
336
337 MenuNum = Index;
338
339 for (Index = 0; Index < MenuNum; Index++) {
340 ASSERT (MenuArray[Index] != NULL);
341 PxeBcDisplayBootItem (MenuArray[Index]->DescStr, MenuArray[Index]->DescLen);
342 }
343
344 TopRow = gST->ConOut->Mode->CursorRow - MenuNum;
345
346 //
347 // Select the boot item by user in the boot menu.
348 //
349 do {
350 //
351 // Highlight selected row.
352 //
353 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
354 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + Select);
355 ASSERT (Select < PXEBC_MENU_MAX_NUM);
356 ASSERT (MenuArray[Select] != NULL);
357 Blank[MenuArray[Select]->DescLen] = 0;
358 AsciiPrint ("%a\r", Blank);
359 PxeBcDisplayBootItem (MenuArray[Select]->DescStr, MenuArray[Select]->DescLen);
360 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
361 LastSelect = Select;
362
363 while (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
364 gBS->Stall (10 * TICKS_PER_MS);
365 }
366
367 if (InputKey.ScanCode == 0) {
368 switch (InputKey.UnicodeChar) {
369 case CTRL ('c'):
370 InputKey.ScanCode = SCAN_ESC;
371 break;
372
373 case CTRL ('j'): /* linefeed */
374 case CTRL ('m'): /* return */
375 Finish = TRUE;
376 break;
377
378 case CTRL ('i'): /* tab */
379 case ' ':
380 case 'd':
381 case 'D':
382 InputKey.ScanCode = SCAN_DOWN;
383 break;
384
385 case CTRL ('h'): /* backspace */
386 case 'u':
387 case 'U':
388 InputKey.ScanCode = SCAN_UP;
389 break;
390
391 default:
392 InputKey.ScanCode = 0;
393 }
394 }
395
396 switch (InputKey.ScanCode) {
397 case SCAN_LEFT:
398 case SCAN_UP:
399 if (Select != 0) {
400 Select--;
401 }
402 break;
403
404 case SCAN_DOWN:
405 case SCAN_RIGHT:
406 if (++Select == MenuNum) {
407 Select--;
408 }
409 break;
410
411 case SCAN_PAGE_UP:
412 case SCAN_HOME:
413 Select = 0;
414 break;
415
416 case SCAN_PAGE_DOWN:
417 case SCAN_END:
418 Select = (UINT16) (MenuNum - 1);
419 break;
420
421 case SCAN_ESC:
422 return EFI_ABORTED;
423 }
424
425 //
426 // Unhighlight the last selected row.
427 //
428 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
429 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + LastSelect);
430 ASSERT (LastSelect < PXEBC_MENU_MAX_NUM);
431 ASSERT (MenuArray[LastSelect] != NULL);
432 Blank[MenuArray[LastSelect]->DescLen] = 0;
433 AsciiPrint ("%a\r", Blank);
434 PxeBcDisplayBootItem (MenuArray[LastSelect]->DescStr, MenuArray[LastSelect]->DescLen);
435 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
436 } while (!Finish);
437
438 //
439 // Swap the byte order.
440 //
441 ASSERT (Select < PXEBC_MENU_MAX_NUM);
442 ASSERT (MenuArray[Select] != NULL);
443 CopyMem (Type, &MenuArray[Select]->Type, sizeof (UINT16));
444 *Type = NTOHS (*Type);
445
446 return EFI_SUCCESS;
447 }
448
449
450 /**
451 Parse out the boot information from the last Dhcp4 reply packet.
452
453 @param[in, out] Private Pointer to PxeBc private data.
454 @param[out] BufferSize Size of the boot file to be downloaded.
455
456 @retval EFI_SUCCESS Successfully parsed out all the boot information.
457 @retval Others Failed to parse out the boot information.
458
459 **/
460 EFI_STATUS
461 PxeBcDhcp4BootInfo (
462 IN OUT PXEBC_PRIVATE_DATA *Private,
463 OUT UINT64 *BufferSize
464 )
465 {
466 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
467 EFI_PXE_BASE_CODE_MODE *Mode;
468 EFI_STATUS Status;
469 PXEBC_DHCP4_PACKET_CACHE *Cache4;
470 UINT16 Value;
471 PXEBC_VENDOR_OPTION *VendorOpt;
472 PXEBC_BOOT_SVR_ENTRY *Entry;
473
474 PxeBc = &Private->PxeBc;
475 Mode = PxeBc->Mode;
476 Status = EFI_SUCCESS;
477 *BufferSize = 0;
478
479 //
480 // Get the last received Dhcp4 reply packet.
481 //
482 if (Mode->PxeReplyReceived) {
483 Cache4 = &Private->PxeReply.Dhcp4;
484 } else if (Mode->ProxyOfferReceived) {
485 Cache4 = &Private->ProxyOffer.Dhcp4;
486 } else {
487 Cache4 = &Private->DhcpAck.Dhcp4;
488 }
489
490 ASSERT (Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL);
491
492 //
493 // Parse the boot server address.
494 // If prompt/discover is disabled, get the first boot server from the boot servers list.
495 // Otherwise, parse the boot server Ipv4 address from next server address field in DHCP header.
496 // If all these fields are not available, use option 54 instead.
497 //
498 VendorOpt = &Cache4->VendorOpt;
499 if (IS_DISABLE_PROMPT_MENU (VendorOpt->DiscoverCtrl) && IS_VALID_BOOT_SERVERS (VendorOpt->BitMap)) {
500 Entry = VendorOpt->BootSvr;
501 if (VendorOpt->BootSvrLen >= sizeof (PXEBC_BOOT_SVR_ENTRY) && Entry->IpCnt > 0) {
502 CopyMem (
503 &Private->ServerIp,
504 &Entry->IpAddr[0],
505 sizeof (EFI_IPv4_ADDRESS)
506 );
507 }
508 }
509 if (Private->ServerIp.Addr[0] == 0) {
510 //
511 // ServerIp.Addr[0] equals zero means we failed to get IP address from boot server list.
512 // Try to use next server address field.
513 //
514 CopyMem (
515 &Private->ServerIp,
516 &Cache4->Packet.Offer.Dhcp4.Header.ServerAddr,
517 sizeof (EFI_IPv4_ADDRESS)
518 );
519 }
520 if (Private->ServerIp.Addr[0] == 0) {
521 //
522 // Still failed , use the IP address from option 54.
523 //
524 CopyMem (
525 &Private->ServerIp,
526 Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,
527 sizeof (EFI_IPv4_ADDRESS)
528 );
529 }
530
531 //
532 // Parse the boot file name by option.
533 //
534 Private->BootFileName = Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data;
535
536 if (Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN] != NULL) {
537 //
538 // Parse the boot file size by option.
539 //
540 CopyMem (&Value, Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN]->Data, sizeof (Value));
541 Value = NTOHS (Value);
542 //
543 // The field of boot file size is 512 bytes in unit.
544 //
545 *BufferSize = 512 * Value;
546 } else {
547 //
548 // Get the bootfile size by tftp command if no option available.
549 //
550 Status = PxeBc->Mtftp (
551 PxeBc,
552 EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
553 NULL,
554 FALSE,
555 BufferSize,
556 &Private->BlockSize,
557 &Private->ServerIp,
558 Private->BootFileName,
559 NULL,
560 FALSE
561 );
562 }
563
564 //
565 // Save the value of boot file size.
566 //
567 Private->BootFileSize = (UINTN) *BufferSize;
568
569 //
570 // Display all the information: boot server address, boot file name and boot file size.
571 //
572 AsciiPrint ("\n Server IP address is ");
573 PxeBcShowIp4Addr (&Private->ServerIp.v4);
574 AsciiPrint ("\n NBP filename is %a", Private->BootFileName);
575 AsciiPrint ("\n NBP filesize is %d Bytes", Private->BootFileSize);
576
577 return Status;
578 }
579
580
581 /**
582 Parse out the boot information from the last Dhcp6 reply packet.
583
584 @param[in, out] Private Pointer to PxeBc private data.
585 @param[out] BufferSize Size of the boot file to be downloaded.
586
587 @retval EFI_SUCCESS Successfully parsed out all the boot information.
588 @retval EFI_BUFFER_TOO_SMALL
589 @retval Others Failed to parse out the boot information.
590
591 **/
592 EFI_STATUS
593 PxeBcDhcp6BootInfo (
594 IN OUT PXEBC_PRIVATE_DATA *Private,
595 OUT UINT64 *BufferSize
596 )
597 {
598 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
599 EFI_PXE_BASE_CODE_MODE *Mode;
600 EFI_STATUS Status;
601 PXEBC_DHCP6_PACKET_CACHE *Cache6;
602 UINT16 Value;
603
604 PxeBc = &Private->PxeBc;
605 Mode = PxeBc->Mode;
606 Status = EFI_SUCCESS;
607 *BufferSize = 0;
608
609 //
610 // Get the last received Dhcp6 reply packet.
611 //
612 if (Mode->PxeReplyReceived) {
613 Cache6 = &Private->PxeReply.Dhcp6;
614 } else if (Mode->ProxyOfferReceived) {
615 Cache6 = &Private->ProxyOffer.Dhcp6;
616 } else {
617 Cache6 = &Private->DhcpAck.Dhcp6;
618 }
619
620 ASSERT (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);
621
622 //
623 // Parse (m)tftp server ip address and bootfile name.
624 //
625 Status = PxeBcExtractBootFileUrl (
626 &Private->BootFileName,
627 &Private->ServerIp.v6,
628 (CHAR8 *) (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),
629 NTOHS (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->OpLen)
630 );
631 if (EFI_ERROR (Status)) {
632 return Status;
633 }
634
635 //
636 // Parse the value of boot file size.
637 //
638 if (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM] != NULL) {
639 //
640 // Parse it out if have the boot file parameter option.
641 //
642 Status = PxeBcExtractBootFileParam ((CHAR8 *) Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM]->Data, &Value);
643 if (EFI_ERROR (Status)) {
644 return Status;
645 }
646 //
647 // The field of boot file size is 512 bytes in unit.
648 //
649 *BufferSize = 512 * Value;
650 } else {
651 //
652 // Send get file size command by tftp if option unavailable.
653 //
654 Status = PxeBc->Mtftp (
655 PxeBc,
656 EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
657 NULL,
658 FALSE,
659 BufferSize,
660 &Private->BlockSize,
661 &Private->ServerIp,
662 Private->BootFileName,
663 NULL,
664 FALSE
665 );
666 }
667
668 //
669 // Save the value of boot file size.
670 //
671 Private->BootFileSize = (UINTN) *BufferSize;
672
673 //
674 // Display all the information: boot server address, boot file name and boot file size.
675 //
676 AsciiPrint ("\n Server IP address is ");
677 PxeBcShowIp6Addr (&Private->ServerIp.v6);
678 AsciiPrint ("\n NBP filename is %a", Private->BootFileName);
679 AsciiPrint ("\n NBP filesize is %d Bytes", Private->BootFileSize);
680
681 return Status;
682 }
683
684
685 /**
686 Extract the discover information and boot server entry from the
687 cached packets if unspecified.
688
689 @param[in] Private Pointer to PxeBc private data.
690 @param[in] Type The type of bootstrap to perform.
691 @param[in, out] DiscoverInfo Pointer to EFI_PXE_BASE_CODE_DISCOVER_INFO.
692 @param[out] BootEntry Pointer to PXEBC_BOOT_SVR_ENTRY.
693 @param[out] SrvList Pointer to EFI_PXE_BASE_CODE_SRVLIST.
694
695 @retval EFI_SUCCESS Successfully extracted the information.
696 @retval EFI_DEVICE_ERROR Failed to extract the information.
697
698 **/
699 EFI_STATUS
700 PxeBcExtractDiscoverInfo (
701 IN PXEBC_PRIVATE_DATA *Private,
702 IN UINT16 Type,
703 IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO **DiscoverInfo,
704 OUT PXEBC_BOOT_SVR_ENTRY **BootEntry,
705 OUT EFI_PXE_BASE_CODE_SRVLIST **SrvList
706 )
707 {
708 EFI_PXE_BASE_CODE_MODE *Mode;
709 PXEBC_DHCP4_PACKET_CACHE *Cache4;
710 PXEBC_VENDOR_OPTION *VendorOpt;
711 PXEBC_BOOT_SVR_ENTRY *Entry;
712 BOOLEAN IsFound;
713 EFI_PXE_BASE_CODE_DISCOVER_INFO *Info;
714 UINT16 Index;
715
716 Mode = Private->PxeBc.Mode;
717 Info = *DiscoverInfo;
718
719 if (Mode->UsingIpv6) {
720 Info->IpCnt = 1;
721 Info->UseUCast = TRUE;
722
723 Info->SrvList[0].Type = Type;
724 Info->SrvList[0].AcceptAnyResponse = FALSE;
725
726 //
727 // There is no vendor options specified in DHCPv6, so take BootFileUrl in the last cached packet.
728 //
729 CopyMem (&Info->SrvList[0].IpAddr, &Private->ServerIp, sizeof (EFI_IP_ADDRESS));
730
731 *SrvList = Info->SrvList;
732 } else {
733 Entry = NULL;
734 IsFound = FALSE;
735 Cache4 = (Mode->ProxyOfferReceived) ? &Private->ProxyOffer.Dhcp4 : &Private->DhcpAck.Dhcp4;
736 VendorOpt = &Cache4->VendorOpt;
737
738 if (!Mode->DhcpAckReceived || !IS_VALID_DISCOVER_VENDOR_OPTION (VendorOpt->BitMap)) {
739 //
740 // Address is not acquired or no discovery options.
741 //
742 return EFI_INVALID_PARAMETER;
743 }
744
745 //
746 // Parse the boot server entry from the vendor option in the last cached packet.
747 //
748 Info->UseMCast = (BOOLEAN) !IS_DISABLE_MCAST_DISCOVER (VendorOpt->DiscoverCtrl);
749 Info->UseBCast = (BOOLEAN) !IS_DISABLE_BCAST_DISCOVER (VendorOpt->DiscoverCtrl);
750 Info->MustUseList = (BOOLEAN) IS_ENABLE_USE_SERVER_LIST (VendorOpt->DiscoverCtrl);
751 Info->UseUCast = (BOOLEAN) IS_VALID_BOOT_SERVERS (VendorOpt->BitMap);
752
753 if (Info->UseMCast) {
754 //
755 // Get the multicast discover ip address from vendor option if has.
756 //
757 CopyMem (&Info->ServerMCastIp.v4, &VendorOpt->DiscoverMcastIp, sizeof (EFI_IPv4_ADDRESS));
758 }
759
760 Info->IpCnt = 0;
761
762 if (Info->UseUCast) {
763 Entry = VendorOpt->BootSvr;
764
765 while (((UINT8) (Entry - VendorOpt->BootSvr)) < VendorOpt->BootSvrLen) {
766 if (Entry->Type == HTONS (Type)) {
767 IsFound = TRUE;
768 break;
769 }
770 Entry = GET_NEXT_BOOT_SVR_ENTRY (Entry);
771 }
772
773 if (!IsFound) {
774 return EFI_DEVICE_ERROR;
775 }
776
777 Info->IpCnt = Entry->IpCnt;
778 if (Info->IpCnt >= 1) {
779 *DiscoverInfo = AllocatePool (sizeof (*Info) + (Info->IpCnt - 1) * sizeof (**SrvList));
780 if (*DiscoverInfo == NULL) {
781 return EFI_OUT_OF_RESOURCES;
782 }
783 CopyMem (*DiscoverInfo, Info, sizeof (*Info));
784 Info = *DiscoverInfo;
785 }
786
787 for (Index = 0; Index < Info->IpCnt; Index++) {
788 CopyMem (&Info->SrvList[Index].IpAddr, &Entry->IpAddr[Index], sizeof (EFI_IPv4_ADDRESS));
789 Info->SrvList[Index].AcceptAnyResponse = !Info->MustUseList;
790 Info->SrvList[Index].Type = NTOHS (Entry->Type);
791 }
792 }
793
794 *BootEntry = Entry;
795 *SrvList = Info->SrvList;
796 }
797
798 return EFI_SUCCESS;
799 }
800
801
802 /**
803 Build the discover packet and send out for boot server.
804
805 @param[in] Private Pointer to PxeBc private data.
806 @param[in] Type PxeBc option boot item type.
807 @param[in] Layer Pointer to option boot item layer.
808 @param[in] UseBis Use BIS or not.
809 @param[in] DestIp Pointer to the destination address.
810 @param[in] IpCount The count of the server address.
811 @param[in] SrvList Pointer to the server address list.
812
813 @retval EFI_SUCCESS Successfully discovered boot file.
814 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource.
815 @retval EFI_NOT_FOUND Can't get the PXE reply packet.
816 @retval Others Failed to discover boot file.
817
818 **/
819 EFI_STATUS
820 PxeBcDiscoverBootServer (
821 IN PXEBC_PRIVATE_DATA *Private,
822 IN UINT16 Type,
823 IN UINT16 *Layer,
824 IN BOOLEAN UseBis,
825 IN EFI_IP_ADDRESS *DestIp,
826 IN UINT16 IpCount,
827 IN EFI_PXE_BASE_CODE_SRVLIST *SrvList
828 )
829 {
830 if (Private->PxeBc.Mode->UsingIpv6) {
831 return PxeBcDhcp6Discover (
832 Private,
833 Type,
834 Layer,
835 UseBis,
836 DestIp
837 );
838 } else {
839 return PxeBcDhcp4Discover (
840 Private,
841 Type,
842 Layer,
843 UseBis,
844 DestIp,
845 IpCount,
846 SrvList
847 );
848 }
849 }
850
851
852 /**
853 Discover all the boot information for boot file.
854
855 @param[in, out] Private Pointer to PxeBc private data.
856 @param[out] BufferSize Size of the boot file to be downloaded.
857
858 @retval EFI_SUCCESS Successfully obtained all the boot information .
859 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
860 @retval EFI_ABORTED User cancel current operation.
861 @retval Others Failed to parse out the boot information.
862
863 **/
864 EFI_STATUS
865 PxeBcDiscoverBootFile (
866 IN OUT PXEBC_PRIVATE_DATA *Private,
867 OUT UINT64 *BufferSize
868 )
869 {
870 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
871 EFI_PXE_BASE_CODE_MODE *Mode;
872 EFI_STATUS Status;
873 UINT16 Type;
874 UINT16 Layer;
875 BOOLEAN UseBis;
876
877 PxeBc = &Private->PxeBc;
878 Mode = PxeBc->Mode;
879 Type = EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP;
880 Layer = EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL;
881
882 //
883 // Start D.O.R.A/S.A.R.R exchange to acquire station ip address and
884 // other pxe boot information.
885 //
886 Status = PxeBc->Dhcp (PxeBc, TRUE);
887 if (EFI_ERROR (Status)) {
888 return Status;
889 }
890
891 //
892 // Select a boot server from boot server list.
893 //
894 Status = PxeBcSelectBootPrompt (Private);
895
896 if (Status == EFI_SUCCESS) {
897 //
898 // Choose by user's input.
899 //
900 Status = PxeBcSelectBootMenu (Private, &Type, FALSE);
901 } else if (Status == EFI_TIMEOUT) {
902 //
903 // Choose by default item.
904 //
905 Status = PxeBcSelectBootMenu (Private, &Type, TRUE);
906 }
907
908 if (!EFI_ERROR (Status)) {
909
910 if (Type == EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP) {
911 //
912 // Local boot(PXE bootstrap server) need abort
913 //
914 return EFI_ABORTED;
915 }
916
917 //
918 // Start to discover the boot server to get (m)tftp server ip address, bootfile
919 // name and bootfile size.
920 //
921 UseBis = (BOOLEAN) (Mode->BisSupported && Mode->BisDetected);
922 Status = PxeBc->Discover (PxeBc, Type, &Layer, UseBis, NULL);
923 if (EFI_ERROR (Status)) {
924 return Status;
925 }
926
927 if (Mode->PxeReplyReceived && !Mode->ProxyOfferReceived) {
928 //
929 // Some network boot loader only search the packet in Mode.ProxyOffer to get its server
930 // IP address, so we need to store a copy of Mode.PxeReply packet into Mode.ProxyOffer.
931 //
932 if (Mode->UsingIpv6) {
933 CopyMem (
934 &Mode->ProxyOffer.Dhcpv6,
935 &Mode->PxeReply.Dhcpv6,
936 Private->PxeReply.Dhcp6.Packet.Ack.Length
937 );
938 } else {
939 CopyMem (
940 &Mode->ProxyOffer.Dhcpv4,
941 &Mode->PxeReply.Dhcpv4,
942 Private->PxeReply.Dhcp4.Packet.Ack.Length
943 );
944 }
945 Mode->ProxyOfferReceived = TRUE;
946 }
947 }
948
949 //
950 // Parse the boot information.
951 //
952 if (Mode->UsingIpv6) {
953 Status = PxeBcDhcp6BootInfo (Private, BufferSize);
954 } else {
955 Status = PxeBcDhcp4BootInfo (Private, BufferSize);
956 }
957
958 return Status;
959 }
960
961
962 /**
963 Install PxeBaseCodeCallbackProtocol if not installed before.
964
965 @param[in, out] Private Pointer to PxeBc private data.
966 @param[out] NewMakeCallback If TRUE, it is a new callback.
967 Otherwise, it is not new callback.
968 @retval EFI_SUCCESS PxeBaseCodeCallbackProtocol installed succesfully.
969 @retval Others Failed to install PxeBaseCodeCallbackProtocol.
970
971 **/
972 EFI_STATUS
973 PxeBcInstallCallback (
974 IN OUT PXEBC_PRIVATE_DATA *Private,
975 OUT BOOLEAN *NewMakeCallback
976 )
977 {
978 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
979 EFI_STATUS Status;
980
981 //
982 // Check whether PxeBaseCodeCallbackProtocol already installed.
983 //
984 PxeBc = &Private->PxeBc;
985 Status = gBS->HandleProtocol (
986 Private->Controller,
987 &gEfiPxeBaseCodeCallbackProtocolGuid,
988 (VOID **) &Private->PxeBcCallback
989 );
990 if (Status == EFI_UNSUPPORTED) {
991
992 CopyMem (
993 &Private->LoadFileCallback,
994 &gPxeBcCallBackTemplate,
995 sizeof (EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL)
996 );
997
998 //
999 // Install a default callback if user didn't offer one.
1000 //
1001 Status = gBS->InstallProtocolInterface (
1002 &Private->Controller,
1003 &gEfiPxeBaseCodeCallbackProtocolGuid,
1004 EFI_NATIVE_INTERFACE,
1005 &Private->LoadFileCallback
1006 );
1007
1008 (*NewMakeCallback) = (BOOLEAN) (Status == EFI_SUCCESS);
1009
1010 Status = PxeBc->SetParameters (PxeBc, NULL, NULL, NULL, NULL, NewMakeCallback);
1011 if (EFI_ERROR (Status)) {
1012 PxeBc->Stop (PxeBc);
1013 return Status;
1014 }
1015 }
1016
1017 return EFI_SUCCESS;
1018 }
1019
1020
1021 /**
1022 Uninstall PxeBaseCodeCallbackProtocol.
1023
1024 @param[in] Private Pointer to PxeBc private data.
1025 @param[in] NewMakeCallback If TRUE, it is a new callback.
1026 Otherwise, it is not new callback.
1027
1028 **/
1029 VOID
1030 PxeBcUninstallCallback (
1031 IN PXEBC_PRIVATE_DATA *Private,
1032 IN BOOLEAN NewMakeCallback
1033 )
1034 {
1035 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1036
1037 PxeBc = &Private->PxeBc;
1038
1039 if (NewMakeCallback) {
1040
1041 NewMakeCallback = FALSE;
1042
1043 PxeBc->SetParameters (PxeBc, NULL, NULL, NULL, NULL, &NewMakeCallback);
1044
1045 gBS->UninstallProtocolInterface (
1046 Private->Controller,
1047 &gEfiPxeBaseCodeCallbackProtocolGuid,
1048 &Private->LoadFileCallback
1049 );
1050 }
1051 }
1052
1053
1054 /**
1055 Download one of boot file in the list, and it's special for IPv6.
1056
1057 @param[in] Private Pointer to PxeBc private data.
1058 @param[in, out] BufferSize Size of user buffer for input;
1059 required buffer size for output.
1060 @param[in] Buffer Pointer to user buffer.
1061
1062 @retval EFI_SUCCESS Read one of boot file in the list successfully.
1063 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
1064 @retval EFI_NOT_FOUND There is no proper boot file available.
1065 @retval Others Failed to download boot file in the list.
1066
1067 **/
1068 EFI_STATUS
1069 PxeBcReadBootFileList (
1070 IN PXEBC_PRIVATE_DATA *Private,
1071 IN OUT UINT64 *BufferSize,
1072 IN VOID *Buffer OPTIONAL
1073 )
1074 {
1075 EFI_STATUS Status;
1076 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1077
1078 PxeBc = &Private->PxeBc;
1079
1080 //
1081 // Try to download the boot file if everything is ready.
1082 //
1083 if (Buffer != NULL) {
1084 Status = PxeBc->Mtftp (
1085 PxeBc,
1086 EFI_PXE_BASE_CODE_TFTP_READ_FILE,
1087 Buffer,
1088 FALSE,
1089 BufferSize,
1090 &Private->BlockSize,
1091 &Private->ServerIp,
1092 Private->BootFileName,
1093 NULL,
1094 FALSE
1095 );
1096
1097
1098 } else {
1099 Status = EFI_BUFFER_TOO_SMALL;
1100 }
1101
1102 return Status;
1103 }
1104
1105
1106 /**
1107 Load boot file into user buffer.
1108
1109 @param[in] Private Pointer to PxeBc private data.
1110 @param[in, out] BufferSize Size of user buffer for input;
1111 required buffer size for output.
1112 @param[in] Buffer Pointer to user buffer.
1113
1114 @retval EFI_SUCCESS Get all the boot information successfully.
1115 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
1116 @retval EFI_ABORTED User cancelled the current operation.
1117 @retval Others Failed to parse out the boot information.
1118
1119 **/
1120 EFI_STATUS
1121 PxeBcLoadBootFile (
1122 IN PXEBC_PRIVATE_DATA *Private,
1123 IN OUT UINTN *BufferSize,
1124 IN VOID *Buffer OPTIONAL
1125 )
1126 {
1127 BOOLEAN NewMakeCallback;
1128 UINT64 RequiredSize;
1129 UINT64 CurrentSize;
1130 EFI_STATUS Status;
1131 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1132 EFI_PXE_BASE_CODE_MODE *PxeBcMode;
1133
1134 NewMakeCallback = FALSE;
1135 PxeBc = &Private->PxeBc;
1136 PxeBcMode = &Private->Mode;
1137 CurrentSize = *BufferSize;
1138 RequiredSize = 0;
1139
1140 //
1141 // Install pxebc callback protocol if hasn't been installed yet.
1142 //
1143 Status = PxeBcInstallCallback (Private, &NewMakeCallback);
1144 if (EFI_ERROR(Status)) {
1145 return Status;
1146 }
1147
1148 if (Private->BootFileSize == 0) {
1149 //
1150 // Discover the boot information about the bootfile if hasn't.
1151 //
1152 Status = PxeBcDiscoverBootFile (Private, &RequiredSize);
1153 if (EFI_ERROR (Status)) {
1154 goto ON_EXIT;
1155 }
1156
1157 if (PXEBC_IS_SIZE_OVERFLOWED (RequiredSize)) {
1158 //
1159 // It's error if the required buffer size is beyond the system scope.
1160 //
1161 Status = EFI_DEVICE_ERROR;
1162 goto ON_EXIT;
1163 } else if (RequiredSize > 0) {
1164 //
1165 // Get the right buffer size of the bootfile required.
1166 //
1167 if (CurrentSize < RequiredSize || Buffer == NULL) {
1168 //
1169 // It's buffer too small if the size of user buffer is smaller than the required.
1170 //
1171 CurrentSize = RequiredSize;
1172 Status = EFI_BUFFER_TOO_SMALL;
1173 goto ON_EXIT;
1174 }
1175 CurrentSize = RequiredSize;
1176 } else if (RequiredSize == 0 && PxeBcMode->UsingIpv6) {
1177 //
1178 // Try to download another bootfile in list if failed to get the filesize of the last one.
1179 // It's special for the case of IPv6.
1180 //
1181 Status = PxeBcReadBootFileList (Private, &CurrentSize, Buffer);
1182 goto ON_EXIT;
1183 }
1184 } else if (CurrentSize < Private->BootFileSize || Buffer == NULL ) {
1185 //
1186 // It's buffer too small if the size of user buffer is smaller than the required.
1187 //
1188 CurrentSize = Private->BootFileSize;
1189 Status = EFI_BUFFER_TOO_SMALL;
1190 goto ON_EXIT;
1191 }
1192
1193 //
1194 // Begin to download the bootfile if everything is ready.
1195 //
1196 AsciiPrint ("\n Downloading NBP file...\n");
1197 if (PxeBcMode->UsingIpv6) {
1198 Status = PxeBcReadBootFileList (
1199 Private,
1200 &CurrentSize,
1201 Buffer
1202 );
1203 } else {
1204 Status = PxeBc->Mtftp (
1205 PxeBc,
1206 EFI_PXE_BASE_CODE_TFTP_READ_FILE,
1207 Buffer,
1208 FALSE,
1209 &CurrentSize,
1210 &Private->BlockSize,
1211 &Private->ServerIp,
1212 Private->BootFileName,
1213 NULL,
1214 FALSE
1215 );
1216 }
1217
1218 ON_EXIT:
1219 *BufferSize = (UINTN) CurrentSize;
1220 PxeBcUninstallCallback(Private, NewMakeCallback);
1221
1222 if (Status == EFI_SUCCESS) {
1223 AsciiPrint ("\n Succeed to download NBP file.\n");
1224 return EFI_SUCCESS;
1225 } else if (Status == EFI_BUFFER_TOO_SMALL && Buffer != NULL) {
1226 AsciiPrint ("\n PXE-E05: Buffer size is smaller than the requested file.\n");
1227 } else if (Status == EFI_DEVICE_ERROR) {
1228 AsciiPrint ("\n PXE-E07: Network device error.\n");
1229 } else if (Status == EFI_OUT_OF_RESOURCES) {
1230 AsciiPrint ("\n PXE-E09: Could not allocate I/O buffers.\n");
1231 } else if (Status == EFI_NO_MEDIA) {
1232 AsciiPrint ("\n PXE-E12: Could not detect network connection.\n");
1233 } else if (Status == EFI_NO_RESPONSE) {
1234 AsciiPrint ("\n PXE-E16: No offer received.\n");
1235 } else if (Status == EFI_TIMEOUT) {
1236 AsciiPrint ("\n PXE-E18: Server response timeout.\n");
1237 } else if (Status == EFI_ABORTED) {
1238 AsciiPrint ("\n PXE-E21: Remote boot cancelled.\n");
1239 } else if (Status == EFI_ICMP_ERROR) {
1240 AsciiPrint ("\n PXE-E22: Client received ICMP error from server.\n");
1241 } else if (Status == EFI_TFTP_ERROR) {
1242 AsciiPrint ("\n PXE-E23: Client received TFTP error from server.\n");
1243 } else if (Status == EFI_NOT_FOUND) {
1244 AsciiPrint ("\n PXE-E53: No boot filename received.\n");
1245 } else if (Status != EFI_BUFFER_TOO_SMALL) {
1246 AsciiPrint ("\n PXE-E99: Unexpected network error.\n");
1247 }
1248
1249 return Status;
1250 }
1251
EFI Development Kit II mirror for PVE