ShellPkg/map: Fix out-of-bound read when "map fsn"
[mirror_edk2.git] / ShellPkg / Library / UefiShellLevel2CommandsLib / Map.c
1 /** @file
2 Main file for map shell level 2 command.
3
4 Copyright (c) 2009 - 2018, 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 UINTN Length;
226
227 //
228 // specific has priority
229 //
230 if (Specific != NULL) {
231 Length = StrLen (Specific);
232 //
233 // Allocate enough buffer for Specific and potential ":"
234 //
235 NewSpecific = AllocatePool ((Length + 2) * sizeof(CHAR16));
236 if (NewSpecific == NULL){
237 return FALSE;
238 }
239 StrCpyS (NewSpecific, Length + 2, Specific);
240 if (Specific[Length - 1] != L':') {
241 Status = StrnCatS(NewSpecific, Length + 2, L":", StrLen(L":"));
242 if (EFI_ERROR (Status)) {
243 FreePool(NewSpecific);
244 return FALSE;
245 }
246 }
247
248 if (SearchList(MapList, NewSpecific, NULL, TRUE, FALSE, L";")) {
249 FreePool(NewSpecific);
250 return (TRUE);
251 }
252 FreePool(NewSpecific);
253 }
254 if ( Consist
255 && Specific == NULL
256 && (SearchList(MapList, L"HD*", NULL, TRUE, TRUE, L";")
257 ||SearchList(MapList, L"CD*", NULL, TRUE, TRUE, L";")
258 ||SearchList(MapList, L"F*", NULL, TRUE, TRUE, L";")
259 ||SearchList(MapList, L"FP*", NULL, TRUE, TRUE, L";"))){
260 return (TRUE);
261 }
262
263 if ( Normal
264 && Specific == NULL
265 && (SearchList(MapList, L"FS", NULL, FALSE, TRUE, L";")
266 ||SearchList(MapList, L"BLK", NULL, FALSE, TRUE, L";"))){
267 return (TRUE);
268 }
269
270 if (TypeString != NULL && SearchList(MapList, TypeString, NULL, TRUE, TRUE, L";")) {
271 return (TRUE);
272 }
273 return (FALSE);
274 }
275
276
277 /**
278 Display a single map line for device Handle if conditions are met.
279
280 @param[in] Verbose TRUE to display (extra) verbose information.
281 @param[in] Consist TRUE to display consistent mappings.
282 @param[in] Normal TRUE to display normal (not consist) mappings.
283 @param[in] TypeString pointer to string of filter types.
284 @param[in] SFO TRUE to display output in Standard Output Format.
285 @param[in] Specific pointer to string for specific map to display.
286 @param[in] Handle The handle to display from.
287
288 @retval EFI_SUCCESS The mapping was displayed.
289 **/
290 EFI_STATUS
291 PerformSingleMappingDisplay(
292 IN CONST BOOLEAN Verbose,
293 IN CONST BOOLEAN Consist,
294 IN CONST BOOLEAN Normal,
295 IN CONST CHAR16 *TypeString,
296 IN CONST BOOLEAN SFO,
297 IN CONST CHAR16 *Specific OPTIONAL,
298 IN CONST EFI_HANDLE Handle
299 )
300 {
301 EFI_DEVICE_PATH_PROTOCOL *DevPath;
302 EFI_DEVICE_PATH_PROTOCOL *DevPathCopy;
303 CONST CHAR16 *MapList;
304 CHAR16 *CurrentName;
305 CHAR16 *MediaType;
306 CHAR16 *DevPathString;
307 CHAR16 *TempSpot;
308 CHAR16 *Alias;
309 UINTN TempLen;
310 BOOLEAN Removable;
311 CONST CHAR16 *TempSpot2;
312
313 Alias = NULL;
314 TempSpot2 = NULL;
315 CurrentName = NULL;
316 DevPath = DevicePathFromHandle(Handle);
317 DevPathCopy = DevPath;
318 MapList = gEfiShellProtocol->GetMapFromDevicePath(&DevPathCopy);
319 if (MapList == NULL) {
320 return EFI_NOT_FOUND;
321 }
322
323 if (!MappingListHasType(MapList, Specific, TypeString, Normal, Consist)){
324 return EFI_NOT_FOUND;
325 }
326
327 if (Normal || !Consist) {
328 //
329 // need the Normal here since people can use both on command line. otherwise unused.
330 //
331
332 //
333 // Allocate a name
334 //
335 CurrentName = NULL;
336 CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
337 if (CurrentName == NULL) {
338 return (EFI_OUT_OF_RESOURCES);
339 }
340
341 //
342 // Chop off the other names that become "Alias(s)"
343 // leaving just the normal name
344 //
345 TempSpot = StrStr(CurrentName, L";");
346 if (TempSpot != NULL) {
347 *TempSpot = CHAR_NULL;
348 }
349 } else {
350 CurrentName = NULL;
351
352 //
353 // Skip the first name. This is the standard name.
354 //
355 TempSpot = StrStr(MapList, L";");
356 if (TempSpot != NULL) {
357 TempSpot++;
358 }
359 SearchList(TempSpot, L"HD*", &CurrentName, TRUE, FALSE, L";");
360 if (CurrentName == NULL) {
361 SearchList(TempSpot, L"CD*", &CurrentName, TRUE, FALSE, L";");
362 }
363 if (CurrentName == NULL) {
364 SearchList(TempSpot, L"FP*", &CurrentName, TRUE, FALSE, L";");
365 }
366 if (CurrentName == NULL) {
367 SearchList(TempSpot, L"F*", &CurrentName, TRUE, FALSE, L";");
368 }
369 if (CurrentName == NULL) {
370 //
371 // We didnt find anything, so just the first one in the list...
372 //
373 CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
374 if (CurrentName == NULL) {
375 return (EFI_OUT_OF_RESOURCES);
376 }
377 TempSpot = StrStr(CurrentName, L";");
378 if (TempSpot != NULL) {
379 *TempSpot = CHAR_NULL;
380 }
381 } else {
382 Alias = StrnCatGrow(&Alias, 0, MapList, 0);
383 if (Alias == NULL) {
384 return EFI_OUT_OF_RESOURCES;
385 }
386 TempSpot = StrStr(Alias, CurrentName);
387 if (TempSpot != NULL) {
388 TempSpot2 = StrStr(TempSpot, L";");
389 if (TempSpot2 != NULL) {
390 TempSpot2++; // Move past ";" from CurrentName
391 CopyMem(TempSpot, TempSpot2, StrSize(TempSpot2));
392 } else {
393 *TempSpot = CHAR_NULL;
394 }
395 }
396 if (Alias[StrLen(Alias)-1] == L';') {
397 Alias[StrLen(Alias)-1] = CHAR_NULL;
398 }
399 }
400 }
401 DevPathString = ConvertDevicePathToText(DevPath, TRUE, FALSE);
402 TempLen = StrLen(CurrentName);
403 if (!SFO) {
404 ShellPrintHiiEx (
405 -1,
406 -1,
407 NULL,
408 STRING_TOKEN (STR_MAP_ENTRY),
409 gShellLevel2HiiHandle,
410 CurrentName,
411 Alias!=NULL?Alias:(TempLen < StrLen(MapList)?MapList + TempLen+1:L""),
412 DevPathString
413 );
414 if (Verbose) {
415 //
416 // also print handle, media type, removable (y/n), and current directory
417 //
418 MediaType = GetDeviceMediaType(DevPath);
419 if ((TypeString != NULL &&MediaType != NULL && StrStr(TypeString, MediaType) != NULL) || TypeString == NULL) {
420 Removable = IsRemoveableDevice(DevPath);
421 TempSpot2 = ShellGetCurrentDir(CurrentName);
422 ShellPrintHiiEx (
423 -1,
424 -1,
425 NULL,
426 STRING_TOKEN (STR_MAP_ENTRY_VERBOSE),
427 gShellLevel2HiiHandle,
428 ConvertHandleToHandleIndex(Handle),
429 MediaType,
430 Removable?L"Yes":L"No",
431 TempSpot2
432 );
433 }
434 SHELL_FREE_NON_NULL(MediaType);
435 }
436 } else {
437 ShellPrintHiiEx (
438 -1,
439 -1,
440 NULL,
441 STRING_TOKEN (STR_MAP_SFO_MAPPINGS),
442 gShellLevel2HiiHandle,
443 CurrentName,
444 DevPathString,
445 Consist?L"":(TempLen < StrLen(MapList)?MapList + TempLen+1:L"")
446 );
447 }
448 SHELL_FREE_NON_NULL(DevPathString);
449 SHELL_FREE_NON_NULL(CurrentName);
450 SHELL_FREE_NON_NULL(Alias);
451 return EFI_SUCCESS;
452 }
453
454 /**
455 Delete Specific from the list of maps for device Handle.
456
457 @param[in] Specific The name to delete.
458 @param[in] Handle The device to look on.
459
460 @retval EFI_SUCCESS The delete was successful.
461 @retval EFI_NOT_FOUND Name was not a map on Handle.
462 **/
463 EFI_STATUS
464 PerformSingleMappingDelete(
465 IN CONST CHAR16 *Specific,
466 IN CONST EFI_HANDLE Handle
467 )
468 {
469 EFI_DEVICE_PATH_PROTOCOL *DevPath;
470 EFI_DEVICE_PATH_PROTOCOL *DevPathCopy;
471 CONST CHAR16 *MapList;
472 CHAR16 *CurrentName;
473
474 DevPath = DevicePathFromHandle(Handle);
475 DevPathCopy = DevPath;
476 MapList = gEfiShellProtocol->GetMapFromDevicePath(&DevPathCopy);
477 CurrentName = NULL;
478
479 if (MapList == NULL) {
480 return (EFI_NOT_FOUND);
481 }
482 //
483 // if there is a specific and its not on the list...
484 //
485 if (!SearchList(MapList, Specific, &CurrentName, TRUE, FALSE, L";")) {
486 return (EFI_NOT_FOUND);
487 }
488 return (gEfiShellProtocol->SetMap(NULL, CurrentName));
489 }
490
491 CONST CHAR16 Cd[] = L"cd*";
492 CONST CHAR16 Hd[] = L"hd*";
493 CONST CHAR16 Fp[] = L"fp*";
494 CONST CHAR16 AnyF[] = L"F*";
495 /**
496 Function to display mapping information to the user.
497
498 If Specific is specified then Consist and Normal will be ignored since information will
499 be printed for the specific item only.
500
501 @param[in] Verbose TRUE to display (extra) verbose information.
502 @param[in] Consist TRUE to display consistent mappings.
503 @param[in] Normal TRUE to display normal (not consist) mappings.
504 @param[in] TypeString Pointer to string of filter types.
505 @param[in] SFO TRUE to display output in Standard Output Format.
506 @param[in] Specific Pointer to string for specific map to display.
507 @param[in] Header TRUE to print the header block.
508
509 @retval SHELL_SUCCESS The display was printed.
510 @retval SHELL_INVALID_PARAMETER One of Consist or Normal must be TRUE if no Specific.
511
512 **/
513 SHELL_STATUS
514 PerformMappingDisplay(
515 IN CONST BOOLEAN Verbose,
516 IN CONST BOOLEAN Consist,
517 IN CONST BOOLEAN Normal,
518 IN CONST CHAR16 *TypeString,
519 IN CONST BOOLEAN SFO,
520 IN CONST CHAR16 *Specific OPTIONAL,
521 IN CONST BOOLEAN Header
522 )
523 {
524 EFI_STATUS Status;
525 EFI_HANDLE *HandleBuffer;
526 UINTN BufferSize;
527 UINTN LoopVar;
528 CHAR16 *Test;
529 BOOLEAN Found;
530
531 if (!Consist && !Normal && Specific == NULL && TypeString == NULL) {
532 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
533 return (SHELL_INVALID_PARAMETER);
534 }
535
536 if (TypeString != NULL) {
537 Test = (CHAR16*)Cd;
538 if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
539 Test = (CHAR16*)Hd;
540 if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
541 Test = (CHAR16*)Fp;
542 if (StrnCmp(TypeString, Test, StrLen(Test)-1) != 0) {
543 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", TypeString);
544 return (SHELL_INVALID_PARAMETER);
545 }
546 } else if (Test == NULL) {
547 Test = (CHAR16*)AnyF;
548 }
549 }
550 } else {
551 Test = NULL;
552 }
553
554 if (Header) {
555 //
556 // Print the header
557 //
558 if (!SFO) {
559 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_HEADER), gShellLevel2HiiHandle);
560 } else {
561 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellLevel2HiiHandle, L"map");
562 }
563 }
564
565 BufferSize = 0;
566 HandleBuffer = NULL;
567
568 //
569 // Look up all SimpleFileSystems in the platform
570 //
571 Status = gBS->LocateHandle(
572 ByProtocol,
573 &gEfiSimpleFileSystemProtocolGuid,
574 NULL,
575 &BufferSize,
576 HandleBuffer);
577 if (Status == EFI_BUFFER_TOO_SMALL) {
578 HandleBuffer = AllocateZeroPool(BufferSize);
579 if (HandleBuffer == NULL) {
580 return (SHELL_OUT_OF_RESOURCES);
581 }
582 Status = gBS->LocateHandle(
583 ByProtocol,
584 &gEfiSimpleFileSystemProtocolGuid,
585 NULL,
586 &BufferSize,
587 HandleBuffer);
588 }
589
590 //
591 // Get the map name(s) for each one.
592 //
593 for ( LoopVar = 0, Found = FALSE
594 ; LoopVar < (BufferSize / sizeof(EFI_HANDLE)) && HandleBuffer != NULL
595 ; LoopVar ++
596 ){
597 Status = PerformSingleMappingDisplay(
598 Verbose,
599 Consist,
600 Normal,
601 Test,
602 SFO,
603 Specific,
604 HandleBuffer[LoopVar]);
605 if (!EFI_ERROR(Status)) {
606 Found = TRUE;
607 }
608 }
609
610 //
611 // Look up all BlockIo in the platform
612 //
613 Status = gBS->LocateHandle(
614 ByProtocol,
615 &gEfiBlockIoProtocolGuid,
616 NULL,
617 &BufferSize,
618 HandleBuffer);
619 if (Status == EFI_BUFFER_TOO_SMALL) {
620 SHELL_FREE_NON_NULL(HandleBuffer);
621 HandleBuffer = AllocateZeroPool(BufferSize);
622 if (HandleBuffer == NULL) {
623 return (SHELL_OUT_OF_RESOURCES);
624 }
625 Status = gBS->LocateHandle(
626 ByProtocol,
627 &gEfiBlockIoProtocolGuid,
628 NULL,
629 &BufferSize,
630 HandleBuffer);
631 }
632 if (!EFI_ERROR(Status) && HandleBuffer != NULL) {
633 //
634 // Get the map name(s) for each one.
635 //
636 for ( LoopVar = 0
637 ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
638 ; LoopVar ++
639 ){
640 //
641 // Skip any that were already done...
642 //
643 if (gBS->OpenProtocol(
644 HandleBuffer[LoopVar],
645 &gEfiSimpleFileSystemProtocolGuid,
646 NULL,
647 gImageHandle,
648 NULL,
649 EFI_OPEN_PROTOCOL_TEST_PROTOCOL) == EFI_SUCCESS) {
650 continue;
651 }
652 Status = PerformSingleMappingDisplay(
653 Verbose,
654 Consist,
655 Normal,
656 Test,
657 SFO,
658 Specific,
659 HandleBuffer[LoopVar]);
660 if (!EFI_ERROR(Status)) {
661 Found = TRUE;
662 }
663 }
664 FreePool(HandleBuffer);
665 }
666 if (!Found) {
667 if (Specific != NULL) {
668 ShellPrintHiiEx(gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", Specific);
669 } else {
670 ShellPrintHiiEx(gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle, L"map");
671 }
672 }
673 return (SHELL_SUCCESS);
674 }
675
676 /**
677 Perform a mapping display and parse for multiple types in the TypeString.
678
679 @param[in] Verbose TRUE to use verbose output.
680 @param[in] Consist TRUE to display consistent names.
681 @param[in] Normal TRUE to display normal names.
682 @param[in] TypeString An optional comma-delimited list of types.
683 @param[in] SFO TRUE to display in SFO format. See Spec.
684 @param[in] Specific An optional specific map name to display alone.
685
686 @retval SHELL_INVALID_PARAMETER A parameter was invalid.
687 @retval SHELL_SUCCESS The display was successful.
688 @sa PerformMappingDisplay
689 **/
690 SHELL_STATUS
691 PerformMappingDisplay2(
692 IN CONST BOOLEAN Verbose,
693 IN CONST BOOLEAN Consist,
694 IN CONST BOOLEAN Normal,
695 IN CONST CHAR16 *TypeString,
696 IN CONST BOOLEAN SFO,
697 IN CONST CHAR16 *Specific OPTIONAL
698 )
699 {
700 CONST CHAR16 *TypeWalker;
701 SHELL_STATUS ShellStatus;
702 CHAR16 *Comma;
703
704
705 if (TypeString == NULL) {
706 return (PerformMappingDisplay(Verbose, Consist, Normal, NULL, SFO, Specific, TRUE));
707 }
708 ShellStatus = SHELL_SUCCESS;
709 for (TypeWalker = TypeString ; TypeWalker != NULL && *TypeWalker != CHAR_NULL ;) {
710 Comma = StrStr(TypeWalker, L",");
711 if (Comma == NULL) {
712 if (ShellStatus == SHELL_SUCCESS) {
713 ShellStatus = PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
714 } else {
715 PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
716 }
717 break;
718 } else {
719 *Comma = CHAR_NULL;
720 if (ShellStatus == SHELL_SUCCESS) {
721 ShellStatus = PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
722 } else {
723 PerformMappingDisplay(Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
724 }
725 *Comma = L',';
726 TypeWalker = Comma + 1;
727 }
728 }
729
730 return (ShellStatus);
731 }
732
733 /**
734 Delete a specific map.
735
736 @param[in] Specific The pointer to the name of the map to delete.
737
738 @retval EFI_INVALID_PARAMETER Specific was NULL.
739 @retval EFI_SUCCESS The operation was successful.
740 @retval EFI_NOT_FOUND Specific could not be found.
741 **/
742 EFI_STATUS
743 PerformMappingDelete(
744 IN CONST CHAR16 *Specific
745 )
746 {
747 EFI_STATUS Status;
748 EFI_HANDLE *HandleBuffer;
749 UINTN BufferSize;
750 UINTN LoopVar;
751 BOOLEAN Deleted;
752
753 if (Specific == NULL) {
754 return (EFI_INVALID_PARAMETER);
755 }
756
757 BufferSize = 0;
758 HandleBuffer = NULL;
759 Deleted = FALSE;
760
761 //
762 // Look up all SimpleFileSystems in the platform
763 //
764 Status = gBS->LocateHandle(
765 ByProtocol,
766 &gEfiDevicePathProtocolGuid,
767 NULL,
768 &BufferSize,
769 HandleBuffer);
770 if (Status == EFI_BUFFER_TOO_SMALL) {
771 HandleBuffer = AllocateZeroPool(BufferSize);
772 if (HandleBuffer == NULL) {
773 return (EFI_OUT_OF_RESOURCES);
774 }
775 Status = gBS->LocateHandle(
776 ByProtocol,
777 &gEfiDevicePathProtocolGuid,
778 NULL,
779 &BufferSize,
780 HandleBuffer);
781 }
782 if (EFI_ERROR(Status)) {
783 SHELL_FREE_NON_NULL(HandleBuffer);
784 return (Status);
785 }
786
787 if (HandleBuffer != NULL) {
788 //
789 // Get the map name(s) for each one.
790 //
791 for ( LoopVar = 0
792 ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
793 ; LoopVar ++
794 ){
795 if (PerformSingleMappingDelete(Specific,HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
796 Deleted = TRUE;
797 }
798 }
799 }
800 //
801 // Look up all BlockIo in the platform
802 //
803 Status = gBS->LocateHandle(
804 ByProtocol,
805 &gEfiBlockIoProtocolGuid,
806 NULL,
807 &BufferSize,
808 HandleBuffer);
809 if (Status == EFI_BUFFER_TOO_SMALL) {
810 FreePool(HandleBuffer);
811 HandleBuffer = AllocateZeroPool(BufferSize);
812 if (HandleBuffer == NULL) {
813 return (EFI_OUT_OF_RESOURCES);
814 }
815 Status = gBS->LocateHandle(
816 ByProtocol,
817 &gEfiBlockIoProtocolGuid,
818 NULL,
819 &BufferSize,
820 HandleBuffer);
821 }
822 if (EFI_ERROR(Status)) {
823 SHELL_FREE_NON_NULL(HandleBuffer);
824 return (Status);
825 }
826
827 if (HandleBuffer != NULL) {
828 //
829 // Get the map name(s) for each one.
830 //
831 for ( LoopVar = 0
832 ; LoopVar < BufferSize / sizeof(EFI_HANDLE)
833 ; LoopVar ++
834 ){
835 //
836 // Skip any that were already done...
837 //
838 if (gBS->OpenProtocol(
839 HandleBuffer[LoopVar],
840 &gEfiDevicePathProtocolGuid,
841 NULL,
842 gImageHandle,
843 NULL,
844 EFI_OPEN_PROTOCOL_TEST_PROTOCOL) == EFI_SUCCESS) {
845 continue;
846 }
847 if (PerformSingleMappingDelete(Specific,HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
848 Deleted = TRUE;
849 }
850 }
851 }
852 SHELL_FREE_NON_NULL(HandleBuffer);
853 if (!Deleted) {
854 return (EFI_NOT_FOUND);
855 }
856 return (EFI_SUCCESS);
857 }
858
859 /**
860 function to add a mapping from mapping.
861
862 This function will get the device path associated with the mapping and call SetMap.
863
864 @param[in] Map The Map to add a mapping for
865 @param[in] SName The name of the new mapping
866
867 @retval SHELL_SUCCESS the mapping was added
868 @retval SHELL_INVALID_PARAMETER the device path for Map could not be retrieved.
869 @return Shell version of a return value from EfiShellProtocol->SetMap
870
871 **/
872 SHELL_STATUS
873 AddMappingFromMapping(
874 IN CONST CHAR16 *Map,
875 IN CONST CHAR16 *SName
876 )
877 {
878 CONST EFI_DEVICE_PATH_PROTOCOL *DevPath;
879 EFI_STATUS Status;
880 CHAR16 *NewSName;
881 RETURN_STATUS StrRetStatus;
882
883 NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
884 if (NewSName == NULL) {
885 return (SHELL_OUT_OF_RESOURCES);
886 }
887 if (NewSName[StrLen(NewSName)-1] != L':') {
888 StrRetStatus = StrnCatS(NewSName, (StrSize(SName) + sizeof(CHAR16))/sizeof(CHAR16), L":", StrLen(L":"));
889 if (EFI_ERROR(StrRetStatus)) {
890 FreePool(NewSName);
891 return ((SHELL_STATUS) (StrRetStatus & (~MAX_BIT)));
892 }
893 }
894
895 if (!IsNumberLetterOnly(NewSName, StrLen(NewSName)-1)) {
896 FreePool(NewSName);
897 return (SHELL_INVALID_PARAMETER);
898 }
899
900 DevPath = gEfiShellProtocol->GetDevicePathFromMap(Map);
901 if (DevPath == NULL) {
902 FreePool(NewSName);
903 return (SHELL_INVALID_PARAMETER);
904 }
905
906 Status = gEfiShellProtocol->SetMap(DevPath, NewSName);
907 FreePool(NewSName);
908 if (EFI_ERROR(Status)) {
909 return (SHELL_DEVICE_ERROR);
910 }
911 return (SHELL_SUCCESS);
912 }
913
914 /**
915 function to add a mapping from an EFI_HANDLE.
916
917 This function will get the device path associated with the Handle and call SetMap.
918
919 @param[in] Handle The handle to add a mapping for
920 @param[in] SName The name of the new mapping
921
922 @retval SHELL_SUCCESS the mapping was added
923 @retval SHELL_INVALID_PARAMETER SName was not valid for a map name.
924 @return Shell version of a return value from either
925 gBS->OpenProtocol or EfiShellProtocol->SetMap
926
927 **/
928 SHELL_STATUS
929 AddMappingFromHandle(
930 IN CONST EFI_HANDLE Handle,
931 IN CONST CHAR16 *SName
932 )
933 {
934 EFI_DEVICE_PATH_PROTOCOL *DevPath;
935 EFI_STATUS Status;
936 CHAR16 *NewSName;
937 RETURN_STATUS StrRetStatus;
938
939 NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
940 if (NewSName == NULL) {
941 return (SHELL_OUT_OF_RESOURCES);
942 }
943 if (NewSName[StrLen(NewSName)-1] != L':') {
944 StrRetStatus = StrnCatS(NewSName, (StrSize(SName) + sizeof(CHAR16))/sizeof(CHAR16), L":", StrLen(L":"));
945 if (EFI_ERROR(StrRetStatus)) {
946 FreePool(NewSName);
947 return ((SHELL_STATUS) (StrRetStatus & (~MAX_BIT)));
948 }
949 }
950
951 if (!IsNumberLetterOnly(NewSName, StrLen(NewSName)-1)) {
952 FreePool(NewSName);
953 return (SHELL_INVALID_PARAMETER);
954 }
955
956 Status = gBS->OpenProtocol(
957 Handle,
958 &gEfiDevicePathProtocolGuid,
959 (VOID**)&DevPath,
960 gImageHandle,
961 NULL,
962 EFI_OPEN_PROTOCOL_GET_PROTOCOL
963 );
964 if (EFI_ERROR(Status)) {
965 FreePool(NewSName);
966 return (SHELL_DEVICE_ERROR);
967 }
968 Status = gEfiShellProtocol->SetMap(DevPath, NewSName);
969 FreePool(NewSName);
970 if (EFI_ERROR(Status)) {
971 return (SHELL_DEVICE_ERROR);
972 }
973 return (SHELL_SUCCESS);
974 }
975
976 STATIC CONST SHELL_PARAM_ITEM MapParamList[] = {
977 {L"-d", TypeValue},
978 {L"-r", TypeFlag},
979 {L"-v", TypeFlag},
980 {L"-c", TypeFlag},
981 {L"-f", TypeFlag},
982 {L"-u", TypeFlag},
983 {L"-t", TypeValue},
984 {L"-sfo", TypeValue},
985 {NULL, TypeMax}
986 };
987
988 /**
989 The routine issues dummy read for every physical block device to cause
990 the BlockIo re-installed if media change happened.
991 **/
992 VOID
993 ProbeForMediaChange (
994 VOID
995 )
996 {
997 EFI_STATUS Status;
998 UINTN HandleCount;
999 EFI_HANDLE *Handles;
1000 EFI_BLOCK_IO_PROTOCOL *BlockIo;
1001 UINTN Index;
1002
1003 gBS->LocateHandleBuffer (
1004 ByProtocol,
1005 &gEfiBlockIoProtocolGuid,
1006 NULL,
1007 &HandleCount,
1008 &Handles
1009 );
1010 //
1011 // Probe for media change for every physical block io
1012 //
1013 for (Index = 0; Index < HandleCount; Index++) {
1014 Status = gBS->HandleProtocol (
1015 Handles[Index],
1016 &gEfiBlockIoProtocolGuid,
1017 (VOID **) &BlockIo
1018 );
1019 if (!EFI_ERROR (Status)) {
1020 if (!BlockIo->Media->LogicalPartition) {
1021 //
1022 // Per spec:
1023 // The function (ReadBlocks) must return EFI_NO_MEDIA or
1024 // EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1025 // for changes in media state.
1026 //
1027 BlockIo->ReadBlocks (
1028 BlockIo,
1029 BlockIo->Media->MediaId,
1030 0,
1031 0,
1032 NULL
1033 );
1034 }
1035 }
1036 }
1037 }
1038
1039 /**
1040 Function for 'map' command.
1041
1042 @param[in] ImageHandle Handle to the Image (NULL if Internal).
1043 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
1044 **/
1045 SHELL_STATUS
1046 EFIAPI
1047 ShellCommandRunMap (
1048 IN EFI_HANDLE ImageHandle,
1049 IN EFI_SYSTEM_TABLE *SystemTable
1050 )
1051 {
1052 EFI_STATUS Status;
1053 LIST_ENTRY *Package;
1054 CHAR16 *ProblemParam;
1055 CONST CHAR16 *SName;
1056 CONST CHAR16 *Mapping;
1057 EFI_HANDLE MapAsHandle;
1058 SHELL_STATUS ShellStatus;
1059 BOOLEAN SfoMode;
1060 BOOLEAN ConstMode;
1061 BOOLEAN NormlMode;
1062 CONST CHAR16 *Param1;
1063 CONST CHAR16 *TypeString;
1064 UINTN TempStringLength;
1065
1066 ProblemParam = NULL;
1067 Mapping = NULL;
1068 SName = NULL;
1069 ShellStatus = SHELL_SUCCESS;
1070 MapAsHandle = NULL;
1071
1072 //
1073 // initialize the shell lib (we must be in non-auto-init...)
1074 //
1075 Status = ShellInitialize();
1076 ASSERT_EFI_ERROR(Status);
1077
1078 Status = CommandInit();
1079 ASSERT_EFI_ERROR(Status);
1080
1081 //
1082 // parse the command line
1083 //
1084 Status = ShellCommandLineParse (MapParamList, &Package, &ProblemParam, TRUE);
1085 if (EFI_ERROR(Status)) {
1086 if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
1087 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"map", ProblemParam);
1088 FreePool(ProblemParam);
1089 ShellStatus = SHELL_INVALID_PARAMETER;
1090 } else {
1091 ASSERT(FALSE);
1092 }
1093 } else {
1094 //
1095 // check for "-?"
1096 //
1097 SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
1098 ConstMode = ShellCommandLineGetFlag(Package, L"-c");
1099 NormlMode = ShellCommandLineGetFlag(Package, L"-f");
1100 if (ShellCommandLineGetFlag(Package, L"-?")) {
1101 ASSERT(FALSE);
1102 } else if (ShellCommandLineGetRawValue(Package, 3) != NULL) {
1103 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"map");
1104 ShellStatus = SHELL_INVALID_PARAMETER;
1105 } else {
1106 //
1107 // Deleting a map name...
1108 //
1109 if (ShellCommandLineGetFlag(Package, L"-d")) {
1110 if ( ShellCommandLineGetFlag(Package, L"-r")
1111 || ShellCommandLineGetFlag(Package, L"-v")
1112 || ConstMode
1113 || NormlMode
1114 || ShellCommandLineGetFlag(Package, L"-u")
1115 || ShellCommandLineGetFlag(Package, L"-t")
1116 ){
1117 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CON), gShellLevel2HiiHandle, L"map");
1118 ShellStatus = SHELL_INVALID_PARAMETER;
1119 } else {
1120 SName = ShellCommandLineGetValue(Package, L"-d");
1121 if (SName != NULL) {
1122 Status = PerformMappingDelete(SName);
1123 if (EFI_ERROR(Status)) {
1124 if (Status == EFI_ACCESS_DENIED) {
1125 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1126 ShellStatus = SHELL_ACCESS_DENIED;
1127 } else if (Status == EFI_NOT_FOUND) {
1128 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", SName);
1129 ShellStatus = SHELL_INVALID_PARAMETER;
1130 } else {
1131 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1132 ShellStatus = SHELL_UNSUPPORTED;
1133 }
1134 }
1135 } else {
1136 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
1137 ShellStatus = SHELL_INVALID_PARAMETER;
1138 }
1139 }
1140 } else if ( ShellCommandLineGetFlag(Package, L"-r")
1141 // || ShellCommandLineGetFlag(Package, L"-v")
1142 || ConstMode
1143 || NormlMode
1144 || ShellCommandLineGetFlag(Package, L"-u")
1145 || ShellCommandLineGetFlag(Package, L"-t")
1146 ){
1147 ProbeForMediaChange ();
1148 if ( ShellCommandLineGetFlag(Package, L"-r")) {
1149 //
1150 // Do the reset
1151 //
1152 Status = ShellCommandCreateInitialMappingsAndPaths();
1153 if (EFI_ERROR(Status)) {
1154 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1155 ShellStatus = SHELL_UNSUPPORTED;
1156 }
1157 }
1158 if ( ShellStatus == SHELL_SUCCESS && ShellCommandLineGetFlag(Package, L"-u")) {
1159 //
1160 // Do the Update
1161 //
1162 Status = ShellCommandUpdateMapping ();
1163 if (EFI_ERROR(Status)) {
1164 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1165 ShellStatus = SHELL_UNSUPPORTED;
1166 }
1167 }
1168 if (ShellStatus == SHELL_SUCCESS) {
1169 Param1 = ShellCommandLineGetRawValue(Package, 1);
1170 TypeString = ShellCommandLineGetValue(Package, L"-t");
1171 if (!ConstMode
1172 &&!NormlMode
1173 &&TypeString == NULL
1174 ) {
1175 //
1176 // now do the display...
1177 //
1178 ShellStatus = PerformMappingDisplay(
1179 ShellCommandLineGetFlag(Package, L"-v"),
1180 TRUE,
1181 TRUE,
1182 NULL,
1183 SfoMode,
1184 Param1,
1185 TRUE
1186 );
1187 } else {
1188 //
1189 // now do the display...
1190 //
1191 ShellStatus = PerformMappingDisplay2(
1192 ShellCommandLineGetFlag(Package, L"-v"),
1193 ConstMode,
1194 NormlMode,
1195 TypeString,
1196 SfoMode,
1197 Param1
1198 );
1199 }
1200 }
1201 } else {
1202 //
1203 // adding or displaying (there were no flags)
1204 //
1205 SName = ShellCommandLineGetRawValue(Package, 1);
1206 Mapping = ShellCommandLineGetRawValue(Package, 2);
1207 if ( SName == NULL
1208 && Mapping == NULL
1209 ){
1210 //
1211 // display only since no flags
1212 //
1213 ShellStatus = PerformMappingDisplay(
1214 ShellCommandLineGetFlag(Package, L"-v"),
1215 TRUE,
1216 TRUE,
1217 NULL,
1218 SfoMode,
1219 NULL,
1220 TRUE
1221 );
1222 } else if ( SName == NULL
1223 || Mapping == NULL
1224 ){
1225 //
1226 // Display only the one specified
1227 //
1228 ShellStatus = PerformMappingDisplay(
1229 FALSE,
1230 FALSE,
1231 FALSE,
1232 NULL,
1233 SfoMode,
1234 SName, // note the variable here...
1235 TRUE
1236 );
1237 } else {
1238 if (ShellIsHexOrDecimalNumber(Mapping, TRUE, FALSE)) {
1239 MapAsHandle = ConvertHandleIndexToHandle(ShellStrToUintn(Mapping));
1240 } else {
1241 MapAsHandle = NULL;
1242 }
1243 if (MapAsHandle == NULL && Mapping[StrLen(Mapping)-1] != L':') {
1244 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1245 ShellStatus = SHELL_INVALID_PARAMETER;
1246 } else {
1247 TempStringLength = StrLen(SName);
1248 if (!IsNumberLetterOnly(SName, TempStringLength-(SName[TempStringLength-1]==L':'?1:0))) {
1249 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", SName);
1250 ShellStatus = SHELL_INVALID_PARAMETER;
1251 }
1252
1253 if (ShellStatus == SHELL_SUCCESS) {
1254 if (MapAsHandle != NULL) {
1255 ShellStatus = AddMappingFromHandle(MapAsHandle, SName);
1256 } else {
1257 ShellStatus = AddMappingFromMapping(Mapping, SName);
1258 }
1259
1260 if (ShellStatus != SHELL_SUCCESS) {
1261 switch (ShellStatus) {
1262 case SHELL_ACCESS_DENIED:
1263 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1264 break;
1265 case SHELL_INVALID_PARAMETER:
1266 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1267 break;
1268 case SHELL_DEVICE_ERROR:
1269 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NOF), gShellLevel2HiiHandle, L"map", Mapping);
1270 break;
1271 default:
1272 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", ShellStatus|MAX_BIT);
1273 }
1274 } else {
1275 //
1276 // now do the display...
1277 //
1278 ShellStatus = PerformMappingDisplay(
1279 FALSE,
1280 FALSE,
1281 FALSE,
1282 NULL,
1283 SfoMode,
1284 SName,
1285 TRUE
1286 );
1287 } // we were sucessful so do an output
1288 }
1289 } // got a valid map target
1290 } // got 2 variables
1291 } // we are adding a mapping
1292 } // got valid parameters
1293 }
1294
1295 //
1296 // free the command line package
1297 //
1298 ShellCommandLineFreeVarList (Package);
1299
1300 return (ShellStatus);
1301 }
1302