5e34b8dad17b87c4529b01dfa996ba2b90b9dc12
[mirror_edk2.git] / ShellPkg / Application / Shell / ShellProtocol.c
1 /** @file
2 Member functions of EFI_SHELL_PROTOCOL and functions for creation,
3 manipulation, and initialization of EFI_SHELL_PROTOCOL.
4
5 (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
6 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
7 Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
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 "Shell.h"
19
20 #define INIT_NAME_BUFFER_SIZE 128
21
22 /**
23 Close an open file handle.
24
25 This function closes a specified file handle. All "dirty" cached file data is
26 flushed to the device, and the file is closed. In all cases the handle is
27 closed.
28
29 @param[in] FileHandle The file handle to close.
30
31 @retval EFI_SUCCESS The file handle was closed successfully.
32 **/
33 EFI_STATUS
34 EFIAPI
35 EfiShellClose (
36 IN SHELL_FILE_HANDLE FileHandle
37 )
38 {
39 ShellFileHandleRemove(FileHandle);
40 return (FileHandleClose(ConvertShellHandleToEfiFileProtocol(FileHandle)));
41 }
42
43 /**
44 Internal worker to determine whether there is a BlockIo somewhere
45 upon the device path specified.
46
47 @param[in] DevicePath The device path to test.
48
49 @retval TRUE gEfiBlockIoProtocolGuid was installed on a handle with this device path
50 @retval FALSE gEfiBlockIoProtocolGuid was not found.
51 **/
52 BOOLEAN
53 InternalShellProtocolIsBlockIoPresent(
54 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
55 )
56 {
57 EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
58 EFI_STATUS Status;
59 EFI_HANDLE Handle;
60
61 Handle = NULL;
62
63 DevicePathCopy = (EFI_DEVICE_PATH_PROTOCOL*)DevicePath;
64 Status = gBS->LocateDevicePath(&gEfiBlockIoProtocolGuid, &DevicePathCopy, &Handle);
65
66 if ((Handle != NULL) && (!EFI_ERROR(Status))) {
67 return (TRUE);
68 }
69 return (FALSE);
70 }
71
72 /**
73 Internal worker to determine whether there is a file system somewhere
74 upon the device path specified.
75
76 @param[in] DevicePath The device path to test.
77
78 @retval TRUE gEfiSimpleFileSystemProtocolGuid was installed on a handle with this device path
79 @retval FALSE gEfiSimpleFileSystemProtocolGuid was not found.
80 **/
81 BOOLEAN
82 InternalShellProtocolIsSimpleFileSystemPresent(
83 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
84 )
85 {
86 EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
87 EFI_STATUS Status;
88 EFI_HANDLE Handle;
89
90 Handle = NULL;
91
92 DevicePathCopy = (EFI_DEVICE_PATH_PROTOCOL*)DevicePath;
93 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &Handle);
94
95 if ((Handle != NULL) && (!EFI_ERROR(Status))) {
96 return (TRUE);
97 }
98 return (FALSE);
99 }
100
101 /**
102 Internal worker debug helper function to print out maps as they are added.
103
104 @param[in] Mapping string mapping that has been added
105 @param[in] DevicePath pointer to device path that has been mapped.
106
107 @retval EFI_SUCCESS the operation was successful.
108 @return other an error ocurred
109
110 @sa LocateHandle
111 @sa OpenProtocol
112 **/
113 EFI_STATUS
114 InternalShellProtocolDebugPrintMessage (
115 IN CONST CHAR16 *Mapping,
116 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath
117 )
118 {
119 EFI_STATUS Status;
120 CHAR16 *Temp;
121
122 Status = EFI_SUCCESS;
123 DEBUG_CODE_BEGIN();
124
125 if (Mapping != NULL) {
126 DEBUG((EFI_D_INFO, "Added new map item:\"%S\"\r\n", Mapping));
127 }
128 Temp = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
129 DEBUG((EFI_D_INFO, "DevicePath: %S\r\n", Temp));
130 FreePool(Temp);
131
132 DEBUG_CODE_END();
133 return (Status);
134 }
135
136 /**
137 This function creates a mapping for a device path.
138
139 If both DeviecPath and Mapping are NULL, this will reset the mapping to default values.
140
141 @param DevicePath Points to the device path. If this is NULL and Mapping points to a valid mapping,
142 then the mapping will be deleted.
143 @param Mapping Points to the NULL-terminated mapping for the device path. Must end with a ':'
144
145 @retval EFI_SUCCESS Mapping created or deleted successfully.
146 @retval EFI_NO_MAPPING There is no handle that corresponds exactly to DevicePath. See the
147 boot service function LocateDevicePath().
148 @retval EFI_ACCESS_DENIED The mapping is a built-in alias.
149 @retval EFI_INVALID_PARAMETER Mapping was NULL
150 @retval EFI_INVALID_PARAMETER Mapping did not end with a ':'
151 @retval EFI_INVALID_PARAMETER DevicePath was not pointing at a device that had a SIMPLE_FILE_SYSTEM_PROTOCOL installed.
152 @retval EFI_NOT_FOUND There was no mapping found to delete
153 @retval EFI_OUT_OF_RESOURCES Memory allocation failed
154 **/
155 EFI_STATUS
156 EFIAPI
157 EfiShellSetMap(
158 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath OPTIONAL,
159 IN CONST CHAR16 *Mapping
160 )
161 {
162 EFI_STATUS Status;
163 SHELL_MAP_LIST *MapListNode;
164
165 if (Mapping == NULL){
166 return (EFI_INVALID_PARAMETER);
167 }
168
169 if (Mapping[StrLen(Mapping)-1] != ':') {
170 return (EFI_INVALID_PARAMETER);
171 }
172
173 //
174 // Delete the mapping
175 //
176 if (DevicePath == NULL) {
177 if (IsListEmpty(&gShellMapList.Link)) {
178 return (EFI_NOT_FOUND);
179 }
180 for ( MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
181 ; !IsNull(&gShellMapList.Link, &MapListNode->Link)
182 ; MapListNode = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &MapListNode->Link)
183 ){
184 if (StringNoCaseCompare(&MapListNode->MapName, &Mapping) == 0) {
185 RemoveEntryList(&MapListNode->Link);
186 SHELL_FREE_NON_NULL(MapListNode->DevicePath);
187 SHELL_FREE_NON_NULL(MapListNode->MapName);
188 SHELL_FREE_NON_NULL(MapListNode->CurrentDirectoryPath);
189 FreePool(MapListNode);
190 return (EFI_SUCCESS);
191 }
192 } // for loop
193
194 //
195 // We didnt find one to delete
196 //
197 return (EFI_NOT_FOUND);
198 }
199
200 //
201 // make sure this is a valid to add device path
202 //
203 ///@todo add BlockIo to this test...
204 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath)
205 && !InternalShellProtocolIsBlockIoPresent(DevicePath)) {
206 return (EFI_INVALID_PARAMETER);
207 }
208
209 //
210 // First make sure there is no old mapping
211 //
212 Status = EfiShellSetMap(NULL, Mapping);
213 if ((Status != EFI_SUCCESS) && (Status != EFI_NOT_FOUND)) {
214 return (Status);
215 }
216
217 //
218 // now add the new one.
219 //
220 Status = ShellCommandAddMapItemAndUpdatePath(Mapping, DevicePath, 0, FALSE);
221
222 return(Status);
223 }
224
225 /**
226 Gets the device path from the mapping.
227
228 This function gets the device path associated with a mapping.
229
230 @param Mapping A pointer to the mapping
231
232 @retval !=NULL Pointer to the device path that corresponds to the
233 device mapping. The returned pointer does not need
234 to be freed.
235 @retval NULL There is no device path associated with the
236 specified mapping.
237 **/
238 CONST EFI_DEVICE_PATH_PROTOCOL *
239 EFIAPI
240 EfiShellGetDevicePathFromMap(
241 IN CONST CHAR16 *Mapping
242 )
243 {
244 SHELL_MAP_LIST *MapListItem;
245 CHAR16 *NewName;
246 UINTN Size;
247
248 NewName = NULL;
249 Size = 0;
250
251 StrnCatGrow(&NewName, &Size, Mapping, 0);
252 if (Mapping[StrLen(Mapping)-1] != L':') {
253 StrnCatGrow(&NewName, &Size, L":", 0);
254 }
255
256 MapListItem = ShellCommandFindMapItem(NewName);
257
258 FreePool(NewName);
259
260 if (MapListItem != NULL) {
261 return (MapListItem->DevicePath);
262 }
263 return(NULL);
264 }
265
266 /**
267 Gets the mapping(s) that most closely matches the device path.
268
269 This function gets the mapping which corresponds to the device path *DevicePath. If
270 there is no exact match, then the mapping which most closely matches *DevicePath
271 is returned, and *DevicePath is updated to point to the remaining portion of the
272 device path. If there is an exact match, the mapping is returned and *DevicePath
273 points to the end-of-device-path node.
274
275 If there are multiple map names they will be semi-colon seperated in the
276 NULL-terminated string.
277
278 @param DevicePath On entry, points to a device path pointer. On
279 exit, updates the pointer to point to the
280 portion of the device path after the mapping.
281
282 @retval NULL No mapping was found.
283 @return !=NULL Pointer to NULL-terminated mapping. The buffer
284 is callee allocated and should be freed by the caller.
285 **/
286 CONST CHAR16 *
287 EFIAPI
288 EfiShellGetMapFromDevicePath(
289 IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
290 )
291 {
292 SHELL_MAP_LIST *Node;
293 CHAR16 *PathForReturn;
294 UINTN PathSize;
295 // EFI_HANDLE PathHandle;
296 // EFI_HANDLE MapHandle;
297 // EFI_STATUS Status;
298 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
299 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
300
301 if (DevicePath == NULL || *DevicePath == NULL) {
302 return (NULL);
303 }
304
305 PathForReturn = NULL;
306 PathSize = 0;
307
308 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
309 ; !IsNull(&gShellMapList.Link, &Node->Link)
310 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
311 ){
312 //
313 // check for exact match
314 //
315 if (DevicePathCompare(DevicePath, &Node->DevicePath) == 0) {
316 ASSERT((PathForReturn == NULL && PathSize == 0) || (PathForReturn != NULL));
317 if (PathSize != 0) {
318 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
319 }
320 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
321 }
322 }
323 if (PathForReturn != NULL) {
324 while (!IsDevicePathEndType (*DevicePath)) {
325 *DevicePath = NextDevicePathNode (*DevicePath);
326 }
327 SetDevicePathEndNode (*DevicePath);
328 }
329 /*
330 ///@todo finish code for inexact matches.
331 if (PathForReturn == NULL) {
332 PathSize = 0;
333
334 DevicePathCopy = DuplicateDevicePath(*DevicePath);
335 ASSERT(DevicePathCopy != NULL);
336 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
337 ASSERT_EFI_ERROR(Status);
338 //
339 // check each of the device paths we have to get the root of the path for consist mappings
340 //
341 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
342 ; !IsNull(&gShellMapList.Link, &Node->Link)
343 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
344 ){
345 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
346 continue;
347 }
348 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
349 ASSERT(MapPathCopy != NULL);
350 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
351 if (MapHandle == PathHandle) {
352
353 *DevicePath = DevicePathCopy;
354
355 MapPathCopy = NULL;
356 DevicePathCopy = NULL;
357 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
358 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
359 break;
360 }
361 }
362 //
363 // now add on the non-consistent mappings
364 //
365 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
366 ; !IsNull(&gShellMapList.Link, &Node->Link)
367 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
368 ){
369 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
370 continue;
371 }
372 MapPathCopy = Node->DevicePath;
373 ASSERT(MapPathCopy != NULL);
374 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
375 if (MapHandle == PathHandle) {
376 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
377 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
378 break;
379 }
380 }
381 }
382 */
383
384 return (AddBufferToFreeList(PathForReturn));
385 }
386
387 /**
388 Converts a device path to a file system-style path.
389
390 This function converts a device path to a file system path by replacing part, or all, of
391 the device path with the file-system mapping. If there are more than one application
392 file system mappings, the one that most closely matches Path will be used.
393
394 @param Path The pointer to the device path
395
396 @retval NULL the device path could not be found.
397 @return all The pointer of the NULL-terminated file path. The path
398 is callee-allocated and should be freed by the caller.
399 **/
400 CHAR16 *
401 EFIAPI
402 EfiShellGetFilePathFromDevicePath(
403 IN CONST EFI_DEVICE_PATH_PROTOCOL *Path
404 )
405 {
406 EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
407 EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
408 SHELL_MAP_LIST *MapListItem;
409 CHAR16 *PathForReturn;
410 UINTN PathSize;
411 EFI_HANDLE PathHandle;
412 EFI_HANDLE MapHandle;
413 EFI_STATUS Status;
414 FILEPATH_DEVICE_PATH *FilePath;
415 FILEPATH_DEVICE_PATH *AlignedNode;
416
417 PathForReturn = NULL;
418 PathSize = 0;
419
420 DevicePathCopy = (EFI_DEVICE_PATH_PROTOCOL*)Path;
421 ASSERT(DevicePathCopy != NULL);
422 if (DevicePathCopy == NULL) {
423 return (NULL);
424 }
425 ///@todo BlockIo?
426 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
427
428 if (EFI_ERROR(Status)) {
429 return (NULL);
430 }
431 //
432 // check each of the device paths we have to get the root of the path
433 //
434 for ( MapListItem = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
435 ; !IsNull(&gShellMapList.Link, &MapListItem->Link)
436 ; MapListItem = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &MapListItem->Link)
437 ){
438 MapPathCopy = (EFI_DEVICE_PATH_PROTOCOL*)MapListItem->DevicePath;
439 ASSERT(MapPathCopy != NULL);
440 ///@todo BlockIo?
441 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
442 if (MapHandle == PathHandle) {
443 ASSERT((PathForReturn == NULL && PathSize == 0) || (PathForReturn != NULL));
444 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, MapListItem->MapName, 0);
445 //
446 // go through all the remaining nodes in the device path
447 //
448 for ( FilePath = (FILEPATH_DEVICE_PATH*)DevicePathCopy
449 ; !IsDevicePathEnd (&FilePath->Header)
450 ; FilePath = (FILEPATH_DEVICE_PATH*)NextDevicePathNode (&FilePath->Header)
451 ){
452 //
453 // If any node is not a file path node, then the conversion can not be completed
454 //
455 if ((DevicePathType(&FilePath->Header) != MEDIA_DEVICE_PATH) ||
456 (DevicePathSubType(&FilePath->Header) != MEDIA_FILEPATH_DP)) {
457 FreePool(PathForReturn);
458 return NULL;
459 }
460
461 //
462 // append the path part onto the filepath.
463 //
464 ASSERT((PathForReturn == NULL && PathSize == 0) || (PathForReturn != NULL));
465
466 AlignedNode = AllocateCopyPool (DevicePathNodeLength(FilePath), FilePath);
467 if (AlignedNode == NULL) {
468 FreePool (PathForReturn);
469 return NULL;
470 }
471
472 // File Path Device Path Nodes 'can optionally add a "\" separator to
473 // the beginning and/or the end of the Path Name string.'
474 // (UEFI Spec 2.4 section 9.3.6.4).
475 // If necessary, add a "\", but otherwise don't
476 // (This is specified in the above section, and also implied by the
477 // UEFI Shell spec section 3.7)
478 if ((PathSize != 0) &&
479 (PathForReturn != NULL) &&
480 (PathForReturn[PathSize / sizeof (CHAR16) - 1] != L'\\') &&
481 (AlignedNode->PathName[0] != L'\\')) {
482 PathForReturn = StrnCatGrow (&PathForReturn, &PathSize, L"\\", 1);
483 }
484
485 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, AlignedNode->PathName, 0);
486 FreePool(AlignedNode);
487 } // for loop of remaining nodes
488 }
489 if (PathForReturn != NULL) {
490 break;
491 }
492 } // for loop of paths to check
493 return(PathForReturn);
494 }
495
496 /**
497 Converts a file system style name to a device path.
498
499 This function converts a file system style name to a device path, by replacing any
500 mapping references to the associated device path.
501
502 @param[in] Path The pointer to the path.
503
504 @return The pointer of the file path. The file path is callee
505 allocated and should be freed by the caller.
506 @retval NULL The path could not be found.
507 @retval NULL There was not enough available memory.
508 **/
509 EFI_DEVICE_PATH_PROTOCOL *
510 EFIAPI
511 EfiShellGetDevicePathFromFilePath(
512 IN CONST CHAR16 *Path
513 )
514 {
515 CHAR16 *MapName;
516 CHAR16 *NewPath;
517 CONST CHAR16 *Cwd;
518 UINTN Size;
519 CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath;
520 EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
521 EFI_DEVICE_PATH_PROTOCOL *DevicePathCopyForFree;
522 EFI_DEVICE_PATH_PROTOCOL *DevicePathForReturn;
523 EFI_HANDLE Handle;
524 EFI_STATUS Status;
525
526 if (Path == NULL) {
527 return (NULL);
528 }
529
530 MapName = NULL;
531 NewPath = NULL;
532
533 if (StrStr(Path, L":") == NULL) {
534 Cwd = EfiShellGetCurDir(NULL);
535 if (Cwd == NULL) {
536 return (NULL);
537 }
538 Size = StrSize(Cwd) + StrSize(Path);
539 NewPath = AllocateZeroPool(Size);
540 if (NewPath == NULL) {
541 return (NULL);
542 }
543 StrCpyS(NewPath, Size/sizeof(CHAR16), Cwd);
544 StrCatS(NewPath, Size/sizeof(CHAR16), L"\\");
545 if (*Path == L'\\') {
546 Path++;
547 while (PathRemoveLastItem(NewPath)) ;
548 }
549 StrCatS(NewPath, Size/sizeof(CHAR16), Path);
550 DevicePathForReturn = EfiShellGetDevicePathFromFilePath(NewPath);
551 FreePool(NewPath);
552 return (DevicePathForReturn);
553 }
554
555 Size = 0;
556 //
557 // find the part before (but including) the : for the map name
558 //
559 ASSERT((MapName == NULL && Size == 0) || (MapName != NULL));
560 MapName = StrnCatGrow(&MapName, &Size, Path, (StrStr(Path, L":")-Path+1));
561 if (MapName == NULL || MapName[StrLen(MapName)-1] != L':') {
562 return (NULL);
563 }
564
565 //
566 // look up the device path in the map
567 //
568 DevicePath = EfiShellGetDevicePathFromMap(MapName);
569 if (DevicePath == NULL) {
570 //
571 // Must have been a bad Mapname
572 //
573 return (NULL);
574 }
575
576 //
577 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
578 //
579 DevicePathCopyForFree = DevicePathCopy = DuplicateDevicePath(DevicePath);
580 if (DevicePathCopy == NULL) {
581 FreePool(MapName);
582 return (NULL);
583 }
584
585 //
586 // get the handle
587 //
588 ///@todo BlockIo?
589 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &Handle);
590 if (EFI_ERROR(Status)) {
591 if (DevicePathCopyForFree != NULL) {
592 FreePool(DevicePathCopyForFree);
593 }
594 FreePool(MapName);
595 return (NULL);
596 }
597
598 //
599 // build the full device path
600 //
601 if ((*(Path+StrLen(MapName)) != CHAR_NULL) &&
602 (*(Path+StrLen(MapName)+1) == CHAR_NULL)) {
603 DevicePathForReturn = FileDevicePath(Handle, L"\\");
604 } else {
605 DevicePathForReturn = FileDevicePath(Handle, Path+StrLen(MapName));
606 }
607
608 FreePool(MapName);
609 if (DevicePathCopyForFree != NULL) {
610 FreePool(DevicePathCopyForFree);
611 }
612
613 return (DevicePathForReturn);
614 }
615
616 /**
617 Gets the name of the device specified by the device handle.
618
619 This function gets the user-readable name of the device specified by the device
620 handle. If no user-readable name could be generated, then *BestDeviceName will be
621 NULL and EFI_NOT_FOUND will be returned.
622
623 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
624 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
625 DeviceHandle.
626
627 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
628 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
629 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
630 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
631 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
632
633 @param DeviceHandle The handle of the device.
634 @param Flags Determines the possible sources of component names.
635 Valid bits are:
636 EFI_DEVICE_NAME_USE_COMPONENT_NAME
637 EFI_DEVICE_NAME_USE_DEVICE_PATH
638 @param Language A pointer to the language specified for the device
639 name, in the same format as described in the UEFI
640 specification, Appendix M
641 @param BestDeviceName On return, points to the callee-allocated NULL-
642 terminated name of the device. If no device name
643 could be found, points to NULL. The name must be
644 freed by the caller...
645
646 @retval EFI_SUCCESS Get the name successfully.
647 @retval EFI_NOT_FOUND Fail to get the device name.
648 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
649 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
650 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
651 **/
652 EFI_STATUS
653 EFIAPI
654 EfiShellGetDeviceName(
655 IN EFI_HANDLE DeviceHandle,
656 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags,
657 IN CHAR8 *Language,
658 OUT CHAR16 **BestDeviceName
659 )
660 {
661 EFI_STATUS Status;
662 EFI_COMPONENT_NAME2_PROTOCOL *CompName2;
663 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
664 EFI_HANDLE *HandleList;
665 UINTN HandleCount;
666 UINTN LoopVar;
667 CHAR16 *DeviceNameToReturn;
668 CHAR8 *Lang;
669 UINTN ParentControllerCount;
670 EFI_HANDLE *ParentControllerBuffer;
671 UINTN ParentDriverCount;
672 EFI_HANDLE *ParentDriverBuffer;
673
674 if (BestDeviceName == NULL ||
675 DeviceHandle == NULL
676 ){
677 return (EFI_INVALID_PARAMETER);
678 }
679
680 //
681 // make sure one of the 2 supported bits is on
682 //
683 if (((Flags & EFI_DEVICE_NAME_USE_COMPONENT_NAME) == 0) &&
684 ((Flags & EFI_DEVICE_NAME_USE_DEVICE_PATH) == 0)) {
685 return (EFI_INVALID_PARAMETER);
686 }
687
688 DeviceNameToReturn = NULL;
689 *BestDeviceName = NULL;
690 HandleList = NULL;
691 HandleCount = 0;
692 Lang = NULL;
693
694 if ((Flags & EFI_DEVICE_NAME_USE_COMPONENT_NAME) != 0) {
695 Status = ParseHandleDatabaseByRelationship(
696 NULL,
697 DeviceHandle,
698 HR_DRIVER_BINDING_HANDLE|HR_DEVICE_DRIVER,
699 &HandleCount,
700 &HandleList);
701 for (LoopVar = 0; LoopVar < HandleCount ; LoopVar++){
702 //
703 // Go through those handles until we get one that passes for GetComponentName
704 //
705 Status = gBS->OpenProtocol(
706 HandleList[LoopVar],
707 &gEfiComponentName2ProtocolGuid,
708 (VOID**)&CompName2,
709 gImageHandle,
710 NULL,
711 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
712 if (EFI_ERROR(Status)) {
713 Status = gBS->OpenProtocol(
714 HandleList[LoopVar],
715 &gEfiComponentNameProtocolGuid,
716 (VOID**)&CompName2,
717 gImageHandle,
718 NULL,
719 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
720 }
721
722 if (EFI_ERROR(Status)) {
723 continue;
724 }
725 Lang = GetBestLanguageForDriver(CompName2->SupportedLanguages, Language, FALSE);
726 Status = CompName2->GetControllerName(CompName2, DeviceHandle, NULL, Lang, &DeviceNameToReturn);
727 FreePool(Lang);
728 Lang = NULL;
729 if (!EFI_ERROR(Status) && DeviceNameToReturn != NULL) {
730 break;
731 }
732 }
733 if (HandleList != NULL) {
734 FreePool(HandleList);
735 }
736
737 //
738 // Now check the parent controller using this as the child.
739 //
740 if (DeviceNameToReturn == NULL){
741 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle, &ParentControllerCount, &ParentControllerBuffer);
742 for (LoopVar = 0 ; LoopVar < ParentControllerCount ; LoopVar++) {
743 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer[LoopVar], &ParentDriverCount, &ParentDriverBuffer);
744 for (HandleCount = 0 ; HandleCount < ParentDriverCount ; HandleCount++) {
745 //
746 // try using that driver's component name with controller and our driver as the child.
747 //
748 Status = gBS->OpenProtocol(
749 ParentDriverBuffer[HandleCount],
750 &gEfiComponentName2ProtocolGuid,
751 (VOID**)&CompName2,
752 gImageHandle,
753 NULL,
754 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
755 if (EFI_ERROR(Status)) {
756 Status = gBS->OpenProtocol(
757 ParentDriverBuffer[HandleCount],
758 &gEfiComponentNameProtocolGuid,
759 (VOID**)&CompName2,
760 gImageHandle,
761 NULL,
762 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
763 }
764
765 if (EFI_ERROR(Status)) {
766 continue;
767 }
768 Lang = GetBestLanguageForDriver(CompName2->SupportedLanguages, Language, FALSE);
769 Status = CompName2->GetControllerName(CompName2, ParentControllerBuffer[LoopVar], DeviceHandle, Lang, &DeviceNameToReturn);
770 FreePool(Lang);
771 Lang = NULL;
772 if (!EFI_ERROR(Status) && DeviceNameToReturn != NULL) {
773 break;
774 }
775
776
777
778 }
779 SHELL_FREE_NON_NULL(ParentDriverBuffer);
780 if (!EFI_ERROR(Status) && DeviceNameToReturn != NULL) {
781 break;
782 }
783 }
784 SHELL_FREE_NON_NULL(ParentControllerBuffer);
785 }
786 //
787 // dont return on fail since we will try device path if that bit is on
788 //
789 if (DeviceNameToReturn != NULL){
790 ASSERT(BestDeviceName != NULL);
791 StrnCatGrow(BestDeviceName, NULL, DeviceNameToReturn, 0);
792 return (EFI_SUCCESS);
793 }
794 }
795 if ((Flags & EFI_DEVICE_NAME_USE_DEVICE_PATH) != 0) {
796 Status = gBS->OpenProtocol(
797 DeviceHandle,
798 &gEfiDevicePathProtocolGuid,
799 (VOID**)&DevicePath,
800 gImageHandle,
801 NULL,
802 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
803 if (!EFI_ERROR(Status)) {
804 //
805 // use device path to text on the device path
806 //
807 *BestDeviceName = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
808 return (EFI_SUCCESS);
809 }
810 }
811 //
812 // none of the selected bits worked.
813 //
814 return (EFI_NOT_FOUND);
815 }
816
817 /**
818 Opens the root directory of a device on a handle
819
820 This function opens the root directory of a device and returns a file handle to it.
821
822 @param DeviceHandle The handle of the device that contains the volume.
823 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
824 device.
825
826 @retval EFI_SUCCESS Root opened successfully.
827 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
828 could not be opened.
829 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
830 @retval EFI_DEVICE_ERROR The device had an error
831 **/
832 EFI_STATUS
833 EFIAPI
834 EfiShellOpenRootByHandle(
835 IN EFI_HANDLE DeviceHandle,
836 OUT SHELL_FILE_HANDLE *FileHandle
837 )
838 {
839 EFI_STATUS Status;
840 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFileSystem;
841 EFI_FILE_PROTOCOL *RealFileHandle;
842 EFI_DEVICE_PATH_PROTOCOL *DevPath;
843
844 //
845 // get the simple file system interface
846 //
847 Status = gBS->OpenProtocol(DeviceHandle,
848 &gEfiSimpleFileSystemProtocolGuid,
849 (VOID**)&SimpleFileSystem,
850 gImageHandle,
851 NULL,
852 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
853 if (EFI_ERROR(Status)) {
854 return (EFI_NOT_FOUND);
855 }
856
857 Status = gBS->OpenProtocol(DeviceHandle,
858 &gEfiDevicePathProtocolGuid,
859 (VOID**)&DevPath,
860 gImageHandle,
861 NULL,
862 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
863 if (EFI_ERROR(Status)) {
864 return (EFI_NOT_FOUND);
865 }
866 //
867 // Open the root volume now...
868 //
869 Status = SimpleFileSystem->OpenVolume(SimpleFileSystem, &RealFileHandle);
870 *FileHandle = ConvertEfiFileProtocolToShellHandle(RealFileHandle, EfiShellGetMapFromDevicePath(&DevPath));
871 return (Status);
872 }
873
874 /**
875 Opens the root directory of a device.
876
877 This function opens the root directory of a device and returns a file handle to it.
878
879 @param DevicePath Points to the device path corresponding to the device where the
880 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
881 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
882 device.
883
884 @retval EFI_SUCCESS Root opened successfully.
885 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
886 could not be opened.
887 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
888 @retval EFI_DEVICE_ERROR The device had an error
889 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
890 **/
891 EFI_STATUS
892 EFIAPI
893 EfiShellOpenRoot(
894 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
895 OUT SHELL_FILE_HANDLE *FileHandle
896 )
897 {
898 EFI_STATUS Status;
899 EFI_HANDLE Handle;
900
901 if (FileHandle == NULL) {
902 return (EFI_INVALID_PARAMETER);
903 }
904
905 //
906 // find the handle of the device with that device handle and the file system
907 //
908 ///@todo BlockIo?
909 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid,
910 &DevicePath,
911 &Handle);
912 if (EFI_ERROR(Status)) {
913 return (EFI_NOT_FOUND);
914 }
915
916 return (EfiShellOpenRootByHandle(Handle, FileHandle));
917 }
918
919 /**
920 Returns whether any script files are currently being processed.
921
922 @retval TRUE There is at least one script file active.
923 @retval FALSE No script files are active now.
924
925 **/
926 BOOLEAN
927 EFIAPI
928 EfiShellBatchIsActive (
929 VOID
930 )
931 {
932 if (ShellCommandGetCurrentScriptFile() == NULL) {
933 return (FALSE);
934 }
935 return (TRUE);
936 }
937
938 /**
939 Worker function to open a file based on a device path. this will open the root
940 of the volume and then traverse down to the file itself.
941
942 @param DevicePath Device Path of the file.
943 @param FileHandle Pointer to the file upon a successful return.
944 @param OpenMode mode to open file in.
945 @param Attributes the File Attributes to use when creating a new file.
946
947 @retval EFI_SUCCESS the file is open and FileHandle is valid
948 @retval EFI_UNSUPPORTED the device path cotained non-path elements
949 @retval other an error ocurred.
950 **/
951 EFI_STATUS
952 InternalOpenFileDevicePath(
953 IN OUT EFI_DEVICE_PATH_PROTOCOL *DevicePath,
954 OUT SHELL_FILE_HANDLE *FileHandle,
955 IN UINT64 OpenMode,
956 IN UINT64 Attributes OPTIONAL
957 )
958 {
959 EFI_STATUS Status;
960 FILEPATH_DEVICE_PATH *FilePathNode;
961 EFI_HANDLE Handle;
962 SHELL_FILE_HANDLE ShellHandle;
963 EFI_FILE_PROTOCOL *Handle1;
964 EFI_FILE_PROTOCOL *Handle2;
965 FILEPATH_DEVICE_PATH *AlignedNode;
966
967 if (FileHandle == NULL) {
968 return (EFI_INVALID_PARAMETER);
969 }
970 *FileHandle = NULL;
971 Handle1 = NULL;
972 Handle2 = NULL;
973 Handle = NULL;
974 ShellHandle = NULL;
975 FilePathNode = NULL;
976 AlignedNode = NULL;
977
978 Status = EfiShellOpenRoot(DevicePath, &ShellHandle);
979
980 if (!EFI_ERROR(Status)) {
981 Handle1 = ConvertShellHandleToEfiFileProtocol(ShellHandle);
982 if (Handle1 != NULL) {
983 //
984 // chop off the begining part before the file system part...
985 //
986 ///@todo BlockIo?
987 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid,
988 &DevicePath,
989 &Handle);
990 if (!EFI_ERROR(Status)) {
991 //
992 // To access as a file system, the file path should only
993 // contain file path components. Follow the file path nodes
994 // and find the target file
995 //
996 for ( FilePathNode = (FILEPATH_DEVICE_PATH *)DevicePath
997 ; !IsDevicePathEnd (&FilePathNode->Header)
998 ; FilePathNode = (FILEPATH_DEVICE_PATH *) NextDevicePathNode (&FilePathNode->Header)
999 ){
1000 SHELL_FREE_NON_NULL(AlignedNode);
1001 AlignedNode = AllocateCopyPool (DevicePathNodeLength(FilePathNode), FilePathNode);
1002 //
1003 // For file system access each node should be a file path component
1004 //
1005 if (DevicePathType (&FilePathNode->Header) != MEDIA_DEVICE_PATH ||
1006 DevicePathSubType (&FilePathNode->Header) != MEDIA_FILEPATH_DP
1007 ) {
1008 Status = EFI_UNSUPPORTED;
1009 break;
1010 }
1011
1012 //
1013 // Open this file path node
1014 //
1015 Handle2 = Handle1;
1016 Handle1 = NULL;
1017
1018 //
1019 // if this is the last node in the DevicePath always create (if that was requested).
1020 //
1021 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode->Header)))) {
1022 Status = Handle2->Open (
1023 Handle2,
1024 &Handle1,
1025 AlignedNode->PathName,
1026 OpenMode,
1027 Attributes
1028 );
1029 } else {
1030
1031 //
1032 // This is not the last node and we dont want to 'create' existing
1033 // directory entries...
1034 //
1035
1036 //
1037 // open without letting it create
1038 // prevents error on existing files/directories
1039 //
1040 Status = Handle2->Open (
1041 Handle2,
1042 &Handle1,
1043 AlignedNode->PathName,
1044 OpenMode &~EFI_FILE_MODE_CREATE,
1045 Attributes
1046 );
1047 //
1048 // if above failed now open and create the 'item'
1049 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1050 //
1051 if ((EFI_ERROR (Status)) && ((OpenMode & EFI_FILE_MODE_CREATE) != 0)) {
1052 Status = Handle2->Open (
1053 Handle2,
1054 &Handle1,
1055 AlignedNode->PathName,
1056 OpenMode,
1057 Attributes
1058 );
1059 }
1060 }
1061 //
1062 // Close the last node
1063 //
1064 ShellInfoObject.NewEfiShellProtocol->CloseFile (Handle2);
1065
1066 //
1067 // If there's been an error, stop
1068 //
1069 if (EFI_ERROR (Status)) {
1070 break;
1071 }
1072 } // for loop
1073 }
1074 }
1075 }
1076 SHELL_FREE_NON_NULL(AlignedNode);
1077 if (EFI_ERROR(Status)) {
1078 if (Handle1 != NULL) {
1079 ShellInfoObject.NewEfiShellProtocol->CloseFile(Handle1);
1080 }
1081 } else {
1082 *FileHandle = ConvertEfiFileProtocolToShellHandle(Handle1, ShellFileHandleGetPath(ShellHandle));
1083 }
1084 return (Status);
1085 }
1086
1087 /**
1088 Creates a file or directory by name.
1089
1090 This function creates an empty new file or directory with the specified attributes and
1091 returns the new file's handle. If the file already exists and is read-only, then
1092 EFI_INVALID_PARAMETER will be returned.
1093
1094 If the file already existed, it is truncated and its attributes updated. If the file is
1095 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1096
1097 If the file name begins with >v, then the file handle which is returned refers to the
1098 shell environment variable with the specified name. If the shell environment variable
1099 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1100
1101 @param FileName Pointer to NULL-terminated file path
1102 @param FileAttribs The new file's attrbiutes. the different attributes are
1103 described in EFI_FILE_PROTOCOL.Open().
1104 @param FileHandle On return, points to the created file handle or directory's handle
1105
1106 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1107 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1108 @retval EFI_UNSUPPORTED could not open the file path
1109 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1110 file the file system on the device.
1111 @retval EFI_NO_MEDIA the device has no medium.
1112 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1113 longer supported.
1114 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1115 the DirName.
1116 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1117 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1118 when the media is write-protected.
1119 @retval EFI_ACCESS_DENIED The service denied access to the file.
1120 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1121 @retval EFI_VOLUME_FULL The volume is full.
1122 **/
1123 EFI_STATUS
1124 EFIAPI
1125 EfiShellCreateFile(
1126 IN CONST CHAR16 *FileName,
1127 IN UINT64 FileAttribs,
1128 OUT SHELL_FILE_HANDLE *FileHandle
1129 )
1130 {
1131 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1132 EFI_STATUS Status;
1133 BOOLEAN Volatile;
1134
1135 //
1136 // Is this for an environment variable
1137 // do we start with >v
1138 //
1139 if (StrStr(FileName, L">v") == FileName) {
1140 Status = IsVolatileEnv (FileName + 2, &Volatile);
1141 if (EFI_ERROR (Status)) {
1142 return Status;
1143 }
1144 if (!Volatile) {
1145 return (EFI_INVALID_PARAMETER);
1146 }
1147 *FileHandle = CreateFileInterfaceEnv(FileName+2);
1148 return (EFI_SUCCESS);
1149 }
1150
1151 //
1152 // We are opening a regular file.
1153 //
1154 DevicePath = EfiShellGetDevicePathFromFilePath(FileName);
1155 if (DevicePath == NULL) {
1156 return (EFI_NOT_FOUND);
1157 }
1158
1159 Status = InternalOpenFileDevicePath(DevicePath, FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, FileAttribs);
1160 FreePool(DevicePath);
1161
1162 return(Status);
1163 }
1164
1165 /**
1166 Register a GUID and a localized human readable name for it.
1167
1168 If Guid is not assigned a name, then assign GuidName to Guid. This list of GUID
1169 names must be used whenever a shell command outputs GUID information.
1170
1171 This function is only available when the major and minor versions in the
1172 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
1173
1174 @param[in] Guid A pointer to the GUID being registered.
1175 @param[in] GuidName A pointer to the localized name for the GUID being registered.
1176
1177 @retval EFI_SUCCESS The operation was successful.
1178 @retval EFI_INVALID_PARAMETER Guid was NULL.
1179 @retval EFI_INVALID_PARAMETER GuidName was NULL.
1180 @retval EFI_ACCESS_DENIED Guid already is assigned a name.
1181 **/
1182 EFI_STATUS
1183 EFIAPI
1184 EfiShellRegisterGuidName(
1185 IN CONST EFI_GUID *Guid,
1186 IN CONST CHAR16 *GuidName
1187 )
1188 {
1189 return (AddNewGuidNameMapping(Guid, GuidName, NULL));
1190 }
1191
1192 /**
1193 Opens a file or a directory by file name.
1194
1195 This function opens the specified file in the specified OpenMode and returns a file
1196 handle.
1197 If the file name begins with >v, then the file handle which is returned refers to the
1198 shell environment variable with the specified name. If the shell environment variable
1199 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1200 EFI_INVALID_PARAMETER is returned.
1201
1202 If the file name is >i, then the file handle which is returned refers to the standard
1203 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1204 is returned.
1205
1206 If the file name is >o, then the file handle which is returned refers to the standard
1207 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1208 is returned.
1209
1210 If the file name is >e, then the file handle which is returned refers to the standard
1211 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1212 is returned.
1213
1214 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1215 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1216 returned.
1217
1218 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1219 FileHandle is NULL.
1220
1221 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1222 @param FileHandle On return, points to the file handle.
1223 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1224 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1225 Specification.
1226 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1227 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1228 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1229 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1230 system could not be found on the device. FileHandle is NULL.
1231 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1232 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1233 longer supported. FileHandle is NULL.
1234 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1235 the FileName. FileHandle is NULL.
1236 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1237 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1238 when the media is write-protected. FileHandle is NULL.
1239 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1240 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1241 is NULL.
1242 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1243 **/
1244 EFI_STATUS
1245 EFIAPI
1246 EfiShellOpenFileByName(
1247 IN CONST CHAR16 *FileName,
1248 OUT SHELL_FILE_HANDLE *FileHandle,
1249 IN UINT64 OpenMode
1250 )
1251 {
1252 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1253 EFI_STATUS Status;
1254 BOOLEAN Volatile;
1255
1256 *FileHandle = NULL;
1257
1258 //
1259 // Is this for StdIn
1260 //
1261 if (StrCmp(FileName, L">i") == 0) {
1262 //
1263 // make sure not writing to StdIn
1264 //
1265 if ((OpenMode & EFI_FILE_MODE_WRITE) != 0) {
1266 return (EFI_INVALID_PARAMETER);
1267 }
1268 *FileHandle = ShellInfoObject.NewShellParametersProtocol->StdIn;
1269 ASSERT(*FileHandle != NULL);
1270 return (EFI_SUCCESS);
1271 }
1272
1273 //
1274 // Is this for StdOut
1275 //
1276 if (StrCmp(FileName, L">o") == 0) {
1277 //
1278 // make sure not writing to StdIn
1279 //
1280 if ((OpenMode & EFI_FILE_MODE_READ) != 0) {
1281 return (EFI_INVALID_PARAMETER);
1282 }
1283 *FileHandle = &FileInterfaceStdOut;
1284 return (EFI_SUCCESS);
1285 }
1286
1287 //
1288 // Is this for NUL / NULL file
1289 //
1290 if ((gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16*)FileName, L"NUL") == 0) ||
1291 (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16*)FileName, L"NULL") == 0)) {
1292 *FileHandle = &FileInterfaceNulFile;
1293 return (EFI_SUCCESS);
1294 }
1295
1296 //
1297 // Is this for StdErr
1298 //
1299 if (StrCmp(FileName, L">e") == 0) {
1300 //
1301 // make sure not writing to StdIn
1302 //
1303 if ((OpenMode & EFI_FILE_MODE_READ) != 0) {
1304 return (EFI_INVALID_PARAMETER);
1305 }
1306 *FileHandle = &FileInterfaceStdErr;
1307 return (EFI_SUCCESS);
1308 }
1309
1310 //
1311 // Is this for an environment variable
1312 // do we start with >v
1313 //
1314 if (StrStr(FileName, L">v") == FileName) {
1315 Status = IsVolatileEnv (FileName + 2, &Volatile);
1316 if (EFI_ERROR (Status)) {
1317 return Status;
1318 }
1319 if (!Volatile &&
1320 ((OpenMode & EFI_FILE_MODE_WRITE) != 0)) {
1321 return (EFI_INVALID_PARAMETER);
1322 }
1323 *FileHandle = CreateFileInterfaceEnv(FileName+2);
1324 return (EFI_SUCCESS);
1325 }
1326
1327 //
1328 // We are opening a regular file.
1329 //
1330 DevicePath = EfiShellGetDevicePathFromFilePath(FileName);
1331 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1332 if (DevicePath == NULL) {
1333 return (EFI_NOT_FOUND);
1334 }
1335
1336 //
1337 // Copy the device path, open the file, then free the memory
1338 //
1339 Status = InternalOpenFileDevicePath(DevicePath, FileHandle, OpenMode, 0); // 0 = no specific file attributes
1340 FreePool(DevicePath);
1341
1342 return(Status);
1343 }
1344
1345 /**
1346 Deletes the file specified by the file name.
1347
1348 This function deletes a file.
1349
1350 @param FileName Points to the NULL-terminated file name.
1351
1352 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1353 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1354 @sa EfiShellCreateFile
1355 **/
1356 EFI_STATUS
1357 EFIAPI
1358 EfiShellDeleteFileByName(
1359 IN CONST CHAR16 *FileName
1360 )
1361 {
1362 SHELL_FILE_HANDLE FileHandle;
1363 EFI_STATUS Status;
1364
1365 FileHandle = NULL;
1366
1367 //
1368 // get a handle to the file
1369 //
1370 Status = EfiShellCreateFile(FileName,
1371 0,
1372 &FileHandle);
1373 if (EFI_ERROR(Status)) {
1374 return (Status);
1375 }
1376 //
1377 // now delete the file
1378 //
1379 ShellFileHandleRemove(FileHandle);
1380 return (ShellInfoObject.NewEfiShellProtocol->DeleteFile(FileHandle));
1381 }
1382
1383 /**
1384 Disables the page break output mode.
1385 **/
1386 VOID
1387 EFIAPI
1388 EfiShellDisablePageBreak (
1389 VOID
1390 )
1391 {
1392 ShellInfoObject.PageBreakEnabled = FALSE;
1393 }
1394
1395 /**
1396 Enables the page break output mode.
1397 **/
1398 VOID
1399 EFIAPI
1400 EfiShellEnablePageBreak (
1401 VOID
1402 )
1403 {
1404 ShellInfoObject.PageBreakEnabled = TRUE;
1405 }
1406
1407 /**
1408 internal worker function to load and run an image via device path.
1409
1410 @param ParentImageHandle A handle of the image that is executing the specified
1411 command line.
1412 @param DevicePath device path of the file to execute
1413 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1414 containing the command line. If NULL then the command-
1415 line will be empty.
1416 @param Environment Points to a NULL-terminated array of environment
1417 variables with the format 'x=y', where x is the
1418 environment variable name and y is the value. If this
1419 is NULL, then the current shell environment is used.
1420
1421 @param[out] StartImageStatus Returned status from gBS->StartImage.
1422
1423 @retval EFI_SUCCESS The command executed successfully. The status code
1424 returned by the command is pointed to by StatusCode.
1425 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1426 @retval EFI_OUT_OF_RESOURCES Out of resources.
1427 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1428 **/
1429 EFI_STATUS
1430 InternalShellExecuteDevicePath(
1431 IN CONST EFI_HANDLE *ParentImageHandle,
1432 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1433 IN CONST CHAR16 *CommandLine OPTIONAL,
1434 IN CONST CHAR16 **Environment OPTIONAL,
1435 OUT EFI_STATUS *StartImageStatus OPTIONAL
1436 )
1437 {
1438 EFI_STATUS Status;
1439 EFI_STATUS StartStatus;
1440 EFI_STATUS CleanupStatus;
1441 EFI_HANDLE NewHandle;
1442 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
1443 LIST_ENTRY OrigEnvs;
1444 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol;
1445 CHAR16 *ImagePath;
1446 UINTN Index;
1447 CHAR16 *Walker;
1448 CHAR16 *NewCmdLine;
1449
1450 if (ParentImageHandle == NULL) {
1451 return (EFI_INVALID_PARAMETER);
1452 }
1453
1454 InitializeListHead(&OrigEnvs);
1455 ZeroMem(&ShellParamsProtocol, sizeof(EFI_SHELL_PARAMETERS_PROTOCOL));
1456
1457 NewHandle = NULL;
1458
1459 NewCmdLine = AllocateCopyPool (StrSize (CommandLine), CommandLine);
1460 if (NewCmdLine == NULL) {
1461 return EFI_OUT_OF_RESOURCES;
1462 }
1463
1464 for (Walker = NewCmdLine; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
1465 if (*Walker == L'^' && *(Walker+1) == L'#') {
1466 CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
1467 }
1468 }
1469
1470 //
1471 // Load the image with:
1472 // FALSE - not from boot manager and NULL, 0 being not already in memory
1473 //
1474 Status = gBS->LoadImage(
1475 FALSE,
1476 *ParentImageHandle,
1477 (EFI_DEVICE_PATH_PROTOCOL*)DevicePath,
1478 NULL,
1479 0,
1480 &NewHandle);
1481
1482 if (EFI_ERROR(Status)) {
1483 if (NewHandle != NULL) {
1484 gBS->UnloadImage(NewHandle);
1485 }
1486 FreePool (NewCmdLine);
1487 return (Status);
1488 }
1489 Status = gBS->OpenProtocol(
1490 NewHandle,
1491 &gEfiLoadedImageProtocolGuid,
1492 (VOID**)&LoadedImage,
1493 gImageHandle,
1494 NULL,
1495 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
1496
1497 if (!EFI_ERROR(Status)) {
1498 //
1499 // If the image is not an app abort it.
1500 //
1501 if (LoadedImage->ImageCodeType != EfiLoaderCode){
1502 ShellPrintHiiEx(
1503 -1,
1504 -1,
1505 NULL,
1506 STRING_TOKEN (STR_SHELL_IMAGE_NOT_APP),
1507 ShellInfoObject.HiiHandle
1508 );
1509 goto UnloadImage;
1510 }
1511
1512 ASSERT(LoadedImage->LoadOptionsSize == 0);
1513 if (NewCmdLine != NULL) {
1514 LoadedImage->LoadOptionsSize = (UINT32)StrSize(NewCmdLine);
1515 LoadedImage->LoadOptions = (VOID*)NewCmdLine;
1516 }
1517
1518 //
1519 // Save our current environment settings for later restoration if necessary
1520 //
1521 if (Environment != NULL) {
1522 Status = GetEnvironmentVariableList(&OrigEnvs);
1523 if (!EFI_ERROR(Status)) {
1524 Status = SetEnvironmentVariables(Environment);
1525 }
1526 }
1527
1528 //
1529 // Initialize and install a shell parameters protocol on the image.
1530 //
1531 ShellParamsProtocol.StdIn = ShellInfoObject.NewShellParametersProtocol->StdIn;
1532 ShellParamsProtocol.StdOut = ShellInfoObject.NewShellParametersProtocol->StdOut;
1533 ShellParamsProtocol.StdErr = ShellInfoObject.NewShellParametersProtocol->StdErr;
1534 Status = UpdateArgcArgv(&ShellParamsProtocol, NewCmdLine, Efi_Application, NULL, NULL);
1535 ASSERT_EFI_ERROR(Status);
1536 //
1537 // Replace Argv[0] with the full path of the binary we're executing:
1538 // If the command line was "foo", the binary might be called "foo.efi".
1539 // "The first entry in [Argv] is always the full file path of the
1540 // executable" - UEFI Shell Spec section 2.3
1541 //
1542 ImagePath = EfiShellGetFilePathFromDevicePath (DevicePath);
1543 // The image we're executing isn't necessarily in a filesystem - it might
1544 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1545 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1546 if (ImagePath != NULL) {
1547 if (ShellParamsProtocol.Argv == NULL) {
1548 // Command line was empty or null.
1549 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1550 ShellParamsProtocol.Argv = AllocatePool (sizeof (CHAR16 *));
1551 if (ShellParamsProtocol.Argv == NULL) {
1552 Status = EFI_OUT_OF_RESOURCES;
1553 goto UnloadImage;
1554 }
1555 ShellParamsProtocol.Argc = 1;
1556 } else {
1557 // Free the string UpdateArgcArgv put in Argv[0];
1558 FreePool (ShellParamsProtocol.Argv[0]);
1559 }
1560 ShellParamsProtocol.Argv[0] = ImagePath;
1561 }
1562
1563 Status = gBS->InstallProtocolInterface(&NewHandle, &gEfiShellParametersProtocolGuid, EFI_NATIVE_INTERFACE, &ShellParamsProtocol);
1564 ASSERT_EFI_ERROR(Status);
1565
1566 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1567
1568 //
1569 // now start the image and if the caller wanted the return code pass it to them...
1570 //
1571 if (!EFI_ERROR(Status)) {
1572 StartStatus = gBS->StartImage(
1573 NewHandle,
1574 0,
1575 NULL
1576 );
1577 if (StartImageStatus != NULL) {
1578 *StartImageStatus = StartStatus;
1579 }
1580
1581 CleanupStatus = gBS->UninstallProtocolInterface(
1582 NewHandle,
1583 &gEfiShellParametersProtocolGuid,
1584 &ShellParamsProtocol
1585 );
1586 ASSERT_EFI_ERROR(CleanupStatus);
1587
1588 goto FreeAlloc;
1589 }
1590
1591 UnloadImage:
1592 // Unload image - We should only get here if we didn't call StartImage
1593 gBS->UnloadImage (NewHandle);
1594
1595 FreeAlloc:
1596 // Free Argv (Allocated in UpdateArgcArgv)
1597 if (ShellParamsProtocol.Argv != NULL) {
1598 for (Index = 0; Index < ShellParamsProtocol.Argc; Index++) {
1599 if (ShellParamsProtocol.Argv[Index] != NULL) {
1600 FreePool (ShellParamsProtocol.Argv[Index]);
1601 }
1602 }
1603 FreePool (ShellParamsProtocol.Argv);
1604 }
1605 }
1606
1607 // Restore environment variables
1608 if (!IsListEmpty(&OrigEnvs)) {
1609 CleanupStatus = SetEnvironmentVariableList(&OrigEnvs);
1610 ASSERT_EFI_ERROR (CleanupStatus);
1611 }
1612
1613 FreePool (NewCmdLine);
1614
1615 return(Status);
1616 }
1617
1618 /**
1619 internal worker function to load and run an image in the current shell.
1620
1621 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1622 containing the command line. If NULL then the command-
1623 line will be empty.
1624 @param Environment Points to a NULL-terminated array of environment
1625 variables with the format 'x=y', where x is the
1626 environment variable name and y is the value. If this
1627 is NULL, then the current shell environment is used.
1628
1629 @param[out] StartImageStatus Returned status from the command line.
1630
1631 @retval EFI_SUCCESS The command executed successfully. The status code
1632 returned by the command is pointed to by StatusCode.
1633 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1634 @retval EFI_OUT_OF_RESOURCES Out of resources.
1635 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1636 **/
1637 EFI_STATUS
1638 InternalShellExecute(
1639 IN CONST CHAR16 *CommandLine OPTIONAL,
1640 IN CONST CHAR16 **Environment OPTIONAL,
1641 OUT EFI_STATUS *StartImageStatus OPTIONAL
1642 )
1643 {
1644 EFI_STATUS Status;
1645 EFI_STATUS CleanupStatus;
1646 LIST_ENTRY OrigEnvs;
1647
1648 InitializeListHead(&OrigEnvs);
1649
1650 //
1651 // Save our current environment settings for later restoration if necessary
1652 //
1653 if (Environment != NULL) {
1654 Status = GetEnvironmentVariableList(&OrigEnvs);
1655 if (!EFI_ERROR(Status)) {
1656 Status = SetEnvironmentVariables(Environment);
1657 } else {
1658 return Status;
1659 }
1660 }
1661
1662 Status = RunShellCommand(CommandLine, StartImageStatus);
1663
1664 // Restore environment variables
1665 if (!IsListEmpty(&OrigEnvs)) {
1666 CleanupStatus = SetEnvironmentVariableList(&OrigEnvs);
1667 ASSERT_EFI_ERROR (CleanupStatus);
1668 }
1669
1670 return(Status);
1671 }
1672
1673 /**
1674 Determine if the UEFI Shell is currently running with nesting enabled or disabled.
1675
1676 @retval FALSE nesting is required
1677 @retval other nesting is enabled
1678 **/
1679 STATIC
1680 BOOLEAN
1681 NestingEnabled(
1682 )
1683 {
1684 EFI_STATUS Status;
1685 CHAR16 *Temp;
1686 CHAR16 *Temp2;
1687 UINTN TempSize;
1688 BOOLEAN RetVal;
1689
1690 RetVal = TRUE;
1691 Temp = NULL;
1692 Temp2 = NULL;
1693
1694 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoNest) {
1695 TempSize = 0;
1696 Temp = NULL;
1697 Status = SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName, &TempSize, Temp);
1698 if (Status == EFI_BUFFER_TOO_SMALL) {
1699 Temp = AllocateZeroPool(TempSize + sizeof(CHAR16));
1700 if (Temp != NULL) {
1701 Status = SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName, &TempSize, Temp);
1702 }
1703 }
1704 Temp2 = StrnCatGrow(&Temp2, NULL, mNoNestingTrue, 0);
1705 if (Temp != NULL && Temp2 != NULL && StringNoCaseCompare(&Temp, &Temp2) == 0) {
1706 //
1707 // Use the no nesting method.
1708 //
1709 RetVal = FALSE;
1710 }
1711 }
1712
1713 SHELL_FREE_NON_NULL(Temp);
1714 SHELL_FREE_NON_NULL(Temp2);
1715 return (RetVal);
1716 }
1717
1718 /**
1719 Execute the command line.
1720
1721 This function creates a nested instance of the shell and executes the specified
1722 command (CommandLine) with the specified environment (Environment). Upon return,
1723 the status code returned by the specified command is placed in StatusCode.
1724
1725 If Environment is NULL, then the current environment is used and all changes made
1726 by the commands executed will be reflected in the current environment. If the
1727 Environment is non-NULL, then the changes made will be discarded.
1728
1729 The CommandLine is executed from the current working directory on the current
1730 device.
1731
1732 @param ParentImageHandle A handle of the image that is executing the specified
1733 command line.
1734 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1735 containing the command line. If NULL then the command-
1736 line will be empty.
1737 @param Environment Points to a NULL-terminated array of environment
1738 variables with the format 'x=y', where x is the
1739 environment variable name and y is the value. If this
1740 is NULL, then the current shell environment is used.
1741 @param StatusCode Points to the status code returned by the CommandLine.
1742
1743 @retval EFI_SUCCESS The command executed successfully. The status code
1744 returned by the command is pointed to by StatusCode.
1745 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1746 @retval EFI_OUT_OF_RESOURCES Out of resources.
1747 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1748 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1749
1750 @sa InternalShellExecuteDevicePath
1751 **/
1752 EFI_STATUS
1753 EFIAPI
1754 EfiShellExecute(
1755 IN EFI_HANDLE *ParentImageHandle,
1756 IN CHAR16 *CommandLine OPTIONAL,
1757 IN CHAR16 **Environment OPTIONAL,
1758 OUT EFI_STATUS *StatusCode OPTIONAL
1759 )
1760 {
1761 EFI_STATUS Status;
1762 CHAR16 *Temp;
1763 EFI_DEVICE_PATH_PROTOCOL *DevPath;
1764 UINTN Size;
1765
1766 if ((PcdGet8(PcdShellSupportLevel) < 1)) {
1767 return (EFI_UNSUPPORTED);
1768 }
1769
1770 if (NestingEnabled()) {
1771 DevPath = AppendDevicePath (ShellInfoObject.ImageDevPath, ShellInfoObject.FileDevPath);
1772
1773 DEBUG_CODE_BEGIN();
1774 Temp = ConvertDevicePathToText(ShellInfoObject.FileDevPath, TRUE, TRUE);
1775 FreePool(Temp);
1776 Temp = ConvertDevicePathToText(ShellInfoObject.ImageDevPath, TRUE, TRUE);
1777 FreePool(Temp);
1778 Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);
1779 FreePool(Temp);
1780 DEBUG_CODE_END();
1781
1782 Temp = NULL;
1783 Size = 0;
1784 ASSERT((Temp == NULL && Size == 0) || (Temp != NULL));
1785 StrnCatGrow(&Temp, &Size, L"Shell.efi -exit ", 0);
1786 StrnCatGrow(&Temp, &Size, CommandLine, 0);
1787
1788 Status = InternalShellExecuteDevicePath(
1789 ParentImageHandle,
1790 DevPath,
1791 Temp,
1792 (CONST CHAR16**)Environment,
1793 StatusCode);
1794
1795 //
1796 // de-allocate and return
1797 //
1798 FreePool(DevPath);
1799 FreePool(Temp);
1800 } else {
1801 Status = InternalShellExecute(
1802 (CONST CHAR16*)CommandLine,
1803 (CONST CHAR16**)Environment,
1804 StatusCode);
1805 }
1806
1807 return(Status);
1808 }
1809
1810 /**
1811 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1812
1813 1) frees all pointers (non-NULL)
1814 2) Closes the SHELL_FILE_HANDLE
1815
1816 @param FileListNode pointer to the list node to free
1817 **/
1818 VOID
1819 InternalFreeShellFileInfoNode(
1820 IN EFI_SHELL_FILE_INFO *FileListNode
1821 )
1822 {
1823 if (FileListNode->Info != NULL) {
1824 FreePool((VOID*)FileListNode->Info);
1825 }
1826 if (FileListNode->FileName != NULL) {
1827 FreePool((VOID*)FileListNode->FileName);
1828 }
1829 if (FileListNode->FullName != NULL) {
1830 FreePool((VOID*)FileListNode->FullName);
1831 }
1832 if (FileListNode->Handle != NULL) {
1833 ShellInfoObject.NewEfiShellProtocol->CloseFile(FileListNode->Handle);
1834 }
1835 FreePool(FileListNode);
1836 }
1837 /**
1838 Frees the file list.
1839
1840 This function cleans up the file list and any related data structures. It has no
1841 impact on the files themselves.
1842
1843 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1844 defined in OpenFileList()
1845
1846 @retval EFI_SUCCESS Free the file list successfully.
1847 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1848 **/
1849 EFI_STATUS
1850 EFIAPI
1851 EfiShellFreeFileList(
1852 IN EFI_SHELL_FILE_INFO **FileList
1853 )
1854 {
1855 EFI_SHELL_FILE_INFO *ShellFileListItem;
1856
1857 if (FileList == NULL || *FileList == NULL) {
1858 return (EFI_INVALID_PARAMETER);
1859 }
1860
1861 for ( ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetFirstNode(&(*FileList)->Link)
1862 ; !IsListEmpty(&(*FileList)->Link)
1863 ; ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetFirstNode(&(*FileList)->Link)
1864 ){
1865 RemoveEntryList(&ShellFileListItem->Link);
1866 InternalFreeShellFileInfoNode(ShellFileListItem);
1867 }
1868 InternalFreeShellFileInfoNode(*FileList);
1869 *FileList = NULL;
1870 return(EFI_SUCCESS);
1871 }
1872
1873 /**
1874 Deletes the duplicate file names files in the given file list.
1875
1876 This function deletes the reduplicate files in the given file list.
1877
1878 @param FileList A pointer to the first entry in the file list.
1879
1880 @retval EFI_SUCCESS Always success.
1881 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1882 **/
1883 EFI_STATUS
1884 EFIAPI
1885 EfiShellRemoveDupInFileList(
1886 IN EFI_SHELL_FILE_INFO **FileList
1887 )
1888 {
1889 EFI_SHELL_FILE_INFO *ShellFileListItem;
1890 EFI_SHELL_FILE_INFO *ShellFileListItem2;
1891 EFI_SHELL_FILE_INFO *TempNode;
1892
1893 if (FileList == NULL || *FileList == NULL) {
1894 return (EFI_INVALID_PARAMETER);
1895 }
1896 for ( ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetFirstNode(&(*FileList)->Link)
1897 ; !IsNull(&(*FileList)->Link, &ShellFileListItem->Link)
1898 ; ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetNextNode(&(*FileList)->Link, &ShellFileListItem->Link)
1899 ){
1900 for ( ShellFileListItem2 = (EFI_SHELL_FILE_INFO*)GetNextNode(&(*FileList)->Link, &ShellFileListItem->Link)
1901 ; !IsNull(&(*FileList)->Link, &ShellFileListItem2->Link)
1902 ; ShellFileListItem2 = (EFI_SHELL_FILE_INFO*)GetNextNode(&(*FileList)->Link, &ShellFileListItem2->Link)
1903 ){
1904 if (gUnicodeCollation->StriColl(
1905 gUnicodeCollation,
1906 (CHAR16*)ShellFileListItem->FullName,
1907 (CHAR16*)ShellFileListItem2->FullName) == 0
1908 ){
1909 TempNode = (EFI_SHELL_FILE_INFO *)GetPreviousNode(
1910 &(*FileList)->Link,
1911 &ShellFileListItem2->Link
1912 );
1913 RemoveEntryList(&ShellFileListItem2->Link);
1914 InternalFreeShellFileInfoNode(ShellFileListItem2);
1915 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1916 // memory in GetNextNode in the loop expression above.
1917 ShellFileListItem2 = TempNode;
1918 }
1919 }
1920 }
1921 return (EFI_SUCCESS);
1922 }
1923
1924 //
1925 // This is the same structure as the external version, but it has no CONST qualifiers.
1926 //
1927 typedef struct {
1928 LIST_ENTRY Link; ///< Linked list members.
1929 EFI_STATUS Status; ///< Status of opening the file. Valid only if Handle != NULL.
1930 CHAR16 *FullName; ///< Fully qualified filename.
1931 CHAR16 *FileName; ///< name of this file.
1932 SHELL_FILE_HANDLE Handle; ///< Handle for interacting with the opened file or NULL if closed.
1933 EFI_FILE_INFO *Info; ///< Pointer to the FileInfo struct for this file or NULL.
1934 } EFI_SHELL_FILE_INFO_NO_CONST;
1935
1936 /**
1937 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1938
1939 @param[in] Node The node to copy from.
1940 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1941
1942 @retval NULL a memory allocation error ocurred
1943 @return != NULL a pointer to the new node
1944 **/
1945 EFI_SHELL_FILE_INFO*
1946 InternalDuplicateShellFileInfo(
1947 IN EFI_SHELL_FILE_INFO *Node,
1948 IN BOOLEAN Save
1949 )
1950 {
1951 EFI_SHELL_FILE_INFO_NO_CONST *NewNode;
1952
1953 //
1954 // try to confirm that the objects are in sync
1955 //
1956 ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST) == sizeof(EFI_SHELL_FILE_INFO));
1957
1958 NewNode = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
1959 if (NewNode == NULL) {
1960 return (NULL);
1961 }
1962 NewNode->FullName = AllocateCopyPool(StrSize(Node->FullName), Node->FullName);
1963 NewNode->FileName = AllocateCopyPool(StrSize(Node->FileName), Node->FileName);
1964 NewNode->Info = AllocateCopyPool((UINTN)Node->Info->Size, Node->Info);
1965 if ( NewNode->FullName == NULL
1966 || NewNode->FileName == NULL
1967 || NewNode->Info == NULL
1968 ){
1969 SHELL_FREE_NON_NULL(NewNode->FullName);
1970 SHELL_FREE_NON_NULL(NewNode->FileName);
1971 SHELL_FREE_NON_NULL(NewNode->Info);
1972 SHELL_FREE_NON_NULL(NewNode);
1973 return(NULL);
1974 }
1975 NewNode->Status = Node->Status;
1976 NewNode->Handle = Node->Handle;
1977 if (!Save) {
1978 Node->Handle = NULL;
1979 }
1980
1981 return((EFI_SHELL_FILE_INFO*)NewNode);
1982 }
1983
1984 /**
1985 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1986 failed it will return NULL.
1987
1988 @param[in] BasePath the Path to prepend onto filename for FullPath
1989 @param[in] Status Status member initial value.
1990 @param[in] FileName FileName member initial value.
1991 @param[in] Handle Handle member initial value.
1992 @param[in] Info Info struct to copy.
1993
1994 @retval NULL An error ocurred.
1995 @return a pointer to the newly allocated structure.
1996 **/
1997 EFI_SHELL_FILE_INFO *
1998 CreateAndPopulateShellFileInfo(
1999 IN CONST CHAR16 *BasePath,
2000 IN CONST EFI_STATUS Status,
2001 IN CONST CHAR16 *FileName,
2002 IN CONST SHELL_FILE_HANDLE Handle,
2003 IN CONST EFI_FILE_INFO *Info
2004 )
2005 {
2006 EFI_SHELL_FILE_INFO *ShellFileListItem;
2007 CHAR16 *TempString;
2008 UINTN Size;
2009
2010 TempString = NULL;
2011 Size = 0;
2012
2013 ShellFileListItem = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
2014 if (ShellFileListItem == NULL) {
2015 return (NULL);
2016 }
2017 if (Info != NULL && Info->Size != 0) {
2018 ShellFileListItem->Info = AllocateZeroPool((UINTN)Info->Size);
2019 if (ShellFileListItem->Info == NULL) {
2020 FreePool(ShellFileListItem);
2021 return (NULL);
2022 }
2023 CopyMem(ShellFileListItem->Info, Info, (UINTN)Info->Size);
2024 } else {
2025 ShellFileListItem->Info = NULL;
2026 }
2027 if (FileName != NULL) {
2028 ASSERT(TempString == NULL);
2029 ShellFileListItem->FileName = StrnCatGrow(&TempString, 0, FileName, 0);
2030 if (ShellFileListItem->FileName == NULL) {
2031 FreePool(ShellFileListItem->Info);
2032 FreePool(ShellFileListItem);
2033 return (NULL);
2034 }
2035 } else {
2036 ShellFileListItem->FileName = NULL;
2037 }
2038 Size = 0;
2039 TempString = NULL;
2040 if (BasePath != NULL) {
2041 ASSERT((TempString == NULL && Size == 0) || (TempString != NULL));
2042 TempString = StrnCatGrow(&TempString, &Size, BasePath, 0);
2043 if (TempString == NULL) {
2044 FreePool((VOID*)ShellFileListItem->FileName);
2045 SHELL_FREE_NON_NULL(ShellFileListItem->Info);
2046 FreePool(ShellFileListItem);
2047 return (NULL);
2048 }
2049 }
2050 if (ShellFileListItem->FileName != NULL) {
2051 ASSERT((TempString == NULL && Size == 0) || (TempString != NULL));
2052 TempString = StrnCatGrow(&TempString, &Size, ShellFileListItem->FileName, 0);
2053 if (TempString == NULL) {
2054 FreePool((VOID*)ShellFileListItem->FileName);
2055 FreePool(ShellFileListItem->Info);
2056 FreePool(ShellFileListItem);
2057 return (NULL);
2058 }
2059 }
2060
2061 TempString = PathCleanUpDirectories(TempString);
2062
2063 ShellFileListItem->FullName = TempString;
2064 ShellFileListItem->Status = Status;
2065 ShellFileListItem->Handle = Handle;
2066
2067 return (ShellFileListItem);
2068 }
2069
2070 /**
2071 Find all files in a specified directory.
2072
2073 @param FileDirHandle Handle of the directory to search.
2074 @param FileList On return, points to the list of files in the directory
2075 or NULL if there are no files in the directory.
2076
2077 @retval EFI_SUCCESS File information was returned successfully.
2078 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
2079 @retval EFI_DEVICE_ERROR The device reported an error.
2080 @retval EFI_NO_MEDIA The device media is not present.
2081 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
2082 @return An error from FileHandleGetFileName().
2083 **/
2084 EFI_STATUS
2085 EFIAPI
2086 EfiShellFindFilesInDir(
2087 IN SHELL_FILE_HANDLE FileDirHandle,
2088 OUT EFI_SHELL_FILE_INFO **FileList
2089 )
2090 {
2091 EFI_SHELL_FILE_INFO *ShellFileList;
2092 EFI_SHELL_FILE_INFO *ShellFileListItem;
2093 EFI_FILE_INFO *FileInfo;
2094 EFI_STATUS Status;
2095 BOOLEAN NoFile;
2096 CHAR16 *TempString;
2097 CHAR16 *BasePath;
2098 UINTN Size;
2099 CHAR16 *TempSpot;
2100
2101 BasePath = NULL;
2102 Status = FileHandleGetFileName(FileDirHandle, &BasePath);
2103 if (EFI_ERROR(Status)) {
2104 return (Status);
2105 }
2106
2107 if (ShellFileHandleGetPath(FileDirHandle) != NULL) {
2108 TempString = NULL;
2109 Size = 0;
2110 TempString = StrnCatGrow(&TempString, &Size, ShellFileHandleGetPath(FileDirHandle), 0);
2111 if (TempString == NULL) {
2112 SHELL_FREE_NON_NULL(BasePath);
2113 return (EFI_OUT_OF_RESOURCES);
2114 }
2115 TempSpot = StrStr(TempString, L";");
2116
2117 if (TempSpot != NULL) {
2118 *TempSpot = CHAR_NULL;
2119 }
2120
2121 TempString = StrnCatGrow(&TempString, &Size, BasePath, 0);
2122 if (TempString == NULL) {
2123 SHELL_FREE_NON_NULL(BasePath);
2124 return (EFI_OUT_OF_RESOURCES);
2125 }
2126 SHELL_FREE_NON_NULL(BasePath);
2127 BasePath = TempString;
2128 }
2129
2130 NoFile = FALSE;
2131 ShellFileList = NULL;
2132 ShellFileListItem = NULL;
2133 FileInfo = NULL;
2134 Status = EFI_SUCCESS;
2135
2136
2137 for ( Status = FileHandleFindFirstFile(FileDirHandle, &FileInfo)
2138 ; !EFI_ERROR(Status) && !NoFile
2139 ; Status = FileHandleFindNextFile(FileDirHandle, FileInfo, &NoFile)
2140 ){
2141 if (ShellFileList == NULL) {
2142 ShellFileList = (EFI_SHELL_FILE_INFO*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
2143 if (ShellFileList == NULL) {
2144 SHELL_FREE_NON_NULL (BasePath);
2145 return EFI_OUT_OF_RESOURCES;
2146 }
2147 InitializeListHead(&ShellFileList->Link);
2148 }
2149 //
2150 // allocate a new EFI_SHELL_FILE_INFO and populate it...
2151 //
2152 ShellFileListItem = CreateAndPopulateShellFileInfo(
2153 BasePath,
2154 EFI_SUCCESS, // success since we didnt fail to open it...
2155 FileInfo->FileName,
2156 NULL, // no handle since not open
2157 FileInfo);
2158 if (ShellFileListItem == NULL) {
2159 Status = EFI_OUT_OF_RESOURCES;
2160 //
2161 // Free resources outside the loop.
2162 //
2163 break;
2164 }
2165 InsertTailList(&ShellFileList->Link, &ShellFileListItem->Link);
2166 }
2167 if (EFI_ERROR(Status)) {
2168 EfiShellFreeFileList(&ShellFileList);
2169 *FileList = NULL;
2170 } else {
2171 *FileList = ShellFileList;
2172 }
2173 SHELL_FREE_NON_NULL(BasePath);
2174 return(Status);
2175 }
2176
2177 /**
2178 Get the GUID value from a human readable name.
2179
2180 If GuidName is a known GUID name, then update Guid to have the correct value for
2181 that GUID.
2182
2183 This function is only available when the major and minor versions in the
2184 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2185
2186 @param[in] GuidName A pointer to the localized name for the GUID being queried.
2187 @param[out] Guid A pointer to the GUID structure to be filled in.
2188
2189 @retval EFI_SUCCESS The operation was successful.
2190 @retval EFI_INVALID_PARAMETER Guid was NULL.
2191 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2192 @retval EFI_NOT_FOUND GuidName is not a known GUID Name.
2193 **/
2194 EFI_STATUS
2195 EFIAPI
2196 EfiShellGetGuidFromName(
2197 IN CONST CHAR16 *GuidName,
2198 OUT EFI_GUID *Guid
2199 )
2200 {
2201 EFI_GUID *NewGuid;
2202 EFI_STATUS Status;
2203
2204 if (Guid == NULL || GuidName == NULL) {
2205 return (EFI_INVALID_PARAMETER);
2206 }
2207
2208 Status = GetGuidFromStringName(GuidName, NULL, &NewGuid);
2209
2210 if (!EFI_ERROR(Status)) {
2211 CopyGuid(Guid, NewGuid);
2212 }
2213
2214 return (Status);
2215 }
2216
2217 /**
2218 Get the human readable name for a GUID from the value.
2219
2220 If Guid is assigned a name, then update *GuidName to point to the name. The callee
2221 should not modify the value.
2222
2223 This function is only available when the major and minor versions in the
2224 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2225
2226 @param[in] Guid A pointer to the GUID being queried.
2227 @param[out] GuidName A pointer to a pointer the localized to name for the GUID being requested
2228
2229 @retval EFI_SUCCESS The operation was successful.
2230 @retval EFI_INVALID_PARAMETER Guid was NULL.
2231 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2232 @retval EFI_NOT_FOUND Guid is not assigned a name.
2233 **/
2234 EFI_STATUS
2235 EFIAPI
2236 EfiShellGetGuidName(
2237 IN CONST EFI_GUID *Guid,
2238 OUT CONST CHAR16 **GuidName
2239 )
2240 {
2241 CHAR16 *Name;
2242
2243 if (Guid == NULL || GuidName == NULL) {
2244 return (EFI_INVALID_PARAMETER);
2245 }
2246
2247 Name = GetStringNameFromGuid(Guid, NULL);
2248 if (Name == NULL || StrLen(Name) == 0) {
2249 SHELL_FREE_NON_NULL(Name);
2250 return (EFI_NOT_FOUND);
2251 }
2252
2253 *GuidName = AddBufferToFreeList(Name);
2254
2255 return (EFI_SUCCESS);
2256 }
2257
2258 /**
2259 Updates a file name to be preceeded by the mapped drive name
2260
2261 @param[in] BasePath the Mapped drive name to prepend
2262 @param[in, out] Path pointer to pointer to the file name to update.
2263
2264 @retval EFI_SUCCESS
2265 @retval EFI_OUT_OF_RESOURCES
2266 **/
2267 EFI_STATUS
2268 UpdateFileName(
2269 IN CONST CHAR16 *BasePath,
2270 IN OUT CHAR16 **Path
2271 )
2272 {
2273 CHAR16 *Path2;
2274 UINTN Path2Size;
2275
2276 Path2Size = 0;
2277 Path2 = NULL;
2278
2279 ASSERT(Path != NULL);
2280 ASSERT(*Path != NULL);
2281 ASSERT(BasePath != NULL);
2282
2283 //
2284 // convert a local path to an absolute path
2285 //
2286 if (StrStr(*Path, L":") == NULL) {
2287 ASSERT((Path2 == NULL && Path2Size == 0) || (Path2 != NULL));
2288 StrnCatGrow(&Path2, &Path2Size, BasePath, 0);
2289 if (Path2 == NULL) {
2290 return (EFI_OUT_OF_RESOURCES);
2291 }
2292 ASSERT((Path2 == NULL && Path2Size == 0) || (Path2 != NULL));
2293 StrnCatGrow(&Path2, &Path2Size, (*Path)[0] == L'\\'?(*Path) + 1 :*Path, 0);
2294 if (Path2 == NULL) {
2295 return (EFI_OUT_OF_RESOURCES);
2296 }
2297 }
2298
2299 FreePool(*Path);
2300 (*Path) = Path2;
2301
2302 return (EFI_SUCCESS);
2303 }
2304
2305 /**
2306 If FileHandle is a directory then the function reads from FileHandle and reads in
2307 each of the FileInfo structures. If one of them matches the Pattern's first
2308 "level" then it opens that handle and calls itself on that handle.
2309
2310 If FileHandle is a file and matches all of the remaining Pattern (which would be
2311 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2312
2313 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2314 FreeFileList with FileList.
2315
2316 @param[in] FilePattern The FilePattern to check against.
2317 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2318 @param[in] FileHandle The FileHandle to start with
2319 @param[in, out] FileList pointer to pointer to list of found files.
2320 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2321 @param[in] MapName The file system name this file is on.
2322
2323 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2324 @retval EFI_NOT_FOUND no files were found
2325 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2326 **/
2327 EFI_STATUS
2328 ShellSearchHandle(
2329 IN CONST CHAR16 *FilePattern,
2330 IN EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation,
2331 IN SHELL_FILE_HANDLE FileHandle,
2332 IN OUT EFI_SHELL_FILE_INFO **FileList,
2333 IN CONST EFI_SHELL_FILE_INFO *ParentNode OPTIONAL,
2334 IN CONST CHAR16 *MapName
2335 )
2336 {
2337 EFI_STATUS Status;
2338 CONST CHAR16 *NextFilePatternStart;
2339 CHAR16 *CurrentFilePattern;
2340 EFI_SHELL_FILE_INFO *ShellInfo;
2341 EFI_SHELL_FILE_INFO *ShellInfoNode;
2342 EFI_SHELL_FILE_INFO *NewShellNode;
2343 EFI_FILE_INFO *FileInfo;
2344 BOOLEAN Directory;
2345 CHAR16 *NewFullName;
2346 UINTN Size;
2347
2348 if ( FilePattern == NULL
2349 || UnicodeCollation == NULL
2350 || FileList == NULL
2351 ){
2352 return (EFI_INVALID_PARAMETER);
2353 }
2354 ShellInfo = NULL;
2355 CurrentFilePattern = NULL;
2356
2357 if (*FilePattern == L'\\') {
2358 FilePattern++;
2359 }
2360
2361 for( NextFilePatternStart = FilePattern
2362 ; *NextFilePatternStart != CHAR_NULL && *NextFilePatternStart != L'\\'
2363 ; NextFilePatternStart++);
2364
2365 CurrentFilePattern = AllocateZeroPool((NextFilePatternStart-FilePattern+1)*sizeof(CHAR16));
2366 if (CurrentFilePattern == NULL) {
2367 return EFI_OUT_OF_RESOURCES;
2368 }
2369
2370 StrnCpyS(CurrentFilePattern, NextFilePatternStart-FilePattern+1, FilePattern, NextFilePatternStart-FilePattern);
2371
2372 if (CurrentFilePattern[0] == CHAR_NULL
2373 &&NextFilePatternStart[0] == CHAR_NULL
2374 ){
2375 //
2376 // we want the parent or root node (if no parent)
2377 //
2378 if (ParentNode == NULL) {
2379 //
2380 // We want the root node. create the node.
2381 //
2382 FileInfo = FileHandleGetInfo(FileHandle);
2383 NewShellNode = CreateAndPopulateShellFileInfo(
2384 MapName,
2385 EFI_SUCCESS,
2386 L"\\",
2387 FileHandle,
2388 FileInfo
2389 );
2390 SHELL_FREE_NON_NULL(FileInfo);
2391 } else {
2392 //
2393 // Add the current parameter FileHandle to the list, then end...
2394 //
2395 NewShellNode = InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO*)ParentNode, TRUE);
2396 }
2397 if (NewShellNode == NULL) {
2398 Status = EFI_OUT_OF_RESOURCES;
2399 } else {
2400 NewShellNode->Handle = NULL;
2401 if (*FileList == NULL) {
2402 *FileList = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
2403 InitializeListHead(&((*FileList)->Link));
2404 }
2405
2406 //
2407 // Add to the returning to use list
2408 //
2409 InsertTailList(&(*FileList)->Link, &NewShellNode->Link);
2410
2411 Status = EFI_SUCCESS;
2412 }
2413 } else {
2414 Status = EfiShellFindFilesInDir(FileHandle, &ShellInfo);
2415
2416 if (!EFI_ERROR(Status)){
2417 if (StrStr(NextFilePatternStart, L"\\") != NULL){
2418 Directory = TRUE;
2419 } else {
2420 Directory = FALSE;
2421 }
2422 for ( ShellInfoNode = (EFI_SHELL_FILE_INFO*)GetFirstNode(&ShellInfo->Link)
2423 ; !IsNull (&ShellInfo->Link, &ShellInfoNode->Link)
2424 ; ShellInfoNode = (EFI_SHELL_FILE_INFO*)GetNextNode(&ShellInfo->Link, &ShellInfoNode->Link)
2425 ){
2426 if (UnicodeCollation->MetaiMatch(UnicodeCollation, (CHAR16*)ShellInfoNode->FileName, CurrentFilePattern)){
2427 if (ShellInfoNode->FullName != NULL && StrStr(ShellInfoNode->FullName, L":") == NULL) {
2428 Size = StrSize (ShellInfoNode->FullName) + StrSize (MapName);
2429 NewFullName = AllocateZeroPool(Size);
2430 if (NewFullName == NULL) {
2431 Status = EFI_OUT_OF_RESOURCES;
2432 } else {
2433 StrCpyS(NewFullName, Size / sizeof(CHAR16), MapName);
2434 StrCatS(NewFullName, Size / sizeof(CHAR16), ShellInfoNode->FullName);
2435 FreePool ((VOID *) ShellInfoNode->FullName);
2436 ShellInfoNode->FullName = NewFullName;
2437 }
2438 }
2439 if (Directory && !EFI_ERROR(Status) && ShellInfoNode->FullName != NULL && ShellInfoNode->FileName != NULL){
2440 //
2441 // should be a directory
2442 //
2443
2444 //
2445 // don't open the . and .. directories
2446 //
2447 if ( (StrCmp(ShellInfoNode->FileName, L".") != 0)
2448 && (StrCmp(ShellInfoNode->FileName, L"..") != 0)
2449 ){
2450 //
2451 //
2452 //
2453 if (EFI_ERROR(Status)) {
2454 break;
2455 }
2456 //
2457 // Open the directory since we need that handle in the next recursion.
2458 //
2459 ShellInfoNode->Status = EfiShellOpenFileByName (ShellInfoNode->FullName, &ShellInfoNode->Handle, EFI_FILE_MODE_READ);
2460
2461 //
2462 // recurse with the next part of the pattern
2463 //
2464 Status = ShellSearchHandle(NextFilePatternStart, UnicodeCollation, ShellInfoNode->Handle, FileList, ShellInfoNode, MapName);
2465 EfiShellClose(ShellInfoNode->Handle);
2466 ShellInfoNode->Handle = NULL;
2467 }
2468 } else if (!EFI_ERROR(Status)) {
2469 //
2470 // should be a file
2471 //
2472
2473 //
2474 // copy the information we need into a new Node
2475 //
2476 NewShellNode = InternalDuplicateShellFileInfo(ShellInfoNode, FALSE);
2477 if (NewShellNode == NULL) {
2478 Status = EFI_OUT_OF_RESOURCES;
2479 }
2480 if (*FileList == NULL) {
2481 *FileList = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
2482 InitializeListHead(&((*FileList)->Link));
2483 }
2484
2485 //
2486 // Add to the returning to use list
2487 //
2488 InsertTailList(&(*FileList)->Link, &NewShellNode->Link);
2489 }
2490 }
2491 if (EFI_ERROR(Status)) {
2492 break;
2493 }
2494 }
2495 if (EFI_ERROR(Status)) {
2496 EfiShellFreeFileList(&ShellInfo);
2497 } else {
2498 Status = EfiShellFreeFileList(&ShellInfo);
2499 }
2500 }
2501 }
2502
2503 if (*FileList == NULL || (*FileList != NULL && IsListEmpty(&(*FileList)->Link))) {
2504 Status = EFI_NOT_FOUND;
2505 }
2506
2507 FreePool(CurrentFilePattern);
2508 return (Status);
2509 }
2510
2511 /**
2512 Find files that match a specified pattern.
2513
2514 This function searches for all files and directories that match the specified
2515 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2516 information is placed in the file list FileList.
2517
2518 Wildcards are processed
2519 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2520
2521 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2522 field is set to NULL.
2523
2524 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2525
2526 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2527 @param FileList On return, points to the start of a file list containing the names
2528 of all matching files or else points to NULL if no matching files
2529 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2530
2531 @retval EFI_SUCCESS Files found. FileList is a valid list.
2532 @retval EFI_NOT_FOUND No files found.
2533 @retval EFI_NO_MEDIA The device has no media
2534 @retval EFI_DEVICE_ERROR The device reported an error
2535 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2536 **/
2537 EFI_STATUS
2538 EFIAPI
2539 EfiShellFindFiles(
2540 IN CONST CHAR16 *FilePattern,
2541 OUT EFI_SHELL_FILE_INFO **FileList
2542 )
2543 {
2544 EFI_STATUS Status;
2545 CHAR16 *PatternCopy;
2546 CHAR16 *PatternCurrentLocation;
2547 EFI_DEVICE_PATH_PROTOCOL *RootDevicePath;
2548 SHELL_FILE_HANDLE RootFileHandle;
2549 CHAR16 *MapName;
2550 UINTN Count;
2551
2552 if ( FilePattern == NULL
2553 || FileList == NULL
2554 || StrStr(FilePattern, L":") == NULL
2555 ){
2556 return (EFI_INVALID_PARAMETER);
2557 }
2558 Status = EFI_SUCCESS;
2559 RootDevicePath = NULL;
2560 RootFileHandle = NULL;
2561 MapName = NULL;
2562 PatternCopy = AllocateCopyPool(StrSize(FilePattern), FilePattern);
2563 if (PatternCopy == NULL) {
2564 return (EFI_OUT_OF_RESOURCES);
2565 }
2566
2567 PatternCopy = PathCleanUpDirectories(PatternCopy);
2568
2569 Count = StrStr(PatternCopy, L":") - PatternCopy + 1;
2570 ASSERT (Count <= StrLen (PatternCopy));
2571
2572 ASSERT(MapName == NULL);
2573 MapName = StrnCatGrow(&MapName, NULL, PatternCopy, Count);
2574 if (MapName == NULL) {
2575 Status = EFI_OUT_OF_RESOURCES;
2576 } else {
2577 RootDevicePath = EfiShellGetDevicePathFromFilePath(PatternCopy);
2578 if (RootDevicePath == NULL) {
2579 Status = EFI_INVALID_PARAMETER;
2580 } else {
2581 Status = EfiShellOpenRoot(RootDevicePath, &RootFileHandle);
2582 if (!EFI_ERROR(Status)) {
2583 for ( PatternCurrentLocation = PatternCopy
2584 ; *PatternCurrentLocation != ':'
2585 ; PatternCurrentLocation++);
2586 PatternCurrentLocation++;
2587 Status = ShellSearchHandle(PatternCurrentLocation, gUnicodeCollation, RootFileHandle, FileList, NULL, MapName);
2588 EfiShellClose(RootFileHandle);
2589 }
2590 FreePool(RootDevicePath);
2591 }
2592 }
2593
2594 SHELL_FREE_NON_NULL(PatternCopy);
2595 SHELL_FREE_NON_NULL(MapName);
2596
2597 return(Status);
2598 }
2599
2600 /**
2601 Opens the files that match the path specified.
2602
2603 This function opens all of the files specified by Path. Wildcards are processed
2604 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2605 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2606
2607 @param Path A pointer to the path string.
2608 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2609 EFI_FILE_MODE_WRITE.
2610 @param FileList Points to the start of a list of files opened.
2611
2612 @retval EFI_SUCCESS Create the file list successfully.
2613 @return Others Can't create the file list.
2614 **/
2615 EFI_STATUS
2616 EFIAPI
2617 EfiShellOpenFileList(
2618 IN CHAR16 *Path,
2619 IN UINT64 OpenMode,
2620 IN OUT EFI_SHELL_FILE_INFO **FileList
2621 )
2622 {
2623 EFI_STATUS Status;
2624 EFI_SHELL_FILE_INFO *ShellFileListItem;
2625 CHAR16 *Path2;
2626 UINTN Path2Size;
2627 CONST CHAR16 *CurDir;
2628 BOOLEAN Found;
2629
2630 PathCleanUpDirectories(Path);
2631
2632 Path2Size = 0;
2633 Path2 = NULL;
2634
2635 if (FileList == NULL || *FileList == NULL) {
2636 return (EFI_INVALID_PARAMETER);
2637 }
2638
2639 if (*Path == L'.' && *(Path+1) == L'\\') {
2640 Path+=2;
2641 }
2642
2643 //
2644 // convert a local path to an absolute path
2645 //
2646 if (StrStr(Path, L":") == NULL) {
2647 CurDir = EfiShellGetCurDir(NULL);
2648 ASSERT((Path2 == NULL && Path2Size == 0) || (Path2 != NULL));
2649 StrnCatGrow(&Path2, &Path2Size, CurDir, 0);
2650 StrnCatGrow(&Path2, &Path2Size, L"\\", 0);
2651 if (*Path == L'\\') {
2652 Path++;
2653 while (PathRemoveLastItem(Path2)) ;
2654 }
2655 ASSERT((Path2 == NULL && Path2Size == 0) || (Path2 != NULL));
2656 StrnCatGrow(&Path2, &Path2Size, Path, 0);
2657 } else {
2658 ASSERT(Path2 == NULL);
2659 StrnCatGrow(&Path2, NULL, Path, 0);
2660 }
2661
2662 PathCleanUpDirectories (Path2);
2663
2664 //
2665 // do the search
2666 //
2667 Status = EfiShellFindFiles(Path2, FileList);
2668
2669 FreePool(Path2);
2670
2671 if (EFI_ERROR(Status)) {
2672 return (Status);
2673 }
2674
2675 Found = FALSE;
2676 //
2677 // We had no errors so open all the files (that are not already opened...)
2678 //
2679 for ( ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetFirstNode(&(*FileList)->Link)
2680 ; !IsNull(&(*FileList)->Link, &ShellFileListItem->Link)
2681 ; ShellFileListItem = (EFI_SHELL_FILE_INFO*)GetNextNode(&(*FileList)->Link, &ShellFileListItem->Link)
2682 ){
2683 if (ShellFileListItem->Status == 0 && ShellFileListItem->Handle == NULL) {
2684 ShellFileListItem->Status = EfiShellOpenFileByName (ShellFileListItem->FullName, &ShellFileListItem->Handle, OpenMode);
2685 Found = TRUE;
2686 }
2687 }
2688
2689 if (!Found) {
2690 return (EFI_NOT_FOUND);
2691 }
2692 return(EFI_SUCCESS);
2693 }
2694
2695 /**
2696 Gets the environment variable and Attributes, or list of environment variables. Can be
2697 used instead of GetEnv().
2698
2699 This function returns the current value of the specified environment variable and
2700 the Attributes. If no variable name was specified, then all of the known
2701 variables will be returned.
2702
2703 @param[in] Name A pointer to the environment variable name. If Name is NULL,
2704 then the function will return all of the defined shell
2705 environment variables. In the case where multiple environment
2706 variables are being returned, each variable will be terminated
2707 by a NULL, and the list will be terminated by a double NULL.
2708 @param[out] Attributes If not NULL, a pointer to the returned attributes bitmask for
2709 the environment variable. In the case where Name is NULL, and
2710 multiple environment variables are being returned, Attributes
2711 is undefined.
2712
2713 @retval NULL The environment variable doesn't exist.
2714 @return A non-NULL value points to the variable's value. The returned
2715 pointer does not need to be freed by the caller.
2716 **/
2717 CONST CHAR16 *
2718 EFIAPI
2719 EfiShellGetEnvEx(
2720 IN CONST CHAR16 *Name,
2721 OUT UINT32 *Attributes OPTIONAL
2722 )
2723 {
2724 EFI_STATUS Status;
2725 VOID *Buffer;
2726 UINTN Size;
2727 ENV_VAR_LIST *Node;
2728 CHAR16 *CurrentWriteLocation;
2729
2730 Size = 0;
2731 Buffer = NULL;
2732
2733 if (Name == NULL) {
2734
2735 //
2736 // Build the semi-colon delimited list. (2 passes)
2737 //
2738 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&gShellEnvVarList.Link)
2739 ; !IsNull(&gShellEnvVarList.Link, &Node->Link)
2740 ; Node = (ENV_VAR_LIST*)GetNextNode(&gShellEnvVarList.Link, &Node->Link)
2741 ){
2742 ASSERT(Node->Key != NULL);
2743 Size += StrSize(Node->Key);
2744 }
2745
2746 Size += 2*sizeof(CHAR16);
2747
2748 Buffer = AllocateZeroPool(Size);
2749 if (Buffer == NULL) {
2750 return (NULL);
2751 }
2752 CurrentWriteLocation = (CHAR16*)Buffer;
2753
2754 for ( Node = (ENV_VAR_LIST*)GetFirstNode(&gShellEnvVarList.Link)
2755 ; !IsNull(&gShellEnvVarList.Link, &Node->Link)
2756 ; Node = (ENV_VAR_LIST*)GetNextNode(&gShellEnvVarList.Link, &Node->Link)
2757 ){
2758 ASSERT(Node->Key != NULL);
2759 StrCpyS( CurrentWriteLocation,
2760 (Size)/sizeof(CHAR16) - (CurrentWriteLocation - ((CHAR16*)Buffer)),
2761 Node->Key
2762 );
2763 CurrentWriteLocation += StrLen(CurrentWriteLocation) + 1;
2764 }
2765
2766 } else {
2767 //
2768 // We are doing a specific environment variable
2769 //
2770 Status = ShellFindEnvVarInList(Name, (CHAR16**)&Buffer, &Size, Attributes);
2771
2772 if (EFI_ERROR(Status)){
2773 //
2774 // get the size we need for this EnvVariable
2775 //
2776 Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name, Attributes, &Size, Buffer);
2777 if (Status == EFI_BUFFER_TOO_SMALL) {
2778 //
2779 // Allocate the space and recall the get function
2780 //
2781 Buffer = AllocateZeroPool(Size);
2782 Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name, Attributes, &Size, Buffer);
2783 }
2784 //
2785 // we didnt get it (might not exist)
2786 // free the memory if we allocated any and return NULL
2787 //
2788 if (EFI_ERROR(Status)) {
2789 if (Buffer != NULL) {
2790 FreePool(Buffer);
2791 }
2792 return (NULL);
2793 } else {
2794 //
2795 // If we did not find the environment variable in the gShellEnvVarList
2796 // but get it from UEFI variable storage successfully then we need update
2797 // the gShellEnvVarList.
2798 //
2799 ShellFreeEnvVarList ();
2800 Status = ShellInitEnvVarList ();
2801 ASSERT (Status == EFI_SUCCESS);
2802 }
2803 }
2804 }
2805
2806 //
2807 // return the buffer
2808 //
2809 return (AddBufferToFreeList(Buffer));
2810 }
2811
2812 /**
2813 Gets either a single or list of environment variables.
2814
2815 If name is not NULL then this function returns the current value of the specified
2816 environment variable.
2817
2818 If Name is NULL, then a list of all environment variable names is returned. Each is a
2819 NULL terminated string with a double NULL terminating the list.
2820
2821 @param Name A pointer to the environment variable name. If
2822 Name is NULL, then the function will return all
2823 of the defined shell environment variables. In
2824 the case where multiple environment variables are
2825 being returned, each variable will be terminated by
2826 a NULL, and the list will be terminated by a double
2827 NULL.
2828
2829 @retval !=NULL A pointer to the returned string.
2830 The returned pointer does not need to be freed by the caller.
2831
2832 @retval NULL The environment variable doesn't exist or there are
2833 no environment variables.
2834 **/
2835 CONST CHAR16 *
2836 EFIAPI
2837 EfiShellGetEnv(
2838 IN CONST CHAR16 *Name
2839 )
2840 {
2841 return (EfiShellGetEnvEx(Name, NULL));
2842 }
2843
2844 /**
2845 Internal variable setting function. Allows for setting of the read only variables.
2846
2847 @param Name Points to the NULL-terminated environment variable name.
2848 @param Value Points to the NULL-terminated environment variable value. If the value is an
2849 empty string then the environment variable is deleted.
2850 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2851
2852 @retval EFI_SUCCESS The environment variable was successfully updated.
2853 **/
2854 EFI_STATUS
2855 InternalEfiShellSetEnv(
2856 IN CONST CHAR16 *Name,
2857 IN CONST CHAR16 *Value,
2858 IN BOOLEAN Volatile
2859 )
2860 {
2861 EFI_STATUS Status;
2862
2863 if (Value == NULL || StrLen(Value) == 0) {
2864 Status = SHELL_DELETE_ENVIRONMENT_VARIABLE(Name);
2865 if (!EFI_ERROR(Status)) {
2866 ShellRemvoeEnvVarFromList(Name);
2867 }
2868 } else {
2869 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name);
2870 Status = ShellAddEnvVarToList(
2871 Name, Value, StrSize(Value),
2872 EFI_VARIABLE_BOOTSERVICE_ACCESS | (Volatile ? 0 : EFI_VARIABLE_NON_VOLATILE)
2873 );
2874 if (!EFI_ERROR (Status)) {
2875 Status = Volatile
2876 ? SHELL_SET_ENVIRONMENT_VARIABLE_V (Name, StrSize (Value) - sizeof (CHAR16), Value)
2877 : SHELL_SET_ENVIRONMENT_VARIABLE_NV (Name, StrSize (Value) - sizeof (CHAR16), Value);
2878 if (EFI_ERROR (Status)) {
2879 ShellRemvoeEnvVarFromList(Name);
2880 }
2881 }
2882 }
2883 return Status;
2884 }
2885
2886 /**
2887 Sets the environment variable.
2888
2889 This function changes the current value of the specified environment variable. If the
2890 environment variable exists and the Value is an empty string, then the environment
2891 variable is deleted. If the environment variable exists and the Value is not an empty
2892 string, then the value of the environment variable is changed. If the environment
2893 variable does not exist and the Value is an empty string, there is no action. If the
2894 environment variable does not exist and the Value is a non-empty string, then the
2895 environment variable is created and assigned the specified value.
2896
2897 For a description of volatile and non-volatile environment variables, see UEFI Shell
2898 2.0 specification section 3.6.1.
2899
2900 @param Name Points to the NULL-terminated environment variable name.
2901 @param Value Points to the NULL-terminated environment variable value. If the value is an
2902 empty string then the environment variable is deleted.
2903 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2904
2905 @retval EFI_SUCCESS The environment variable was successfully updated.
2906 **/
2907 EFI_STATUS
2908 EFIAPI
2909 EfiShellSetEnv(
2910 IN CONST CHAR16 *Name,
2911 IN CONST CHAR16 *Value,
2912 IN BOOLEAN Volatile
2913 )
2914 {
2915 if (Name == NULL || *Name == CHAR_NULL) {
2916 return (EFI_INVALID_PARAMETER);
2917 }
2918 //
2919 // Make sure we dont 'set' a predefined read only variable
2920 //
2921 if (gUnicodeCollation->StriColl(
2922 gUnicodeCollation,
2923 (CHAR16*)Name,
2924 L"cwd") == 0
2925 ||gUnicodeCollation->StriColl(
2926 gUnicodeCollation,
2927 (CHAR16*)Name,
2928 L"Lasterror") == 0
2929 ||gUnicodeCollation->StriColl(
2930 gUnicodeCollation,
2931 (CHAR16*)Name,
2932 L"profiles") == 0
2933 ||gUnicodeCollation->StriColl(
2934 gUnicodeCollation,
2935 (CHAR16*)Name,
2936 L"uefishellsupport") == 0
2937 ||gUnicodeCollation->StriColl(
2938 gUnicodeCollation,
2939 (CHAR16*)Name,
2940 L"uefishellversion") == 0
2941 ||gUnicodeCollation->StriColl(
2942 gUnicodeCollation,
2943 (CHAR16*)Name,
2944 L"uefiversion") == 0
2945 ||(!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoNest &&
2946 gUnicodeCollation->StriColl(
2947 gUnicodeCollation,
2948 (CHAR16*)Name,
2949 (CHAR16*)mNoNestingEnvVarName) == 0)
2950 ){
2951 return (EFI_INVALID_PARAMETER);
2952 }
2953 return (InternalEfiShellSetEnv(Name, Value, Volatile));
2954 }
2955
2956 /**
2957 Returns the current directory on the specified device.
2958
2959 If FileSystemMapping is NULL, it returns the current working directory. If the
2960 FileSystemMapping is not NULL, it returns the current directory associated with the
2961 FileSystemMapping. In both cases, the returned name includes the file system
2962 mapping (i.e. fs0:\current-dir).
2963
2964 Note that the current directory string should exclude the tailing backslash character.
2965
2966 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2967 then the current working directory is returned.
2968
2969 @retval !=NULL The current directory.
2970 @retval NULL Current directory does not exist.
2971 **/
2972 CONST CHAR16 *
2973 EFIAPI
2974 EfiShellGetCurDir(
2975 IN CONST CHAR16 *FileSystemMapping OPTIONAL
2976 )
2977 {
2978 CHAR16 *PathToReturn;
2979 UINTN Size;
2980 SHELL_MAP_LIST *MapListItem;
2981 if (!IsListEmpty(&gShellMapList.Link)) {
2982 //
2983 // if parameter is NULL, use current
2984 //
2985 if (FileSystemMapping == NULL) {
2986 return (EfiShellGetEnv(L"cwd"));
2987 } else {
2988 Size = 0;
2989 PathToReturn = NULL;
2990 MapListItem = ShellCommandFindMapItem(FileSystemMapping);
2991 if (MapListItem != NULL) {
2992 ASSERT((PathToReturn == NULL && Size == 0) || (PathToReturn != NULL));
2993 PathToReturn = StrnCatGrow(&PathToReturn, &Size, MapListItem->MapName, 0);
2994 PathToReturn = StrnCatGrow(&PathToReturn, &Size, MapListItem->CurrentDirectoryPath, 0);
2995 }
2996 }
2997 return (AddBufferToFreeList(PathToReturn));
2998 } else {
2999 return (NULL);
3000 }
3001 }
3002
3003 /**
3004 Changes the current directory on the specified device.
3005
3006 If the FileSystem is NULL, and the directory Dir does not contain a file system's
3007 mapped name, this function changes the current working directory.
3008
3009 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
3010 current file system and the current directory on that file system are changed.
3011
3012 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
3013 system.
3014
3015 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
3016 directory on the specified file system.
3017
3018 If the current working directory or the current working file system is changed then the
3019 %cwd% environment variable will be updated
3020
3021 Note that the current directory string should exclude the tailing backslash character.
3022
3023 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
3024 directory is changed.
3025 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
3026
3027 @retval EFI_SUCCESS The operation was sucessful
3028 @retval EFI_NOT_FOUND The file system could not be found
3029 **/
3030 EFI_STATUS
3031 EFIAPI
3032 EfiShellSetCurDir(
3033 IN CONST CHAR16 *FileSystem OPTIONAL,
3034 IN CONST CHAR16 *Dir
3035 )
3036 {
3037 CHAR16 *MapName;
3038 SHELL_MAP_LIST *MapListItem;
3039 UINTN Size;
3040 EFI_STATUS Status;
3041 CHAR16 *TempString;
3042 CHAR16 *DirectoryName;
3043 UINTN TempLen;
3044
3045 Size = 0;
3046 MapName = NULL;
3047 MapListItem = NULL;
3048 TempString = NULL;
3049 DirectoryName = NULL;
3050
3051 if ((FileSystem == NULL && Dir == NULL) || Dir == NULL) {
3052 return (EFI_INVALID_PARAMETER);
3053 }
3054
3055 if (IsListEmpty(&gShellMapList.Link)){
3056 return (EFI_NOT_FOUND);
3057 }
3058
3059 DirectoryName = StrnCatGrow(&DirectoryName, NULL, Dir, 0);
3060 ASSERT(DirectoryName != NULL);
3061
3062 PathCleanUpDirectories(DirectoryName);
3063
3064 if (FileSystem == NULL) {
3065 //
3066 // determine the file system mapping to use
3067 //
3068 if (StrStr(DirectoryName, L":") != NULL) {
3069 ASSERT(MapName == NULL);
3070 MapName = StrnCatGrow(&MapName, NULL, DirectoryName, (StrStr(DirectoryName, L":")-DirectoryName+1));
3071 }
3072 //
3073 // find the file system mapping's entry in the list
3074 // or use current
3075 //
3076 if (MapName != NULL) {
3077 MapListItem = ShellCommandFindMapItem(MapName);
3078
3079 //
3080 // make that the current file system mapping
3081 //
3082 if (MapListItem != NULL) {
3083 gShellCurMapping = MapListItem;
3084 }
3085 } else {
3086 MapListItem = gShellCurMapping;
3087 }
3088
3089 if (MapListItem == NULL) {
3090 FreePool (DirectoryName);
3091 SHELL_FREE_NON_NULL(MapName);
3092 return (EFI_NOT_FOUND);
3093 }
3094
3095 //
3096 // now update the MapListItem's current directory
3097 //
3098 if (MapListItem->CurrentDirectoryPath != NULL && DirectoryName[StrLen(DirectoryName) - 1] != L':') {
3099 FreePool(MapListItem->CurrentDirectoryPath);
3100 MapListItem->CurrentDirectoryPath = NULL;
3101 }
3102 if (MapName != NULL) {
3103 TempLen = StrLen(MapName);
3104 if (TempLen != StrLen(DirectoryName)) {
3105 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3106 MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, DirectoryName+StrLen(MapName), 0);
3107 }
3108 FreePool (MapName);
3109 } else {
3110 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3111 MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, DirectoryName, 0);
3112 }
3113 if ((MapListItem->CurrentDirectoryPath != NULL && MapListItem->CurrentDirectoryPath[StrLen(MapListItem->CurrentDirectoryPath)-1] == L'\\') || (MapListItem->CurrentDirectoryPath == NULL)) {
3114 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3115 if (MapListItem->CurrentDirectoryPath != NULL) {
3116 MapListItem->CurrentDirectoryPath[StrLen(MapListItem->CurrentDirectoryPath)-1] = CHAR_NULL;
3117 }
3118 }
3119 } else {
3120 //
3121 // cant have a mapping in the directory...
3122 //
3123 if (StrStr(DirectoryName, L":") != NULL) {
3124 FreePool (DirectoryName);
3125 return (EFI_INVALID_PARAMETER);
3126 }
3127 //
3128 // FileSystem != NULL
3129 //
3130 MapListItem = ShellCommandFindMapItem(FileSystem);
3131 if (MapListItem == NULL) {
3132 FreePool (DirectoryName);
3133 return (EFI_INVALID_PARAMETER);
3134 }
3135 // gShellCurMapping = MapListItem;
3136 if (DirectoryName != NULL) {
3137 //
3138 // change current dir on that file system
3139 //
3140
3141 if (MapListItem->CurrentDirectoryPath != NULL) {
3142 FreePool(MapListItem->CurrentDirectoryPath);
3143 DEBUG_CODE(MapListItem->CurrentDirectoryPath = NULL;);
3144 }
3145 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3146 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
3147 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3148 MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, L"\\", 0);
3149 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3150 MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, DirectoryName, 0);
3151 if (MapListItem->CurrentDirectoryPath != NULL && MapListItem->CurrentDirectoryPath[StrLen(MapListItem->CurrentDirectoryPath)-1] == L'\\') {
3152 ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3153 MapListItem->CurrentDirectoryPath[StrLen(MapListItem->CurrentDirectoryPath)-1] = CHAR_NULL;
3154 }
3155 }
3156 }
3157 FreePool (DirectoryName);
3158 //
3159 // if updated the current directory then update the environment variable
3160 //
3161 if (MapListItem == gShellCurMapping) {
3162 Size = 0;
3163 ASSERT((TempString == NULL && Size == 0) || (TempString != NULL));
3164 StrnCatGrow(&TempString, &Size, MapListItem->MapName, 0);
3165 ASSERT((TempString == NULL && Size == 0) || (TempString != NULL));
3166 StrnCatGrow(&TempString, &Size, MapListItem->CurrentDirectoryPath, 0);
3167 Status = InternalEfiShellSetEnv(L"cwd", TempString, TRUE);
3168 FreePool(TempString);
3169 return (Status);
3170 }
3171 return(EFI_SUCCESS);
3172 }
3173
3174 /**
3175 Return help information about a specific command.
3176
3177 This function returns the help information for the specified command. The help text
3178 can be internal to the shell or can be from a UEFI Shell manual page.
3179
3180 If Sections is specified, then each section name listed will be compared in a casesensitive
3181 manner, to the section names described in Appendix B. If the section exists,
3182 it will be appended to the returned help text. If the section does not exist, no
3183 information will be returned. If Sections is NULL, then all help text information
3184 available will be returned.
3185
3186 @param Command Points to the NULL-terminated UEFI Shell command name.
3187 @param Sections Points to the NULL-terminated comma-delimited
3188 section names to return. If NULL, then all
3189 sections will be returned.
3190 @param HelpText On return, points to a callee-allocated buffer
3191 containing all specified help text.
3192
3193 @retval EFI_SUCCESS The help text was returned.
3194 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
3195 returned help text.
3196 @retval EFI_INVALID_PARAMETER HelpText is NULL
3197 @retval EFI_NOT_FOUND There is no help text available for Command.
3198 **/
3199 EFI_STATUS
3200 EFIAPI
3201 EfiShellGetHelpText(
3202 IN CONST CHAR16 *Command,
3203 IN CONST CHAR16 *Sections OPTIONAL,
3204 OUT CHAR16 **HelpText
3205 )
3206 {
3207 CONST CHAR16 *ManFileName;
3208 CHAR16 *FixCommand;
3209 EFI_STATUS Status;
3210
3211 ASSERT(HelpText != NULL);
3212 FixCommand = NULL;
3213
3214 ManFileName = ShellCommandGetManFileNameHandler(Command);
3215
3216 if (ManFileName != NULL) {
3217 return (ProcessManFile(ManFileName, Command, Sections, NULL, HelpText));
3218 } else {
3219 if ((StrLen(Command)> 4)
3220 && (Command[StrLen(Command)-1] == L'i' || Command[StrLen(Command)-1] == L'I')
3221 && (Command[StrLen(Command)-2] == L'f' || Command[StrLen(Command)-2] == L'F')
3222 && (Command[StrLen(Command)-3] == L'e' || Command[StrLen(Command)-3] == L'E')
3223 && (Command[StrLen(Command)-4] == L'.')
3224 ) {
3225 FixCommand = AllocateZeroPool(StrSize(Command) - 4 * sizeof (CHAR16));
3226 if (FixCommand == NULL) {
3227 return EFI_OUT_OF_RESOURCES;
3228 }
3229
3230 StrnCpyS( FixCommand,
3231 (StrSize(Command) - 4 * sizeof (CHAR16))/sizeof(CHAR16),
3232 Command,
3233 StrLen(Command)-4
3234 );
3235 Status = ProcessManFile(FixCommand, FixCommand, Sections, NULL, HelpText);
3236 FreePool(FixCommand);
3237 return Status;
3238 } else {
3239 return (ProcessManFile(Command, Command, Sections, NULL, HelpText));
3240 }
3241 }
3242 }
3243
3244 /**
3245 Gets the enable status of the page break output mode.
3246
3247 User can use this function to determine current page break mode.
3248
3249 @retval TRUE The page break output mode is enabled.
3250 @retval FALSE The page break output mode is disabled.
3251 **/
3252 BOOLEAN
3253 EFIAPI
3254 EfiShellGetPageBreak(
3255 VOID
3256 )
3257 {
3258 return(ShellInfoObject.PageBreakEnabled);
3259 }
3260
3261 /**
3262 Judges whether the active shell is the root shell.
3263
3264 This function makes the user to know that whether the active Shell is the root shell.
3265
3266 @retval TRUE The active Shell is the root Shell.
3267 @retval FALSE The active Shell is NOT the root Shell.
3268 **/
3269 BOOLEAN
3270 EFIAPI
3271 EfiShellIsRootShell(
3272 VOID
3273 )
3274 {
3275 return(ShellInfoObject.RootShellInstance);
3276 }
3277
3278 /**
3279 function to return a semi-colon delimeted list of all alias' in the current shell
3280
3281 up to caller to free the memory.
3282
3283 @retval NULL No alias' were found
3284 @retval NULL An error ocurred getting alias'
3285 @return !NULL a list of all alias'
3286 **/
3287 CHAR16 *
3288 InternalEfiShellGetListAlias(
3289 )
3290 {
3291
3292 EFI_STATUS Status;
3293 EFI_GUID Guid;
3294 CHAR16 *VariableName;
3295 UINTN NameSize;
3296 UINTN NameBufferSize;
3297 CHAR16 *RetVal;
3298 UINTN RetSize;
3299
3300 NameBufferSize = INIT_NAME_BUFFER_SIZE;
3301 VariableName = AllocateZeroPool(NameBufferSize);
3302 RetSize = 0;
3303 RetVal = NULL;
3304
3305 if (VariableName == NULL) {
3306 return (NULL);
3307 }
3308
3309 VariableName[0] = CHAR_NULL;
3310
3311 while (TRUE) {
3312 NameSize = NameBufferSize;
3313 Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
3314 if (Status == EFI_NOT_FOUND){
3315 break;
3316 } else if (Status == EFI_BUFFER_TOO_SMALL) {
3317 NameBufferSize = NameSize > NameBufferSize * 2 ? NameSize : NameBufferSize * 2;
3318 SHELL_FREE_NON_NULL(VariableName);
3319 VariableName = AllocateZeroPool(NameBufferSize);
3320 if (VariableName == NULL) {
3321 Status = EFI_OUT_OF_RESOURCES;
3322 SHELL_FREE_NON_NULL(RetVal);
3323 RetVal = NULL;
3324 break;
3325 }
3326
3327 NameSize = NameBufferSize;
3328 Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
3329 }
3330
3331 if (EFI_ERROR (Status)) {
3332 SHELL_FREE_NON_NULL(RetVal);
3333 RetVal = NULL;
3334 break;
3335 }
3336
3337 if (CompareGuid(&Guid, &gShellAliasGuid)){
3338 ASSERT((RetVal == NULL && RetSize == 0) || (RetVal != NULL));
3339 RetVal = StrnCatGrow(&RetVal, &RetSize, VariableName, 0);
3340 RetVal = StrnCatGrow(&RetVal, &RetSize, L";", 0);
3341 } // compare guid
3342 } // while
3343 SHELL_FREE_NON_NULL(VariableName);
3344
3345 return (RetVal);
3346 }
3347
3348 /**
3349 Convert a null-terminated unicode string, in-place, to all lowercase.
3350 Then return it.
3351
3352 @param Str The null-terminated string to be converted to all lowercase.
3353
3354 @return The null-terminated string converted into all lowercase.
3355 **/
3356 CHAR16 *
3357 ToLower (
3358 CHAR16 *Str
3359 )
3360 {
3361 UINTN Index;
3362
3363 for (Index = 0; Str[Index] != L'\0'; Index++) {
3364 if (Str[Index] >= L'A' && Str[Index] <= L'Z') {
3365 Str[Index] -= (CHAR16)(L'A' - L'a');
3366 }
3367 }
3368 return Str;
3369 }
3370
3371 /**
3372 This function returns the command associated with a alias or a list of all
3373 alias'.
3374
3375 @param[in] Alias Points to the NULL-terminated shell alias.
3376 If this parameter is NULL, then all
3377 aliases will be returned in ReturnedData.
3378 @param[out] Volatile upon return of a single command if TRUE indicates
3379 this is stored in a volatile fashion. FALSE otherwise.
3380
3381 @return If Alias is not NULL, it will return a pointer to
3382 the NULL-terminated command for that alias.
3383 If Alias is NULL, ReturnedData points to a ';'
3384 delimited list of alias (e.g.
3385 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3386 @retval NULL an error ocurred
3387 @retval NULL Alias was not a valid Alias
3388 **/
3389 CONST CHAR16 *
3390 EFIAPI
3391 EfiShellGetAlias(
3392 IN CONST CHAR16 *Alias,
3393 OUT BOOLEAN *Volatile OPTIONAL
3394 )
3395 {
3396 CHAR16 *RetVal;
3397 UINTN RetSize;
3398 UINT32 Attribs;
3399 EFI_STATUS Status;
3400 CHAR16 *AliasLower;
3401 CHAR16 *AliasVal;
3402
3403 // Convert to lowercase to make aliases case-insensitive
3404 if (Alias != NULL) {
3405 AliasLower = AllocateCopyPool (StrSize (Alias), Alias);
3406 if (AliasLower == NULL) {
3407 return NULL;
3408 }
3409 ToLower (AliasLower);
3410
3411 if (Volatile == NULL) {
3412 GetVariable2 (AliasLower, &gShellAliasGuid, (VOID **)&AliasVal, NULL);
3413 FreePool(AliasLower);
3414 return (AddBufferToFreeList(AliasVal));
3415 }
3416 RetSize = 0;
3417 RetVal = NULL;
3418 Status = gRT->GetVariable(AliasLower, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
3419 if (Status == EFI_BUFFER_TOO_SMALL) {
3420 RetVal = AllocateZeroPool(RetSize);
3421 Status = gRT->GetVariable(AliasLower, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
3422 }
3423 if (EFI_ERROR(Status)) {
3424 if (RetVal != NULL) {
3425 FreePool(RetVal);
3426 }
3427 FreePool(AliasLower);
3428 return (NULL);
3429 }
3430 if ((EFI_VARIABLE_NON_VOLATILE & Attribs) == EFI_VARIABLE_NON_VOLATILE) {
3431 *Volatile = FALSE;
3432 } else {
3433 *Volatile = TRUE;
3434 }
3435
3436 FreePool (AliasLower);
3437 return (AddBufferToFreeList(RetVal));
3438 }
3439 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3440 }
3441
3442 /**
3443 Changes a shell command alias.
3444
3445 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3446
3447 this function does not check for built in alias'.
3448
3449 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3450 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3451 Command refers to an alias, that alias will be deleted.
3452 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3453 Alias being set will be stored in a non-volatile fashion.
3454
3455 @retval EFI_SUCCESS Alias created or deleted successfully.
3456 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3457 **/
3458 EFI_STATUS
3459 InternalSetAlias(
3460 IN CONST CHAR16 *Command,
3461 IN CONST CHAR16 *Alias,
3462 IN BOOLEAN Volatile
3463 )
3464 {
3465 EFI_STATUS Status;
3466 CHAR16 *AliasLower;
3467 BOOLEAN DeleteAlias;
3468
3469 DeleteAlias = FALSE;
3470 if (Alias == NULL) {
3471 //
3472 // We must be trying to remove one if Alias is NULL
3473 // remove an alias (but passed in COMMAND parameter)
3474 //
3475 Alias = Command;
3476 DeleteAlias = TRUE;
3477 }
3478 ASSERT (Alias != NULL);
3479
3480 //
3481 // Convert to lowercase to make aliases case-insensitive
3482 //
3483 AliasLower = AllocateCopyPool (StrSize (Alias), Alias);
3484 if (AliasLower == NULL) {
3485 return EFI_OUT_OF_RESOURCES;
3486 }
3487 ToLower (AliasLower);
3488
3489 if (DeleteAlias) {
3490 Status = gRT->SetVariable (AliasLower, &gShellAliasGuid, 0, 0, NULL);
3491 } else {
3492 Status = gRT->SetVariable (
3493 AliasLower, &gShellAliasGuid,
3494 EFI_VARIABLE_BOOTSERVICE_ACCESS | (Volatile ? 0 : EFI_VARIABLE_NON_VOLATILE),
3495 StrSize (Command), (VOID *) Command
3496 );
3497 }
3498
3499 FreePool (AliasLower);
3500
3501 return Status;
3502 }
3503
3504 /**
3505 Changes a shell command alias.
3506
3507 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3508
3509
3510 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3511 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3512 Command refers to an alias, that alias will be deleted.
3513 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3514 FALSE and the alias already exists, then the existing alias is unchanged and
3515 EFI_ACCESS_DENIED is returned.
3516 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3517 Alias being set will be stored in a non-volatile fashion.
3518
3519 @retval EFI_SUCCESS Alias created or deleted successfully.
3520 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3521 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3522 FALSE.
3523 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3524 **/
3525 EFI_STATUS
3526 EFIAPI
3527 EfiShellSetAlias(
3528 IN CONST CHAR16 *Command,
3529 IN CONST CHAR16 *Alias,
3530 IN BOOLEAN Replace,
3531 IN BOOLEAN Volatile
3532 )
3533 {
3534 if (ShellCommandIsOnAliasList(Alias==NULL?Command:Alias)) {
3535 //
3536 // cant set over a built in alias
3537 //
3538 return (EFI_ACCESS_DENIED);
3539 } else if (Command == NULL || *Command == CHAR_NULL || StrLen(Command) == 0) {
3540 //
3541 // Command is null or empty
3542 //
3543 return (EFI_INVALID_PARAMETER);
3544 } else if (EfiShellGetAlias(Command, NULL) != NULL && !Replace) {
3545 //
3546 // Alias already exists, Replace not set
3547 //
3548 return (EFI_ACCESS_DENIED);
3549 } else {
3550 return (InternalSetAlias(Command, Alias, Volatile));
3551 }
3552 }
3553
3554 // Pure FILE_HANDLE operations are passed to FileHandleLib
3555 // these functions are indicated by the *
3556 EFI_SHELL_PROTOCOL mShellProtocol = {
3557 EfiShellExecute,
3558 EfiShellGetEnv,
3559 EfiShellSetEnv,
3560 EfiShellGetAlias,
3561 EfiShellSetAlias,
3562 EfiShellGetHelpText,
3563 EfiShellGetDevicePathFromMap,
3564 EfiShellGetMapFromDevicePath,
3565 EfiShellGetDevicePathFromFilePath,
3566 EfiShellGetFilePathFromDevicePath,
3567 EfiShellSetMap,
3568 EfiShellGetCurDir,
3569 EfiShellSetCurDir,
3570 EfiShellOpenFileList,
3571 EfiShellFreeFileList,
3572 EfiShellRemoveDupInFileList,
3573 EfiShellBatchIsActive,
3574 EfiShellIsRootShell,
3575 EfiShellEnablePageBreak,
3576 EfiShellDisablePageBreak,
3577 EfiShellGetPageBreak,
3578 EfiShellGetDeviceName,
3579 (EFI_SHELL_GET_FILE_INFO)FileHandleGetInfo, //*
3580 (EFI_SHELL_SET_FILE_INFO)FileHandleSetInfo, //*
3581 EfiShellOpenFileByName,
3582 EfiShellClose,
3583 EfiShellCreateFile,
3584 (EFI_SHELL_READ_FILE)FileHandleRead, //*
3585 (EFI_SHELL_WRITE_FILE)FileHandleWrite, //*
3586 (EFI_SHELL_DELETE_FILE)FileHandleDelete, //*
3587 EfiShellDeleteFileByName,
3588 (EFI_SHELL_GET_FILE_POSITION)FileHandleGetPosition, //*
3589 (EFI_SHELL_SET_FILE_POSITION)FileHandleSetPosition, //*
3590 (EFI_SHELL_FLUSH_FILE)FileHandleFlush, //*
3591 EfiShellFindFiles,
3592 EfiShellFindFilesInDir,
3593 (EFI_SHELL_GET_FILE_SIZE)FileHandleGetSize, //*
3594 EfiShellOpenRoot,
3595 EfiShellOpenRootByHandle,
3596 NULL,
3597 SHELL_MAJOR_VERSION,
3598 SHELL_MINOR_VERSION,
3599
3600 // New for UEFI Shell 2.1
3601 EfiShellRegisterGuidName,
3602 EfiShellGetGuidName,
3603 EfiShellGetGuidFromName,
3604 EfiShellGetEnvEx
3605 };
3606
3607 /**
3608 Function to create and install on the current handle.
3609
3610 Will overwrite any existing ShellProtocols in the system to be sure that
3611 the current shell is in control.
3612
3613 This must be removed via calling CleanUpShellProtocol().
3614
3615 @param[in, out] NewShell The pointer to the pointer to the structure
3616 to install.
3617
3618 @retval EFI_SUCCESS The operation was successful.
3619 @return An error from LocateHandle, CreateEvent, or other core function.
3620 **/
3621 EFI_STATUS
3622 CreatePopulateInstallShellProtocol (
3623 IN OUT EFI_SHELL_PROTOCOL **NewShell
3624 )
3625 {
3626 EFI_STATUS Status;
3627 UINTN BufferSize;
3628 EFI_HANDLE *Buffer;
3629 UINTN HandleCounter;
3630 SHELL_PROTOCOL_HANDLE_LIST *OldProtocolNode;
3631 EFI_SHELL_PROTOCOL *OldShell;
3632
3633 if (NewShell == NULL) {
3634 return (EFI_INVALID_PARAMETER);
3635 }
3636
3637 BufferSize = 0;
3638 Buffer = NULL;
3639 OldProtocolNode = NULL;
3640 InitializeListHead(&ShellInfoObject.OldShellList.Link);
3641
3642 //
3643 // Initialize EfiShellProtocol object...
3644 //
3645 Status = gBS->CreateEvent(0,
3646 0,
3647 NULL,
3648 NULL,
3649 &mShellProtocol.ExecutionBreak);
3650 if (EFI_ERROR(Status)) {
3651 return (Status);
3652 }
3653
3654 //
3655 // Get the size of the buffer we need.
3656 //
3657 Status = gBS->LocateHandle(ByProtocol,
3658 &gEfiShellProtocolGuid,
3659 NULL,
3660 &BufferSize,
3661 Buffer);
3662 if (Status == EFI_BUFFER_TOO_SMALL) {
3663 //
3664 // Allocate and recall with buffer of correct size
3665 //
3666 Buffer = AllocateZeroPool(BufferSize);
3667 if (Buffer == NULL) {
3668 return (EFI_OUT_OF_RESOURCES);
3669 }
3670 Status = gBS->LocateHandle(ByProtocol,
3671 &gEfiShellProtocolGuid,
3672 NULL,
3673 &BufferSize,
3674 Buffer);
3675 if (EFI_ERROR(Status)) {
3676 FreePool(Buffer);
3677 return (Status);
3678 }
3679 //
3680 // now overwrite each of them, but save the info to restore when we end.
3681 //
3682 for (HandleCounter = 0 ; HandleCounter < (BufferSize/sizeof(EFI_HANDLE)) ; HandleCounter++) {
3683 Status = gBS->OpenProtocol(Buffer[HandleCounter],
3684 &gEfiShellProtocolGuid,
3685 (VOID **) &OldShell,
3686 gImageHandle,
3687 NULL,
3688 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3689 );
3690 if (!EFI_ERROR(Status)) {
3691 OldProtocolNode = AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST));
3692 if (OldProtocolNode == NULL) {
3693 if (!IsListEmpty (&ShellInfoObject.OldShellList.Link)) {
3694 CleanUpShellProtocol (&mShellProtocol);
3695 }
3696 Status = EFI_OUT_OF_RESOURCES;
3697 break;
3698 }
3699 //
3700 // reinstall over the old one...
3701 //
3702 OldProtocolNode->Handle = Buffer[HandleCounter];
3703 OldProtocolNode->Interface = OldShell;
3704 Status = gBS->ReinstallProtocolInterface(
3705 OldProtocolNode->Handle,
3706 &gEfiShellProtocolGuid,
3707 OldProtocolNode->Interface,
3708 (VOID*)(&mShellProtocol));
3709 if (!EFI_ERROR(Status)) {
3710 //
3711 // we reinstalled sucessfully. log this so we can reverse it later.
3712 //
3713