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