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