ShellPkg/Application/Shell/Shell.h

   1 /** @file
   2   function definitions for internal to shell functions.
   3
   4   (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef _SHELL_INTERNAL_HEADER_
  17 #define _SHELL_INTERNAL_HEADER_
  18
  19 #include <Uefi.h>
  20 #include <ShellBase.h>
  21
  22 #include <Guid/ShellVariableGuid.h>
  23 #include <Guid/ShellAliasGuid.h>
  24
  25 #include <Protocol/LoadedImage.h>
  26 #include <Protocol/SimpleTextOut.h>
  27 #include <Protocol/EfiShell.h>
  28 #include <Protocol/EfiShellInterface.h>
  29 #include <Protocol/EfiShellEnvironment2.h>
  30 #include <Protocol/EfiShellParameters.h>
  31 #include <Protocol/BlockIo.h>
  32 #include <Protocol/HiiPackageList.h>
  33
  34 #include <Library/BaseLib.h>
  35 #include <Library/UefiApplicationEntryPoint.h>
  36 #include <Library/UefiLib.h>
  37 #include <Library/DebugLib.h>
  38 #include <Library/MemoryAllocationLib.h>
  39 #include <Library/ShellCommandLib.h>
  40 #include <Library/UefiRuntimeServicesTableLib.h>
  41 #include <Library/UefiBootServicesTableLib.h>
  42 #include <Library/DevicePathLib.h>
  43 #include <Library/BaseMemoryLib.h>
  44 #include <Library/PcdLib.h>
  45 #include <Library/ShellLib.h>
  46 #include <Library/SortLib.h>
  47 #include <Library/HiiLib.h>
  48 #include <Library/PrintLib.h>
  49 #include <Library/HandleParsingLib.h>
  50 #include <Library/FileHandleLib.h>
  51 #include <Library/UefiHiiServicesLib.h>
  52
  53 #include "ShellParametersProtocol.h"
  54 #include "ShellProtocol.h"
  55 #include "ShellEnvVar.h"
  56 #include "ConsoleLogger.h"
  57 #include "ShellManParser.h"
  58 #include "ConsoleWrappers.h"
  59 #include "FileHandleWrappers.h"
  60
  61 extern CONST CHAR16 mNoNestingEnvVarName[];
  62 extern CONST CHAR16 mNoNestingTrue[];
  63 extern CONST CHAR16 mNoNestingFalse[];
  64
  65 typedef struct {
  66   LIST_ENTRY        Link;           ///< Standard linked list handler.
  67   SHELL_FILE_HANDLE *SplitStdOut;   ///< ConsoleOut for use in the split.
  68   SHELL_FILE_HANDLE *SplitStdIn;    ///< ConsoleIn for use in the split.
  69 } SPLIT_LIST;
  70
  71 typedef struct {
  72   UINT32  Startup:1;      ///< Was "-startup"       found on command line.
  73   UINT32  NoStartup:1;    ///< Was "-nostartup"     found on command line.
  74   UINT32  NoConsoleOut:1; ///< Was "-noconsoleout"  found on command line.
  75   UINT32  NoConsoleIn:1;  ///< Was "-noconsolein"   found on command line.
  76   UINT32  NoInterrupt:1;  ///< Was "-nointerrupt"   found on command line.
  77   UINT32  NoMap:1;        ///< Was "-nomap"         found on command line.
  78   UINT32  NoVersion:1;    ///< Was "-noversion"     found on command line.
  79   UINT32  Delay:1;        ///< Was "-delay[:n]      found on command line
  80   UINT32  Exit:1;         ///< Was "-_exit"         found on command line
  81   UINT32  NoNest:1;       ///< Was "-nonest"        found on command line
  82   UINT32  Reserved:7;     ///< Extra bits
  83 } SHELL_BITS;
  84
  85 typedef union {
  86   SHELL_BITS  Bits;
  87   UINT16      AllBits;
  88 } SHELL_BIT_UNION;
  89
  90 typedef struct {
  91   SHELL_BIT_UNION BitUnion;
  92   UINTN           Delay;          ///< Seconds of delay default:5.
  93   CHAR16          *FileName;      ///< Filename to run upon successful initialization.
  94   CHAR16          *FileOptions;   ///< Options to pass to FileName.
  95 } SHELL_INIT_SETTINGS;
  96
  97 typedef struct {
  98   BUFFER_LIST                 CommandHistory;
  99   UINTN                       VisibleRowNumber;
 100   UINTN                       OriginalVisibleRowNumber;
 101   BOOLEAN                     InsertMode;           ///< Is the current typing mode insert (FALSE = overwrite).
 102 } SHELL_VIEWING_SETTINGS;
 103
 104 typedef struct {
 105   EFI_SHELL_PARAMETERS_PROTOCOL *NewShellParametersProtocol;
 106   EFI_SHELL_PROTOCOL            *NewEfiShellProtocol;
 107   BOOLEAN                       PageBreakEnabled;
 108   BOOLEAN                       RootShellInstance;
 109   SHELL_INIT_SETTINGS           ShellInitSettings;
 110   BUFFER_LIST                   BufferToFreeList;     ///< List of buffers that were returned to the user to free.
 111   SHELL_VIEWING_SETTINGS        ViewingSettings;
 112   EFI_HII_HANDLE                HiiHandle;            ///< Handle from HiiLib.
 113   UINTN                         LogScreenCount;       ///< How many screens of log information to save.
 114   EFI_EVENT                     UserBreakTimer;       ///< Timer event for polling for CTRL-C.
 115   EFI_DEVICE_PATH_PROTOCOL      *ImageDevPath;        ///< DevicePath for ourselves.
 116   EFI_DEVICE_PATH_PROTOCOL      *FileDevPath;         ///< DevicePath for ourselves.
 117   CONSOLE_LOGGER_PRIVATE_DATA   *ConsoleInfo;         ///< Pointer for ConsoleInformation.
 118   EFI_SHELL_PARAMETERS_PROTOCOL *OldShellParameters;  ///< old shell parameters to reinstall upon exiting.
 119   SHELL_PROTOCOL_HANDLE_LIST    OldShellList;         ///< List of other instances to reinstall when closing.
 120   SPLIT_LIST                    SplitList;            ///< List of Splits in FILO stack.
 121   VOID                          *CtrlCNotifyHandle1;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 122   VOID                          *CtrlCNotifyHandle2;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 123   VOID                          *CtrlCNotifyHandle3;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 124   VOID                          *CtrlCNotifyHandle4;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 125   VOID                          *CtrlSNotifyHandle1;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 126   VOID                          *CtrlSNotifyHandle2;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 127   VOID                          *CtrlSNotifyHandle3;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 128   VOID                          *CtrlSNotifyHandle4;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
 129   BOOLEAN                       HaltOutput;           ///< TRUE to start a CTRL-S halt.
 130 } SHELL_INFO;
 131
 132 #pragma pack(1)
 133 ///
 134 /// HII specific Vendor Device Path definition.
 135 ///
 136 typedef struct {
 137   VENDOR_DEVICE_PATH             VendorDevicePath;
 138   EFI_DEVICE_PATH_PROTOCOL       End;
 139 } SHELL_MAN_HII_VENDOR_DEVICE_PATH;
 140 #pragma pack()
 141
 142 extern SHELL_INFO ShellInfoObject;
 143
 144 /**
 145   Converts the command line to it's post-processed form.  this replaces variables and alias' per UEFI Shell spec.
 146
 147   @param[in,out] CmdLine        pointer to the command line to update
 148
 149   @retval EFI_SUCCESS           The operation was successful
 150   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 151   @return                       some other error occurred
 152 **/
 153 EFI_STATUS
 154 ProcessCommandLineToFinal(
 155   IN OUT CHAR16 **CmdLine
 156   );
 157
 158 /**
 159   Function to update the shell variable "lasterror".
 160
 161   @param[in] ErrorCode      the error code to put into lasterror
 162 **/
 163 EFI_STATUS
 164 SetLastError(
 165   IN CONST SHELL_STATUS   ErrorCode
 166   );
 167
 168 /**
 169   Sets all the alias' that were registered with the ShellCommandLib library.
 170
 171   @retval EFI_SUCCESS           all init commands were run successfully.
 172 **/
 173 EFI_STATUS
 174 SetBuiltInAlias(
 175   VOID
 176   );
 177
 178 /**
 179   This function will populate the 2 device path protocol parameters based on the
 180   global gImageHandle.  the DevPath will point to the device path for the handle that has
 181   loaded image protocol installed on it.  the FilePath will point to the device path
 182   for the file that was loaded.
 183
 184   @param[in, out] DevPath       on a successful return the device path to the loaded image
 185   @param[in, out] FilePath      on a successful return the device path to the file
 186
 187   @retval EFI_SUCCESS           the 2 device paths were successfully returned.
 188   @return other                 a error from gBS->HandleProtocol
 189
 190   @sa HandleProtocol
 191 **/
 192 EFI_STATUS
 193 GetDevicePathsForImageAndFile (
 194   IN OUT EFI_DEVICE_PATH_PROTOCOL **DevPath,
 195   IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath
 196   );
 197
 198 /**
 199   Process all Uefi Shell 2.0 command line options.
 200
 201   see Uefi Shell 2.0 section 3.2 for full details.
 202
 203   the command line should resemble the following:
 204
 205   shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
 206
 207   ShellOpt options  Options which control the initialization behavior of the shell.
 208                     These options are read from the EFI global variable "ShellOpt"
 209                     and are processed before options or file-name.
 210
 211   options           Options which control the initialization behavior of the shell.
 212
 213   file-name         The name of a UEFI shell application or script to be executed
 214                     after initialization is complete. By default, if file-name is
 215                     specified, then -nostartup is implied. Scripts are not supported
 216                     by level 0.
 217
 218   file-nameoptions  The command-line options that are passed to file-name when it
 219                     is invoked.
 220
 221   This will initialize the ShellInitSettings global variable.
 222
 223   @retval EFI_SUCCESS           the variable is initialized.
 224 **/
 225 EFI_STATUS
 226 ProcessCommandLine(
 227   VOID
 228   );
 229
 230 /**
 231   Handles all interaction with the default startup script.
 232
 233   this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
 234
 235   @param[in] ImagePath          The path to the image for shell.  The first place to look for the startup script.
 236   @param[in] FilePath           The path to the file for shell.  The second place to look for the startup script.
 237
 238   @retval EFI_SUCCESS           The variable is initialized.
 239 **/
 240 EFI_STATUS
 241 DoStartupScript(
 242   IN EFI_DEVICE_PATH_PROTOCOL *ImagePath,
 243   IN EFI_DEVICE_PATH_PROTOCOL *FilePath
 244   );
 245
 246 /**
 247   Function to perform the shell prompt looping.  It will do a single prompt,
 248   dispatch the result, and then return.  It is expected that the caller will
 249   call this function in a loop many times.
 250
 251   @retval EFI_SUCCESS
 252   @retval RETURN_ABORTED
 253 **/
 254 EFI_STATUS
 255 DoShellPrompt (
 256   VOID
 257   );
 258
 259 /**
 260   Add a buffer to the Buffer To Free List for safely returning buffers to other
 261   places without risking letting them modify internal shell information.
 262
 263   @param Buffer   Something to pass to FreePool when the shell is exiting.
 264 **/
 265 VOID*
 266 AddBufferToFreeList(
 267   VOID *Buffer
 268   );
 269
 270 /**
 271   Add a buffer to the Command History List.
 272
 273   @param Buffer[in]     The line buffer to add.
 274 **/
 275 VOID
 276 AddLineToCommandHistory(
 277   IN CONST CHAR16 *Buffer
 278   );
 279
 280 /**
 281   Function will process and run a command line.
 282
 283   This will determine if the command line represents an internal shell command or dispatch an external application.
 284
 285   @param[in] CmdLine  the command line to parse
 286
 287   @retval EFI_SUCCESS     the command was completed
 288   @retval EFI_ABORTED     the command's operation was aborted
 289 **/
 290 EFI_STATUS
 291 RunCommand(
 292   IN CONST CHAR16   *CmdLine
 293   );
 294
 295 /**
 296   Function will process and run a command line.
 297
 298   This will determine if the command line represents an internal shell
 299   command or dispatch an external application.
 300
 301   @param[in] CmdLine      The command line to parse.
 302   @param[out] CommandStatus   The status from the command line.
 303
 304   @retval EFI_SUCCESS     The command was completed.
 305   @retval EFI_ABORTED     The command's operation was aborted.
 306 **/
 307 EFI_STATUS
 308 RunShellCommand(
 309   IN CONST CHAR16   *CmdLine,
 310   OUT EFI_STATUS    *CommandStatus
 311   );
 312
 313 /**
 314   Function determines if the CommandName COULD be a valid command.  It does not determine whether
 315   this is a valid command.  It only checks for invalid characters.
 316
 317   @param[in] CommandName    The name to check
 318
 319   @retval TRUE              CommandName could be a command name
 320   @retval FALSE             CommandName could not be a valid command name
 321 **/
 322 BOOLEAN
 323 IsValidCommandName(
 324   IN CONST CHAR16     *CommandName
 325   );
 326
 327 /**
 328   Function to process a NSH script file via SHELL_FILE_HANDLE.
 329
 330   @param[in] Handle             The handle to the already opened file.
 331   @param[in] Name               The name of the script file.
 332
 333   @retval EFI_SUCCESS           the script completed successfully
 334 **/
 335 EFI_STATUS
 336 RunScriptFileHandle (
 337   IN SHELL_FILE_HANDLE  Handle,
 338   IN CONST CHAR16       *Name
 339   );
 340
 341 /**
 342   Function to process a NSH script file.
 343
 344   @param[in] ScriptPath         Pointer to the script file name (including file system path).
 345   @param[in] Handle             the handle of the script file already opened.
 346   @param[in] CmdLine            the command line to run.
 347   @param[in] ParamProtocol      the shell parameters protocol pointer
 348
 349   @retval EFI_SUCCESS           the script completed successfully
 350 **/
 351 EFI_STATUS
 352 RunScriptFile (
 353   IN CONST CHAR16                   *ScriptPath,
 354   IN SHELL_FILE_HANDLE              Handle OPTIONAL,
 355   IN CONST CHAR16                   *CmdLine,
 356   IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
 357   );
 358
 359 /**
 360   Return the pointer to the first occurrence of any character from a list of characters.
 361
 362   @param[in] String           the string to parse
 363   @param[in] CharacterList    the list of character to look for
 364   @param[in] EscapeCharacter  An escape character to skip
 365
 366   @return the location of the first character in the string
 367   @retval CHAR_NULL no instance of any character in CharacterList was found in String
 368 **/
 369 CONST CHAR16*
 370 FindFirstCharacter(
 371   IN CONST CHAR16 *String,
 372   IN CONST CHAR16 *CharacterList,
 373   IN CONST CHAR16 EscapeCharacter
 374   );
 375
 376 /**
 377   Cleans off leading and trailing spaces and tabs.
 378
 379   @param[in] String pointer to the string to trim them off.
 380 **/
 381 EFI_STATUS
 382 TrimSpaces(
 383   IN CHAR16 **String
 384   );
 385
 386 /**
 387
 388   Create a new buffer list and stores the old one to OldBufferList
 389
 390   @param OldBufferList   The temporary list head used to store the nodes in BufferToFreeList.
 391 **/
 392 VOID
 393 SaveBufferList (
 394   OUT LIST_ENTRY     *OldBufferList
 395   );
 396
 397 /**
 398   Restore previous nodes into BufferToFreeList .
 399
 400   @param OldBufferList   The temporary list head used to store the nodes in BufferToFreeList.
 401 **/
 402 VOID
 403 RestoreBufferList (
 404   IN OUT LIST_ENTRY     *OldBufferList
 405   );
 406
 407
 408
 409 #endif //_SHELL_INTERNAL_HEADER_
 410