From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 20004C19759 for ; Wed, 7 Aug 2019 06:47:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DADF321BF2 for ; Wed, 7 Aug 2019 06:47:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727344AbfHGGrw (ORCPT ); Wed, 7 Aug 2019 02:47:52 -0400 Received: from mga06.intel.com ([134.134.136.31]:3495 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727105AbfHGGrw (ORCPT ); Wed, 7 Aug 2019 02:47:52 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga104.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 06 Aug 2019 23:47:51 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,356,1559545200"; d="scan'208";a="182194359" Received: from ingas-nuc1.sea.intel.com ([10.254.176.241]) by FMSMGA003.fm.intel.com with ESMTP; 06 Aug 2019 23:47:51 -0700 From: Inga Stotland To: linux-bluetooth@vger.kernel.org Cc: brian.gix@intel.com, luiz.dentz@gmail.com, Inga Stotland Subject: [PATCH BlueZ 1/2] shared/shell: Add ell based shell implementation Date: Tue, 6 Aug 2019 23:47:46 -0700 Message-Id: <20190807064747.6725-2-inga.stotland@intel.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190807064747.6725-1-inga.stotland@intel.com> References: <20190807064747.6725-1-inga.stotland@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-bluetooth-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-bluetooth@vger.kernel.org This adds the functionality of bt_shell that uses ell mainloop. --- Makefile.am | 13 +- src/shared/shell-ell.c | 1320 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1330 insertions(+), 3 deletions(-) create mode 100644 src/shared/shell-ell.c diff --git a/Makefile.am b/Makefile.am index 9d25a815b..0ce3048ad 100644 --- a/Makefile.am +++ b/Makefile.am @@ -187,9 +187,6 @@ shared_sources = src/shared/io.h src/shared/timeout.h \ src/shared/log.h src/shared/log.c \ src/shared/tty.h -if READLINE -shared_sources += src/shared/shell.c src/shared/shell.h -endif src_libshared_glib_la_SOURCES = $(shared_sources) \ src/shared/io-glib.c \ @@ -205,11 +202,21 @@ src_libshared_mainloop_la_SOURCES = $(shared_sources) \ src/shared/mainloop-notify.h \ src/shared/mainloop-notify.c +if READLINE +shared_sources += src/shared/shell.h +src_libshared_glib_la_SOURCES += src/shared/shell.c +src_libshared_mainloop_la_SOURCES += src/shared/shell.c +endif + if LIBSHARED_ELL noinst_LTLIBRARIES += src/libshared-ell.la src_libshared_ell_la_SOURCES = $(shared_sources) \ src/shared/io-ell.c + +if READLINE +src_libshared_ell_la_SOURCES += src/shared/shell-ell.c +endif endif attrib_sources = attrib/att.h attrib/att-database.h attrib/att.c \ diff --git a/src/shared/shell-ell.c b/src/shared/shell-ell.c new file mode 100644 index 000000000..1b481e04e --- /dev/null +++ b/src/shared/shell-ell.c @@ -0,0 +1,1320 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2017-2019 Intel Corporation. All rights reserved. + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "ell/ell.h" + +#include "src/shared/util.h" +#include "src/shared/log.h" +#include "src/shared/shell.h" + +#define CMD_LENGTH 48 +#define print_text(color, fmt, args...) \ + printf(color fmt COLOR_OFF "\n", ## args) +#define print_menu(cmd, args, desc) \ + printf(COLOR_HIGHLIGHT "%s %-*s " COLOR_OFF "%s\n", \ + cmd, (int)(CMD_LENGTH - strlen(cmd)), args, desc) +#define print_submenu(cmd, desc) \ + printf(COLOR_BLUE "%s %-*s " COLOR_OFF "%s\n", \ + cmd, (int)(CMD_LENGTH - strlen(cmd)), "", desc) + +struct bt_shell_env { + char *name; + void *value; +}; + +static char *cmplt = "help"; + +struct bt_shell_prompt_input { + char *str; + bt_shell_prompt_input_func func; + void *user_data; +}; + +static struct { + bool init; + char *name; + char history[256]; + int argc; + char **argv; + bool mode; + bool monitor; + int timeout; + struct l_io *input; + + bool saved_prompt; + bt_shell_prompt_input_func saved_func; + void *saved_user_data; + + struct l_queue *prompts; + + const struct bt_shell_menu *menu; + const struct bt_shell_menu *main; + struct l_queue *submenus; + const struct bt_shell_menu_entry *exec; + + struct l_queue *envs; +} data; + +static void shell_print_menu(void); + +static void cmd_version(int argc, char *argv[]) +{ + bt_shell_printf("Version %s\n", VERSION); + + return bt_shell_noninteractive_quit(EXIT_SUCCESS); +} + +static void cmd_quit(int argc, char *argv[]) +{ + l_main_quit(); +} + +static void print_cmds(void) +{ + const struct bt_shell_menu_entry *entry; + const struct l_queue_entry *submenu; + + if (!data.menu) + return; + + printf("Commands:\n"); + + for (entry = data.menu->entries; entry->cmd; entry++) { + printf("\t%s%s\t%s\n", entry->cmd, + strlen(entry->cmd) < 8 ? "\t" : "", entry->desc); + } + + for (submenu = l_queue_get_entries(data.submenus); submenu; + submenu = submenu->next) { + struct bt_shell_menu *menu = submenu->data; + + printf("\n\t%s.:\n", menu->name); + + for (entry = menu->entries; entry->cmd; entry++) { + printf("\t\t%s%s\t%s\n", entry->cmd, + strlen(entry->cmd) < 8 ? "\t" : "", + entry->desc); + } + } +} + +static void cmd_help(int argc, char *argv[]) +{ + if (argv[0] == cmplt) + print_cmds(); + else + shell_print_menu(); + + return bt_shell_noninteractive_quit(EXIT_SUCCESS); +} + +static const struct bt_shell_menu *find_menu(const char *name, size_t len) +{ + const struct l_queue_entry *entry; + + for (entry = l_queue_get_entries(data.submenus); entry; + entry = entry->next) { + struct bt_shell_menu *menu = entry->data; + + if (!strncmp(menu->name, name, len)) + return menu; + } + + return NULL; +} + +static char *menu_generator(const char *text, int state) +{ + static unsigned int index, len; + static struct l_queue_entry *entry; + + if (!state) { + index = 0; + len = strlen(text); + entry = (void *) l_queue_get_entries(data.submenus); + } + + for (; entry; entry = entry->next) { + struct bt_shell_menu *menu = entry->data; + + index++; + + if (!strncmp(menu->name, text, len)) { + entry = entry->next; + return strdup(menu->name); + } + } + + return NULL; +} + +static void cmd_menu(int argc, char *argv[]) +{ + const struct bt_shell_menu *menu; + + if (argc < 2 || !strlen(argv[1])) { + bt_shell_printf("Missing name argument\n"); + return bt_shell_noninteractive_quit(EXIT_FAILURE); + } + + menu = find_menu(argv[1], strlen(argv[1])); + if (!menu) { + bt_shell_printf("Unable find menu with name: %s\n", argv[1]); + return bt_shell_noninteractive_quit(EXIT_FAILURE); + } + + bt_shell_set_menu(menu); + + shell_print_menu(); + + return bt_shell_noninteractive_quit(EXIT_SUCCESS); +} + +static bool cmd_menu_exists(const struct bt_shell_menu *menu) +{ + /* Skip menu command if not on main menu or if there are no + * submenus. + */ + if (menu != data.main || l_queue_isempty(data.submenus)) + return false; + + return true; +} + +static void cmd_back(int argc, char *argv[]) +{ + if (data.menu == data.main) { + bt_shell_printf("Already on main menu\n"); + return; + } + + bt_shell_set_menu(data.main); + + shell_print_menu(); +} + +static bool cmd_back_exists(const struct bt_shell_menu *menu) +{ + /* Skip back command if on main menu */ + if (menu == data.main) + return false; + + return true; +} + +static void cmd_export(int argc, char *argv[]) +{ + const struct l_queue_entry *entry; + + entry = l_queue_get_entries(data.envs); + + for (; entry; entry = entry->next) { + struct bt_shell_env *env = entry->data; + + print_text(COLOR_HIGHLIGHT, "%s=%p", env->name, env->value); + } +} + +static const struct bt_shell_menu_entry default_menu[] = { + { "back", NULL, cmd_back, "Return to main menu", NULL, + NULL, cmd_back_exists }, + { "menu", "", cmd_menu, "Select submenu", + menu_generator, NULL, + cmd_menu_exists}, + { "version", NULL, cmd_version, "Display version" }, + { "quit", NULL, cmd_quit, "Quit program" }, + { "exit", NULL, cmd_quit, "Quit program" }, + { "help", NULL, cmd_help, + "Display help about this program" }, + { "export", NULL, cmd_export, + "Print evironment variables" }, + { } +}; + +static void shell_print_help(void) +{ + print_text(COLOR_HIGHLIGHT, + "\n" + "Use \"help\" for a list of available commands in a menu.\n" + "Use \"menu \" if you want to enter any submenu.\n" + "Use \"back\" if you want to return to menu main."); +} + +static void shell_print_menu(void) +{ + const struct bt_shell_menu_entry *entry; + const struct l_queue_entry *submenu; + + if (!data.menu) + return; + + print_text(COLOR_HIGHLIGHT, "Menu %s:", data.menu->name); + print_text(COLOR_HIGHLIGHT, "Available commands:"); + print_text(COLOR_HIGHLIGHT, "-------------------"); + + if (data.menu == data.main) { + for (submenu = l_queue_get_entries(data.submenus); submenu; + submenu = submenu->next) { + struct bt_shell_menu *menu = submenu->data; + + print_submenu(menu->name, menu->desc ? menu->desc : + "Submenu"); + } + } + + for (entry = data.menu->entries; entry->cmd; entry++) + print_menu(entry->cmd, entry->arg ? : "", entry->desc ? : ""); + + for (entry = default_menu; entry->cmd; entry++) { + if (entry->exists && !entry->exists(data.menu)) + continue; + + print_menu(entry->cmd, entry->arg ? : "", entry->desc ? : ""); + } +} + +static int parse_args(char *arg, wordexp_t *w, char *del, int flags) +{ + char *str; + + str = strdelimit(arg, del, '"'); + + if (wordexp(str, w, flags)) { + free(str); + return -EINVAL; + } + + /* If argument ends with ... set we_offs bypass strict checks */ + if (w->we_wordc && !strsuffix(w->we_wordv[w->we_wordc - 1], "...")) + w->we_offs = 1; + + free(str); + + return 0; +} + +static int cmd_exec(const struct bt_shell_menu_entry *entry, + int argc, char *argv[]) +{ + wordexp_t w; + size_t len; + char *man, *opt; + int flags = WRDE_NOCMD; + bool optargs = false; + + if (!entry->arg || entry->arg[0] == '\0') { + if (argc > 1) { + print_text(COLOR_HIGHLIGHT, "Too many arguments"); + return -EINVAL; + } + goto exec; + } + + /* Find last mandatory arguments */ + man = strrchr(entry->arg, '>'); + if (!man) { + opt = strdup(entry->arg); + goto optional; + } + + len = man - entry->arg; + if (entry->arg[0] == '<') + man = strndup(entry->arg, len + 1); + else { + /* Find where mandatory arguments start */ + opt = strrchr(entry->arg, '<'); + /* Skip if mandatory arguments are not in the right format */ + if (!opt || opt > man) { + opt = strdup(entry->arg); + goto optional; + } + man = strndup(opt, man - opt + 1); + optargs = true; + } + + if (parse_args(man, &w, "<>", flags) < 0) { + print_text(COLOR_HIGHLIGHT, + "Unable to parse mandatory command arguments: %s", man); + free(man); + return -EINVAL; + } + + free(man); + + /* Check if there are enough arguments */ + if ((unsigned int) argc - 1 < w.we_wordc) { + print_text(COLOR_HIGHLIGHT, "Missing %s argument", + w.we_wordv[argc - 1]); + goto fail; + } + + flags |= WRDE_APPEND; + opt = strdup(entry->arg + len + 1); + +optional: + if (parse_args(opt, &w, "[]", flags) < 0) { + print_text(COLOR_HIGHLIGHT, + "Unable to parse optional command arguments: %s", opt); + free(opt); + return -EINVAL; + } + + free(opt); + + /* Check if there are too many arguments */ + if (!optargs && ((unsigned int) argc - 1 > w.we_wordc && !w.we_offs)) { + print_text(COLOR_HIGHLIGHT, "Too many arguments: %d > %zu", + argc - 1, w.we_wordc); + goto fail; + } + + w.we_offs = 0; + wordfree(&w); + +exec: + data.exec = entry; + + if (entry->func) + entry->func(argc, argv); + + data.exec = NULL; + + return 0; + +fail: + w.we_offs = 0; + wordfree(&w); + return -EINVAL; +} + +static int menu_exec(const struct bt_shell_menu_entry *entry, + int argc, char *argv[]) +{ + for (; entry->cmd; entry++) { + if (strcmp(argv[0], entry->cmd)) + continue; + + /* Skip menu command if not on main menu */ + if (data.menu != data.main && !strcmp(entry->cmd, "menu")) + continue; + + /* Skip back command if on main menu */ + if (data.menu == data.main && !strcmp(entry->cmd, "back")) + continue; + + return cmd_exec(entry, argc, argv); + } + + return -ENOENT; +} + +static int submenu_exec(int argc, char *argv[]) +{ + char *name; + int len, tlen; + const struct bt_shell_menu *submenu; + + if (data.menu != data.main) + return -ENOENT; + + name = strchr(argv[0], '.'); + if (!name) + return -ENOENT; + + tlen = strlen(argv[0]); + len = name - argv[0]; + name[0] = '\0'; + + submenu = find_menu(argv[0], strlen(argv[0])); + if (!submenu) + return -ENOENT; + + /* Replace submenu.command with command */ + memmove(argv[0], argv[0] + len + 1, tlen - len - 1); + memset(argv[0] + tlen - len - 1, 0, len + 1); + + return menu_exec(submenu->entries, argc, argv); +} + +static int shell_exec(int argc, char *argv[]) +{ + int err; + + if (!data.menu || !argv[0]) + return -EINVAL; + + err = menu_exec(default_menu, argc, argv); + if (err == -ENOENT) { + err = menu_exec(data.menu->entries, argc, argv); + if (err == -ENOENT) { + err = submenu_exec(argc, argv); + if (err == -ENOENT) { + print_text(COLOR_HIGHLIGHT, + "Invalid command in menu %s: %s", + data.menu->name, argv[0]); + shell_print_help(); + } + } + } + + return err; +} + +void bt_shell_printf(const char *fmt, ...) +{ + va_list args; + bool save_input; + char *saved_line; + int saved_point; + + if (!data.input) + return; + + if (data.mode) { + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + return; + } + + save_input = !RL_ISSTATE(RL_STATE_DONE); + + if (save_input) { + saved_point = rl_point; + saved_line = rl_copy_text(0, rl_end); + if (!data.saved_prompt) + rl_save_prompt(); + rl_replace_line("", 0); + rl_redisplay(); + } + + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + + if (data.monitor) { + va_start(args, fmt); + bt_log_vprintf(0xffff, data.name, LOG_INFO, fmt, args); + va_end(args); + } + + if (save_input) { + if (!data.saved_prompt) + rl_restore_prompt(); + rl_replace_line(saved_line, 0); + rl_point = saved_point; + rl_forced_update_display(); + free(saved_line); + } +} + +static void print_string(const char *str, void *user_data) +{ + bt_shell_printf("%s\n", str); +} + +void bt_shell_hexdump(const unsigned char *buf, size_t len) +{ + util_hexdump(' ', buf, len, print_string, NULL); +} + +void bt_shell_usage(void) +{ + if (!data.exec) + return; + + bt_shell_printf("Usage: %s %s\n", data.exec->cmd, + data.exec->arg ? data.exec->arg : ""); +} + +static void prompt_input(const char *str, bt_shell_prompt_input_func func, + void *user_data) +{ + data.saved_prompt = true; + data.saved_func = func; + data.saved_user_data = user_data; + + rl_save_prompt(); + bt_shell_set_prompt(str); +} + +void bt_shell_prompt_input(const char *label, const char *msg, + bt_shell_prompt_input_func func, void *user_data) +{ + char *str; + + if (!data.init || data.mode) + return; + + if (data.saved_prompt) { + struct bt_shell_prompt_input *prompt; + + prompt = l_new(struct bt_shell_prompt_input, 1); + + if (asprintf(&str, COLOR_HIGHLIGHT "[%s] %s " COLOR_OFF, label, + msg) < 0) { + free(prompt); + return; + } + + prompt->func = func; + prompt->user_data = user_data; + + l_queue_push_tail(data.prompts, prompt); + + return; + } + + if (asprintf(&str, COLOR_HIGHLIGHT "[%s] %s " COLOR_OFF, label, + msg) < 0) + return; + + prompt_input(str, func, user_data); + + free(str); +} + +static void prompt_free(void *data) +{ + struct bt_shell_prompt_input *prompt = data; + + free(prompt->str); + free(prompt); +} + +int bt_shell_release_prompt(const char *input) +{ + struct bt_shell_prompt_input *prompt; + bt_shell_prompt_input_func func; + void *user_data; + + if (!data.saved_prompt) + return -1; + + data.saved_prompt = false; + + rl_restore_prompt(); + + func = data.saved_func; + user_data = data.saved_user_data; + + prompt = l_queue_pop_head(data.prompts); + if (prompt) + data.saved_prompt = true; + + data.saved_func = NULL; + data.saved_user_data = NULL; + + func(input, user_data); + + if (prompt) { + prompt_input(prompt->str, prompt->func, prompt->user_data); + prompt_free(prompt); + } + + return 0; +} + +static void rl_handler(char *input) +{ + wordexp_t w; + + if (!input) { + rl_insert_text("quit"); + rl_redisplay(); + rl_crlf(); + l_main_quit(); + return; + } + + if (!strlen(input)) + goto done; + + if (!bt_shell_release_prompt(input)) + goto done; + + if (history_search(input, -1)) + add_history(input); + + if (data.monitor) + bt_log_printf(0xffff, data.name, LOG_INFO, "%s", input); + + if (wordexp(input, &w, WRDE_NOCMD)) + goto done; + + if (w.we_wordc == 0) { + wordfree(&w); + goto done; + } + + shell_exec(w.we_wordc, w.we_wordv); + wordfree(&w); +done: + free(input); +} + +static char *find_cmd(const char *text, + const struct bt_shell_menu_entry *entry, int *index) +{ + const struct bt_shell_menu_entry *tmp; + int len; + + len = strlen(text); + + while ((tmp = &entry[*index])) { + (*index)++; + + if (!tmp->cmd) + break; + + if (tmp->exists && !tmp->exists(data.menu)) + continue; + + if (!strncmp(tmp->cmd, text, len)) + return strdup(tmp->cmd); + } + + return NULL; +} + +static char *cmd_generator(const char *text, int state) +{ + static int index; + static bool default_menu_enabled, submenu_enabled; + static const struct bt_shell_menu *menu; + char *cmd; + + if (!state) { + index = 0; + menu = NULL; + default_menu_enabled = true; + submenu_enabled = false; + } + + if (default_menu_enabled) { + cmd = find_cmd(text, default_menu, &index); + if (cmd) + return cmd; + + index = 0; + menu = data.menu; + default_menu_enabled = false; + } + + if (!submenu_enabled) { + cmd = find_cmd(text, menu->entries, &index); + if (cmd || menu != data.main) + return cmd; + + cmd = strrchr(text, '.'); + if (!cmd) + return NULL; + + menu = find_menu(text, cmd - text); + if (!menu) + return NULL; + + index = 0; + submenu_enabled = true; + } + + cmd = find_cmd(text + strlen(menu->name) + 1, menu->entries, &index); + if (cmd) { + int err; + char *tmp; + + err = asprintf(&tmp, "%s.%s", menu->name, cmd); + + free(cmd); + + if (err < 0) + return NULL; + + cmd = tmp; + } + + return cmd; +} + +static wordexp_t args; + +static char *arg_generator(const char *text, int state) +{ + static unsigned int index, len; + const char *arg; + + if (!state) { + index = 0; + len = strlen(text); + } + + while (index < args.we_wordc) { + arg = args.we_wordv[index]; + index++; + + if (!strncmp(arg, text, len)) + return strdup(arg); + } + + return NULL; +} + +static char **args_completion(const struct bt_shell_menu_entry *entry, int argc, + const char *text) +{ + char **matches = NULL; + char *str; + int index; + + index = text[0] == '\0' ? argc - 1 : argc - 2; + if (index < 0) + return NULL; + + if (!entry->arg) + goto end; + + str = strdup(entry->arg); + + if (parse_args(str, &args, "<>[]", WRDE_NOCMD)) + goto done; + + /* Check if argument is valid */ + if ((unsigned int) index > args.we_wordc - 1) + goto done; + + /* Check if there are multiple values */ + if (!strrchr(entry->arg, '/')) + goto done; + + free(str); + + /* Split values separated by / */ + str = strdelimit(args.we_wordv[index], "/", ' '); + + args.we_offs = 0; + wordfree(&args); + + if (wordexp(str, &args, WRDE_NOCMD)) + goto done; + + rl_completion_display_matches_hook = NULL; + matches = rl_completion_matches(text, arg_generator); + +done: + free(str); +end: + if (!matches && text[0] == '\0') + bt_shell_printf("Usage: %s %s\n", entry->cmd, + entry->arg ? entry->arg : ""); + + args.we_offs = 0; + wordfree(&args); + return matches; +} + +static char **menu_completion(const struct bt_shell_menu_entry *entry, + const char *text, int argc, char *input_cmd) +{ + char **matches = NULL; + + for (; entry->cmd; entry++) { + if (strcmp(entry->cmd, input_cmd)) + continue; + + if (!entry->gen) { + matches = args_completion(entry, argc, text); + break; + } + + rl_completion_display_matches_hook = entry->disp; + matches = rl_completion_matches(text, entry->gen); + break; + } + + return matches; +} + +static char **shell_completion(const char *text, int start, int end) +{ + char **matches = NULL; + + if (!data.menu) + return NULL; + + if (start > 0) { + wordexp_t w; + + if (wordexp(rl_line_buffer, &w, WRDE_NOCMD)) + return NULL; + + matches = menu_completion(default_menu, text, w.we_wordc, + w.we_wordv[0]); + if (!matches) + matches = menu_completion(data.menu->entries, text, + w.we_wordc, + w.we_wordv[0]); + + wordfree(&w); + } else { + rl_completion_display_matches_hook = NULL; + matches = rl_completion_matches(text, cmd_generator); + } + + if (!matches) + rl_attempted_completion_over = 1; + + return matches; +} + +static void io_hup(struct l_io *io, void *user_data) +{ + l_main_quit(); +} + +static void signal_callback(unsigned int signum, void *user_data) +{ + static bool terminated; + + switch (signum) { + case SIGINT: + if (data.input && !data.mode) { + rl_replace_line("", 0); + rl_crlf(); + rl_on_new_line(); + rl_redisplay(); + return; + } + + /* + * If input was not yet setup up that means signal was received + * while daemon was not yet running. Since user is not able + * to terminate client by CTRL-D or typing exit treat this as + * exit and fall through. + */ + + /* fall through */ + case SIGTERM: + if (!terminated) { + if (!data.mode) { + rl_replace_line("", 0); + rl_crlf(); + } + l_main_quit(); + } + + terminated = true; + break; + } +} + +static void rl_init_history(void) +{ + const char *name; + char *dir; + + memset(data.history, 0, sizeof(data.history)); + + name = strrchr(data.name, '/'); + if (!name) + name = data.name; + else + name++; + + dir = getenv("XDG_CACHE_HOME"); + if (dir) { + snprintf(data.history, sizeof(data.history), "%s/.%s_history", + dir, name); + goto done; + } + + dir = getenv("HOME"); + if (dir) { + snprintf(data.history, sizeof(data.history), + "%s/.cache/.%s_history", dir, name); + goto done; + } + + dir = getenv("PWD"); + if (dir) { + snprintf(data.history, sizeof(data.history), "%s/.%s_history", + dir, name); + goto done; + } + + return; + +done: + read_history(data.history); + using_history(); + bt_shell_set_env("HISTORY", data.history); +} + +static void rl_init(void) +{ + if (data.mode) + return; + + /* Allow conditional parsing of the ~/.inputrc file. */ + rl_readline_name = data.name; + + setlinebuf(stdout); + rl_attempted_completion_function = shell_completion; + + rl_erase_empty_line = 1; + rl_callback_handler_install(NULL, rl_handler); + + rl_init_history(); +} + +static const struct option main_options[] = { + { "version", no_argument, 0, 'v' }, + { "help", no_argument, 0, 'h' }, + { "timeout", required_argument, 0, 't' }, + { "monitor", no_argument, 0, 'm' }, +}; + +static void usage(int argc, char **argv, const struct bt_shell_opt *opt) +{ + unsigned int i; + + printf("%s ver %s\n", data.name, VERSION); + printf("Usage:\n" + "\t%s [--options] [commands]\n", data.name); + + printf("Options:\n"); + + for (i = 0; opt && opt->options[i].name; i++) + printf("\t--%s \t%s\n", opt->options[i].name, opt->help[i]); + + printf("\t--monitor \tEnable monitor output\n" + "\t--timeout \tTimeout in seconds for non-interactive mode\n" + "\t--version \tDisplay version\n" + "\t--help \t\tDisplay help\n"); +} + +void bt_shell_init(int argc, char **argv, const struct bt_shell_opt *opt) +{ + int c, index = -1; + struct option options[256]; + char optstr[256]; + size_t offset; + + offset = sizeof(main_options) / sizeof(struct option); + + memcpy(options, main_options, sizeof(struct option) * offset); + + if (opt) { + memcpy(options + offset, opt->options, + sizeof(struct option) * opt->optno); + snprintf(optstr, sizeof(optstr), "+mhvt:%s", opt->optstr); + } else + snprintf(optstr, sizeof(optstr), "+mhvt:"); + + data.name = strrchr(argv[0], '/'); + if (!data.name) + data.name = strdup(argv[0]); + else + data.name = strdup(++data.name); + + while ((c = getopt_long(argc, argv, optstr, options, &index)) != -1) { + switch (c) { + case 'v': + printf("%s: %s\n", data.name, VERSION); + exit(EXIT_SUCCESS); + return; + case 'h': + usage(argc, argv, opt); + data.argc = 1; + data.argv = &cmplt; + data.mode = 1; + goto done; + case 't': + data.timeout = atoi(optarg); + break; + case 'm': + data.monitor = true; + if (bt_log_open() < 0) { + data.monitor = false; + printf("Unable to open logging channel\n"); + } + break; + default: + if (index < 0) { + for (index = 0; options[index].val; index++) { + if (c == options[index].val) + break; + } + } + + if (c != opt->options[index - offset].val) { + usage(argc, argv, opt); + exit(EXIT_SUCCESS); + return; + } + + *opt->optarg[index - offset] = optarg; + } + + index = -1; + } + + bt_shell_set_env("SHELL", data.name); + + data.argc = argc - optind; + data.argv = argv + optind; + optind = 0; + data.mode = (data.argc > 0); + +done: + if (data.mode) + bt_shell_set_env("NON_INTERACTIVE", &data.mode); + + l_main_init(); + + rl_init(); + + data.init = true; + data.prompts = l_queue_new(); +} + +static void rl_cleanup(void) +{ + if (data.mode) + return; + + if (data.history[0] != '\0') + write_history(data.history); + + rl_message(""); + rl_callback_handler_remove(); +} + +static void env_destroy(void *data) +{ + struct bt_shell_env *env = data; + + free(env->name); + free(env); +} + +int bt_shell_run(void) +{ + int status; + + status = l_main_run_with_signal(signal_callback, NULL); + + bt_shell_cleanup(); + + l_main_exit(); + + return status; +} + +void bt_shell_cleanup(void) +{ + bt_shell_release_prompt(""); + bt_shell_detach(); + + if (data.envs) { + l_queue_destroy(data.envs, env_destroy); + data.envs = NULL; + } + + if (data.monitor) + bt_log_close(); + + rl_cleanup(); + + l_queue_destroy(data.prompts, prompt_free); + data.prompts = NULL; + + data.init = false; + free(data.name); +} + +void bt_shell_quit(int status) +{ + l_main_quit(); +} + +void bt_shell_noninteractive_quit(int status) +{ + if (!data.mode || data.timeout) + return; + + bt_shell_quit(status); +} + +bool bt_shell_set_menu(const struct bt_shell_menu *menu) +{ + if (!menu) + return false; + + data.menu = menu; + + if (!data.main) + data.main = menu; + + return true; +} + +bool bt_shell_add_submenu(const struct bt_shell_menu *menu) +{ + if (!menu) + return false; + + if (!data.submenus) + data.submenus = l_queue_new(); + + l_queue_push_tail(data.submenus, (void *) menu); + + return true; +} + +void bt_shell_set_prompt(const char *string) +{ + if (!data.init || data.mode) + return; + + rl_set_prompt(string); + rl_redisplay(); +} + +static bool input_read(struct l_io *io, void *user_data) +{ + rl_callback_read_char(); + return true; +} + +static void quit_on_timeout(struct l_timeout *timeout, void *user_data) +{ + l_main_quit(); +} + +bool bt_shell_attach(int fd) +{ + struct l_io *io; + + /* TODO: Allow more than one input? */ + if (data.input) + return false; + + io = l_io_new(fd); + + if (!data.mode) + l_io_set_read_handler(io, input_read, NULL, NULL); + + l_io_set_disconnect_handler(io, io_hup, NULL, NULL); + + data.input = io; + + if (data.mode) { + if (shell_exec(data.argc, data.argv) < 0) { + bt_shell_noninteractive_quit(EXIT_FAILURE); + return true; + } + + + if (data.timeout) + l_timeout_create(data.timeout, quit_on_timeout, NULL, + NULL); + } + + return true; +} + +bool bt_shell_detach(void) +{ + if (!data.input) + return false; + + l_io_destroy(data.input); + data.input = NULL; + + return true; +} + +static bool match_env(const void *data, const void *user_data) +{ + const struct bt_shell_env *env = data; + const char *name = user_data; + + return !strcmp(env->name, name); +} + +void bt_shell_set_env(const char *name, void *value) +{ + struct bt_shell_env *env; + + if (!data.envs) { + if (!value) + return; + data.envs = l_queue_new(); + goto done; + } + + env = l_queue_remove_if(data.envs, match_env, (void *) name); + if (env) + env_destroy(env); + + /* Don't create an env if value is not set */ + if (!value) + return; + +done: + env = l_new(struct bt_shell_env, 1); + env->name = strdup(name); + env->value = value; + + l_queue_push_tail(data.envs, env); +} + +void *bt_shell_get_env(const char *name) +{ + const struct bt_shell_env *env; + + if (!data.envs) + return NULL; + + env = l_queue_find(data.envs, match_env, name); + if (!env) + return NULL; + + return env->value; +} -- 2.21.0