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