dynui_cmd.c File Reference

Dynamic user interface commands. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <ipxe/dynui.h>
#include <ipxe/command.h>
#include <ipxe/parseopt.h>
#include <ipxe/settings.h>
#include <ipxe/features.h>

Go to the source code of this file.

Data Structures
struct	dynui_options
	"dynui" options More...
struct	item_options
	"item" options More...
struct	choose_options
	"choose" options More...
struct	present_options
	"present" options More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FEATURE (FEATURE_MISC, "Menu", DHCP_EB_FEATURE_MENU, 1)
static int	dynui_exec (int argc, char **argv)
	The "dynui" command. More...
static int	item_exec (int argc, char **argv)
	The "item" command. More...
static int	choose_exec (int argc, char **argv)
	The "choose" command. More...
static int	present_exec (int argc, char **argv)
	The "present" command. More...

Variables
static struct option_descriptor	dynui_opts []
	"dynui" option list More...
static struct command_descriptor	dynui_cmd
	"dynui" command descriptor More...
static struct option_descriptor	item_opts []
	"item" option list More...
static struct command_descriptor	item_cmd
	"item" command descriptor More...
static struct option_descriptor	choose_opts []
	"choose" option list More...
static struct command_descriptor	choose_cmd
	"choose" command descriptor More...
static struct option_descriptor	present_opts []
	"present" option list More...
static struct command_descriptor	present_cmd
	"present" command descriptor More...
struct command dynui_commands []	__command
	Dynamic user interface commands. More...

Detailed Description

Dynamic user interface commands.

Definition in file dynui_cmd.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FEATURE()

FEATURE	(	FEATURE_MISC	,
		"Menu"	,
		DHCP_EB_FEATURE_MENU	,
		1
	)

dynui_exec()

static int dynui_exec ( int  argc, char **  argv  )

static

The "dynui" command.

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 73 of file dynui_cmd.c.

                                                {
        struct dynui_options opts;
        struct dynamic_ui *dynui;
        char *title;
        int rc;

        /* Parse options */
        if ( ( rc = parse_options ( argc, argv, &dynui_cmd, &opts ) ) != 0 )
                goto err_parse_options;

        /* Parse title */
        title = concat_args ( &argv[optind] );
        if ( ! title ) {
                rc = -ENOMEM;
                goto err_parse_title;
        }

        /* Create dynamic user interface */
        dynui = create_dynui ( opts.name, title );
        if ( ! dynui ) {
                rc = -ENOMEM;
                goto err_create_dynui;
        }

        /* Destroy dynamic user interface, if applicable */
        if ( opts.delete )
                destroy_dynui ( dynui );

        /* Success */
        rc = 0;

 err_create_dynui:
        free ( title );
 err_parse_title:
 err_parse_options:
        return rc;
}

References concat_args(), create_dynui(), destroy_dynui(), dynui_cmd, ENOMEM, free, optind, opts, parse_options(), rc, and dynamic_ui::title.

item_exec()

static int item_exec ( int  argc, char **  argv  )

static

The "item" command.

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 153 of file dynui_cmd.c.

                                               {
        struct item_options opts;
        struct dynamic_ui *dynui;
        struct dynamic_item *item;
        unsigned int flags = 0;
        char *name = NULL;
        char *text = NULL;
        int rc;

        /* Parse options */
        if ( ( rc = parse_options ( argc, argv, &item_cmd, &opts ) ) != 0 )
                goto err_parse_options;

        /* Parse name, if present */
        if ( ! opts.is_gap )
                name = argv[optind++]; /* May be NULL */

        /* Parse text, if present */
        if ( optind < argc ) {
                text = concat_args ( &argv[optind] );
                if ( ! text ) {
                        rc = -ENOMEM;
                        goto err_parse_text;
                }
        }

        /* Identify dynamic user interface */
        if ( ( rc = parse_dynui ( opts.dynui, &dynui ) ) != 0 )
                goto err_parse_dynui;

        /* Add dynamic user interface item */
        if ( opts.is_default )
                flags |= DYNUI_DEFAULT;
        if ( opts.is_secret )
                flags |= DYNUI_SECRET;
        item = add_dynui_item ( dynui, name, ( text ? text : "" ), flags,
                                opts.key );
        if ( ! item ) {
                rc = -ENOMEM;
                goto err_add_dynui_item;
        }

        /* Success */
        rc = 0;

 err_add_dynui_item:
 err_parse_dynui:
        free ( text );
 err_parse_text:
 err_parse_options:
        return rc;
}

References add_dynui_item(), concat_args(), DYNUI_DEFAULT, DYNUI_SECRET, ENOMEM, flags, free, item_cmd, name, NULL, optind, opts, parse_dynui(), parse_options(), rc, and dynamic_item::text.

choose_exec()

static int choose_exec ( int  argc, char **  argv  )

static

The "choose" command.

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 245 of file dynui_cmd.c.

                                                 {
        struct choose_options opts;
        struct named_setting setting;
        struct dynamic_ui *dynui;
        struct dynamic_item *item;
        int rc;

        /* Parse options */
        if ( ( rc = parse_options ( argc, argv, &choose_cmd, &opts ) ) != 0 )
                goto err_parse_options;

        /* Parse setting name */
        if ( ( rc = parse_autovivified_setting ( argv[optind],
                                                 &setting ) ) != 0 )
                goto err_parse_setting;

        /* Identify dynamic user interface */
        if ( ( rc = parse_dynui ( opts.dynui, &dynui ) ) != 0 )
                goto err_parse_dynui;

        /* Show as menu */
        if ( ( rc = show_menu ( dynui, opts.timeout, opts.retimeout,
                                opts.select, &item ) ) != 0 )
                goto err_show_menu;

        /* Apply default type if necessary */
        if ( ! setting.setting.type )
                setting.setting.type = &setting_type_string;

        /* Store setting */
        if ( ( rc = storef_setting ( setting.settings, &setting.setting,
                                     item->name ) ) != 0 ) {
                printf ( "Could not store \"%s\": %s\n",
                         setting.setting.name, strerror ( rc ) );
                goto err_store;
        }

        /* Success */
        rc = 0;

 err_store:
 err_show_menu:
        /* Destroy dynamic user interface, if applicable */
        if ( ! opts.keep )
                destroy_dynui ( dynui );
 err_parse_dynui:
 err_parse_setting:
 err_parse_options:
        return rc;
}

References choose_cmd, destroy_dynui(), setting::name, dynamic_item::name, optind, opts, parse_autovivified_setting(), parse_dynui(), parse_options(), printf(), rc, show_menu(), storef_setting(), strerror(), and setting::type.

present_exec()

static int present_exec ( int  argc, char **  argv  )

static

The "present" command.

Parameters

argc	Argument count
argv	Argument list

Return values

rc	Return status code

Definition at line 323 of file dynui_cmd.c.

                                                  {
        struct present_options opts;
        struct dynamic_ui *dynui;
        int rc;

        /* Parse options */
        if ( ( rc = parse_options ( argc, argv, &present_cmd, &opts ) ) != 0 )
                goto err_parse_options;

        /* Identify dynamic user interface */
        if ( ( rc = parse_dynui ( opts.dynui, &dynui ) ) != 0 )
                goto err_parse_dynui;

        /* Show as form */
        if ( ( rc = show_form ( dynui ) ) != 0 )
                goto err_show_form;

        /* Success */
        rc = 0;

 err_show_form:
        /* Destroy dynamic user interface, if applicable */
        if ( ! opts.keep )
                destroy_dynui ( dynui );
 err_parse_dynui:
 err_parse_options:
        return rc;
}

References destroy_dynui(), opts, parse_dynui(), parse_options(), present_cmd, rc, and show_form().

Variable Documentation

dynui_opts

struct option_descriptor dynui_opts[]

static

Initial value:

= {
        OPTION_DESC ( "name", 'n', required_argument,
                      struct dynui_options, name, parse_string ),
        OPTION_DESC ( "delete", 'd', no_argument,
                      struct dynui_options, delete, parse_flag ),
}

"dynui" option list

Definition at line 54 of file dynui_cmd.c.

dynui_cmd

struct command_descriptor dynui_cmd

static

Initial value:

=
        COMMAND_DESC ( struct dynui_options, dynui_opts, 0, MAX_ARGUMENTS,
                       "[<title>]" )

"dynui" command descriptor

Definition at line 62 of file dynui_cmd.c.

Referenced by dynui_exec().

item_opts

struct option_descriptor item_opts[]

static

Initial value:

= {
        OPTION_DESC ( "menu", 'm', required_argument,
                      struct item_options, dynui, parse_string ),
        OPTION_DESC ( "form", 'f', required_argument,
                      struct item_options, dynui, parse_string ),
        OPTION_DESC ( "key", 'k', required_argument,
                      struct item_options, key, parse_key ),
        OPTION_DESC ( "default", 'd', no_argument,
                      struct item_options, is_default, parse_flag ),
        OPTION_DESC ( "secret", 's', no_argument,
                      struct item_options, is_secret, parse_flag ),
        OPTION_DESC ( "gap", 'g', no_argument,
                      struct item_options, is_gap, parse_flag ),
}

"item" option list

Definition at line 126 of file dynui_cmd.c.

item_cmd

struct command_descriptor item_cmd

static

Initial value:

=
        COMMAND_DESC ( struct item_options, item_opts, 0, MAX_ARGUMENTS,
                       "[<name> [<text>]]" )

"item" command descriptor

Definition at line 142 of file dynui_cmd.c.

Referenced by item_exec().

choose_opts

struct option_descriptor choose_opts[]

static

Initial value:

= {
        OPTION_DESC ( "menu", 'm', required_argument,
                      struct choose_options, dynui, parse_string ),
        OPTION_DESC ( "default", 'd', required_argument,
                      struct choose_options, select, parse_string ),
        OPTION_DESC ( "timeout", 't', required_argument,
                      struct choose_options, timeout, parse_timeout ),
        OPTION_DESC ( "retimeout", 'r', required_argument,
                      struct choose_options, retimeout, parse_timeout ),
        OPTION_DESC ( "keep", 'k', no_argument,
                      struct choose_options, keep, parse_flag ),
}

"choose" option list

Definition at line 221 of file dynui_cmd.c.

choose_cmd

struct command_descriptor choose_cmd

static

Initial value:

=
        COMMAND_DESC ( struct choose_options, choose_opts, 1, 1, "<setting>" )

"choose" command descriptor

Definition at line 235 of file dynui_cmd.c.

Referenced by choose_exec().

present_opts

struct option_descriptor present_opts[]

static

Initial value:

= {
        OPTION_DESC ( "form", 'f', required_argument,
                      struct present_options, dynui, parse_string ),
        OPTION_DESC ( "keep", 'k', no_argument,
                      struct present_options, keep, parse_flag ),
}

"present" option list

Definition at line 305 of file dynui_cmd.c.

present_cmd

struct command_descriptor present_cmd

static

Initial value:

=
        COMMAND_DESC ( struct present_options, present_opts, 0, 0, NULL )

"present" command descriptor

Definition at line 313 of file dynui_cmd.c.

Referenced by present_exec().

__command

struct command dynui_commands [] __command

Initial value:

= {
        {
                .name = "menu",
                .exec = dynui_exec,
        },
        {
                .name = "form",
                .exec = dynui_exec,
        },
        {
                .name = "item",
                .exec = item_exec,
        },
        {
                .name = "choose",
                .exec = choose_exec,
        },
        {
                .name = "present",
                .exec = present_exec,
        },
}

Dynamic user interface commands.

Definition at line 353 of file dynui_cmd.c.