/*
* Copyright (C) 2001 Cluster File Systems, Inc.
*
- * Copyright (c) 2014, Intel Corporation.
+ * Copyright (c) 2014, 2017, Intel Corporation.
*
* This file is part of Lustre, http://www.sf.net/projects/lustre/
*
*
*/
-#include <lustre_ver.h>
-#include <libcfs/libcfsutil.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <getopt.h>
+#include <malloc.h>
+#ifdef HAVE_LIBREADLINE
+# include <readline/history.h>
+# include <readline/readline.h>
+#endif /* HAVE_LIBREADLINE */
+#include <string.h>
+#include <unistd.h>
+
+#include <libcfs/util/parser.h>
+#include <linux/lustre/lustre_ver.h>
static command_t * top_level; /* Top level of commands, initialized by
* InitParser */
static char *skiptowhitespace(char *s);
static command_t *find_cmd(char *name, command_t cmds[], char **next);
static int process(char *s, char **next, command_t *lookup, command_t **result,
- char **prev);
-static void print_commands(char *str, command_t *table);
+ char **prev);
static char * skipwhitespace(char * s)
{
int Parser_execarg(int argc, char **argv, command_t cmds[])
{
- command_t *cmd;
-
- cmd = Parser_findargcmd(argv[0], cmds);
- if ( cmd ) {
- int rc = (cmd->pc_func)(argc, argv);
- if (rc == CMD_HELP)
- fprintf(stderr, "%s\n", cmd->pc_help);
- return rc;
- } else {
+ command_t *cmd;
+
+ cmd = Parser_findargcmd(argv[0], cmds);
+ if (cmd != NULL && cmd->pc_func != NULL) {
+ int rc = (cmd->pc_func)(argc, argv);
+ if (rc == CMD_HELP)
+ fprintf(stderr, "%s\n", cmd->pc_help);
+ return rc;
+ } else {
printf("Try interactive use without arguments or use one of:\n");
- for (cmd = cmds; cmd->pc_name; cmd++)
- printf("\"%s\"\n", cmd->pc_name);
- printf("as argument.\n");
- }
- return -1;
+ for (cmd = cmds; cmd->pc_name; cmd++)
+ printf("\"%s\"\n", cmd->pc_name);
+ printf("as argument.\n");
+ }
+ return -1;
}
/* returns the command_t * (NULL if not found) corresponding to a
}
got_it:
- /* found a unique command: component or full? */
- if ( (*result)->pc_func ) {
- return CMD_COMPLETE;
- } else {
- if ( *next == '\0' ) {
- return CMD_INCOMPLETE;
- } else {
- return process(*next, next, (*result)->pc_sub_cmd,
- result, prev);
- }
- }
+ /* found a unique command: component or full? */
+ if ((*result)->pc_func != NULL) {
+ return CMD_COMPLETE;
+ } else {
+ if (**next == '\0') {
+ return CMD_INCOMPLETE;
+ } else {
+ return process(*next, next, (*result)->pc_sub_cmd,
+ result, prev);
+ }
+ }
}
#ifdef HAVE_LIBREADLINE
if (*(pos - 1) == ' ') match_tbl = table->pc_sub_cmd;
}
- return completion_matches(text, command_generator);
+ return rl_completion_matches(text, command_generator);
}
#endif
/* take a string and execute the function or print help */
int execute_line(char * line)
{
- command_t *cmd, *ambig;
- char *prev;
- char *next, *tmp;
- char *argv[MAXARGS];
- int i;
- int rc = 0;
-
- switch (process(line, &next, top_level, &cmd, &prev)) {
- case CMD_AMBIG:
- fprintf(stderr, "Ambiguous command \'%s\'\nOptions: ", line);
- while( (ambig = find_cmd(prev, cmd, &tmp)) ) {
- fprintf(stderr, "%s ", ambig->pc_name);
- cmd = ambig + 1;
- }
- fprintf(stderr, "\n");
- break;
- case CMD_NONE:
- fprintf(stderr, "No such command, type help\n");
- break;
- case CMD_INCOMPLETE:
- fprintf(stderr,
- "'%s' incomplete command. Use '%s x' where x is one of:\n",
- line, line);
- fprintf(stderr, "\t");
- for (i = 0; cmd->pc_sub_cmd[i].pc_name; i++) {
- fprintf(stderr, "%s ", cmd->pc_sub_cmd[i].pc_name);
- }
- fprintf(stderr, "\n");
- break;
- case CMD_COMPLETE:
- i = line2args(line, argv, MAXARGS);
- rc = (cmd->pc_func)(i, argv);
-
- if (rc == CMD_HELP)
- fprintf(stderr, "%s\n", cmd->pc_help);
-
- break;
- }
+ command_t *cmd, *ambig;
+ char *prev;
+ char *next, *tmp;
+ char *argv[MAXARGS];
+ int i;
+ int rc = 0;
+
+ switch (process(line, &next, top_level, &cmd, &prev)) {
+ case CMD_AMBIG:
+ fprintf(stderr, "Ambiguous command \'%s\'\nOptions: ", line);
+ while ((ambig = find_cmd(prev, cmd, &tmp))) {
+ fprintf(stderr, "%s ", ambig->pc_name);
+ cmd = ambig + 1;
+ }
+ fprintf(stderr, "\n");
+ break;
+ case CMD_NONE:
+ fprintf(stderr, "No such command, type help\n");
+ break;
+ case CMD_INCOMPLETE:
+ fprintf(stderr, "'%s' incomplete command. Use '%s x' where "
+ "x is one of:\n", line, line);
+ fprintf(stderr, "\t");
+ for (i = 0; cmd->pc_sub_cmd[i].pc_name; i++)
+ fprintf(stderr, "%s ", cmd->pc_sub_cmd[i].pc_name);
+ fprintf(stderr, "\n");
+ break;
+ case CMD_COMPLETE:
+ optind = 0;
+ i = line2args(line, argv, MAXARGS);
+ rc = (cmd->pc_func)(i, argv);
+
+ if (rc == CMD_HELP)
+ fprintf(stderr, "%s\n", cmd->pc_help);
+
+ break;
+ }
- return rc;
+ return rc;
}
#ifdef HAVE_LIBREADLINE
void Parser_qhelp(int argc, char *argv[]) {
- printf("Available commands are:\n");
+ printf("usage: %s [COMMAND] [OPTIONS]... [ARGS]\n",
+ program_invocation_short_name);
+ printf("Without any parameters, interactive mode is invoked\n");
- print_commands(NULL, top_level);
- printf("For more help type: help command-name\n");
+ printf("Try '%s help <COMMAND>' or '%s --list-commands' for more information\n",
+ program_invocation_short_name, program_invocation_short_name);
}
int Parser_help(int argc, char **argv)
/*************************************************************************
* COMMANDS *
*************************************************************************/
-static void print_commands(char * str, command_t * table) {
- command_t * cmds;
- char buf[80];
-
- for (cmds = table; cmds->pc_name; cmds++) {
- if (cmds->pc_func) {
- if (str) printf("\t%s %s\n", str, cmds->pc_name);
- else printf("\t%s\n", cmds->pc_name);
- }
- if (cmds->pc_sub_cmd) {
- if (str) {
- sprintf(buf, "%s %s", str, cmds->pc_name);
- print_commands(buf, cmds->pc_sub_cmd);
- } else {
- print_commands(cmds->pc_name, cmds->pc_sub_cmd);
- }
- }
- }
+
+/**
+ * Parser_list_commands() - Output a list of the supported commands.
+ * @cmdlist: Array of structures describing the commands.
+ * @buffer: String buffer used to temporarily store the output text.
+ * @buf_size: Length of the string buffer.
+ * @parent_cmd: When called recursively, contains the name of the parent cmd.
+ * @col_start: Column where printing should begin.
+ * @col_num: The number of commands printed in a single row.
+ *
+ * The commands and subcommands supported by the utility are printed, arranged
+ * into several columns for readability. If a command supports subcommands, the
+ * function is called recursively, and the name of the parent command is
+ * supplied so that it can be prepended to the names of the subcommands.
+ *
+ * Return: The number of items that were printed.
+ */
+int Parser_list_commands(const command_t *cmdlist, char *buffer,
+ size_t buf_size, const char *parent_cmd,
+ int col_start, int col_num)
+{
+ int col = col_start;
+ int char_max;
+ int len;
+ int count = 0;
+ int rc;
+
+ if (col_start >= col_num)
+ return 0;
+
+ char_max = (buf_size - 1) / col_num; /* Reserve 1 char for NUL */
+
+ for (; cmdlist->pc_name != NULL; cmdlist++) {
+ if (cmdlist->pc_func == NULL && cmdlist->pc_sub_cmd == NULL)
+ break;
+ count++;
+ if (parent_cmd != NULL)
+ len = snprintf(&buffer[col * char_max],
+ char_max + 1, "%s %s", parent_cmd,
+ cmdlist->pc_name);
+ else
+ len = snprintf(&buffer[col * char_max],
+ char_max + 1, "%s", cmdlist->pc_name);
+
+ /* Add trailing spaces to pad the entry to the column size */
+ if (len < char_max) {
+ snprintf(&buffer[col * char_max] + len,
+ char_max - len + 1, "%*s", char_max - len,
+ " ");
+ } else {
+ buffer[(col + 1) * char_max - 1] = ' ';
+ }
+
+ col++;
+ if (col >= col_num) {
+ fprintf(stdout, "%s\n", buffer);
+ col = 0;
+ buffer[0] = '\0';
+ }
+
+ if (cmdlist->pc_sub_cmd != NULL) {
+ rc = Parser_list_commands(cmdlist->pc_sub_cmd, buffer,
+ buf_size, cmdlist->pc_name,
+ col, col_num);
+ col = (col + rc) % col_num;
+ count += rc;
+ }
+ }
+ if (parent_cmd == NULL && col != 0)
+ fprintf(stdout, "%s\n", buffer);
+ return count;
}
char *Parser_getstr(const char *prompt, const char *deft, char *res,