fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-04 10:40:58 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

cli: make it possible to call sub-commands with client obtained asynchronously

Browse source
This commit is contained in:
Lubomir Rintel 2016-08-31 21:04:33 +02:00
parent 6499bb893f
commit 3ee03afecc
7 changed files with 215 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
clients/cli/agent.c
View file

@ -209,13 +209,12 @@ do_agent_all (NmCli *nmc, int argc, char **argv)
}
static const NMCCommand agent_cmds[] = {
{"secret", do_agent_secret, usage_agent_secret },
{"polkit", do_agent_polkit, usage_agent_polkit },
{"all", do_agent_all, usage_agent_all },
{NULL, do_agent_all, usage }
{ "secret", do_agent_secret, usage_agent_secret, FALSE },
{ "polkit", do_agent_polkit, usage_agent_polkit, FALSE },
{ "all", do_agent_all, usage_agent_all, FALSE },
{ NULL, do_agent_all, usage, FALSE },
};
NMCResultCode
do_agent (NmCli *nmc, int argc, char **argv)
{
@ -225,9 +224,10 @@ do_agent (NmCli *nmc, int argc, char **argv)
/* Check whether NetworkManager is running */
if (!nm_client_get_nm_running (nmc->client)) {
g_string_printf (nmc->return_text, _("Error: NetworkManager is not running."));
nmc->return_value = NMC_RESULT_ERROR_NM_NOT_RUNNING;
return nmc->return_value;
return NMC_RESULT_ERROR_NM_NOT_RUNNING;
}
return nmc_do_cmd (nmc, agent_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, agent_cmds, *argv, argc, argv);
return nmc->return_value;
}

130
clients/cli/common.c
View file

@ -1565,13 +1565,92 @@ nmc_parse_lldp_capabilities (guint value)
return g_string_free (str, FALSE);
}
extern GMainLoop *loop;
static void
command_done (GObject *object, GAsyncResult *res, gpointer user_data)
{
GSimpleAsyncResult *simple = (GSimpleAsyncResult *)res;
NmCli *nmc = user_data;
GError *error = NULL;
if (g_simple_async_result_propagate_error (simple, &error)) {
nmc->return_value = error->code;
g_string_assign (nmc->return_text, error->message);
g_error_free (error);
}
if (!nmc->should_wait)
g_main_loop_quit (loop);
}
typedef struct {
NmCli *nmc;
const NMCCommand *cmd;
int argc;
char **argv;
GSimpleAsyncResult *simple;
} CmdCall;
static void
call_cmd (NmCli *nmc, GSimpleAsyncResult *simple, const NMCCommand *cmd, int argc, char **argv);
static void
got_client (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GError *error = NULL;
CmdCall *call = user_data;
NmCli *nmc = call->nmc;
nmc->should_wait--;
nmc->client = nm_client_new_finish (res, &error);
if (!nmc->client) {
g_simple_async_result_set_error (call->simple, NMCLI_ERROR, NMC_RESULT_ERROR_UNKNOWN,
_("Error: Could not create NMClient object: %s."), error->message);
g_error_free (error);
g_simple_async_result_complete (call->simple);
} else {
call_cmd (nmc, call->simple, call->cmd, call->argc, call->argv);
}
g_slice_free (CmdCall, call);
}
static void
call_cmd (NmCli *nmc, GSimpleAsyncResult *simple, const NMCCommand *cmd, int argc, char **argv)
{
CmdCall *call;
if (nmc->client || !cmd->needs_client) {
/* Check whether NetworkManager is running */
if (cmd->needs_nm_running && !nm_client_get_nm_running (nmc->client)) {
g_simple_async_result_set_error (simple, NMCLI_ERROR, NMC_RESULT_ERROR_NM_NOT_RUNNING,
_("Error: NetworkManager is not running."));
} else
nmc->return_value = cmd->func (nmc, argc, argv);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
} else {
nmc->should_wait++;
call = g_slice_new0 (CmdCall);
call->nmc = nmc;
call->cmd = cmd;
call->argc = argc;
call->argv = argv;
call->simple = simple;
nm_client_new_async (NULL, got_client, call);
}
}
/**
* nmc_do_cmd:
* @nmc: Client instance
* @cmds: Command table
* @cmd: Command
* @argc: Argument count
* @argv: Arguments vector
* @argv: Arguments vector. Must be a global variable.
*
* Picks the right callback to handle command from the command table.
* If --help argument follows and the usage callback is specified for the command
@ -1580,22 +1659,35 @@ nmc_parse_lldp_capabilities (guint value)
* The command table is terminated with a %NULL command. The terminating
* entry's handlers are called if the command is empty.
*
* Returns: a nmcli return code
* The argument vector needs to be a pointer to the global arguments vector that is
* never freed, since the command handler will be called asynchronously and there's
* no callback to free the memory in (for simplicity).
*/
NMCResultCode
void
nmc_do_cmd (NmCli *nmc, const NMCCommand cmds[], const char *cmd, int argc, char **argv)
{
const NMCCommand *c;
GSimpleAsyncResult *simple;
if (argc == 0 && nmc->complete)
return nmc->return_value;
simple = g_simple_async_result_new (NULL,
command_done,
nmc,
nmc_do_cmd);
if (argc == 0 && nmc->complete) {
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
if (argc == 1 && nmc->complete) {
for (c = cmds; c->cmd; ++c) {
if (!*cmd || matches (cmd, c->cmd) == 0)
g_print ("%s\n", c->cmd);
}
return nmc->return_value;
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
for (c = cmds; c->cmd; ++c) {
@ -1605,28 +1697,34 @@ nmc_do_cmd (NmCli *nmc, const NMCCommand cmds[], const char *cmd, int argc, char
if (c->cmd) {
/* A valid command was specified. */
if (c->usage && nmc_arg_is_help (*(argv+1)))
if (c->usage && nmc_arg_is_help (*(argv+1))) {
c->usage ();
else
nmc->return_value = c->func (nmc, argc-1, argv+1);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
} else
call_cmd (nmc, simple, c, argc-1, argv+1);
} else if (cmd) {
/* Not a known command. */
if (nmc_arg_is_help (cmd) && c->usage) {
c->usage ();
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
} else {
g_string_printf (nmc->return_text, _("Error: argument '%s' not understood. Try passing --help instead."), cmd);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
g_simple_async_result_set_error (simple, NMCLI_ERROR, NMC_RESULT_ERROR_USER_INPUT,
_("Error: argument '%s' not understood. Try passing --help instead."), cmd);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
} else if (c->func) {
/* No command, run the default handler. */
nmc->return_value = c->func (nmc, argc, argv);
call_cmd (nmc, simple, c, argc, argv);
} else {
/* No command and no default handler. */
g_string_printf (nmc->return_text, _("Error: missing argument. Try passing --help."));
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
g_simple_async_result_set_error (simple, NMCLI_ERROR, NMC_RESULT_ERROR_USER_INPUT,
_("Error: missing argument. Try passing --help."));
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
return nmc->return_value;
}
/**

4
clients/cli/common.h
View file

@ -80,9 +80,11 @@ typedef struct {
const char *cmd;
NMCResultCode (*func) (NmCli *nmc, int argc, char **argv);
void (*usage) (void);
gboolean needs_client;
gboolean needs_nm_running;
} NMCCommand;
NMCResultCode nmc_do_cmd (NmCli *nmc, const NMCCommand cmds[], const char *argv0, int argc, char **argv);
void nmc_do_cmd (NmCli *nmc, const NMCCommand cmds[], const char *cmd, int argc, char **argv);
void nmc_complete_strings (const char *prefix, ...) G_GNUC_NULL_TERMINATED;

32
clients/cli/connections.c
View file

@ -8796,20 +8796,20 @@ nmcli_con_tab_completion (const char *text, int start, int end)
}
static const NMCCommand connection_cmds[] = {
{"show", do_connections_show, usage_connection_show },
{"up", do_connection_up, usage_connection_up },
{"down", do_connection_down, usage_connection_down },
{"add", do_connection_add, usage_connection_add },
{"edit", do_connection_edit, usage_connection_edit },
{"delete", do_connection_delete, usage_connection_delete },
{"reload", do_connection_reload, usage_connection_reload },
{"load", do_connection_load, usage_connection_load },
{"modify", do_connection_modify, usage_connection_modify },
{"clone", do_connection_clone, usage_connection_clone },
{"import", do_connection_import, usage_connection_import },
{"export", do_connection_export, usage_connection_export },
{"monitor", do_connection_monitor, usage_connection_monitor },
{NULL, do_connections_show, usage },
{ "show", do_connections_show, usage_connection_show, FALSE },
{ "up", do_connection_up, usage_connection_up, FALSE },
{ "down", do_connection_down, usage_connection_down, FALSE },
{ "add", do_connection_add, usage_connection_add, FALSE },
{ "edit", do_connection_edit, usage_connection_edit, FALSE },
{ "delete", do_connection_delete, usage_connection_delete, FALSE },
{ "reload", do_connection_reload, usage_connection_reload, FALSE },
{ "load", do_connection_load, usage_connection_load, FALSE },
{ "modify", do_connection_modify, usage_connection_modify, FALSE },
{ "clone", do_connection_clone, usage_connection_clone, FALSE },
{ "import", do_connection_import, usage_connection_import, FALSE },
{ "export", do_connection_export, usage_connection_export, FALSE },
{ "monitor", do_connection_monitor, usage_connection_monitor, FALSE },
{ NULL, do_connections_show, usage, FALSE },
};
/* Entry point function for connections-related commands: 'nmcli connection' */
@ -8834,7 +8834,9 @@ do_connections (NmCli *nmc, int argc, char **argv)
return nmc->return_value;
}
return nmc_do_cmd (nmc, connection_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, connection_cmds, *argv, argc, argv);
return nmc->return_value;
}
void

50
clients/cli/devices.c
View file

@ -3607,11 +3607,11 @@ finish:
}
static NMCCommand device_wifi_cmds[] = {
{"list", do_device_wifi_list, NULL },
{"connect", do_device_wifi_connect_network, NULL },
{"hotspot", do_device_wifi_hotspot, NULL },
{"rescan", do_device_wifi_rescan, NULL },
{NULL, do_device_wifi_list, NULL }
{ "list", do_device_wifi_list, NULL, FALSE },
{ "connect", do_device_wifi_connect_network, NULL, FALSE },
{ "hotspot", do_device_wifi_hotspot, NULL, FALSE },
{ "rescan", do_device_wifi_rescan, NULL, FALSE },
{ NULL, do_device_wifi_list, NULL, FALSE },
};
static NMCResultCode
@ -3625,7 +3625,9 @@ do_device_wifi (NmCli *nmc, int argc, char **argv)
return NMC_RESULT_ERROR_USER_INPUT;
}
return nmc_do_cmd (nmc, device_wifi_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, device_wifi_cmds, *argv, argc, argv);
return nmc->return_value;
}
static int
@ -3780,8 +3782,8 @@ do_device_lldp_list (NmCli *nmc, int argc, char **argv)
}
static NMCCommand device_lldp_cmds[] = {
{"list", do_device_lldp_list, NULL },
{NULL, do_device_lldp_list, NULL }
{ "list", do_device_lldp_list, NULL, FALSE },
{ NULL, do_device_lldp_list, NULL, FALSE },
};
static NMCResultCode
@ -3798,7 +3800,9 @@ do_device_lldp (NmCli *nmc, int argc, char **argv)
if (!nmc->mode_specified)
nmc->multiline_output = TRUE; /* multiline mode is default for 'device lldp' */
return nmc_do_cmd (nmc, device_lldp_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, device_lldp_cmds, *argv, argc, argv);
return nmc->return_value;
}
static gboolean
@ -3844,18 +3848,18 @@ nmcli_device_tab_completion (const char *text, int start, int end)
}
static const NMCCommand device_cmds[] = {
{"status", do_devices_status, usage_device_status },
{"show", do_device_show, usage_device_show },
{"connect", do_device_connect, usage_device_connect },
{"reapply", do_device_reapply, usage_device_reapply },
{"disconnect", do_devices_disconnect, usage_device_disconnect },
{"delete", do_devices_delete, usage_device_delete },
{"set", do_device_set, usage_device_set },
{"monitor", do_devices_monitor, usage_device_monitor },
{"wifi", do_device_wifi, usage_device_wifi },
{"lldp", do_device_lldp, usage_device_lldp },
{"modify", do_device_modify, usage_device_modify },
{NULL, do_devices_status, usage },
{ "status", do_devices_status, usage_device_status, FALSE },
{ "show", do_device_show, usage_device_show, FALSE },
{ "connect", do_device_connect, usage_device_connect, FALSE },
{ "reapply", do_device_reapply, usage_device_reapply, FALSE },
{ "disconnect", do_devices_disconnect, usage_device_disconnect, FALSE },
{ "delete", do_devices_delete, usage_device_delete, FALSE },
{ "set", do_device_set, usage_device_set, FALSE },
{ "monitor", do_devices_monitor, usage_device_monitor, FALSE },
{ "wifi", do_device_wifi, usage_device_wifi, FALSE },
{ "lldp", do_device_lldp, usage_device_lldp, FALSE },
{ "modify", do_device_modify, usage_device_modify, FALSE },
{ NULL, do_devices_status, usage, FALSE },
};
NMCResultCode
@ -3875,7 +3879,9 @@ do_devices (NmCli *nmc, int argc, char **argv)
return NMC_RESULT_ERROR_NM_NOT_RUNNING;
}
return nmc_do_cmd (nmc, device_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, device_cmds, *argv, argc, argv);
return nmc->return_value;
}
void

26
clients/cli/general.c
View file

@ -678,11 +678,11 @@ do_general_hostname (NmCli *nmc, int argc, char **argv)
}
static const NMCCommand general_cmds[] = {
{"status", do_general_status, usage_general_status },
{"hostname", do_general_hostname, usage_general_hostname },
{"permissions", do_general_permissions, usage_general_permissions },
{"logging", do_general_logging, usage_general_logging },
{NULL, do_general_status, usage_general }
{ "status", do_general_status, usage_general_status, FALSE },
{ "hostname", do_general_hostname, usage_general_hostname, FALSE },
{ "permissions", do_general_permissions, usage_general_permissions, FALSE },
{ "logging", do_general_logging, usage_general_logging, FALSE },
{ NULL, do_general_status, usage_general, FALSE },
};
/*
@ -694,7 +694,9 @@ do_general (NmCli *nmc, int argc, char **argv)
/* Register polkit agent */
nmc_start_polkit_agent_start_try (nmc);
return nmc_do_cmd (nmc, general_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, general_cmds, *argv, argc, argv);
return nmc->return_value;
}
static gboolean
@ -916,10 +918,10 @@ do_radio_wwan (NmCli *nmc, int argc, char **argv)
}
static const NMCCommand radio_cmds[] = {
{"all", do_radio_all, usage_radio_all },
{"wifi", do_radio_wifi, usage_radio_wifi },
{"wwan", do_radio_wwan, usage_radio_wwan },
{NULL, do_radio_all, usage_radio }
{ "all", do_radio_all, usage_radio_all, FALSE },
{ "wifi", do_radio_wifi, usage_radio_wifi, FALSE },
{ "wwan", do_radio_wwan, usage_radio_wwan, FALSE },
{ NULL, do_radio_all, usage_radio, FALSE },
};
/*
@ -931,7 +933,9 @@ do_radio (NmCli *nmc, int argc, char **argv)
/* Register polkit agent */
nmc_start_polkit_agent_start_try (nmc);
return nmc_do_cmd (nmc, radio_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, radio_cmds, *argv, argc, argv);
return nmc->return_value;
}
static void

72
clients/cli/nmcli.c
View file

@ -205,18 +205,18 @@ usage (void)
}
static const NMCCommand nmcli_cmds[] = {
{ "general", do_general, NULL },
{ "monitor", do_monitor, NULL },
{ "networking", do_networking, NULL },
{ "radio", do_radio, NULL },
{ "connection", do_connections, NULL },
{ "device", do_devices, NULL },
{ "agent", do_agent, NULL },
{ NULL, do_overview, usage }
{ "general", do_general, NULL, FALSE },
{ "monitor", do_monitor, NULL, FALSE },
{ "networking", do_networking, NULL, FALSE },
{ "radio", do_radio, NULL, FALSE },
{ "connection", do_connections, NULL, FALSE },
{ "device", do_devices, NULL, FALSE },
{ "agent", do_agent, NULL, FALSE },
{ NULL, do_overview, usage, FALSE },
};
static NMCResultCode
parse_command_line (NmCli *nmc, int argc, char **argv)
static gboolean
process_command_line (NmCli *nmc, int argc, char **argv)
{
char *base;
@ -257,12 +257,12 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
if (nmc->print_output == NMC_PRINT_TERSE) {
g_string_printf (nmc->return_text, _("Error: Option '--terse' is specified the second time."));
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
else if (nmc->print_output == NMC_PRINT_PRETTY) {
g_string_printf (nmc->return_text, _("Error: Option '--terse' is mutually exclusive with '--pretty'."));
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
else
nmc->print_output = NMC_PRINT_TERSE;
@ -270,12 +270,12 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
if (nmc->print_output == NMC_PRINT_PRETTY) {
g_string_printf (nmc->return_text, _("Error: Option '--pretty' is specified the second time."));
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
else if (nmc->print_output == NMC_PRINT_TERSE) {
g_string_printf (nmc->return_text, _("Error: Option '--pretty' is mutually exclusive with '--terse'."));
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
else
nmc->print_output = NMC_PRINT_PRETTY;
@ -284,7 +284,7 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
if (next_arg (&argc, &argv) != 0) {
g_string_printf (nmc->return_text, _("Error: missing argument for '%s' option."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
if (argc == 1 && nmc->complete)
nmc_complete_strings (argv[0], "tabular", "multiline", NULL);
@ -295,13 +295,13 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
else {
g_string_printf (nmc->return_text, _("Error: '%s' is not valid argument for '%s' option."), argv[0], opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
} else if (matches (opt, "-colors") == 0) {
if (next_arg (&argc, &argv) != 0) {
g_string_printf (nmc->return_text, _("Error: missing argument for '%s' option."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
if (argc == 1 && nmc->complete)
nmc_complete_strings (argv[0], "yes", "no", "auto", NULL);
@ -314,13 +314,13 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
else {
g_string_printf (nmc->return_text, _("Error: '%s' is not valid argument for '%s' option."), argv[0], opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
} else if (matches (opt, "-escape") == 0) {
if (next_arg (&argc, &argv) != 0) {
g_string_printf (nmc->return_text, _("Error: missing argument for '%s' option."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
if (argc == 1 && nmc->complete)
nmc_complete_strings (argv[0], "yes", "no", NULL);
@ -331,13 +331,13 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
else {
g_string_printf (nmc->return_text, _("Error: '%s' is not valid argument for '%s' option."), argv[0], opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
} else if (matches (opt, "-fields") == 0) {
if (next_arg (&argc, &argv) != 0) {
g_string_printf (nmc->return_text, _("Error: fields for '%s' options are missing."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
if (argc == 1 && nmc->complete)
complete_fields (argv[0]);
@ -353,13 +353,13 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
if (next_arg (&argc, &argv) != 0) {
g_string_printf (nmc->return_text, _("Error: missing argument for '%s' option."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
if (!nmc_string_to_uint (argv[0], TRUE, 0, G_MAXINT, &timeout)) {
g_string_printf (nmc->return_text, _("Error: '%s' is not a valid timeout for '%s' option."),
argv[0], opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
nmc->timeout = (int) timeout;
} else if (matches (opt, "-version") == 0) {
@ -373,14 +373,16 @@ parse_command_line (NmCli *nmc, int argc, char **argv)
} else {
g_string_printf (nmc->return_text, _("Error: Option '%s' is unknown, try 'nmcli -help'."), opt);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
return nmc->return_value;
return FALSE;
}
argc--;
argv++;
}
/* Now run the requested command */
return nmc_do_cmd (nmc, nmcli_cmds, *argv, argc, argv);
nmc_do_cmd (nmc, nmcli_cmds, *argv, argc, argv);
return TRUE;
}
static gboolean nmcli_sigint = FALSE;
@ -587,19 +589,6 @@ nmc_cleanup (NmCli *nmc)
nmc_polkit_agent_fini (nmc);
}
static gboolean
start (gpointer data)
{
ArgsInfo *info = (ArgsInfo *) data;
info->nmc->return_value = parse_command_line (info->nmc, info->argc, info->argv);
if (!info->nmc->should_wait)
g_main_loop_quit (loop);
return FALSE;
}
int
main (int argc, char *argv[])
{
@ -626,10 +615,9 @@ main (int argc, char *argv[])
nmc_value_transforms_register ();
nmc_init (&nm_cli);
g_idle_add (start, &args_info);
loop = g_main_loop_new (NULL, FALSE); /* create main loop */
g_main_loop_run (loop); /* run main loop */
loop = g_main_loop_new (NULL, FALSE);
if (process_command_line (&nm_cli, argc, argv))
g_main_loop_run (loop);
if (nm_cli.complete) {
/* Remove error statuses from command completion runs. */