]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - ShellPkg/Application/Shell/Shell.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
NetworkPkg: Update Http driver to use DPC mechanism.
[mirror_edk2.git] / ShellPkg / Application / Shell / Shell.c
... / ...
CommitLineData
1/** @file\r
2 This is THE shell (application)\r
3\r
4 Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
5 (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P.<BR>\r
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
17\r
18//\r
19// Initialize the global structure\r
20//\r
21SHELL_INFO ShellInfoObject = {\r
22 NULL,\r
23 NULL,\r
24 FALSE,\r
25 FALSE,\r
26 {\r
27 {{\r
28 0,\r
29 0,\r
30 0,\r
31 0,\r
32 0,\r
33 0,\r
34 0,\r
35 0,\r
36 0\r
37 }},\r
38 0,\r
39 NULL,\r
40 NULL\r
41 },\r
42 {{NULL, NULL}, NULL},\r
43 {\r
44 {{NULL, NULL}, NULL},\r
45 0,\r
46 0,\r
47 TRUE\r
48 },\r
49 NULL,\r
50 0,\r
51 NULL,\r
52 NULL,\r
53 NULL,\r
54 NULL,\r
55 NULL,\r
56 {{NULL, NULL}, NULL, NULL},\r
57 {{NULL, NULL}, NULL, NULL},\r
58 NULL,\r
59 NULL,\r
60 NULL,\r
61 NULL,\r
62 NULL,\r
63 NULL,\r
64 NULL,\r
65 NULL,\r
66 FALSE\r
67};\r
68\r
69STATIC CONST CHAR16 mScriptExtension[] = L".NSH";\r
70STATIC CONST CHAR16 mExecutableExtensions[] = L".NSH;.EFI";\r
71STATIC CONST CHAR16 mStartupScript[] = L"startup.nsh";\r
72\r
73/**\r
74 Cleans off leading and trailing spaces and tabs.\r
75\r
76 @param[in] String pointer to the string to trim them off.\r
77**/\r
78EFI_STATUS\r
79EFIAPI\r
80TrimSpaces(\r
81 IN CHAR16 **String\r
82 )\r
83{\r
84 ASSERT(String != NULL);\r
85 ASSERT(*String!= NULL);\r
86 //\r
87 // Remove any spaces and tabs at the beginning of the (*String).\r
88 //\r
89 while (((*String)[0] == L' ') || ((*String)[0] == L'\t')) {\r
90 CopyMem((*String), (*String)+1, StrSize((*String)) - sizeof((*String)[0]));\r
91 }\r
92\r
93 //\r
94 // Remove any spaces and tabs at the end of the (*String).\r
95 //\r
96 while ((StrLen (*String) > 0) && (((*String)[StrLen((*String))-1] == L' ') || ((*String)[StrLen((*String))-1] == L'\t'))) {\r
97 (*String)[StrLen((*String))-1] = CHAR_NULL;\r
98 }\r
99\r
100 return (EFI_SUCCESS);\r
101}\r
102\r
103/**\r
104 Parse for the next instance of one string within another string. Can optionally make sure that \r
105 the string was not escaped (^ character) per the shell specification.\r
106\r
107 @param[in] SourceString The string to search within\r
108 @param[in] FindString The string to look for\r
109 @param[in] CheckForEscapeCharacter TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances\r
110**/\r
111CHAR16*\r
112EFIAPI\r
113FindNextInstance(\r
114 IN CONST CHAR16 *SourceString,\r
115 IN CONST CHAR16 *FindString,\r
116 IN CONST BOOLEAN CheckForEscapeCharacter\r
117 )\r
118{\r
119 CHAR16 *Temp;\r
120 if (SourceString == NULL) {\r
121 return (NULL);\r
122 }\r
123 Temp = StrStr(SourceString, FindString);\r
124\r
125 //\r
126 // If nothing found, or we don't care about escape characters\r
127 //\r
128 if (Temp == NULL || !CheckForEscapeCharacter) {\r
129 return (Temp);\r
130 }\r
131\r
132 //\r
133 // If we found an escaped character, try again on the remainder of the string\r
134 //\r
135 if ((Temp > (SourceString)) && *(Temp-1) == L'^') {\r
136 return FindNextInstance(Temp+1, FindString, CheckForEscapeCharacter);\r
137 }\r
138\r
139 //\r
140 // we found the right character\r
141 //\r
142 return (Temp);\r
143}\r
144\r
145/**\r
146 Check whether the string between a pair of % is a valid environment variable name.\r
147\r
148 @param[in] BeginPercent pointer to the first percent.\r
149 @param[in] EndPercent pointer to the last percent.\r
150\r
151 @retval TRUE is a valid environment variable name.\r
152 @retval FALSE is NOT a valid environment variable name.\r
153**/\r
154BOOLEAN\r
155IsValidEnvironmentVariableName(\r
156 IN CONST CHAR16 *BeginPercent,\r
157 IN CONST CHAR16 *EndPercent\r
158 )\r
159{\r
160 CONST CHAR16 *Walker;\r
161 \r
162 Walker = NULL;\r
163\r
164 ASSERT (BeginPercent != NULL);\r
165 ASSERT (EndPercent != NULL);\r
166 ASSERT (BeginPercent < EndPercent);\r
167 \r
168 if ((BeginPercent + 1) == EndPercent) {\r
169 return FALSE;\r
170 }\r
171\r
172 for (Walker = BeginPercent + 1; Walker < EndPercent; Walker++) {\r
173 if (\r
174 (*Walker >= L'0' && *Walker <= L'9') ||\r
175 (*Walker >= L'A' && *Walker <= L'Z') ||\r
176 (*Walker >= L'a' && *Walker <= L'z') ||\r
177 (*Walker == L'_')\r
178 ) {\r
179 if (Walker == BeginPercent + 1 && (*Walker >= L'0' && *Walker <= L'9')) {\r
180 return FALSE;\r
181 } else {\r
182 continue;\r
183 }\r
184 } else {\r
185 return FALSE;\r
186 }\r
187 }\r
188\r
189 return TRUE;\r
190}\r
191\r
192/**\r
193 Determine if a command line contains a split operation\r
194\r
195 @param[in] CmdLine The command line to parse.\r
196\r
197 @retval TRUE CmdLine has a valid split.\r
198 @retval FALSE CmdLine does not have a valid split.\r
199**/\r
200BOOLEAN\r
201EFIAPI\r
202ContainsSplit(\r
203 IN CONST CHAR16 *CmdLine\r
204 )\r
205{\r
206 CONST CHAR16 *TempSpot;\r
207 CONST CHAR16 *FirstQuote;\r
208 CONST CHAR16 *SecondQuote;\r
209\r
210 FirstQuote = FindNextInstance (CmdLine, L"\"", TRUE);\r
211 SecondQuote = NULL;\r
212 TempSpot = FindFirstCharacter(CmdLine, L"|", L'^');\r
213\r
214 if (FirstQuote == NULL || \r
215 TempSpot == NULL || \r
216 TempSpot == CHAR_NULL || \r
217 FirstQuote > TempSpot\r
218 ) {\r
219 return (BOOLEAN) ((TempSpot != NULL) && (*TempSpot != CHAR_NULL));\r
220 }\r
221\r
222 while ((TempSpot != NULL) && (*TempSpot != CHAR_NULL)) {\r
223 if (FirstQuote == NULL || FirstQuote > TempSpot) {\r
224 break;\r
225 } \r
226 SecondQuote = FindNextInstance (FirstQuote + 1, L"\"", TRUE);\r
227 if (SecondQuote == NULL) {\r
228 break;\r
229 }\r
230 if (SecondQuote < TempSpot) {\r
231 FirstQuote = FindNextInstance (SecondQuote + 1, L"\"", TRUE);\r
232 continue;\r
233 } else {\r
234 FirstQuote = FindNextInstance (SecondQuote + 1, L"\"", TRUE);\r
235 TempSpot = FindFirstCharacter(TempSpot + 1, L"|", L'^');\r
236 continue;\r
237 } \r
238 }\r
239 \r
240 return (BOOLEAN) ((TempSpot != NULL) && (*TempSpot != CHAR_NULL));\r
241}\r
242\r
243/**\r
244 Function to start monitoring for CTRL-S using SimpleTextInputEx. This \r
245 feature's enabled state was not known when the shell initially launched.\r
246\r
247 @retval EFI_SUCCESS The feature is enabled.\r
248 @retval EFI_OUT_OF_RESOURCES There is not enough memory available.\r
249**/\r
250EFI_STATUS\r
251EFIAPI\r
252InternalEfiShellStartCtrlSMonitor(\r
253 VOID\r
254 )\r
255{\r
256 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;\r
257 EFI_KEY_DATA KeyData;\r
258 EFI_STATUS Status;\r
259\r
260 Status = gBS->OpenProtocol(\r
261 gST->ConsoleInHandle,\r
262 &gEfiSimpleTextInputExProtocolGuid,\r
263 (VOID**)&SimpleEx,\r
264 gImageHandle,\r
265 NULL,\r
266 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
267 if (EFI_ERROR(Status)) {\r
268 ShellPrintHiiEx(\r
269 -1, \r
270 -1, \r
271 NULL,\r
272 STRING_TOKEN (STR_SHELL_NO_IN_EX),\r
273 ShellInfoObject.HiiHandle);\r
274 return (EFI_SUCCESS);\r
275 }\r
276\r
277 KeyData.KeyState.KeyToggleState = 0;\r
278 KeyData.Key.ScanCode = 0;\r
279 KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;\r
280 KeyData.Key.UnicodeChar = L's';\r
281\r
282 Status = SimpleEx->RegisterKeyNotify(\r
283 SimpleEx,\r
284 &KeyData,\r
285 NotificationFunction,\r
286 &ShellInfoObject.CtrlSNotifyHandle1);\r
287 \r
288 KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;\r
289 if (!EFI_ERROR(Status)) {\r
290 Status = SimpleEx->RegisterKeyNotify(\r
291 SimpleEx,\r
292 &KeyData,\r
293 NotificationFunction,\r
294 &ShellInfoObject.CtrlSNotifyHandle2);\r
295 }\r
296 KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;\r
297 KeyData.Key.UnicodeChar = 19;\r
298\r
299 if (!EFI_ERROR(Status)) {\r
300 Status = SimpleEx->RegisterKeyNotify(\r
301 SimpleEx,\r
302 &KeyData,\r
303 NotificationFunction,\r
304 &ShellInfoObject.CtrlSNotifyHandle3);\r
305 } \r
306 KeyData.KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;\r
307 if (!EFI_ERROR(Status)) {\r
308 Status = SimpleEx->RegisterKeyNotify(\r
309 SimpleEx,\r
310 &KeyData,\r
311 NotificationFunction,\r
312 &ShellInfoObject.CtrlSNotifyHandle4);\r
313 }\r
314 return (Status);\r
315}\r
316\r
317\r
318\r
319/**\r
320 The entry point for the application.\r
321\r
322 @param[in] ImageHandle The firmware allocated handle for the EFI image.\r
323 @param[in] SystemTable A pointer to the EFI System Table.\r
324\r
325 @retval EFI_SUCCESS The entry point is executed successfully.\r
326 @retval other Some error occurs when executing this entry point.\r
327\r
328**/\r
329EFI_STATUS\r
330EFIAPI\r
331UefiMain (\r
332 IN EFI_HANDLE ImageHandle,\r
333 IN EFI_SYSTEM_TABLE *SystemTable\r
334 )\r
335{\r
336 EFI_STATUS Status;\r
337 CHAR16 *TempString;\r
338 UINTN Size;\r
339 EFI_HANDLE ConInHandle;\r
340 EFI_SIMPLE_TEXT_INPUT_PROTOCOL *OldConIn;\r
341\r
342 if (PcdGet8(PcdShellSupportLevel) > 3) {\r
343 return (EFI_UNSUPPORTED);\r
344 }\r
345\r
346 //\r
347 // Clear the screen\r
348 //\r
349 Status = gST->ConOut->ClearScreen(gST->ConOut);\r
350 if (EFI_ERROR(Status)) {\r
351 return (Status);\r
352 }\r
353\r
354 //\r
355 // Populate the global structure from PCDs\r
356 //\r
357 ShellInfoObject.ImageDevPath = NULL;\r
358 ShellInfoObject.FileDevPath = NULL;\r
359 ShellInfoObject.PageBreakEnabled = PcdGetBool(PcdShellPageBreakDefault);\r
360 ShellInfoObject.ViewingSettings.InsertMode = PcdGetBool(PcdShellInsertModeDefault);\r
361 ShellInfoObject.LogScreenCount = PcdGet8 (PcdShellScreenLogCount );\r
362\r
363 //\r
364 // verify we dont allow for spec violation\r
365 //\r
366 ASSERT(ShellInfoObject.LogScreenCount >= 3);\r
367\r
368 //\r
369 // Initialize the LIST ENTRY objects...\r
370 //\r
371 InitializeListHead(&ShellInfoObject.BufferToFreeList.Link);\r
372 InitializeListHead(&ShellInfoObject.ViewingSettings.CommandHistory.Link);\r
373 InitializeListHead(&ShellInfoObject.SplitList.Link);\r
374\r
375 //\r
376 // Check PCDs for optional features that are not implemented yet.\r
377 //\r
378 if ( PcdGetBool(PcdShellSupportOldProtocols)\r
379 || !FeaturePcdGet(PcdShellRequireHiiPlatform)\r
380 || FeaturePcdGet(PcdShellSupportFrameworkHii)\r
381 ) {\r
382 return (EFI_UNSUPPORTED);\r
383 }\r
384\r
385 //\r
386 // turn off the watchdog timer\r
387 //\r
388 gBS->SetWatchdogTimer (0, 0, 0, NULL);\r
389\r
390 //\r
391 // install our console logger. This will keep a log of the output for back-browsing\r
392 //\r
393 Status = ConsoleLoggerInstall(ShellInfoObject.LogScreenCount, &ShellInfoObject.ConsoleInfo);\r
394 if (!EFI_ERROR(Status)) {\r
395 //\r
396 // Enable the cursor to be visible\r
397 //\r
398 gST->ConOut->EnableCursor (gST->ConOut, TRUE);\r
399\r
400 //\r
401 // If supporting EFI 1.1 we need to install HII protocol\r
402 // only do this if PcdShellRequireHiiPlatform == FALSE\r
403 //\r
404 // remove EFI_UNSUPPORTED check above when complete.\r
405 ///@todo add support for Framework HII\r
406\r
407 //\r
408 // install our (solitary) HII package\r
409 //\r
410 ShellInfoObject.HiiHandle = HiiAddPackages (&gEfiCallerIdGuid, gImageHandle, ShellStrings, NULL);\r
411 if (ShellInfoObject.HiiHandle == NULL) {\r
412 if (PcdGetBool(PcdShellSupportFrameworkHii)) {\r
413 ///@todo Add our package into Framework HII\r
414 }\r
415 if (ShellInfoObject.HiiHandle == NULL) {\r
416 Status = EFI_NOT_STARTED;\r
417 goto FreeResources;\r
418 }\r
419 }\r
420\r
421 //\r
422 // create and install the EfiShellParametersProtocol\r
423 //\r
424 Status = CreatePopulateInstallShellParametersProtocol(&ShellInfoObject.NewShellParametersProtocol, &ShellInfoObject.RootShellInstance);\r
425 ASSERT_EFI_ERROR(Status);\r
426 ASSERT(ShellInfoObject.NewShellParametersProtocol != NULL);\r
427\r
428 //\r
429 // create and install the EfiShellProtocol\r
430 //\r
431 Status = CreatePopulateInstallShellProtocol(&ShellInfoObject.NewEfiShellProtocol);\r
432 ASSERT_EFI_ERROR(Status);\r
433 ASSERT(ShellInfoObject.NewEfiShellProtocol != NULL);\r
434\r
435 //\r
436 // Now initialize the shell library (it requires Shell Parameters protocol)\r
437 //\r
438 Status = ShellInitialize();\r
439 ASSERT_EFI_ERROR(Status);\r
440\r
441 Status = CommandInit();\r
442 ASSERT_EFI_ERROR(Status);\r
443\r
444 //\r
445 // Check the command line\r
446 //\r
447 Status = ProcessCommandLine ();\r
448 if (EFI_ERROR (Status)) {\r
449 goto FreeResources;\r
450 }\r
451\r
452 //\r
453 // If shell support level is >= 1 create the mappings and paths\r
454 //\r
455 if (PcdGet8(PcdShellSupportLevel) >= 1) {\r
456 Status = ShellCommandCreateInitialMappingsAndPaths();\r
457 }\r
458\r
459 //\r
460 // save the device path for the loaded image and the device path for the filepath (under loaded image)\r
461 // These are where to look for the startup.nsh file\r
462 //\r
463 Status = GetDevicePathsForImageAndFile(&ShellInfoObject.ImageDevPath, &ShellInfoObject.FileDevPath);\r
464 ASSERT_EFI_ERROR(Status);\r
465\r
466 //\r
467 // Display the version\r
468 //\r
469 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion) {\r
470 ShellPrintHiiEx (\r
471 0,\r
472 gST->ConOut->Mode->CursorRow,\r
473 NULL,\r
474 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SHELL),\r
475 ShellInfoObject.HiiHandle,\r
476 SupportLevel[PcdGet8(PcdShellSupportLevel)],\r
477 gEfiShellProtocol->MajorVersion,\r
478 gEfiShellProtocol->MinorVersion\r
479 );\r
480\r
481 ShellPrintHiiEx (\r
482 -1,\r
483 -1,\r
484 NULL,\r
485 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SUPPLIER),\r
486 ShellInfoObject.HiiHandle,\r
487 (CHAR16 *) PcdGetPtr (PcdShellSupplier)\r
488 );\r
489\r
490 ShellPrintHiiEx (\r
491 -1,\r
492 -1,\r
493 NULL,\r
494 STRING_TOKEN (STR_VER_OUTPUT_MAIN_UEFI),\r
495 ShellInfoObject.HiiHandle,\r
496 (gST->Hdr.Revision&0xffff0000)>>16,\r
497 (gST->Hdr.Revision&0x0000ffff),\r
498 gST->FirmwareVendor,\r
499 gST->FirmwareRevision\r
500 );\r
501 }\r
502\r
503 //\r
504 // Display the mapping\r
505 //\r
506 if (PcdGet8(PcdShellSupportLevel) >= 2 && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap) {\r
507 Status = RunCommand(L"map");\r
508 ASSERT_EFI_ERROR(Status);\r
509 }\r
510\r
511 //\r
512 // init all the built in alias'\r
513 //\r
514 Status = SetBuiltInAlias();\r
515 ASSERT_EFI_ERROR(Status);\r
516\r
517 //\r
518 // Initialize environment variables\r
519 //\r
520 if (ShellCommandGetProfileList() != NULL) {\r
521 Status = InternalEfiShellSetEnv(L"profiles", ShellCommandGetProfileList(), TRUE);\r
522 ASSERT_EFI_ERROR(Status);\r
523 }\r
524\r
525 Size = 100;\r
526 TempString = AllocateZeroPool(Size);\r
527\r
528 UnicodeSPrint(TempString, Size, L"%d", PcdGet8(PcdShellSupportLevel));\r
529 Status = InternalEfiShellSetEnv(L"uefishellsupport", TempString, TRUE);\r
530 ASSERT_EFI_ERROR(Status);\r
531\r
532 UnicodeSPrint(TempString, Size, L"%d.%d", ShellInfoObject.NewEfiShellProtocol->MajorVersion, ShellInfoObject.NewEfiShellProtocol->MinorVersion);\r
533 Status = InternalEfiShellSetEnv(L"uefishellversion", TempString, TRUE);\r
534 ASSERT_EFI_ERROR(Status);\r
535\r
536 UnicodeSPrint(TempString, Size, L"%d.%d", (gST->Hdr.Revision & 0xFFFF0000) >> 16, gST->Hdr.Revision & 0x0000FFFF);\r
537 Status = InternalEfiShellSetEnv(L"uefiversion", TempString, TRUE);\r
538 ASSERT_EFI_ERROR(Status);\r
539\r
540 FreePool(TempString);\r
541\r
542 if (!EFI_ERROR(Status)) {\r
543 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt) {\r
544 //\r
545 // Set up the event for CTRL-C monitoring...\r
546 //\r
547 Status = InernalEfiShellStartMonitor();\r
548 }\r
549\r
550 if (!EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {\r
551 //\r
552 // Set up the event for CTRL-S monitoring...\r
553 //\r
554 Status = InternalEfiShellStartCtrlSMonitor();\r
555 }\r
556\r
557 if (!EFI_ERROR(Status) && ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {\r
558 //\r
559 // close off the gST->ConIn\r
560 //\r
561 OldConIn = gST->ConIn;\r
562 ConInHandle = gST->ConsoleInHandle;\r
563 gST->ConIn = CreateSimpleTextInOnFile((SHELL_FILE_HANDLE)&FileInterfaceNulFile, &gST->ConsoleInHandle);\r
564 } else {\r
565 OldConIn = NULL;\r
566 ConInHandle = NULL;\r
567 }\r
568\r
569 if (!EFI_ERROR(Status) && PcdGet8(PcdShellSupportLevel) >= 1) {\r
570 //\r
571 // process the startup script or launch the called app.\r
572 //\r
573 Status = DoStartupScript(ShellInfoObject.ImageDevPath, ShellInfoObject.FileDevPath);\r
574 }\r
575\r
576 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit && !ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel) >= 3 || PcdGetBool(PcdShellForceConsole)) && !EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {\r
577 //\r
578 // begin the UI waiting loop\r
579 //\r
580 do {\r
581 //\r
582 // clean out all the memory allocated for CONST <something> * return values\r
583 // between each shell prompt presentation\r
584 //\r
585 if (!IsListEmpty(&ShellInfoObject.BufferToFreeList.Link)){\r
586 FreeBufferList(&ShellInfoObject.BufferToFreeList);\r
587 }\r
588\r
589 //\r
590 // Reset page break back to default.\r
591 //\r
592 ShellInfoObject.PageBreakEnabled = PcdGetBool(PcdShellPageBreakDefault);\r
593 ASSERT (ShellInfoObject.ConsoleInfo != NULL);\r
594 ShellInfoObject.ConsoleInfo->Enabled = TRUE;\r
595 ShellInfoObject.ConsoleInfo->RowCounter = 0;\r
596\r
597 //\r
598 // Reset the CTRL-C event (yes we ignore the return values)\r
599 //\r
600 Status = gBS->CheckEvent (ShellInfoObject.NewEfiShellProtocol->ExecutionBreak);\r
601\r
602 //\r
603 // Display Prompt\r
604 //\r
605 Status = DoShellPrompt();\r
606 } while (!ShellCommandGetExit());\r
607 }\r
608 if (OldConIn != NULL && ConInHandle != NULL) {\r
609 CloseSimpleTextInOnFile (gST->ConIn);\r
610 gST->ConIn = OldConIn;\r
611 gST->ConsoleInHandle = ConInHandle;\r
612 }\r
613 }\r
614 }\r
615\r
616FreeResources:\r
617 //\r
618 // uninstall protocols / free memory / etc...\r
619 //\r
620 if (ShellInfoObject.UserBreakTimer != NULL) {\r
621 gBS->CloseEvent(ShellInfoObject.UserBreakTimer);\r
622 DEBUG_CODE(ShellInfoObject.UserBreakTimer = NULL;);\r
623 }\r
624 if (ShellInfoObject.ImageDevPath != NULL) {\r
625 FreePool(ShellInfoObject.ImageDevPath);\r
626 DEBUG_CODE(ShellInfoObject.ImageDevPath = NULL;);\r
627 }\r
628 if (ShellInfoObject.FileDevPath != NULL) {\r
629 FreePool(ShellInfoObject.FileDevPath);\r
630 DEBUG_CODE(ShellInfoObject.FileDevPath = NULL;);\r
631 }\r
632 if (ShellInfoObject.NewShellParametersProtocol != NULL) {\r
633 CleanUpShellParametersProtocol(ShellInfoObject.NewShellParametersProtocol);\r
634 DEBUG_CODE(ShellInfoObject.NewShellParametersProtocol = NULL;);\r
635 }\r
636 if (ShellInfoObject.NewEfiShellProtocol != NULL){\r
637 if (ShellInfoObject.NewEfiShellProtocol->IsRootShell()){\r
638 InternalEfiShellSetEnv(L"cwd", NULL, TRUE);\r
639 }\r
640 CleanUpShellProtocol(ShellInfoObject.NewEfiShellProtocol);\r
641 DEBUG_CODE(ShellInfoObject.NewEfiShellProtocol = NULL;);\r
642 }\r
643\r
644 if (!IsListEmpty(&ShellInfoObject.BufferToFreeList.Link)){\r
645 FreeBufferList(&ShellInfoObject.BufferToFreeList);\r
646 }\r
647\r
648 if (!IsListEmpty(&ShellInfoObject.SplitList.Link)){\r
649 ASSERT(FALSE); ///@todo finish this de-allocation.\r
650 }\r
651\r
652 if (ShellInfoObject.ShellInitSettings.FileName != NULL) {\r
653 FreePool(ShellInfoObject.ShellInitSettings.FileName);\r
654 DEBUG_CODE(ShellInfoObject.ShellInitSettings.FileName = NULL;);\r
655 }\r
656\r
657 if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {\r
658 FreePool(ShellInfoObject.ShellInitSettings.FileOptions);\r
659 DEBUG_CODE(ShellInfoObject.ShellInitSettings.FileOptions = NULL;);\r
660 }\r
661\r
662 if (ShellInfoObject.HiiHandle != NULL) {\r
663 HiiRemovePackages(ShellInfoObject.HiiHandle);\r
664 DEBUG_CODE(ShellInfoObject.HiiHandle = NULL;);\r
665 }\r
666\r
667 if (!IsListEmpty(&ShellInfoObject.ViewingSettings.CommandHistory.Link)){\r
668 FreeBufferList(&ShellInfoObject.ViewingSettings.CommandHistory);\r
669 }\r
670\r
671 ASSERT(ShellInfoObject.ConsoleInfo != NULL);\r
672 if (ShellInfoObject.ConsoleInfo != NULL) {\r
673 ConsoleLoggerUninstall(ShellInfoObject.ConsoleInfo);\r
674 FreePool(ShellInfoObject.ConsoleInfo);\r
675 DEBUG_CODE(ShellInfoObject.ConsoleInfo = NULL;);\r
676 }\r
677\r
678 if (ShellCommandGetExit()) {\r
679 return ((EFI_STATUS)ShellCommandGetExitCode());\r
680 }\r
681 return (Status);\r
682}\r
683\r
684/**\r
685 Sets all the alias' that were registered with the ShellCommandLib library.\r
686\r
687 @retval EFI_SUCCESS all init commands were run successfully.\r
688**/\r
689EFI_STATUS\r
690EFIAPI\r
691SetBuiltInAlias(\r
692 )\r
693{\r
694 EFI_STATUS Status;\r
695 CONST ALIAS_LIST *List;\r
696 ALIAS_LIST *Node;\r
697\r
698 //\r
699 // Get all the commands we want to run\r
700 //\r
701 List = ShellCommandGetInitAliasList();\r
702\r
703 //\r
704 // for each command in the List\r
705 //\r
706 for ( Node = (ALIAS_LIST*)GetFirstNode(&List->Link)\r
707 ; !IsNull (&List->Link, &Node->Link)\r
708 ; Node = (ALIAS_LIST *)GetNextNode(&List->Link, &Node->Link)\r
709 ){\r
710 //\r
711 // install the alias'\r
712 //\r
713 Status = InternalSetAlias(Node->CommandString, Node->Alias, TRUE);\r
714 ASSERT_EFI_ERROR(Status);\r
715 }\r
716 return (EFI_SUCCESS);\r
717}\r
718\r
719/**\r
720 Internal function to determine if 2 command names are really the same.\r
721\r
722 @param[in] Command1 The pointer to the first command name.\r
723 @param[in] Command2 The pointer to the second command name.\r
724\r
725 @retval TRUE The 2 command names are the same.\r
726 @retval FALSE The 2 command names are not the same.\r
727**/\r
728BOOLEAN\r
729EFIAPI\r
730IsCommand(\r
731 IN CONST CHAR16 *Command1,\r
732 IN CONST CHAR16 *Command2\r
733 )\r
734{\r
735 if (StringNoCaseCompare(&Command1, &Command2) == 0) {\r
736 return (TRUE);\r
737 }\r
738 return (FALSE);\r
739}\r
740\r
741/**\r
742 Internal function to determine if a command is a script only command.\r
743\r
744 @param[in] CommandName The pointer to the command name.\r
745\r
746 @retval TRUE The command is a script only command.\r
747 @retval FALSE The command is not a script only command.\r
748**/\r
749BOOLEAN\r
750EFIAPI\r
751IsScriptOnlyCommand(\r
752 IN CONST CHAR16 *CommandName\r
753 )\r
754{\r
755 if (IsCommand(CommandName, L"for")\r
756 ||IsCommand(CommandName, L"endfor")\r
757 ||IsCommand(CommandName, L"if")\r
758 ||IsCommand(CommandName, L"else")\r
759 ||IsCommand(CommandName, L"endif")\r
760 ||IsCommand(CommandName, L"goto")) {\r
761 return (TRUE);\r
762 }\r
763 return (FALSE);\r
764}\r
765\r
766/**\r
767 This function will populate the 2 device path protocol parameters based on the\r
768 global gImageHandle. The DevPath will point to the device path for the handle that has\r
769 loaded image protocol installed on it. The FilePath will point to the device path\r
770 for the file that was loaded.\r
771\r
772 @param[in, out] DevPath On a successful return the device path to the loaded image.\r
773 @param[in, out] FilePath On a successful return the device path to the file.\r
774\r
775 @retval EFI_SUCCESS The 2 device paths were successfully returned.\r
776 @retval other A error from gBS->HandleProtocol.\r
777\r
778 @sa HandleProtocol\r
779**/\r
780EFI_STATUS\r
781EFIAPI\r
782GetDevicePathsForImageAndFile (\r
783 IN OUT EFI_DEVICE_PATH_PROTOCOL **DevPath,\r
784 IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath\r
785 )\r
786{\r
787 EFI_STATUS Status;\r
788 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;\r
789 EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;\r
790\r
791 ASSERT(DevPath != NULL);\r
792 ASSERT(FilePath != NULL);\r
793\r
794 Status = gBS->OpenProtocol (\r
795 gImageHandle,\r
796 &gEfiLoadedImageProtocolGuid,\r
797 (VOID**)&LoadedImage,\r
798 gImageHandle,\r
799 NULL,\r
800 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
801 );\r
802 if (!EFI_ERROR (Status)) {\r
803 Status = gBS->OpenProtocol (\r
804 LoadedImage->DeviceHandle,\r
805 &gEfiDevicePathProtocolGuid,\r
806 (VOID**)&ImageDevicePath,\r
807 gImageHandle,\r
808 NULL,\r
809 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
810 );\r
811 if (!EFI_ERROR (Status)) {\r
812 *DevPath = DuplicateDevicePath (ImageDevicePath);\r
813 *FilePath = DuplicateDevicePath (LoadedImage->FilePath);\r
814 gBS->CloseProtocol(\r
815 LoadedImage->DeviceHandle,\r
816 &gEfiDevicePathProtocolGuid,\r
817 gImageHandle,\r
818 NULL);\r
819 }\r
820 gBS->CloseProtocol(\r
821 gImageHandle,\r
822 &gEfiLoadedImageProtocolGuid,\r
823 gImageHandle,\r
824 NULL);\r
825 }\r
826 return (Status);\r
827}\r
828\r
829/**\r
830 Process all Uefi Shell 2.0 command line options.\r
831\r
832 see Uefi Shell 2.0 section 3.2 for full details.\r
833\r
834 the command line must resemble the following:\r
835\r
836 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]\r
837\r
838 ShellOpt-options Options which control the initialization behavior of the shell.\r
839 These options are read from the EFI global variable "ShellOpt"\r
840 and are processed before options or file-name.\r
841\r
842 options Options which control the initialization behavior of the shell.\r
843\r
844 file-name The name of a UEFI shell application or script to be executed\r
845 after initialization is complete. By default, if file-name is\r
846 specified, then -nostartup is implied. Scripts are not supported\r
847 by level 0.\r
848\r
849 file-name-options The command-line options that are passed to file-name when it\r
850 is invoked.\r
851\r
852 This will initialize the ShellInfoObject.ShellInitSettings global variable.\r
853\r
854 @retval EFI_SUCCESS The variable is initialized.\r
855**/\r
856EFI_STATUS\r
857EFIAPI\r
858ProcessCommandLine(\r
859 VOID\r
860 )\r
861{\r
862 UINTN Size;\r
863 UINTN LoopVar;\r
864 CHAR16 *CurrentArg;\r
865 CHAR16 *DelayValueStr;\r
866 UINT64 DelayValue;\r
867 EFI_STATUS Status;\r
868 EFI_UNICODE_COLLATION_PROTOCOL *UnicodeCollation;\r
869\r
870 // `file-name-options` will contain arguments to `file-name` that we don't\r
871 // know about. This would cause ShellCommandLineParse to error, so we parse\r
872 // arguments manually, ignoring those after the first thing that doesn't look\r
873 // like a shell option (which is assumed to be `file-name`).\r
874\r
875 Status = gBS->LocateProtocol (\r
876 &gEfiUnicodeCollationProtocolGuid,\r
877 NULL,\r
878 (VOID **) &UnicodeCollation\r
879 );\r
880 if (EFI_ERROR (Status)) {\r
881 return Status;\r
882 }\r
883\r
884 // Set default options\r
885 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup = FALSE;\r
886 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = FALSE;\r
887 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = FALSE;\r
888 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn = FALSE;\r
889 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt = FALSE;\r
890 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap = FALSE;\r
891 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion = FALSE;\r
892 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay = FALSE;\r
893 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit = FALSE;\r
894 ShellInfoObject.ShellInitSettings.Delay = 5;\r
895\r
896 //\r
897 // Start LoopVar at 0 to parse only optional arguments at Argv[0]\r
898 // and parse other parameters from Argv[1]. This is for use case that\r
899 // UEFI Shell boot option is created, and OptionalData is provided\r
900 // that starts with shell command-line options.\r
901 //\r
902 for (LoopVar = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {\r
903 CurrentArg = gEfiShellParametersProtocol->Argv[LoopVar];\r
904 if (UnicodeCollation->StriColl (\r
905 UnicodeCollation,\r
906 L"-startup",\r
907 CurrentArg\r
908 ) == 0) {\r
909 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup = TRUE;\r
910 }\r
911 else if (UnicodeCollation->StriColl (\r
912 UnicodeCollation,\r
913 L"-nostartup",\r
914 CurrentArg\r
915 ) == 0) {\r
916 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = TRUE;\r
917 }\r
918 else if (UnicodeCollation->StriColl (\r
919 UnicodeCollation,\r
920 L"-noconsoleout",\r
921 CurrentArg\r
922 ) == 0) {\r
923 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = TRUE;\r
924 }\r
925 else if (UnicodeCollation->StriColl (\r
926 UnicodeCollation,\r
927 L"-noconsolein",\r
928 CurrentArg\r
929 ) == 0) {\r
930 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn = TRUE;\r
931 }\r
932 else if (UnicodeCollation->StriColl (\r
933 UnicodeCollation,\r
934 L"-nointerrupt",\r
935 CurrentArg\r
936 ) == 0) {\r
937 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt = TRUE;\r
938 }\r
939 else if (UnicodeCollation->StriColl (\r
940 UnicodeCollation,\r
941 L"-nomap",\r
942 CurrentArg\r
943 ) == 0) {\r
944 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap = TRUE;\r
945 }\r
946 else if (UnicodeCollation->StriColl (\r
947 UnicodeCollation,\r
948 L"-noversion",\r
949 CurrentArg\r
950 ) == 0) {\r
951 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion = TRUE;\r
952 }\r
953 else if (UnicodeCollation->StriColl (\r
954 UnicodeCollation,\r
955 L"-delay",\r
956 CurrentArg\r
957 ) == 0) {\r
958 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay = TRUE;\r
959 // Check for optional delay value following "-delay"\r
960 DelayValueStr = gEfiShellParametersProtocol->Argv[LoopVar + 1];\r
961 if (DelayValueStr != NULL){\r
962 if (*DelayValueStr == L':') {\r
963 DelayValueStr++;\r
964 }\r
965 if (!EFI_ERROR(ShellConvertStringToUint64 (\r
966 DelayValueStr,\r
967 &DelayValue,\r
968 FALSE,\r
969 FALSE\r
970 ))) {\r
971 ShellInfoObject.ShellInitSettings.Delay = (UINTN)DelayValue;\r
972 LoopVar++;\r
973 }\r
974 }\r
975 } else if (UnicodeCollation->StriColl (\r
976 UnicodeCollation,\r
977 L"-_exit",\r
978 CurrentArg\r
979 ) == 0) {\r
980 ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit = TRUE;\r
981 } else if (StrnCmp (L"-", CurrentArg, 1) == 0) {\r
982 // Unrecognized option\r
983 ShellPrintHiiEx(-1, -1, NULL,\r
984 STRING_TOKEN (STR_GEN_PROBLEM),\r
985 ShellInfoObject.HiiHandle,\r
986 CurrentArg\r
987 );\r
988 return EFI_INVALID_PARAMETER;\r
989 } else {\r
990 //\r
991 // First argument should be Shell.efi image name\r
992 //\r
993 if (LoopVar == 0) {\r
994 continue;\r
995 }\r
996\r
997 ShellInfoObject.ShellInitSettings.FileName = AllocateCopyPool(StrSize(CurrentArg), CurrentArg);\r
998 if (ShellInfoObject.ShellInitSettings.FileName == NULL) {\r
999 return (EFI_OUT_OF_RESOURCES);\r
1000 }\r
1001 //\r
1002 // We found `file-name`.\r
1003 //\r
1004 ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = 1;\r
1005 LoopVar++;\r
1006\r
1007 // Add `file-name-options`\r
1008 for (Size = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {\r
1009 ASSERT((ShellInfoObject.ShellInitSettings.FileOptions == NULL && Size == 0) || (ShellInfoObject.ShellInitSettings.FileOptions != NULL));\r
1010 StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,\r
1011 &Size,\r
1012 L" ",\r
1013 0);\r
1014 if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {\r
1015 SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);\r
1016 return (EFI_OUT_OF_RESOURCES);\r
1017 }\r
1018 StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,\r
1019 &Size,\r
1020 gEfiShellParametersProtocol->Argv[LoopVar],\r
1021 0);\r
1022 if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {\r
1023 SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);\r
1024 return (EFI_OUT_OF_RESOURCES);\r
1025 }\r
1026 }\r
1027 }\r
1028 }\r
1029\r
1030 // "-nointerrupt" overrides "-delay"\r
1031 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt) {\r
1032 ShellInfoObject.ShellInitSettings.Delay = 0;\r
1033 }\r
1034\r
1035 return EFI_SUCCESS;\r
1036}\r
1037\r
1038/**\r
1039 Handles all interaction with the default startup script.\r
1040\r
1041 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.\r
1042\r
1043 @param ImagePath the path to the image for shell. first place to look for the startup script\r
1044 @param FilePath the path to the file for shell. second place to look for the startup script.\r
1045\r
1046 @retval EFI_SUCCESS the variable is initialized.\r
1047**/\r
1048EFI_STATUS\r
1049EFIAPI\r
1050DoStartupScript(\r
1051 IN EFI_DEVICE_PATH_PROTOCOL *ImagePath,\r
1052 IN EFI_DEVICE_PATH_PROTOCOL *FilePath\r
1053 )\r
1054{\r
1055 EFI_STATUS Status;\r
1056 UINTN Delay;\r
1057 EFI_INPUT_KEY Key;\r
1058 SHELL_FILE_HANDLE FileHandle;\r
1059 EFI_DEVICE_PATH_PROTOCOL *NewPath;\r
1060 EFI_DEVICE_PATH_PROTOCOL *NamePath;\r
1061 CHAR16 *FileStringPath;\r
1062 CHAR16 *TempSpot;\r
1063 UINTN NewSize;\r
1064 CONST CHAR16 *MapName;\r
1065\r
1066 Key.UnicodeChar = CHAR_NULL;\r
1067 Key.ScanCode = 0;\r
1068 FileHandle = NULL;\r
1069\r
1070 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup && ShellInfoObject.ShellInitSettings.FileName != NULL) {\r
1071 //\r
1072 // launch something else instead\r
1073 //\r
1074 NewSize = StrSize(ShellInfoObject.ShellInitSettings.FileName);\r
1075 if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {\r
1076 NewSize += StrSize(ShellInfoObject.ShellInitSettings.FileOptions) + sizeof(CHAR16);\r
1077 }\r
1078 FileStringPath = AllocateZeroPool(NewSize);\r
1079 if (FileStringPath == NULL) {\r
1080 return (EFI_OUT_OF_RESOURCES);\r
1081 }\r
1082 StrCpyS(FileStringPath, NewSize/sizeof(CHAR16), ShellInfoObject.ShellInitSettings.FileName);\r
1083 if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {\r
1084 StrnCatS(FileStringPath, NewSize/sizeof(CHAR16), L" ", NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);\r
1085 StrnCatS(FileStringPath, NewSize/sizeof(CHAR16), ShellInfoObject.ShellInitSettings.FileOptions, NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);\r
1086 }\r
1087 Status = RunCommand(FileStringPath);\r
1088 FreePool(FileStringPath);\r
1089 return (Status);\r
1090\r
1091 }\r
1092\r
1093 //\r
1094 // for shell level 0 we do no scripts\r
1095 // Without the Startup bit overriding we allow for nostartup to prevent scripts\r
1096 //\r
1097 if ( (PcdGet8(PcdShellSupportLevel) < 1)\r
1098 || (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup)\r
1099 ){\r
1100 return (EFI_SUCCESS);\r
1101 }\r
1102\r
1103 gST->ConOut->EnableCursor(gST->ConOut, FALSE);\r
1104 //\r
1105 // print out our warning and see if they press a key\r
1106 //\r
1107 for ( Status = EFI_UNSUPPORTED, Delay = ShellInfoObject.ShellInitSettings.Delay\r
1108 ; Delay != 0 && EFI_ERROR(Status)\r
1109 ; Delay--\r
1110 ){\r
1111 ShellPrintHiiEx(0, gST->ConOut->Mode->CursorRow, NULL, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION), ShellInfoObject.HiiHandle, Delay);\r
1112 gBS->Stall (1000000);\r
1113 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {\r
1114 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
1115 }\r
1116 }\r
1117 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CRLF), ShellInfoObject.HiiHandle);\r
1118 gST->ConOut->EnableCursor(gST->ConOut, TRUE);\r
1119\r
1120 //\r
1121 // ESC was pressed\r
1122 //\r
1123 if (Status == EFI_SUCCESS && Key.UnicodeChar == 0 && Key.ScanCode == SCAN_ESC) {\r
1124 return (EFI_SUCCESS);\r
1125 }\r
1126\r
1127 //\r
1128 // Try the first location (must be file system)\r
1129 //\r
1130 MapName = ShellInfoObject.NewEfiShellProtocol->GetMapFromDevicePath(&ImagePath);\r
1131 if (MapName != NULL) {\r
1132 FileStringPath = NULL;\r
1133 NewSize = 0;\r
1134 FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, MapName, 0);\r
1135 if (FileStringPath == NULL) {\r
1136 Status = EFI_OUT_OF_RESOURCES;\r
1137 } else {\r
1138 TempSpot = StrStr(FileStringPath, L";");\r
1139 if (TempSpot != NULL) {\r
1140 *TempSpot = CHAR_NULL;\r
1141 }\r
1142 FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, ((FILEPATH_DEVICE_PATH*)FilePath)->PathName, 0);\r
1143 PathRemoveLastItem(FileStringPath);\r
1144 FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, mStartupScript, 0);\r
1145 Status = ShellInfoObject.NewEfiShellProtocol->OpenFileByName(FileStringPath, &FileHandle, EFI_FILE_MODE_READ);\r
1146 FreePool(FileStringPath);\r
1147 }\r
1148 }\r
1149 if (EFI_ERROR(Status)) {\r
1150 NamePath = FileDevicePath (NULL, mStartupScript);\r
1151 NewPath = AppendDevicePathNode (ImagePath, NamePath);\r
1152 FreePool(NamePath);\r
1153\r
1154 //\r
1155 // Try the location\r
1156 //\r
1157 Status = InternalOpenFileDevicePath(NewPath, &FileHandle, EFI_FILE_MODE_READ, 0);\r
1158 FreePool(NewPath);\r
1159 }\r
1160 //\r
1161 // If we got a file, run it\r
1162 //\r
1163 if (!EFI_ERROR(Status) && FileHandle != NULL) {\r
1164 Status = RunScriptFile (mStartupScript, FileHandle, L"", ShellInfoObject.NewShellParametersProtocol);\r
1165 ShellInfoObject.NewEfiShellProtocol->CloseFile(FileHandle);\r
1166 } else {\r
1167 FileStringPath = ShellFindFilePath(mStartupScript);\r
1168 if (FileStringPath == NULL) {\r
1169 //\r
1170 // we return success since we don't need to have a startup script\r
1171 //\r
1172 Status = EFI_SUCCESS;\r
1173 ASSERT(FileHandle == NULL);\r
1174 } else {\r
1175 Status = RunScriptFile(FileStringPath, NULL, L"", ShellInfoObject.NewShellParametersProtocol);\r
1176 FreePool(FileStringPath);\r
1177 }\r
1178 }\r
1179\r
1180\r
1181 return (Status);\r
1182}\r
1183\r
1184/**\r
1185 Function to perform the shell prompt looping. It will do a single prompt,\r
1186 dispatch the result, and then return. It is expected that the caller will\r
1187 call this function in a loop many times.\r
1188\r
1189 @retval EFI_SUCCESS\r
1190 @retval RETURN_ABORTED\r
1191**/\r
1192EFI_STATUS\r
1193EFIAPI\r
1194DoShellPrompt (\r
1195 VOID\r
1196 )\r
1197{\r
1198 UINTN Column;\r
1199 UINTN Row;\r
1200 CHAR16 *CmdLine;\r
1201 CONST CHAR16 *CurDir;\r
1202 UINTN BufferSize;\r
1203 EFI_STATUS Status;\r
1204\r
1205 CurDir = NULL;\r
1206\r
1207 //\r
1208 // Get screen setting to decide size of the command line buffer\r
1209 //\r
1210 gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Column, &Row);\r
1211 BufferSize = Column * Row * sizeof (CHAR16);\r
1212 CmdLine = AllocateZeroPool (BufferSize);\r
1213 if (CmdLine == NULL) {\r
1214 return EFI_OUT_OF_RESOURCES;\r
1215 }\r
1216\r
1217 CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");\r
1218\r
1219 //\r
1220 // Prompt for input\r
1221 //\r
1222 gST->ConOut->SetCursorPosition (gST->ConOut, 0, gST->ConOut->Mode->CursorRow);\r
1223\r
1224 if (CurDir != NULL && StrLen(CurDir) > 1) {\r
1225 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);\r
1226 } else {\r
1227 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);\r
1228 }\r
1229\r
1230 //\r
1231 // Read a line from the console\r
1232 //\r
1233 Status = ShellInfoObject.NewEfiShellProtocol->ReadFile(ShellInfoObject.NewShellParametersProtocol->StdIn, &BufferSize, CmdLine);\r
1234\r
1235 //\r
1236 // Null terminate the string and parse it\r
1237 //\r
1238 if (!EFI_ERROR (Status)) {\r
1239 CmdLine[BufferSize / sizeof (CHAR16)] = CHAR_NULL;\r
1240 Status = RunCommand(CmdLine);\r
1241 }\r
1242\r
1243 //\r
1244 // Done with this command\r
1245 //\r
1246 FreePool (CmdLine);\r
1247 return Status;\r
1248}\r
1249\r
1250/**\r
1251 Add a buffer to the Buffer To Free List for safely returning buffers to other\r
1252 places without risking letting them modify internal shell information.\r
1253\r
1254 @param Buffer Something to pass to FreePool when the shell is exiting.\r
1255**/\r
1256VOID*\r
1257EFIAPI\r
1258AddBufferToFreeList(\r
1259 VOID *Buffer\r
1260 )\r
1261{\r
1262 BUFFER_LIST *BufferListEntry;\r
1263\r
1264 if (Buffer == NULL) {\r
1265 return (NULL);\r
1266 }\r
1267\r
1268 BufferListEntry = AllocateZeroPool(sizeof(BUFFER_LIST));\r
1269 ASSERT(BufferListEntry != NULL);\r
1270 BufferListEntry->Buffer = Buffer;\r
1271 InsertTailList(&ShellInfoObject.BufferToFreeList.Link, &BufferListEntry->Link);\r
1272 return (Buffer);\r
1273}\r
1274\r
1275/**\r
1276 Add a buffer to the Line History List\r
1277\r
1278 @param Buffer The line buffer to add.\r
1279**/\r
1280VOID\r
1281EFIAPI\r
1282AddLineToCommandHistory(\r
1283 IN CONST CHAR16 *Buffer\r
1284 )\r
1285{\r
1286 BUFFER_LIST *Node;\r
1287\r
1288 Node = AllocateZeroPool(sizeof(BUFFER_LIST));\r
1289 ASSERT(Node != NULL);\r
1290 Node->Buffer = AllocateCopyPool(StrSize(Buffer), Buffer);\r
1291 ASSERT(Node->Buffer != NULL);\r
1292\r
1293 InsertTailList(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link);\r
1294}\r
1295\r
1296/**\r
1297 Checks if a string is an alias for another command. If yes, then it replaces the alias name\r
1298 with the correct command name.\r
1299\r
1300 @param[in, out] CommandString Upon entry the potential alias. Upon return the\r
1301 command name if it was an alias. If it was not\r
1302 an alias it will be unchanged. This function may\r
1303 change the buffer to fit the command name.\r
1304\r
1305 @retval EFI_SUCCESS The name was changed.\r
1306 @retval EFI_SUCCESS The name was not an alias.\r
1307 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
1308**/\r
1309EFI_STATUS\r
1310EFIAPI\r
1311ShellConvertAlias(\r
1312 IN OUT CHAR16 **CommandString\r
1313 )\r
1314{\r
1315 CONST CHAR16 *NewString;\r
1316\r
1317 NewString = ShellInfoObject.NewEfiShellProtocol->GetAlias(*CommandString, NULL);\r
1318 if (NewString == NULL) {\r
1319 return (EFI_SUCCESS);\r
1320 }\r
1321 FreePool(*CommandString);\r
1322 *CommandString = AllocateCopyPool(StrSize(NewString), NewString);\r
1323 if (*CommandString == NULL) {\r
1324 return (EFI_OUT_OF_RESOURCES);\r
1325 }\r
1326 return (EFI_SUCCESS);\r
1327}\r
1328\r
1329/**\r
1330 This function will eliminate unreplaced (and therefore non-found) environment variables.\r
1331\r
1332 @param[in,out] CmdLine The command line to update.\r
1333**/\r
1334EFI_STATUS\r
1335EFIAPI\r
1336StripUnreplacedEnvironmentVariables(\r
1337 IN OUT CHAR16 *CmdLine\r
1338 )\r
1339{\r
1340 CHAR16 *FirstPercent;\r
1341 CHAR16 *FirstQuote;\r
1342 CHAR16 *SecondPercent;\r
1343 CHAR16 *SecondQuote;\r
1344 CHAR16 *CurrentLocator;\r
1345\r
1346 for (CurrentLocator = CmdLine ; CurrentLocator != NULL ; ) {\r
1347 FirstQuote = FindNextInstance(CurrentLocator, L"\"", TRUE);\r
1348 FirstPercent = FindNextInstance(CurrentLocator, L"%", TRUE);\r
1349 SecondPercent = FirstPercent!=NULL?FindNextInstance(FirstPercent+1, L"%", TRUE):NULL;\r
1350 if (FirstPercent == NULL || SecondPercent == NULL) {\r
1351 //\r
1352 // If we ever don't have 2 % we are done.\r
1353 //\r
1354 break;\r
1355 }\r
1356\r
1357 if (FirstQuote!= NULL && FirstQuote < FirstPercent) {\r
1358 SecondQuote = FindNextInstance(FirstQuote+1, L"\"", TRUE);\r
1359 //\r
1360 // Quote is first found\r
1361 //\r
1362\r
1363 if (SecondQuote < FirstPercent) {\r
1364 //\r
1365 // restart after the pair of "\r
1366 //\r
1367 CurrentLocator = SecondQuote + 1;\r
1368 } else /* FirstPercent < SecondQuote */{\r
1369 //\r
1370 // Restart on the first percent\r
1371 //\r
1372 CurrentLocator = FirstPercent;\r
1373 }\r
1374 continue;\r
1375 }\r
1376 \r
1377 if (FirstQuote == NULL || SecondPercent < FirstQuote) {\r
1378 if (IsValidEnvironmentVariableName(FirstPercent, SecondPercent)) {\r
1379 //\r
1380 // We need to remove from FirstPercent to SecondPercent\r
1381 //\r
1382 CopyMem(FirstPercent, SecondPercent + 1, StrSize(SecondPercent + 1));\r
1383 //\r
1384 // don't need to update the locator. both % characters are gone.\r
1385 //\r
1386 } else {\r
1387 CurrentLocator = SecondPercent + 1;\r
1388 }\r
1389 continue;\r
1390 }\r
1391 CurrentLocator = FirstQuote;\r
1392 }\r
1393 return (EFI_SUCCESS);\r
1394}\r
1395\r
1396/**\r
1397 Function allocates a new command line and replaces all instances of environment\r
1398 variable names that are correctly preset to their values.\r
1399\r
1400 If the return value is not NULL the memory must be caller freed.\r
1401\r
1402 @param[in] OriginalCommandLine The original command line\r
1403\r
1404 @retval NULL An error occurred.\r
1405 @return The new command line with no environment variables present.\r
1406**/\r
1407CHAR16*\r
1408EFIAPI\r
1409ShellConvertVariables (\r
1410 IN CONST CHAR16 *OriginalCommandLine\r
1411 )\r
1412{\r
1413 CONST CHAR16 *MasterEnvList;\r
1414 UINTN NewSize;\r
1415 CHAR16 *NewCommandLine1;\r
1416 CHAR16 *NewCommandLine2;\r
1417 CHAR16 *Temp;\r
1418 UINTN ItemSize;\r
1419 CHAR16 *ItemTemp;\r
1420 SCRIPT_FILE *CurrentScriptFile;\r
1421 ALIAS_LIST *AliasListNode;\r
1422\r
1423 ASSERT(OriginalCommandLine != NULL);\r
1424\r
1425 ItemSize = 0;\r
1426 NewSize = StrSize(OriginalCommandLine);\r
1427 CurrentScriptFile = ShellCommandGetCurrentScriptFile();\r
1428 Temp = NULL;\r
1429\r
1430 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?\r
1431\r
1432 //\r
1433 // calculate the size required for the post-conversion string...\r
1434 //\r
1435 if (CurrentScriptFile != NULL) {\r
1436 for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)\r
1437 ; !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1438 ; AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1439 ){\r
1440 for (Temp = StrStr(OriginalCommandLine, AliasListNode->Alias)\r
1441 ; Temp != NULL\r
1442 ; Temp = StrStr(Temp+1, AliasListNode->Alias)\r
1443 ){\r
1444 //\r
1445 // we need a preceding and if there is space no ^ preceding (if no space ignore)\r
1446 //\r
1447 if ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2)) {\r
1448 NewSize += StrSize(AliasListNode->CommandString);\r
1449 }\r
1450 }\r
1451 }\r
1452 }\r
1453\r
1454 for (MasterEnvList = EfiShellGetEnv(NULL)\r
1455 ; MasterEnvList != NULL && *MasterEnvList != CHAR_NULL //&& *(MasterEnvList+1) != CHAR_NULL\r
1456 ; MasterEnvList += StrLen(MasterEnvList) + 1\r
1457 ){\r
1458 if (StrSize(MasterEnvList) > ItemSize) {\r
1459 ItemSize = StrSize(MasterEnvList);\r
1460 }\r
1461 for (Temp = StrStr(OriginalCommandLine, MasterEnvList)\r
1462 ; Temp != NULL\r
1463 ; Temp = StrStr(Temp+1, MasterEnvList)\r
1464 ){\r
1465 //\r
1466 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)\r
1467 //\r
1468 if (*(Temp-1) == L'%' && *(Temp+StrLen(MasterEnvList)) == L'%' &&\r
1469 ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2))) {\r
1470 NewSize+=StrSize(EfiShellGetEnv(MasterEnvList));\r
1471 }\r
1472 }\r
1473 }\r
1474\r
1475 //\r
1476 // now do the replacements...\r
1477 //\r
1478 NewCommandLine1 = AllocateCopyPool(NewSize, OriginalCommandLine);\r
1479 NewCommandLine2 = AllocateZeroPool(NewSize);\r
1480 ItemTemp = AllocateZeroPool(ItemSize+(2*sizeof(CHAR16)));\r
1481 if (NewCommandLine1 == NULL || NewCommandLine2 == NULL || ItemTemp == NULL) {\r
1482 SHELL_FREE_NON_NULL(NewCommandLine1);\r
1483 SHELL_FREE_NON_NULL(NewCommandLine2);\r
1484 SHELL_FREE_NON_NULL(ItemTemp);\r
1485 return (NULL);\r
1486 }\r
1487 for (MasterEnvList = EfiShellGetEnv(NULL)\r
1488 ; MasterEnvList != NULL && *MasterEnvList != CHAR_NULL\r
1489 ; MasterEnvList += StrLen(MasterEnvList) + 1\r
1490 ){\r
1491 StrCpyS( ItemTemp, \r
1492 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1493 L"%"\r
1494 );\r
1495 StrCatS( ItemTemp, \r
1496 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1497 MasterEnvList\r
1498 );\r
1499 StrCatS( ItemTemp, \r
1500 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1501 L"%"\r
1502 );\r
1503 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, ItemTemp, EfiShellGetEnv(MasterEnvList), TRUE, FALSE);\r
1504 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1505 }\r
1506 if (CurrentScriptFile != NULL) {\r
1507 for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)\r
1508 ; !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1509 ; AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1510 ){\r
1511 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, AliasListNode->Alias, AliasListNode->CommandString, TRUE, FALSE);\r
1512 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1513 }\r
1514 }\r
1515\r
1516 //\r
1517 // Remove non-existent environment variables\r
1518 //\r
1519 StripUnreplacedEnvironmentVariables(NewCommandLine1);\r
1520\r
1521 //\r
1522 // Now cleanup any straggler intentionally ignored "%" characters\r
1523 //\r
1524 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, L"^%", L"%", TRUE, FALSE);\r
1525 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1526 \r
1527 FreePool(NewCommandLine2);\r
1528 FreePool(ItemTemp);\r
1529\r
1530 return (NewCommandLine1);\r
1531}\r
1532\r
1533/**\r
1534 Internal function to run a command line with pipe usage.\r
1535\r
1536 @param[in] CmdLine The pointer to the command line.\r
1537 @param[in] StdIn The pointer to the Standard input.\r
1538 @param[in] StdOut The pointer to the Standard output.\r
1539\r
1540 @retval EFI_SUCCESS The split command is executed successfully.\r
1541 @retval other Some error occurs when executing the split command.\r
1542**/\r
1543EFI_STATUS\r
1544EFIAPI\r
1545RunSplitCommand(\r
1546 IN CONST CHAR16 *CmdLine,\r
1547 IN SHELL_FILE_HANDLE *StdIn,\r
1548 IN SHELL_FILE_HANDLE *StdOut\r
1549 )\r
1550{\r
1551 EFI_STATUS Status;\r
1552 CHAR16 *NextCommandLine;\r
1553 CHAR16 *OurCommandLine;\r
1554 UINTN Size1;\r
1555 UINTN Size2;\r
1556 SPLIT_LIST *Split;\r
1557 SHELL_FILE_HANDLE *TempFileHandle;\r
1558 BOOLEAN Unicode;\r
1559\r
1560 ASSERT(StdOut == NULL);\r
1561\r
1562 ASSERT(StrStr(CmdLine, L"|") != NULL);\r
1563\r
1564 Status = EFI_SUCCESS;\r
1565 NextCommandLine = NULL;\r
1566 OurCommandLine = NULL;\r
1567 Size1 = 0;\r
1568 Size2 = 0;\r
1569\r
1570 NextCommandLine = StrnCatGrow(&NextCommandLine, &Size1, StrStr(CmdLine, L"|")+1, 0);\r
1571 OurCommandLine = StrnCatGrow(&OurCommandLine , &Size2, CmdLine , StrStr(CmdLine, L"|") - CmdLine);\r
1572\r
1573 if (NextCommandLine == NULL || OurCommandLine == NULL) {\r
1574 SHELL_FREE_NON_NULL(OurCommandLine);\r
1575 SHELL_FREE_NON_NULL(NextCommandLine);\r
1576 return (EFI_OUT_OF_RESOURCES);\r
1577 } else if (StrStr(OurCommandLine, L"|") != NULL || Size1 == 0 || Size2 == 0) {\r
1578 SHELL_FREE_NON_NULL(OurCommandLine);\r
1579 SHELL_FREE_NON_NULL(NextCommandLine);\r
1580 return (EFI_INVALID_PARAMETER);\r
1581 } else if (NextCommandLine[0] != CHAR_NULL &&\r
1582 NextCommandLine[0] == L'a' &&\r
1583 NextCommandLine[1] == L' '\r
1584 ){\r
1585 CopyMem(NextCommandLine, NextCommandLine+1, StrSize(NextCommandLine) - sizeof(NextCommandLine[0]));\r
1586 Unicode = FALSE;\r
1587 } else {\r
1588 Unicode = TRUE;\r
1589 }\r
1590\r
1591\r
1592 //\r
1593 // make a SPLIT_LIST item and add to list\r
1594 //\r
1595 Split = AllocateZeroPool(sizeof(SPLIT_LIST));\r
1596 ASSERT(Split != NULL);\r
1597 Split->SplitStdIn = StdIn;\r
1598 Split->SplitStdOut = ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode), NULL);\r
1599 ASSERT(Split->SplitStdOut != NULL);\r
1600 InsertHeadList(&ShellInfoObject.SplitList.Link, &Split->Link);\r
1601\r
1602 Status = RunCommand(OurCommandLine);\r
1603\r
1604 //\r
1605 // move the output from the first to the in to the second.\r
1606 //\r
1607 TempFileHandle = Split->SplitStdOut;\r
1608 if (Split->SplitStdIn == StdIn) {\r
1609 Split->SplitStdOut = NULL;\r
1610 } else {\r
1611 Split->SplitStdOut = Split->SplitStdIn;\r
1612 }\r
1613 Split->SplitStdIn = TempFileHandle;\r
1614 ShellInfoObject.NewEfiShellProtocol->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split->SplitStdIn), 0);\r
1615\r
1616 if (!EFI_ERROR(Status)) {\r
1617 Status = RunCommand(NextCommandLine);\r
1618 }\r
1619\r
1620 //\r
1621 // remove the top level from the ScriptList\r
1622 //\r
1623 ASSERT((SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link) == Split);\r
1624 RemoveEntryList(&Split->Link);\r
1625\r
1626 //\r
1627 // Note that the original StdIn is now the StdOut...\r
1628 //\r
1629 if (Split->SplitStdOut != NULL && Split->SplitStdOut != StdIn) {\r
1630 ShellInfoObject.NewEfiShellProtocol->CloseFile(ConvertShellHandleToEfiFileProtocol(Split->SplitStdOut));\r
1631 }\r
1632 if (Split->SplitStdIn != NULL) {\r
1633 ShellInfoObject.NewEfiShellProtocol->CloseFile(ConvertShellHandleToEfiFileProtocol(Split->SplitStdIn));\r
1634 }\r
1635\r
1636 FreePool(Split);\r
1637 FreePool(NextCommandLine);\r
1638 FreePool(OurCommandLine);\r
1639\r
1640 return (Status);\r
1641}\r
1642\r
1643/**\r
1644 Take the original command line, substitute any variables, free \r
1645 the original string, return the modified copy.\r
1646\r
1647 @param[in] CmdLine pointer to the command line to update.\r
1648\r
1649 @retval EFI_SUCCESS the function was successful.\r
1650 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.\r
1651**/\r
1652EFI_STATUS\r
1653EFIAPI\r
1654ShellSubstituteVariables(\r
1655 IN CHAR16 **CmdLine\r
1656 )\r
1657{\r
1658 CHAR16 *NewCmdLine;\r
1659 NewCmdLine = ShellConvertVariables(*CmdLine);\r
1660 SHELL_FREE_NON_NULL(*CmdLine);\r
1661 if (NewCmdLine == NULL) {\r
1662 return (EFI_OUT_OF_RESOURCES);\r
1663 }\r
1664 *CmdLine = NewCmdLine;\r
1665 return (EFI_SUCCESS);\r
1666}\r
1667\r
1668/**\r
1669 Take the original command line, substitute any alias in the first group of space delimited characters, free \r
1670 the original string, return the modified copy.\r
1671\r
1672 @param[in] CmdLine pointer to the command line to update.\r
1673\r
1674 @retval EFI_SUCCESS the function was successful.\r
1675 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.\r
1676**/\r
1677EFI_STATUS\r
1678EFIAPI\r
1679ShellSubstituteAliases(\r
1680 IN CHAR16 **CmdLine\r
1681 )\r
1682{\r
1683 CHAR16 *NewCmdLine;\r
1684 CHAR16 *CommandName;\r
1685 EFI_STATUS Status;\r
1686 UINTN PostAliasSize;\r
1687 ASSERT(CmdLine != NULL);\r
1688 ASSERT(*CmdLine!= NULL);\r
1689\r
1690\r
1691 CommandName = NULL;\r
1692 if (StrStr((*CmdLine), L" ") == NULL){\r
1693 StrnCatGrow(&CommandName, NULL, (*CmdLine), 0);\r
1694 } else {\r
1695 StrnCatGrow(&CommandName, NULL, (*CmdLine), StrStr((*CmdLine), L" ") - (*CmdLine));\r
1696 }\r
1697\r
1698 //\r
1699 // This cannot happen 'inline' since the CmdLine can need extra space.\r
1700 //\r
1701 NewCmdLine = NULL;\r
1702 if (!ShellCommandIsCommandOnList(CommandName)) {\r
1703 //\r
1704 // Convert via alias\r
1705 //\r
1706 Status = ShellConvertAlias(&CommandName);\r
1707 if (EFI_ERROR(Status)){\r
1708 return (Status);\r
1709 }\r
1710 PostAliasSize = 0;\r
1711 NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, CommandName, 0);\r
1712 if (NewCmdLine == NULL) {\r
1713 SHELL_FREE_NON_NULL(CommandName);\r
1714 SHELL_FREE_NON_NULL(*CmdLine);\r
1715 return (EFI_OUT_OF_RESOURCES);\r
1716 }\r
1717 NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, StrStr((*CmdLine), L" "), 0);\r
1718 if (NewCmdLine == NULL) {\r
1719 SHELL_FREE_NON_NULL(CommandName);\r
1720 SHELL_FREE_NON_NULL(*CmdLine);\r
1721 return (EFI_OUT_OF_RESOURCES);\r
1722 }\r
1723 } else {\r
1724 NewCmdLine = StrnCatGrow(&NewCmdLine, NULL, (*CmdLine), 0);\r
1725 }\r
1726\r
1727 SHELL_FREE_NON_NULL(*CmdLine);\r
1728 SHELL_FREE_NON_NULL(CommandName);\r
1729 \r
1730 //\r
1731 // re-assign the passed in double pointer to point to our newly allocated buffer\r
1732 //\r
1733 *CmdLine = NewCmdLine;\r
1734\r
1735 return (EFI_SUCCESS);\r
1736}\r
1737\r
1738/**\r
1739 Takes the Argv[0] part of the command line and determine the meaning of it.\r
1740\r
1741 @param[in] CmdName pointer to the command line to update.\r
1742 \r
1743 @retval Internal_Command The name is an internal command.\r
1744 @retval File_Sys_Change the name is a file system change.\r
1745 @retval Script_File_Name the name is a NSH script file.\r
1746 @retval Unknown_Invalid the name is unknown.\r
1747 @retval Efi_Application the name is an application (.EFI).\r
1748**/\r
1749SHELL_OPERATION_TYPES\r
1750EFIAPI\r
1751GetOperationType(\r
1752 IN CONST CHAR16 *CmdName\r
1753 )\r
1754{\r
1755 CHAR16* FileWithPath;\r
1756 CONST CHAR16* TempLocation;\r
1757 CONST CHAR16* TempLocation2;\r
1758\r
1759 FileWithPath = NULL;\r
1760 //\r
1761 // test for an internal command.\r
1762 //\r
1763 if (ShellCommandIsCommandOnList(CmdName)) {\r
1764 return (Internal_Command);\r
1765 }\r
1766\r
1767 //\r
1768 // Test for file system change request. anything ending with first : and cant have spaces.\r
1769 //\r
1770 if (CmdName[(StrLen(CmdName)-1)] == L':') {\r
1771 if ( StrStr(CmdName, L" ") != NULL \r
1772 || StrLen(StrStr(CmdName, L":")) > 1\r
1773 ) {\r
1774 return (Unknown_Invalid);\r
1775 }\r
1776 return (File_Sys_Change);\r
1777 }\r
1778\r
1779 //\r
1780 // Test for a file\r
1781 //\r
1782 if ((FileWithPath = ShellFindFilePathEx(CmdName, mExecutableExtensions)) != NULL) {\r
1783 //\r
1784 // See if that file has a script file extension\r
1785 //\r
1786 if (StrLen(FileWithPath) > 4) {\r
1787 TempLocation = FileWithPath+StrLen(FileWithPath)-4;\r
1788 TempLocation2 = mScriptExtension;\r
1789 if (StringNoCaseCompare((VOID*)(&TempLocation), (VOID*)(&TempLocation2)) == 0) {\r
1790 SHELL_FREE_NON_NULL(FileWithPath);\r
1791 return (Script_File_Name);\r
1792 }\r
1793 }\r
1794\r
1795 //\r
1796 // Was a file, but not a script. we treat this as an application.\r
1797 //\r
1798 SHELL_FREE_NON_NULL(FileWithPath);\r
1799 return (Efi_Application);\r
1800 }\r
1801 \r
1802 SHELL_FREE_NON_NULL(FileWithPath);\r
1803 //\r
1804 // No clue what this is... return invalid flag...\r
1805 //\r
1806 return (Unknown_Invalid);\r
1807}\r
1808\r
1809/**\r
1810 Determine if the first item in a command line is valid.\r
1811\r
1812 @param[in] CmdLine The command line to parse.\r
1813\r
1814 @retval EFI_SUCCESS The item is valid.\r
1815 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
1816 @retval EFI_NOT_FOUND The operation type is unknown or invalid.\r
1817**/\r
1818EFI_STATUS \r
1819EFIAPI\r
1820IsValidSplit(\r
1821 IN CONST CHAR16 *CmdLine\r
1822 )\r
1823{\r
1824 CHAR16 *Temp;\r
1825 CHAR16 *FirstParameter;\r
1826 CHAR16 *TempWalker;\r
1827 EFI_STATUS Status;\r
1828\r
1829 Temp = NULL;\r
1830\r
1831 Temp = StrnCatGrow(&Temp, NULL, CmdLine, 0);\r
1832 if (Temp == NULL) {\r
1833 return (EFI_OUT_OF_RESOURCES);\r
1834 }\r
1835\r
1836 FirstParameter = StrStr(Temp, L"|");\r
1837 if (FirstParameter != NULL) {\r
1838 *FirstParameter = CHAR_NULL;\r
1839 }\r
1840\r
1841 FirstParameter = NULL;\r
1842\r
1843 //\r
1844 // Process the command line\r
1845 //\r
1846 Status = ProcessCommandLineToFinal(&Temp);\r
1847\r
1848 if (!EFI_ERROR(Status)) {\r
1849 FirstParameter = AllocateZeroPool(StrSize(CmdLine));\r
1850 if (FirstParameter == NULL) {\r
1851 SHELL_FREE_NON_NULL(Temp);\r
1852 return (EFI_OUT_OF_RESOURCES);\r
1853 }\r
1854 TempWalker = (CHAR16*)Temp;\r
1855 if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CmdLine)))) {\r
1856 if (GetOperationType(FirstParameter) == Unknown_Invalid) {\r
1857 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
1858 SetLastError(SHELL_NOT_FOUND);\r
1859 Status = EFI_NOT_FOUND;\r
1860 }\r
1861 }\r
1862 }\r
1863\r
1864 SHELL_FREE_NON_NULL(Temp);\r
1865 SHELL_FREE_NON_NULL(FirstParameter);\r
1866 return Status;\r
1867}\r
1868\r
1869/**\r
1870 Determine if a command line contains with a split contains only valid commands.\r
1871\r
1872 @param[in] CmdLine The command line to parse.\r
1873\r
1874 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.\r
1875 @retval EFI_ABORTED CmdLine has at least one invalid command or application.\r
1876**/\r
1877EFI_STATUS\r
1878EFIAPI\r
1879VerifySplit(\r
1880 IN CONST CHAR16 *CmdLine\r
1881 )\r
1882{\r
1883 CONST CHAR16 *TempSpot;\r
1884 EFI_STATUS Status;\r
1885\r
1886 //\r
1887 // Verify up to the pipe or end character\r
1888 //\r
1889 Status = IsValidSplit(CmdLine);\r
1890 if (EFI_ERROR(Status)) {\r
1891 return (Status);\r
1892 }\r
1893\r
1894 //\r
1895 // If this was the only item, then get out\r
1896 //\r
1897 if (!ContainsSplit(CmdLine)) {\r
1898 return (EFI_SUCCESS);\r
1899 }\r
1900\r
1901 //\r
1902 // recurse to verify the next item\r
1903 //\r
1904 TempSpot = FindFirstCharacter(CmdLine, L"|", L'^') + 1;\r
1905 return (VerifySplit(TempSpot));\r
1906}\r
1907\r
1908/**\r
1909 Process a split based operation.\r
1910\r
1911 @param[in] CmdLine pointer to the command line to process\r
1912\r
1913 @retval EFI_SUCCESS The operation was successful\r
1914 @return an error occurred.\r
1915**/\r
1916EFI_STATUS\r
1917EFIAPI\r
1918ProcessNewSplitCommandLine(\r
1919 IN CONST CHAR16 *CmdLine\r
1920 )\r
1921{\r
1922 SPLIT_LIST *Split;\r
1923 EFI_STATUS Status;\r
1924\r
1925 Status = VerifySplit(CmdLine);\r
1926 if (EFI_ERROR(Status)) {\r
1927 return (Status);\r
1928 }\r
1929\r
1930 Split = NULL;\r
1931\r
1932 //\r
1933 // are we in an existing split???\r
1934 //\r
1935 if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {\r
1936 Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);\r
1937 }\r
1938\r
1939 if (Split == NULL) {\r
1940 Status = RunSplitCommand(CmdLine, NULL, NULL);\r
1941 } else {\r
1942 Status = RunSplitCommand(CmdLine, Split->SplitStdIn, Split->SplitStdOut);\r
1943 }\r
1944 if (EFI_ERROR(Status)) {\r
1945 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_SPLIT), ShellInfoObject.HiiHandle, CmdLine);\r
1946 }\r
1947 return (Status);\r
1948}\r
1949\r
1950/**\r
1951 Handle a request to change the current file system.\r
1952\r
1953 @param[in] CmdLine The passed in command line.\r
1954\r
1955 @retval EFI_SUCCESS The operation was successful.\r
1956**/\r
1957EFI_STATUS\r
1958EFIAPI\r
1959ChangeMappedDrive(\r
1960 IN CONST CHAR16 *CmdLine\r
1961 )\r
1962{\r
1963 EFI_STATUS Status;\r
1964 Status = EFI_SUCCESS;\r
1965\r
1966 //\r
1967 // make sure we are the right operation\r
1968 //\r
1969 ASSERT(CmdLine[(StrLen(CmdLine)-1)] == L':' && StrStr(CmdLine, L" ") == NULL);\r
1970 \r
1971 //\r
1972 // Call the protocol API to do the work\r
1973 //\r
1974 Status = ShellInfoObject.NewEfiShellProtocol->SetCurDir(NULL, CmdLine);\r
1975\r
1976 //\r
1977 // Report any errors\r
1978 //\r
1979 if (EFI_ERROR(Status)) {\r
1980 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_MAPPING), ShellInfoObject.HiiHandle, CmdLine);\r
1981 }\r
1982\r
1983 return (Status);\r
1984}\r
1985\r
1986/**\r
1987 Reprocess the command line to direct all -? to the help command.\r
1988\r
1989 if found, will add "help" as argv[0], and move the rest later.\r
1990\r
1991 @param[in,out] CmdLine pointer to the command line to update\r
1992**/\r
1993EFI_STATUS\r
1994EFIAPI\r
1995DoHelpUpdate(\r
1996 IN OUT CHAR16 **CmdLine\r
1997 )\r
1998{\r
1999 CHAR16 *CurrentParameter;\r
2000 CHAR16 *Walker;\r
2001 CHAR16 *NewCommandLine;\r
2002 EFI_STATUS Status;\r
2003 UINTN NewCmdLineSize;\r
2004\r
2005 Status = EFI_SUCCESS;\r
2006\r
2007 CurrentParameter = AllocateZeroPool(StrSize(*CmdLine));\r
2008 if (CurrentParameter == NULL) {\r
2009 return (EFI_OUT_OF_RESOURCES);\r
2010 }\r
2011\r
2012 Walker = *CmdLine;\r
2013 while(Walker != NULL && *Walker != CHAR_NULL) {\r
2014 if (!EFI_ERROR(GetNextParameter(&Walker, &CurrentParameter, StrSize(*CmdLine)))) {\r
2015 if (StrStr(CurrentParameter, L"-?") == CurrentParameter) {\r
2016 CurrentParameter[0] = L' ';\r
2017 CurrentParameter[1] = L' ';\r
2018 NewCmdLineSize = StrSize(L"help ") + StrSize(*CmdLine);\r
2019 NewCommandLine = AllocateZeroPool(NewCmdLineSize);\r
2020 if (NewCommandLine == NULL) {\r
2021 Status = EFI_OUT_OF_RESOURCES;\r
2022 break;\r
2023 }\r
2024\r
2025 //\r
2026 // We know the space is sufficient since we just calculated it.\r
2027 //\r
2028 StrnCpyS(NewCommandLine, NewCmdLineSize/sizeof(CHAR16), L"help ", 5);\r
2029 StrnCatS(NewCommandLine, NewCmdLineSize/sizeof(CHAR16), *CmdLine, StrLen(*CmdLine));\r
2030 SHELL_FREE_NON_NULL(*CmdLine);\r
2031 *CmdLine = NewCommandLine;\r
2032 break;\r
2033 }\r
2034 }\r
2035 }\r
2036\r
2037 SHELL_FREE_NON_NULL(CurrentParameter);\r
2038\r
2039 return (Status);\r
2040}\r
2041\r
2042/**\r
2043 Function to update the shell variable "lasterror".\r
2044\r
2045 @param[in] ErrorCode the error code to put into lasterror.\r
2046**/\r
2047EFI_STATUS\r
2048EFIAPI\r
2049SetLastError(\r
2050 IN CONST SHELL_STATUS ErrorCode\r
2051 )\r
2052{\r
2053 CHAR16 LeString[19];\r
2054 if (sizeof(EFI_STATUS) == sizeof(UINT64)) {\r
2055 UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ErrorCode);\r
2056 } else {\r
2057 UnicodeSPrint(LeString, sizeof(LeString), L"0x%x", ErrorCode);\r
2058 }\r
2059 DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););\r
2060 InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);\r
2061\r
2062 return (EFI_SUCCESS);\r
2063}\r
2064\r
2065/**\r
2066 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.\r
2067\r
2068 @param[in,out] CmdLine pointer to the command line to update\r
2069\r
2070 @retval EFI_SUCCESS The operation was successful\r
2071 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
2072 @return some other error occurred\r
2073**/\r
2074EFI_STATUS\r
2075EFIAPI\r
2076ProcessCommandLineToFinal(\r
2077 IN OUT CHAR16 **CmdLine\r
2078 )\r
2079{\r
2080 EFI_STATUS Status;\r
2081 TrimSpaces(CmdLine);\r
2082\r
2083 Status = ShellSubstituteAliases(CmdLine);\r
2084 if (EFI_ERROR(Status)) {\r
2085 return (Status);\r
2086 }\r
2087\r
2088 TrimSpaces(CmdLine);\r
2089\r
2090 Status = ShellSubstituteVariables(CmdLine);\r
2091 if (EFI_ERROR(Status)) {\r
2092 return (Status);\r
2093 }\r
2094 ASSERT (*CmdLine != NULL);\r
2095\r
2096 TrimSpaces(CmdLine);\r
2097\r
2098 //\r
2099 // update for help parsing\r
2100 //\r
2101 if (StrStr(*CmdLine, L"?") != NULL) {\r
2102 //\r
2103 // This may do nothing if the ? does not indicate help.\r
2104 // Save all the details for in the API below.\r
2105 //\r
2106 Status = DoHelpUpdate(CmdLine);\r
2107 }\r
2108\r
2109 TrimSpaces(CmdLine);\r
2110\r
2111 return (EFI_SUCCESS);\r
2112}\r
2113\r
2114/**\r
2115 Run an internal shell command.\r
2116\r
2117 This API will update the shell's environment since these commands are libraries.\r
2118 \r
2119 @param[in] CmdLine the command line to run.\r
2120 @param[in] FirstParameter the first parameter on the command line\r
2121 @param[in] ParamProtocol the shell parameters protocol pointer\r
2122\r
2123 @retval EFI_SUCCESS The command was completed.\r
2124 @retval EFI_ABORTED The command's operation was aborted.\r
2125**/\r
2126EFI_STATUS\r
2127EFIAPI\r
2128RunInternalCommand(\r
2129 IN CONST CHAR16 *CmdLine,\r
2130 IN CHAR16 *FirstParameter,\r
2131 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol\r
2132)\r
2133{\r
2134 EFI_STATUS Status;\r
2135 UINTN Argc;\r
2136 CHAR16 **Argv;\r
2137 SHELL_STATUS CommandReturnedStatus;\r
2138 BOOLEAN LastError;\r
2139 CHAR16 *Walker;\r
2140 CHAR16 *NewCmdLine; \r
2141\r
2142 NewCmdLine = AllocateCopyPool (StrSize (CmdLine), CmdLine);\r
2143 if (NewCmdLine == NULL) {\r
2144 return EFI_OUT_OF_RESOURCES;\r
2145 }\r
2146\r
2147 for (Walker = NewCmdLine; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {\r
2148 if (*Walker == L'^' && *(Walker+1) == L'#') {\r
2149 CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));\r
2150 }\r
2151 }\r
2152\r
2153 //\r
2154 // get the argc and argv updated for internal commands\r
2155 //\r
2156 Status = UpdateArgcArgv(ParamProtocol, NewCmdLine, &Argv, &Argc);\r
2157 if (!EFI_ERROR(Status)) {\r
2158 //\r
2159 // Run the internal command.\r
2160 //\r
2161 Status = ShellCommandRunCommandHandler(FirstParameter, &CommandReturnedStatus, &LastError);\r
2162\r
2163 if (!EFI_ERROR(Status)) {\r
2164 //\r
2165 // Update last error status.\r
2166 // some commands do not update last error.\r
2167 //\r
2168 if (LastError) {\r
2169 SetLastError(CommandReturnedStatus);\r
2170 }\r
2171\r
2172 //\r
2173 // Pass thru the exitcode from the app.\r
2174 //\r
2175 if (ShellCommandGetExit()) {\r
2176 //\r
2177 // An Exit was requested ("exit" command), pass its value up.\r
2178 //\r
2179 Status = CommandReturnedStatus;\r
2180 } else if (CommandReturnedStatus != SHELL_SUCCESS && IsScriptOnlyCommand(FirstParameter)) {\r
2181 //\r
2182 // Always abort when a script only command fails for any reason\r
2183 //\r
2184 Status = EFI_ABORTED;\r
2185 } else if (ShellCommandGetCurrentScriptFile() != NULL && CommandReturnedStatus == SHELL_ABORTED) {\r
2186 //\r
2187 // Abort when in a script and a command aborted\r
2188 //\r
2189 Status = EFI_ABORTED;\r
2190 }\r
2191 }\r
2192 }\r
2193\r
2194 //\r
2195 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.\r
2196 // This is safe even if the update API failed. In this case, it may be a no-op.\r
2197 //\r
2198 RestoreArgcArgv(ParamProtocol, &Argv, &Argc);\r
2199\r
2200 //\r
2201 // If a script is running and the command is not a script only command, then\r
2202 // change return value to success so the script won't halt (unless aborted).\r
2203 //\r
2204 // Script only commands have to be able halt the script since the script will\r
2205 // not operate if they are failing.\r
2206 //\r
2207 if ( ShellCommandGetCurrentScriptFile() != NULL\r
2208 && !IsScriptOnlyCommand(FirstParameter)\r
2209 && Status != EFI_ABORTED\r
2210 ) {\r
2211 Status = EFI_SUCCESS;\r
2212 }\r
2213\r
2214 FreePool (NewCmdLine);\r
2215 return (Status);\r
2216}\r
2217\r
2218/**\r
2219 Function to run the command or file.\r
2220\r
2221 @param[in] Type the type of operation being run.\r
2222 @param[in] CmdLine the command line to run.\r
2223 @param[in] FirstParameter the first parameter on the command line\r
2224 @param[in] ParamProtocol the shell parameters protocol pointer\r
2225\r
2226 @retval EFI_SUCCESS The command was completed.\r
2227 @retval EFI_ABORTED The command's operation was aborted.\r
2228**/\r
2229EFI_STATUS\r
2230EFIAPI\r
2231RunCommandOrFile(\r
2232 IN SHELL_OPERATION_TYPES Type,\r
2233 IN CONST CHAR16 *CmdLine,\r
2234 IN CHAR16 *FirstParameter,\r
2235 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol\r
2236)\r
2237{\r
2238 EFI_STATUS Status;\r
2239 EFI_STATUS StartStatus;\r
2240 CHAR16 *CommandWithPath;\r
2241 EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
2242 SHELL_STATUS CalleeExitStatus;\r
2243\r
2244 Status = EFI_SUCCESS;\r
2245 CommandWithPath = NULL;\r
2246 DevPath = NULL;\r
2247 CalleeExitStatus = SHELL_INVALID_PARAMETER;\r
2248\r
2249 switch (Type) {\r
2250 case Internal_Command:\r
2251 Status = RunInternalCommand(CmdLine, FirstParameter, ParamProtocol);\r
2252 break;\r
2253 case Script_File_Name:\r
2254 case Efi_Application:\r
2255 //\r
2256 // Process a fully qualified path\r
2257 //\r
2258 if (StrStr(FirstParameter, L":") != NULL) {\r
2259 ASSERT (CommandWithPath == NULL);\r
2260 if (ShellIsFile(FirstParameter) == EFI_SUCCESS) {\r
2261 CommandWithPath = StrnCatGrow(&CommandWithPath, NULL, FirstParameter, 0);\r
2262 }\r
2263 }\r
2264\r
2265 //\r
2266 // Process a relative path and also check in the path environment variable\r
2267 //\r
2268 if (CommandWithPath == NULL) {\r
2269 CommandWithPath = ShellFindFilePathEx(FirstParameter, mExecutableExtensions);\r
2270 }\r
2271\r
2272 //\r
2273 // This should be impossible now.\r
2274 //\r
2275 ASSERT(CommandWithPath != NULL);\r
2276\r
2277 //\r
2278 // Make sure that path is not just a directory (or not found)\r
2279 //\r
2280 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath))) {\r
2281 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2282 SetLastError(SHELL_NOT_FOUND);\r
2283 }\r
2284 switch (Type) {\r
2285 case Script_File_Name:\r
2286 Status = RunScriptFile (CommandWithPath, NULL, CmdLine, ParamProtocol);\r
2287 break;\r
2288 case Efi_Application:\r
2289 //\r
2290 // Get the device path of the application image\r
2291 //\r
2292 DevPath = ShellInfoObject.NewEfiShellProtocol->GetDevicePathFromFilePath(CommandWithPath);\r
2293 if (DevPath == NULL){\r
2294 Status = EFI_OUT_OF_RESOURCES;\r
2295 break;\r
2296 }\r
2297\r
2298 //\r
2299 // Execute the device path\r
2300 //\r
2301 Status = InternalShellExecuteDevicePath(\r
2302 &gImageHandle,\r
2303 DevPath,\r
2304 CmdLine,\r
2305 NULL,\r
2306 &StartStatus\r
2307 );\r
2308\r
2309 SHELL_FREE_NON_NULL(DevPath);\r
2310\r
2311 if(EFI_ERROR (Status)) {\r
2312 CalleeExitStatus = (SHELL_STATUS) (Status & (~MAX_BIT));\r
2313 } else {\r
2314 CalleeExitStatus = (SHELL_STATUS) StartStatus;\r
2315 }\r
2316\r
2317 //\r
2318 // Update last error status.\r
2319 //\r
2320 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS\r
2321 SetLastError(CalleeExitStatus);\r
2322 break;\r
2323 default:\r
2324 //\r
2325 // Do nothing.\r
2326 //\r
2327 break;\r
2328 }\r
2329 break;\r
2330 default:\r
2331 //\r
2332 // Do nothing.\r
2333 //\r
2334 break;\r
2335 }\r
2336\r
2337 SHELL_FREE_NON_NULL(CommandWithPath);\r
2338\r
2339 return (Status);\r
2340}\r
2341\r
2342/**\r
2343 Function to setup StdIn, StdErr, StdOut, and then run the command or file.\r
2344\r
2345 @param[in] Type the type of operation being run.\r
2346 @param[in] CmdLine the command line to run.\r
2347 @param[in] FirstParameter the first parameter on the command line.\r
2348 @param[in] ParamProtocol the shell parameters protocol pointer\r
2349\r
2350 @retval EFI_SUCCESS The command was completed.\r
2351 @retval EFI_ABORTED The command's operation was aborted.\r
2352**/\r
2353EFI_STATUS\r
2354EFIAPI\r
2355SetupAndRunCommandOrFile(\r
2356 IN SHELL_OPERATION_TYPES Type,\r
2357 IN CHAR16 *CmdLine,\r
2358 IN CHAR16 *FirstParameter,\r
2359 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol\r
2360)\r
2361{\r
2362 EFI_STATUS Status;\r
2363 SHELL_FILE_HANDLE OriginalStdIn;\r
2364 SHELL_FILE_HANDLE OriginalStdOut;\r
2365 SHELL_FILE_HANDLE OriginalStdErr;\r
2366 SYSTEM_TABLE_INFO OriginalSystemTableInfo;\r
2367\r
2368 //\r
2369 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII\r
2370 //\r
2371 Status = UpdateStdInStdOutStdErr(ParamProtocol, CmdLine, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);\r
2372\r
2373 //\r
2374 // The StdIn, StdOut, and StdErr are set up.\r
2375 // Now run the command, script, or application\r
2376 //\r
2377 if (!EFI_ERROR(Status)) {\r
2378 TrimSpaces(&CmdLine);\r
2379 Status = RunCommandOrFile(Type, CmdLine, FirstParameter, ParamProtocol);\r
2380 }\r
2381\r
2382 //\r
2383 // Now print errors\r
2384 //\r
2385 if (EFI_ERROR(Status)) {\r
2386 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_ERROR), ShellInfoObject.HiiHandle, (VOID*)(Status));\r
2387 }\r
2388\r
2389 //\r
2390 // put back the original StdIn, StdOut, and StdErr\r
2391 //\r
2392 RestoreStdInStdOutStdErr(ParamProtocol, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);\r
2393\r
2394 return (Status);\r
2395}\r
2396\r
2397/**\r
2398 Function will process and run a command line.\r
2399\r
2400 This will determine if the command line represents an internal shell \r
2401 command or dispatch an external application.\r
2402\r
2403 @param[in] CmdLine The command line to parse.\r
2404\r
2405 @retval EFI_SUCCESS The command was completed.\r
2406 @retval EFI_ABORTED The command's operation was aborted.\r
2407**/\r
2408EFI_STATUS\r
2409EFIAPI\r
2410RunCommand(\r
2411 IN CONST CHAR16 *CmdLine\r
2412 )\r
2413{\r
2414 EFI_STATUS Status;\r
2415 CHAR16 *CleanOriginal;\r
2416 CHAR16 *FirstParameter;\r
2417 CHAR16 *TempWalker;\r
2418 SHELL_OPERATION_TYPES Type;\r
2419\r
2420 ASSERT(CmdLine != NULL);\r
2421 if (StrLen(CmdLine) == 0) {\r
2422 return (EFI_SUCCESS);\r
2423 }\r
2424\r
2425 Status = EFI_SUCCESS;\r
2426 CleanOriginal = NULL;\r
2427\r
2428 CleanOriginal = StrnCatGrow(&CleanOriginal, NULL, CmdLine, 0);\r
2429 if (CleanOriginal == NULL) {\r
2430 return (EFI_OUT_OF_RESOURCES);\r
2431 }\r
2432\r
2433 TrimSpaces(&CleanOriginal);\r
2434\r
2435 //\r
2436 // NULL out comments (leveraged from RunScriptFileHandle() ).\r
2437 // The # character on a line is used to denote that all characters on the same line\r
2438 // and to the right of the # are to be ignored by the shell.\r
2439 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.\r
2440 //\r
2441 for (TempWalker = CleanOriginal; TempWalker != NULL && *TempWalker != CHAR_NULL; TempWalker++) {\r
2442 if (*TempWalker == L'^') {\r
2443 if (*(TempWalker + 1) == L'#') {\r
2444 TempWalker++;\r
2445 }\r
2446 } else if (*TempWalker == L'#') {\r
2447 *TempWalker = CHAR_NULL;\r
2448 }\r
2449 }\r
2450\r
2451 TrimSpaces(&CleanOriginal);\r
2452\r
2453 //\r
2454 // Handle case that passed in command line is just 1 or more " " characters.\r
2455 //\r
2456 if (StrLen (CleanOriginal) == 0) {\r
2457 SHELL_FREE_NON_NULL(CleanOriginal);\r
2458 return (EFI_SUCCESS);\r
2459 }\r
2460\r
2461 Status = ProcessCommandLineToFinal(&CleanOriginal);\r
2462 if (EFI_ERROR(Status)) {\r
2463 SHELL_FREE_NON_NULL(CleanOriginal);\r
2464 return (Status);\r
2465 }\r
2466\r
2467 //\r
2468 // We don't do normal processing with a split command line (output from one command input to another)\r
2469 //\r
2470 if (ContainsSplit(CleanOriginal)) {\r
2471 Status = ProcessNewSplitCommandLine(CleanOriginal);\r
2472 SHELL_FREE_NON_NULL(CleanOriginal);\r
2473 return (Status);\r
2474 } \r
2475\r
2476 //\r
2477 // We need the first parameter information so we can determine the operation type\r
2478 //\r
2479 FirstParameter = AllocateZeroPool(StrSize(CleanOriginal));\r
2480 if (FirstParameter == NULL) {\r
2481 SHELL_FREE_NON_NULL(CleanOriginal);\r
2482 return (EFI_OUT_OF_RESOURCES);\r
2483 }\r
2484 TempWalker = CleanOriginal;\r
2485 if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CleanOriginal)))) {\r
2486 //\r
2487 // Depending on the first parameter we change the behavior\r
2488 //\r
2489 switch (Type = GetOperationType(FirstParameter)) {\r
2490 case File_Sys_Change:\r
2491 Status = ChangeMappedDrive (FirstParameter);\r
2492 break;\r
2493 case Internal_Command:\r
2494 case Script_File_Name:\r
2495 case Efi_Application:\r
2496 Status = SetupAndRunCommandOrFile(Type, CleanOriginal, FirstParameter, ShellInfoObject.NewShellParametersProtocol);\r
2497 break;\r
2498 default:\r
2499 //\r
2500 // Whatever was typed, it was invalid.\r
2501 //\r
2502 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2503 SetLastError(SHELL_NOT_FOUND);\r
2504 break;\r
2505 }\r
2506 } else {\r
2507 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2508 SetLastError(SHELL_NOT_FOUND);\r
2509 }\r
2510 \r
2511 SHELL_FREE_NON_NULL(CleanOriginal);\r
2512 SHELL_FREE_NON_NULL(FirstParameter);\r
2513\r
2514 return (Status);\r
2515}\r
2516\r
2517STATIC CONST UINT16 InvalidChars[] = {L'*', L'?', L'<', L'>', L'\\', L'/', L'\"', 0x0001, 0x0002};\r
2518/**\r
2519 Function determines if the CommandName COULD be a valid command. It does not determine whether\r
2520 this is a valid command. It only checks for invalid characters.\r
2521\r
2522 @param[in] CommandName The name to check\r
2523\r
2524 @retval TRUE CommandName could be a command name\r
2525 @retval FALSE CommandName could not be a valid command name\r
2526**/\r
2527BOOLEAN\r
2528EFIAPI\r
2529IsValidCommandName(\r
2530 IN CONST CHAR16 *CommandName\r
2531 )\r
2532{\r
2533 UINTN Count;\r
2534 if (CommandName == NULL) {\r
2535 ASSERT(FALSE);\r
2536 return (FALSE);\r
2537 }\r
2538 for ( Count = 0\r
2539 ; Count < sizeof(InvalidChars) / sizeof(InvalidChars[0])\r
2540 ; Count++\r
2541 ){\r
2542 if (ScanMem16(CommandName, StrSize(CommandName), InvalidChars[Count]) != NULL) {\r
2543 return (FALSE);\r
2544 }\r
2545 }\r
2546 return (TRUE);\r
2547}\r
2548\r
2549/**\r
2550 Function to process a NSH script file via SHELL_FILE_HANDLE.\r
2551\r
2552 @param[in] Handle The handle to the already opened file.\r
2553 @param[in] Name The name of the script file.\r
2554\r
2555 @retval EFI_SUCCESS the script completed successfully\r
2556**/\r
2557EFI_STATUS\r
2558EFIAPI\r
2559RunScriptFileHandle (\r
2560 IN SHELL_FILE_HANDLE Handle,\r
2561 IN CONST CHAR16 *Name\r
2562 )\r
2563{\r
2564 EFI_STATUS Status;\r
2565 SCRIPT_FILE *NewScriptFile;\r
2566 UINTN LoopVar;\r
2567 UINTN PrintBuffSize;\r
2568 CHAR16 *CommandLine;\r
2569 CHAR16 *CommandLine2;\r
2570 CHAR16 *CommandLine3;\r
2571 SCRIPT_COMMAND_LIST *LastCommand;\r
2572 BOOLEAN Ascii;\r
2573 BOOLEAN PreScriptEchoState;\r
2574 BOOLEAN PreCommandEchoState;\r
2575 CONST CHAR16 *CurDir;\r
2576 UINTN LineCount;\r
2577 CHAR16 LeString[50];\r
2578\r
2579 ASSERT(!ShellCommandGetScriptExit());\r
2580\r
2581 PreScriptEchoState = ShellCommandGetEchoState();\r
2582 PrintBuffSize = PcdGet16(PcdShellPrintBufferSize);\r
2583\r
2584 NewScriptFile = (SCRIPT_FILE*)AllocateZeroPool(sizeof(SCRIPT_FILE));\r
2585 if (NewScriptFile == NULL) {\r
2586 return (EFI_OUT_OF_RESOURCES);\r
2587 }\r
2588\r
2589 //\r
2590 // Set up the name\r
2591 //\r
2592 ASSERT(NewScriptFile->ScriptName == NULL);\r
2593 NewScriptFile->ScriptName = StrnCatGrow(&NewScriptFile->ScriptName, NULL, Name, 0);\r
2594 if (NewScriptFile->ScriptName == NULL) {\r
2595 DeleteScriptFileStruct(NewScriptFile);\r
2596 return (EFI_OUT_OF_RESOURCES);\r
2597 }\r
2598\r
2599 //\r
2600 // Save the parameters (used to replace %0 to %9 later on)\r
2601 //\r
2602 NewScriptFile->Argc = ShellInfoObject.NewShellParametersProtocol->Argc;\r
2603 if (NewScriptFile->Argc != 0) {\r
2604 NewScriptFile->Argv = (CHAR16**)AllocateZeroPool(NewScriptFile->Argc * sizeof(CHAR16*));\r
2605 if (NewScriptFile->Argv == NULL) {\r
2606 DeleteScriptFileStruct(NewScriptFile);\r
2607 return (EFI_OUT_OF_RESOURCES);\r
2608 }\r
2609 for (LoopVar = 0 ; LoopVar < 10 && LoopVar < NewScriptFile->Argc; LoopVar++) {\r
2610 ASSERT(NewScriptFile->Argv[LoopVar] == NULL);\r
2611 NewScriptFile->Argv[LoopVar] = StrnCatGrow(&NewScriptFile->Argv[LoopVar], NULL, ShellInfoObject.NewShellParametersProtocol->Argv[LoopVar], 0);\r
2612 if (NewScriptFile->Argv[LoopVar] == NULL) {\r
2613 DeleteScriptFileStruct(NewScriptFile);\r
2614 return (EFI_OUT_OF_RESOURCES);\r
2615 }\r
2616 }\r
2617 } else {\r
2618 NewScriptFile->Argv = NULL;\r
2619 }\r
2620\r
2621 InitializeListHead(&NewScriptFile->CommandList);\r
2622 InitializeListHead(&NewScriptFile->SubstList);\r
2623\r
2624 //\r
2625 // Now build the list of all script commands.\r
2626 //\r
2627 LineCount = 0;\r
2628 while(!ShellFileHandleEof(Handle)) {\r
2629 CommandLine = ShellFileHandleReturnLine(Handle, &Ascii);\r
2630 LineCount++;\r
2631 if (CommandLine == NULL || StrLen(CommandLine) == 0 || CommandLine[0] == '#') {\r
2632 SHELL_FREE_NON_NULL(CommandLine);\r
2633 continue;\r
2634 }\r
2635 NewScriptFile->CurrentCommand = AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST));\r
2636 if (NewScriptFile->CurrentCommand == NULL) {\r
2637 SHELL_FREE_NON_NULL(CommandLine);\r
2638 DeleteScriptFileStruct(NewScriptFile);\r
2639 return (EFI_OUT_OF_RESOURCES);\r
2640 }\r
2641\r
2642 NewScriptFile->CurrentCommand->Cl = CommandLine;\r
2643 NewScriptFile->CurrentCommand->Data = NULL;\r
2644 NewScriptFile->CurrentCommand->Line = LineCount;\r
2645\r
2646 InsertTailList(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
2647 }\r
2648\r
2649 //\r
2650 // Add this as the topmost script file\r
2651 //\r
2652 ShellCommandSetNewScript (NewScriptFile);\r
2653\r
2654 //\r
2655 // Now enumerate through the commands and run each one.\r
2656 //\r
2657 CommandLine = AllocateZeroPool(PrintBuffSize);\r
2658 if (CommandLine == NULL) {\r
2659 DeleteScriptFileStruct(NewScriptFile);\r
2660 return (EFI_OUT_OF_RESOURCES);\r
2661 }\r
2662 CommandLine2 = AllocateZeroPool(PrintBuffSize);\r
2663 if (CommandLine2 == NULL) {\r
2664 FreePool(CommandLine);\r
2665 DeleteScriptFileStruct(NewScriptFile);\r
2666 return (EFI_OUT_OF_RESOURCES);\r
2667 }\r
2668\r
2669 for ( NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&NewScriptFile->CommandList)\r
2670 ; !IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)\r
2671 ; // conditional increment in the body of the loop\r
2672 ){\r
2673 ASSERT(CommandLine2 != NULL);\r
2674 StrnCpyS( CommandLine2, \r
2675 PrintBuffSize/sizeof(CHAR16), \r
2676 NewScriptFile->CurrentCommand->Cl,\r
2677 PrintBuffSize/sizeof(CHAR16) - 1\r
2678 );\r
2679\r
2680 //\r
2681 // NULL out comments\r
2682 //\r
2683 for (CommandLine3 = CommandLine2 ; CommandLine3 != NULL && *CommandLine3 != CHAR_NULL ; CommandLine3++) {\r
2684 if (*CommandLine3 == L'^') {\r
2685 if ( *(CommandLine3+1) == L':') {\r
2686 CopyMem(CommandLine3, CommandLine3+1, StrSize(CommandLine3) - sizeof(CommandLine3[0]));\r
2687 } else if (*(CommandLine3+1) == L'#') {\r
2688 CommandLine3++;\r
2689 }\r
2690 } else if (*CommandLine3 == L'#') {\r
2691 *CommandLine3 = CHAR_NULL;\r
2692 }\r
2693 }\r
2694\r
2695 if (CommandLine2 != NULL && StrLen(CommandLine2) >= 1) {\r
2696 //\r
2697 // Due to variability in starting the find and replace action we need to have both buffers the same.\r
2698 //\r
2699 StrnCpyS( CommandLine, \r
2700 PrintBuffSize/sizeof(CHAR16), \r
2701 CommandLine2,\r
2702 PrintBuffSize/sizeof(CHAR16) - 1\r
2703 );\r
2704\r
2705 //\r
2706 // Remove the %0 to %9 from the command line (if we have some arguments)\r
2707 //\r
2708 if (NewScriptFile->Argv != NULL) {\r
2709 switch (NewScriptFile->Argc) {\r
2710 default:\r
2711 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%9", NewScriptFile->Argv[9], FALSE, TRUE);\r
2712 ASSERT_EFI_ERROR(Status);\r
2713 case 9:\r
2714 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%8", NewScriptFile->Argv[8], FALSE, TRUE);\r
2715 ASSERT_EFI_ERROR(Status);\r
2716 case 8:\r
2717 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%7", NewScriptFile->Argv[7], FALSE, TRUE);\r
2718 ASSERT_EFI_ERROR(Status);\r
2719 case 7:\r
2720 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%6", NewScriptFile->Argv[6], FALSE, TRUE);\r
2721 ASSERT_EFI_ERROR(Status);\r
2722 case 6:\r
2723 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%5", NewScriptFile->Argv[5], FALSE, TRUE);\r
2724 ASSERT_EFI_ERROR(Status);\r
2725 case 5:\r
2726 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%4", NewScriptFile->Argv[4], FALSE, TRUE);\r
2727 ASSERT_EFI_ERROR(Status);\r
2728 case 4:\r
2729 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%3", NewScriptFile->Argv[3], FALSE, TRUE);\r
2730 ASSERT_EFI_ERROR(Status);\r
2731 case 3:\r
2732 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%2", NewScriptFile->Argv[2], FALSE, TRUE);\r
2733 ASSERT_EFI_ERROR(Status);\r
2734 case 2:\r
2735 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%1", NewScriptFile->Argv[1], FALSE, TRUE);\r
2736 ASSERT_EFI_ERROR(Status);\r
2737 case 1:\r
2738 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%0", NewScriptFile->Argv[0], FALSE, TRUE);\r
2739 ASSERT_EFI_ERROR(Status);\r
2740 break;\r
2741 case 0:\r
2742 break;\r
2743 }\r
2744 }\r
2745 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%1", L"\"\"", FALSE, FALSE);\r
2746 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%2", L"\"\"", FALSE, FALSE);\r
2747 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%3", L"\"\"", FALSE, FALSE);\r
2748 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%4", L"\"\"", FALSE, FALSE);\r
2749 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%5", L"\"\"", FALSE, FALSE);\r
2750 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%6", L"\"\"", FALSE, FALSE);\r
2751 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%7", L"\"\"", FALSE, FALSE);\r
2752 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%8", L"\"\"", FALSE, FALSE);\r
2753 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%9", L"\"\"", FALSE, FALSE);\r
2754\r
2755 StrnCpyS( CommandLine2, \r
2756 PrintBuffSize/sizeof(CHAR16), \r
2757 CommandLine,\r
2758 PrintBuffSize/sizeof(CHAR16) - 1\r
2759 );\r
2760\r
2761 LastCommand = NewScriptFile->CurrentCommand;\r
2762\r
2763 for (CommandLine3 = CommandLine2 ; CommandLine3[0] == L' ' ; CommandLine3++);\r
2764\r
2765 if (CommandLine3 != NULL && CommandLine3[0] == L':' ) {\r
2766 //\r
2767 // This line is a goto target / label\r
2768 //\r
2769 } else {\r
2770 if (CommandLine3 != NULL && StrLen(CommandLine3) > 0) {\r
2771 if (CommandLine3[0] == L'@') {\r
2772 //\r
2773 // We need to save the current echo state\r
2774 // and disable echo for just this command.\r
2775 //\r
2776 PreCommandEchoState = ShellCommandGetEchoState();\r
2777 ShellCommandSetEchoState(FALSE);\r
2778 Status = RunCommand(CommandLine3+1);\r
2779\r
2780 //\r
2781 // If command was "@echo -off" or "@echo -on" then don't restore echo state\r
2782 //\r
2783 if (StrCmp (L"@echo -off", CommandLine3) != 0 &&\r
2784 StrCmp (L"@echo -on", CommandLine3) != 0) {\r
2785 //\r
2786 // Now restore the pre-'@' echo state.\r
2787 //\r
2788 ShellCommandSetEchoState(PreCommandEchoState);\r
2789 }\r
2790 } else {\r
2791 if (ShellCommandGetEchoState()) {\r
2792 CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");\r
2793 if (CurDir != NULL && StrLen(CurDir) > 1) {\r
2794 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);\r
2795 } else {\r
2796 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);\r
2797 }\r
2798 ShellPrintEx(-1, -1, L"%s\r\n", CommandLine2);\r
2799 }\r
2800 Status = RunCommand(CommandLine3);\r
2801 }\r
2802 }\r
2803\r
2804 if (ShellCommandGetScriptExit()) {\r
2805 //\r
2806 // ShellCommandGetExitCode() always returns a UINT64\r
2807 //\r
2808 UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ShellCommandGetExitCode());\r
2809 DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););\r
2810 InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);\r
2811\r
2812 ShellCommandRegisterExit(FALSE, 0);\r
2813 Status = EFI_SUCCESS;\r
2814 break;\r
2815 }\r
2816 if (ShellGetExecutionBreakFlag()) {\r
2817 break;\r
2818 }\r
2819 if (EFI_ERROR(Status)) {\r
2820 break;\r
2821 }\r
2822 if (ShellCommandGetExit()) {\r
2823 break;\r
2824 }\r
2825 }\r
2826 //\r
2827 // If that commend did not update the CurrentCommand then we need to advance it...\r
2828 //\r
2829 if (LastCommand == NewScriptFile->CurrentCommand) {\r
2830 NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
2831 if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {\r
2832 NewScriptFile->CurrentCommand->Reset = TRUE;\r
2833 }\r
2834 }\r
2835 } else {\r
2836 NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
2837 if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {\r
2838 NewScriptFile->CurrentCommand->Reset = TRUE;\r
2839 }\r
2840 }\r
2841 }\r
2842\r
2843\r
2844 FreePool(CommandLine);\r
2845 FreePool(CommandLine2);\r
2846 ShellCommandSetNewScript (NULL);\r
2847\r
2848 //\r
2849 // Only if this was the last script reset the state.\r
2850 //\r
2851 if (ShellCommandGetCurrentScriptFile()==NULL) {\r
2852 ShellCommandSetEchoState(PreScriptEchoState);\r
2853 }\r
2854 return (EFI_SUCCESS);\r
2855}\r
2856\r
2857/**\r
2858 Function to process a NSH script file.\r
2859\r
2860 @param[in] ScriptPath Pointer to the script file name (including file system path).\r
2861 @param[in] Handle the handle of the script file already opened.\r
2862 @param[in] CmdLine the command line to run.\r
2863 @param[in] ParamProtocol the shell parameters protocol pointer\r
2864\r
2865 @retval EFI_SUCCESS the script completed successfully\r
2866**/\r
2867EFI_STATUS\r
2868EFIAPI\r
2869RunScriptFile (\r
2870 IN CONST CHAR16 *ScriptPath,\r
2871 IN SHELL_FILE_HANDLE Handle OPTIONAL,\r
2872 IN CONST CHAR16 *CmdLine,\r
2873 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol\r
2874 )\r
2875{\r
2876 EFI_STATUS Status;\r
2877 SHELL_FILE_HANDLE FileHandle;\r
2878 UINTN Argc;\r
2879 CHAR16 **Argv;\r
2880\r
2881 if (ShellIsFile(ScriptPath) != EFI_SUCCESS) {\r
2882 return (EFI_INVALID_PARAMETER);\r
2883 }\r
2884\r
2885 //\r
2886 // get the argc and argv updated for scripts\r
2887 //\r
2888 Status = UpdateArgcArgv(ParamProtocol, CmdLine, &Argv, &Argc);\r
2889 if (!EFI_ERROR(Status)) {\r
2890\r
2891 if (Handle == NULL) {\r
2892 //\r
2893 // open the file\r
2894 //\r
2895 Status = ShellOpenFileByName(ScriptPath, &FileHandle, EFI_FILE_MODE_READ, 0);\r
2896 if (!EFI_ERROR(Status)) {\r
2897 //\r
2898 // run it\r
2899 //\r
2900 Status = RunScriptFileHandle(FileHandle, ScriptPath);\r
2901\r
2902 //\r
2903 // now close the file\r
2904 //\r
2905 ShellCloseFile(&FileHandle);\r
2906 }\r
2907 } else {\r
2908 Status = RunScriptFileHandle(Handle, ScriptPath);\r
2909 }\r
2910 }\r
2911\r
2912 //\r
2913 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.\r
2914 // This is safe even if the update API failed. In this case, it may be a no-op.\r
2915 //\r
2916 RestoreArgcArgv(ParamProtocol, &Argv, &Argc);\r
2917\r
2918 return (Status);\r
2919}\r
2920\r
2921/**\r
2922 Return the pointer to the first occurrence of any character from a list of characters.\r
2923\r
2924 @param[in] String the string to parse\r
2925 @param[in] CharacterList the list of character to look for\r
2926 @param[in] EscapeCharacter An escape character to skip\r
2927\r
2928 @return the location of the first character in the string\r
2929 @retval CHAR_NULL no instance of any character in CharacterList was found in String\r
2930**/\r
2931CONST CHAR16*\r
2932EFIAPI\r
2933FindFirstCharacter(\r
2934 IN CONST CHAR16 *String,\r
2935 IN CONST CHAR16 *CharacterList,\r
2936 IN CONST CHAR16 EscapeCharacter\r
2937 )\r
2938{\r
2939 UINT32 WalkChar;\r
2940 UINT32 WalkStr;\r
2941\r
2942 for (WalkStr = 0; WalkStr < StrLen(String); WalkStr++) {\r
2943 if (String[WalkStr] == EscapeCharacter) {\r
2944 WalkStr++;\r
2945 continue;\r
2946 }\r
2947 for (WalkChar = 0; WalkChar < StrLen(CharacterList); WalkChar++) {\r
2948 if (String[WalkStr] == CharacterList[WalkChar]) {\r
2949 return (&String[WalkStr]);\r
2950 }\r
2951 }\r
2952 }\r
2953 return (String + StrLen(String));\r
2954}\r
EFI Development Kit II mirror for PVE