]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - ShellPkg/Application/Shell/Shell.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
NetworkPkg: Fix MSFT C4255 warning
[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 Function try to find location of the Startup.nsh file.\r
1136 \r
1137 The buffer is callee allocated and should be freed by the caller.\r
1138\r
1139 @param ImageDevicePath The path to the image for shell. first place to look for the startup script\r
1140 @param FileDevicePath The path to the file for shell. second place to look for the startup script.\r
1141\r
1142 @retval NULL No Startup.nsh file was found.\r
1143 @return !=NULL Pointer to NULL-terminated path.\r
1144**/\r
1145CHAR16 *\r
1146LocateStartupScript (\r
1147 IN EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath,\r
1148 IN EFI_DEVICE_PATH_PROTOCOL *FileDevicePath\r
1149 )\r
1150{\r
1151 CHAR16 *StartupScriptPath;\r
1152 CHAR16 *TempSpot;\r
1153 CONST CHAR16 *MapName;\r
1154 UINTN Size;\r
1155\r
1156 StartupScriptPath = NULL;\r
1157 Size = 0;\r
1158\r
1159 //\r
1160 // Try to find 'Startup.nsh' in the directory where the shell itself was launched.\r
1161 //\r
1162 MapName = ShellInfoObject.NewEfiShellProtocol->GetMapFromDevicePath (&ImageDevicePath);\r
1163 if (MapName != NULL) { \r
1164 StartupScriptPath = StrnCatGrow (&StartupScriptPath, &Size, MapName, 0);\r
1165 if (StartupScriptPath == NULL) {\r
1166 //\r
1167 // Do not locate the startup script in sys path when out of resource.\r
1168 //\r
1169 return NULL;\r
1170 }\r
1171 TempSpot = StrStr (StartupScriptPath, L";");\r
1172 if (TempSpot != NULL) {\r
1173 *TempSpot = CHAR_NULL;\r
1174 }\r
1175\r
1176 StartupScriptPath = StrnCatGrow (&StartupScriptPath, &Size, ((FILEPATH_DEVICE_PATH *)FileDevicePath)->PathName, 0);\r
1177 PathRemoveLastItem (StartupScriptPath);\r
1178 StartupScriptPath = StrnCatGrow (&StartupScriptPath, &Size, mStartupScript, 0);\r
1179 }\r
1180\r
1181 //\r
1182 // Try to find 'Startup.nsh' in the execution path defined by the envrionment variable PATH.\r
1183 //\r
1184 if ((StartupScriptPath == NULL) || EFI_ERROR (ShellIsFile (StartupScriptPath))) {\r
1185 SHELL_FREE_NON_NULL (StartupScriptPath);\r
1186 StartupScriptPath = ShellFindFilePath (mStartupScript);\r
1187 }\r
1188\r
1189 return StartupScriptPath;\r
1190}\r
1191\r
1192/**\r
1193 Handles all interaction with the default startup script.\r
1194\r
1195 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.\r
1196\r
1197 @param ImagePath the path to the image for shell. first place to look for the startup script\r
1198 @param FilePath the path to the file for shell. second place to look for the startup script.\r
1199\r
1200 @retval EFI_SUCCESS the variable is initialized.\r
1201**/\r
1202EFI_STATUS\r
1203DoStartupScript(\r
1204 IN EFI_DEVICE_PATH_PROTOCOL *ImagePath,\r
1205 IN EFI_DEVICE_PATH_PROTOCOL *FilePath\r
1206 )\r
1207{\r
1208 EFI_STATUS Status;\r
1209 EFI_STATUS CalleeStatus;\r
1210 UINTN Delay;\r
1211 EFI_INPUT_KEY Key;\r
1212 CHAR16 *FileStringPath;\r
1213 UINTN NewSize;\r
1214\r
1215 Key.UnicodeChar = CHAR_NULL;\r
1216 Key.ScanCode = 0;\r
1217\r
1218 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup && ShellInfoObject.ShellInitSettings.FileName != NULL) {\r
1219 //\r
1220 // launch something else instead\r
1221 //\r
1222 NewSize = StrSize(ShellInfoObject.ShellInitSettings.FileName);\r
1223 if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {\r
1224 NewSize += StrSize(ShellInfoObject.ShellInitSettings.FileOptions) + sizeof(CHAR16);\r
1225 }\r
1226 FileStringPath = AllocateZeroPool(NewSize);\r
1227 if (FileStringPath == NULL) {\r
1228 return (EFI_OUT_OF_RESOURCES);\r
1229 }\r
1230 StrCpyS(FileStringPath, NewSize/sizeof(CHAR16), ShellInfoObject.ShellInitSettings.FileName);\r
1231 if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {\r
1232 StrnCatS(FileStringPath, NewSize/sizeof(CHAR16), L" ", NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);\r
1233 StrnCatS(FileStringPath, NewSize/sizeof(CHAR16), ShellInfoObject.ShellInitSettings.FileOptions, NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);\r
1234 }\r
1235 Status = RunShellCommand(FileStringPath, &CalleeStatus);\r
1236 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit == TRUE) {\r
1237 ShellCommandRegisterExit(gEfiShellProtocol->BatchIsActive(), (UINT64)CalleeStatus);\r
1238 }\r
1239 FreePool(FileStringPath);\r
1240 return (Status);\r
1241\r
1242 }\r
1243\r
1244 //\r
1245 // for shell level 0 we do no scripts\r
1246 // Without the Startup bit overriding we allow for nostartup to prevent scripts\r
1247 //\r
1248 if ( (PcdGet8(PcdShellSupportLevel) < 1)\r
1249 || (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup)\r
1250 ){\r
1251 return (EFI_SUCCESS);\r
1252 }\r
1253\r
1254 gST->ConOut->EnableCursor(gST->ConOut, FALSE);\r
1255 //\r
1256 // print out our warning and see if they press a key\r
1257 //\r
1258 for ( Status = EFI_UNSUPPORTED, Delay = ShellInfoObject.ShellInitSettings.Delay\r
1259 ; Delay != 0 && EFI_ERROR(Status)\r
1260 ; Delay--\r
1261 ){\r
1262 ShellPrintHiiEx(0, gST->ConOut->Mode->CursorRow, NULL, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION), ShellInfoObject.HiiHandle, Delay);\r
1263 gBS->Stall (1000000);\r
1264 if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {\r
1265 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
1266 }\r
1267 }\r
1268 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CRLF), ShellInfoObject.HiiHandle);\r
1269 gST->ConOut->EnableCursor(gST->ConOut, TRUE);\r
1270\r
1271 //\r
1272 // ESC was pressed\r
1273 //\r
1274 if (Status == EFI_SUCCESS && Key.UnicodeChar == 0 && Key.ScanCode == SCAN_ESC) {\r
1275 return (EFI_SUCCESS);\r
1276 }\r
1277\r
1278 FileStringPath = LocateStartupScript (ImagePath, FilePath);\r
1279 if (FileStringPath != NULL) {\r
1280 Status = RunScriptFile (FileStringPath, NULL, L"", ShellInfoObject.NewShellParametersProtocol);\r
1281 FreePool (FileStringPath);\r
1282 } else {\r
1283 //\r
1284 // we return success since startup script is not mandatory.\r
1285 //\r
1286 Status = EFI_SUCCESS;\r
1287 }\r
1288\r
1289 return (Status);\r
1290}\r
1291\r
1292/**\r
1293 Function to perform the shell prompt looping. It will do a single prompt,\r
1294 dispatch the result, and then return. It is expected that the caller will\r
1295 call this function in a loop many times.\r
1296\r
1297 @retval EFI_SUCCESS\r
1298 @retval RETURN_ABORTED\r
1299**/\r
1300EFI_STATUS\r
1301DoShellPrompt (\r
1302 VOID\r
1303 )\r
1304{\r
1305 UINTN Column;\r
1306 UINTN Row;\r
1307 CHAR16 *CmdLine;\r
1308 CONST CHAR16 *CurDir;\r
1309 UINTN BufferSize;\r
1310 EFI_STATUS Status;\r
1311 LIST_ENTRY OldBufferList;\r
1312\r
1313 CurDir = NULL;\r
1314\r
1315 //\r
1316 // Get screen setting to decide size of the command line buffer\r
1317 //\r
1318 gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Column, &Row);\r
1319 BufferSize = Column * Row * sizeof (CHAR16);\r
1320 CmdLine = AllocateZeroPool (BufferSize);\r
1321 if (CmdLine == NULL) {\r
1322 return EFI_OUT_OF_RESOURCES;\r
1323 }\r
1324\r
1325 SaveBufferList(&OldBufferList);\r
1326 CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");\r
1327\r
1328 //\r
1329 // Prompt for input\r
1330 //\r
1331 gST->ConOut->SetCursorPosition (gST->ConOut, 0, gST->ConOut->Mode->CursorRow);\r
1332\r
1333 if (CurDir != NULL && StrLen(CurDir) > 1) {\r
1334 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);\r
1335 } else {\r
1336 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);\r
1337 }\r
1338\r
1339 //\r
1340 // Read a line from the console\r
1341 //\r
1342 Status = ShellInfoObject.NewEfiShellProtocol->ReadFile(ShellInfoObject.NewShellParametersProtocol->StdIn, &BufferSize, CmdLine);\r
1343\r
1344 //\r
1345 // Null terminate the string and parse it\r
1346 //\r
1347 if (!EFI_ERROR (Status)) {\r
1348 CmdLine[BufferSize / sizeof (CHAR16)] = CHAR_NULL;\r
1349 Status = RunCommand(CmdLine);\r
1350 }\r
1351\r
1352 //\r
1353 // Done with this command\r
1354 //\r
1355 RestoreBufferList(&OldBufferList);\r
1356 FreePool (CmdLine);\r
1357 return Status;\r
1358}\r
1359\r
1360/**\r
1361 Add a buffer to the Buffer To Free List for safely returning buffers to other\r
1362 places without risking letting them modify internal shell information.\r
1363\r
1364 @param Buffer Something to pass to FreePool when the shell is exiting.\r
1365**/\r
1366VOID*\r
1367AddBufferToFreeList (\r
1368 VOID *Buffer\r
1369 )\r
1370{\r
1371 BUFFER_LIST *BufferListEntry;\r
1372\r
1373 if (Buffer == NULL) {\r
1374 return (NULL);\r
1375 }\r
1376\r
1377 BufferListEntry = AllocateZeroPool (sizeof (BUFFER_LIST));\r
1378 if (BufferListEntry == NULL) {\r
1379 return NULL;\r
1380 }\r
1381\r
1382 BufferListEntry->Buffer = Buffer;\r
1383 InsertTailList (&ShellInfoObject.BufferToFreeList.Link, &BufferListEntry->Link);\r
1384 return (Buffer);\r
1385}\r
1386\r
1387\r
1388/**\r
1389 Create a new buffer list and stores the old one to OldBufferList \r
1390\r
1391 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.\r
1392**/\r
1393VOID\r
1394SaveBufferList (\r
1395 OUT LIST_ENTRY *OldBufferList\r
1396 )\r
1397{\r
1398 CopyMem (OldBufferList, &ShellInfoObject.BufferToFreeList.Link, sizeof (LIST_ENTRY));\r
1399 InitializeListHead (&ShellInfoObject.BufferToFreeList.Link);\r
1400}\r
1401\r
1402/**\r
1403 Restore previous nodes into BufferToFreeList .\r
1404\r
1405 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.\r
1406**/\r
1407VOID\r
1408RestoreBufferList (\r
1409 IN OUT LIST_ENTRY *OldBufferList\r
1410 )\r
1411{\r
1412 FreeBufferList (&ShellInfoObject.BufferToFreeList);\r
1413 CopyMem (&ShellInfoObject.BufferToFreeList.Link, OldBufferList, sizeof (LIST_ENTRY));\r
1414}\r
1415\r
1416\r
1417/**\r
1418 Add a buffer to the Line History List\r
1419\r
1420 @param Buffer The line buffer to add.\r
1421**/\r
1422VOID\r
1423AddLineToCommandHistory(\r
1424 IN CONST CHAR16 *Buffer\r
1425 )\r
1426{\r
1427 BUFFER_LIST *Node;\r
1428 BUFFER_LIST *Walker;\r
1429 UINT16 MaxHistoryCmdCount;\r
1430 UINT16 Count;\r
1431\r
1432 Count = 0;\r
1433 MaxHistoryCmdCount = PcdGet16(PcdShellMaxHistoryCommandCount);\r
1434 \r
1435 if (MaxHistoryCmdCount == 0) {\r
1436 return ;\r
1437 }\r
1438\r
1439\r
1440 Node = AllocateZeroPool(sizeof(BUFFER_LIST));\r
1441 if (Node == NULL) {\r
1442 return;\r
1443 }\r
1444\r
1445 Node->Buffer = AllocateCopyPool (StrSize (Buffer), Buffer);\r
1446 if (Node->Buffer == NULL) {\r
1447 FreePool (Node);\r
1448 return;\r
1449 }\r
1450\r
1451 for ( Walker = (BUFFER_LIST*)GetFirstNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link)\r
1452 ; !IsNull(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Walker->Link)\r
1453 ; Walker = (BUFFER_LIST*)GetNextNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Walker->Link)\r
1454 ){\r
1455 Count++;\r
1456 }\r
1457 if (Count < MaxHistoryCmdCount){\r
1458 InsertTailList(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link);\r
1459 } else {\r
1460 Walker = (BUFFER_LIST*)GetFirstNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link);\r
1461 RemoveEntryList(&Walker->Link);\r
1462 if (Walker->Buffer != NULL) {\r
1463 FreePool(Walker->Buffer);\r
1464 }\r
1465 FreePool(Walker);\r
1466 InsertTailList(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link);\r
1467 }\r
1468}\r
1469\r
1470/**\r
1471 Checks if a string is an alias for another command. If yes, then it replaces the alias name\r
1472 with the correct command name.\r
1473\r
1474 @param[in, out] CommandString Upon entry the potential alias. Upon return the\r
1475 command name if it was an alias. If it was not\r
1476 an alias it will be unchanged. This function may\r
1477 change the buffer to fit the command name.\r
1478\r
1479 @retval EFI_SUCCESS The name was changed.\r
1480 @retval EFI_SUCCESS The name was not an alias.\r
1481 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
1482**/\r
1483EFI_STATUS\r
1484ShellConvertAlias(\r
1485 IN OUT CHAR16 **CommandString\r
1486 )\r
1487{\r
1488 CONST CHAR16 *NewString;\r
1489\r
1490 NewString = ShellInfoObject.NewEfiShellProtocol->GetAlias(*CommandString, NULL);\r
1491 if (NewString == NULL) {\r
1492 return (EFI_SUCCESS);\r
1493 }\r
1494 FreePool(*CommandString);\r
1495 *CommandString = AllocateCopyPool(StrSize(NewString), NewString);\r
1496 if (*CommandString == NULL) {\r
1497 return (EFI_OUT_OF_RESOURCES);\r
1498 }\r
1499 return (EFI_SUCCESS);\r
1500}\r
1501\r
1502/**\r
1503 This function will eliminate unreplaced (and therefore non-found) environment variables.\r
1504\r
1505 @param[in,out] CmdLine The command line to update.\r
1506**/\r
1507EFI_STATUS\r
1508StripUnreplacedEnvironmentVariables(\r
1509 IN OUT CHAR16 *CmdLine\r
1510 )\r
1511{\r
1512 CHAR16 *FirstPercent;\r
1513 CHAR16 *FirstQuote;\r
1514 CHAR16 *SecondPercent;\r
1515 CHAR16 *SecondQuote;\r
1516 CHAR16 *CurrentLocator;\r
1517\r
1518 for (CurrentLocator = CmdLine ; CurrentLocator != NULL ; ) {\r
1519 FirstQuote = FindNextInstance(CurrentLocator, L"\"", TRUE);\r
1520 FirstPercent = FindNextInstance(CurrentLocator, L"%", TRUE);\r
1521 SecondPercent = FirstPercent!=NULL?FindNextInstance(FirstPercent+1, L"%", TRUE):NULL;\r
1522 if (FirstPercent == NULL || SecondPercent == NULL) {\r
1523 //\r
1524 // If we ever don't have 2 % we are done.\r
1525 //\r
1526 break;\r
1527 }\r
1528\r
1529 if (FirstQuote!= NULL && FirstQuote < FirstPercent) {\r
1530 SecondQuote = FindNextInstance(FirstQuote+1, L"\"", TRUE);\r
1531 //\r
1532 // Quote is first found\r
1533 //\r
1534\r
1535 if (SecondQuote < FirstPercent) {\r
1536 //\r
1537 // restart after the pair of "\r
1538 //\r
1539 CurrentLocator = SecondQuote + 1;\r
1540 } else /* FirstPercent < SecondQuote */{\r
1541 //\r
1542 // Restart on the first percent\r
1543 //\r
1544 CurrentLocator = FirstPercent;\r
1545 }\r
1546 continue;\r
1547 }\r
1548 \r
1549 if (FirstQuote == NULL || SecondPercent < FirstQuote) {\r
1550 if (IsValidEnvironmentVariableName(FirstPercent, SecondPercent)) {\r
1551 //\r
1552 // We need to remove from FirstPercent to SecondPercent\r
1553 //\r
1554 CopyMem(FirstPercent, SecondPercent + 1, StrSize(SecondPercent + 1));\r
1555 //\r
1556 // don't need to update the locator. both % characters are gone.\r
1557 //\r
1558 } else {\r
1559 CurrentLocator = SecondPercent + 1;\r
1560 }\r
1561 continue;\r
1562 }\r
1563 CurrentLocator = FirstQuote;\r
1564 }\r
1565 return (EFI_SUCCESS);\r
1566}\r
1567\r
1568/**\r
1569 Function allocates a new command line and replaces all instances of environment\r
1570 variable names that are correctly preset to their values.\r
1571\r
1572 If the return value is not NULL the memory must be caller freed.\r
1573\r
1574 @param[in] OriginalCommandLine The original command line\r
1575\r
1576 @retval NULL An error occurred.\r
1577 @return The new command line with no environment variables present.\r
1578**/\r
1579CHAR16*\r
1580ShellConvertVariables (\r
1581 IN CONST CHAR16 *OriginalCommandLine\r
1582 )\r
1583{\r
1584 CONST CHAR16 *MasterEnvList;\r
1585 UINTN NewSize;\r
1586 CHAR16 *NewCommandLine1;\r
1587 CHAR16 *NewCommandLine2;\r
1588 CHAR16 *Temp;\r
1589 UINTN ItemSize;\r
1590 CHAR16 *ItemTemp;\r
1591 SCRIPT_FILE *CurrentScriptFile;\r
1592 ALIAS_LIST *AliasListNode;\r
1593\r
1594 ASSERT(OriginalCommandLine != NULL);\r
1595\r
1596 ItemSize = 0;\r
1597 NewSize = StrSize(OriginalCommandLine);\r
1598 CurrentScriptFile = ShellCommandGetCurrentScriptFile();\r
1599 Temp = NULL;\r
1600\r
1601 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?\r
1602\r
1603 //\r
1604 // calculate the size required for the post-conversion string...\r
1605 //\r
1606 if (CurrentScriptFile != NULL) {\r
1607 for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)\r
1608 ; !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1609 ; AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1610 ){\r
1611 for (Temp = StrStr(OriginalCommandLine, AliasListNode->Alias)\r
1612 ; Temp != NULL\r
1613 ; Temp = StrStr(Temp+1, AliasListNode->Alias)\r
1614 ){\r
1615 //\r
1616 // we need a preceding and if there is space no ^ preceding (if no space ignore)\r
1617 //\r
1618 if ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2)) {\r
1619 NewSize += StrSize(AliasListNode->CommandString);\r
1620 }\r
1621 }\r
1622 }\r
1623 }\r
1624\r
1625 for (MasterEnvList = EfiShellGetEnv(NULL)\r
1626 ; MasterEnvList != NULL && *MasterEnvList != CHAR_NULL //&& *(MasterEnvList+1) != CHAR_NULL\r
1627 ; MasterEnvList += StrLen(MasterEnvList) + 1\r
1628 ){\r
1629 if (StrSize(MasterEnvList) > ItemSize) {\r
1630 ItemSize = StrSize(MasterEnvList);\r
1631 }\r
1632 for (Temp = StrStr(OriginalCommandLine, MasterEnvList)\r
1633 ; Temp != NULL\r
1634 ; Temp = StrStr(Temp+1, MasterEnvList)\r
1635 ){\r
1636 //\r
1637 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)\r
1638 //\r
1639 if (*(Temp-1) == L'%' && *(Temp+StrLen(MasterEnvList)) == L'%' &&\r
1640 ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2))) {\r
1641 NewSize+=StrSize(EfiShellGetEnv(MasterEnvList));\r
1642 }\r
1643 }\r
1644 }\r
1645\r
1646 //\r
1647 // now do the replacements...\r
1648 //\r
1649 NewCommandLine1 = AllocateZeroPool (NewSize);\r
1650 NewCommandLine2 = AllocateZeroPool(NewSize);\r
1651 ItemTemp = AllocateZeroPool(ItemSize+(2*sizeof(CHAR16)));\r
1652 if (NewCommandLine1 == NULL || NewCommandLine2 == NULL || ItemTemp == NULL) {\r
1653 SHELL_FREE_NON_NULL(NewCommandLine1);\r
1654 SHELL_FREE_NON_NULL(NewCommandLine2);\r
1655 SHELL_FREE_NON_NULL(ItemTemp);\r
1656 return (NULL);\r
1657 }\r
1658 CopyMem (NewCommandLine1, OriginalCommandLine, StrSize (OriginalCommandLine));\r
1659\r
1660 for (MasterEnvList = EfiShellGetEnv(NULL)\r
1661 ; MasterEnvList != NULL && *MasterEnvList != CHAR_NULL\r
1662 ; MasterEnvList += StrLen(MasterEnvList) + 1\r
1663 ){\r
1664 StrCpyS( ItemTemp, \r
1665 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1666 L"%"\r
1667 );\r
1668 StrCatS( ItemTemp, \r
1669 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1670 MasterEnvList\r
1671 );\r
1672 StrCatS( ItemTemp, \r
1673 ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16)), \r
1674 L"%"\r
1675 );\r
1676 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, ItemTemp, EfiShellGetEnv(MasterEnvList), TRUE, FALSE);\r
1677 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1678 }\r
1679 if (CurrentScriptFile != NULL) {\r
1680 for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)\r
1681 ; !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1682 ; AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)\r
1683 ){\r
1684 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, AliasListNode->Alias, AliasListNode->CommandString, TRUE, FALSE);\r
1685 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1686 }\r
1687 }\r
1688\r
1689 //\r
1690 // Remove non-existent environment variables\r
1691 //\r
1692 StripUnreplacedEnvironmentVariables(NewCommandLine1);\r
1693\r
1694 //\r
1695 // Now cleanup any straggler intentionally ignored "%" characters\r
1696 //\r
1697 ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, L"^%", L"%", TRUE, FALSE);\r
1698 StrCpyS(NewCommandLine1, NewSize/sizeof(CHAR16), NewCommandLine2);\r
1699 \r
1700 FreePool(NewCommandLine2);\r
1701 FreePool(ItemTemp);\r
1702\r
1703 return (NewCommandLine1);\r
1704}\r
1705\r
1706/**\r
1707 Internal function to run a command line with pipe usage.\r
1708\r
1709 @param[in] CmdLine The pointer to the command line.\r
1710 @param[in] StdIn The pointer to the Standard input.\r
1711 @param[in] StdOut The pointer to the Standard output.\r
1712\r
1713 @retval EFI_SUCCESS The split command is executed successfully.\r
1714 @retval other Some error occurs when executing the split command.\r
1715**/\r
1716EFI_STATUS\r
1717RunSplitCommand(\r
1718 IN CONST CHAR16 *CmdLine,\r
1719 IN SHELL_FILE_HANDLE StdIn,\r
1720 IN SHELL_FILE_HANDLE StdOut\r
1721 )\r
1722{\r
1723 EFI_STATUS Status;\r
1724 CHAR16 *NextCommandLine;\r
1725 CHAR16 *OurCommandLine;\r
1726 UINTN Size1;\r
1727 UINTN Size2;\r
1728 SPLIT_LIST *Split;\r
1729 SHELL_FILE_HANDLE TempFileHandle;\r
1730 BOOLEAN Unicode;\r
1731\r
1732 ASSERT(StdOut == NULL);\r
1733\r
1734 ASSERT(StrStr(CmdLine, L"|") != NULL);\r
1735\r
1736 Status = EFI_SUCCESS;\r
1737 NextCommandLine = NULL;\r
1738 OurCommandLine = NULL;\r
1739 Size1 = 0;\r
1740 Size2 = 0;\r
1741\r
1742 NextCommandLine = StrnCatGrow(&NextCommandLine, &Size1, StrStr(CmdLine, L"|")+1, 0);\r
1743 OurCommandLine = StrnCatGrow(&OurCommandLine , &Size2, CmdLine , StrStr(CmdLine, L"|") - CmdLine);\r
1744\r
1745 if (NextCommandLine == NULL || OurCommandLine == NULL) {\r
1746 SHELL_FREE_NON_NULL(OurCommandLine);\r
1747 SHELL_FREE_NON_NULL(NextCommandLine);\r
1748 return (EFI_OUT_OF_RESOURCES);\r
1749 } else if (StrStr(OurCommandLine, L"|") != NULL || Size1 == 0 || Size2 == 0) {\r
1750 SHELL_FREE_NON_NULL(OurCommandLine);\r
1751 SHELL_FREE_NON_NULL(NextCommandLine);\r
1752 return (EFI_INVALID_PARAMETER);\r
1753 } else if (NextCommandLine[0] == L'a' &&\r
1754 (NextCommandLine[1] == L' ' || NextCommandLine[1] == CHAR_NULL)\r
1755 ){\r
1756 CopyMem(NextCommandLine, NextCommandLine+1, StrSize(NextCommandLine) - sizeof(NextCommandLine[0]));\r
1757 while (NextCommandLine[0] == L' ') {\r
1758 CopyMem(NextCommandLine, NextCommandLine+1, StrSize(NextCommandLine) - sizeof(NextCommandLine[0]));\r
1759 }\r
1760 if (NextCommandLine[0] == CHAR_NULL) {\r
1761 SHELL_FREE_NON_NULL(OurCommandLine);\r
1762 SHELL_FREE_NON_NULL(NextCommandLine);\r
1763 return (EFI_INVALID_PARAMETER);\r
1764 }\r
1765 Unicode = FALSE;\r
1766 } else {\r
1767 Unicode = TRUE;\r
1768 }\r
1769\r
1770\r
1771 //\r
1772 // make a SPLIT_LIST item and add to list\r
1773 //\r
1774 Split = AllocateZeroPool(sizeof(SPLIT_LIST));\r
1775 if (Split == NULL) {\r
1776 return EFI_OUT_OF_RESOURCES;\r
1777 }\r
1778 Split->SplitStdIn = StdIn;\r
1779 Split->SplitStdOut = ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode), NULL);\r
1780 ASSERT(Split->SplitStdOut != NULL);\r
1781 InsertHeadList(&ShellInfoObject.SplitList.Link, &Split->Link);\r
1782\r
1783 Status = RunCommand(OurCommandLine);\r
1784\r
1785 //\r
1786 // move the output from the first to the in to the second.\r
1787 //\r
1788 TempFileHandle = Split->SplitStdOut;\r
1789 if (Split->SplitStdIn == StdIn) {\r
1790 Split->SplitStdOut = NULL;\r
1791 } else {\r
1792 Split->SplitStdOut = Split->SplitStdIn;\r
1793 }\r
1794 Split->SplitStdIn = TempFileHandle;\r
1795 ShellInfoObject.NewEfiShellProtocol->SetFilePosition (Split->SplitStdIn, 0);\r
1796\r
1797 if (!EFI_ERROR(Status)) {\r
1798 Status = RunCommand(NextCommandLine);\r
1799 }\r
1800\r
1801 //\r
1802 // remove the top level from the ScriptList\r
1803 //\r
1804 ASSERT((SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link) == Split);\r
1805 RemoveEntryList(&Split->Link);\r
1806\r
1807 //\r
1808 // Note that the original StdIn is now the StdOut...\r
1809 //\r
1810 if (Split->SplitStdOut != NULL) {\r
1811 ShellInfoObject.NewEfiShellProtocol->CloseFile (Split->SplitStdOut);\r
1812 }\r
1813 if (Split->SplitStdIn != NULL) {\r
1814 ShellInfoObject.NewEfiShellProtocol->CloseFile (Split->SplitStdIn);\r
1815 }\r
1816\r
1817 FreePool(Split);\r
1818 FreePool(NextCommandLine);\r
1819 FreePool(OurCommandLine);\r
1820\r
1821 return (Status);\r
1822}\r
1823\r
1824/**\r
1825 Take the original command line, substitute any variables, free \r
1826 the original string, return the modified copy.\r
1827\r
1828 @param[in] CmdLine pointer to the command line to update.\r
1829\r
1830 @retval EFI_SUCCESS the function was successful.\r
1831 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.\r
1832**/\r
1833EFI_STATUS\r
1834ShellSubstituteVariables(\r
1835 IN CHAR16 **CmdLine\r
1836 )\r
1837{\r
1838 CHAR16 *NewCmdLine;\r
1839 NewCmdLine = ShellConvertVariables(*CmdLine);\r
1840 SHELL_FREE_NON_NULL(*CmdLine);\r
1841 if (NewCmdLine == NULL) {\r
1842 return (EFI_OUT_OF_RESOURCES);\r
1843 }\r
1844 *CmdLine = NewCmdLine;\r
1845 return (EFI_SUCCESS);\r
1846}\r
1847\r
1848/**\r
1849 Take the original command line, substitute any alias in the first group of space delimited characters, free \r
1850 the original string, return the modified copy.\r
1851\r
1852 @param[in] CmdLine pointer to the command line to update.\r
1853\r
1854 @retval EFI_SUCCESS the function was successful.\r
1855 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.\r
1856**/\r
1857EFI_STATUS\r
1858ShellSubstituteAliases(\r
1859 IN CHAR16 **CmdLine\r
1860 )\r
1861{\r
1862 CHAR16 *NewCmdLine;\r
1863 CHAR16 *CommandName;\r
1864 EFI_STATUS Status;\r
1865 UINTN PostAliasSize;\r
1866 ASSERT(CmdLine != NULL);\r
1867 ASSERT(*CmdLine!= NULL);\r
1868\r
1869\r
1870 CommandName = NULL;\r
1871 if (StrStr((*CmdLine), L" ") == NULL){\r
1872 StrnCatGrow(&CommandName, NULL, (*CmdLine), 0);\r
1873 } else {\r
1874 StrnCatGrow(&CommandName, NULL, (*CmdLine), StrStr((*CmdLine), L" ") - (*CmdLine));\r
1875 }\r
1876\r
1877 //\r
1878 // This cannot happen 'inline' since the CmdLine can need extra space.\r
1879 //\r
1880 NewCmdLine = NULL;\r
1881 if (!ShellCommandIsCommandOnList(CommandName)) {\r
1882 //\r
1883 // Convert via alias\r
1884 //\r
1885 Status = ShellConvertAlias(&CommandName);\r
1886 if (EFI_ERROR(Status)){\r
1887 return (Status);\r
1888 }\r
1889 PostAliasSize = 0;\r
1890 NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, CommandName, 0);\r
1891 if (NewCmdLine == NULL) {\r
1892 SHELL_FREE_NON_NULL(CommandName);\r
1893 SHELL_FREE_NON_NULL(*CmdLine);\r
1894 return (EFI_OUT_OF_RESOURCES);\r
1895 }\r
1896 NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, StrStr((*CmdLine), L" "), 0);\r
1897 if (NewCmdLine == NULL) {\r
1898 SHELL_FREE_NON_NULL(CommandName);\r
1899 SHELL_FREE_NON_NULL(*CmdLine);\r
1900 return (EFI_OUT_OF_RESOURCES);\r
1901 }\r
1902 } else {\r
1903 NewCmdLine = StrnCatGrow(&NewCmdLine, NULL, (*CmdLine), 0);\r
1904 }\r
1905\r
1906 SHELL_FREE_NON_NULL(*CmdLine);\r
1907 SHELL_FREE_NON_NULL(CommandName);\r
1908 \r
1909 //\r
1910 // re-assign the passed in double pointer to point to our newly allocated buffer\r
1911 //\r
1912 *CmdLine = NewCmdLine;\r
1913\r
1914 return (EFI_SUCCESS);\r
1915}\r
1916\r
1917/**\r
1918 Takes the Argv[0] part of the command line and determine the meaning of it.\r
1919\r
1920 @param[in] CmdName pointer to the command line to update.\r
1921 \r
1922 @retval Internal_Command The name is an internal command.\r
1923 @retval File_Sys_Change the name is a file system change.\r
1924 @retval Script_File_Name the name is a NSH script file.\r
1925 @retval Unknown_Invalid the name is unknown.\r
1926 @retval Efi_Application the name is an application (.EFI).\r
1927**/\r
1928SHELL_OPERATION_TYPES\r
1929GetOperationType(\r
1930 IN CONST CHAR16 *CmdName\r
1931 )\r
1932{\r
1933 CHAR16* FileWithPath;\r
1934 CONST CHAR16* TempLocation;\r
1935 CONST CHAR16* TempLocation2;\r
1936\r
1937 FileWithPath = NULL;\r
1938 //\r
1939 // test for an internal command.\r
1940 //\r
1941 if (ShellCommandIsCommandOnList(CmdName)) {\r
1942 return (Internal_Command);\r
1943 }\r
1944\r
1945 //\r
1946 // Test for file system change request. anything ending with first : and cant have spaces.\r
1947 //\r
1948 if (CmdName[(StrLen(CmdName)-1)] == L':') {\r
1949 if ( StrStr(CmdName, L" ") != NULL \r
1950 || StrLen(StrStr(CmdName, L":")) > 1\r
1951 ) {\r
1952 return (Unknown_Invalid);\r
1953 }\r
1954 return (File_Sys_Change);\r
1955 }\r
1956\r
1957 //\r
1958 // Test for a file\r
1959 //\r
1960 if ((FileWithPath = ShellFindFilePathEx(CmdName, mExecutableExtensions)) != NULL) {\r
1961 //\r
1962 // See if that file has a script file extension\r
1963 //\r
1964 if (StrLen(FileWithPath) > 4) {\r
1965 TempLocation = FileWithPath+StrLen(FileWithPath)-4;\r
1966 TempLocation2 = mScriptExtension;\r
1967 if (StringNoCaseCompare((VOID*)(&TempLocation), (VOID*)(&TempLocation2)) == 0) {\r
1968 SHELL_FREE_NON_NULL(FileWithPath);\r
1969 return (Script_File_Name);\r
1970 }\r
1971 }\r
1972\r
1973 //\r
1974 // Was a file, but not a script. we treat this as an application.\r
1975 //\r
1976 SHELL_FREE_NON_NULL(FileWithPath);\r
1977 return (Efi_Application);\r
1978 }\r
1979 \r
1980 SHELL_FREE_NON_NULL(FileWithPath);\r
1981 //\r
1982 // No clue what this is... return invalid flag...\r
1983 //\r
1984 return (Unknown_Invalid);\r
1985}\r
1986\r
1987/**\r
1988 Determine if the first item in a command line is valid.\r
1989\r
1990 @param[in] CmdLine The command line to parse.\r
1991\r
1992 @retval EFI_SUCCESS The item is valid.\r
1993 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
1994 @retval EFI_NOT_FOUND The operation type is unknown or invalid.\r
1995**/\r
1996EFI_STATUS \r
1997IsValidSplit(\r
1998 IN CONST CHAR16 *CmdLine\r
1999 )\r
2000{\r
2001 CHAR16 *Temp;\r
2002 CHAR16 *FirstParameter;\r
2003 CHAR16 *TempWalker;\r
2004 EFI_STATUS Status;\r
2005\r
2006 Temp = NULL;\r
2007\r
2008 Temp = StrnCatGrow(&Temp, NULL, CmdLine, 0);\r
2009 if (Temp == NULL) {\r
2010 return (EFI_OUT_OF_RESOURCES);\r
2011 }\r
2012\r
2013 FirstParameter = StrStr(Temp, L"|");\r
2014 if (FirstParameter != NULL) {\r
2015 *FirstParameter = CHAR_NULL;\r
2016 }\r
2017\r
2018 FirstParameter = NULL;\r
2019\r
2020 //\r
2021 // Process the command line\r
2022 //\r
2023 Status = ProcessCommandLineToFinal(&Temp);\r
2024\r
2025 if (!EFI_ERROR(Status)) {\r
2026 FirstParameter = AllocateZeroPool(StrSize(CmdLine));\r
2027 if (FirstParameter == NULL) {\r
2028 SHELL_FREE_NON_NULL(Temp);\r
2029 return (EFI_OUT_OF_RESOURCES);\r
2030 }\r
2031 TempWalker = (CHAR16*)Temp;\r
2032 if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CmdLine), TRUE))) {\r
2033 if (GetOperationType(FirstParameter) == Unknown_Invalid) {\r
2034 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2035 SetLastError(SHELL_NOT_FOUND);\r
2036 Status = EFI_NOT_FOUND;\r
2037 }\r
2038 }\r
2039 }\r
2040\r
2041 SHELL_FREE_NON_NULL(Temp);\r
2042 SHELL_FREE_NON_NULL(FirstParameter);\r
2043 return Status;\r
2044}\r
2045\r
2046/**\r
2047 Determine if a command line contains with a split contains only valid commands.\r
2048\r
2049 @param[in] CmdLine The command line to parse.\r
2050\r
2051 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.\r
2052 @retval EFI_ABORTED CmdLine has at least one invalid command or application.\r
2053**/\r
2054EFI_STATUS\r
2055VerifySplit(\r
2056 IN CONST CHAR16 *CmdLine\r
2057 )\r
2058{\r
2059 CONST CHAR16 *TempSpot;\r
2060 EFI_STATUS Status;\r
2061\r
2062 //\r
2063 // If this was the only item, then get out\r
2064 //\r
2065 if (!ContainsSplit(CmdLine)) {\r
2066 return (EFI_SUCCESS);\r
2067 }\r
2068\r
2069 //\r
2070 // Verify up to the pipe or end character\r
2071 //\r
2072 Status = IsValidSplit(CmdLine);\r
2073 if (EFI_ERROR(Status)) {\r
2074 return (Status);\r
2075 }\r
2076\r
2077 //\r
2078 // recurse to verify the next item\r
2079 //\r
2080 TempSpot = FindFirstCharacter(CmdLine, L"|", L'^') + 1;\r
2081 if (*TempSpot == L'a' && \r
2082 (*(TempSpot + 1) == L' ' || *(TempSpot + 1) == CHAR_NULL)\r
2083 ) {\r
2084 // If it's an ASCII pipe '|a'\r
2085 TempSpot += 1;\r
2086 }\r
2087 \r
2088 return (VerifySplit(TempSpot));\r
2089}\r
2090\r
2091/**\r
2092 Process a split based operation.\r
2093\r
2094 @param[in] CmdLine pointer to the command line to process\r
2095\r
2096 @retval EFI_SUCCESS The operation was successful\r
2097 @return an error occurred.\r
2098**/\r
2099EFI_STATUS\r
2100ProcessNewSplitCommandLine(\r
2101 IN CONST CHAR16 *CmdLine\r
2102 )\r
2103{\r
2104 SPLIT_LIST *Split;\r
2105 EFI_STATUS Status;\r
2106\r
2107 Status = VerifySplit(CmdLine);\r
2108 if (EFI_ERROR(Status)) {\r
2109 return (Status);\r
2110 }\r
2111\r
2112 Split = NULL;\r
2113\r
2114 //\r
2115 // are we in an existing split???\r
2116 //\r
2117 if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {\r
2118 Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);\r
2119 }\r
2120\r
2121 if (Split == NULL) {\r
2122 Status = RunSplitCommand(CmdLine, NULL, NULL);\r
2123 } else {\r
2124 Status = RunSplitCommand(CmdLine, Split->SplitStdIn, Split->SplitStdOut);\r
2125 }\r
2126 if (EFI_ERROR(Status)) {\r
2127 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_SPLIT), ShellInfoObject.HiiHandle, CmdLine);\r
2128 }\r
2129 return (Status);\r
2130}\r
2131\r
2132/**\r
2133 Handle a request to change the current file system.\r
2134\r
2135 @param[in] CmdLine The passed in command line.\r
2136\r
2137 @retval EFI_SUCCESS The operation was successful.\r
2138**/\r
2139EFI_STATUS\r
2140ChangeMappedDrive(\r
2141 IN CONST CHAR16 *CmdLine\r
2142 )\r
2143{\r
2144 EFI_STATUS Status;\r
2145 Status = EFI_SUCCESS;\r
2146\r
2147 //\r
2148 // make sure we are the right operation\r
2149 //\r
2150 ASSERT(CmdLine[(StrLen(CmdLine)-1)] == L':' && StrStr(CmdLine, L" ") == NULL);\r
2151 \r
2152 //\r
2153 // Call the protocol API to do the work\r
2154 //\r
2155 Status = ShellInfoObject.NewEfiShellProtocol->SetCurDir(NULL, CmdLine);\r
2156\r
2157 //\r
2158 // Report any errors\r
2159 //\r
2160 if (EFI_ERROR(Status)) {\r
2161 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_MAPPING), ShellInfoObject.HiiHandle, CmdLine);\r
2162 }\r
2163\r
2164 return (Status);\r
2165}\r
2166\r
2167/**\r
2168 Reprocess the command line to direct all -? to the help command.\r
2169\r
2170 if found, will add "help" as argv[0], and move the rest later.\r
2171\r
2172 @param[in,out] CmdLine pointer to the command line to update\r
2173**/\r
2174EFI_STATUS\r
2175DoHelpUpdate(\r
2176 IN OUT CHAR16 **CmdLine\r
2177 )\r
2178{\r
2179 CHAR16 *CurrentParameter;\r
2180 CHAR16 *Walker;\r
2181 CHAR16 *NewCommandLine;\r
2182 EFI_STATUS Status;\r
2183 UINTN NewCmdLineSize;\r
2184\r
2185 Status = EFI_SUCCESS;\r
2186\r
2187 CurrentParameter = AllocateZeroPool(StrSize(*CmdLine));\r
2188 if (CurrentParameter == NULL) {\r
2189 return (EFI_OUT_OF_RESOURCES);\r
2190 }\r
2191\r
2192 Walker = *CmdLine;\r
2193 while(Walker != NULL && *Walker != CHAR_NULL) {\r
2194 if (!EFI_ERROR(GetNextParameter(&Walker, &CurrentParameter, StrSize(*CmdLine), TRUE))) {\r
2195 if (StrStr(CurrentParameter, L"-?") == CurrentParameter) {\r
2196 CurrentParameter[0] = L' ';\r
2197 CurrentParameter[1] = L' ';\r
2198 NewCmdLineSize = StrSize(L"help ") + StrSize(*CmdLine);\r
2199 NewCommandLine = AllocateZeroPool(NewCmdLineSize);\r
2200 if (NewCommandLine == NULL) {\r
2201 Status = EFI_OUT_OF_RESOURCES;\r
2202 break;\r
2203 }\r
2204\r
2205 //\r
2206 // We know the space is sufficient since we just calculated it.\r
2207 //\r
2208 StrnCpyS(NewCommandLine, NewCmdLineSize/sizeof(CHAR16), L"help ", 5);\r
2209 StrnCatS(NewCommandLine, NewCmdLineSize/sizeof(CHAR16), *CmdLine, StrLen(*CmdLine));\r
2210 SHELL_FREE_NON_NULL(*CmdLine);\r
2211 *CmdLine = NewCommandLine;\r
2212 break;\r
2213 }\r
2214 }\r
2215 }\r
2216\r
2217 SHELL_FREE_NON_NULL(CurrentParameter);\r
2218\r
2219 return (Status);\r
2220}\r
2221\r
2222/**\r
2223 Function to update the shell variable "lasterror".\r
2224\r
2225 @param[in] ErrorCode the error code to put into lasterror.\r
2226**/\r
2227EFI_STATUS\r
2228SetLastError(\r
2229 IN CONST SHELL_STATUS ErrorCode\r
2230 )\r
2231{\r
2232 CHAR16 LeString[19];\r
2233 if (sizeof(EFI_STATUS) == sizeof(UINT64)) {\r
2234 UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ErrorCode);\r
2235 } else {\r
2236 UnicodeSPrint(LeString, sizeof(LeString), L"0x%x", ErrorCode);\r
2237 }\r
2238 DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););\r
2239 InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);\r
2240\r
2241 return (EFI_SUCCESS);\r
2242}\r
2243\r
2244/**\r
2245 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.\r
2246\r
2247 @param[in,out] CmdLine pointer to the command line to update\r
2248\r
2249 @retval EFI_SUCCESS The operation was successful\r
2250 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.\r
2251 @return some other error occurred\r
2252**/\r
2253EFI_STATUS\r
2254ProcessCommandLineToFinal(\r
2255 IN OUT CHAR16 **CmdLine\r
2256 )\r
2257{\r
2258 EFI_STATUS Status;\r
2259 TrimSpaces(CmdLine);\r
2260\r
2261 Status = ShellSubstituteAliases(CmdLine);\r
2262 if (EFI_ERROR(Status)) {\r
2263 return (Status);\r
2264 }\r
2265\r
2266 TrimSpaces(CmdLine);\r
2267\r
2268 Status = ShellSubstituteVariables(CmdLine);\r
2269 if (EFI_ERROR(Status)) {\r
2270 return (Status);\r
2271 }\r
2272 ASSERT (*CmdLine != NULL);\r
2273\r
2274 TrimSpaces(CmdLine);\r
2275\r
2276 //\r
2277 // update for help parsing\r
2278 //\r
2279 if (StrStr(*CmdLine, L"?") != NULL) {\r
2280 //\r
2281 // This may do nothing if the ? does not indicate help.\r
2282 // Save all the details for in the API below.\r
2283 //\r
2284 Status = DoHelpUpdate(CmdLine);\r
2285 }\r
2286\r
2287 TrimSpaces(CmdLine);\r
2288\r
2289 return (EFI_SUCCESS);\r
2290}\r
2291\r
2292/**\r
2293 Run an internal shell command.\r
2294\r
2295 This API will update the shell's environment since these commands are libraries.\r
2296 \r
2297 @param[in] CmdLine the command line to run.\r
2298 @param[in] FirstParameter the first parameter on the command line\r
2299 @param[in] ParamProtocol the shell parameters protocol pointer\r
2300 @param[out] CommandStatus the status from the command line.\r
2301\r
2302 @retval EFI_SUCCESS The command was completed.\r
2303 @retval EFI_ABORTED The command's operation was aborted.\r
2304**/\r
2305EFI_STATUS\r
2306RunInternalCommand(\r
2307 IN CONST CHAR16 *CmdLine,\r
2308 IN CHAR16 *FirstParameter,\r
2309 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol,\r
2310 OUT EFI_STATUS *CommandStatus\r
2311)\r
2312{\r
2313 EFI_STATUS Status;\r
2314 UINTN Argc;\r
2315 CHAR16 **Argv;\r
2316 SHELL_STATUS CommandReturnedStatus;\r
2317 BOOLEAN LastError;\r
2318 CHAR16 *Walker;\r
2319 CHAR16 *NewCmdLine; \r
2320\r
2321 NewCmdLine = AllocateCopyPool (StrSize (CmdLine), CmdLine);\r
2322 if (NewCmdLine == NULL) {\r
2323 return EFI_OUT_OF_RESOURCES;\r
2324 }\r
2325\r
2326 for (Walker = NewCmdLine; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {\r
2327 if (*Walker == L'^' && *(Walker+1) == L'#') {\r
2328 CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));\r
2329 }\r
2330 }\r
2331\r
2332 //\r
2333 // get the argc and argv updated for internal commands\r
2334 //\r
2335 Status = UpdateArgcArgv(ParamProtocol, NewCmdLine, Internal_Command, &Argv, &Argc);\r
2336 if (!EFI_ERROR(Status)) {\r
2337 //\r
2338 // Run the internal command.\r
2339 //\r
2340 Status = ShellCommandRunCommandHandler(FirstParameter, &CommandReturnedStatus, &LastError);\r
2341\r
2342 if (!EFI_ERROR(Status)) {\r
2343 if (CommandStatus != NULL) {\r
2344 if (CommandReturnedStatus != SHELL_SUCCESS) {\r
2345 *CommandStatus = (EFI_STATUS)(CommandReturnedStatus | MAX_BIT);\r
2346 } else {\r
2347 *CommandStatus = EFI_SUCCESS;\r
2348 }\r
2349 }\r
2350\r
2351 //\r
2352 // Update last error status.\r
2353 // some commands do not update last error.\r
2354 //\r
2355 if (LastError) {\r
2356 SetLastError(CommandReturnedStatus);\r
2357 }\r
2358\r
2359 //\r
2360 // Pass thru the exitcode from the app.\r
2361 //\r
2362 if (ShellCommandGetExit()) {\r
2363 //\r
2364 // An Exit was requested ("exit" command), pass its value up.\r
2365 //\r
2366 Status = CommandReturnedStatus;\r
2367 } else if (CommandReturnedStatus != SHELL_SUCCESS && IsScriptOnlyCommand(FirstParameter)) {\r
2368 //\r
2369 // Always abort when a script only command fails for any reason\r
2370 //\r
2371 Status = EFI_ABORTED;\r
2372 } else if (ShellCommandGetCurrentScriptFile() != NULL && CommandReturnedStatus == SHELL_ABORTED) {\r
2373 //\r
2374 // Abort when in a script and a command aborted\r
2375 //\r
2376 Status = EFI_ABORTED;\r
2377 }\r
2378 }\r
2379 }\r
2380\r
2381 //\r
2382 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.\r
2383 // This is safe even if the update API failed. In this case, it may be a no-op.\r
2384 //\r
2385 RestoreArgcArgv(ParamProtocol, &Argv, &Argc);\r
2386\r
2387 //\r
2388 // If a script is running and the command is not a script only command, then\r
2389 // change return value to success so the script won't halt (unless aborted).\r
2390 //\r
2391 // Script only commands have to be able halt the script since the script will\r
2392 // not operate if they are failing.\r
2393 //\r
2394 if ( ShellCommandGetCurrentScriptFile() != NULL\r
2395 && !IsScriptOnlyCommand(FirstParameter)\r
2396 && Status != EFI_ABORTED\r
2397 ) {\r
2398 Status = EFI_SUCCESS;\r
2399 }\r
2400\r
2401 FreePool (NewCmdLine);\r
2402 return (Status);\r
2403}\r
2404\r
2405/**\r
2406 Function to run the command or file.\r
2407\r
2408 @param[in] Type the type of operation being run.\r
2409 @param[in] CmdLine the command line to run.\r
2410 @param[in] FirstParameter the first parameter on the command line\r
2411 @param[in] ParamProtocol the shell parameters protocol pointer\r
2412 @param[out] CommandStatus the status from the command line.\r
2413\r
2414 @retval EFI_SUCCESS The command was completed.\r
2415 @retval EFI_ABORTED The command's operation was aborted.\r
2416**/\r
2417EFI_STATUS\r
2418RunCommandOrFile(\r
2419 IN SHELL_OPERATION_TYPES Type,\r
2420 IN CONST CHAR16 *CmdLine,\r
2421 IN CHAR16 *FirstParameter,\r
2422 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol,\r
2423 OUT EFI_STATUS *CommandStatus\r
2424)\r
2425{\r
2426 EFI_STATUS Status;\r
2427 EFI_STATUS StartStatus;\r
2428 CHAR16 *CommandWithPath;\r
2429 EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
2430 SHELL_STATUS CalleeExitStatus;\r
2431\r
2432 Status = EFI_SUCCESS;\r
2433 CommandWithPath = NULL;\r
2434 DevPath = NULL;\r
2435 CalleeExitStatus = SHELL_INVALID_PARAMETER;\r
2436\r
2437 switch (Type) {\r
2438 case Internal_Command:\r
2439 Status = RunInternalCommand(CmdLine, FirstParameter, ParamProtocol, CommandStatus);\r
2440 break;\r
2441 case Script_File_Name:\r
2442 case Efi_Application:\r
2443 //\r
2444 // Process a fully qualified path\r
2445 //\r
2446 if (StrStr(FirstParameter, L":") != NULL) {\r
2447 ASSERT (CommandWithPath == NULL);\r
2448 if (ShellIsFile(FirstParameter) == EFI_SUCCESS) {\r
2449 CommandWithPath = StrnCatGrow(&CommandWithPath, NULL, FirstParameter, 0);\r
2450 }\r
2451 }\r
2452\r
2453 //\r
2454 // Process a relative path and also check in the path environment variable\r
2455 //\r
2456 if (CommandWithPath == NULL) {\r
2457 CommandWithPath = ShellFindFilePathEx(FirstParameter, mExecutableExtensions);\r
2458 }\r
2459\r
2460 //\r
2461 // This should be impossible now.\r
2462 //\r
2463 ASSERT(CommandWithPath != NULL);\r
2464\r
2465 //\r
2466 // Make sure that path is not just a directory (or not found)\r
2467 //\r
2468 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath))) {\r
2469 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2470 SetLastError(SHELL_NOT_FOUND);\r
2471 }\r
2472 switch (Type) {\r
2473 case Script_File_Name:\r
2474 Status = RunScriptFile (CommandWithPath, NULL, CmdLine, ParamProtocol);\r
2475 break;\r
2476 case Efi_Application:\r
2477 //\r
2478 // Get the device path of the application image\r
2479 //\r
2480 DevPath = ShellInfoObject.NewEfiShellProtocol->GetDevicePathFromFilePath(CommandWithPath);\r
2481 if (DevPath == NULL){\r
2482 Status = EFI_OUT_OF_RESOURCES;\r
2483 break;\r
2484 }\r
2485\r
2486 //\r
2487 // Execute the device path\r
2488 //\r
2489 Status = InternalShellExecuteDevicePath(\r
2490 &gImageHandle,\r
2491 DevPath,\r
2492 CmdLine,\r
2493 NULL,\r
2494 &StartStatus\r
2495 );\r
2496\r
2497 SHELL_FREE_NON_NULL(DevPath);\r
2498\r
2499 if(EFI_ERROR (Status)) {\r
2500 CalleeExitStatus = (SHELL_STATUS) (Status & (~MAX_BIT));\r
2501 } else {\r
2502 CalleeExitStatus = (SHELL_STATUS) StartStatus;\r
2503 }\r
2504\r
2505 if (CommandStatus != NULL) {\r
2506 *CommandStatus = CalleeExitStatus;\r
2507 }\r
2508\r
2509 //\r
2510 // Update last error status.\r
2511 //\r
2512 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS\r
2513 SetLastError(CalleeExitStatus);\r
2514 break;\r
2515 default:\r
2516 //\r
2517 // Do nothing.\r
2518 //\r
2519 break;\r
2520 }\r
2521 break;\r
2522 default:\r
2523 //\r
2524 // Do nothing.\r
2525 //\r
2526 break;\r
2527 }\r
2528\r
2529 SHELL_FREE_NON_NULL(CommandWithPath);\r
2530\r
2531 return (Status);\r
2532}\r
2533\r
2534/**\r
2535 Function to setup StdIn, StdErr, StdOut, and then run the command or file.\r
2536\r
2537 @param[in] Type the type of operation being run.\r
2538 @param[in] CmdLine the command line to run.\r
2539 @param[in] FirstParameter the first parameter on the command line.\r
2540 @param[in] ParamProtocol the shell parameters protocol pointer\r
2541 @param[out] CommandStatus the status from the command line.\r
2542\r
2543 @retval EFI_SUCCESS The command was completed.\r
2544 @retval EFI_ABORTED The command's operation was aborted.\r
2545**/\r
2546EFI_STATUS\r
2547SetupAndRunCommandOrFile(\r
2548 IN SHELL_OPERATION_TYPES Type,\r
2549 IN CHAR16 *CmdLine,\r
2550 IN CHAR16 *FirstParameter,\r
2551 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol,\r
2552 OUT EFI_STATUS *CommandStatus\r
2553)\r
2554{\r
2555 EFI_STATUS Status;\r
2556 SHELL_FILE_HANDLE OriginalStdIn;\r
2557 SHELL_FILE_HANDLE OriginalStdOut;\r
2558 SHELL_FILE_HANDLE OriginalStdErr;\r
2559 SYSTEM_TABLE_INFO OriginalSystemTableInfo;\r
2560 CONST SCRIPT_FILE *ConstScriptFile;\r
2561\r
2562 //\r
2563 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII\r
2564 //\r
2565 Status = UpdateStdInStdOutStdErr(ParamProtocol, CmdLine, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);\r
2566\r
2567 //\r
2568 // The StdIn, StdOut, and StdErr are set up.\r
2569 // Now run the command, script, or application\r
2570 //\r
2571 if (!EFI_ERROR(Status)) {\r
2572 TrimSpaces(&CmdLine);\r
2573 Status = RunCommandOrFile(Type, CmdLine, FirstParameter, ParamProtocol, CommandStatus);\r
2574 }\r
2575\r
2576 //\r
2577 // Now print errors\r
2578 //\r
2579 if (EFI_ERROR(Status)) {\r
2580 ConstScriptFile = ShellCommandGetCurrentScriptFile();\r
2581 if (ConstScriptFile == NULL || ConstScriptFile->CurrentCommand == NULL) {\r
2582 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_ERROR), ShellInfoObject.HiiHandle, (VOID*)(Status));\r
2583 } else {\r
2584 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_ERROR_SCRIPT), ShellInfoObject.HiiHandle, (VOID*)(Status), ConstScriptFile->CurrentCommand->Line);\r
2585 }\r
2586 }\r
2587\r
2588 //\r
2589 // put back the original StdIn, StdOut, and StdErr\r
2590 //\r
2591 RestoreStdInStdOutStdErr(ParamProtocol, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);\r
2592\r
2593 return (Status);\r
2594}\r
2595\r
2596/**\r
2597 Function will process and run a command line.\r
2598\r
2599 This will determine if the command line represents an internal shell \r
2600 command or dispatch an external application.\r
2601\r
2602 @param[in] CmdLine The command line to parse.\r
2603 @param[out] CommandStatus The status from the command line.\r
2604\r
2605 @retval EFI_SUCCESS The command was completed.\r
2606 @retval EFI_ABORTED The command's operation was aborted.\r
2607**/\r
2608EFI_STATUS\r
2609RunShellCommand(\r
2610 IN CONST CHAR16 *CmdLine,\r
2611 OUT EFI_STATUS *CommandStatus\r
2612 )\r
2613{\r
2614 EFI_STATUS Status;\r
2615 CHAR16 *CleanOriginal;\r
2616 CHAR16 *FirstParameter;\r
2617 CHAR16 *TempWalker;\r
2618 SHELL_OPERATION_TYPES Type;\r
2619 CONST CHAR16 *CurDir;\r
2620\r
2621 ASSERT(CmdLine != NULL);\r
2622 if (StrLen(CmdLine) == 0) {\r
2623 return (EFI_SUCCESS);\r
2624 }\r
2625\r
2626 Status = EFI_SUCCESS;\r
2627 CleanOriginal = NULL;\r
2628\r
2629 CleanOriginal = StrnCatGrow(&CleanOriginal, NULL, CmdLine, 0);\r
2630 if (CleanOriginal == NULL) {\r
2631 return (EFI_OUT_OF_RESOURCES);\r
2632 }\r
2633\r
2634 TrimSpaces(&CleanOriginal);\r
2635\r
2636 //\r
2637 // NULL out comments (leveraged from RunScriptFileHandle() ).\r
2638 // The # character on a line is used to denote that all characters on the same line\r
2639 // and to the right of the # are to be ignored by the shell.\r
2640 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.\r
2641 //\r
2642 for (TempWalker = CleanOriginal; TempWalker != NULL && *TempWalker != CHAR_NULL; TempWalker++) {\r
2643 if (*TempWalker == L'^') {\r
2644 if (*(TempWalker + 1) == L'#') {\r
2645 TempWalker++;\r
2646 }\r
2647 } else if (*TempWalker == L'#') {\r
2648 *TempWalker = CHAR_NULL;\r
2649 }\r
2650 }\r
2651\r
2652 TrimSpaces(&CleanOriginal);\r
2653\r
2654 //\r
2655 // Handle case that passed in command line is just 1 or more " " characters.\r
2656 //\r
2657 if (StrLen (CleanOriginal) == 0) {\r
2658 SHELL_FREE_NON_NULL(CleanOriginal);\r
2659 return (EFI_SUCCESS);\r
2660 }\r
2661\r
2662 Status = ProcessCommandLineToFinal(&CleanOriginal);\r
2663 if (EFI_ERROR(Status)) {\r
2664 SHELL_FREE_NON_NULL(CleanOriginal);\r
2665 return (Status);\r
2666 }\r
2667\r
2668 //\r
2669 // We don't do normal processing with a split command line (output from one command input to another)\r
2670 //\r
2671 if (ContainsSplit(CleanOriginal)) {\r
2672 Status = ProcessNewSplitCommandLine(CleanOriginal);\r
2673 SHELL_FREE_NON_NULL(CleanOriginal);\r
2674 return (Status);\r
2675 } \r
2676\r
2677 //\r
2678 // We need the first parameter information so we can determine the operation type\r
2679 //\r
2680 FirstParameter = AllocateZeroPool(StrSize(CleanOriginal));\r
2681 if (FirstParameter == NULL) {\r
2682 SHELL_FREE_NON_NULL(CleanOriginal);\r
2683 return (EFI_OUT_OF_RESOURCES);\r
2684 }\r
2685 TempWalker = CleanOriginal;\r
2686 if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CleanOriginal), TRUE))) {\r
2687 //\r
2688 // Depending on the first parameter we change the behavior\r
2689 //\r
2690 switch (Type = GetOperationType(FirstParameter)) {\r
2691 case File_Sys_Change:\r
2692 Status = ChangeMappedDrive (FirstParameter);\r
2693 break;\r
2694 case Internal_Command:\r
2695 case Script_File_Name:\r
2696 case Efi_Application:\r
2697 Status = SetupAndRunCommandOrFile(Type, CleanOriginal, FirstParameter, ShellInfoObject.NewShellParametersProtocol, CommandStatus);\r
2698 break;\r
2699 default:\r
2700 //\r
2701 // Whatever was typed, it was invalid.\r
2702 //\r
2703 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2704 SetLastError(SHELL_NOT_FOUND);\r
2705 break;\r
2706 }\r
2707 } else {\r
2708 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);\r
2709 SetLastError(SHELL_NOT_FOUND);\r
2710 }\r
2711 //\r
2712 // Check whether the current file system still exists. If not exist, we need update "cwd" and gShellCurMapping.\r
2713 //\r
2714 CurDir = EfiShellGetCurDir (NULL);\r
2715 if (CurDir != NULL) {\r
2716 if (EFI_ERROR(ShellFileExists (CurDir))) {\r
2717 //\r
2718 // EfiShellSetCurDir() cannot set current directory to NULL.\r
2719 // EfiShellSetEnv() is not allowed to set the "cwd" variable.\r
2720 // Only InternalEfiShellSetEnv () is allowed setting the "cwd" variable.\r
2721 //\r
2722 InternalEfiShellSetEnv (L"cwd", NULL, TRUE);\r
2723 gShellCurMapping = NULL;\r
2724 }\r
2725 }\r
2726\r
2727 SHELL_FREE_NON_NULL(CleanOriginal);\r
2728 SHELL_FREE_NON_NULL(FirstParameter);\r
2729\r
2730 return (Status);\r
2731}\r
2732\r
2733/**\r
2734 Function will process and run a command line.\r
2735\r
2736 This will determine if the command line represents an internal shell \r
2737 command or dispatch an external application.\r
2738\r
2739 @param[in] CmdLine The command line to parse.\r
2740\r
2741 @retval EFI_SUCCESS The command was completed.\r
2742 @retval EFI_ABORTED The command's operation was aborted.\r
2743**/\r
2744EFI_STATUS\r
2745RunCommand(\r
2746 IN CONST CHAR16 *CmdLine\r
2747 )\r
2748{\r
2749 return (RunShellCommand(CmdLine, NULL));\r
2750}\r
2751\r
2752\r
2753STATIC CONST UINT16 InvalidChars[] = {L'*', L'?', L'<', L'>', L'\\', L'/', L'\"', 0x0001, 0x0002};\r
2754/**\r
2755 Function determines if the CommandName COULD be a valid command. It does not determine whether\r
2756 this is a valid command. It only checks for invalid characters.\r
2757\r
2758 @param[in] CommandName The name to check\r
2759\r
2760 @retval TRUE CommandName could be a command name\r
2761 @retval FALSE CommandName could not be a valid command name\r
2762**/\r
2763BOOLEAN\r
2764IsValidCommandName(\r
2765 IN CONST CHAR16 *CommandName\r
2766 )\r
2767{\r
2768 UINTN Count;\r
2769 if (CommandName == NULL) {\r
2770 ASSERT(FALSE);\r
2771 return (FALSE);\r
2772 }\r
2773 for ( Count = 0\r
2774 ; Count < sizeof(InvalidChars) / sizeof(InvalidChars[0])\r
2775 ; Count++\r
2776 ){\r
2777 if (ScanMem16(CommandName, StrSize(CommandName), InvalidChars[Count]) != NULL) {\r
2778 return (FALSE);\r
2779 }\r
2780 }\r
2781 return (TRUE);\r
2782}\r
2783\r
2784/**\r
2785 Function to process a NSH script file via SHELL_FILE_HANDLE.\r
2786\r
2787 @param[in] Handle The handle to the already opened file.\r
2788 @param[in] Name The name of the script file.\r
2789\r
2790 @retval EFI_SUCCESS the script completed successfully\r
2791**/\r
2792EFI_STATUS\r
2793RunScriptFileHandle (\r
2794 IN SHELL_FILE_HANDLE Handle,\r
2795 IN CONST CHAR16 *Name\r
2796 )\r
2797{\r
2798 EFI_STATUS Status;\r
2799 SCRIPT_FILE *NewScriptFile;\r
2800 UINTN LoopVar;\r
2801 UINTN PrintBuffSize;\r
2802 CHAR16 *CommandLine;\r
2803 CHAR16 *CommandLine2;\r
2804 CHAR16 *CommandLine3;\r
2805 SCRIPT_COMMAND_LIST *LastCommand;\r
2806 BOOLEAN Ascii;\r
2807 BOOLEAN PreScriptEchoState;\r
2808 BOOLEAN PreCommandEchoState;\r
2809 CONST CHAR16 *CurDir;\r
2810 UINTN LineCount;\r
2811 CHAR16 LeString[50];\r
2812 LIST_ENTRY OldBufferList;\r
2813\r
2814 ASSERT(!ShellCommandGetScriptExit());\r
2815\r
2816 PreScriptEchoState = ShellCommandGetEchoState();\r
2817 PrintBuffSize = PcdGet16(PcdShellPrintBufferSize);\r
2818\r
2819 NewScriptFile = (SCRIPT_FILE*)AllocateZeroPool(sizeof(SCRIPT_FILE));\r
2820 if (NewScriptFile == NULL) {\r
2821 return (EFI_OUT_OF_RESOURCES);\r
2822 }\r
2823\r
2824 //\r
2825 // Set up the name\r
2826 //\r
2827 ASSERT(NewScriptFile->ScriptName == NULL);\r
2828 NewScriptFile->ScriptName = StrnCatGrow(&NewScriptFile->ScriptName, NULL, Name, 0);\r
2829 if (NewScriptFile->ScriptName == NULL) {\r
2830 DeleteScriptFileStruct(NewScriptFile);\r
2831 return (EFI_OUT_OF_RESOURCES);\r
2832 }\r
2833\r
2834 //\r
2835 // Save the parameters (used to replace %0 to %9 later on)\r
2836 //\r
2837 NewScriptFile->Argc = ShellInfoObject.NewShellParametersProtocol->Argc;\r
2838 if (NewScriptFile->Argc != 0) {\r
2839 NewScriptFile->Argv = (CHAR16**)AllocateZeroPool(NewScriptFile->Argc * sizeof(CHAR16*));\r
2840 if (NewScriptFile->Argv == NULL) {\r
2841 DeleteScriptFileStruct(NewScriptFile);\r
2842 return (EFI_OUT_OF_RESOURCES);\r
2843 }\r
2844 for (LoopVar = 0 ; LoopVar < 10 && LoopVar < NewScriptFile->Argc; LoopVar++) {\r
2845 ASSERT(NewScriptFile->Argv[LoopVar] == NULL);\r
2846 NewScriptFile->Argv[LoopVar] = StrnCatGrow(&NewScriptFile->Argv[LoopVar], NULL, ShellInfoObject.NewShellParametersProtocol->Argv[LoopVar], 0);\r
2847 if (NewScriptFile->Argv[LoopVar] == NULL) {\r
2848 DeleteScriptFileStruct(NewScriptFile);\r
2849 return (EFI_OUT_OF_RESOURCES);\r
2850 }\r
2851 }\r
2852 } else {\r
2853 NewScriptFile->Argv = NULL;\r
2854 }\r
2855\r
2856 InitializeListHead(&NewScriptFile->CommandList);\r
2857 InitializeListHead(&NewScriptFile->SubstList);\r
2858\r
2859 //\r
2860 // Now build the list of all script commands.\r
2861 //\r
2862 LineCount = 0;\r
2863 while(!ShellFileHandleEof(Handle)) {\r
2864 CommandLine = ShellFileHandleReturnLine(Handle, &Ascii);\r
2865 LineCount++;\r
2866 if (CommandLine == NULL || StrLen(CommandLine) == 0 || CommandLine[0] == '#') {\r
2867 SHELL_FREE_NON_NULL(CommandLine);\r
2868 continue;\r
2869 }\r
2870 NewScriptFile->CurrentCommand = AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST));\r
2871 if (NewScriptFile->CurrentCommand == NULL) {\r
2872 SHELL_FREE_NON_NULL(CommandLine);\r
2873 DeleteScriptFileStruct(NewScriptFile);\r
2874 return (EFI_OUT_OF_RESOURCES);\r
2875 }\r
2876\r
2877 NewScriptFile->CurrentCommand->Cl = CommandLine;\r
2878 NewScriptFile->CurrentCommand->Data = NULL;\r
2879 NewScriptFile->CurrentCommand->Line = LineCount;\r
2880\r
2881 InsertTailList(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
2882 }\r
2883\r
2884 //\r
2885 // Add this as the topmost script file\r
2886 //\r
2887 ShellCommandSetNewScript (NewScriptFile);\r
2888\r
2889 //\r
2890 // Now enumerate through the commands and run each one.\r
2891 //\r
2892 CommandLine = AllocateZeroPool(PrintBuffSize);\r
2893 if (CommandLine == NULL) {\r
2894 DeleteScriptFileStruct(NewScriptFile);\r
2895 return (EFI_OUT_OF_RESOURCES);\r
2896 }\r
2897 CommandLine2 = AllocateZeroPool(PrintBuffSize);\r
2898 if (CommandLine2 == NULL) {\r
2899 FreePool(CommandLine);\r
2900 DeleteScriptFileStruct(NewScriptFile);\r
2901 return (EFI_OUT_OF_RESOURCES);\r
2902 }\r
2903\r
2904 for ( NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&NewScriptFile->CommandList)\r
2905 ; !IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)\r
2906 ; // conditional increment in the body of the loop\r
2907 ){\r
2908 ASSERT(CommandLine2 != NULL);\r
2909 StrnCpyS( CommandLine2, \r
2910 PrintBuffSize/sizeof(CHAR16), \r
2911 NewScriptFile->CurrentCommand->Cl,\r
2912 PrintBuffSize/sizeof(CHAR16) - 1\r
2913 );\r
2914\r
2915 SaveBufferList(&OldBufferList);\r
2916\r
2917 //\r
2918 // NULL out comments\r
2919 //\r
2920 for (CommandLine3 = CommandLine2 ; CommandLine3 != NULL && *CommandLine3 != CHAR_NULL ; CommandLine3++) {\r
2921 if (*CommandLine3 == L'^') {\r
2922 if ( *(CommandLine3+1) == L':') {\r
2923 CopyMem(CommandLine3, CommandLine3+1, StrSize(CommandLine3) - sizeof(CommandLine3[0]));\r
2924 } else if (*(CommandLine3+1) == L'#') {\r
2925 CommandLine3++;\r
2926 }\r
2927 } else if (*CommandLine3 == L'#') {\r
2928 *CommandLine3 = CHAR_NULL;\r
2929 }\r
2930 }\r
2931\r
2932 if (CommandLine2 != NULL && StrLen(CommandLine2) >= 1) {\r
2933 //\r
2934 // Due to variability in starting the find and replace action we need to have both buffers the same.\r
2935 //\r
2936 StrnCpyS( CommandLine, \r
2937 PrintBuffSize/sizeof(CHAR16), \r
2938 CommandLine2,\r
2939 PrintBuffSize/sizeof(CHAR16) - 1\r
2940 );\r
2941\r
2942 //\r
2943 // Remove the %0 to %9 from the command line (if we have some arguments)\r
2944 //\r
2945 if (NewScriptFile->Argv != NULL) {\r
2946 switch (NewScriptFile->Argc) {\r
2947 default:\r
2948 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%9", NewScriptFile->Argv[9], FALSE, FALSE);\r
2949 ASSERT_EFI_ERROR(Status);\r
2950 case 9:\r
2951 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%8", NewScriptFile->Argv[8], FALSE, FALSE);\r
2952 ASSERT_EFI_ERROR(Status);\r
2953 case 8:\r
2954 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%7", NewScriptFile->Argv[7], FALSE, FALSE);\r
2955 ASSERT_EFI_ERROR(Status);\r
2956 case 7:\r
2957 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%6", NewScriptFile->Argv[6], FALSE, FALSE);\r
2958 ASSERT_EFI_ERROR(Status);\r
2959 case 6:\r
2960 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%5", NewScriptFile->Argv[5], FALSE, FALSE);\r
2961 ASSERT_EFI_ERROR(Status);\r
2962 case 5:\r
2963 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%4", NewScriptFile->Argv[4], FALSE, FALSE);\r
2964 ASSERT_EFI_ERROR(Status);\r
2965 case 4:\r
2966 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%3", NewScriptFile->Argv[3], FALSE, FALSE);\r
2967 ASSERT_EFI_ERROR(Status);\r
2968 case 3:\r
2969 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%2", NewScriptFile->Argv[2], FALSE, FALSE);\r
2970 ASSERT_EFI_ERROR(Status);\r
2971 case 2:\r
2972 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%1", NewScriptFile->Argv[1], FALSE, FALSE);\r
2973 ASSERT_EFI_ERROR(Status);\r
2974 case 1:\r
2975 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%0", NewScriptFile->Argv[0], FALSE, FALSE);\r
2976 ASSERT_EFI_ERROR(Status);\r
2977 break;\r
2978 case 0:\r
2979 break;\r
2980 }\r
2981 }\r
2982 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%1", L"\"\"", FALSE, FALSE);\r
2983 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%2", L"\"\"", FALSE, FALSE);\r
2984 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%3", L"\"\"", FALSE, FALSE);\r
2985 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%4", L"\"\"", FALSE, FALSE);\r
2986 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%5", L"\"\"", FALSE, FALSE);\r
2987 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%6", L"\"\"", FALSE, FALSE);\r
2988 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%7", L"\"\"", FALSE, FALSE);\r
2989 Status = ShellCopySearchAndReplace(CommandLine, CommandLine2, PrintBuffSize, L"%8", L"\"\"", FALSE, FALSE);\r
2990 Status = ShellCopySearchAndReplace(CommandLine2, CommandLine, PrintBuffSize, L"%9", L"\"\"", FALSE, FALSE);\r
2991\r
2992 StrnCpyS( CommandLine2, \r
2993 PrintBuffSize/sizeof(CHAR16), \r
2994 CommandLine,\r
2995 PrintBuffSize/sizeof(CHAR16) - 1\r
2996 );\r
2997\r
2998 LastCommand = NewScriptFile->CurrentCommand;\r
2999\r
3000 for (CommandLine3 = CommandLine2 ; CommandLine3[0] == L' ' ; CommandLine3++);\r
3001\r
3002 if (CommandLine3 != NULL && CommandLine3[0] == L':' ) {\r
3003 //\r
3004 // This line is a goto target / label\r
3005 //\r
3006 } else {\r
3007 if (CommandLine3 != NULL && StrLen(CommandLine3) > 0) {\r
3008 if (CommandLine3[0] == L'@') {\r
3009 //\r
3010 // We need to save the current echo state\r
3011 // and disable echo for just this command.\r
3012 //\r
3013 PreCommandEchoState = ShellCommandGetEchoState();\r
3014 ShellCommandSetEchoState(FALSE);\r
3015 Status = RunCommand(CommandLine3+1);\r
3016\r
3017 //\r
3018 // If command was "@echo -off" or "@echo -on" then don't restore echo state\r
3019 //\r
3020 if (StrCmp (L"@echo -off", CommandLine3) != 0 &&\r
3021 StrCmp (L"@echo -on", CommandLine3) != 0) {\r
3022 //\r
3023 // Now restore the pre-'@' echo state.\r
3024 //\r
3025 ShellCommandSetEchoState(PreCommandEchoState);\r
3026 }\r
3027 } else {\r
3028 if (ShellCommandGetEchoState()) {\r
3029 CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");\r
3030 if (CurDir != NULL && StrLen(CurDir) > 1) {\r
3031 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);\r
3032 } else {\r
3033 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);\r
3034 }\r
3035 ShellPrintEx(-1, -1, L"%s\r\n", CommandLine2);\r
3036 }\r
3037 Status = RunCommand(CommandLine3);\r
3038 }\r
3039 }\r
3040\r
3041 if (ShellCommandGetScriptExit()) {\r
3042 //\r
3043 // ShellCommandGetExitCode() always returns a UINT64\r
3044 //\r
3045 UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ShellCommandGetExitCode());\r
3046 DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););\r
3047 InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);\r
3048\r
3049 ShellCommandRegisterExit(FALSE, 0);\r
3050 Status = EFI_SUCCESS;\r
3051 RestoreBufferList(&OldBufferList);\r
3052 break;\r
3053 }\r
3054 if (ShellGetExecutionBreakFlag()) {\r
3055 RestoreBufferList(&OldBufferList);\r
3056 break;\r
3057 }\r
3058 if (EFI_ERROR(Status)) {\r
3059 RestoreBufferList(&OldBufferList);\r
3060 break;\r
3061 }\r
3062 if (ShellCommandGetExit()) {\r
3063 RestoreBufferList(&OldBufferList);\r
3064 break;\r
3065 }\r
3066 }\r
3067 //\r
3068 // If that commend did not update the CurrentCommand then we need to advance it...\r
3069 //\r
3070 if (LastCommand == NewScriptFile->CurrentCommand) {\r
3071 NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
3072 if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {\r
3073 NewScriptFile->CurrentCommand->Reset = TRUE;\r
3074 }\r
3075 }\r
3076 } else {\r
3077 NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);\r
3078 if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {\r
3079 NewScriptFile->CurrentCommand->Reset = TRUE;\r
3080 }\r
3081 }\r
3082 RestoreBufferList(&OldBufferList);\r
3083 }\r
3084\r
3085\r
3086 FreePool(CommandLine);\r
3087 FreePool(CommandLine2);\r
3088 ShellCommandSetNewScript (NULL);\r
3089\r
3090 //\r
3091 // Only if this was the last script reset the state.\r
3092 //\r
3093 if (ShellCommandGetCurrentScriptFile()==NULL) {\r
3094 ShellCommandSetEchoState(PreScriptEchoState);\r
3095 }\r
3096 return (EFI_SUCCESS);\r
3097}\r
3098\r
3099/**\r
3100 Function to process a NSH script file.\r
3101\r
3102 @param[in] ScriptPath Pointer to the script file name (including file system path).\r
3103 @param[in] Handle the handle of the script file already opened.\r
3104 @param[in] CmdLine the command line to run.\r
3105 @param[in] ParamProtocol the shell parameters protocol pointer\r
3106\r
3107 @retval EFI_SUCCESS the script completed successfully\r
3108**/\r
3109EFI_STATUS\r
3110RunScriptFile (\r
3111 IN CONST CHAR16 *ScriptPath,\r
3112 IN SHELL_FILE_HANDLE Handle OPTIONAL,\r
3113 IN CONST CHAR16 *CmdLine,\r
3114 IN EFI_SHELL_PARAMETERS_PROTOCOL *ParamProtocol\r
3115 )\r
3116{\r
3117 EFI_STATUS Status;\r
3118 SHELL_FILE_HANDLE FileHandle;\r
3119 UINTN Argc;\r
3120 CHAR16 **Argv;\r
3121\r
3122 if (ShellIsFile(ScriptPath) != EFI_SUCCESS) {\r
3123 return (EFI_INVALID_PARAMETER);\r
3124 }\r
3125\r
3126 //\r
3127 // get the argc and argv updated for scripts\r
3128 //\r
3129 Status = UpdateArgcArgv(ParamProtocol, CmdLine, Script_File_Name, &Argv, &Argc);\r
3130 if (!EFI_ERROR(Status)) {\r
3131\r
3132 if (Handle == NULL) {\r
3133 //\r
3134 // open the file\r
3135 //\r
3136 Status = ShellOpenFileByName(ScriptPath, &FileHandle, EFI_FILE_MODE_READ, 0);\r
3137 if (!EFI_ERROR(Status)) {\r
3138 //\r
3139 // run it\r
3140 //\r
3141 Status = RunScriptFileHandle(FileHandle, ScriptPath);\r
3142\r
3143 //\r
3144 // now close the file\r
3145 //\r
3146 ShellCloseFile(&FileHandle);\r
3147 }\r
3148 } else {\r
3149 Status = RunScriptFileHandle(Handle, ScriptPath);\r
3150 }\r
3151 }\r
3152\r
3153 //\r
3154 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.\r
3155 // This is safe even if the update API failed. In this case, it may be a no-op.\r
3156 //\r
3157 RestoreArgcArgv(ParamProtocol, &Argv, &Argc);\r
3158\r
3159 return (Status);\r
3160}\r
3161\r
3162/**\r
3163 Return the pointer to the first occurrence of any character from a list of characters.\r
3164\r
3165 @param[in] String the string to parse\r
3166 @param[in] CharacterList the list of character to look for\r
3167 @param[in] EscapeCharacter An escape character to skip\r
3168\r
3169 @return the location of the first character in the string\r
3170 @retval CHAR_NULL no instance of any character in CharacterList was found in String\r
3171**/\r
3172CONST CHAR16*\r
3173FindFirstCharacter(\r
3174 IN CONST CHAR16 *String,\r
3175 IN CONST CHAR16 *CharacterList,\r
3176 IN CONST CHAR16 EscapeCharacter\r
3177 )\r
3178{\r
3179 UINT32 WalkChar;\r
3180 UINT32 WalkStr;\r
3181\r
3182 for (WalkStr = 0; WalkStr < StrLen(String); WalkStr++) {\r
3183 if (String[WalkStr] == EscapeCharacter) {\r
3184 WalkStr++;\r
3185 continue;\r
3186 }\r
3187 for (WalkChar = 0; WalkChar < StrLen(CharacterList); WalkChar++) {\r
3188 if (String[WalkStr] == CharacterList[WalkChar]) {\r
3189 return (&String[WalkStr]);\r
3190 }\r
3191 }\r
3192 }\r
3193 return (String + StrLen(String));\r
3194}\r
EFI Development Kit II mirror for PVE