1 /** @file 2 Main file for BCFG command. 3 4 (C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR> 5 Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR> 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions of the BSD License 8 which accompanies this distribution. The full text of the license may be found at 9 http://opensource.org/licenses/bsd-license.php 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 17 #include <Uefi.h> 18 19 #include <Guid/GlobalVariable.h> 20 #include <Guid/ShellLibHiiGuid.h> 21 22 #include <Protocol/Shell.h> 23 #include <Protocol/ShellParameters.h> 24 #include <Protocol/DevicePath.h> 25 #include <Protocol/LoadedImage.h> 26 #include <Protocol/UnicodeCollation.h> 27 28 #include <Library/BaseLib.h> 29 #include <Library/BaseMemoryLib.h> 30 #include <Library/DebugLib.h> 31 #include <Library/MemoryAllocationLib.h> 32 #include <Library/PcdLib.h> 33 #include <Library/ShellCommandLib.h> 34 #include <Library/ShellLib.h> 35 #include <Library/SortLib.h> 36 #include <Library/UefiLib.h> 37 #include <Library/UefiRuntimeServicesTableLib.h> 38 #include <Library/UefiBootServicesTableLib.h> 39 #include <Library/HiiLib.h> 40 #include <Library/FileHandleLib.h> 41 #include <Library/PrintLib.h> 42 #include <Library/HandleParsingLib.h> 43 #include <Library/DevicePathLib.h> 44 45 STATIC CONST CHAR16 mFileName[] = L"ShellCommands"; 46 STATIC EFI_HANDLE gShellBcfgHiiHandle = NULL; 47 48 typedef enum { 49 BcfgTargetBootOrder = 0, 50 BcfgTargetDriverOrder = 1, 51 BcfgTargetMax = 2 52 } BCFG_OPERATION_TARGET; 53 54 typedef enum { 55 BcfgTypeDump = 0, 56 BcfgTypeAdd = 1, 57 BcfgTypeAddp = 2, 58 BcfgTypeAddh = 3, 59 BcfgTypeRm = 4, 60 BcfgTypeMv = 5, 61 BcfgTypeOpt = 6, 62 BcfgTypeMax = 7 63 } BCFG_OPERATION_TYPE; 64 65 typedef struct { 66 BCFG_OPERATION_TARGET Target; 67 BCFG_OPERATION_TYPE Type; 68 UINT16 Number1; 69 UINT16 Number2; 70 UINTN HandleIndex; 71 CHAR16 *FileName; 72 CHAR16 *Description; 73 UINT16 *Order; 74 CONST CHAR16 *OptData; 75 } BGFG_OPERATION; 76 77 /** 78 Update the optional data for a boot or driver option. 79 80 If optional data exists it will be changed. 81 82 @param[in] Index The boot or driver option index update. 83 @param[in] DataSize The size in bytes of Data. 84 @param[in] Data The buffer for the optioanl data. 85 @param[in] Target The target of the operation. 86 87 @retval EFI_SUCCESS The data was sucessfully updated. 88 @retval other A error occured. 89 **/ 90 EFI_STATUS 91 UpdateOptionalData( 92 UINT16 Index, 93 UINTN DataSize, 94 UINT8 *Data, 95 IN CONST BCFG_OPERATION_TARGET Target 96 ) 97 { 98 EFI_STATUS Status; 99 CHAR16 VariableName[12]; 100 UINTN OriginalSize; 101 UINT8 *OriginalData; 102 UINTN NewSize; 103 UINT8 *NewData; 104 UINTN OriginalOptionDataSize; 105 106 UnicodeSPrint(VariableName, sizeof(VariableName), L"%s%04x", Target == BcfgTargetBootOrder?L"Boot":L"Driver", Index); 107 108 OriginalSize = 0; 109 OriginalData = NULL; 110 NewData = NULL; 111 NewSize = 0; 112 113 Status = gRT->GetVariable( 114 VariableName, 115 (EFI_GUID*)&gEfiGlobalVariableGuid, 116 NULL, 117 &OriginalSize, 118 OriginalData); 119 if (Status == EFI_BUFFER_TOO_SMALL) { 120 OriginalData = AllocateZeroPool(OriginalSize); 121 if (OriginalData == NULL) { 122 return (EFI_OUT_OF_RESOURCES); 123 } 124 Status = gRT->GetVariable( 125 VariableName, 126 (EFI_GUID*)&gEfiGlobalVariableGuid, 127 NULL, 128 &OriginalSize, 129 OriginalData); 130 } 131 132 if (!EFI_ERROR(Status)) { 133 // 134 // Allocate new struct and discard old optional data. 135 // 136 ASSERT (OriginalData != NULL); 137 OriginalOptionDataSize = sizeof(UINT32) + sizeof(UINT16) + StrSize(((CHAR16*)(OriginalData + sizeof(UINT32) + sizeof(UINT16)))); 138 OriginalOptionDataSize += (*(UINT16*)(OriginalData + sizeof(UINT32))); 139 OriginalOptionDataSize -= OriginalSize; 140 NewSize = OriginalSize - OriginalOptionDataSize + DataSize; 141 NewData = AllocateCopyPool(NewSize, OriginalData); 142 if (NewData == NULL) { 143 Status = EFI_OUT_OF_RESOURCES; 144 } else { 145 CopyMem(NewData + OriginalSize - OriginalOptionDataSize, Data, DataSize); 146 } 147 } 148 149 if (!EFI_ERROR(Status)) { 150 // 151 // put the data back under the variable 152 // 153 Status = gRT->SetVariable( 154 VariableName, 155 (EFI_GUID*)&gEfiGlobalVariableGuid, 156 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 157 NewSize, 158 NewData); 159 } 160 161 SHELL_FREE_NON_NULL(OriginalData); 162 SHELL_FREE_NON_NULL(NewData); 163 return (Status); 164 } 165 166 /** 167 This function will get a CRC for a boot option. 168 169 @param[in, out] Crc The CRC value to return. 170 @param[in] BootIndex The boot option index to CRC. 171 172 @retval EFI_SUCCESS The CRC was sucessfully returned. 173 @retval other A error occured. 174 **/ 175 EFI_STATUS 176 GetBootOptionCrc( 177 UINT32 *Crc, 178 UINT16 BootIndex 179 ) 180 { 181 CHAR16 VariableName[12]; 182 EFI_STATUS Status; 183 UINT8 *Buffer; 184 UINTN BufferSize; 185 186 Buffer = NULL; 187 BufferSize = 0; 188 189 // 190 // Get the data Buffer 191 // 192 UnicodeSPrint(VariableName, sizeof(VariableName), L"%Boot%04x", BootIndex); 193 Status = gRT->GetVariable( 194 VariableName, 195 (EFI_GUID*)&gEfiGlobalVariableGuid, 196 NULL, 197 &BufferSize, 198 NULL); 199 if (Status == EFI_BUFFER_TOO_SMALL) { 200 Buffer = AllocateZeroPool(BufferSize); 201 Status = gRT->GetVariable( 202 VariableName, 203 (EFI_GUID*)&gEfiGlobalVariableGuid, 204 NULL, 205 &BufferSize, 206 Buffer); 207 } 208 209 // 210 // Get the CRC computed 211 // 212 if (!EFI_ERROR(Status)) { 213 Status = gBS->CalculateCrc32 (Buffer, BufferSize, Crc); 214 } 215 216 SHELL_FREE_NON_NULL(Buffer); 217 return EFI_SUCCESS; 218 } 219 220 /** 221 This function will populate the device path protocol parameter based on TheHandle. 222 223 @param[in] TheHandle Driver handle. 224 @param[in, out] FilePath On a sucessful return the device path to the handle. 225 226 @retval EFI_SUCCESS The device path was sucessfully returned. 227 @retval other A error from gBS->HandleProtocol. 228 229 @sa HandleProtocol 230 **/ 231 EFI_STATUS 232 GetDevicePathForDriverHandle ( 233 IN EFI_HANDLE TheHandle, 234 IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath 235 ) 236 { 237 EFI_STATUS Status; 238 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; 239 EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath; 240 241 Status = gBS->OpenProtocol ( 242 TheHandle, 243 &gEfiLoadedImageProtocolGuid, 244 (VOID**)&LoadedImage, 245 gImageHandle, 246 NULL, 247 EFI_OPEN_PROTOCOL_GET_PROTOCOL 248 ); 249 if (!EFI_ERROR (Status)) { 250 Status = gBS->OpenProtocol ( 251 LoadedImage->DeviceHandle, 252 &gEfiDevicePathProtocolGuid, 253 (VOID**)&ImageDevicePath, 254 gImageHandle, 255 NULL, 256 EFI_OPEN_PROTOCOL_GET_PROTOCOL 257 ); 258 if (!EFI_ERROR (Status)) { 259 // *DevPath = DuplicateDevicePath (ImageDevicePath); 260 // *FilePath = DuplicateDevicePath (LoadedImage->FilePath); 261 *FilePath = AppendDevicePath(ImageDevicePath,LoadedImage->FilePath); 262 gBS->CloseProtocol( 263 LoadedImage->DeviceHandle, 264 &gEfiDevicePathProtocolGuid, 265 gImageHandle, 266 NULL); 267 } 268 gBS->CloseProtocol( 269 TheHandle, 270 &gEfiLoadedImageProtocolGuid, 271 gImageHandle, 272 NULL); 273 } 274 return (Status); 275 } 276 277 /** 278 Function to add a option. 279 280 @param[in] Position The position to add Target at. 281 @param[in] File The file to make the target. 282 @param[in] Desc The description text. 283 @param[in] CurrentOrder The pointer to the current order of items. 284 @param[in] OrderCount The number if items in CurrentOrder. 285 @param[in] Target The info on the option to add. 286 @param[in] UseHandle TRUE to use HandleNumber, FALSE to use File and Desc. 287 @param[in] UsePath TRUE to convert to devicepath. 288 @param[in] HandleNumber The handle number to add. 289 290 @retval SHELL_SUCCESS The operation was successful. 291 @retval SHELL_INVALID_PARAMETER A parameter was invalid. 292 **/ 293 SHELL_STATUS 294 BcfgAdd( 295 IN UINTN Position, 296 IN CONST CHAR16 *File, 297 IN CONST CHAR16 *Desc, 298 IN CONST UINT16 *CurrentOrder, 299 IN CONST UINTN OrderCount, 300 IN CONST BCFG_OPERATION_TARGET Target, 301 IN CONST BOOLEAN UseHandle, 302 IN CONST BOOLEAN UsePath, 303 IN CONST UINTN HandleNumber 304 ) 305 { 306 EFI_STATUS Status; 307 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 308 EFI_DEVICE_PATH_PROTOCOL *DevPath; 309 EFI_DEVICE_PATH_PROTOCOL *FilePath; 310 CHAR16 *Str; 311 UINT8 *TempByteBuffer; 312 UINT8 *TempByteStart; 313 EFI_SHELL_FILE_INFO *Arg; 314 EFI_SHELL_FILE_INFO *FileList; 315 CHAR16 OptionStr[40]; 316 UINTN DescSize, FilePathSize; 317 BOOLEAN Found; 318 UINTN TargetLocation; 319 UINTN Index; 320 EFI_HANDLE *Handles; 321 EFI_HANDLE CurHandle; 322 UINTN DriverBindingHandleCount; 323 UINTN ParentControllerHandleCount; 324 UINTN ChildControllerHandleCount; 325 SHELL_STATUS ShellStatus; 326 UINT16 *NewOrder; 327 328 if (!UseHandle) { 329 if (File == NULL || Desc == NULL) { 330 return (SHELL_INVALID_PARAMETER); 331 } 332 } else { 333 if (HandleNumber == 0) { 334 return (SHELL_INVALID_PARAMETER); 335 } 336 } 337 338 if (Position > OrderCount) { 339 Position = OrderCount; 340 } 341 342 Str = NULL; 343 FilePath = NULL; 344 FileList = NULL; 345 Handles = NULL; 346 ShellStatus = SHELL_SUCCESS; 347 TargetLocation = 0xFFFF; 348 349 if (UseHandle) { 350 CurHandle = ConvertHandleIndexToHandle(HandleNumber); 351 if (CurHandle == NULL) { 352 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Handle Number"); 353 ShellStatus = SHELL_INVALID_PARAMETER; 354 } else { 355 if (Target == BcfgTargetBootOrder) { 356 // 357 //Make sure that the handle should point to a real controller 358 // 359 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS ( 360 CurHandle, 361 &DriverBindingHandleCount, 362 NULL); 363 364 Status = PARSE_HANDLE_DATABASE_PARENTS ( 365 CurHandle, 366 &ParentControllerHandleCount, 367 NULL); 368 369 Status = ParseHandleDatabaseForChildControllers ( 370 CurHandle, 371 &ChildControllerHandleCount, 372 NULL); 373 374 if (DriverBindingHandleCount > 0 375 || ParentControllerHandleCount > 0 376 || ChildControllerHandleCount > 0) { 377 FilePath = NULL; 378 Status = gBS->HandleProtocol ( 379 CurHandle, 380 &gEfiDevicePathProtocolGuid, 381 (VOID**)&FilePath); 382 } 383 if (EFI_ERROR (Status)) { 384 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_HANDLE), gShellBcfgHiiHandle, L"bcfg", HandleNumber); 385 ShellStatus = SHELL_INVALID_PARAMETER; 386 } 387 } else { 388 // 389 //Make sure that the handle should point to driver, not a controller. 390 // 391 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS ( 392 CurHandle, 393 &DriverBindingHandleCount, 394 NULL); 395 396 Status = PARSE_HANDLE_DATABASE_PARENTS ( 397 CurHandle, 398 &ParentControllerHandleCount, 399 NULL); 400 401 Status = ParseHandleDatabaseForChildControllers ( 402 CurHandle, 403 &ChildControllerHandleCount, 404 NULL); 405 406 Status = gBS->HandleProtocol ( 407 CurHandle, 408 &gEfiDevicePathProtocolGuid, 409 (VOID**)&FilePath); 410 411 if (DriverBindingHandleCount > 0 412 || ParentControllerHandleCount > 0 413 || ChildControllerHandleCount > 0 414 || !EFI_ERROR(Status) ) { 415 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Handle Number"); 416 ShellStatus = SHELL_INVALID_PARAMETER; 417 } else { 418 // 419 // Get the DevicePath from the loaded image information. 420 // 421 Status = GetDevicePathForDriverHandle(CurHandle, &FilePath); 422 } 423 } 424 } 425 } else { 426 // 427 // Get file info 428 // 429 ShellOpenFileMetaArg ((CHAR16*)File, EFI_FILE_MODE_READ, &FileList); 430 431 if (FileList == NULL) { 432 // 433 // If filename matched nothing fail 434 // 435 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellBcfgHiiHandle, L"bcfg", File); 436 ShellStatus = SHELL_INVALID_PARAMETER; 437 } else if (FileList->Link.ForwardLink != FileList->Link.BackLink) { 438 // 439 // If filename expanded to multiple names, fail 440 // 441 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE), gShellBcfgHiiHandle, L"bcfg", File); 442 ShellStatus = SHELL_INVALID_PARAMETER; 443 } else { 444 Arg = (EFI_SHELL_FILE_INFO*)GetFirstNode(&FileList->Link); 445 if (EFI_ERROR(Arg->Status)) { 446 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_OPEN), gShellBcfgHiiHandle, L"bcfg", File); 447 ShellStatus = SHELL_INVALID_PARAMETER; 448 } else { 449 // 450 // Build FilePath to the filename 451 // 452 453 // 454 // get the device path 455 // 456 DevicePath = gEfiShellProtocol->GetDevicePathFromFilePath(Arg->FullName); 457 if (DevicePath == NULL) { 458 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_DP), gShellBcfgHiiHandle, L"bcfg", Arg->FullName); 459 ShellStatus = SHELL_UNSUPPORTED; 460 } else { 461 if (UsePath) { 462 DevPath = DevicePath; 463 ShellStatus = SHELL_INVALID_PARAMETER; 464 while (!IsDevicePathEnd(DevPath)) { 465 if ((DevicePathType(DevPath) == MEDIA_DEVICE_PATH) && 466 (DevicePathSubType(DevPath) == MEDIA_HARDDRIVE_DP)) { 467 468 // 469 // If we find it use it instead 470 // 471 ShellStatus = SHELL_SUCCESS; 472 FilePath = DuplicateDevicePath (DevPath); 473 break; 474 } 475 DevPath = NextDevicePathNode(DevPath); 476 } 477 } else { 478 FilePath = DuplicateDevicePath(DevicePath); 479 } 480 FreePool(DevicePath); 481 } 482 } 483 } 484 } 485 486 487 if (ShellStatus == SHELL_SUCCESS) { 488 // 489 // Find a free target ,a brute force implementation 490 // 491 Found = FALSE; 492 for (TargetLocation=0; TargetLocation < 0xFFFF; TargetLocation++) { 493 Found = TRUE; 494 for (Index=0; Index < OrderCount; Index++) { 495 if (CurrentOrder[Index] == TargetLocation) { 496 Found = FALSE; 497 break; 498 } 499 } 500 501 if (Found) { 502 break; 503 } 504 } 505 506 if (TargetLocation == 0xFFFF) { 507 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_TARGET_NF), gShellBcfgHiiHandle, L"bcfg"); 508 } else { 509 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_TARGET), gShellBcfgHiiHandle, TargetLocation); 510 } 511 } 512 513 if (ShellStatus == SHELL_SUCCESS) { 514 // 515 // Add the option 516 // 517 DescSize = StrSize(Desc); 518 FilePathSize = GetDevicePathSize (FilePath); 519 520 TempByteBuffer = AllocateZeroPool(sizeof(UINT32) + sizeof(UINT16) + DescSize + FilePathSize); 521 if (TempByteBuffer != NULL) { 522 TempByteStart = TempByteBuffer; 523 *((UINT32 *) TempByteBuffer) = LOAD_OPTION_ACTIVE; // Attributes 524 TempByteBuffer += sizeof (UINT32); 525 526 *((UINT16 *) TempByteBuffer) = (UINT16)FilePathSize; // FilePathListLength 527 TempByteBuffer += sizeof (UINT16); 528 529 CopyMem (TempByteBuffer, Desc, DescSize); 530 TempByteBuffer += DescSize; 531 ASSERT (FilePath != NULL); 532 CopyMem (TempByteBuffer, FilePath, FilePathSize); 533 534 UnicodeSPrint (OptionStr, sizeof(OptionStr), L"%s%04x", Target == BcfgTargetBootOrder?L"Boot":L"Driver", TargetLocation); 535 Status = gRT->SetVariable ( 536 OptionStr, 537 &gEfiGlobalVariableGuid, 538 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 539 sizeof(UINT32) + sizeof(UINT16) + DescSize + FilePathSize, 540 TempByteStart 541 ); 542 543 FreePool(TempByteStart); 544 } else { 545 Status = EFI_OUT_OF_RESOURCES; 546 } 547 548 if (EFI_ERROR(Status)) { 549 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", OptionStr); 550 } else { 551 NewOrder = AllocateZeroPool ((OrderCount + 1) * sizeof (NewOrder[0])); 552 if (NewOrder != NULL) { 553 CopyMem (NewOrder, CurrentOrder, (OrderCount) * sizeof (NewOrder[0])); 554 555 // 556 // Insert target into order list 557 // 558 for (Index = OrderCount; Index > Position; Index--) { 559 NewOrder[Index] = NewOrder[Index - 1]; 560 } 561 562 NewOrder[Position] = (UINT16) TargetLocation; 563 Status = gRT->SetVariable ( 564 Target == BcfgTargetBootOrder ? L"BootOrder" : L"DriverOrder", 565 &gEfiGlobalVariableGuid, 566 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 567 (OrderCount + 1) * sizeof (UINT16), 568 NewOrder 569 ); 570 571 FreePool (NewOrder); 572 573 if (EFI_ERROR (Status)) { 574 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder ? L"BootOrder" : L"DriverOrder"); 575 ShellStatus = SHELL_INVALID_PARAMETER; 576 } else { 577 Print (L"bcfg: Add %s as %x\n", OptionStr, Position); 578 } 579 } 580 } 581 } 582 583 // 584 //If always Free FilePath, will free devicepath in system when use "addh" 585 // 586 if (FilePath!=NULL && !UseHandle) { 587 FreePool (FilePath); 588 } 589 590 if (Str != NULL) { 591 FreePool(Str); 592 } 593 594 if (Handles != NULL) { 595 FreePool (Handles); 596 } 597 598 if (FileList != NULL) { 599 ShellCloseFileMetaArg (&FileList); 600 } 601 602 return (ShellStatus); 603 } 604 605 /** 606 Funciton to remove an item. 607 608 @param[in] Target The target item to move. 609 @param[in] CurrentOrder The pointer to the current order of items. 610 @param[in] OrderCount The number if items in CurrentOrder. 611 @param[in] Location The current location of the Target. 612 613 @retval SHELL_SUCCESS The operation was successful. 614 @retval SHELL_INVALID_PARAMETER A parameter was invalid. 615 **/ 616 SHELL_STATUS 617 BcfgRemove( 618 IN CONST BCFG_OPERATION_TARGET Target, 619 IN CONST UINT16 *CurrentOrder, 620 IN CONST UINTN OrderCount, 621 IN CONST UINT16 Location 622 ) 623 { 624 CHAR16 VariableName[12]; 625 UINT16 *NewOrder; 626 EFI_STATUS Status; 627 UINTN NewCount; 628 629 UnicodeSPrint(VariableName, sizeof(VariableName), L"%s%04x", Target == BcfgTargetBootOrder?L"Boot":L"Driver", CurrentOrder[Location]); 630 Status = gRT->SetVariable( 631 VariableName, 632 (EFI_GUID*)&gEfiGlobalVariableGuid, 633 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 634 0, 635 NULL); 636 if (EFI_ERROR(Status)) { 637 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName); 638 return (SHELL_INVALID_PARAMETER); 639 } 640 NewOrder = AllocateZeroPool(OrderCount*sizeof(CurrentOrder[0])); 641 if (NewOrder != NULL) { 642 NewCount = OrderCount; 643 CopyMem(NewOrder, CurrentOrder, OrderCount*sizeof(CurrentOrder[0])); 644 CopyMem(NewOrder+Location, NewOrder+Location+1, (OrderCount - Location - 1)*sizeof(CurrentOrder[0])); 645 NewCount--; 646 647 Status = gRT->SetVariable( 648 Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder", 649 (EFI_GUID*)&gEfiGlobalVariableGuid, 650 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 651 NewCount*sizeof(NewOrder[0]), 652 NewOrder); 653 FreePool(NewOrder); 654 } else { 655 Status = EFI_OUT_OF_RESOURCES; 656 } 657 if (EFI_ERROR(Status)) { 658 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder"); 659 return (SHELL_INVALID_PARAMETER); 660 } 661 return (SHELL_SUCCESS); 662 } 663 664 /** 665 Funciton to move a item to another location. 666 667 @param[in] Target The target item to move. 668 @param[in] CurrentOrder The pointer to the current order of items. 669 @param[in] OrderCount The number if items in CurrentOrder. 670 @param[in] OldLocation The current location of the Target. 671 @param[in] NewLocation The desired location of the Target. 672 673 @retval SHELL_SUCCESS The operation was successful. 674 @retval SHELL_INVALID_PARAMETER A parameter was invalid. 675 **/ 676 SHELL_STATUS 677 BcfgMove( 678 IN CONST BCFG_OPERATION_TARGET Target, 679 IN CONST UINT16 *CurrentOrder, 680 IN CONST UINTN OrderCount, 681 IN CONST UINT16 OldLocation, 682 IN UINT16 NewLocation 683 ) 684 { 685 UINT16 *NewOrder; 686 EFI_STATUS Status; 687 UINT16 Temp; 688 689 NewOrder = AllocateCopyPool(OrderCount*sizeof(CurrentOrder[0]), CurrentOrder); 690 if (NewOrder == NULL) { 691 return (SHELL_OUT_OF_RESOURCES); 692 } 693 694 // 695 // correct the new location 696 // 697 if (NewLocation >= OrderCount) { 698 if (OrderCount > 0) { 699 NewLocation = (UINT16)OrderCount - 1; 700 } else { 701 NewLocation = 0; 702 } 703 } 704 705 Temp = CurrentOrder[OldLocation]; 706 CopyMem(NewOrder+OldLocation, NewOrder+OldLocation+1, (OrderCount - OldLocation - 1)*sizeof(CurrentOrder[0])); 707 CopyMem(NewOrder+NewLocation+1, NewOrder+NewLocation, (OrderCount - NewLocation - 1)*sizeof(CurrentOrder[0])); 708 NewOrder[NewLocation] = Temp; 709 710 Status = gRT->SetVariable( 711 Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder", 712 (EFI_GUID*)&gEfiGlobalVariableGuid, 713 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 714 OrderCount*sizeof(CurrentOrder[0]), 715 NewOrder); 716 717 FreePool(NewOrder); 718 719 if (EFI_ERROR(Status)) { 720 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder"); 721 return (SHELL_INVALID_PARAMETER); 722 } 723 return (SHELL_SUCCESS); 724 } 725 726 /** 727 Function to add optional data to an option. 728 729 @param[in] OptData The optional data to add. 730 @param[in] CurrentOrder The pointer to the current order of items. 731 @param[in] OrderCount The number if items in CurrentOrder. 732 @param[in] Target The target of the operation. 733 734 @retval SHELL_SUCCESS The operation was succesful. 735 **/ 736 SHELL_STATUS 737 BcfgAddOpt( 738 IN CONST CHAR16 *OptData, 739 IN CONST UINT16 *CurrentOrder, 740 IN CONST UINTN OrderCount, 741 IN CONST BCFG_OPERATION_TARGET Target 742 ) 743 { 744 EFI_KEY_OPTION NewKeyOption; 745 EFI_KEY_OPTION *KeyOptionBuffer; 746 SHELL_STATUS ShellStatus; 747 EFI_STATUS Status; 748 UINT16 OptionIndex; 749 UINT16 LoopCounter; 750 UINT64 Intermediate; 751 CONST CHAR16 *Temp; 752 CONST CHAR16 *Walker; 753 CHAR16 *FileName; 754 CHAR16 *Temp2; 755 CHAR16 *Data; 756 UINT32 KeyIndex; 757 CHAR16 VariableName[12]; 758 VOID *VariableData; 759 760 SHELL_FILE_HANDLE FileHandle; 761 762 Status = EFI_SUCCESS; 763 ShellStatus = SHELL_SUCCESS; 764 Walker = OptData; 765 FileName = NULL; 766 Data = NULL; 767 KeyOptionBuffer = NULL; 768 VariableData = NULL; 769 770 ZeroMem(&NewKeyOption, sizeof(EFI_KEY_OPTION)); 771 ZeroMem(VariableName, sizeof(VariableName)); 772 773 while(Walker[0] == L' ') { 774 Walker++; 775 } 776 777 // 778 // Get the index of the variable we are changing. 779 // 780 Status = ShellConvertStringToUint64(Walker, &Intermediate, FALSE, TRUE); 781 if (EFI_ERROR(Status) || (((UINT16)Intermediate) != Intermediate) || StrStr(Walker, L" ") == NULL || ((UINT16)Intermediate) > ((UINT16)OrderCount)) { 782 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Option Index"); 783 ShellStatus = SHELL_INVALID_PARAMETER; 784 return (ShellStatus); 785 } 786 OptionIndex = (UINT16)Intermediate; 787 788 Temp = StrStr(Walker, L" "); 789 if (Temp != NULL) { 790 Walker = Temp; 791 } 792 while(Walker[0] == L' ') { 793 Walker++; 794 } 795 796 // 797 // determine whether we have file with data, quote delimited information, or a hot-key 798 // 799 if (Walker[0] == L'\"') { 800 // 801 // quoted filename or quoted information. 802 // 803 Temp = StrStr(Walker+1, L"\""); 804 if (Temp == NULL || StrLen(Temp) != 1) { 805 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker); 806 ShellStatus = SHELL_INVALID_PARAMETER; 807 } else { 808 FileName = StrnCatGrow(&FileName, NULL, Walker+1, 0); 809 if (FileName == NULL) { 810 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellBcfgHiiHandle, L"bcfg"); 811 ShellStatus = SHELL_OUT_OF_RESOURCES; 812 return (ShellStatus); 813 } 814 Temp2 = StrStr(FileName, L"\""); 815 ASSERT(Temp2 != NULL); 816 Temp2[0] = CHAR_NULL; 817 Temp2++; 818 if (StrLen(Temp2)>0) { 819 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker); 820 ShellStatus = SHELL_INVALID_PARAMETER; 821 } 822 if (EFI_ERROR(ShellFileExists(Walker))) { 823 // 824 // Not a file. must be misc information. 825 // 826 Data = FileName; 827 FileName = NULL; 828 } else { 829 FileName = StrnCatGrow(&FileName, NULL, Walker, 0); 830 } 831 } 832 } else { 833 // 834 // filename or hot key information. 835 // 836 if (StrStr(Walker, L" ") == NULL) { 837 // 838 // filename 839 // 840 if (EFI_ERROR(ShellFileExists(Walker))) { 841 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FIND_FAIL), gShellBcfgHiiHandle, L"bcfg", Walker); 842 ShellStatus = SHELL_INVALID_PARAMETER; 843 } else { 844 FileName = StrnCatGrow(&FileName, NULL, Walker, 0); 845 } 846 } else { 847 if (Target != BcfgTargetBootOrder) { 848 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_BOOT_ONLY), gShellBcfgHiiHandle, L"bcfg"); 849 ShellStatus = SHELL_INVALID_PARAMETER; 850 } 851 852 if (ShellStatus == SHELL_SUCCESS) { 853 // 854 // Get hot key information 855 // 856 Status = ShellConvertStringToUint64(Walker, &Intermediate, FALSE, TRUE); 857 if (EFI_ERROR(Status) || (((UINT32)Intermediate) != Intermediate) || StrStr(Walker, L" ") == NULL) { 858 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker); 859 ShellStatus = SHELL_INVALID_PARAMETER; 860 } 861 NewKeyOption.KeyData.PackedValue = (UINT32)Intermediate; 862 Temp = StrStr(Walker, L" "); 863 if (Temp != NULL) { 864 Walker = Temp; 865 } 866 while(Walker[0] == L' ') { 867 Walker++; 868 } 869 } 870 871 if (ShellStatus == SHELL_SUCCESS) { 872 // 873 // Now we know how many EFI_INPUT_KEY structs we need to attach to the end of the EFI_KEY_OPTION struct. 874 // Re-allocate with the added information. 875 // 876 KeyOptionBuffer = AllocateCopyPool(sizeof(EFI_KEY_OPTION) + (sizeof(EFI_INPUT_KEY) * NewKeyOption.KeyData.Options.InputKeyCount), &NewKeyOption); 877 if (KeyOptionBuffer == NULL) { 878 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellBcfgHiiHandle, L"bcfg"); 879 ShellStatus = SHELL_OUT_OF_RESOURCES; 880 } 881 } 882 for (LoopCounter = 0 ; ShellStatus == SHELL_SUCCESS && LoopCounter < NewKeyOption.KeyData.Options.InputKeyCount; LoopCounter++) { 883 // 884 // ScanCode 885 // 886 Status = ShellConvertStringToUint64(Walker, &Intermediate, FALSE, TRUE); 887 if (EFI_ERROR(Status) || (((UINT16)Intermediate) != Intermediate) || StrStr(Walker, L" ") == NULL) { 888 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker); 889 ShellStatus = SHELL_INVALID_PARAMETER; 890 } 891 ((EFI_INPUT_KEY*)(((UINT8*)KeyOptionBuffer) + sizeof(EFI_KEY_OPTION)))[LoopCounter].ScanCode = (UINT16)Intermediate; 892 Temp = StrStr(Walker, L" "); 893 if (Temp != NULL) { 894 Walker = Temp; 895 } 896 while(Walker[0] == L' ') { 897 Walker++; 898 } 899 900 // 901 // UnicodeChar 902 // 903 Status = ShellConvertStringToUint64(Walker, &Intermediate, FALSE, TRUE); 904 if (EFI_ERROR(Status) || (((UINT16)Intermediate) != Intermediate)) { 905 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker); 906 ShellStatus = SHELL_INVALID_PARAMETER; 907 } 908 ((EFI_INPUT_KEY*)(((UINT8*)KeyOptionBuffer) + sizeof(EFI_KEY_OPTION)))[LoopCounter].UnicodeChar = (UINT16)Intermediate; 909 Temp = StrStr(Walker, L" "); 910 if (Temp != NULL) { 911 Walker = Temp; 912 } 913 while(Walker[0] == L' ') { 914 Walker++; 915 } 916 } 917 918 if (ShellStatus == SHELL_SUCCESS) { 919 // 920 // Now do the BootOption / BootOptionCrc 921 // 922 ASSERT (OptionIndex <= OrderCount); 923 KeyOptionBuffer->BootOption = CurrentOrder[OptionIndex]; 924 Status = GetBootOptionCrc(&(KeyOptionBuffer->BootOptionCrc), KeyOptionBuffer->BootOption); 925 if (EFI_ERROR(Status)) { 926 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Option Index"); 927 ShellStatus = SHELL_INVALID_PARAMETER; 928 } 929 } 930 931 if (ShellStatus == SHELL_SUCCESS) { 932 for (Temp2 = NULL, KeyIndex = 0 ; KeyIndex <= 0xFFFF ; KeyIndex++) { 933 UnicodeSPrint(VariableName, sizeof(VariableName), L"Key%04x", KeyIndex); 934 Status = GetEfiGlobalVariable2 (VariableName, &VariableData, NULL); 935 if (Status == EFI_NOT_FOUND) { 936 break; 937 } 938 if (!EFI_ERROR(Status)) { 939 SHELL_FREE_NON_NULL(VariableData); 940 } 941 } 942 if (KeyIndex <= 0xFFFF) { 943 Status = gRT->SetVariable( 944 VariableName, 945 (EFI_GUID*)&gEfiGlobalVariableGuid, 946 EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS, 947 sizeof(EFI_KEY_OPTION) + (sizeof(EFI_INPUT_KEY) * NewKeyOption.KeyData.Options.InputKeyCount), 948 KeyOptionBuffer); 949 if (EFI_ERROR(Status)) { 950 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName); 951 ShellStatus = SHELL_INVALID_PARAMETER; 952 } 953 } else { 954 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_VAR_NO_NUM), gShellBcfgHiiHandle, L"bcfg"); 955 ShellStatus = SHELL_INVALID_PARAMETER; 956 } 957 ASSERT(FileName == NULL && Data == NULL); 958 } 959 } 960 } 961 962 // 963 // Shouldn't be possible to have have both. Neither is ok though. 964 // 965 ASSERT(FileName == NULL || Data == NULL); 966 967 if (ShellStatus == SHELL_SUCCESS && (FileName != NULL || Data != NULL)) { 968 if (FileName != NULL) { 969 // 970 // Open the file and populate the data buffer. 971 // 972 Status = ShellOpenFileByName( 973 FileName, 974 &FileHandle, 975 EFI_FILE_MODE_READ, 976 0); 977 if (!EFI_ERROR(Status)) { 978 Status = ShellGetFileSize(FileHandle, &Intermediate); 979 } 980 Data = AllocateZeroPool((UINTN)Intermediate); 981 if (Data == NULL) { 982 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellBcfgHiiHandle, L"bcfg"); 983 ShellStatus = SHELL_OUT_OF_RESOURCES; 984 } 985 if (!EFI_ERROR(Status)) { 986 Status = ShellReadFile(FileHandle, (UINTN *)&Intermediate, Data); 987 } 988 } else { 989 Intermediate = StrSize(Data); 990 } 991 992 if (!EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS && Data != NULL) { 993 Status = UpdateOptionalData(CurrentOrder[OptionIndex], (UINTN)Intermediate, (UINT8*)Data, Target); 994 if (EFI_ERROR(Status)) { 995 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName); 996 ShellStatus = SHELL_INVALID_PARAMETER; 997 } 998 } 999 if (EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS) { 1000 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName); 1001 ShellStatus = SHELL_INVALID_PARAMETER; 1002 } 1003 } 1004 1005 SHELL_FREE_NON_NULL(Data); 1006 SHELL_FREE_NON_NULL(KeyOptionBuffer); 1007 SHELL_FREE_NON_NULL(FileName); 1008 return ShellStatus; 1009 } 1010 1011 /** 1012 Function to dump the Bcfg information. 1013 1014 @param[in] Op The operation. 1015 @param[in] OrderCount How many to dump. 1016 @param[in] CurrentOrder The pointer to the current order of items. 1017 @param[in] VerboseOutput TRUE for extra output. FALSE otherwise. 1018 1019 @retval SHELL_SUCCESS The dump was successful. 1020 @retval SHELL_INVALID_PARAMETER A parameter was invalid. 1021 **/ 1022 SHELL_STATUS 1023 BcfgDisplayDump( 1024 IN CONST CHAR16 *Op, 1025 IN CONST UINTN OrderCount, 1026 IN CONST UINT16 *CurrentOrder, 1027 IN CONST BOOLEAN VerboseOutput 1028 ) 1029 { 1030 EFI_STATUS Status; 1031 UINT8 *Buffer; 1032 UINTN BufferSize; 1033 CHAR16 VariableName[12]; 1034 UINTN LoopVar; 1035 CHAR16 *DevPathString; 1036 VOID *FilePathList; 1037 UINTN Errors; 1038 EFI_LOAD_OPTION *LoadOption; 1039 CHAR16 *Description; 1040 UINTN DescriptionSize; 1041 UINTN OptionalDataOffset; 1042 1043 if (OrderCount == 0) { 1044 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_BCFG_NONE), gShellBcfgHiiHandle, L"bcfg"); 1045 return (SHELL_SUCCESS); 1046 } 1047 1048 Errors = 0; 1049 1050 for (LoopVar = 0 ; LoopVar < OrderCount ; LoopVar++) { 1051 Buffer = NULL; 1052 BufferSize = 0; 1053 DevPathString = NULL; 1054 1055 UnicodeSPrint(VariableName, sizeof(VariableName), L"%s%04x", Op, CurrentOrder[LoopVar]); 1056 1057 Status = gRT->GetVariable( 1058 VariableName, 1059 (EFI_GUID*)&gEfiGlobalVariableGuid, 1060 NULL, 1061 &BufferSize, 1062 Buffer); 1063 if (Status == EFI_BUFFER_TOO_SMALL) { 1064 Buffer = AllocateZeroPool(BufferSize); 1065 Status = gRT->GetVariable( 1066 VariableName, 1067 (EFI_GUID*)&gEfiGlobalVariableGuid, 1068 NULL, 1069 &BufferSize, 1070 Buffer); 1071 } 1072 1073 if (EFI_ERROR(Status) || Buffer == NULL) { 1074 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_READ_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName); 1075 ++Errors; 1076 goto Cleanup; 1077 } 1078 1079 // 1080 // We expect the Attributes, FilePathListLength, and L'\0'-terminated 1081 // Description fields to be present. 1082 // 1083 if (BufferSize < sizeof *LoadOption + sizeof (CHAR16)) { 1084 ShellPrintHiiEx ( 1085 -1, 1086 -1, 1087 NULL, 1088 STRING_TOKEN (STR_BCFG_VAR_CORRUPT), 1089 gShellBcfgHiiHandle, 1090 L"bcfg", 1091 VariableName 1092 ); 1093 ++Errors; 1094 goto Cleanup; 1095 } 1096 1097 LoadOption = (EFI_LOAD_OPTION *)Buffer; 1098 Description = (CHAR16*)(Buffer + sizeof (EFI_LOAD_OPTION)); 1099 DescriptionSize = StrSize (Description); 1100 1101 if (LoadOption->FilePathListLength != 0) { 1102 FilePathList = (UINT8 *)Description + DescriptionSize; 1103 DevPathString = ConvertDevicePathToText(FilePathList, TRUE, FALSE); 1104 } 1105 1106 OptionalDataOffset = sizeof *LoadOption + DescriptionSize + 1107 LoadOption->FilePathListLength; 1108 1109 ShellPrintHiiEx( 1110 -1, 1111 -1, 1112 NULL, 1113 STRING_TOKEN(STR_BCFG_LOAD_OPTIONS), 1114 gShellBcfgHiiHandle, 1115 LoopVar, 1116 VariableName, 1117 Description, 1118 DevPathString, 1119 OptionalDataOffset >= BufferSize ? L'N' : L'Y' 1120 ); 1121 if (VerboseOutput && (OptionalDataOffset < BufferSize)) { 1122 DumpHex ( 1123 2, // Indent 1124 0, // Offset (displayed) 1125 BufferSize - OptionalDataOffset, // DataSize 1126 Buffer + OptionalDataOffset // UserData 1127 ); 1128 } 1129 1130 Cleanup: 1131 if (Buffer != NULL) { 1132 FreePool(Buffer); 1133 } 1134 if (DevPathString != NULL) { 1135 FreePool(DevPathString); 1136 } 1137 } 1138 return (Errors > 0) ? SHELL_INVALID_PARAMETER : SHELL_SUCCESS; 1139 } 1140 1141 /** 1142 Function to initialize the BCFG operation structure. 1143 1144 @param[in] Struct The stuct to initialize. 1145 **/ 1146 VOID 1147 InitBcfgStruct( 1148 IN BGFG_OPERATION *Struct 1149 ) 1150 { 1151 ASSERT(Struct != NULL); 1152 Struct->Target = BcfgTargetMax; 1153 Struct->Type = BcfgTypeMax; 1154 Struct->Number1 = 0; 1155 Struct->Number2 = 0; 1156 Struct->HandleIndex = 0; 1157 Struct->FileName = NULL; 1158 Struct->Description = NULL; 1159 Struct->Order = NULL; 1160 Struct->OptData = NULL; 1161 } 1162 1163 1164 STATIC CONST SHELL_PARAM_ITEM ParamList[] = { 1165 {L"-v", TypeFlag}, 1166 {L"-opt", TypeMaxValue}, 1167 {NULL, TypeMax} 1168 }; 1169 1170 /** 1171 Function for 'bcfg' command. 1172 1173 @param[in] ImageHandle Handle to the Image (NULL if Internal). 1174 @param[in] SystemTable Pointer to the System Table (NULL if Internal). 1175 **/ 1176 SHELL_STATUS 1177 EFIAPI 1178 ShellCommandRunBcfg ( 1179 IN EFI_HANDLE ImageHandle, 1180 IN EFI_SYSTEM_TABLE *SystemTable 1181 ) 1182 { 1183 EFI_STATUS Status; 1184 LIST_ENTRY *Package; 1185 CHAR16 *ProblemParam; 1186 SHELL_STATUS ShellStatus; 1187 UINTN ParamNumber; 1188 CONST CHAR16 *CurrentParam; 1189 BGFG_OPERATION CurrentOperation; 1190 UINTN Length; 1191 UINT64 Intermediate; 1192 UINT16 Count; 1193 1194 Length = 0; 1195 ProblemParam = NULL; 1196 Package = NULL; 1197 ShellStatus = SHELL_SUCCESS; 1198 1199 InitBcfgStruct(&CurrentOperation); 1200 1201 // 1202 // initialize the shell lib (we must be in non-auto-init...) 1203 // 1204 Status = ShellInitialize(); 1205 ASSERT_EFI_ERROR(Status); 1206 1207 Status = CommandInit(); 1208 ASSERT_EFI_ERROR(Status); 1209 1210 // 1211 // parse the command line 1212 // 1213 Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE); 1214 if (EFI_ERROR(Status)) { 1215 if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) { 1216 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellBcfgHiiHandle, L"bcfg", ProblemParam); 1217 FreePool(ProblemParam); 1218 ShellStatus = SHELL_INVALID_PARAMETER; 1219 } else { 1220 ASSERT(FALSE); 1221 } 1222 } else { 1223 // 1224 // Read in if we are doing -OPT 1225 // 1226 if (ShellCommandLineGetFlag(Package, L"-opt")) { 1227 CurrentOperation.OptData = ShellCommandLineGetValue(Package, L"-opt"); 1228 if (CurrentOperation.OptData == NULL) { 1229 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellBcfgHiiHandle, L"bcfg", L"-opt"); 1230 ShellStatus = SHELL_INVALID_PARAMETER; 1231 } 1232 CurrentOperation.Type = BcfgTypeOpt; 1233 } 1234 1235 // 1236 // small block to read the target of the operation 1237 // 1238 if ((ShellCommandLineGetCount(Package) < 3 && CurrentOperation.Type != BcfgTypeOpt) || 1239 (ShellCommandLineGetCount(Package) < 2 && CurrentOperation.Type == BcfgTypeOpt) 1240 ){ 1241 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1242 ShellStatus = SHELL_INVALID_PARAMETER; 1243 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)ShellCommandLineGetRawValue(Package, 1), L"driver") == 0) { 1244 CurrentOperation.Target = BcfgTargetDriverOrder; 1245 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)ShellCommandLineGetRawValue(Package, 1), L"boot") == 0) { 1246 CurrentOperation.Target = BcfgTargetBootOrder; 1247 } else { 1248 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_DRIVER_BOOT), gShellBcfgHiiHandle, L"bcfg"); 1249 ShellStatus = SHELL_INVALID_PARAMETER; 1250 } 1251 1252 1253 // 1254 // Read in the boot or driver order environment variable (not needed for opt) 1255 // 1256 if (ShellStatus == SHELL_SUCCESS && CurrentOperation.Target < BcfgTargetMax) { 1257 Length = 0; 1258 Status = gRT->GetVariable( 1259 CurrentOperation.Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder", 1260 (EFI_GUID*)&gEfiGlobalVariableGuid, 1261 NULL, 1262 &Length, 1263 CurrentOperation.Order); 1264 if (Status == EFI_BUFFER_TOO_SMALL) { 1265 CurrentOperation.Order = AllocateZeroPool(Length+(4*sizeof(CurrentOperation.Order[0]))); 1266 if (CurrentOperation.Order == NULL) { 1267 ShellStatus = SHELL_OUT_OF_RESOURCES; 1268 } else { 1269 Status = gRT->GetVariable( 1270 CurrentOperation.Target == BcfgTargetBootOrder?(CHAR16*)L"BootOrder":(CHAR16*)L"DriverOrder", 1271 (EFI_GUID*)&gEfiGlobalVariableGuid, 1272 NULL, 1273 &Length, 1274 CurrentOperation.Order); 1275 } 1276 } 1277 } 1278 1279 Count = (UINT16) (Length / sizeof(CurrentOperation.Order[0])); 1280 1281 // 1282 // large block to read the type of operation and verify parameter types for the info. 1283 // 1284 if (ShellStatus == SHELL_SUCCESS && CurrentOperation.Target < BcfgTargetMax) { 1285 for (ParamNumber = 2 ; ParamNumber < ShellCommandLineGetCount(Package) && ShellStatus == SHELL_SUCCESS; ParamNumber++) { 1286 CurrentParam = ShellCommandLineGetRawValue(Package, ParamNumber); 1287 if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"dump") == 0) { 1288 CurrentOperation.Type = BcfgTypeDump; 1289 if (ShellCommandLineGetCount(Package) > 3) { 1290 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellBcfgHiiHandle, L"bcfg"); 1291 ShellStatus = SHELL_INVALID_PARAMETER; 1292 } 1293 } else if (ShellCommandLineGetFlag(Package, L"-v")) { 1294 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"-v (without dump)"); 1295 ShellStatus = SHELL_INVALID_PARAMETER; 1296 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"add") == 0) { 1297 if ((ParamNumber + 3) >= ShellCommandLineGetCount(Package)) { 1298 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1299 ShellStatus = SHELL_INVALID_PARAMETER; 1300 } 1301 CurrentOperation.Type = BcfgTypeAdd; 1302 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1303 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1304 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1305 ShellStatus = SHELL_INVALID_PARAMETER; 1306 } else { 1307 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1308 CurrentOperation.Number1 = (UINT16)Intermediate; 1309 ASSERT(CurrentOperation.FileName == NULL); 1310 CurrentOperation.FileName = StrnCatGrow(&CurrentOperation.FileName , NULL, ShellCommandLineGetRawValue(Package, ++ParamNumber), 0); 1311 ASSERT(CurrentOperation.Description == NULL); 1312 CurrentOperation.Description = StrnCatGrow(&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue(Package, ++ParamNumber), 0); 1313 } 1314 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"addp") == 0) { 1315 if ((ParamNumber + 3) >= ShellCommandLineGetCount(Package)) { 1316 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1317 ShellStatus = SHELL_INVALID_PARAMETER; 1318 } 1319 CurrentOperation.Type = BcfgTypeAddp; 1320 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1321 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1322 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1323 ShellStatus = SHELL_INVALID_PARAMETER; 1324 } else { 1325 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1326 CurrentOperation.Number1 = (UINT16)Intermediate; 1327 ASSERT(CurrentOperation.FileName == NULL); 1328 CurrentOperation.FileName = StrnCatGrow(&CurrentOperation.FileName , NULL, ShellCommandLineGetRawValue(Package, ++ParamNumber), 0); 1329 ASSERT(CurrentOperation.Description == NULL); 1330 CurrentOperation.Description = StrnCatGrow(&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue(Package, ++ParamNumber), 0); 1331 } 1332 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"addh") == 0) { 1333 if ((ParamNumber + 3) >= ShellCommandLineGetCount(Package)) { 1334 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1335 ShellStatus = SHELL_INVALID_PARAMETER; 1336 } 1337 CurrentOperation.Type = BcfgTypeAddh; 1338 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1339 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1340 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1341 ShellStatus = SHELL_INVALID_PARAMETER; 1342 } else { 1343 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1344 CurrentOperation.Number1 = (UINT16)Intermediate; 1345 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1346 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1347 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1348 ShellStatus = SHELL_INVALID_PARAMETER; 1349 } else { 1350 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1351 CurrentOperation.HandleIndex = (UINT16)Intermediate; 1352 ASSERT(CurrentOperation.Description == NULL); 1353 CurrentOperation.Description = StrnCatGrow(&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue(Package, ++ParamNumber), 0); 1354 } 1355 } 1356 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"rm") == 0) { 1357 if ((ParamNumber + 1) >= ShellCommandLineGetCount(Package)) { 1358 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1359 ShellStatus = SHELL_INVALID_PARAMETER; 1360 } 1361 CurrentOperation.Type = BcfgTypeRm; 1362 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1363 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1364 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1365 ShellStatus = SHELL_INVALID_PARAMETER; 1366 } else { 1367 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1368 CurrentOperation.Number1 = (UINT16)Intermediate; 1369 if (CurrentOperation.Number1 >= Count){ 1370 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count); 1371 ShellStatus = SHELL_INVALID_PARAMETER; 1372 } 1373 } 1374 } else if (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)CurrentParam, L"mv") == 0) { 1375 if ((ParamNumber + 2) >= ShellCommandLineGetCount(Package)) { 1376 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg"); 1377 ShellStatus = SHELL_INVALID_PARAMETER; 1378 } 1379 CurrentOperation.Type = BcfgTypeMv; 1380 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1381 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1382 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1383 ShellStatus = SHELL_INVALID_PARAMETER; 1384 } else { 1385 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1386 CurrentOperation.Number1 = (UINT16)Intermediate; 1387 if (CurrentOperation.Number1 >= Count){ 1388 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count); 1389 ShellStatus = SHELL_INVALID_PARAMETER; 1390 } else { 1391 CurrentParam = ShellCommandLineGetRawValue(Package, ++ParamNumber); 1392 if (CurrentParam == NULL || !ShellIsHexOrDecimalNumber(CurrentParam, TRUE, FALSE)) { 1393 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1394 ShellStatus = SHELL_INVALID_PARAMETER; 1395 } else { 1396 Status = ShellConvertStringToUint64(CurrentParam, &Intermediate, TRUE, FALSE); 1397 CurrentOperation.Number2 = (UINT16)Intermediate; 1398 } 1399 if (CurrentOperation.Number2 == CurrentOperation.Number1 1400 ||CurrentOperation.Number2 >= Count 1401 ){ 1402 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count); 1403 ShellStatus = SHELL_INVALID_PARAMETER; 1404 } 1405 } 1406 } 1407 } else { 1408 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam); 1409 ShellStatus = SHELL_INVALID_PARAMETER; 1410 } 1411 } 1412 } 1413 if (ShellStatus == SHELL_SUCCESS && CurrentOperation.Target < BcfgTargetMax && CurrentOperation.Type < BcfgTypeMax) { 1414 // 1415 // we have all the info. Do the work 1416 // 1417 switch (CurrentOperation.Type) { 1418 case BcfgTypeDump: 1419 ShellStatus = BcfgDisplayDump( 1420 CurrentOperation.Target == BcfgTargetBootOrder?L"Boot":L"Driver", 1421 Count, 1422 CurrentOperation.Order, 1423 ShellCommandLineGetFlag(Package, L"-v")); 1424 break; 1425 case BcfgTypeMv: 1426 ShellStatus = BcfgMove( 1427 CurrentOperation.Target, 1428 CurrentOperation.Order, 1429 Count, 1430 CurrentOperation.Number1, 1431 CurrentOperation.Number2); 1432 break; 1433 case BcfgTypeRm: 1434 ShellStatus = BcfgRemove( 1435 CurrentOperation.Target, 1436 CurrentOperation.Order, 1437 Count, 1438 CurrentOperation.Number1); 1439 break; 1440 case BcfgTypeAdd: 1441 case BcfgTypeAddp: 1442 case BcfgTypeAddh: 1443 ShellStatus = BcfgAdd( 1444 CurrentOperation.Number1, 1445 CurrentOperation.FileName, 1446 CurrentOperation.Description==NULL?L"":CurrentOperation.Description, 1447 CurrentOperation.Order, 1448 Count, 1449 CurrentOperation.Target, 1450 (BOOLEAN)(CurrentOperation.Type == BcfgTypeAddh), 1451 (BOOLEAN)(CurrentOperation.Type == BcfgTypeAddp), 1452 CurrentOperation.HandleIndex); 1453 break; 1454 case BcfgTypeOpt: 1455 ShellStatus = BcfgAddOpt( 1456 CurrentOperation.OptData, 1457 CurrentOperation.Order, 1458 Count, 1459 CurrentOperation.Target); 1460 break; 1461 default: 1462 ASSERT(FALSE); 1463 } 1464 } 1465 } 1466 1467 if (Package != NULL) { 1468 ShellCommandLineFreeVarList (Package); 1469 } 1470 if (CurrentOperation.FileName != NULL) { 1471 FreePool(CurrentOperation.FileName); 1472 } 1473 if (CurrentOperation.Description != NULL) { 1474 FreePool(CurrentOperation.Description); 1475 } 1476 if (CurrentOperation.Order != NULL) { 1477 FreePool(CurrentOperation.Order); 1478 } 1479 1480 return (ShellStatus); 1481 } 1482 1483 1484 /** 1485 Function to get the filename with help context if HII will not be used. 1486 1487 @return The filename with help text in it. 1488 **/ 1489 CONST CHAR16* 1490 EFIAPI 1491 ShellCommandGetManFileNameBcfg ( 1492 VOID 1493 ) 1494 { 1495 return (mFileName); 1496 } 1497 1498 /** 1499 "Constructor" for the library. 1500 1501 This will register the handler for the bcfg command. 1502 1503 @param[in] ImageHandle the image handle of the process 1504 @param[in] SystemTable the EFI System Table pointer 1505 @param[in] Name the profile name to use 1506 1507 @retval EFI_SUCCESS the shell command handlers were installed sucessfully 1508 @retval EFI_UNSUPPORTED the shell level required was not found. 1509 **/ 1510 EFI_STATUS 1511 EFIAPI 1512 BcfgLibraryRegisterBcfgCommand ( 1513 IN EFI_HANDLE ImageHandle, 1514 IN EFI_SYSTEM_TABLE *SystemTable, 1515 IN CONST CHAR16 *Name 1516 ) 1517 { 1518 if (gShellBcfgHiiHandle != NULL) { 1519 return (EFI_SUCCESS); 1520 } 1521 1522 gShellBcfgHiiHandle = HiiAddPackages (&gShellBcfgHiiGuid, gImageHandle, UefiShellBcfgCommandLibStrings, NULL); 1523 if (gShellBcfgHiiHandle == NULL) { 1524 return (EFI_DEVICE_ERROR); 1525 } 1526 1527 // 1528 // install our shell command handler 1529 // 1530 ShellCommandRegisterCommandName(L"bcfg", ShellCommandRunBcfg , ShellCommandGetManFileNameBcfg, 0, Name, FALSE, gShellBcfgHiiHandle, STRING_TOKEN(STR_GET_HELP_BCFG)); 1531 1532 return (EFI_SUCCESS); 1533 } 1534 1535 /** 1536 Destructor for the library. free any resources. 1537 1538 @param ImageHandle The image handle of the process. 1539 @param SystemTable The EFI System Table pointer. 1540 **/ 1541 EFI_STATUS 1542 EFIAPI 1543 BcfgLibraryUnregisterBcfgCommand ( 1544 IN EFI_HANDLE ImageHandle, 1545 IN EFI_SYSTEM_TABLE *SystemTable 1546 ) 1547 { 1548 if (gShellBcfgHiiHandle != NULL) { 1549 HiiRemovePackages(gShellBcfgHiiHandle); 1550 } 1551 gShellBcfgHiiHandle = NULL; 1552 return (EFI_SUCCESS); 1553 } 1554 1555
