ShellPkg/Application/Shell/Shell.h

   1 /** @file
   2   function definitions for internal to shell functions.
   3
   4   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #ifndef _SHELL_INTERNAL_HEADER_
  16 #define _SHELL_INTERNAL_HEADER_
  17
  18 #include <Uefi.h>
  19 #include <ShellBase.h>
  20
  21 #include <Guid/ShellVariableGuid.h>
  22
  23 #include <Protocol/LoadedImage.h>
  24 #include <Protocol/SimpleTextOut.h>
  25 #include <Protocol/EfiShell.h>
  26 #include <Protocol/EfiShellInterface.h>
  27 #include <Protocol/EfiShellEnvironment2.h>
  28 #include <Protocol/EfiShellParameters.h>
  29 #include <Protocol/BlockIo.h>
  30
  31 #include <Library/BaseLib.h>
  32 #include <Library/UefiApplicationEntryPoint.h>
  33 #include <Library/UefiLib.h>
  34 #include <Library/DebugLib.h>
  35 #include <Library/MemoryAllocationLib.h>
  36 #include <Library/ShellCommandLib.h>
  37 #include <Library/UefiRuntimeServicesTableLib.h>
  38 #include <Library/UefiBootServicesTableLib.h>
  39 #include <Library/DevicePathLib.h>
  40 #include <Library/BaseMemoryLib.h>
  41 #include <Library/PcdLib.h>
  42 #include <Library/ShellLib.h>
  43 #include <Library/SortLib.h>
  44 #include <Library/HiiLib.h>
  45 #include <Library/PrintLib.h>
  46 #include <Library/HandleParsingLib.h>
  47
  48 #include "ShellParametersProtocol.h"
  49 #include "ShellProtocol.h"
  50 #include "ShellEnvVar.h"
  51 #include "ConsoleLogger.h"
  52 #include "ShellManParser.h"
  53
  54 typedef struct {
  55   LIST_ENTRY        Link;           ///< Standard linked list handler.
  56   SHELL_FILE_HANDLE *SplitStdOut;   ///< ConsoleOut for use in the split.
  57   SHELL_FILE_HANDLE *SplitStdIn;    ///< ConsoleIn for use in the split.
  58 } SPLIT_LIST;
  59
  60 typedef struct {
  61   UINT32  Startup:1;      ///< Was "-startup"       found on command line.
  62   UINT32  NoStartup:1;    ///< Was "-nostartup"     found on command line.
  63   UINT32  NoConsoleOut:1; ///< Was "-noconsoleout"  found on command line.
  64   UINT32  NoConsoleIn:1;  ///< Was "-noconsolein"   found on command line.
  65   UINT32  NoInterrupt:1;  ///< Was "-nointerrupt"   found on command line.
  66   UINT32  NoMap:1;        ///< Was "-nomap"         found on command line.
  67   UINT32  NoVersion:1;    ///< Was "-noversion"     found on command line.
  68   UINT32  Delay:1;        ///< Was "-delay[:n]      found on command line
  69   UINT32  Reserved:8;     ///< Extra bits
  70 } SHELL_BITS;
  71
  72 typedef union {
  73   SHELL_BITS  Bits;
  74   UINT16      AllBits;
  75 } SHELL_BIT_UNION;
  76
  77 typedef struct {
  78   SHELL_BIT_UNION BitUnion;
  79   UINTN           Delay;          ///< Seconds of delay default:5.
  80   CHAR16          *FileName;      ///< Filename to run upon successful initialization.
  81   CHAR16          *FileOptions;   ///< Options to pass to FileName.
  82 } SHELL_INIT_SETTINGS;
  83
  84 typedef struct {
  85   BUFFER_LIST                 CommandHistory;
  86   UINTN                       VisibleRowNumber;
  87   UINTN                       OriginalVisibleRowNumber;
  88   BOOLEAN                     InsertMode;           ///< Is the current typing mode insert (FALSE = overwrite).
  89 } SHELL_VIEWING_SETTINGS;
  90
  91 typedef struct {
  92   EFI_SHELL_PARAMETERS_PROTOCOL *NewShellParametersProtocol;
  93   EFI_SHELL_PROTOCOL            *NewEfiShellProtocol;
  94   BOOLEAN                       PageBreakEnabled;
  95   BOOLEAN                       RootShellInstance;
  96   SHELL_INIT_SETTINGS           ShellInitSettings;
  97   BUFFER_LIST                   BufferToFreeList;     ///< List of buffers that were returned to the user to free.
  98   SHELL_VIEWING_SETTINGS        ViewingSettings;
  99   EFI_HII_HANDLE                HiiHandle;            ///< Handle from HiiLib.
 100   UINTN                         LogScreenCount;       ///< How many screens of log information to save.
 101   EFI_EVENT                     UserBreakTimer;       ///< Timer event for polling for CTRL-C.
 102   EFI_DEVICE_PATH_PROTOCOL      *ImageDevPath;        ///< DevicePath for ourselves.
 103   EFI_DEVICE_PATH_PROTOCOL      *FileDevPath;         ///< DevicePath for ourselves.
 104   CONSOLE_LOGGER_PRIVATE_DATA   *ConsoleInfo;         ///< Pointer for ConsoleInformation.
 105   EFI_SHELL_PARAMETERS_PROTOCOL *OldShellParameters;  ///< old shell parameters to reinstall upon exiting.
 106   SHELL_PROTOCOL_HANDLE_LIST    OldShellList;         ///< List of other instances to reinstall when closing.
 107   SPLIT_LIST                    SplitList;            ///< List of Splits in FILO stack.
 108 } SHELL_INFO;
 109
 110 extern SHELL_INFO ShellInfoObject;
 111
 112 /**
 113   Sets all the alias' that were registered with the ShellCommandLib library.
 114
 115   @retval EFI_SUCCESS           all init commands were run sucessfully.
 116 **/
 117 EFI_STATUS
 118 EFIAPI
 119 SetBuiltInAlias(
 120   VOID
 121   );
 122
 123 /**
 124   This function will populate the 2 device path protocol parameters based on the
 125   global gImageHandle.  the DevPath will point to the device path for the handle that has
 126   loaded image protocol installed on it.  the FilePath will point to the device path
 127   for the file that was loaded.
 128
 129   @param[in,out] DevPath       on a sucessful return the device path to the loaded image
 130   @param[in,out] FilePath      on a sucessful return the device path to the file
 131
 132   @retval EFI_SUCCESS           the 2 device paths were sucessfully returned.
 133   @return other                 a error from gBS->HandleProtocol
 134
 135   @sa HandleProtocol
 136 **/
 137 EFI_STATUS
 138 EFIAPI
 139 GetDevicePathsForImageAndFile (
 140   IN OUT EFI_DEVICE_PATH_PROTOCOL **DevPath,
 141   IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath
 142   );
 143
 144 /**
 145   Process all Uefi Shell 2.0 command line options.
 146
 147   see Uefi Shell 2.0 section 3.2 for full details.
 148
 149   the command line should resemble the following:
 150
 151   shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
 152
 153   ShellOpt options  Options which control the initialization behavior of the shell.
 154                     These options are read from the EFI global variable "ShellOpt"
 155                     and are processed before options or file-name.
 156
 157   options           Options which control the initialization behavior of the shell.
 158
 159   file-name         The name of a UEFI shell application or script to be executed
 160                     after initialization is complete. By default, if file-name is
 161                     specified, then -nostartup is implied. Scripts are not supported
 162                     by level 0.
 163
 164   file-nameoptions  The command-line options that are passed to file-name when it
 165                     is invoked.
 166
 167   This will initialize the ShellInitSettings global variable.
 168
 169   @retval EFI_SUCCESS           the variable is initialized.
 170 **/
 171 EFI_STATUS
 172 EFIAPI
 173 ProcessCommandLine(
 174   VOID
 175   );
 176
 177 /**
 178   Handles all interaction with the default startup script.
 179
 180   this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
 181
 182   @param[in] ImagePath          The path to the image for shell.  The first place to look for the startup script.
 183   @param[in] FilePath           The path to the file for shell.  The second place to look for the startup script.
 184
 185   @retval EFI_SUCCESS           The variable is initialized.
 186 **/
 187 EFI_STATUS
 188 EFIAPI
 189 DoStartupScript(
 190   IN EFI_DEVICE_PATH_PROTOCOL *ImagePath,
 191   IN EFI_DEVICE_PATH_PROTOCOL *FilePath
 192   );
 193
 194 /**
 195   Function to perform the shell prompt looping.  It will do a single prompt,
 196   dispatch the result, and then return.  It is expected that the caller will
 197   call this function in a loop many times.
 198
 199   @retval EFI_SUCCESS
 200   @retval RETURN_ABORTED
 201 **/
 202 EFI_STATUS
 203 EFIAPI
 204 DoShellPrompt (
 205   VOID
 206   );
 207
 208 /**
 209   Add a buffer to the Buffer To Free List for safely returning buffers to other
 210   places without risking letting them modify internal shell information.
 211
 212   @param Buffer   Something to pass to FreePool when the shell is exiting.
 213 **/
 214 VOID*
 215 EFIAPI
 216 AddBufferToFreeList(
 217   VOID *Buffer
 218   );
 219
 220 /**
 221   Add a buffer to the Command History List.
 222
 223   @param Buffer[in]     The line buffer to add.
 224 **/
 225 VOID
 226 EFIAPI
 227 AddLineToCommandHistory(
 228   IN CONST CHAR16 *Buffer
 229   );
 230
 231 /**
 232   Function will process and run a command line.
 233
 234   This will determine if the command line represents an internal shell command or dispatch an external application.
 235
 236   @param[in] CmdLine  the command line to parse
 237
 238   @retval EFI_SUCCESS     the command was completed
 239   @retval EFI_ABORTED     the command's operation was aborted
 240 **/
 241 EFI_STATUS
 242 EFIAPI
 243 RunCommand(
 244   IN CONST CHAR16   *CmdLine
 245   );
 246
 247 /**
 248   Function determins if the CommandName COULD be a valid command.  It does not determine whether
 249   this is a valid command.  It only checks for invalid characters.
 250
 251   @param[in] CommandName    The name to check
 252
 253   @retval TRUE              CommandName could be a command name
 254   @retval FALSE             CommandName could not be a valid command name
 255 **/
 256 BOOLEAN
 257 EFIAPI
 258 IsValidCommandName(
 259   IN CONST CHAR16     *CommandName
 260   );
 261
 262 /**
 263   Function to process a NSH script file via SHELL_FILE_HANDLE.
 264
 265   @param[in] Handle             The handle to the already opened file.
 266   @param[in] Name               The name of the script file.
 267
 268   @retval EFI_SUCCESS           the script completed sucessfully
 269 **/
 270 EFI_STATUS
 271 EFIAPI
 272 RunScriptFileHandle (
 273   IN SHELL_FILE_HANDLE  Handle,
 274   IN CONST CHAR16       *Name
 275   );
 276
 277 /**
 278   Function to process a NSH script file.
 279
 280   @param[in] ScriptPath         Pointer to the script file name (including file system path).
 281
 282   @retval EFI_SUCCESS           the script completed sucessfully
 283 **/
 284 EFI_STATUS
 285 EFIAPI
 286 RunScriptFile (
 287   IN CONST CHAR16 *ScriptPath
 288   );
 289
 290
 291 #endif //_SHELL_INTERNAL_HEADER_
 292