ShellPkg/Library/UefiShellLevel2CommandsLib/Map.c

   1 /** @file
   2   Main file for map shell level 2 command.
   3
   4   Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
   5   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
   6   (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   7
   8   This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #include "UefiShellLevel2CommandsLib.h"
  19 #include <Protocol/SimpleFileSystem.h>
  20 #include <Protocol/BlockIo.h>
  21 #include <Library/DevicePathLib.h>
  22 #include <Library/HandleParsingLib.h>
  23 #include <Library/SortLib.h>
  24
  25 /**
  26   Determine if a string has only numbers and letters.
  27
  28   This is useful for such things as Map names which can only be letters and numbers.
  29
  30   @param[in] String       pointer to the string to analyze,
  31   @param[in] Len          Number of characters to analyze.
  32
  33   @retval TRUE            String has only numbers and letters
  34   @retval FALSE           String has at least one other character.
  35 **/
  36 BOOLEAN
  37 IsNumberLetterOnly(
  38   IN CONST CHAR16 *String,
  39   IN CONST UINTN  Len
  40   )
  41 {
  42   UINTN Count;
  43   for (Count = 0 ; Count < Len && String != NULL && *String != CHAR_NULL ; String++,Count++) {
  44     if (! ((*String >= L'a' && *String <= L'z') ||
  45            (*String >= L'A' && *String <= L'Z') ||
  46            (*String >= L'0' && *String <= L'9'))
  47         ){
  48       return (FALSE);
  49     }
  50   }
  51   return (TRUE);
  52 }
  53
  54 /**
  55   Do a search in the Target delimited list.
  56
  57   @param[in] List         The list to seatch in.
  58   @param[in] MetaTarget   The item to search for. MetaMatching supported.
  59   @param[out] FullName    Optional pointer to an allocated buffer containing
  60                           the match.
  61   @param[in] Meta         TRUE to use MetaMatching.
  62   @param[in] SkipTrailingNumbers  TRUE to allow for numbers after the MetaTarget.
  63   @param[in] Target       The single character that delimits list
  64                           items (";" normally).
  65 **/
  66 BOOLEAN
  67 SearchList(
  68   IN CONST CHAR16   *List,
  69   IN CONST CHAR16   *MetaTarget,
  70   OUT CHAR16        **FullName OPTIONAL,
  71   IN CONST BOOLEAN  Meta,
  72   IN CONST BOOLEAN  SkipTrailingNumbers,
  73   IN CONST CHAR16   *Target
  74
  75   )
  76 {
  77   CHAR16        *TempList;
  78   CONST CHAR16  *ListWalker;
  79   BOOLEAN       Result;
  80   CHAR16        *TempSpot;
  81
  82   for (ListWalker = List , TempList = NULL
  83      ; ListWalker != NULL && *ListWalker != CHAR_NULL
  84      ;
  85    ) {
  86     TempList = StrnCatGrow(&TempList, NULL, ListWalker, 0);
  87     ASSERT(TempList != NULL);
  88     TempSpot = StrStr(TempList, Target);
  89     if (TempSpot != NULL) {
  90       *TempSpot = CHAR_NULL;
  91     }
  92
  93     while (SkipTrailingNumbers && (ShellIsDecimalDigitCharacter(TempList[StrLen(TempList)-1]) || TempList[StrLen(TempList)-1] == L':')) {
  94       TempList[StrLen(TempList)-1] = CHAR_NULL;
  95     }
  96
  97     ListWalker = StrStr(ListWalker, Target);
  98     while(ListWalker != NULL && *ListWalker == *Target) {
  99       ListWalker++;
 100     }
 101     if (Meta) {
 102       Result = gUnicodeCollation->MetaiMatch(gUnicodeCollation, (CHAR16*)TempList, (CHAR16*)MetaTarget);
 103     } else {
 104       Result = (BOOLEAN)(StrCmp(TempList, MetaTarget)==0);
 105     }
 106     if (Result) {
 107       if (FullName != NULL) {
 108         *FullName = TempList;
 109       } else {
 110         FreePool(TempList);
 111       }
 112       return (TRUE);
 113     }
 114     FreePool(TempList);
 115     TempList = NULL;
 116   }
 117
 118   return (FALSE);
 119 }
 120
 121 /**
 122   Determine what type of device is represented and return it's string.  The
 123   string is in allocated memory and must be callee freed.  The HII is is listed below.
 124   The actual string cannot be determined.
 125
 126   @param[in] DevicePath     The device to analyze.
 127
 128   @retval STR_MAP_MEDIA_UNKNOWN   The media type is unknown.
 129   @retval STR_MAP_MEDIA_HARDDISK  The media is a hard drive.
 130   @retval STR_MAP_MEDIA_CDROM     The media is a CD ROM.
 131   @retval STR_MAP_MEDIA_FLOPPY    The media is a floppy drive.
 132 **/
 133 CHAR16*
 134 GetDeviceMediaType (
 135   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
 136   )
 137 {
 138   ACPI_HID_DEVICE_PATH  *Acpi;
 139
 140   //
 141   //  Parse the device path:
 142   //  Devicepath sub type                 mediatype
 143   //    MEDIA_HANRDDRIVE_DP      ->       Hard Disk
 144   //    MEDIA_CDROM_DP           ->       CD Rom
 145   //    Acpi.HID = 0X0604        ->       Floppy
 146   //
 147   if (NULL == DevicePath) {
 148     return HiiGetString(gShellLevel2HiiHandle, STRING_TOKEN(STR_MAP_MEDIA_UNKNOWN), NULL);
 149   }
 150
 151   for (;!IsDevicePathEndType (DevicePath) ;DevicePath = NextDevicePathNode (DevicePath)) {
 152     if (DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) {
 153       switch (DevicePathSubType (DevicePath)) {
 154       case MEDIA_HARDDRIVE_DP:
 155         return HiiGetString(gShellLevel2HiiHandle, STRING_TOKEN(STR_MAP_MEDIA_HARDDISK), NULL);
 156       case MEDIA_CDROM_DP:
 157         return HiiGetString(gShellLevel2HiiHandle, STRING_TOKEN(STR_MAP_MEDIA_CDROM), NULL);
 158       }
 159     } else if (DevicePathType (DevicePath) == ACPI_DEVICE_PATH) {
 160       Acpi = (ACPI_HID_DEVICE_PATH *) DevicePath;
 161       if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {
 162         return HiiGetString(gShellLevel2HiiHandle, STRING_TOKEN(STR_MAP_MEDIA_FLOPPY), NULL);
 163       }
 164     }
 165   }
 166
 167   return HiiGetString(gShellLevel2HiiHandle, STRING_TOKEN(STR_MAP_MEDIA_UNKNOWN), NULL);
 168 }
 169
 170 /**
 171   Function to detemine if a handle has removable storage.
 172
 173   @param[in] DevicePath             DevicePath to test.
 174
 175   @retval TRUE                      The handle has removable storage.
 176   @retval FALSE                     The handle does not have removable storage.
 177 **/
 178 BOOLEAN
 179 IsRemoveableDevice (
 180   IN EFI_DEVICE_PATH_PROTOCOL      *DevicePath
 181   )
 182 {
 183   if (NULL == DevicePath) {
 184     return FALSE;
 185   }
 186
 187   while (!IsDevicePathEndType (DevicePath)) {
 188     if (DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) {
 189       switch (DevicePathSubType (DevicePath)) {
 190       case MSG_USB_DP:
 191       case MSG_SCSI_DP:
 192         return TRUE;
 193       default:
 194         return FALSE;
 195       }
 196     }
 197     DevicePath = NextDevicePathNode (DevicePath);
 198   }
 199   return FALSE;
 200 }
 201
 202 /**
 203   Function to detemine if a something on the map list matches.
 204
 205   @param[in] MapList          The pointer to the list to test.
 206   @param[in] Specific         The pointer to a specific name to test for.
 207   @param[in] TypeString       The pointer to the list of types.
 208   @param[in] Normal           Always show normal mappings.
 209   @param[in] Consist          Always show consistent mappings.
 210
 211   @retval TRUE                The map should be displayed.
 212   @retval FALSE               The map should not be displayed.
 213 **/
 214 BOOLEAN
 215 MappingListHasType(
 216   IN CONST CHAR16     *MapList,
 217   IN CONST CHAR16     *Specific,
 218   IN CONST CHAR16     *TypeString,
 219   IN CONST BOOLEAN    Normal,
 220   IN CONST BOOLEAN    Consist
 221   )
 222 {
 223   CHAR16 *NewSpecific;
 224   RETURN_STATUS  Status;
 225
 226   //
 227   // specific has priority
 228   //
 229   if (Specific != NULL) {
 230     NewSpecific = AllocateCopyPool(StrSize(Specific) + sizeof(CHAR16), Specific);
 231     if (NewSpecific == NULL){
 232       return FALSE;
 233     }
 234     if (NewSpecific[StrLen(NewSpecific)-1] != L':') {
 235       Status = StrnCatS(NewSpecific, (StrSize(Specific) + sizeof(CHAR16))/sizeof(CHAR16), L":", StrLen(L":"));
 236       if (EFI_ERROR (Status)) {
 237         FreePool(NewSpecific);
 238         return FALSE;
 239       }
 240     }
 241
 242     if (SearchList(MapList, NewSpecific, NULL, TRUE, FALSE, L";")) {
 243       FreePool(NewSpecific);
 244       return (TRUE);
 245     }
 246     FreePool(NewSpecific);
 247   }
 248   if (  Consist
 249     && Specific == NULL
 250     && (SearchList(MapList, L"HD*",  NULL, TRUE, TRUE, L";")
 251       ||SearchList(MapList, L"CD*",  NULL, TRUE, TRUE, L";")
 252       ||SearchList(MapList, L"F*",   NULL, TRUE, TRUE, L";")
 253       ||SearchList(MapList, L"FP*",  NULL, TRUE, TRUE, L";"))){
 254     return (TRUE);
 255   }
 256
 257   if (  Normal
 258     && Specific == NULL
 259     && (SearchList(MapList, L"FS",  NULL, FALSE, TRUE, L";")
 260       ||SearchList(MapList, L"BLK", NULL, FALSE, TRUE, L";"))){
 261     return (TRUE);
 262   }
 263
 264   if (TypeString != NULL && SearchList(MapList, TypeString,  NULL, TRUE, TRUE, L";")) {
 265     return (TRUE);
 266   }
 267   return (FALSE);
 268 }
 269
 270
 271 /**
 272   Display a single map line for device Handle if conditions are met.
 273
 274   @param[in] Verbose                TRUE to display (extra) verbose information.
 275   @param[in] Consist                TRUE to display consistent mappings.
 276   @param[in] Normal                 TRUE to display normal (not consist) mappings.
 277   @param[in] TypeString             pointer to string of filter types.
 278   @param[in] SFO                    TRUE to display output in Standard Output Format.
 279   @param[in] Specific               pointer to string for specific map to display.
 280   @param[in] Handle                 The handle to display from.
 281
 282   @retval EFI_SUCCESS               The mapping was displayed.
 283 **/
 284 EFI_STATUS
 285 PerformSingleMappingDisplay(
 286   IN CONST BOOLEAN    Verbose,
 287   IN CONST BOOLEAN    Consist,
 288   IN CONST BOOLEAN    Normal,
 289   IN CONST CHAR16     *TypeString,
 290   IN CONST BOOLEAN    SFO,
 291   IN CONST CHAR16     *Specific OPTIONAL,
 292   IN CONST EFI_HANDLE Handle
 293   )
 294 {
 295   EFI_DEVICE_PATH_PROTOCOL  *DevPath;
 296   EFI_DEVICE_PATH_PROTOCOL  *DevPathCopy;
 297   CONST CHAR16              *MapList;
 298   CHAR16                    *CurrentName;
 299   CHAR16                    *MediaType;
 300   CHAR16                    *DevPathString;
 301   CHAR16                    *TempSpot;
 302   CHAR16                    *Alias;
 303   UINTN                     TempLen;
 304   BOOLEAN                   Removable;
 305   CONST CHAR16              *TempSpot2;
 306
 307   Alias       = NULL;
 308   TempSpot2   = NULL;
 309   CurrentName = NULL;
 310   DevPath = DevicePathFromHandle(Handle);
 311   DevPathCopy = DevPath;
 312   MapList = gEfiShellProtocol->GetMapFromDevicePath(&DevPathCopy);
 313   if (MapList == NULL) {
 314     return EFI_NOT_FOUND;
 315   }
 316
 317   if (!MappingListHasType(MapList, Specific, TypeString, Normal, Consist)){
 318     return EFI_NOT_FOUND;
 319   }
 320
 321   if (Normal || !Consist) {
 322     //
 323     // need the Normal here since people can use both on command line.  otherwise unused.
 324     //
 325
 326     //
 327     // Allocate a name
 328     //
 329     CurrentName = NULL;
 330     CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
 331     if (CurrentName == NULL) {
 332       return (EFI_OUT_OF_RESOURCES);
 333     }
 334
 335     //
 336     // Chop off the other names that become "Alias(s)"
 337     // leaving just the normal name
 338     //
 339     TempSpot = StrStr(CurrentName, L";");
 340     if (TempSpot != NULL) {
 341       *TempSpot = CHAR_NULL;
 342     }
 343   } else {
 344     CurrentName = NULL;
 345
 346     //
 347     // Skip the first name.  This is the standard name.
 348     //
 349     TempSpot = StrStr(MapList, L";");
 350     if (TempSpot != NULL) {
 351       TempSpot++;
 352     }
 353     SearchList(TempSpot, L"HD*", &CurrentName, TRUE, FALSE, L";");
 354     if (CurrentName == NULL) {
 355       SearchList(TempSpot, L"CD*", &CurrentName, TRUE, FALSE, L";");
 356     }
 357     if (CurrentName == NULL) {
 358       SearchList(TempSpot, L"FP*", &CurrentName, TRUE, FALSE, L";");
 359     }
 360     if (CurrentName == NULL) {
 361       SearchList(TempSpot, L"F*",  &CurrentName, TRUE, FALSE, L";");
 362     }
 363     if (CurrentName == NULL) {
 364       //
 365       // We didnt find anything, so just the first one in the list...
 366       //
 367       CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
 368       if (CurrentName == NULL) {
 369         return (EFI_OUT_OF_RESOURCES);
 370       }
 371       TempSpot = StrStr(CurrentName, L";");
 372       if (TempSpot != NULL) {
 373         *TempSpot = CHAR_NULL;
 374       }
 375     } else {
 376       Alias = StrnCatGrow(&Alias, 0, MapList, 0);
 377       if (Alias == NULL) {
 378         return EFI_OUT_OF_RESOURCES;
 379       }
 380       TempSpot = StrStr(Alias, CurrentName);
 381       if (TempSpot != NULL) {
 382         TempSpot2 = StrStr(TempSpot, L";");
 383         if (TempSpot2 != NULL) {
 384           TempSpot2++; // Move past ";" from CurrentName
 385           CopyMem(TempSpot, TempSpot2, StrSize(TempSpot2));
 386         } else {
 387           *TempSpot = CHAR_NULL;
 388         }
 389       }
 390       if (Alias[StrLen(Alias)-1] == L';') {
 391         Alias[StrLen(Alias)-1] = CHAR_NULL;
 392       }
 393     }
 394   }
 395   DevPathString = ConvertDevicePathToText(DevPath, TRUE, FALSE);
 396   TempLen = StrLen(CurrentName);
 397   if (!SFO) {
 398     ShellPrintHiiEx (
 399       -1,
 400       -1,
 401       NULL,
 402       STRING_TOKEN (STR_MAP_ENTRY),
 403       gShellLevel2HiiHandle,
 404       CurrentName,
 405       Alias!=NULL?Alias:(TempLen < StrLen(MapList)?MapList + TempLen+1:L""),
 406       DevPathString
 407      );
 408     if (Verbose) {
 409       //
 410       // also print handle, media type, removable (y/n), and current directory
 411       //
 412       MediaType = GetDeviceMediaType(DevPath);
 413       if ((TypeString != NULL &&MediaType != NULL && StrStr(TypeString, MediaType) != NULL) || TypeString == NULL) {
 414         Removable = IsRemoveableDevice(DevPath);
 415         TempSpot2 = ShellGetCurrentDir(CurrentName);
 416         ShellPrintHiiEx (
 417           -1,
 418           -1,
 419           NULL,
 420           STRING_TOKEN (STR_MAP_ENTRY_VERBOSE),
 421           gShellLevel2HiiHandle,
 422           ConvertHandleToHandleIndex(Handle),
 423           MediaType,
 424           Removable?L"Yes":L"No",
 425           TempSpot2
 426          );
 427       }
 428       SHELL_FREE_NON_NULL(MediaType);
 429     }
 430   } else {
 431     ShellPrintHiiEx (
 432       -1,
 433       -1,
 434       NULL,
 435       STRING_TOKEN (STR_MAP_SFO_MAPPINGS),
 436       gShellLevel2HiiHandle,
 437       CurrentName,
 438       DevPathString,
 439       Consist?L"":(TempLen < StrLen(MapList)?MapList + TempLen+1:L"")
 440      );
 441   }
 442   SHELL_FREE_NON_NULL(DevPathString);
 443   SHELL_FREE_NON_NULL(CurrentName);
 444   SHELL_FREE_NON_NULL(Alias);
 445   return EFI_SUCCESS;
 446 }
 447
 448 /**
 449   Delete Specific from the list of maps for device Handle.
 450
 451   @param[in] Specific   The name to delete.
 452   @param[in] Handle     The device to look on.
 453
 454   @retval EFI_SUCCESS     The delete was successful.
 455   @retval EFI_NOT_FOUND   Name was not a map on Handle.
 456 **/
 457 EFI_STATUS
 458 PerformSingleMappingDelete(
 459   IN CONST CHAR16     *Specific,
 460   IN CONST EFI_HANDLE Handle
 461   )
 462 {
 463   EFI_DEVICE_PATH_PROTOCOL  *DevPath;
 464   EFI_DEVICE_PATH_PROTOCOL  *DevPathCopy;
 465   CONST CHAR16              *MapList;
 466   CHAR16                    *CurrentName;
 467
 468   DevPath     = DevicePathFromHandle(Handle);
 469   DevPathCopy = DevPath;
 470   MapList     = gEfiShellProtocol->GetMapFromDevicePath(&DevPathCopy);
 471   CurrentName = NULL;
 472
 473   if (MapList == NULL) {
 474     return (EFI_NOT_FOUND);
 475   }
 476   //
 477   // if there is a specific and its not on the list...
 478   //
 479   if (!SearchList(MapList, Specific, &CurrentName, TRUE, FALSE, L";")) {
 480     return (EFI_NOT_FOUND);
 481   }
 482   return (gEfiShellProtocol->SetMap(NULL, CurrentName));
 483 }
 484
 485 CONST CHAR16 Cd[] = L"cd*";
 486 CONST CHAR16 Hd[] = L"hd*";
 487 CONST CHAR16 Fp[] = L"fp*";
 488 CONST CHAR16 AnyF[] = L"F*";
 489 /**
 490   Function to display mapping information to the user.
 491
 492   If Specific is specified then Consist and Normal will be ignored since information will
 493   be printed for the specific item only.
 494
 495   @param[in] Verbose                TRUE to display (extra) verbose information.
 496   @param[in] Consist                TRUE to display consistent mappings.
 497   @param[in] Normal                 TRUE to display normal (not consist) mappings.
 498   @param[in] TypeString             Pointer to string of filter types.
 499   @param[in] SFO                    TRUE to display output in Standard Output Format.
 500   @param[in] Specific               Pointer to string for specific map to display.
 501   @param[in] Header                 TRUE to print the header block.
 502
 503   @retval SHELL_SUCCESS               The display was printed.
 504   @retval SHELL_INVALID_PARAMETER     One of Consist or Normal must be TRUE if no Specific.
 505
 506 **/
 507 SHELL_STATUS
 508 PerformMappingDisplay(
 509   IN CONST BOOLEAN Verbose,
 510   IN CONST BOOLEAN Consist,
 511   IN CONST BOOLEAN Normal,
 512   IN CONST CHAR16  *TypeString,
 513   IN CONST BOOLEAN SFO,
 514   IN CONST CHAR16  *Specific OPTIONAL,
 515   IN CONST BOOLEAN Header
 516   )
 517 {
 518   EFI_STATUS                Status;
 519   EFI_HANDLE                *HandleBuffer;
 520   UINTN                     BufferSize;
 521   UINTN                     LoopVar;
 522   CHAR16                    *Test;
 523   BOOLEAN                   Found;
 524
 525   if (!Consist && !Normal && Specific == NULL && TypeString == NULL) {
 526     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
 527     return (SHELL_INVALID_PARAMETER);
 528   }
 529
 530   if (TypeString != NULL) {
 531     Test = (CHAR16*)Cd;
 532     if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
 533       Test = (CHAR16*)Hd;
 534       if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
 535         Test = (CHAR16*)Fp;
 536         if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
 537           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", TypeString);
 538           return (SHELL_INVALID_PARAMETER);
 539         }
 540       } else if (Test == NULL) {
 541         Test = (CHAR16*)AnyF;
 542       }
 543     }
 544   } else {
 545     Test = NULL;
 546   }
 547
 548   if (Header) {
 549     //
 550     // Print the header
 551     //
 552     if (!SFO) {
 553       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_HEADER), gShellLevel2HiiHandle);
 554     } else {
 555       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellLevel2HiiHandle, L"map");
 556     }
 557   }
 558
 559   BufferSize    = 0;
 560   HandleBuffer  = NULL;
 561
 562   //
 563   // Look up all SimpleFileSystems in the platform
 564   //
 565   Status = gBS->LocateHandle(
 566     ByProtocol,
 567     &gEfiSimpleFileSystemProtocolGuid,
 568     NULL,
 569     &BufferSize,
 570     HandleBuffer);
 571   if (Status == EFI_BUFFER_TOO_SMALL) {
 572     HandleBuffer = AllocateZeroPool(BufferSize);
 573     if (HandleBuffer == NULL) {
 574       return (SHELL_OUT_OF_RESOURCES);
 575     }
 576     Status = gBS->LocateHandle(
 577       ByProtocol,
 578       &gEfiSimpleFileSystemProtocolGuid,
 579       NULL,
 580       &BufferSize,
 581       HandleBuffer);
 582   }
 583
 584   //
 585   // Get the map name(s) for each one.
 586   //
 587   for ( LoopVar = 0, Found = FALSE
 588       ; LoopVar < (BufferSize / sizeof(EFI_HANDLE)) && HandleBuffer != NULL
 589       ; LoopVar ++
 590      ){
 591     Status = PerformSingleMappingDisplay(
 592       Verbose,
 593       Consist,
 594       Normal,
 595       Test,
 596       SFO,
 597       Specific,
 598       HandleBuffer[LoopVar]);
 599     if (!EFI_ERROR(Status)) {
 600       Found = TRUE;
 601     }
 602   }
 603
 604   //
 605   // Look up all BlockIo in the platform
 606   //
 607   Status = gBS->LocateHandle(
 608     ByProtocol,
 609     &gEfiBlockIoProtocolGuid,
 610     NULL,
 611     &BufferSize,
 612     HandleBuffer);
 613   if (Status == EFI_BUFFER_TOO_SMALL) {
 614     SHELL_FREE_NON_NULL(HandleBuffer);
 615     HandleBuffer = AllocateZeroPool(BufferSize);
 616     if (HandleBuffer == NULL) {
 617       return (SHELL_OUT_OF_RESOURCES);
 618     }
 619     Status = gBS->LocateHandle(
 620       ByProtocol,
 621       &gEfiBlockIoProtocolGuid,
 622       NULL,
 623       &BufferSize,
 624       HandleBuffer);
 625   }
 626   if (!EFI_ERROR(Status) && HandleBuffer != NULL) {
 627     //
 628     // Get the map name(s) for each one.
 629     //
 630     for ( LoopVar = 0
 631         ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
 632         ; LoopVar ++
 633        ){
 634       //
 635       // Skip any that were already done...
 636       //
 637       if (gBS->OpenProtocol(
 638         HandleBuffer[LoopVar],
 639         &gEfiSimpleFileSystemProtocolGuid,
 640         NULL,
 641         gImageHandle,
 642         NULL,
 643         EFI_OPEN_PROTOCOL_TEST_PROTOCOL) == EFI_SUCCESS) {
 644           continue;
 645       }
 646       Status = PerformSingleMappingDisplay(
 647         Verbose,
 648         Consist,
 649         Normal,
 650         Test,
 651         SFO,
 652         Specific,
 653         HandleBuffer[LoopVar]);
 654       if (!EFI_ERROR(Status)) {
 655         Found = TRUE;
 656       }
 657     }
 658     FreePool(HandleBuffer);
 659   }
 660   if (!Found) {
 661     if (Specific != NULL) {
 662       ShellPrintHiiEx(gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", Specific);
 663     } else {
 664       ShellPrintHiiEx(gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle, L"map");
 665     }
 666   }
 667   return (SHELL_SUCCESS);
 668 }
 669
 670 /**
 671   Perform a mapping display and parse for multiple types in the TypeString.
 672
 673   @param[in] Verbose      TRUE to use verbose output.
 674   @param[in] Consist      TRUE to display consistent names.
 675   @param[in] Normal       TRUE to display normal names.
 676   @param[in] TypeString   An optional comma-delimited list of types.
 677   @param[in] SFO          TRUE to display in SFO format.  See Spec.
 678   @param[in] Specific     An optional specific map name to display alone.
 679
 680   @retval SHELL_INVALID_PARAMETER   A parameter was invalid.
 681   @retval SHELL_SUCCESS             The display was successful.
 682   @sa PerformMappingDisplay
 683 **/
 684 SHELL_STATUS
 685 PerformMappingDisplay2(
 686   IN CONST BOOLEAN Verbose,
 687   IN CONST BOOLEAN Consist,
 688   IN CONST BOOLEAN Normal,
 689   IN CONST CHAR16  *TypeString,
 690   IN CONST BOOLEAN SFO,
 691   IN CONST CHAR16  *Specific OPTIONAL
 692   )
 693 {
 694   CONST CHAR16  *TypeWalker;
 695   SHELL_STATUS  ShellStatus;
 696   CHAR16        *Comma;
 697
 698
 699   if (TypeString == NULL) {
 700     return (PerformMappingDisplay(Verbose, Consist, Normal, NULL, SFO, Specific, TRUE));
 701   }
 702   ShellStatus = SHELL_SUCCESS;
 703   for (TypeWalker = TypeString ; TypeWalker != NULL && *TypeWalker != CHAR_NULL ;) {
 704     Comma = StrStr(TypeWalker, L",");
 705     if (Comma == NULL) {
 706       if (ShellStatus == SHELL_SUCCESS) {
 707         ShellStatus = PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
 708       } else {
 709         PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
 710       }
 711       break;
 712     } else {
 713       *Comma = CHAR_NULL;
 714       if (ShellStatus == SHELL_SUCCESS) {
 715         ShellStatus = PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
 716       } else {
 717         PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
 718       }
 719       *Comma = L',';
 720       TypeWalker = Comma + 1;
 721     }
 722   }
 723
 724   return (ShellStatus);
 725 }
 726
 727 /**
 728   Delete a specific map.
 729
 730   @param[in] Specific  The pointer to the name of the map to delete.
 731
 732   @retval EFI_INVALID_PARAMETER     Specific was NULL.
 733   @retval EFI_SUCCESS               The operation was successful.
 734   @retval EFI_NOT_FOUND             Specific could not be found.
 735 **/
 736 EFI_STATUS
 737 PerformMappingDelete(
 738   IN CONST CHAR16  *Specific
 739   )
 740 {
 741   EFI_STATUS                Status;
 742   EFI_HANDLE                *HandleBuffer;
 743   UINTN                     BufferSize;
 744   UINTN                     LoopVar;
 745   BOOLEAN                   Deleted;
 746
 747   if (Specific == NULL) {
 748     return (EFI_INVALID_PARAMETER);
 749   }
 750
 751   BufferSize    = 0;
 752   HandleBuffer  = NULL;
 753   Deleted       = FALSE;
 754
 755   //
 756   // Look up all SimpleFileSystems in the platform
 757   //
 758   Status = gBS->LocateHandle(
 759     ByProtocol,
 760     &gEfiDevicePathProtocolGuid,
 761     NULL,
 762     &BufferSize,
 763     HandleBuffer);
 764   if (Status == EFI_BUFFER_TOO_SMALL) {
 765     HandleBuffer = AllocateZeroPool(BufferSize);
 766     if (HandleBuffer == NULL) {
 767       return (EFI_OUT_OF_RESOURCES);
 768     }
 769     Status = gBS->LocateHandle(
 770       ByProtocol,
 771       &gEfiDevicePathProtocolGuid,
 772       NULL,
 773       &BufferSize,
 774       HandleBuffer);
 775   }
 776   if (EFI_ERROR(Status)) {
 777     SHELL_FREE_NON_NULL(HandleBuffer);
 778     return (Status);
 779   }
 780
 781   if (HandleBuffer != NULL) {
 782     //
 783     // Get the map name(s) for each one.
 784     //
 785     for ( LoopVar = 0
 786         ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
 787         ; LoopVar ++
 788        ){
 789       if (PerformSingleMappingDelete(Specific,HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
 790           Deleted = TRUE;
 791       }
 792     }
 793   }
 794   //
 795   // Look up all BlockIo in the platform
 796   //
 797   Status = gBS->LocateHandle(
 798     ByProtocol,
 799     &gEfiBlockIoProtocolGuid,
 800     NULL,
 801     &BufferSize,
 802     HandleBuffer);
 803   if (Status == EFI_BUFFER_TOO_SMALL) {
 804     FreePool(HandleBuffer);
 805     HandleBuffer = AllocateZeroPool(BufferSize);
 806     if (HandleBuffer == NULL) {
 807       return (EFI_OUT_OF_RESOURCES);
 808     }
 809     Status = gBS->LocateHandle(
 810       ByProtocol,
 811       &gEfiBlockIoProtocolGuid,
 812       NULL,
 813       &BufferSize,
 814       HandleBuffer);
 815   }
 816   if (EFI_ERROR(Status)) {
 817     SHELL_FREE_NON_NULL(HandleBuffer);
 818     return (Status);
 819   }
 820
 821   if (HandleBuffer != NULL) {
 822     //
 823     // Get the map name(s) for each one.
 824     //
 825     for ( LoopVar = 0
 826         ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
 827         ; LoopVar ++
 828        ){
 829       //
 830       // Skip any that were already done...
 831       //
 832       if (gBS->OpenProtocol(
 833         HandleBuffer[LoopVar],
 834         &gEfiDevicePathProtocolGuid,
 835         NULL,
 836         gImageHandle,
 837         NULL,
 838         EFI_OPEN_PROTOCOL_TEST_PROTOCOL) == EFI_SUCCESS) {
 839           continue;
 840       }
 841       if (PerformSingleMappingDelete(Specific,HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
 842           Deleted = TRUE;
 843       }
 844     }
 845   }
 846   SHELL_FREE_NON_NULL(HandleBuffer);
 847   if (!Deleted) {
 848     return (EFI_NOT_FOUND);
 849   }
 850   return (EFI_SUCCESS);
 851 }
 852
 853 /**
 854   function to add a mapping from mapping.
 855
 856   This function will get the device path associated with the mapping and call SetMap.
 857
 858   @param[in] Map         The Map to add a mapping for
 859   @param[in] SName       The name of the new mapping
 860
 861   @retval SHELL_SUCCESS             the mapping was added
 862   @retval SHELL_INVALID_PARAMETER   the device path for Map could not be retrieved.
 863   @return                           Shell version of a return value from EfiShellProtocol->SetMap
 864
 865 **/
 866 SHELL_STATUS
 867 AddMappingFromMapping(
 868   IN CONST CHAR16     *Map,
 869   IN CONST CHAR16     *SName
 870   )
 871 {
 872   CONST EFI_DEVICE_PATH_PROTOCOL  *DevPath;
 873   EFI_STATUS                      Status;
 874   CHAR16                          *NewSName;
 875   RETURN_STATUS                   StrRetStatus;
 876
 877   NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
 878   if (NewSName == NULL) {
 879     return (SHELL_OUT_OF_RESOURCES);
 880   }
 881   if (NewSName[StrLen(NewSName)-1] != L':') {
 882     StrRetStatus = StrnCatS(NewSName, (StrSize(SName) + sizeof(CHAR16))/sizeof(CHAR16), L":", StrLen(L":"));
 883     if (EFI_ERROR(StrRetStatus)) {
 884       FreePool(NewSName);
 885       return ((SHELL_STATUS) (StrRetStatus & (~MAX_BIT)));
 886     }
 887   }
 888
 889   if (!IsNumberLetterOnly(NewSName, StrLen(NewSName)-1)) {
 890     FreePool(NewSName);
 891     return (SHELL_INVALID_PARAMETER);
 892   }
 893
 894   DevPath = gEfiShellProtocol->GetDevicePathFromMap(Map);
 895   if (DevPath == NULL) {
 896     FreePool(NewSName);
 897     return (SHELL_INVALID_PARAMETER);
 898   }
 899
 900   Status = gEfiShellProtocol->SetMap(DevPath, NewSName);
 901   FreePool(NewSName);
 902   if (EFI_ERROR(Status)) {
 903     return (SHELL_DEVICE_ERROR);
 904   }
 905   return (SHELL_SUCCESS);
 906 }
 907
 908 /**
 909   function to add a mapping from an EFI_HANDLE.
 910
 911   This function will get the device path associated with the Handle and call SetMap.
 912
 913   @param[in] Handle       The handle to add a mapping for
 914   @param[in] SName        The name of the new mapping
 915
 916   @retval SHELL_SUCCESS           the mapping was added
 917   @retval SHELL_INVALID_PARAMETER SName was not valid for a map name.
 918   @return                         Shell version of a return value from either
 919                                   gBS->OpenProtocol or EfiShellProtocol->SetMap
 920
 921 **/
 922 SHELL_STATUS
 923 AddMappingFromHandle(
 924   IN CONST EFI_HANDLE Handle,
 925   IN CONST CHAR16     *SName
 926   )
 927 {
 928   EFI_DEVICE_PATH_PROTOCOL  *DevPath;
 929   EFI_STATUS                Status;
 930   CHAR16                    *NewSName;
 931   RETURN_STATUS             StrRetStatus;
 932
 933   NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
 934   if (NewSName == NULL) {
 935     return (SHELL_OUT_OF_RESOURCES);
 936   }
 937   if (NewSName[StrLen(NewSName)-1] != L':') {
 938     StrRetStatus = StrnCatS(NewSName, (StrSize(SName) + sizeof(CHAR16))/sizeof(CHAR16), L":", StrLen(L":"));
 939     if (EFI_ERROR(StrRetStatus)) {
 940       FreePool(NewSName);
 941       return ((SHELL_STATUS) (StrRetStatus & (~MAX_BIT)));
 942     }
 943   }
 944
 945   if (!IsNumberLetterOnly(NewSName, StrLen(NewSName)-1)) {
 946     FreePool(NewSName);
 947     return (SHELL_INVALID_PARAMETER);
 948   }
 949
 950   Status = gBS->OpenProtocol(
 951     Handle,
 952     &gEfiDevicePathProtocolGuid,
 953     (VOID**)&DevPath,
 954     gImageHandle,
 955     NULL,
 956     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 957    );
 958   if (EFI_ERROR(Status)) {
 959     FreePool(NewSName);
 960     return (SHELL_DEVICE_ERROR);
 961   }
 962   Status = gEfiShellProtocol->SetMap(DevPath, NewSName);
 963   FreePool(NewSName);
 964   if (EFI_ERROR(Status)) {
 965     return (SHELL_DEVICE_ERROR);
 966   }
 967   return (SHELL_SUCCESS);
 968 }
 969
 970 STATIC CONST SHELL_PARAM_ITEM MapParamList[] = {
 971   {L"-d", TypeValue},
 972   {L"-r", TypeFlag},
 973   {L"-v", TypeFlag},
 974   {L"-c", TypeFlag},
 975   {L"-f", TypeFlag},
 976   {L"-u", TypeFlag},
 977   {L"-t", TypeValue},
 978   {L"-sfo", TypeValue},
 979   {NULL, TypeMax}
 980   };
 981
 982 /**
 983   The routine issues dummy read for every physical block device to cause
 984   the BlockIo re-installed if media change happened.
 985 **/
 986 VOID
 987 ProbeForMediaChange (
 988   VOID
 989   )
 990 {
 991   EFI_STATUS                            Status;
 992   UINTN                                 HandleCount;
 993   EFI_HANDLE                            *Handles;
 994   EFI_BLOCK_IO_PROTOCOL                 *BlockIo;
 995   UINTN                                 Index;
 996
 997   gBS->LocateHandleBuffer (
 998          ByProtocol,
 999          &gEfiBlockIoProtocolGuid,
1000          NULL,
1001          &HandleCount,
1002          &Handles
1003          );
1004   //
1005   // Probe for media change for every physical block io
1006   //
1007   for (Index = 0; Index < HandleCount; Index++) {
1008     Status = gBS->HandleProtocol (
1009                     Handles[Index],
1010                     &gEfiBlockIoProtocolGuid,
1011                     (VOID **) &BlockIo
1012                     );
1013     if (!EFI_ERROR (Status)) {
1014       if (!BlockIo->Media->LogicalPartition) {
1015         //
1016         // Per spec:
1017         //   The function (ReadBlocks) must return EFI_NO_MEDIA or
1018         //   EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1019         //   for changes in media state.
1020         //
1021         BlockIo->ReadBlocks (
1022                    BlockIo,
1023                    BlockIo->Media->MediaId,
1024                    0,
1025                    0,
1026                    NULL
1027                    );
1028       }
1029     }
1030   }
1031 }
1032
1033 /**
1034   Function for 'map' command.
1035
1036   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
1037   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
1038 **/
1039 SHELL_STATUS
1040 EFIAPI
1041 ShellCommandRunMap (
1042   IN EFI_HANDLE        ImageHandle,
1043   IN EFI_SYSTEM_TABLE  *SystemTable
1044   )
1045 {
1046   EFI_STATUS    Status;
1047   LIST_ENTRY    *Package;
1048   CHAR16        *ProblemParam;
1049   CONST CHAR16  *SName;
1050   CONST CHAR16  *Mapping;
1051   EFI_HANDLE    MapAsHandle;
1052   SHELL_STATUS  ShellStatus;
1053   BOOLEAN       SfoMode;
1054   BOOLEAN       ConstMode;
1055   BOOLEAN       NormlMode;
1056   CONST CHAR16  *Param1;
1057   CONST CHAR16  *TypeString;
1058   UINTN         TempStringLength;
1059
1060   ProblemParam  = NULL;
1061   Mapping       = NULL;
1062   SName         = NULL;
1063   ShellStatus   = SHELL_SUCCESS;
1064   MapAsHandle = NULL;
1065
1066   //
1067   // initialize the shell lib (we must be in non-auto-init...)
1068   //
1069   Status = ShellInitialize();
1070   ASSERT_EFI_ERROR(Status);
1071
1072   Status = CommandInit();
1073   ASSERT_EFI_ERROR(Status);
1074
1075   //
1076   // parse the command line
1077   //
1078   Status = ShellCommandLineParse (MapParamList, &Package, &ProblemParam, TRUE);
1079   if (EFI_ERROR(Status)) {
1080     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
1081       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"map", ProblemParam);
1082       FreePool(ProblemParam);
1083       ShellStatus = SHELL_INVALID_PARAMETER;
1084     } else {
1085       ASSERT(FALSE);
1086     }
1087   } else {
1088     //
1089     // check for "-?"
1090     //
1091     SfoMode   = ShellCommandLineGetFlag(Package, L"-sfo");
1092     ConstMode = ShellCommandLineGetFlag(Package, L"-c");
1093     NormlMode = ShellCommandLineGetFlag(Package, L"-f");
1094     if (ShellCommandLineGetFlag(Package, L"-?")) {
1095       ASSERT(FALSE);
1096     } else if (ShellCommandLineGetRawValue(Package, 3) != NULL) {
1097       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"map");
1098       ShellStatus = SHELL_INVALID_PARAMETER;
1099     } else {
1100       //
1101       // Deleting a map name...
1102       //
1103       if (ShellCommandLineGetFlag(Package, L"-d")) {
1104         if ( ShellCommandLineGetFlag(Package, L"-r")
1105           || ShellCommandLineGetFlag(Package, L"-v")
1106           || ConstMode
1107           || NormlMode
1108           || ShellCommandLineGetFlag(Package, L"-u")
1109           || ShellCommandLineGetFlag(Package, L"-t")
1110          ){
1111           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CON), gShellLevel2HiiHandle, L"map");
1112           ShellStatus = SHELL_INVALID_PARAMETER;
1113         } else {
1114           SName = ShellCommandLineGetValue(Package, L"-d");
1115           if (SName != NULL) {
1116             Status = PerformMappingDelete(SName);
1117             if (EFI_ERROR(Status)) {
1118               if (Status == EFI_ACCESS_DENIED) {
1119                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1120                 ShellStatus = SHELL_ACCESS_DENIED;
1121               } else if (Status == EFI_NOT_FOUND) {
1122                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", SName);
1123                 ShellStatus = SHELL_INVALID_PARAMETER;
1124               } else {
1125                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1126                 ShellStatus = SHELL_UNSUPPORTED;
1127               }
1128             }
1129           } else {
1130             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
1131             ShellStatus = SHELL_INVALID_PARAMETER;
1132           }
1133         }
1134       } else if ( ShellCommandLineGetFlag(Package, L"-r")
1135 //               || ShellCommandLineGetFlag(Package, L"-v")
1136                || ConstMode
1137                || NormlMode
1138                || ShellCommandLineGetFlag(Package, L"-u")
1139                || ShellCommandLineGetFlag(Package, L"-t")
1140               ){
1141         ProbeForMediaChange ();
1142         if ( ShellCommandLineGetFlag(Package, L"-r")) {
1143           //
1144           // Do the reset
1145           //
1146           Status = ShellCommandCreateInitialMappingsAndPaths();
1147           if (EFI_ERROR(Status)) {
1148             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1149             ShellStatus = SHELL_UNSUPPORTED;
1150           }
1151         }
1152         if ( ShellStatus == SHELL_SUCCESS && ShellCommandLineGetFlag(Package, L"-u")) {
1153           //
1154           // Do the Update
1155           //
1156           Status = ShellCommandUpdateMapping ();
1157           if (EFI_ERROR(Status)) {
1158             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1159             ShellStatus = SHELL_UNSUPPORTED;
1160           }
1161         }
1162         if (ShellStatus == SHELL_SUCCESS) {
1163           Param1 = ShellCommandLineGetRawValue(Package, 1);
1164           TypeString = ShellCommandLineGetValue(Package, L"-t");
1165           if (!ConstMode
1166             &&!NormlMode
1167             &&TypeString  == NULL
1168             ) {
1169             //
1170             // now do the display...
1171             //
1172             ShellStatus = PerformMappingDisplay(
1173               ShellCommandLineGetFlag(Package, L"-v"),
1174               TRUE,
1175               TRUE,
1176               NULL,
1177               SfoMode,
1178               Param1,
1179               TRUE
1180              );
1181           } else {
1182             //
1183             // now do the display...
1184             //
1185             ShellStatus = PerformMappingDisplay2(
1186               ShellCommandLineGetFlag(Package, L"-v"),
1187               ConstMode,
1188               NormlMode,
1189               TypeString,
1190               SfoMode,
1191               Param1
1192              );
1193           }
1194         }
1195       } else {
1196         //
1197         // adding or displaying (there were no flags)
1198         //
1199         SName = ShellCommandLineGetRawValue(Package, 1);
1200         Mapping = ShellCommandLineGetRawValue(Package, 2);
1201         if ( SName == NULL
1202           && Mapping == NULL
1203          ){
1204           //
1205           // display only since no flags
1206           //
1207           ShellStatus = PerformMappingDisplay(
1208             ShellCommandLineGetFlag(Package, L"-v"),
1209             TRUE,
1210             TRUE,
1211             NULL,
1212             SfoMode,
1213             NULL,
1214             TRUE
1215            );
1216         } else if ( SName == NULL
1217           || Mapping == NULL
1218          ){
1219             //
1220             // Display only the one specified
1221             //
1222           ShellStatus = PerformMappingDisplay(
1223             FALSE,
1224             FALSE,
1225             FALSE,
1226             NULL,
1227             SfoMode,
1228             SName, // note the variable here...
1229             TRUE
1230            );
1231         } else {
1232           if (ShellIsHexOrDecimalNumber(Mapping, TRUE, FALSE)) {
1233             MapAsHandle = ConvertHandleIndexToHandle(ShellStrToUintn(Mapping));
1234           } else {
1235             MapAsHandle = NULL;
1236           }
1237           if (MapAsHandle == NULL && Mapping[StrLen(Mapping)-1] != L':') {
1238             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1239             ShellStatus = SHELL_INVALID_PARAMETER;
1240           } else {
1241             TempStringLength = StrLen(SName);
1242             if (!IsNumberLetterOnly(SName, TempStringLength-(SName[TempStringLength-1]==L':'?1:0))) {
1243               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", SName);
1244               ShellStatus = SHELL_INVALID_PARAMETER;
1245             }
1246
1247             if (ShellStatus == SHELL_SUCCESS) {
1248               if (MapAsHandle != NULL) {
1249                 ShellStatus = AddMappingFromHandle(MapAsHandle, SName);
1250               } else {
1251                 ShellStatus = AddMappingFromMapping(Mapping, SName);
1252               }
1253
1254               if (ShellStatus != SHELL_SUCCESS) {
1255                 switch (ShellStatus) {
1256                   case SHELL_ACCESS_DENIED:
1257                     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1258                     break;
1259                   case SHELL_INVALID_PARAMETER:
1260                     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1261                     break;
1262                   case SHELL_DEVICE_ERROR:
1263                     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NOF), gShellLevel2HiiHandle, L"map", Mapping);
1264                     break;
1265                   default:
1266                     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", ShellStatus|MAX_BIT);
1267                 }
1268               } else {
1269                 //
1270                 // now do the display...
1271                 //
1272                 ShellStatus = PerformMappingDisplay(
1273                   FALSE,
1274                   FALSE,
1275                   FALSE,
1276                   NULL,
1277                   SfoMode,
1278                   SName,
1279                   TRUE
1280                  );
1281               } // we were sucessful so do an output
1282             }
1283           } // got a valid map target
1284         } // got 2 variables
1285       } // we are adding a mapping
1286     } // got valid parameters
1287   }
1288
1289   //
1290   // free the command line package
1291   //
1292   ShellCommandLineFreeVarList (Package);
1293
1294   return (ShellStatus);
1295 }
1296