]> 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
Fix a bug about the iSCSI DHCP dependency issue.
[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcBoot.c
1 /** @file
2 Boot functions implementation for UefiPxeBc Driver.
3
4 Copyright (c) 2009 - 2013, 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
472 PxeBc = &Private->PxeBc;
473 Mode = PxeBc->Mode;
474 Status = EFI_SUCCESS;
475 *BufferSize = 0;
476
477 //
478 // Get the last received Dhcp4 reply packet.
479 //
480 if (Mode->PxeReplyReceived) {
481 Cache4 = &Private->PxeReply.Dhcp4;
482 } else if (Mode->ProxyOfferReceived) {
483 Cache4 = &Private->ProxyOffer.Dhcp4;
484 } else {
485 Cache4 = &Private->DhcpAck.Dhcp4;
486 }
487
488 //
489 // Parse the boot server Ipv4 address by next server address.
490 // If this field isn't available, use option 54 instead.
491 //
492 CopyMem (
493 &Private->ServerIp,
494 &Cache4->Packet.Offer.Dhcp4.Header.ServerAddr,
495 sizeof (EFI_IPv4_ADDRESS)
496 );
497
498 if (Private->ServerIp.Addr[0] == 0) {
499 CopyMem (
500 &Private->ServerIp,
501 Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,
502 sizeof (EFI_IPv4_ADDRESS)
503 );
504 }
505
506 //
507 // Parse the boot file name by option.
508 //
509 ASSERT (Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL);
510 Private->BootFileName = Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data;
511
512 if (Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN] != NULL) {
513 //
514 // Parse the boot file size by option.
515 //
516 CopyMem (&Value, Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE_LEN]->Data, sizeof (Value));
517 Value = NTOHS (Value);
518 //
519 // The field of boot file size is 512 bytes in unit.
520 //
521 *BufferSize = 512 * Value;
522 } else {
523 //
524 // Get the bootfile size by tftp command if no option available.
525 //
526 Status = PxeBc->Mtftp (
527 PxeBc,
528 EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
529 NULL,
530 FALSE,
531 BufferSize,
532 &Private->BlockSize,
533 &Private->ServerIp,
534 Private->BootFileName,
535 NULL,
536 FALSE
537 );
538 }
539
540 //
541 // Save the value of boot file size.
542 //
543 Private->BootFileSize = (UINTN) *BufferSize;
544
545 //
546 // Display all the information: boot server address, boot file name and boot file size.
547 //
548 AsciiPrint ("\n Server IP address is ");
549 PxeBcShowIp4Addr (&Private->ServerIp.v4);
550 AsciiPrint ("\n NBP filename is %a", Private->BootFileName);
551 AsciiPrint ("\n NBP filesize is %d Bytes", Private->BootFileSize);
552
553 return Status;
554 }
555
556
557 /**
558 Parse out the boot information from the last Dhcp6 reply packet.
559
560 @param[in, out] Private Pointer to PxeBc private data.
561 @param[out] BufferSize Size of the boot file to be downloaded.
562
563 @retval EFI_SUCCESS Successfully parsed out all the boot information.
564 @retval EFI_BUFFER_TOO_SMALL
565 @retval Others Failed to parse out the boot information.
566
567 **/
568 EFI_STATUS
569 PxeBcDhcp6BootInfo (
570 IN OUT PXEBC_PRIVATE_DATA *Private,
571 OUT UINT64 *BufferSize
572 )
573 {
574 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
575 EFI_PXE_BASE_CODE_MODE *Mode;
576 EFI_STATUS Status;
577 PXEBC_DHCP6_PACKET_CACHE *Cache6;
578 UINT16 Value;
579
580 PxeBc = &Private->PxeBc;
581 Mode = PxeBc->Mode;
582 Status = EFI_SUCCESS;
583 *BufferSize = 0;
584
585 //
586 // Get the last received Dhcp6 reply packet.
587 //
588 if (Mode->PxeReplyReceived) {
589 Cache6 = &Private->PxeReply.Dhcp6;
590 } else if (Mode->ProxyOfferReceived) {
591 Cache6 = &Private->ProxyOffer.Dhcp6;
592 } else {
593 Cache6 = &Private->DhcpAck.Dhcp6;
594 }
595
596 ASSERT (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);
597
598 //
599 // Parse (m)tftp server ip address and bootfile name.
600 //
601 Status = PxeBcExtractBootFileUrl (
602 &Private->BootFileName,
603 &Private->ServerIp.v6,
604 (CHAR8 *) (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),
605 NTOHS (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->OpLen)
606 );
607 if (EFI_ERROR (Status)) {
608 return Status;
609 }
610
611 //
612 // Parse the value of boot file size.
613 //
614 if (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM] != NULL) {
615 //
616 // Parse it out if have the boot file parameter option.
617 //
618 Status = PxeBcExtractBootFileParam ((CHAR8 *) Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM]->Data, &Value);
619 if (EFI_ERROR (Status)) {
620 return Status;
621 }
622 //
623 // The field of boot file size is 512 bytes in unit.
624 //
625 *BufferSize = 512 * Value;
626 } else {
627 //
628 // Send get file size command by tftp if option unavailable.
629 //
630 Status = PxeBc->Mtftp (
631 PxeBc,
632 EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
633 NULL,
634 FALSE,
635 BufferSize,
636 &Private->BlockSize,
637 &Private->ServerIp,
638 Private->BootFileName,
639 NULL,
640 FALSE
641 );
642 }
643
644 //
645 // Save the value of boot file size.
646 //
647 Private->BootFileSize = (UINTN) *BufferSize;
648
649 //
650 // Display all the information: boot server address, boot file name and boot file size.
651 //
652 AsciiPrint ("\n Server IP address is ");
653 PxeBcShowIp6Addr (&Private->ServerIp.v6);
654 AsciiPrint ("\n NBP filename is %a", Private->BootFileName);
655 AsciiPrint ("\n NBP filesize is %d Bytes", Private->BootFileSize);
656
657 return Status;
658 }
659
660
661 /**
662 Extract the discover information and boot server entry from the
663 cached packets if unspecified.
664
665 @param[in] Private Pointer to PxeBc private data.
666 @param[in] Type The type of bootstrap to perform.
667 @param[in, out] DiscoverInfo Pointer to EFI_PXE_BASE_CODE_DISCOVER_INFO.
668 @param[out] BootEntry Pointer to PXEBC_BOOT_SVR_ENTRY.
669 @param[out] SrvList Pointer to EFI_PXE_BASE_CODE_SRVLIST.
670
671 @retval EFI_SUCCESS Successfully extracted the information.
672 @retval EFI_DEVICE_ERROR Failed to extract the information.
673
674 **/
675 EFI_STATUS
676 PxeBcExtractDiscoverInfo (
677 IN PXEBC_PRIVATE_DATA *Private,
678 IN UINT16 Type,
679 IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO **DiscoverInfo,
680 OUT PXEBC_BOOT_SVR_ENTRY **BootEntry,
681 OUT EFI_PXE_BASE_CODE_SRVLIST **SrvList
682 )
683 {
684 EFI_PXE_BASE_CODE_MODE *Mode;
685 PXEBC_DHCP4_PACKET_CACHE *Cache4;
686 PXEBC_VENDOR_OPTION *VendorOpt;
687 PXEBC_BOOT_SVR_ENTRY *Entry;
688 BOOLEAN IsFound;
689 EFI_PXE_BASE_CODE_DISCOVER_INFO *Info;
690 UINT16 Index;
691
692 Mode = Private->PxeBc.Mode;
693 Info = *DiscoverInfo;
694
695 if (Mode->UsingIpv6) {
696 Info->IpCnt = 1;
697 Info->UseUCast = TRUE;
698
699 Info->SrvList[0].Type = Type;
700 Info->SrvList[0].AcceptAnyResponse = FALSE;
701
702 //
703 // There is no vendor options specified in DHCPv6, so take BootFileUrl in the last cached packet.
704 //
705 CopyMem (&Info->SrvList[0].IpAddr, &Private->ServerIp, sizeof (EFI_IP_ADDRESS));
706
707 *SrvList = Info->SrvList;
708 } else {
709 Entry = NULL;
710 IsFound = FALSE;
711 Cache4 = (Mode->ProxyOfferReceived) ? &Private->ProxyOffer.Dhcp4 : &Private->DhcpAck.Dhcp4;
712 VendorOpt = &Cache4->VendorOpt;
713
714 if (!Mode->DhcpAckReceived || !IS_VALID_DISCOVER_VENDOR_OPTION (VendorOpt->BitMap)) {
715 //
716 // Address is not acquired or no discovery options.
717 //
718 return EFI_INVALID_PARAMETER;
719 }
720
721 //
722 // Parse the boot server entry from the vendor option in the last cached packet.
723 //
724 Info->UseMCast = (BOOLEAN) !IS_DISABLE_MCAST_DISCOVER (VendorOpt->DiscoverCtrl);
725 Info->UseBCast = (BOOLEAN) !IS_DISABLE_BCAST_DISCOVER (VendorOpt->DiscoverCtrl);
726 Info->MustUseList = (BOOLEAN) IS_ENABLE_USE_SERVER_LIST (VendorOpt->DiscoverCtrl);
727 Info->UseUCast = (BOOLEAN) IS_VALID_BOOT_SERVERS (VendorOpt->BitMap);
728
729 if (Info->UseMCast) {
730 //
731 // Get the multicast discover ip address from vendor option if has.
732 //
733 CopyMem (&Info->ServerMCastIp.v4, &VendorOpt->DiscoverMcastIp, sizeof (EFI_IPv4_ADDRESS));
734 }
735
736 Info->IpCnt = 0;
737
738 if (Info->UseUCast) {
739 Entry = VendorOpt->BootSvr;
740
741 while (((UINT8) (Entry - VendorOpt->BootSvr)) < VendorOpt->BootSvrLen) {
742 if (Entry->Type == HTONS (Type)) {
743 IsFound = TRUE;
744 break;
745 }
746 Entry = GET_NEXT_BOOT_SVR_ENTRY (Entry);
747 }
748
749 if (!IsFound) {
750 return EFI_DEVICE_ERROR;
751 }
752
753 Info->IpCnt = Entry->IpCnt;
754 if (Info->IpCnt >= 1) {
755 *DiscoverInfo = AllocatePool (sizeof (*Info) + (Info->IpCnt - 1) * sizeof (**SrvList));
756 if (*DiscoverInfo == NULL) {
757 return EFI_OUT_OF_RESOURCES;
758 }
759 CopyMem (*DiscoverInfo, Info, sizeof (*Info));
760 Info = *DiscoverInfo;
761 }
762
763 for (Index = 0; Index < Info->IpCnt; Index++) {
764 CopyMem (&Info->SrvList[Index].IpAddr, &Entry->IpAddr[Index], sizeof (EFI_IPv4_ADDRESS));
765 Info->SrvList[Index].AcceptAnyResponse = !Info->MustUseList;
766 Info->SrvList[Index].Type = NTOHS (Entry->Type);
767 }
768 }
769
770 *BootEntry = Entry;
771 *SrvList = Info->SrvList;
772 }
773
774 return EFI_SUCCESS;
775 }
776
777
778 /**
779 Build the discover packet and send out for boot server.
780
781 @param[in] Private Pointer to PxeBc private data.
782 @param[in] Type PxeBc option boot item type.
783 @param[in] Layer Pointer to option boot item layer.
784 @param[in] UseBis Use BIS or not.
785 @param[in] DestIp Pointer to the destination address.
786 @param[in] IpCount The count of the server address.
787 @param[in] SrvList Pointer to the server address list.
788
789 @retval EFI_SUCCESS Successfully discovered boot file.
790 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource.
791 @retval EFI_NOT_FOUND Can't get the PXE reply packet.
792 @retval Others Failed to discover boot file.
793
794 **/
795 EFI_STATUS
796 PxeBcDiscoverBootServer (
797 IN PXEBC_PRIVATE_DATA *Private,
798 IN UINT16 Type,
799 IN UINT16 *Layer,
800 IN BOOLEAN UseBis,
801 IN EFI_IP_ADDRESS *DestIp,
802 IN UINT16 IpCount,
803 IN EFI_PXE_BASE_CODE_SRVLIST *SrvList
804 )
805 {
806 if (Private->PxeBc.Mode->UsingIpv6) {
807 return PxeBcDhcp6Discover (
808 Private,
809 Type,
810 Layer,
811 UseBis,
812 DestIp
813 );
814 } else {
815 return PxeBcDhcp4Discover (
816 Private,
817 Type,
818 Layer,
819 UseBis,
820 DestIp,
821 IpCount,
822 SrvList
823 );
824 }
825 }
826
827
828 /**
829 Discover all the boot information for boot file.
830
831 @param[in, out] Private Pointer to PxeBc private data.
832 @param[out] BufferSize Size of the boot file to be downloaded.
833
834 @retval EFI_SUCCESS Successfully obtained all the boot information .
835 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
836 @retval EFI_ABORTED User cancel current operation.
837 @retval Others Failed to parse out the boot information.
838
839 **/
840 EFI_STATUS
841 PxeBcDiscoverBootFile (
842 IN OUT PXEBC_PRIVATE_DATA *Private,
843 OUT UINT64 *BufferSize
844 )
845 {
846 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
847 EFI_PXE_BASE_CODE_MODE *Mode;
848 EFI_STATUS Status;
849 UINT16 Type;
850 UINT16 Layer;
851 BOOLEAN UseBis;
852
853 PxeBc = &Private->PxeBc;
854 Mode = PxeBc->Mode;
855 Type = EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP;
856 Layer = EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL;
857
858 //
859 // Start D.O.R.A/S.A.R.R exchange to acquire station ip address and
860 // other pxe boot information.
861 //
862 Status = PxeBc->Dhcp (PxeBc, TRUE);
863 if (EFI_ERROR (Status)) {
864 return Status;
865 }
866
867 //
868 // Select a boot server from boot server list.
869 //
870 Status = PxeBcSelectBootPrompt (Private);
871
872 if (Status == EFI_SUCCESS) {
873 //
874 // Choose by user's input.
875 //
876 Status = PxeBcSelectBootMenu (Private, &Type, FALSE);
877 } else if (Status == EFI_TIMEOUT) {
878 //
879 // Choose by default item.
880 //
881 Status = PxeBcSelectBootMenu (Private, &Type, TRUE);
882 }
883
884 if (!EFI_ERROR (Status)) {
885
886 if (Type == EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP) {
887 //
888 // Local boot(PXE bootstrap server) need abort
889 //
890 return EFI_ABORTED;
891 }
892
893 //
894 // Start to discover the boot server to get (m)tftp server ip address, bootfile
895 // name and bootfile size.
896 //
897 UseBis = (BOOLEAN) (Mode->BisSupported && Mode->BisDetected);
898 Status = PxeBc->Discover (PxeBc, Type, &Layer, UseBis, NULL);
899 if (EFI_ERROR (Status)) {
900 return Status;
901 }
902
903 if (Mode->PxeReplyReceived && !Mode->ProxyOfferReceived) {
904 //
905 // Some network boot loader only search the packet in Mode.ProxyOffer to get its server
906 // IP address, so we need to store a copy of Mode.PxeReply packet into Mode.ProxyOffer.
907 //
908 if (Mode->UsingIpv6) {
909 CopyMem (
910 &Mode->ProxyOffer.Dhcpv6,
911 &Mode->PxeReply.Dhcpv6,
912 Private->PxeReply.Dhcp6.Packet.Ack.Length
913 );
914 } else {
915 CopyMem (
916 &Mode->ProxyOffer.Dhcpv4,
917 &Mode->PxeReply.Dhcpv4,
918 Private->PxeReply.Dhcp4.Packet.Ack.Length
919 );
920 }
921 Mode->ProxyOfferReceived = TRUE;
922 }
923 }
924
925 //
926 // Parse the boot information.
927 //
928 if (Mode->UsingIpv6) {
929 Status = PxeBcDhcp6BootInfo (Private, BufferSize);
930 } else {
931 Status = PxeBcDhcp4BootInfo (Private, BufferSize);
932 }
933
934 return Status;
935 }
936
937
938 /**
939 Install PxeBaseCodeCallbackProtocol if not installed before.
940
941 @param[in, out] Private Pointer to PxeBc private data.
942 @param[out] NewMakeCallback If TRUE, it is a new callback.
943 Otherwise, it is not new callback.
944 @retval EFI_SUCCESS PxeBaseCodeCallbackProtocol installed succesfully.
945 @retval Others Failed to install PxeBaseCodeCallbackProtocol.
946
947 **/
948 EFI_STATUS
949 PxeBcInstallCallback (
950 IN OUT PXEBC_PRIVATE_DATA *Private,
951 OUT BOOLEAN *NewMakeCallback
952 )
953 {
954 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
955 EFI_STATUS Status;
956
957 //
958 // Check whether PxeBaseCodeCallbackProtocol already installed.
959 //
960 PxeBc = &Private->PxeBc;
961 Status = gBS->HandleProtocol (
962 Private->Controller,
963 &gEfiPxeBaseCodeCallbackProtocolGuid,
964 (VOID **) &Private->PxeBcCallback
965 );
966 if (Status == EFI_UNSUPPORTED) {
967
968 CopyMem (
969 &Private->LoadFileCallback,
970 &gPxeBcCallBackTemplate,
971 sizeof (EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL)
972 );
973
974 //
975 // Install a default callback if user didn't offer one.
976 //
977 Status = gBS->InstallProtocolInterface (
978 &Private->Controller,
979 &gEfiPxeBaseCodeCallbackProtocolGuid,
980 EFI_NATIVE_INTERFACE,
981 &Private->LoadFileCallback
982 );
983
984 (*NewMakeCallback) = (BOOLEAN) (Status == EFI_SUCCESS);
985
986 Status = PxeBc->SetParameters (PxeBc, NULL, NULL, NULL, NULL, NewMakeCallback);
987 if (EFI_ERROR (Status)) {
988 PxeBc->Stop (PxeBc);
989 return Status;
990 }
991 }
992
993 return EFI_SUCCESS;
994 }
995
996
997 /**
998 Uninstall PxeBaseCodeCallbackProtocol.
999
1000 @param[in] Private Pointer to PxeBc private data.
1001 @param[in] NewMakeCallback If TRUE, it is a new callback.
1002 Otherwise, it is not new callback.
1003
1004 **/
1005 VOID
1006 PxeBcUninstallCallback (
1007 IN PXEBC_PRIVATE_DATA *Private,
1008 IN BOOLEAN NewMakeCallback
1009 )
1010 {
1011 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1012
1013 PxeBc = &Private->PxeBc;
1014
1015 if (NewMakeCallback) {
1016
1017 NewMakeCallback = FALSE;
1018
1019 PxeBc->SetParameters (PxeBc, NULL, NULL, NULL, NULL, &NewMakeCallback);
1020
1021 gBS->UninstallProtocolInterface (
1022 Private->Controller,
1023 &gEfiPxeBaseCodeCallbackProtocolGuid,
1024 &Private->LoadFileCallback
1025 );
1026 }
1027 }
1028
1029
1030 /**
1031 Download one of boot file in the list, and it's special for IPv6.
1032
1033 @param[in] Private Pointer to PxeBc private data.
1034 @param[in, out] BufferSize Size of user buffer for input;
1035 required buffer size for output.
1036 @param[in] Buffer Pointer to user buffer.
1037
1038 @retval EFI_SUCCESS Read one of boot file in the list successfully.
1039 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
1040 @retval EFI_NOT_FOUND There is no proper boot file available.
1041 @retval Others Failed to download boot file in the list.
1042
1043 **/
1044 EFI_STATUS
1045 PxeBcReadBootFileList (
1046 IN PXEBC_PRIVATE_DATA *Private,
1047 IN OUT UINT64 *BufferSize,
1048 IN VOID *Buffer OPTIONAL
1049 )
1050 {
1051 EFI_STATUS Status;
1052 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1053
1054 PxeBc = &Private->PxeBc;
1055
1056 //
1057 // Try to download the boot file if everything is ready.
1058 //
1059 if (Buffer != NULL) {
1060 Status = PxeBc->Mtftp (
1061 PxeBc,
1062 EFI_PXE_BASE_CODE_TFTP_READ_FILE,
1063 Buffer,
1064 FALSE,
1065 BufferSize,
1066 &Private->BlockSize,
1067 &Private->ServerIp,
1068 Private->BootFileName,
1069 NULL,
1070 FALSE
1071 );
1072
1073
1074 } else {
1075 Status = EFI_BUFFER_TOO_SMALL;
1076 }
1077
1078 return Status;
1079 }
1080
1081
1082 /**
1083 Load boot file into user buffer.
1084
1085 @param[in] Private Pointer to PxeBc private data.
1086 @param[in, out] BufferSize Size of user buffer for input;
1087 required buffer size for output.
1088 @param[in] Buffer Pointer to user buffer.
1089
1090 @retval EFI_SUCCESS Get all the boot information successfully.
1091 @retval EFI_BUFFER_TOO_SMALL The buffer size is not enough for boot file.
1092 @retval EFI_ABORTED User cancelled the current operation.
1093 @retval Others Failed to parse out the boot information.
1094
1095 **/
1096 EFI_STATUS
1097 PxeBcLoadBootFile (
1098 IN PXEBC_PRIVATE_DATA *Private,
1099 IN OUT UINTN *BufferSize,
1100 IN VOID *Buffer OPTIONAL
1101 )
1102 {
1103 BOOLEAN NewMakeCallback;
1104 UINT64 RequiredSize;
1105 UINT64 CurrentSize;
1106 EFI_STATUS Status;
1107 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;
1108 EFI_PXE_BASE_CODE_MODE *PxeBcMode;
1109
1110 NewMakeCallback = FALSE;
1111 PxeBc = &Private->PxeBc;
1112 PxeBcMode = &Private->Mode;
1113 CurrentSize = *BufferSize;
1114 RequiredSize = 0;
1115
1116 //
1117 // Install pxebc callback protocol if hasn't been installed yet.
1118 //
1119 Status = PxeBcInstallCallback (Private, &NewMakeCallback);
1120 if (EFI_ERROR(Status)) {
1121 return Status;
1122 }
1123
1124 if (Private->BootFileSize == 0) {
1125 //
1126 // Discover the boot information about the bootfile if hasn't.
1127 //
1128 Status = PxeBcDiscoverBootFile (Private, &RequiredSize);
1129 if (EFI_ERROR (Status)) {
1130 goto ON_EXIT;
1131 }
1132
1133 if (PXEBC_IS_SIZE_OVERFLOWED (RequiredSize)) {
1134 //
1135 // It's error if the required buffer size is beyond the system scope.
1136 //
1137 Status = EFI_DEVICE_ERROR;
1138 goto ON_EXIT;
1139 } else if (RequiredSize > 0) {
1140 //
1141 // Get the right buffer size of the bootfile required.
1142 //
1143 if (CurrentSize < RequiredSize || Buffer == NULL) {
1144 //
1145 // It's buffer too small if the size of user buffer is smaller than the required.
1146 //
1147 CurrentSize = RequiredSize;
1148 Status = EFI_BUFFER_TOO_SMALL;
1149 goto ON_EXIT;
1150 }
1151 CurrentSize = RequiredSize;
1152 } else if (RequiredSize == 0 && PxeBcMode->UsingIpv6) {
1153 //
1154 // Try to download another bootfile in list if failed to get the filesize of the last one.
1155 // It's special for the case of IPv6.
1156 //
1157 Status = PxeBcReadBootFileList (Private, &CurrentSize, Buffer);
1158 goto ON_EXIT;
1159 }
1160 } else if (CurrentSize < Private->BootFileSize || Buffer == NULL ) {
1161 //
1162 // It's buffer too small if the size of user buffer is smaller than the required.
1163 //
1164 CurrentSize = Private->BootFileSize;
1165 Status = EFI_BUFFER_TOO_SMALL;
1166 goto ON_EXIT;
1167 }
1168
1169 //
1170 // Begin to download the bootfile if everything is ready.
1171 //
1172 AsciiPrint ("\n Downloading NBP file...\n");
1173 if (PxeBcMode->UsingIpv6) {
1174 Status = PxeBcReadBootFileList (
1175 Private,
1176 &CurrentSize,
1177 Buffer
1178 );
1179 } else {
1180 Status = PxeBc->Mtftp (
1181 PxeBc,
1182 EFI_PXE_BASE_CODE_TFTP_READ_FILE,
1183 Buffer,
1184 FALSE,
1185 &CurrentSize,
1186 &Private->BlockSize,
1187 &Private->ServerIp,
1188 Private->BootFileName,
1189 NULL,
1190 FALSE
1191 );
1192 }
1193
1194 ON_EXIT:
1195 *BufferSize = (UINTN) CurrentSize;
1196 PxeBcUninstallCallback(Private, NewMakeCallback);
1197
1198 if (Status == EFI_SUCCESS) {
1199 AsciiPrint ("\n Succeed to download NBP file.\n");
1200 return EFI_SUCCESS;
1201 } else if (Status == EFI_BUFFER_TOO_SMALL && Buffer != NULL) {
1202 AsciiPrint ("\n PXE-E05: Buffer size is smaller than the requested file.\n");
1203 } else if (Status == EFI_DEVICE_ERROR) {
1204 AsciiPrint ("\n PXE-E07: Network device error.\n");
1205 } else if (Status == EFI_OUT_OF_RESOURCES) {
1206 AsciiPrint ("\n PXE-E09: Could not allocate I/O buffers.\n");
1207 } else if (Status == EFI_NO_MEDIA) {
1208 AsciiPrint ("\n PXE-E12: Could not detect network connection.\n");
1209 } else if (Status == EFI_NO_RESPONSE) {
1210 AsciiPrint ("\n PXE-E16: No offer received.\n");
1211 } else if (Status == EFI_TIMEOUT) {
1212 AsciiPrint ("\n PXE-E18: Server response timeout.\n");
1213 } else if (Status == EFI_ABORTED) {
1214 AsciiPrint ("\n PXE-E21: Remote boot cancelled.\n");
1215 } else if (Status == EFI_ICMP_ERROR) {
1216 AsciiPrint ("\n PXE-E22: Client received ICMP error from server.\n");
1217 } else if (Status == EFI_TFTP_ERROR) {
1218 AsciiPrint ("\n PXE-E23: Client received TFTP error from server.\n");
1219 } else if (Status == EFI_NOT_FOUND) {
1220 AsciiPrint ("\n PXE-E53: No boot filename received.\n");
1221 } else if (Status != EFI_BUFFER_TOO_SMALL) {
1222 AsciiPrint ("\n PXE-E99: Unexpected network error.\n");
1223 }
1224
1225 return Status;
1226 }
1227
EFI Development Kit II mirror for PVE