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