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