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