977 lines
33 KiB
C
977 lines
33 KiB
C
/** @file
|
|
Defines for EFI shell environment 2 ported to EDK II build environment. (no spec)
|
|
|
|
Copyright (c) 2005, 2009 Intel Corporation
|
|
All rights reserved. This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
|
|
#ifndef _SHELLENV2_H_
|
|
#define _SHELLENV2_H_
|
|
|
|
#include <Protocol/SimpleTextIn.h>
|
|
#include <Protocol/SimpleTextOut.h>
|
|
#include <Protocol/EfiShellInterface.h>
|
|
|
|
#define DEFAULT_INIT_ROW 1
|
|
#define DEFAULT_AUTO_LF FALSE
|
|
|
|
|
|
/**
|
|
this function is a prototype for a function that dumps information on a protocol
|
|
to a given location. the location is dependant on the implementation. This is
|
|
used when programatically adding shell commands.
|
|
|
|
@param Handle the handle the protocol is on
|
|
@param Interface the interface to the protocol
|
|
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_DUMP_PROTOCOL_INFO) (
|
|
IN EFI_HANDLE Handle,
|
|
IN VOID *Interface
|
|
);
|
|
|
|
/**
|
|
this function is a prototype foe each command internal to the EFI shell
|
|
implementation. the specific command depends on the implementation. This is
|
|
used when programatically adding shell commands.
|
|
|
|
@param ImageHandle The handle to the binary shell
|
|
@param SystemTable pointer to the system table.
|
|
|
|
@retval EFI_SUCCESS the command ran to completion
|
|
@return other an error ocurred. any error is possible
|
|
depending on the implementation of the shell
|
|
command.
|
|
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_INTERNAL_COMMAND) (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
);
|
|
|
|
/**
|
|
This function is a prototype for one that gets a help string for a given command.
|
|
This is used when programatically adding shell commands. Upon successful return
|
|
the memory allocated is up to the caller to free.
|
|
|
|
@param Str pointer to pointer to string to display for help.
|
|
|
|
@retval EFI_SUCCESS the help string is in the parameter Str.
|
|
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLCMD_GET_LINE_HELP) (
|
|
IN OUT CHAR16 **Str
|
|
);
|
|
|
|
/**
|
|
* Structure returned from functions that open multiple files
|
|
**/
|
|
typedef struct {
|
|
UINT32 Signature; ///< SHELL_FILE_ARG_SIGNATURE
|
|
LIST_ENTRY Link; ///< linked list helper
|
|
EFI_STATUS Status; ///< File's status
|
|
|
|
EFI_FILE_HANDLE Parent; ///< what is the Parent file of this file
|
|
UINT64 OpenMode; ///< how was the file opened
|
|
CHAR16 *ParentName; ///< string representation of parent
|
|
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; ///< DevicePath for Parent
|
|
|
|
CHAR16 *FullName; ///< path and file name for this file
|
|
CHAR16 *FileName; ///< file name for this file
|
|
|
|
EFI_FILE_HANDLE Handle; ///< handle to this file
|
|
EFI_FILE_INFO *Info; ///< pointer to file info for this file
|
|
} SHELL_FILE_ARG;
|
|
|
|
/// signature for SHELL_FILE_ARG
|
|
#define SHELL_FILE_ARG_SIGNATURE SIGNATURE_32 ('g', 'r', 'a', 'f')
|
|
|
|
/**
|
|
* GUID for the shell environment2 and shell environment
|
|
**/
|
|
#define SHELL_ENVIRONMENT_PROTOCOL_GUID \
|
|
{ \
|
|
0x47c7b221, 0xc42a, 0x11d2, 0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b \
|
|
}
|
|
|
|
/**
|
|
* GUID for the shell environment2 extension (main GUID same as shell environment)
|
|
**/
|
|
#define EFI_SE_EXT_SIGNATURE_GUID \
|
|
{ \
|
|
0xd2c18636, 0x40e5, 0x4eb5, {0xa3, 0x1b, 0x36, 0x69, 0x5f, 0xd4, 0x2c, 0x87} \
|
|
}
|
|
|
|
#define EFI_SHELL_MAJOR_VER 0x00000001 ///< Major version of the EFI_SHELL_ENVIRONMENT2
|
|
#define EFI_SHELL_MINOR_VER 0x00000000 ///< Minor version of the EFI_SHELL_ENVIRONMENT2
|
|
|
|
/**
|
|
execute a command line
|
|
|
|
this function will run the CommandLine. This includes loading any required images,
|
|
parsing any requires scripts, and it DebugOutput is TRUE printing errors
|
|
encountered directly to the screen.
|
|
|
|
@param ParentImageHandle Handle of image executing this operation
|
|
@param CommandLine string command line to execute
|
|
@param DebugOutput TRUE indicates that errors should be printed directly.
|
|
FALSE supresses error messages.
|
|
|
|
@retval EFI_SUCCESS the command line executed and completed.
|
|
@retval EFI_ABORTED the operation did not complete due to abort.
|
|
@retval EFI_INVALID_PARAMETER A parameter did not have a valid value.
|
|
@retval EFI_OUT_OF_RESOURCES A required memory allocation failed.
|
|
|
|
@sa HandleProtocol
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_EXECUTE) (
|
|
IN EFI_HANDLE *ParentImageHandle,
|
|
IN CHAR16 *CommandLine,
|
|
IN BOOLEAN DebugOutput
|
|
);
|
|
|
|
/**
|
|
this function returns a shell environment variable value.
|
|
|
|
@param Name pointer to the string with the shell environment
|
|
variables name
|
|
|
|
@retval NULL the shell environment variable's value could not be found
|
|
@retval !NULL the value of the shell environment variable Name
|
|
|
|
**/
|
|
typedef
|
|
CHAR16 *
|
|
(EFIAPI *SHELLENV_GET_ENV) (
|
|
IN CHAR16 *Name
|
|
);
|
|
|
|
/**
|
|
this function returns a shell environment map value.
|
|
|
|
@param Name pointer to the string with the shell environment
|
|
map name
|
|
|
|
@retval NULL the shell environment map's value could not be found
|
|
@retval !NULL the value of the shell environment map Name
|
|
|
|
**/
|
|
typedef
|
|
CHAR16 *
|
|
(EFIAPI *SHELLENV_GET_MAP) (
|
|
IN CHAR16 *Name
|
|
);
|
|
|
|
/**
|
|
This function will add an internal command to the shell interface.
|
|
|
|
This will allocate all required memory, put the new command on the command
|
|
list in the correct location.
|
|
|
|
@param Handler the handler function to call when the command gets called
|
|
@param CmdStr The command name
|
|
@param GetLineHelp function to call of get help for this command
|
|
|
|
@retval EFI_SUCCESS the command is now part of the command list
|
|
@retval EFI_OUT_OF_RESOURCES a memory allocation failed.
|
|
@sa SHELLENV_INTERNAL_COMMAND
|
|
@sa SHELLCMD_GET_LINE_HELP
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_ADD_CMD) (
|
|
IN SHELLENV_INTERNAL_COMMAND Handler,
|
|
IN CHAR16 *Cmd,
|
|
IN SHELLCMD_GET_LINE_HELP GetLineHelp
|
|
);
|
|
|
|
/**
|
|
Internal interface to add protocol handlers.
|
|
|
|
This function is for internal shell use only. This is how protocol handlers are added.
|
|
This will get the current protocol info and add the new info or update existing info
|
|
and then resave the info.
|
|
|
|
@param SaveId save this change as an EFI variable
|
|
@param Protocol the protocol's GUID
|
|
@param DumpToken The function pointer to dump token function or
|
|
NULL
|
|
@param DumpInfo The function pointer to dump infomation function
|
|
or NULL
|
|
@param IdString The english name of the protocol
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_ADD_PROT) (
|
|
IN EFI_GUID *Protocol,
|
|
IN SHELLENV_DUMP_PROTOCOL_INFO DumpToken OPTIONAL,
|
|
IN SHELLENV_DUMP_PROTOCOL_INFO DumpInfo OPTIONAL,
|
|
IN CHAR16 *IdString
|
|
);
|
|
|
|
/**
|
|
this function finds a protocol handle by a GUID.
|
|
|
|
This function will check for already known protocols by GUID and if one is
|
|
found it will return the name of that protocol. if no name is found and
|
|
GenId is TRUE it will generate ths string.
|
|
|
|
@param Protocol the GUID of the protocol to look for.
|
|
@param GenId whether to generate a name string if its not found.
|
|
|
|
@return !NULL the Name of the protocol.
|
|
@retval NULL the Name was not found and GenId was not TRUE.
|
|
**/
|
|
typedef
|
|
CHAR16*
|
|
(EFIAPI *SHELLENV_GET_PROT) (
|
|
IN EFI_GUID *Protocol,
|
|
IN BOOLEAN GenId
|
|
);
|
|
|
|
/**
|
|
this function returns the current directory on a given device
|
|
|
|
If DeviceName is specified, then return the current shell directory on that
|
|
device. If DeviceName is NULL, then return the current directory on the
|
|
current device. The caller us responsible to free the returned string when
|
|
no londer required.
|
|
|
|
@param DeviceName the name of the device to get the current
|
|
directory on or NULL for current device
|
|
|
|
@return The current directory on the current or specified device.
|
|
|
|
**/
|
|
typedef
|
|
CHAR16*
|
|
(EFIAPI *SHELLENV_CUR_DIR) (
|
|
IN CHAR16 *DeviceName OPTIONAL
|
|
);
|
|
|
|
/**
|
|
this function will open a group of files that match the Arg path, including
|
|
support for wildcard characters ('?' and '*') in the Arg path. if there are
|
|
any wildcard characters in the path this function will find any and all files
|
|
that match the wildcards. the return is a double linked list based on the
|
|
LIST_ENTRY linked list structure. use this in conjunction with the
|
|
SHELL_FILE_ARG_SIGNATURE to get the SHELL_FILE_ARG structures that are returned.
|
|
The memory allocated by the callee for this list is freed by making a call to
|
|
SHELLENV_FREE_FILE_LIST.
|
|
|
|
@param Arg pointer Path to files to open
|
|
@param ListHead pointer to allocated and initialized list head
|
|
upon which to append all the opened file structures.
|
|
|
|
@retval EFI_SUCCESS 1 or more files was opened and a struct of each file's
|
|
information was appended to ListHead.
|
|
@retval EFI_OUT_OF_RESOURCES a memory allocation failed.
|
|
@retval EFI_NOT_FOUND no matching files could be found.
|
|
@sa SHELLENV_FREE_FILE_LIST
|
|
**/typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_FILE_META_ARG) (
|
|
IN CHAR16 *Arg,
|
|
IN OUT LIST_ENTRY *ListHead
|
|
);
|
|
|
|
/**
|
|
this frees all of the nodes under the ListHead, but not ListHead itself.
|
|
|
|
@param ListHead Pointer to list to free all nodes of.
|
|
|
|
@retval EFI_SUCCESS always returned.
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_FREE_FILE_LIST) (
|
|
IN OUT LIST_ENTRY *ListHead
|
|
);
|
|
|
|
/**
|
|
this function creates a new instance of the ShellInterface protocol for use on
|
|
the ImageHandle.
|
|
|
|
This function is for internal shell usage. this will allocate and then populate
|
|
EFI_SHELL_INTERFACE protocol. it is the caller's responsibility to free the
|
|
memory.
|
|
|
|
@param ImageHandle the handle which will use the new ShellInterface
|
|
protocol.
|
|
|
|
@return the newly allocated shell interface protocol.
|
|
|
|
**/
|
|
typedef
|
|
EFI_SHELL_INTERFACE*
|
|
(EFIAPI *SHELLENV_NEW_SHELL) (
|
|
IN EFI_HANDLE ImageHandle
|
|
);
|
|
|
|
/**
|
|
this function determins whether a script file is currently being processed.
|
|
|
|
a script file (.nsh file) can contain a series of commands and this is useful to
|
|
know for some shell commands whether they are being run manually or as part of a
|
|
script.
|
|
|
|
@retval TRUE A script file is being processed
|
|
@return FALSE A script file is not being processed
|
|
**/
|
|
typedef
|
|
BOOLEAN
|
|
(EFIAPI *SHELLENV_BATCH_IS_ACTIVE) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
This is an internal shell function to free any and all allocated resources.
|
|
This should be called just closing the shell.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_FREE_RESOURCES) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
This function enables the page break mode.
|
|
|
|
This mode causes the output to pause after each complete screen to enable a
|
|
user to more easily read it. if AutoWrap is TRUE then rows with too many
|
|
characters will be chopped and divided into 2 rows. if FALSE then rows with
|
|
too many characters may not be fully visible to the user on the screen.
|
|
|
|
@param StartRow the row number to start this on.
|
|
@param AutoWrap whether to auto wrap rows that are
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_ENABLE_PAGE_BREAK) (
|
|
IN INT32 StartRow,
|
|
IN BOOLEAN AutoWrap
|
|
);
|
|
|
|
/**
|
|
This function disables the page break mode.
|
|
|
|
disabling this causes the output to print out exactly as coded with no breaks
|
|
for readability.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_DISABLE_PAGE_BREAK) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
Get the status of the page break output mode.
|
|
|
|
@retval FALSE page break output mode is not enabled
|
|
@retval TRUE page break output mode is enabled
|
|
**/
|
|
typedef
|
|
BOOLEAN
|
|
(EFIAPI *SHELLENV_GET_PAGE_BREAK) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
this function sets the keys to filter for for the console in. the valid
|
|
values to set are:
|
|
|
|
#define EFI_OUTPUT_SCROLL 0x00000001
|
|
#define EFI_OUTPUT_PAUSE 0x00000002
|
|
#define EFI_EXECUTION_BREAK 0x00000004
|
|
|
|
@param KeyFilter The new key filter to use.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_SET_KEY_FILTER) (
|
|
IN UINT32 KeyFilter
|
|
);
|
|
|
|
/**
|
|
this function gets the keys to filter for for the console in. the valid
|
|
values to get are:
|
|
|
|
#define EFI_OUTPUT_SCROLL 0x00000001
|
|
#define EFI_OUTPUT_PAUSE 0x00000002
|
|
#define EFI_EXECUTION_BREAK 0x00000004
|
|
|
|
@retval the current filter mask.
|
|
**/
|
|
typedef
|
|
UINT32
|
|
(EFIAPI *SHELLENV_GET_KEY_FILTER) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
this function determins if the shell application should break.
|
|
|
|
This is used to inform a shell application that a break condition has been
|
|
initiated. long loops should check this to prevent delays to the break.
|
|
|
|
@retval TRUE a break has been signaled. the application
|
|
should exit with EFI_ABORTED as soon as possible.
|
|
@retval FALSE continue as normal.
|
|
**/
|
|
typedef
|
|
BOOLEAN
|
|
(EFIAPI *SHELLENV_GET_EXECUTION_BREAK) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
This is an internal-shell function used to increment the shell nesting level.
|
|
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_INCREMENT_SHELL_NESTING_LEVEL) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
This is an internal-shell function used to decrement the shell nesting level.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_DECREMENT_SHELL_NESTING_LEVEL) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
this function determins if the caller is running under the root shell.
|
|
|
|
@retval TRUE The caller is running under the root shell
|
|
@retval FALSE The caller is not running under the root shell
|
|
|
|
**/
|
|
typedef
|
|
BOOLEAN
|
|
(EFIAPI *SHELLENV_IS_ROOT_SHELL) (
|
|
IN VOID
|
|
);
|
|
|
|
/**
|
|
Close the console proxy to restore the original console.
|
|
|
|
This is an internal shell function to handle shell cascading. it restores the
|
|
original set of console protocols.
|
|
|
|
@param ConInHandle The handle of ConIn.
|
|
@param ConIn pointer to the location to return the pointer to
|
|
the original console input.
|
|
@param ConOutHandle The handle of ConOut
|
|
@param ConOut pointer to the location to return the pointer to
|
|
the original console output.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *SHELLENV_CLOSE_CONSOLE_PROXY) (
|
|
IN EFI_HANDLE ConInHandle,
|
|
IN OUT EFI_SIMPLE_TEXT_INPUT_PROTOCOL **ConIn,
|
|
IN EFI_HANDLE ConOutHandle,
|
|
IN OUT EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL **ConOut
|
|
);
|
|
|
|
//
|
|
// declarations of handle enumerator
|
|
//
|
|
/**
|
|
For ease of use the shell maps handle #'s to short numbers.
|
|
This is only done on request for various internal commands and the references
|
|
are immediately freed when the internal command completes.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *INIT_HANDLE_ENUMERATOR) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
this is an internal shell function to enumerate the handle database.
|
|
|
|
this function gets the next handle in the handle database. if no handles are
|
|
found EFI_NOT_FOUND is returned. if the previous Handle was the last handle
|
|
it is set to NULL before returning.
|
|
|
|
this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.
|
|
|
|
@param Handle pointer to pointer to Handle. will be set
|
|
on a sucessful return.
|
|
|
|
@retval EFI_SUCCESS the next handle in the handle database is *Handle
|
|
@retval EFI_NOT_FOUND there is not another handle.
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *NEXT_HANDLE) (
|
|
IN OUT EFI_HANDLE **Handle
|
|
);
|
|
|
|
/**
|
|
this is an internal shell function to enumerate the handle database.
|
|
|
|
this function skips the next SkipNum handles in the handle database. If there
|
|
are not enough handles left to skip that many EFI_ACCESS_DENIED is returned and
|
|
no skip is performed.
|
|
|
|
this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.
|
|
|
|
@param SkipNum how many handles to skip
|
|
|
|
@retval EFI_SUCCESS the next handle in the handle database is *Handle
|
|
@retval EFI_ACCESS_DENIED there are not SkipNum handles left in the database
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SKIP_HANDLE) (
|
|
IN UINTN SkipNum
|
|
);
|
|
|
|
/**
|
|
this is an internal shell function to enumerate the handle database.
|
|
|
|
this function resets the the handle database so that NEXT_HANDLE and SKIP_HANDLE
|
|
will start from EnumIndex on the next call.
|
|
|
|
this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.
|
|
|
|
@param EnumIndex where to start.
|
|
|
|
@retval the number of handles either read out or skipped before this reset.
|
|
**/
|
|
typedef
|
|
UINTN
|
|
(EFIAPI *RESET_HANDLE_ENUMERATOR) (
|
|
IN UINTN EnumIndex
|
|
);
|
|
|
|
/**
|
|
this is an internal shell function to enumerate the handle database.
|
|
|
|
this must be called after INIT_HANDLE_ENUMERATOR.
|
|
|
|
this function releases all memory and resources associated with the handle database.
|
|
after this no other handle enumerator functions except INIT_HANDLE_ENUMERATOR will
|
|
function properly.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *CLOSE_HANDLE_ENUMERATOR) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
this is an internal shell function to enumerate the handle database.
|
|
|
|
this function returns the number of handles in the handle database.
|
|
|
|
this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.
|
|
|
|
@retval the number of handles in the handle database.
|
|
**/
|
|
typedef
|
|
UINTN
|
|
(EFIAPI *GET_NUM) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
Handle Enumerator structure
|
|
**/
|
|
typedef struct {
|
|
INIT_HANDLE_ENUMERATOR Init; ///< pointer to INIT_HANDLE_ENUMERATOR function
|
|
NEXT_HANDLE Next; ///< pointer to NEXT_HANDLE function
|
|
SKIP_HANDLE Skip; ///< pointer to SKIP_HANDLE function
|
|
RESET_HANDLE_ENUMERATOR Reset; ///< pointer to RESET_HANDLE_ENUMERATOR function
|
|
CLOSE_HANDLE_ENUMERATOR Close; ///< pointer to CLOSE_HANDLE_ENUMERATOR function
|
|
GET_NUM GetNum; ///< pointer to GET_NUM function
|
|
} HANDLE_ENUMERATOR;
|
|
/**
|
|
signature for the PROTOCOL_INFO structure
|
|
**/
|
|
#define PROTOCOL_INFO_SIGNATURE SIGNATURE_32 ('s', 'p', 'i', 'n')
|
|
/**
|
|
PROTOCOL_INFO structure for protocol enumerator functions.
|
|
|
|
**/
|
|
typedef struct {
|
|
UINTN Signature; ///< PROTOCOL_INFO_SIGNATURE
|
|
LIST_ENTRY Link; ///< standard lined list helper member
|
|
//
|
|
// parsing info for the protocol
|
|
//
|
|
EFI_GUID ProtocolId; ///< GUID for the protocol
|
|
CHAR16 *IdString; ///< Name of the protocol
|
|
SHELLENV_DUMP_PROTOCOL_INFO DumpToken; ///< pointer to DumpToken function for the protocol
|
|
SHELLENV_DUMP_PROTOCOL_INFO DumpInfo; ///< pointer to DumpInfo function for the protocol
|
|
//
|
|
// database info on which handles are supporting this protocol
|
|
//
|
|
UINTN NoHandles; ///< how many handles produce this protocol
|
|
EFI_HANDLE *Handles; ///< array of handles
|
|
|
|
} PROTOCOL_INFO;
|
|
|
|
//
|
|
// declarations of protocol info enumerator
|
|
//
|
|
/**
|
|
this is an internal shell function to initialize the protocol enumerator.
|
|
|
|
this must be called before NEXT_PROTOCOL_INFO, SKIP_PROTOCOL_INFO,
|
|
RESET_PROTOCOL_INFO_ENUMERATOR, and CLOSE_PROTOCOL_INFO_ENUMERATOR are
|
|
called.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *INIT_PROTOCOL_INFO_ENUMERATOR) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
this function is an internal shell function for enumeration of protocols.
|
|
|
|
This functiol will return the next protocol in the list. If this is called
|
|
immediately after initialization it will return the first. If this is called
|
|
immediately after reset it will return the protocol first again.
|
|
|
|
This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be
|
|
called after INIT_PROTOCOL_INFO_ENUMERATOR.
|
|
|
|
@param ProtocolInfo pointer to pointer to protocol information structure.
|
|
|
|
@retval EFI_SUCCESS the next protocol's information was sucessfully returned.
|
|
If there were no more protocols NULL was returned.
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *NEXT_PROTOCOL_INFO) (
|
|
IN OUT PROTOCOL_INFO **ProtocolInfo
|
|
);
|
|
|
|
/**
|
|
this function is an internal shell function for enumeration of protocols.
|
|
|
|
This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be
|
|
called after INIT_PROTOCOL_INFO_ENUMERATOR.
|
|
|
|
this function does nothing and always returns EFI_SUCCESS.
|
|
|
|
@retval EFI_SUCCESS always returned (see note).
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SKIP_PROTOCOL_INFO) (
|
|
IN UINTN SkipNum
|
|
);
|
|
|
|
/**
|
|
this function is an internal shell function for enumeration of protocols.
|
|
|
|
This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be
|
|
called after INIT_PROTOCOL_INFO_ENUMERATOR.
|
|
|
|
this function resets the list of protocols such that the next one in the
|
|
list is the begining of the list.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *RESET_PROTOCOL_INFO_ENUMERATOR) (
|
|
VOID
|
|
);
|
|
|
|
|
|
/**
|
|
this function is an internal shell function for enumeration of protocols.
|
|
|
|
This must be called after INIT_PROTOCOL_INFO_ENUMERATOR. After this call
|
|
no protocol enumerator calls except INIT_PROTOCOL_INFO_ENUMERATOR may be made.
|
|
|
|
this function frees any memory or resources associated with the protocol
|
|
enumerator.
|
|
**/
|
|
typedef
|
|
VOID
|
|
(EFIAPI *CLOSE_PROTOCOL_INFO_ENUMERATOR) (
|
|
VOID
|
|
);
|
|
|
|
/**
|
|
* protocol enumerator structure of function pointers.
|
|
**/
|
|
typedef struct {
|
|
INIT_PROTOCOL_INFO_ENUMERATOR Init; ///< pointer to INIT_PROTOCOL_INFO_ENUMERATOR function
|
|
NEXT_PROTOCOL_INFO Next; ///< pointer to NEXT_PROTOCOL_INFO function
|
|
SKIP_PROTOCOL_INFO Skip; ///< pointer to SKIP_PROTOCOL_INFO function
|
|
RESET_PROTOCOL_INFO_ENUMERATOR Reset; ///< pointer to RESET_PROTOCOL_INFO_ENUMERATOR function
|
|
CLOSE_PROTOCOL_INFO_ENUMERATOR Close; ///< pointer to CLOSE_PROTOCOL_INFO_ENUMERATOR function
|
|
} PROTOCOL_INFO_ENUMERATOR;
|
|
|
|
/**
|
|
this function is used to retrieve a user-friendly display name for a handle.
|
|
|
|
If UseComponentName is TRUE then the component name protocol for this device
|
|
or it's parent device (if required) will be used to obtain the name of the
|
|
device. If UseDevicePath is TRUE it will get the human readable device path
|
|
and return that. If both are TRUE it will try to use component name first
|
|
and device path if that fails.
|
|
|
|
It will use either ComponentName or ComponentName2 protocol, depending on
|
|
what is present.
|
|
|
|
This function will furthur verify whether the handle in question produced either
|
|
EFI_DRIVER_CONFIGRATION_PROTOCOL or EFI_DRIVER_CONFIGURATION2_PROTOCOL and also
|
|
whether the handle in question produced either EFI_DRIVER_DIAGNOSTICS_PROTOCOL or
|
|
EFI_DRIVER_DIAGNOSTICS2_PROTOCOL.
|
|
|
|
Upon sucessful return the memory for *BestDeviceName is up to the caller to free.
|
|
|
|
@param DeviceHandle the device handle whose name is desired
|
|
@param UseComponentName whether to use the ComponentName protocol at all
|
|
@param UseDevicePath whether to use the DevicePath protocol at all
|
|
@param Language pointer to language string to use
|
|
@param BestDeviceName pointer to pointer to string allocated with the name
|
|
@param ConfigurationStatus pointer to status for opening a Configuration protocol
|
|
@param DiagnosticsStatus pointer to status for opening a Diagnostics protocol
|
|
@param Display Whether to Print this out to default Print location
|
|
@param Indent how many characters to indent the printing
|
|
|
|
@retval EFI_SUCCESS this function always returns EFI_SUCCESS
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *GET_DEVICE_NAME) (
|
|
EFI_HANDLE DeviceHandle,
|
|
BOOLEAN UseComponentName,
|
|
BOOLEAN UseDevicePath,
|
|
CHAR8 *Language,
|
|
CHAR16 **BestDeviceName,
|
|
EFI_STATUS *ConfigurationStatus,
|
|
EFI_STATUS *DiagnosticsStatus,
|
|
BOOLEAN Display,
|
|
UINTN Indent
|
|
);
|
|
|
|
#define EFI_SHELL_COMPATIBLE_MODE_VER L"1.1.1" ///< string for lowest version this shell supports
|
|
#define EFI_SHELL_ENHANCED_MODE_VER L"1.1.2" ///< string for highest version this shell supports
|
|
|
|
/**
|
|
this function gets the shell mode as stored in the shell environment
|
|
"efishellmode". it will not fail.
|
|
|
|
@param Mode returns a string representing one of the
|
|
2 supported modes of the shell.
|
|
|
|
@retval EFI_SUCCESS this function always returns success
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *GET_SHELL_MODE) (
|
|
OUT CHAR16 **Mode
|
|
);
|
|
|
|
/**
|
|
Convert a file system style name to an file path
|
|
|
|
This function will convert a shell path name to a Device Path Protocol path.
|
|
This function will allocate any required memory for this operation and it
|
|
is the responsibility of the caller to free that memory when no longer required.
|
|
|
|
if anything prevents the complete conversion free any allocated memory and
|
|
return NULL.
|
|
|
|
@retval !NULL a pointer to the callee allocated Device Path
|
|
@retval NULL the operation could not be completed.
|
|
**/
|
|
typedef
|
|
EFI_DEVICE_PATH_PROTOCOL*
|
|
(EFIAPI *SHELLENV_NAME_TO_PATH) (
|
|
IN CHAR16 *Path
|
|
);
|
|
|
|
/**
|
|
converts a device path into a file system map name.
|
|
|
|
if DevPath is NULL then ASSERT
|
|
This function looks through the shell environment map for a map whose device
|
|
path matches the DevPath parameter. If one is found the Name is returned via
|
|
Name parameter. If sucessful the caller must free the memory allocated for
|
|
Name.
|
|
|
|
this function will use the internal lock to prevent changes to the map during
|
|
the lookup operation.
|
|
|
|
@param DevPath The device path to search for a name for
|
|
@param ConsistMapping what state to verify map flag VAR_ID_CONSIST
|
|
@param Name on sucessful return the name of that device path
|
|
|
|
@retval EFI_SUCCESS the DevPath was found and the name returned
|
|
in Name.
|
|
@retval EFI_OUT_OF_RESOURCES A required memory allocation failed.
|
|
@retval EFI_UNSUPPORTED the DevPath was not found in the map
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_GET_FS_NAME) (
|
|
IN EFI_DEVICE_PATH_PROTOCOL * DevPath,
|
|
IN BOOLEAN ConsistMapping,
|
|
OUT CHAR16 **Name
|
|
);
|
|
|
|
/**
|
|
this function will open a group of files that match the Arg path, but will not
|
|
support the wildcard characters ('?' and '*') in the Arg path. if there are
|
|
any wildcard characters in the path this function will return
|
|
EFI_INVALID_PARAMETER. the return is a double linked list based on the
|
|
LIST_ENTRY linked list structure. use this in conjunction with the
|
|
SHELL_FILE_ARG_SIGNATURE to get the SHELL_FILE_ARG structures that are returned.
|
|
The memory allocated by the callee for this list is freed by making a call to
|
|
SHELLENV_FREE_FILE_LIST.
|
|
|
|
@param Arg pointer Path to files to open
|
|
@param ListHead pointer to allocated and initialized list head
|
|
upon which to append all the opened file structures.
|
|
|
|
@retval EFI_SUCCESS 1 or more files was opened and a struct of each file's
|
|
information was appended to ListHead.
|
|
@retval EFI_OUT_OF_RESOURCES a memory allocation failed.
|
|
@retval EFI_NOT_FOUND no matching files could be found.
|
|
@sa SHELLENV_FREE_FILE_LIST
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_FILE_META_ARG_NO_WILDCARD) (
|
|
IN CHAR16 *Arg,
|
|
IN OUT LIST_ENTRY *ListHead
|
|
);
|
|
|
|
/**
|
|
this function removes duplicate file listings from lists.
|
|
|
|
this is a function for use with SHELLENV_FILE_META_ARG_NO_WILDCARD and
|
|
SHELLENV_FILE_META_ARG. this function will verify that there are no duplicate
|
|
files in the list of returned files. any file listed twice will have one of its
|
|
instances removed.
|
|
|
|
@param ListHead pointer to linked list head that was returned from
|
|
SHELLENV_FILE_META_ARG_NO_WILDCARD or
|
|
SHELLENV_FILE_META_ARG.
|
|
|
|
@retval EFI_SUCCESS this function always returns success.
|
|
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_DEL_DUP_FILE) (
|
|
IN LIST_ENTRY * ListHead
|
|
);
|
|
|
|
/**
|
|
Converts a File System map name to a device path.
|
|
|
|
if DevPath is NULL then ASSERT()
|
|
|
|
This function looks through the shell environment map for a map whose Name
|
|
matches the Name parameter. If one is found the device path pointer is
|
|
updated to point to that file systems device path. the caller should not
|
|
free the memory from that device path.
|
|
|
|
this function will use the internal lock to prevent changes to the map during
|
|
the lookup operation.
|
|
|
|
@param Name pointer to NULL terminated UNICODE string of the
|
|
file system name
|
|
@param DevPath pointer to pointer to DevicePath. only valid on
|
|
OUT if sucessful
|
|
|
|
@retval EFI_SUCCESS the conversion was successful and the device
|
|
path was returned.
|
|
@retval EFI_NOT_FOUND the file system could not be found in the map.
|
|
**/
|
|
typedef
|
|
EFI_STATUS
|
|
(EFIAPI *SHELLENV_GET_FS_DEVICE_PATH) (
|
|
IN CHAR16 *Name,
|
|
OUT EFI_DEVICE_PATH_PROTOCOL **DevPath
|
|
);
|
|
|
|
/// EFI_SHELL_ENVIRONMENT2 protocol structure
|
|
/// contains pointers to functions
|
|
typedef struct {
|
|
SHELLENV_EXECUTE Execute;
|
|
SHELLENV_GET_ENV GetEnv;
|
|
SHELLENV_GET_MAP GetMap;
|
|
SHELLENV_ADD_CMD AddCmd;
|
|
SHELLENV_ADD_PROT AddProt;
|
|
SHELLENV_GET_PROT GetProt;
|
|
SHELLENV_CUR_DIR CurDir;
|
|
SHELLENV_FILE_META_ARG FileMetaArg;
|
|
SHELLENV_FREE_FILE_LIST FreeFileList;
|
|
|
|
//
|
|
// The following services are only used by the shell itself
|
|
//
|
|
SHELLENV_NEW_SHELL NewShell;
|
|
SHELLENV_BATCH_IS_ACTIVE BatchIsActive;
|
|
|
|
SHELLENV_FREE_RESOURCES FreeResources;
|
|
|
|
//
|
|
// GUID to differentiate ShellEnvironment2 from ShellEnvironment
|
|
//
|
|
EFI_GUID SESGuid;
|
|
//
|
|
// Major Version grows if shell environment interface has been changes
|
|
//
|
|
UINT32 MajorVersion;
|
|
UINT32 MinorVersion;
|
|
SHELLENV_ENABLE_PAGE_BREAK EnablePageBreak;
|
|
SHELLENV_DISABLE_PAGE_BREAK DisablePageBreak;
|
|
SHELLENV_GET_PAGE_BREAK GetPageBreak;
|
|
|
|
SHELLENV_SET_KEY_FILTER SetKeyFilter;
|
|
SHELLENV_GET_KEY_FILTER GetKeyFilter;
|
|
|
|
SHELLENV_GET_EXECUTION_BREAK GetExecutionBreak;
|
|
SHELLENV_INCREMENT_SHELL_NESTING_LEVEL IncrementShellNestingLevel;
|
|
SHELLENV_DECREMENT_SHELL_NESTING_LEVEL DecrementShellNestingLevel;
|
|
SHELLENV_IS_ROOT_SHELL IsRootShell;
|
|
|
|
SHELLENV_CLOSE_CONSOLE_PROXY CloseConsoleProxy;
|
|
HANDLE_ENUMERATOR HandleEnumerator;
|
|
PROTOCOL_INFO_ENUMERATOR ProtocolInfoEnumerator;
|
|
GET_DEVICE_NAME GetDeviceName;
|
|
GET_SHELL_MODE GetShellMode;
|
|
SHELLENV_NAME_TO_PATH NameToPath;
|
|
SHELLENV_GET_FS_NAME GetFsName;
|
|
SHELLENV_FILE_META_ARG_NO_WILDCARD FileMetaArgNoWildCard;
|
|
SHELLENV_DEL_DUP_FILE DelDupFileArg;
|
|
SHELLENV_GET_FS_DEVICE_PATH GetFsDevicePath;
|
|
} EFI_SHELL_ENVIRONMENT2;
|
|
|
|
extern EFI_GUID gEfiShellEnvironment2Guid;
|
|
extern EFI_GUID gEfiShellEnvironment2ExtGuid;
|
|
#endif // _SHELLENV_H_
|