ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.c

   1 /** @file
   2   Main file for NULL named library for debug1 profile shell command functions.
   3
   4   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UefiShellDebug1CommandsLib.h"
  16
  17 STATIC CONST CHAR16 mFileName[] = L"Debug1Commands";
  18 EFI_HANDLE gShellDebug1HiiHandle = NULL;
  19
  20 /**
  21   Gets the debug file name.  This will be used if HII is not working.
  22
  23   @retval NULL    No file is available.
  24   @return         The NULL-terminated filename to get help from.
  25 **/
  26 CONST CHAR16*
  27 EFIAPI
  28 ShellCommandGetManFileNameDebug1 (
  29   VOID
  30   )
  31 {
  32   return (mFileName);
  33 }
  34
  35 /**
  36   Constructor for the Shell Debug1 Commands library.
  37
  38   @param ImageHandle    the image handle of the process
  39   @param SystemTable    the EFI System Table pointer
  40
  41   @retval EFI_SUCCESS        the shell command handlers were installed sucessfully
  42   @retval EFI_UNSUPPORTED    the shell level required was not found.
  43 **/
  44 EFI_STATUS
  45 EFIAPI
  46 UefiShellDebug1CommandsLibConstructor (
  47   IN EFI_HANDLE        ImageHandle,
  48   IN EFI_SYSTEM_TABLE  *SystemTable
  49   )
  50 {
  51   //
  52   // check our bit of the profiles mask
  53   //
  54   if ((PcdGet8(PcdShellProfileMask) & BIT1) == 0) {
  55     return (EFI_SUCCESS);
  56   }
  57
  58   //
  59   // install the HII stuff.
  60   //
  61   gShellDebug1HiiHandle = HiiAddPackages (&gShellDebug1HiiGuid, gImageHandle, UefiShellDebug1CommandsLibStrings, NULL);
  62   if (gShellDebug1HiiHandle == NULL) {
  63     return (EFI_DEVICE_ERROR);
  64   }
  65
  66   //
  67   // install our shell command handlers that are always installed
  68   //
  69   ShellCommandRegisterCommandName(L"setsize",       ShellCommandRunSetSize            , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SETSIZE)      );
  70   ShellCommandRegisterCommandName(L"comp",          ShellCommandRunComp               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_COMP)         );
  71   ShellCommandRegisterCommandName(L"mode",          ShellCommandRunMode               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MODE)         );
  72   ShellCommandRegisterCommandName(L"memmap",        ShellCommandRunMemMap             , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MEMMAP)       );
  73   ShellCommandRegisterCommandName(L"eficompress",   ShellCommandRunEfiCompress        , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EFICOMPRESS)  );
  74   ShellCommandRegisterCommandName(L"efidecompress", ShellCommandRunEfiDecompress      , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EFIDCOMPRESS) );
  75   ShellCommandRegisterCommandName(L"dmem",          ShellCommandRunDmem               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DMEM)         );
  76   ShellCommandRegisterCommandName(L"loadpcirom",    ShellCommandRunLoadPciRom         , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_LOAD_PCI_ROM) );
  77   ShellCommandRegisterCommandName(L"mm",            ShellCommandRunMm                 , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_MM)           );
  78   ShellCommandRegisterCommandName(L"setvar",        ShellCommandRunSetVar             , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SETVAR)       );
  79   ShellCommandRegisterCommandName(L"sermode",       ShellCommandRunSerMode            , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SERMODE)      );
  80   ShellCommandRegisterCommandName(L"pci",           ShellCommandRunPci                , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_PCI)          );
  81   ShellCommandRegisterCommandName(L"smbiosview",    ShellCommandRunSmbiosView         , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_SMBIOSVIEW)   );
  82   ShellCommandRegisterCommandName(L"dmpstore",      ShellCommandRunDmpStore           , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DMPSTORE)     );
  83   ShellCommandRegisterCommandName(L"dblk",          ShellCommandRunDblk               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_DBLK)         );
  84   ShellCommandRegisterCommandName(L"edit",          ShellCommandRunEdit               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_EDIT)         );
  85   ShellCommandRegisterCommandName(L"hexedit",       ShellCommandRunHexEdit            , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_HEXEDIT)      );
  86
  87   //
  88   // check install profile bit of the profiles mask is set
  89   //
  90   if ((PcdGet8(PcdShellProfileMask) & BIT2) == 0) {
  91     ShellCommandRegisterCommandName(L"bcfg",        ShellCommandRunBcfg               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_BCFG)         );
  92   }
  93
  94
  95
  96
  97   ShellCommandRegisterAlias(L"dmem", L"mem");
  98
  99   return (EFI_SUCCESS);
 100 }
 101
 102 /**
 103   Destructor for the library.  free any resources.
 104
 105   @param ImageHandle            The image handle of the process.
 106   @param SystemTable            The EFI System Table pointer.
 107 **/
 108 EFI_STATUS
 109 EFIAPI
 110 UefiShellDebug1CommandsLibDestructor (
 111   IN EFI_HANDLE        ImageHandle,
 112   IN EFI_SYSTEM_TABLE  *SystemTable
 113   )
 114 {
 115   if (gShellDebug1HiiHandle != NULL) {
 116     HiiRemovePackages(gShellDebug1HiiHandle);
 117   }
 118   return (EFI_SUCCESS);
 119 }
 120
 121 STATIC CONST CHAR8 Hex[] = {
 122   '0',
 123   '1',
 124   '2',
 125   '3',
 126   '4',
 127   '5',
 128   '6',
 129   '7',
 130   '8',
 131   '9',
 132   'A',
 133   'B',
 134   'C',
 135   'D',
 136   'E',
 137   'F'
 138 };
 139
 140 /**
 141   Dump some hexadecimal data to the screen.
 142
 143   @param[in] Indent     How many spaces to indent the output.
 144   @param[in] Offset     The offset of the printing.
 145   @param[in] DataSize   The size in bytes of UserData.
 146   @param[in] UserData   The data to print out.
 147 **/
 148 VOID
 149 DumpHex (
 150   IN UINTN        Indent,
 151   IN UINTN        Offset,
 152   IN UINTN        DataSize,
 153   IN VOID         *UserData
 154   )
 155 {
 156   UINT8 *Data;
 157
 158   CHAR8 Val[50];
 159
 160   CHAR8 Str[20];
 161
 162   UINT8 TempByte;
 163   UINTN Size;
 164   UINTN Index;
 165
 166   Data = UserData;
 167   while (DataSize != 0) {
 168     Size = 16;
 169     if (Size > DataSize) {
 170       Size = DataSize;
 171     }
 172
 173     for (Index = 0; Index < Size; Index += 1) {
 174       TempByte            = Data[Index];
 175       Val[Index * 3 + 0]  = Hex[TempByte >> 4];
 176       Val[Index * 3 + 1]  = Hex[TempByte & 0xF];
 177       Val[Index * 3 + 2]  = (CHAR8) ((Index == 7) ? '-' : ' ');
 178       Str[Index]          = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
 179     }
 180
 181     Val[Index * 3]  = 0;
 182     Str[Index]      = 0;
 183     ShellPrintEx(-1, -1, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
 184
 185     Data += Size;
 186     Offset += Size;
 187     DataSize -= Size;
 188   }
 189 }
 190
 191 /**
 192   Convert a Unicode character to upper case only if
 193   it maps to a valid small-case ASCII character.
 194
 195   This internal function only deal with Unicode character
 196   which maps to a valid small-case ASCII character, i.e.
 197   L'a' to L'z'. For other Unicode character, the input character
 198   is returned directly.
 199
 200   @param  Char  The character to convert.
 201
 202   @retval LowerCharacter   If the Char is with range L'a' to L'z'.
 203   @retval Unchanged        Otherwise.
 204
 205
 206   //Stolen from MdePkg Baselib
 207 **/
 208 CHAR16
 209 EFIAPI
 210 CharToUpper (
 211   IN      CHAR16                    Char
 212   )
 213 {
 214   if (Char >= L'a' && Char <= L'z') {
 215     return (CHAR16) (Char - (L'a' - L'A'));
 216   }
 217
 218   return Char;
 219 }
 220
 221 /**
 222   Function returns a system configuration table that is stored in the
 223   EFI System Table based on the provided GUID.
 224
 225   @param[in]  TableGuid     A pointer to the table's GUID type.
 226   @param[in, out] Table     On exit, a pointer to a system configuration table.
 227
 228   @retval EFI_SUCCESS      A configuration table matching TableGuid was found.
 229   @retval EFI_NOT_FOUND    A configuration table matching TableGuid was not found.
 230 **/
 231 EFI_STATUS
 232 EFIAPI
 233 GetSystemConfigurationTable (
 234   IN EFI_GUID *TableGuid,
 235   IN OUT VOID **Table
 236   )
 237 {
 238   UINTN Index;
 239   ASSERT (Table != NULL);
 240
 241   for (Index = 0; Index < gST->NumberOfTableEntries; Index++) {
 242     if (CompareGuid (TableGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {
 243       *Table = gST->ConfigurationTable[Index].VendorTable;
 244       return EFI_SUCCESS;
 245     }
 246   }
 247
 248   return EFI_NOT_FOUND;
 249 }
 250
 251 /**
 252   Convert a Unicode character to numerical value.
 253
 254   This internal function only deal with Unicode character
 255   which maps to a valid hexadecimal ASII character, i.e.
 256   L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
 257   Unicode character, the value returned does not make sense.
 258
 259   @param  Char  The character to convert.
 260
 261   @return The numerical value converted.
 262
 263 **/
 264 UINTN
 265 EFIAPI
 266 HexCharToUintn (
 267   IN      CHAR16                    Char
 268   )
 269 {
 270   if (Char >= L'0' && Char <= L'9') {
 271     return Char - L'0';
 272   }
 273
 274   return (UINTN) (10 + CharToUpper (Char) - L'A');
 275 }
 276
 277 /**
 278   Convert a string representation of a guid to a Guid value.
 279
 280   @param[in] StringGuid    The pointer to the string of a guid.
 281   @param[in, out] Guid     The pointer to the GUID structure to populate.
 282
 283   @retval EFI_INVALID_PARAMETER   A parameter was invalid.
 284   @retval EFI_SUCCESS             The conversion was successful.
 285 **/
 286 EFI_STATUS
 287 EFIAPI
 288 ConvertStringToGuid (
 289   IN CONST CHAR16 *StringGuid,
 290   IN OUT EFI_GUID *Guid
 291   )
 292 {
 293   CHAR16  *TempCopy;
 294   CHAR16  *TempSpot;
 295   CHAR16  *Walker;
 296   UINT64  TempVal;
 297   EFI_STATUS Status;
 298
 299   if (StringGuid == NULL) {
 300     return (EFI_INVALID_PARAMETER);
 301   } else if (StrLen(StringGuid) != 36) {
 302     return (EFI_INVALID_PARAMETER);
 303   }
 304   TempCopy = NULL;
 305   TempCopy = StrnCatGrow(&TempCopy, NULL, StringGuid, 0);
 306   if (TempCopy == NULL) {
 307     return (EFI_OUT_OF_RESOURCES);
 308   }
 309   Walker   = TempCopy;
 310   TempSpot = StrStr(Walker, L"-");
 311   if (TempSpot != NULL) {
 312     *TempSpot = CHAR_NULL;
 313   }
 314   Status = ShellConvertStringToUint64(Walker, &TempVal, TRUE, FALSE);
 315   if (EFI_ERROR(Status)) {
 316     FreePool(TempCopy);
 317     return (Status);
 318   }
 319   Guid->Data1 = (UINT32)TempVal;
 320   Walker += 9;
 321   TempSpot = StrStr(Walker, L"-");
 322   if (TempSpot != NULL) {
 323     *TempSpot = CHAR_NULL;
 324   }
 325   Status = ShellConvertStringToUint64(Walker, &TempVal, TRUE, FALSE);
 326   if (EFI_ERROR(Status)) {
 327     FreePool(TempCopy);
 328     return (Status);
 329   }
 330   Guid->Data2 = (UINT16)TempVal;
 331   Walker += 5;
 332   TempSpot = StrStr(Walker, L"-");
 333   if (TempSpot != NULL) {
 334     *TempSpot = CHAR_NULL;
 335   }
 336   Status = ShellConvertStringToUint64(Walker, &TempVal, TRUE, FALSE);
 337   if (EFI_ERROR(Status)) {
 338     FreePool(TempCopy);
 339     return (Status);
 340   }
 341   Guid->Data3 = (UINT16)TempVal;
 342   Walker += 5;
 343   Guid->Data4[0] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 344   Guid->Data4[0] = (UINT8)(Guid->Data4[0]+ (UINT8)HexCharToUintn(Walker[1]));
 345   Walker += 2;
 346   Guid->Data4[1] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 347   Guid->Data4[1] = (UINT8)(Guid->Data4[1] + (UINT8)HexCharToUintn(Walker[1]));
 348   Walker += 3;
 349   Guid->Data4[2] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 350   Guid->Data4[2] = (UINT8)(Guid->Data4[2] + (UINT8)HexCharToUintn(Walker[1]));
 351   Walker += 2;
 352   Guid->Data4[3] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 353   Guid->Data4[3] = (UINT8)(Guid->Data4[3] + (UINT8)HexCharToUintn(Walker[1]));
 354   Walker += 2;
 355   Guid->Data4[4] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 356   Guid->Data4[4] = (UINT8)(Guid->Data4[4] + (UINT8)HexCharToUintn(Walker[1]));
 357   Walker += 2;
 358   Guid->Data4[5] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 359   Guid->Data4[5] = (UINT8)(Guid->Data4[5] + (UINT8)HexCharToUintn(Walker[1]));
 360   Walker += 2;
 361   Guid->Data4[6] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 362   Guid->Data4[6] = (UINT8)(Guid->Data4[6] + (UINT8)HexCharToUintn(Walker[1]));
 363   Walker += 2;
 364   Guid->Data4[7] = (UINT8)(HexCharToUintn(Walker[0]) * 16);
 365   Guid->Data4[7] = (UINT8)(Guid->Data4[7] + (UINT8)HexCharToUintn(Walker[1]));
 366   FreePool(TempCopy);
 367   return (EFI_SUCCESS);
 368 }
 369
 370 /**
 371   Clear the line at the specified Row.
 372
 373   @param[in] Row                The row number to be cleared ( start from 1 )
 374   @param[in] LastCol            The last printable column.
 375   @param[in] LastRow            The last printable row.
 376 **/
 377 VOID
 378 EFIAPI
 379 EditorClearLine (
 380   IN UINTN Row,
 381   IN UINTN LastCol,
 382   IN UINTN LastRow
 383   )
 384 {
 385   CHAR16 Line[200];
 386
 387   if (Row == 0) {
 388     Row = 1;
 389   }
 390
 391   //
 392   // prepare a blank line
 393   //
 394   SetMem16(Line, LastCol*sizeof(CHAR16), L' ');
 395
 396   if (Row == LastRow) {
 397     //
 398     // if CHAR_NULL is still at position 80, it will cause first line error
 399     //
 400     Line[LastCol - 1] = CHAR_NULL;
 401   } else {
 402     Line[LastCol] = CHAR_NULL;
 403   }
 404
 405   //
 406   // print out the blank line
 407   //
 408   ShellPrintEx (0, ((INT32)Row) - 1, Line);
 409 }
 410
 411 /**
 412   Determine if the character is valid for a filename.
 413
 414   @param[in] Ch     The character to test.
 415
 416   @retval TRUE      The character is valid.
 417   @retval FALSE     The character is not valid.
 418 **/
 419 BOOLEAN
 420 EFIAPI
 421 IsValidFileNameChar (
 422   IN CONST CHAR16 Ch
 423   )
 424 {
 425   //
 426   // See if there are any illegal characters within the name
 427   //
 428   if (Ch < 0x20 || Ch == L'\"' || Ch == L'*' || Ch == L'/' || Ch == L'<' || Ch == L'>' || Ch == L'?' || Ch == L'|') {
 429     return FALSE;
 430   }
 431
 432   return TRUE;
 433 }
 434
 435 /**
 436   Check if file name has illegal characters.
 437
 438   @param Name       The filename to check.
 439
 440   @retval TRUE      The filename is ok.
 441   @retval FALSE     The filename is not ok.
 442 **/
 443 BOOLEAN
 444 EFIAPI
 445 IsValidFileName (
 446   IN CONST CHAR16 *Name
 447   )
 448 {
 449
 450   UINTN Index;
 451   UINTN Len;
 452
 453   //
 454   // check the length of Name
 455   //
 456   for (Len = 0, Index = StrLen (Name) - 1; Index + 1 != 0; Index--, Len++) {
 457     if (Name[Index] == '\\' || Name[Index] == ':') {
 458       break;
 459     }
 460   }
 461
 462   if (Len == 0 || Len > 255) {
 463     return FALSE;
 464   }
 465   //
 466   // check whether any char in Name not appears in valid file name char
 467   //
 468   for (Index = 0; Index < StrLen (Name); Index++) {
 469     if (!IsValidFileNameChar (Name[Index])) {
 470       return FALSE;
 471     }
 472   }
 473
 474   return TRUE;
 475 }
 476
 477 /**
 478   Find a filename that is valid (not taken) with the given extension.
 479
 480   @param[in] Extension      The file extension.
 481
 482   @retval NULL  Something went wrong.
 483   @return the valid filename.
 484 **/
 485 CHAR16 *
 486 EFIAPI
 487 EditGetDefaultFileName (
 488   IN CONST CHAR16 *Extension
 489   )
 490 {
 491   EFI_STATUS         Status;
 492   UINTN              Suffix;
 493   CHAR16             *FileNameTmp;
 494
 495   Suffix       = 0;
 496
 497   do {
 498     FileNameTmp = CatSPrint (NULL, L"NewFile%d.%s", Suffix, Extension);
 499
 500     //
 501     // after that filename changed to path
 502     //
 503     Status = ShellFileExists (FileNameTmp);
 504
 505     if (Status == EFI_NOT_FOUND) {
 506       return FileNameTmp;
 507     }
 508
 509     FreePool (FileNameTmp);
 510     FileNameTmp = NULL;
 511     Suffix++;
 512   } while (Suffix != 0);
 513
 514   FreePool (FileNameTmp);
 515   return NULL;
 516 }
 517
 518 /**
 519   Read a file into an allocated buffer.  The buffer is the responsibility
 520   of the caller to free.
 521
 522   @param[in]  FileName          The filename of the file to open.
 523   @param[out] Buffer            Upon successful return, the pointer to the
 524                                 address of the allocated buffer.
 525   @param[out] BufferSize        If not NULL, then the pointer to the size
 526                                 of the allocated buffer.
 527   @param[out] ReadOnly          Upon successful return TRUE if the file is
 528                                 read only.  FALSE otherwise.
 529
 530   @retval EFI_NOT_FOUND         The filename did not represent a file in the
 531                                 file system.
 532   @retval EFI_SUCCESS           The file was read into the buffer.
 533   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 534   @retval EFI_LOAD_ERROR        The file read operation failed.
 535   @retval EFI_INVALID_PARAMETER A parameter was invalid.
 536   @retval EFI_INVALID_PARAMETER FileName was NULL.
 537   @retval EFI_INVALID_PARAMETER FileName was a directory.
 538 **/
 539 EFI_STATUS
 540 EFIAPI
 541 ReadFileIntoBuffer (
 542   IN CONST CHAR16 *FileName,
 543   OUT VOID        **Buffer,
 544   OUT UINTN       *BufferSize OPTIONAL,
 545   OUT BOOLEAN     *ReadOnly
 546   )
 547 {
 548   VOID              *InternalBuffer;
 549   UINTN             FileSize;
 550   SHELL_FILE_HANDLE FileHandle;
 551   BOOLEAN           CreateFile;
 552   EFI_STATUS        Status;
 553   EFI_FILE_INFO     *Info;
 554
 555   InternalBuffer  = NULL;
 556   FileSize        = 0;
 557   FileHandle      = NULL;
 558   CreateFile      = FALSE;
 559   Status          = EFI_SUCCESS;
 560   Info            = NULL;
 561
 562   if (FileName == NULL || Buffer == NULL || ReadOnly == NULL) {
 563     return (EFI_INVALID_PARAMETER);
 564   }
 565
 566   //
 567   // try to open the file
 568   //
 569   Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ, 0);
 570
 571   if (!EFI_ERROR(Status)) {
 572     ASSERT(CreateFile == FALSE);
 573     if (FileHandle == NULL) {
 574       return EFI_LOAD_ERROR;
 575     }
 576
 577     Info = ShellGetFileInfo(FileHandle);
 578
 579     if (Info->Attribute & EFI_FILE_DIRECTORY) {
 580       FreePool (Info);
 581       return EFI_INVALID_PARAMETER;
 582     }
 583
 584     if (Info->Attribute & EFI_FILE_READ_ONLY) {
 585       *ReadOnly = TRUE;
 586     } else {
 587       *ReadOnly = FALSE;
 588     }
 589     //
 590     // get file size
 591     //
 592     FileSize = (UINTN) Info->FileSize;
 593
 594     FreePool (Info);
 595   } else if (Status == EFI_NOT_FOUND) {
 596     //
 597     // file not exists.  add create and try again
 598     //
 599     Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
 600     if (EFI_ERROR (Status)) {
 601       return Status;
 602     } else {
 603       //
 604       // it worked.  now delete it and move on with the name (now validated)
 605       //
 606       Status = ShellDeleteFile (&FileHandle);
 607       if (Status == EFI_WARN_DELETE_FAILURE) {
 608         Status = EFI_ACCESS_DENIED;
 609       }
 610       if (EFI_ERROR (Status)) {
 611         return Status;
 612       }
 613     }
 614     //
 615     // file doesn't exist, so set CreateFile to TRUE and can't be read-only
 616     //
 617     CreateFile = TRUE;
 618     *ReadOnly  = FALSE;
 619   }
 620
 621   //
 622   // the file exists
 623   //
 624   if (!CreateFile) {
 625     //
 626     // allocate buffer to read file
 627     //
 628     InternalBuffer = AllocateZeroPool (FileSize);
 629     if (InternalBuffer == NULL) {
 630       return EFI_OUT_OF_RESOURCES;
 631     }
 632     //
 633     // read file into InternalBuffer
 634     //
 635     Status = ShellReadFile (FileHandle, &FileSize, InternalBuffer);
 636     ShellCloseFile(&FileHandle);
 637     FileHandle = NULL;
 638     if (EFI_ERROR (Status)) {
 639       SHELL_FREE_NON_NULL (InternalBuffer);
 640       return EFI_LOAD_ERROR;
 641     }
 642   }
 643   *Buffer = InternalBuffer;
 644   if (BufferSize != NULL) {
 645     *BufferSize = FileSize;
 646   }
 647   return (EFI_SUCCESS);
 648
 649 }