VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellProtocol.c@ 58466

Last change on this file since 58466 was 58466, checked in by vboxsync, 9 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette