X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fconsole%2Fconsole.c;h=05892a718a776169146ca3d604688d5ff53fc06a;hb=730033d0e792e8edab6746fddfbee42b1a2345ba;hp=3823180cc8f82bac92a2f0d7736ecba37d4ed9c0;hpb=2643cdaa7a761d6d9ff906f26794d781c01c017d;p=bacula%2Fbacula diff --git a/bacula/src/console/console.c b/bacula/src/console/console.c index 3823180cc8..05892a718a 100644 --- a/bacula/src/console/console.c +++ b/bacula/src/console/console.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2009 Free Software Foundation Europe e.V. + + The main author of Bacula is Kern Sibbald, with contributions from + many others, a complete list can be found in the file AUTHORS. + This program is Free Software; you can redistribute it and/or + modify it under the terms of version two of the GNU General Public + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program 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 + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + + Bacula® is a registered trademark of Kern Sibbald. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * * Bacula Console interface to the Director @@ -7,60 +34,67 @@ * Version $Id$ */ -/* - Copyright (C) 2000-2003 Kern Sibbald and John Walker - - 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. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, - MA 02111-1307, USA. - - */ - #include "bacula.h" #include "console_conf.h" #include "jcr.h" - -/* Imported functions */ -int authenticate_director(JCR *jcr, DIRRES *director); - - -/* Exported variables */ -#ifdef HAVE_CYGWIN -int rl_catch_signals; +#ifdef HAVE_CONIO +#include "conio.h" +//#define CONIO_FIX 1 #else -extern int rl_catch_signals; +#define con_init(x) +#define con_term() +#define con_set_zed_keys(); +#define trapctlc() +#define clrbrk() +#define usrbrk() 0 +#endif + +#if defined(HAVE_WIN32) +#define isatty(fd) (fd==0) #endif +/* Exported variables */ + +//extern int rl_catch_signals; + +/* Imported functions */ +int authenticate_director(JCR *jcr, DIRRES *director, CONRES *cons); +extern bool parse_cons_config(CONFIG *config, const char *configfile, int exit_code); + /* Forward referenced functions */ static void terminate_console(int sig); -int get_cmd(FILE *input, char *prompt, BSOCK *sock, int sec); +static int check_resources(); +int get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec); static int do_outputcmd(FILE *input, BSOCK *UA_sock); -static void sendit(char *fmt, ...); +void senditf(const char *fmt, ...); +void sendit(const char *buf); + +extern "C" void got_sigstop(int sig); +extern "C" void got_sigcontinue(int sig); +extern "C" void got_sigtout(int sig); +extern "C" void got_sigtin(int sig); + /* Static variables */ static char *configfile = NULL; static BSOCK *UA_sock = NULL; -static DIRRES *dir; +static DIRRES *dir = NULL; +static CONRES *cons = NULL; static FILE *output = stdout; -int tee = 0; /* output to output and stdout */ -static int stop = FALSE; +static bool teeout = false; /* output to output and stdout */ +static bool stop = false; +static bool no_conio = false; +static int timeout = 0; static int argc; +static int numdir; +static int numcon; static POOLMEM *args; static char *argk[MAX_CMD_ARGS]; static char *argv[MAX_CMD_ARGS]; +static CONFIG *config; + /* Command prototypes */ static int versioncmd(FILE *input, BSOCK *UA_sock); @@ -68,49 +102,78 @@ static int inputcmd(FILE *input, BSOCK *UA_sock); static int outputcmd(FILE *input, BSOCK *UA_sock); static int teecmd(FILE *input, BSOCK *UA_sock); static int quitcmd(FILE *input, BSOCK *UA_sock); +static int helpcmd(FILE *input, BSOCK *UA_sock); +static int echocmd(FILE *input, BSOCK *UA_sock); static int timecmd(FILE *input, BSOCK *UA_sock); static int sleepcmd(FILE *input, BSOCK *UA_sock); +static int execcmd(FILE *input, BSOCK *UA_sock); +#ifdef HAVE_READLINE +static int eolcmd(FILE *input, BSOCK *UA_sock); + +# ifndef HAVE_REGEX_H +# include "lib/bregex.h" +# else +# include +# endif +#endif -#define CONFIG_FILE "./console.conf" /* default configuration file */ + +#define CONFIG_FILE "bconsole.conf" /* default configuration file */ static void usage() { - fprintf(stderr, -"\nVersion: " VERSION " (" BDATE ")\n\n" -"Usage: console [-s] [-c config_file] [-d debug_level] [config_file]\n" + fprintf(stderr, _( +PROG_COPYRIGHT +"\nVersion: " VERSION " (" BDATE ") %s %s %s\n\n" +"Usage: bconsole [-s] [-c config_file] [-d debug_level]\n" " -c set configuration file to file\n" -" -dnn set debug level to nn\n" +" -d set debug level to \n" +" -dt print timestamp in debug output\n" +" -n no conio\n" " -s no signals\n" +" -u set command execution timeout to seconds\n" " -t test - read configuration and exit\n" -" -? print this message.\n" -"\n"); - - exit(1); +" -? print this message.\n" +"\n"), 2000, HOST_OS, DISTNAME, DISTVER); } -void got_stop(int sig) +extern "C" +void got_sigstop(int sig) { - stop = TRUE; + stop = true; } -void got_continue(int sig) +extern "C" +void got_sigcontinue(int sig) { - stop = FALSE; + stop = false; } -void got_tout(int sig) +extern "C" +void got_sigtout(int sig) { // printf("Got tout\n"); } -void got_tin(int sig) -{ +extern "C" +void got_sigtin(int sig) +{ // printf("Got tin\n"); } -struct cmdstruct { char *key; int (*func)(FILE *input, BSOCK *UA_sock); char *help; }; + +static int zed_keyscmd(FILE *input, BSOCK *UA_sock) +{ + con_set_zed_keys(); + return 1; +} + +/* + * These are the @command + */ +struct cmdstruct { const char *key; int (*func)(FILE *input, BSOCK *UA_sock); const char *help; }; static struct cmdstruct commands[] = { { N_("input"), inputcmd, _("input from file")}, { N_("output"), outputcmd, _("output to file")}, @@ -119,9 +182,16 @@ static struct cmdstruct commands[] = { { N_("sleep"), sleepcmd, _("sleep specified time")}, { N_("time"), timecmd, _("print current time")}, { N_("version"), versioncmd, _("print Console's version")}, + { N_("echo"), echocmd, _("echo command string")}, + { N_("exec"), execcmd, _("execute an external command")}, { N_("exit"), quitcmd, _("exit = quit")}, - }; -#define comsize (sizeof(commands)/sizeof(struct cmdstruct)) + { N_("zed_keys"), zed_keyscmd, _("zed_keys = use zed keys instead of bash keys")}, + { N_("help"), helpcmd, _("help listing")}, +#ifdef HAVE_READLINE + { N_("separator"), eolcmd, _("set command separator")}, +#endif + }; +#define comsize ((int)(sizeof(commands)/sizeof(struct cmdstruct))) static int do_a_command(FILE *input, BSOCK *UA_sock) { @@ -144,144 +214,730 @@ static int do_a_command(FILE *input, BSOCK *UA_sock) return 1; } len = strlen(cmd); - for (i=0; imsg, _(": is an illegal command\n")); + pm_strcat(&UA_sock->msg, _(": is an invalid command\n")); UA_sock->msglen = strlen(UA_sock->msg); - fputs(UA_sock->msg, output); - fflush(output); + sendit(UA_sock->msg); } return stat; } -static void read_and_process_input(FILE *input, BSOCK *UA_sock) +static void read_and_process_input(FILE *input, BSOCK *UA_sock) { - char *prompt = "*"; - int at_prompt = FALSE; + const char *prompt = "*"; + bool at_prompt = false; int tty_input = isatty(fileno(input)); int stat; + btimer_t *tid=NULL; - for ( ;; ) { + for ( ;; ) { if (at_prompt) { /* don't prompt multiple times */ prompt = ""; } else { prompt = "*"; - at_prompt = TRUE; + at_prompt = true; } if (tty_input) { - stat = get_cmd(input, prompt, UA_sock, 30); + stat = get_cmd(input, prompt, UA_sock, 30); + if (usrbrk() == 1) { + clrbrk(); + } + if (usrbrk()) { + break; + } } else { - int len = sizeof_pool_memory(UA_sock->msg) - 1; - if (fgets(UA_sock->msg, len, input) == NULL) { - stat = -1; - } else { - strip_trailing_junk(UA_sock->msg); - UA_sock->msglen = strlen(UA_sock->msg); - stat = 1; - } + /* Reading input from a file */ + int len = sizeof_pool_memory(UA_sock->msg) - 1; + if (usrbrk()) { + break; + } + if (fgets(UA_sock->msg, len, input) == NULL) { + stat = -1; + } else { + sendit(UA_sock->msg); /* echo to terminal */ + strip_trailing_junk(UA_sock->msg); + UA_sock->msglen = strlen(UA_sock->msg); + stat = 1; + } } if (stat < 0) { - break; /* error */ - } else if (stat == 0) { /* timeout */ - bnet_fsend(UA_sock, ".messages"); + break; /* error or interrupt */ + } else if (stat == 0) { /* timeout */ + if (strcmp(prompt, "*") == 0) { + tid = start_bsock_timer(UA_sock, timeout); + bnet_fsend(UA_sock, ".messages"); + stop_bsock_timer(tid); + } else { + continue; + } } else { - at_prompt = FALSE; - /* @ => internal command for us */ + at_prompt = FALSE; + /* @ => internal command for us */ if (UA_sock->msg[0] == '@') { - parse_command_args(UA_sock->msg, args, &argc, argk, argv); - if (!do_a_command(input, UA_sock)) { - break; - } - continue; - } - if (!bnet_send(UA_sock)) { /* send command */ - break; /* error */ - } + parse_args(UA_sock->msg, &args, &argc, argk, argv, MAX_CMD_ARGS); + if (!do_a_command(input, UA_sock)) { + break; + } + continue; + } + tid = start_bsock_timer(UA_sock, timeout); + if (!bnet_send(UA_sock)) { /* send command */ + stop_bsock_timer(tid); + break; /* error */ + } + stop_bsock_timer(tid); } if (strcmp(UA_sock->msg, ".quit") == 0 || strcmp(UA_sock->msg, ".exit") == 0) { - break; + break; } + tid = start_bsock_timer(UA_sock, timeout); while ((stat = bnet_recv(UA_sock)) >= 0) { - if (at_prompt) { - if (!stop) { + if (at_prompt) { + if (!stop) { sendit("\n"); - } - at_prompt = FALSE; - } - if (!stop) { - sendit("%s", UA_sock->msg); - } + } + at_prompt = false; + } + /* Suppress output if running in background or user hit ctl-c */ + if (!stop && !usrbrk()) { + sendit(UA_sock->msg); + } + } + stop_bsock_timer(tid); + if (usrbrk() > 1) { + break; + } else { + clrbrk(); } if (!stop) { - fflush(stdout); + fflush(stdout); } if (is_bnet_stop(UA_sock)) { - break; /* error or term */ + break; /* error or term */ } else if (stat == BNET_SIGNAL) { - if (UA_sock->msglen == BNET_PROMPT) { - at_prompt = TRUE; - } + if (UA_sock->msglen == BNET_PROMPT) { + at_prompt = true; + } Dmsg1(100, "Got poll %s\n", bnet_sig_to_ascii(UA_sock)); } } } +/* + * Call-back for reading a passphrase for an encrypted PEM file + * This function uses getpass(), + * which uses a static buffer and is NOT thread-safe. + */ +static int tls_pem_callback(char *buf, int size, const void *userdata) +{ +#ifdef HAVE_TLS + const char *prompt = (const char *)userdata; +# if defined(HAVE_WIN32) + sendit(prompt); + if (win32_cgets(buf, size) == NULL) { + buf[0] = 0; + return 0; + } else { + return strlen(buf); + } +# else + char *passwd; + + passwd = getpass(prompt); + bstrncpy(buf, passwd, size); + return strlen(buf); +# endif +#else + buf[0] = 0; + return 0; +#endif +} + +#ifdef HAVE_READLINE +#define READLINE_LIBRARY 1 +#include "readline.h" +#include "history.h" + +/* Get the first keyword of the line */ +static char * +get_first_keyword() +{ + char *ret=NULL; + int len; + char *first_space = strchr(rl_line_buffer, ' '); + if (first_space) { + len = first_space - rl_line_buffer; + ret = (char *) malloc((len + 1) * sizeof(char)); + memcpy(ret, rl_line_buffer, len); + ret[len]=0; + } + return ret; +} + +/* + * Return the command before the current point. + * Set nb to the number of command to skip + */ +static char * +get_previous_keyword(int current_point, int nb) +{ + int i, end=-1, start, inquotes=0; + char *s=NULL; + + while (nb-- >= 0) { + /* first we look for a space before the current word */ + for (i = current_point; i >= 0; i--) { + if (rl_line_buffer[i] == ' ' || rl_line_buffer[i] == '=') { + break; + } + } + + /* find the end of the command */ + for (; i >= 0; i--) { + if (rl_line_buffer[i] != ' ') { + end = i; + break; + } + } + + /* no end of string */ + if (end == -1) { + return NULL; + } + + /* look for the start of the command */ + for (start = end; start > 0; start--) { + if (rl_line_buffer[start] == '"') { + inquotes = !inquotes; + } + if ((rl_line_buffer[start - 1] == ' ') && inquotes == 0) { + break; + } + current_point = start; + } + } + + s = (char *)malloc(end - start + 2); + memcpy(s, rl_line_buffer + start, end - start + 1); + s[end - start + 1] = 0; + + // printf("=======> %i:%i <%s>\n", start, end, s); + + return s; +} + +/* Simple structure that will contain the completion list */ +struct ItemList { + alist list; +}; + +static ItemList *items = NULL; +void init_items() +{ + if (!items) { + items = (ItemList*) malloc(sizeof(ItemList)); + memset(items, 0, sizeof(ItemList)); + + } else { + items->list.destroy(); + } + + items->list.init(); +} + +/* Match a regexp and add the result to the items list + * This function is recursive + */ +static void match_kw(regex_t *preg, const char *what, int len, POOLMEM **buf) +{ + int rc, size; + int nmatch=20; + regmatch_t pmatch[20]; + + if (len <= 0) { + return; + } + rc = regexec(preg, what, nmatch, pmatch, 0); + if (rc == 0) { +#if 0 + Pmsg1(0, "\n\n%s\n0123456789012345678901234567890123456789\n 10 20 30\n", what); + Pmsg2(0, "%i-%i\n", pmatch[0].rm_so, pmatch[0].rm_eo); + Pmsg2(0, "%i-%i\n", pmatch[1].rm_so, pmatch[1].rm_eo); + Pmsg2(0, "%i-%i\n", pmatch[2].rm_so, pmatch[2].rm_eo); + Pmsg2(0, "%i-%i\n", pmatch[3].rm_so, pmatch[3].rm_eo); +#endif + size = pmatch[1].rm_eo - pmatch[1].rm_so; + *buf = check_pool_memory_size(*buf, size + 1); + memcpy(*buf, what+pmatch[1].rm_so, size); + (*buf)[size] = 0; + + items->list.append(bstrdup(*buf)); + /* We search for the next keyword in the line */ + match_kw(preg, what + pmatch[1].rm_eo, len - pmatch[1].rm_eo, buf); + } +} + +/* fill the items list with the output of the help command */ +void get_arguments(const char *what) +{ + regex_t preg; + POOLMEM *buf; + int rc; + init_items(); + + rc = regcomp(&preg, "(([a-z]+=)|([a-z]+)( |$))", REG_EXTENDED); + if (rc != 0) { + return; + } + + buf = get_pool_memory(PM_MESSAGE); + UA_sock->fsend(".help item=%s", what); + while (UA_sock->recv() > 0) { + strip_trailing_junk(UA_sock->msg); + match_kw(&preg, UA_sock->msg, UA_sock->msglen, &buf); + } + free_pool_memory(buf); + regfree(&preg); +} + +/* retreive a simple list (.pool, .client) and store it into items */ +void get_items(const char *what) +{ + init_items(); + + UA_sock->fsend("%s", what); + while (UA_sock->recv() > 0) { + strip_trailing_junk(UA_sock->msg); + items->list.append(bstrdup(UA_sock->msg)); + } +} + +typedef enum +{ + ITEM_ARG, /* item with simple list like .job */ + ITEM_HELP /* use help item=xxx and detect all arguments */ +} cpl_item_t; + +/* Generator function for command completion. STATE lets us know whether + * to start from scratch; without any state (i.e. STATE == 0), then we + * start at the top of the list. + */ +static char *item_generator(const char *text, int state, + const char *item, cpl_item_t type) +{ + static int list_index, len; + char *name; + + /* If this is a new word to complete, initialize now. This includes + * saving the length of TEXT for efficiency, and initializing the index + * variable to 0. + */ + if (!state) + { + list_index = 0; + len = strlen(text); + switch(type) { + case ITEM_ARG: + get_items(item); + break; + case ITEM_HELP: + get_arguments(item); + break; + } + } + + /* Return the next name which partially matches from the command list. */ + while (items && list_index < items->list.size()) + { + name = (char *)items->list[list_index]; + list_index++; + + if (strncmp(name, text, len) == 0) { + char *ret = (char *) actuallymalloc(strlen(name)+1); + strcpy(ret, name); + return ret; + } + } + + /* If no names matched, then return NULL. */ + return ((char *)NULL); +} + +/* gobal variables for the type and the item to search + * the readline API doesn' permit to pass user data. + */ +static const char *cpl_item; +static cpl_item_t cpl_type; + +static char *cpl_generator(const char *text, int state) +{ + return item_generator(text, state, cpl_item, cpl_type); +} + +/* this function is used to not use the default filename completion */ +static char *dummy_completion_function(const char *text, int state) +{ + return NULL; +} + +struct cpl_keywords_t { + const char *key; + const char *cmd; +}; + +static struct cpl_keywords_t cpl_keywords[] = { + {"pool=", ".pool" }, + {"fileset=", ".fileset" }, + {"client=", ".client" }, + {"job=", ".job" }, + {"level=", ".level" }, + {"storage=", ".storage" }, + {"schedule=", ".schedule" }, + {"volume=", ".media" }, + {"oldvolume=", ".media" }, + {"volstatus=", ".volstatus" }, + {"actiononpurge=", ".actiononpurge" } +}; +#define key_size ((int)(sizeof(cpl_keywords)/sizeof(struct cpl_keywords_t))) + +/* Attempt to complete on the contents of TEXT. START and END bound the + * region of rl_line_buffer that contains the word to complete. TEXT is + * the word to complete. We can use the entire contents of rl_line_buffer + * in case we want to do some simple parsing. Return the array of matches, + * or NULL if there aren't any. + */ +static char **readline_completion(const char *text, int start, int end) +{ + bool found=false; + char **matches; + char *s, *cmd; + matches = (char **)NULL; + + /* If this word is at the start of the line, then it is a command + * to complete. Otherwise it is the name of a file in the current + * directory. + */ + s = get_previous_keyword(start, 0); + cmd = get_first_keyword(); + if (s) { + for (int i=0; i < key_size; i++) { + if (!strcasecmp(s, cpl_keywords[i].key)) { + cpl_item = cpl_keywords[i].cmd; + cpl_type = ITEM_ARG; + matches = rl_completion_matches(text, cpl_generator); + found=true; + break; + } + } + + if (!found) { /* we try to get help with the first command */ + cpl_item = cmd; + cpl_type = ITEM_HELP; + /* we don't want to append " " at the end */ + rl_completion_suppress_append=true; + matches = rl_completion_matches(text, cpl_generator); + } + free(s); + } else { /* nothing on the line, display all commands */ + cpl_item = ".help all"; + cpl_type = ITEM_ARG; + matches = rl_completion_matches(text, cpl_generator); + } + if (cmd) { + free(cmd); + } + return (matches); +} + +static char eol = '\0'; +static int eolcmd(FILE *input, BSOCK *UA_sock) +{ + if ((argc > 1) && (strchr("!$%&'()*+,-/:;<>?[]^`{|}~", argk[1][0]) != NULL)) { + eol = argk[1][0]; + } else if (argc == 1) { + eol = '\0'; + } else { + sendit(_("Illegal separator character.\n")); + } + return 1; +} + +int +get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec) +{ + static char *line = NULL; + static char *next = NULL; + static int do_history = 0; + char *command; + + if (line == NULL) { + do_history = 0; + rl_catch_signals = 0; /* do it ourselves */ + /* Here, readline does ***real*** malloc + * so, be we have to use the real free + */ + line = readline((char *)prompt); /* cast needed for old readlines */ + if (!line) { + exit(1); + } + strip_trailing_junk(line); + command = line; + } else if (next) { + command = next + 1; + } else { + sendit(_("Command logic problem\n")); + sock->msglen = 0; + sock->msg[0] = 0; + return 0; + } + + /* + * Split "line" into multiple commands separated by the eol character. + * Each part is pointed to by "next" until finally it becomes null. + */ + if (eol == '\0') { + next = NULL; + } else { + next = strchr(command, eol); + if (next) { + *next = '\0'; + } + } + if (command != line && isatty(fileno(input))) { + senditf("%s%s\n", prompt, command); + } + + sock->msglen = pm_strcpy(&sock->msg, command); + if (sock->msglen) { + do_history++; + } + + if (!next) { + if (do_history) { + add_history(line); + } + actuallyfree(line); /* allocated by readline() malloc */ + line = NULL; + } + return 1; +} + +#else /* no readline, do it ourselves */ + +#ifdef HAVE_CONIO +static bool bisatty(int fd) +{ + if (no_conio) { + return false; + } + return isatty(fd); +} +#endif + +/* + * Returns: 1 if data available + * 0 if timeout + * -1 if error + */ +static int +wait_for_data(int fd, int sec) +{ +#if defined(HAVE_WIN32) + return 1; +#else + fd_set fdset; + struct timeval tv; + + tv.tv_sec = sec; + tv.tv_usec = 0; + for ( ;; ) { + FD_ZERO(&fdset); + FD_SET((unsigned)fd, &fdset); + switch(select(fd + 1, &fdset, NULL, NULL, &tv)) { + case 0: /* timeout */ + return 0; + case -1: + if (errno == EINTR || errno == EAGAIN) { + continue; + } + return -1; /* error return */ + default: + return 1; + } + } +#endif +} + +/* + * Get next input command from terminal. + * + * Returns: 1 if got input + * 0 if timeout + * -1 if EOF or error + */ +int +get_cmd(FILE *input, const char *prompt, BSOCK *sock, int sec) +{ + int len; + if (!stop) { + if (output == stdout || teeout) { + sendit(prompt); + } + } +again: + switch (wait_for_data(fileno(input), sec)) { + case 0: + return 0; /* timeout */ + case -1: + return -1; /* error */ + default: + len = sizeof_pool_memory(sock->msg) - 1; + if (stop) { + sleep(1); + goto again; + } +#ifdef HAVE_CONIO + if (bisatty(fileno(input))) { + input_line(sock->msg, len); + break; + } +#endif +#ifdef HAVE_WIN32 /* use special console for input on win32 */ + if (input == stdin) { + if (win32_cgets(sock->msg, len) == NULL) { + return -1; + } + } + else +#endif + if (fgets(sock->msg, len, input) == NULL) { + return -1; + + } + break; + } + if (usrbrk()) { + clrbrk(); + } + strip_trailing_junk(sock->msg); + sock->msglen = strlen(sock->msg); + return 1; +} + +#endif /* ! HAVE_READLINE */ + + +static int console_update_history(const char *histfile) +{ + int ret=0; + +#ifdef HAVE_READLINE +/* first, try to truncate the history file, and if it + * fail, the file is probably not present, and we + * can use write_history to create it + */ + + if (history_truncate_file(histfile, 100) == 0) { + ret = append_history(history_length, histfile); + } else { + ret = write_history(histfile); + } + +#endif + + return ret; +} + +static int console_init_history(const char *histfile) +{ + int ret=0; + +#ifdef HAVE_READLINE + + using_history(); + ret = read_history(histfile); + /* Tell the completer that we want a complete . */ + rl_completion_entry_function = dummy_completion_function; + rl_attempted_completion_function = readline_completion; + rl_filename_completion_desired = 0; +#endif + + return ret; +} /********************************************************************* * - * Main Bacula Console -- User Interface Program + * Main Bacula Console -- User Interface Program * */ int main(int argc, char *argv[]) { - int ch, i, ndir, item; - int no_signals = FALSE; - int test_config = FALSE; + int ch, i, item; + bool no_signals = false; + bool test_config = false; JCR jcr; + utime_t heart_beat; + + setlocale(LC_ALL, ""); + bindtextdomain("bacula", LOCALEDIR); + textdomain("bacula"); init_stack_dump(); - my_name_is(argc, argv, "console"); - textdomain("bacula-console"); + lmgr_init_thread(); + my_name_is(argc, argv, "bconsole"); init_msg(NULL, NULL); working_directory = "/tmp"; args = get_pool_memory(PM_FNAME); - while ((ch = getopt(argc, argv, "bc:d:r:st?")) != -1) { + while ((ch = getopt(argc, argv, "bc:d:nstu:?")) != -1) { switch (ch) { - case 'c': /* configuration file */ - if (configfile != NULL) { - free(configfile); - } - configfile = bstrdup(optarg); - break; - - case 'd': - debug_level = atoi(optarg); - if (debug_level <= 0) { - debug_level = 1; - } - break; - - case 's': /* turn off signals */ - no_signals = TRUE; - break; - - case 't': - test_config = TRUE; - break; - - case '?': - default: - usage(); - - } + case 'c': /* configuration file */ + if (configfile != NULL) { + free(configfile); + } + configfile = bstrdup(optarg); + break; + + case 'd': + if (*optarg == 't') { + dbg_timestamp = true; + } else { + debug_level = atoi(optarg); + if (debug_level <= 0) { + debug_level = 1; + } + } + break; + + case 'n': /* no conio */ + no_conio = true; + break; + + case 's': /* turn off signals */ + no_signals = true; + break; + + case 't': + test_config = true; + break; + + case 'u': + timeout = atoi(optarg); + break; + + case '?': + default: + usage(); + exit(1); + } } argc -= optind; argv += optind; @@ -289,31 +945,42 @@ int main(int argc, char *argv[]) if (!no_signals) { init_signals(terminate_console); } - signal(SIGCHLD, SIG_IGN); - signal(SIGTSTP, got_stop); - signal(SIGCONT, got_continue); - signal(SIGTTIN, got_tin); - signal(SIGTTOU, got_tout); + + +#if !defined(HAVE_WIN32) + /* Override Bacula default signals */ + signal(SIGQUIT, SIG_IGN); + signal(SIGTSTP, got_sigstop); + signal(SIGCONT, got_sigcontinue); + signal(SIGTTIN, got_sigtin); + signal(SIGTTOU, got_sigtout); + trapctlc(); +#endif + + OSDependentInit(); if (argc) { usage(); + exit(1); } if (configfile == NULL) { configfile = bstrdup(CONFIG_FILE); } - parse_config(configfile); + config = new_config_parser(); + parse_cons_config(config, configfile, M_ERROR_TERM); - LockRes(); - ndir = 0; - for (dir=NULL; (dir = (DIRRES *)GetNextRes(R_DIRECTOR, (RES *)dir)); ) { - ndir++; + if (init_crypto() != 0) { + Emsg0(M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n")); } - UnlockRes(); - if (ndir == 0) { - Emsg1(M_ERROR_TERM, 0, "No Director resource defined in %s\n\ -Without that I don't how to speak to the Director :-(\n", configfile); + + if (!check_resources()) { + Emsg1(M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile); + } + + if (!no_conio) { + con_init(stdin); } if (test_config) { @@ -323,185 +990,291 @@ Without that I don't how to speak to the Director :-(\n", configfile); memset(&jcr, 0, sizeof(jcr)); - if (ndir > 1) { - UA_sock = init_bsock(NULL, 0, "", "", 0); + (void)WSA_Init(); /* Initialize Windows sockets */ + + start_watchdog(); /* Start socket watchdog */ + + LockRes(); + numdir = 0; + foreach_res(dir, R_DIRECTOR) { + numdir++; + } + numcon = 0; + foreach_res(cons, R_CONSOLE) { + numcon++; + } + UnlockRes(); + + if (numdir > 1) { + struct sockaddr client_addr; + memset(&client_addr, 0, sizeof(client_addr)); + UA_sock = init_bsock(NULL, 0, "", "", 0, &client_addr); try_again: - sendit("Available Directors:\n"); + sendit(_("Available Directors:\n")); LockRes(); - ndir = 0; - for (dir = NULL; (dir = (DIRRES *)GetNextRes(R_DIRECTOR, (RES *)dir)); ) { - fprintf(output, "%d %s at %s:%d\n", 1+ndir++, dir->hdr.name, dir->address, - dir->DIRport); + numdir = 0; + foreach_res(dir, R_DIRECTOR) { + senditf( _("%2d: %s at %s:%d\n"), 1+numdir++, dir->hdr.name, dir->address, + dir->DIRport); } UnlockRes(); - if (get_cmd(stdin, "Select Director: ", UA_sock, 600) < 0) { - return 1; + if (get_cmd(stdin, _("Select Director by entering a number: "), UA_sock, 600) < 0) { + (void)WSACleanup(); /* Cleanup Windows sockets */ + return 1; + } + if (!is_a_number(UA_sock->msg)) { + senditf(_("%s is not a number. You must enter a number between 1 and %d\n"), + UA_sock->msg, numdir); + goto try_again; } item = atoi(UA_sock->msg); - if (item < 0 || item > ndir) { - sendit("You must enter a number between 1 and %d\n", ndir); - goto try_again; + if (item < 0 || item > numdir) { + senditf(_("You must enter a number between 1 and %d\n"), numdir); + goto try_again; } + term_bsock(UA_sock); LockRes(); - dir = NULL; for (i=0; idirector && strcmp(cons->director, dir->hdr.name) == 0) { + break; + } + cons = NULL; + } + /* Look for the first non-linked console */ + if (cons == NULL) { + for (i=0; idirector == NULL) + break; + cons = NULL; + } } UnlockRes(); - term_bsock(UA_sock); - } else { + } + /* If no director, take first one */ + if (!dir) { LockRes(); dir = (DIRRES *)GetNextRes(R_DIRECTOR, NULL); UnlockRes(); } - + /* If no console, take first one */ + if (!cons) { + LockRes(); + cons = (CONRES *)GetNextRes(R_CONSOLE, (RES *)NULL); + UnlockRes(); + } + + senditf(_("Connecting to Director %s:%d\n"), dir->address,dir->DIRport); + + char buf[1024]; + /* Initialize Console TLS context */ + if (cons && (cons->tls_enable || cons->tls_require)) { + /* Generate passphrase prompt */ + bsnprintf(buf, sizeof(buf), "Passphrase for Console \"%s\" TLS private key: ", cons->hdr.name); + + /* Initialize TLS context: + * Args: CA certfile, CA certdir, Certfile, Keyfile, + * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer + */ + cons->tls_ctx = new_tls_context(cons->tls_ca_certfile, + cons->tls_ca_certdir, cons->tls_certfile, + cons->tls_keyfile, tls_pem_callback, &buf, NULL, true); + + if (!cons->tls_ctx) { + senditf(_("Failed to initialize TLS context for Console \"%s\".\n"), + dir->hdr.name); + terminate_console(0); + return 1; + } + } + + /* Initialize Director TLS context */ + if (dir->tls_enable || dir->tls_require) { + /* Generate passphrase prompt */ + bsnprintf(buf, sizeof(buf), "Passphrase for Director \"%s\" TLS private key: ", dir->hdr.name); + + /* Initialize TLS context: + * Args: CA certfile, CA certdir, Certfile, Keyfile, + * Keyfile PEM Callback, Keyfile CB Userdata, DHfile, Verify Peer */ + dir->tls_ctx = new_tls_context(dir->tls_ca_certfile, + dir->tls_ca_certdir, dir->tls_certfile, + dir->tls_keyfile, tls_pem_callback, &buf, NULL, true); + + if (!dir->tls_ctx) { + senditf(_("Failed to initialize TLS context for Director \"%s\".\n"), + dir->hdr.name); + terminate_console(0); + return 1; + } + } - sendit("Connecting to Director %s:%d\n", dir->address,dir->DIRport); - UA_sock = bnet_connect(NULL, 5, 15, "Director daemon", dir->address, - NULL, dir->DIRport, 0); + if (dir->heartbeat_interval) { + heart_beat = dir->heartbeat_interval; + } else if (cons) { + heart_beat = cons->heartbeat_interval; + } else { + heart_beat = 0; + } + UA_sock = bnet_connect(NULL, 5, 15, heart_beat, "Director daemon", dir->address, + NULL, dir->DIRport, 0); if (UA_sock == NULL) { terminate_console(0); return 1; } jcr.dir_bsock = UA_sock; - if (!authenticate_director(&jcr, dir)) { - fprintf(stderr, "ERR=%s", UA_sock->msg); + + /* If cons==NULL, default console will be used */ + if (!authenticate_director(&jcr, dir, cons)) { terminate_console(0); return 1; } Dmsg0(40, "Opened connection with Director daemon\n"); + sendit(_("Enter a period to cancel a command.\n")); + + /* Read/Update history file if HOME exists */ + POOL_MEM history_file; + + /* Run commands in ~/.bconsolerc if any */ + char *env = getenv("HOME"); + if (env) { + FILE *fd; + pm_strcpy(&UA_sock->msg, env); + pm_strcat(&UA_sock->msg, "/.bconsolerc"); + fd = fopen(UA_sock->msg, "rb"); + if (fd) { + read_and_process_input(fd, UA_sock); + fclose(fd); + } + + pm_strcpy(history_file, env); + pm_strcat(history_file, "/.bconsole_history"); + console_init_history(history_file.c_str()); + } + read_and_process_input(stdin, UA_sock); if (UA_sock) { - bnet_sig(UA_sock, BNET_TERMINATE); /* send EOF */ - bnet_close(UA_sock); + UA_sock->signal(BNET_TERMINATE); /* send EOF */ + UA_sock->close(); + } + + if (env) { + console_update_history(history_file.c_str()); } terminate_console(0); return 0; } - /* Cleanup and then exit */ static void terminate_console(int sig) { - static int already_here = FALSE; - if (already_here) { /* avoid recursive temination problems */ + static bool already_here = false; + + if (already_here) { /* avoid recursive temination problems */ exit(1); } - already_here = TRUE; + already_here = true; + stop_watchdog(); + config->free_resources(); + free(config); + config = NULL; + cleanup_crypto(); free_pool_memory(args); - if (sig != 0) { - exit(1); + if (!no_conio) { + con_term(); } - return; -} - -#ifdef HAVE_READLINE -#undef free -#include "readline/readline.h" -#include "readline/history.h" - + (void)WSACleanup(); /* Cleanup Windows sockets */ + lmgr_cleanup_main(); -int -get_cmd(FILE *input, char *prompt, BSOCK *sock, int sec) -{ - char *line; - - rl_catch_signals = 0; /* do it ourselves */ - line = readline(prompt); - - if (!line) { + if (sig != 0) { exit(1); } - strcpy(sock->msg, line); - strip_trailing_junk(sock->msg); - sock->msglen = strlen(sock->msg); - if (sock->msglen) { - add_history(sock->msg); - } - free(line); - return 1; + return; } -#else /* no readline, do it ourselves */ - /* - * Returns: 1 if data available - * 0 if timeout - * -1 if error + * Make a quick check to see that we have all the + * resources needed. */ -static int -wait_for_data(int fd, int sec) +static int check_resources() { - fd_set fdset; - struct timeval tv; + bool OK = true; + DIRRES *director; + bool tls_needed; - FD_ZERO(&fdset); - FD_SET(fd, &fdset); - tv.tv_sec = sec; - tv.tv_usec = 0; - for ( ;; ) { - switch(select(fd + 1, &fdset, NULL, NULL, &tv)) { - case 0: /* timeout */ - return 0; - case -1: - if (errno == EINTR || errno == EAGAIN) { - continue; - } - return -1; /* error return */ - default: - return 1; + LockRes(); + + numdir = 0; + foreach_res(director, R_DIRECTOR) { + + numdir++; + /* tls_require implies tls_enable */ + if (director->tls_require) { + if (have_tls) { + director->tls_enable = true; + } else { + Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n")); + OK = false; + continue; + } + } + tls_needed = director->tls_enable || director->tls_authenticate; + + if ((!director->tls_ca_certfile && !director->tls_ca_certdir) && tls_needed) { + Emsg2(M_FATAL, 0, _("Neither \"TLS CA Certificate\"" + " or \"TLS CA Certificate Dir\" are defined for Director \"%s\" in %s." + " At least one CA certificate store is required.\n"), + director->hdr.name, configfile); + OK = false; } } -} + + if (numdir == 0) { + Emsg1(M_FATAL, 0, _("No Director resource defined in %s\n" + "Without that I don't how to speak to the Director :-(\n"), configfile); + OK = false; + } -/* - * Get next input command from terminal. - * - * Returns: 1 if got input - * 0 if timeout - * -1 if EOF or error - */ -int -get_cmd(FILE *input, char *prompt, BSOCK *sock, int sec) -{ - int len; - if (!stop) { - if (output == stdout || tee) { - fputs(prompt, stdout); - fflush(stdout); + CONRES *cons; + /* Loop over Consoles */ + foreach_res(cons, R_CONSOLE) { + /* tls_require implies tls_enable */ + if (cons->tls_require) { + if (have_tls) { + cons->tls_enable = true; + } else { + Jmsg(NULL, M_FATAL, 0, _("TLS required but not configured in Bacula.\n")); + OK = false; + continue; + } + } + tls_needed = cons->tls_enable || cons->tls_authenticate; + if ((!cons->tls_ca_certfile && !cons->tls_ca_certdir) && tls_needed) { + Emsg2(M_FATAL, 0, _("Neither \"TLS CA Certificate\"" + " or \"TLS CA Certificate Dir\" are defined for Console \"%s\" in %s.\n"), + cons->hdr.name, configfile); + OK = false; } } -again: - switch (wait_for_data(fileno(input), sec)) { - case 0: - return 0; /* timeout */ - case -1: - return -1; /* error */ - default: - len = sizeof_pool_memory(sock->msg) - 1; - if (stop) { - goto again; - } - if (fgets(sock->msg, len, input) == NULL) { - return -1; - } - break; - } - strip_trailing_junk(sock->msg); - sock->msglen = strlen(sock->msg); - return 1; -} -#endif + UnlockRes(); + + return OK; +} static int versioncmd(FILE *input, BSOCK *UA_sock) { - sendit("Version: " VERSION " (" BDATE ")\n"); + senditf("Version: " VERSION " (" BDATE ") %s %s %s\n", + HOST_OS, DISTNAME, DISTVER); return 1; } @@ -510,32 +1283,36 @@ static int inputcmd(FILE *input, BSOCK *UA_sock) FILE *fd; if (argc > 2) { - sendit("Too many arguments.\n"); - return 0; + sendit(_("Too many arguments on input command.\n")); + return 1; } if (argc == 1) { - sendit("First argument must be a filename.\n"); - return 0; + sendit(_("First argument to input command must be a filename.\n")); + return 1; } - fd = fopen(argk[1], "r"); + fd = fopen(argk[1], "rb"); if (!fd) { - sendit("Cannot open file. ERR=%s\n", strerror(errno)); - return 0; + berrno be; + senditf(_("Cannot open file %s for input. ERR=%s\n"), + argk[1], be.bstrerror()); + return 1; } read_and_process_input(fd, UA_sock); fclose(fd); return 1; } +/* Send output to both termina and specified file */ static int teecmd(FILE *input, BSOCK *UA_sock) { - tee = 1; + teeout = true; return do_outputcmd(input, UA_sock); } +/* Send output to specified "file" */ static int outputcmd(FILE *input, BSOCK *UA_sock) { - tee = 0; + teeout = false; return do_outputcmd(input, UA_sock); } @@ -543,17 +1320,17 @@ static int outputcmd(FILE *input, BSOCK *UA_sock) static int do_outputcmd(FILE *input, BSOCK *UA_sock) { FILE *fd; - char *mode = "a+"; + const char *mode = "a+b"; if (argc > 3) { - sendit("Too many arguments.\n"); + sendit(_("Too many arguments on output/tee command.\n")); return 1; } if (argc == 1) { if (output != stdout) { - fclose(output); - output = stdout; - tee = 0; + fclose(output); + output = stdout; + teeout = false; } return 1; } @@ -562,18 +1339,77 @@ static int do_outputcmd(FILE *input, BSOCK *UA_sock) } fd = fopen(argk[1], mode); if (!fd) { - sendit("Cannot open file. ERR=%s\n", strerror(errno)); - return 1; + berrno be; + senditf(_("Cannot open file %s for output. ERR=%s\n"), + argk[1], be.bstrerror(errno)); + return 1; } output = fd; return 1; } +/* + * exec "some-command" [wait-seconds] +*/ +static int execcmd(FILE *input, BSOCK *UA_sock) +{ + BPIPE *bpipe; + char line[5000]; + int stat; + int wait = 0; + + if (argc > 3) { + sendit(_("Too many arguments. Enclose command in double quotes.\n")); + return 1; + } + if (argc == 3) { + wait = atoi(argk[2]); + } + bpipe = open_bpipe(argk[1], wait, "r"); + if (!bpipe) { + berrno be; + senditf(_("Cannot popen(\"%s\", \"r\"): ERR=%s\n"), + argk[1], be.bstrerror(errno)); + return 1; + } + + while (fgets(line, sizeof(line), bpipe->rfd)) { + senditf("%s", line); + } + stat = close_bpipe(bpipe); + if (stat != 0) { + berrno be; + be.set_errno(stat); + senditf(_("Autochanger error: ERR=%s\n"), be.bstrerror()); + } + return 1; +} + + +static int echocmd(FILE *input, BSOCK *UA_sock) +{ + for (int i=1; i < argc; i++) { + senditf("%s ", argk[i]); + } + sendit("\n"); + return 1; +} + static int quitcmd(FILE *input, BSOCK *UA_sock) { return 0; } +static int helpcmd(FILE *input, BSOCK *UA_sock) +{ + int i; + for (i=0; i 1) { @@ -588,24 +1424,61 @@ static int timecmd(FILE *input, BSOCK *UA_sock) char sdt[50]; time_t ttime = time(NULL); struct tm tm; - localtime_r(&ttime, &tm); + (void)localtime_r(&ttime, &tm); strftime(sdt, sizeof(sdt), "%d-%b-%Y %H:%M:%S", &tm); - sendit(sdt); sendit("\n"); return 1; } -static void sendit(char *fmt,...) +/* + * Send a line to the output file and or the terminal + */ +void senditf(const char *fmt,...) { - char buf[3000]; - va_list arg_ptr; + char buf[3000]; + va_list arg_ptr; - va_start(arg_ptr, fmt); - bvsnprintf(buf, sizeof(buf), (char *)fmt, arg_ptr); - va_end(arg_ptr); - fputs(buf, output); - if (tee) { - fputs(buf, stdout); - } - fflush(stdout); + va_start(arg_ptr, fmt); + bvsnprintf(buf, sizeof(buf), (char *)fmt, arg_ptr); + va_end(arg_ptr); + sendit(buf); +} + +void sendit(const char *buf) +{ +#ifdef CONIO_FIX + char obuf[3000]; + if (output == stdout || teeout) { + const char *p, *q; + /* + * Here, we convert every \n into \r\n because the + * terminal is in raw mode when we are using + * conio. + */ + for (p=q=buf; (p=strchr(q, '\n')); ) { + int len = p - q; + if (len > 0) { + memcpy(obuf, q, len); + } + memcpy(obuf+len, "\r\n", 3); + q = ++p; /* point after \n */ + fputs(obuf, output); + } + if (*q) { + fputs(q, output); + } + fflush(output); + } + if (output != stdout) { + fputs(buf, output); + } +#else + + fputs(buf, output); + fflush(output); + if (teeout) { + fputs(buf, stdout); + fflush(stdout); + } +#endif }