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