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