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