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