X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=client.c;h=f72719f27df46b012165a9e8c8bde3586d602a95;hp=ec32cd414e31df10dd5c7dbecbdef60c5134a5a2;hb=71386e2530fa351d22f942ce3cf9d18eee99ce78;hpb=d5738d17b54186db8c9c7f119a03b58382ae9be4 diff --git a/client.c b/client.c index ec32cd41..f72719f2 100644 --- a/client.c +++ b/client.c @@ -1,60 +1,604 @@ -/* - * Copyright (C) 1997-2011 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 1997 Andre Noll , see file COPYING. */ -/** \file client.c the client program used to connect to para_server */ +/** \file client.c The client program used to connect to para_server. */ #include -#include -#include +#include +#include +#include "client.lsg.h" #include "para.h" #include "list.h" #include "sched.h" #include "crypt.h" -#include "client.cmdline.h" #include "string.h" #include "stdin.h" #include "stdout.h" #include "client.h" #include "buffer_tree.h" #include "error.h" +#include "version.h" -INIT_CLIENT_ERRLISTS; +/** Array of error strings. */ +DEFINE_PARA_ERRLIST; +static struct sched sched; static struct client_task *ct; static struct stdin_task sit; static struct stdout_task sot; -static void supervisor_post_select(__a_unused struct sched *s, struct task *t) +static int client_loglevel = LL_ERROR; +DEFINE_STDERR_LOGGER(stderr_log, client_loglevel); +__printf_2_3 void (*para_log)(int, const char*, ...) = stderr_log; + +#ifdef HAVE_READLINE +#include "interactive.h" +#include "server_cmd.lsg.h" + +struct exec_task { + struct task *task; + struct btr_node *btrn; + char *result_buf; + size_t result_size; +}; + +static void exec_pre_select(struct sched *s, void *context) +{ + struct exec_task *et = context; + int ret = btr_node_status(et->btrn, 0, BTR_NT_LEAF); + + if (ret != 0) + sched_min_delay(s); +} + +static int exec_post_select(__a_unused struct sched *s, void *context) +{ + struct exec_task *et = context; + struct btr_node *btrn = et->btrn; + char *buf; + size_t sz; + int ret; + + ret = btr_node_status(btrn, 0, BTR_NT_LEAF); + if (ret <= 0) + return ret; + sz = btr_next_buffer(btrn, &buf); + if (sz <= 1) + goto out; + et->result_buf = para_realloc(et->result_buf, et->result_size + sz - 1); + memcpy(et->result_buf + et->result_size - 1, buf, sz - 1); + et->result_size += sz - 1; + et->result_buf[et->result_size - 1] = '\0'; +out: + btr_consume(btrn, sz); + return 0; +} + +/* Called from the line handler and the completers. This overwrites ct->lpr. */ +static int create_merged_lpr(const char *line) +{ + const struct lls_command *cmd = CLIENT_CMD_PTR; + int argc, ret; + char *cmdline, **argv, *errctx; + struct lls_parse_result *argv_lpr; + static struct lls_parse_result *orig_lpr; + + if (!orig_lpr) + orig_lpr = ct->lpr; + ct->lpr = NULL; + cmdline = make_message("-- %s", line); + ret = create_shifted_argv(cmdline, " ", &argv); + free(cmdline); + if (ret < 0) + return ret; + argc = ret; + if (argc == 2) { /* no words (only blanks in line) */ + free_argv(argv); + return 0; + } + argv[0] = para_strdup("--"); + /* + * The original lpr for the interactive session has no non-option + * arguments. We create a fresh lpr from the words in "line" and merge + * it with the orignal lpr. + */ + ret = lls(lls_parse(argc, argv, cmd, &argv_lpr, &errctx)); + free_argv(argv); + if (ret < 0) + goto fail; + ret = lls(lls_merge(orig_lpr, argv_lpr, cmd, &ct->lpr, &errctx)); + lls_free_parse_result(argv_lpr, cmd); + if (ret < 0) + goto fail; + return 1; +fail: + if (errctx) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + free(errctx); + assert(ret < 0); + return ret; +} + +/* called from completers */ +static int execute_client_command(const char *cmd, char **result) +{ + int ret; + struct sched command_sched = {.default_timeout = {.tv_sec = 1}}; + struct exec_task exec_task = { + .result_buf = para_strdup(""), + .result_size = 1, + }; + struct lls_parse_result *old_lpr = ct->lpr; + + *result = NULL; + ret = create_merged_lpr(cmd); + if (ret <= 0) + goto out; + exec_task.btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = "exec_collect")); + exec_task.task = task_register(&(struct task_info) { + .name = "client exec", + .pre_select = exec_pre_select, + .post_select = exec_post_select, + .context = &exec_task, + }, &command_sched); + ret = client_connect(ct, &command_sched, NULL, exec_task.btrn); + if (ret < 0) + goto out; + schedule(&command_sched); + sched_shutdown(&command_sched); + lls_free_parse_result(ct->lpr, CLIENT_CMD_PTR); + ct->lpr = old_lpr; + *result = exec_task.result_buf; + btr_remove_node(&exec_task.btrn); + ret = 1; +out: + btr_remove_node(&exec_task.btrn); + if (ret < 0) + free(exec_task.result_buf); + return ret; +} + +static int extract_matches_from_command(const char *word, char *cmd, + char ***matches) +{ + char *buf, **sl; + int ret; + + ret = execute_client_command(cmd, &buf); + if (ret < 0) + return ret; + ret = create_argv(buf, "\n", &sl); + free(buf); + if (ret < 0) + return ret; + ret = i9e_extract_completions(word, sl, matches); + free_argv(sl); + return ret; +} + +static int complete_attributes(const char *word, char ***matches) +{ + return extract_matches_from_command(word, "lsatt", matches); +} + +static void complete_addblob(__a_unused const char *blob_type, + __a_unused struct i9e_completion_info *ci, + __a_unused struct i9e_completion_result *cr) { - if (ct->task.error < 0) { - t->error = ct->task.error; + cr->filename_completion_desired = true; +} + +static void generic_blob_complete(const char *blob_type, + struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char cmd[20]; + sprintf(cmd, "ls%s", blob_type); + extract_matches_from_command(ci->word, cmd, &cr->matches); +} + +static void complete_catblob(const char *blob_type, + struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + generic_blob_complete(blob_type, ci, cr); +} + +static void complete_lsblob(const char *blob_type, + struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_LSIMG_OPTS, NULL}; + + if (ci->word[0] == '-') + return i9e_complete_option(opts, ci, cr); + generic_blob_complete(blob_type, ci, cr); +} + +static void complete_rmblob(const char *blob_type, + struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + generic_blob_complete(blob_type, ci, cr); +} + +static void complete_mvblob(const char *blob_type, + struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + generic_blob_complete(blob_type, ci, cr); +} + +/* these don't need any completions */ +I9E_DUMMY_COMPLETER(ff); +I9E_DUMMY_COMPLETER(hup); +I9E_DUMMY_COMPLETER(jmp); +I9E_DUMMY_COMPLETER(next); +I9E_DUMMY_COMPLETER(nomore); +I9E_DUMMY_COMPLETER(pause); +I9E_DUMMY_COMPLETER(play); +I9E_DUMMY_COMPLETER(si); +I9E_DUMMY_COMPLETER(term); +I9E_DUMMY_COMPLETER(stop); +I9E_DUMMY_COMPLETER(addatt); +I9E_DUMMY_COMPLETER(init); +I9E_DUMMY_COMPLETER(tasks); + +static struct i9e_completer completers[]; + +static void help_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_HELP_OPTS, NULL}; + + if (ci->word[0] == '-') { + i9e_complete_option(opts, ci, cr); return; } - if (ct->status == CL_SENDING) { - stdin_set_defaults(&sit); - register_task(&sit.task); - t->error = -E_TASK_STARTED; + cr->matches = i9e_complete_commands(ci->word, completers); +} + +static void stat_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_STAT_OPTS, NULL}; + i9e_complete_option(opts, ci, cr); +} + +static void version_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_VERSION_OPTS, NULL}; + i9e_complete_option(opts, ci, cr); +} + +static void sender_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *senders[] = {"http", "dccp", "udp", NULL}; + char *http_cmds[] = {"on", "off", "allow", "deny", "help", NULL}; + char *dccp_cmds[] = {"on", "off", "allow", "deny", "help", NULL}; + char *udp_cmds[] ={"on", "off", "add", "delete", "help", NULL}; + char *sender; + char **cmds; + + //PARA_CRIT_LOG("wn: %d\n", ci->word_num); + if (ci->word_num == 0 || ci->word_num > 3) + return; + if (ci->word_num == 1 || (ci->word_num == 2 && *ci->word != '\0')) { + i9e_extract_completions(ci->word, senders, &cr->matches); return; } - if (ct->status == CL_RECEIVING) { - stdout_set_defaults(&sot); - register_task(&sot.task); - t->error = -E_TASK_STARTED; + sender = ci->argv[1]; + //PARA_CRIT_LOG("sender: %s\n", sender); + if (strcmp(sender, "http") == 0) + cmds = http_cmds; + else if (strcmp(sender, "dccp") == 0) + cmds = dccp_cmds; + else if (strcmp(sender, "udp") == 0) + cmds = udp_cmds; + else + return; + i9e_extract_completions(ci->word, cmds, &cr->matches); +} + +static void add_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_ADD_OPTS, NULL}; + + if (ci->word[0] == '-') + i9e_complete_option(opts, ci, cr); + cr->filename_completion_desired = true; +} + +static void ls_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_LS_OPTS, NULL}; + if (ci->word[0] == '-') + i9e_complete_option(opts, ci, cr); + cr->filename_completion_desired = true; +} + +static void setatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *buf, **sl; + int i, ret, num_atts; + + if (ci->word_num == 0) + return; + + if (*ci->word == '/' || *ci->word == '\0') + cr->filename_completion_desired = true; + if (*ci->word == '/') + return; + ret = execute_client_command("lsatt", &buf); + if (ret < 0) + return; + ret = create_argv(buf, "\n", &sl); + if (ret < 0) + goto out; + num_atts = ret; + sl = para_realloc(sl, (2 * num_atts + 1) * sizeof(char *)); + for (i = 0; i < num_atts; i++) { + char *orig = sl[i]; + sl[i] = make_message("%s+", orig); + sl[num_atts + i] = make_message("%s-", orig); + free(orig); + } + sl[2 * num_atts] = NULL; + i9e_extract_completions(ci->word, sl, &cr->matches); +out: + free(buf); + free_argv(sl); +} + +static void lsatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_LSATT_OPTS, NULL}; + i9e_complete_option(opts, ci, cr); +} + +static void mvatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + complete_attributes(ci->word, &cr->matches); +} + +static void rmatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + complete_attributes(ci->word, &cr->matches); +} + +static void check_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_CHECK_OPTS, NULL}; + i9e_complete_option(opts, ci, cr); +} + +static void rm_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_RM_OPTS, NULL}; + + if (ci->word[0] == '-') { + i9e_complete_option(opts, ci, cr); return; } + cr->filename_completion_desired = true; } -static struct task svt = { - .post_select = supervisor_post_select, - .status = "supervisor task" +static void touch_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_TOUCH_OPTS, NULL}; + + if (ci->word[0] == '-') + i9e_complete_option(opts, ci, cr); + cr->filename_completion_desired = true; +} + +static void cpsi_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *opts[] = {LSG_SERVER_CMD_CPSI_OPTS, NULL}; + + if (ci->word[0] == '-') + i9e_complete_option(opts, ci, cr); + cr->filename_completion_desired = true; +} + +static void select_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) +{ + char *mood_buf, *pl_buf, **moods, **playlists, **mops; + int num_moods, num_pl, i, n, ret; + + ret = execute_client_command("lsmood", &mood_buf); + if (ret < 0) + return; + ret = execute_client_command("lspl", &pl_buf); + if (ret < 0) + goto free_mood_buf; + + ret = create_argv(mood_buf, "\n", &moods); + if (ret < 0) + goto free_pl_buf; + num_moods = ret; + ret = create_argv(pl_buf, "\n", &playlists); + if (ret < 0) + goto free_moods; + num_pl = ret; + n = num_moods + num_pl; + mops = para_malloc((n + 1) * sizeof(char *)); + for (i = 0; i < num_moods; i++) + mops[i] = make_message("m/%s", moods[i]); + for (i = 0; i < num_pl; i++) + mops[num_moods + i] = make_message("p/%s", playlists[i]); + mops[n] = NULL; + i9e_extract_completions(ci->word, mops, &cr->matches); + free_argv(mops); + free_argv(playlists); +free_moods: + free_argv(moods); +free_pl_buf: + free(pl_buf); +free_mood_buf: + free(mood_buf); +} + +#define DEFINE_BLOB_COMPLETER(cmd, blob_type) \ + static void cmd ## blob_type ## _completer( \ + struct i9e_completion_info *ci, \ + struct i9e_completion_result *cr) \ + {complete_ ## cmd ## blob(#blob_type, ci, cr);} + +DEFINE_BLOB_COMPLETER(add, mood) +DEFINE_BLOB_COMPLETER(add, lyr) +DEFINE_BLOB_COMPLETER(add, img) +DEFINE_BLOB_COMPLETER(add, pl) +DEFINE_BLOB_COMPLETER(cat, mood) +DEFINE_BLOB_COMPLETER(cat, lyr) +DEFINE_BLOB_COMPLETER(cat, img) +DEFINE_BLOB_COMPLETER(cat, pl) +DEFINE_BLOB_COMPLETER(ls, mood) +DEFINE_BLOB_COMPLETER(ls, lyr) +DEFINE_BLOB_COMPLETER(ls, img) +DEFINE_BLOB_COMPLETER(ls, pl) +DEFINE_BLOB_COMPLETER(rm, mood) +DEFINE_BLOB_COMPLETER(rm, lyr) +DEFINE_BLOB_COMPLETER(rm, img) +DEFINE_BLOB_COMPLETER(rm, pl) +DEFINE_BLOB_COMPLETER(mv, mood) +DEFINE_BLOB_COMPLETER(mv, lyr) +DEFINE_BLOB_COMPLETER(mv, img) +DEFINE_BLOB_COMPLETER(mv, pl) + +static int client_i9e_line_handler(char *line) +{ + int ret; + static bool first = true; + + if (first) + first = false; + else + lls_free_parse_result(ct->lpr, CLIENT_CMD_PTR); + ret = create_merged_lpr(line); + if (ret <= 0) + return ret; + ret = client_connect(ct, &sched, NULL, NULL); + if (ret < 0) + return ret; + i9e_attach_to_stdout(ct->btrn[0]); + return 1; +} + +static struct i9e_completer completers[] = { +#define LSG_SERVER_CMD_CMD(_name) {.name = #_name, \ + .completer = _name ## _completer} + LSG_SERVER_CMD_SUBCOMMANDS +#undef LSG_SERVER_CMD_CMD + {.name = NULL} +}; + +__noreturn static void interactive_session(void) +{ + int ret; + struct sigaction act; + struct i9e_client_info ici = { + .fds = {0, 1, 2}, + .prompt = "para_client> ", + .line_handler = client_i9e_line_handler, + .loglevel = client_loglevel, + .completers = completers, + }; + + PARA_NOTICE_LOG("\n%s\n", version_text("client")); + if (CLIENT_OPT_GIVEN(HISTORY_FILE, ct->lpr)) + ici.history_file = para_strdup(CLIENT_OPT_STRING_VAL( + HISTORY_FILE, ct->lpr)); + else { + char *home = para_homedir(); + ici.history_file = make_message("%s/.paraslash/client.history", + home); + free(home); + } + act.sa_handler = i9e_signal_dispatch; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGINT, &act, NULL); + sched.select_function = i9e_select; + + ret = i9e_open(&ici, &sched); + if (ret < 0) + goto out; + para_log = i9e_log; + ret = schedule(&sched); + sched_shutdown(&sched); + i9e_close(); + para_log = stderr_log; +out: + if (ret < 0) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + exit(ret < 0? EXIT_FAILURE : EXIT_SUCCESS); + //client_close(ct); +} + +__noreturn static void print_completions(void) +{ + int ret; + + ret = i9e_print_completions(completers); + exit(ret <= 0? EXIT_FAILURE : EXIT_SUCCESS); +} + +#else /* HAVE_READLINE */ + +__noreturn static void interactive_session(void) +{ + PARA_EMERG_LOG("interactive sessions not available\n"); + exit(EXIT_FAILURE); +} + +__noreturn static void print_completions(void) +{ + PARA_EMERG_LOG("command completion not available\n"); + exit(EXIT_FAILURE); +} + +#endif /* HAVE_READLINE */ + +struct supervisor_task { + bool stdout_task_started; + struct task *task; }; -static int client_loglevel = LL_ERROR; /* loglevel */ -INIT_STDERR_LOGGING(client_loglevel); +static int supervisor_post_select(struct sched *s, void *context) +{ + struct supervisor_task *svt = context; + int ret = task_status(ct->task); + + if (ret < 0) + return ret; + if (!svt->stdout_task_started && ct->status == CL_EXECUTING) { + stdout_task_register(&sot, s); + svt->stdout_task_started = true; + return 1; + } + if (ct->status == CL_SENDING) { + stdin_task_register(&sit, s); + return -E_TASK_STARTED; + } + return 0; +} + +static struct supervisor_task supervisor_task; /** * The client program to connect to para_server. @@ -62,9 +606,10 @@ INIT_STDERR_LOGGING(client_loglevel); * \param argc Usual argument count. * \param argv Usual argument vector. * - * It registers two tasks: The client task that communicates with para_server - * and the supervisor task that minitors whether the client task intends to - * read from stdin or write to stdout. + * When called without a paraslash command, an interactive session is started. + * Otherwise, the client task and the supervisor task are started. The former + * communicates with para_server while the latter monitors whether the client + * task intends to read from stdin or write to stdout. * * Once it has been determined whether the client command corresponds to a * stdin command (addmood, addimg, ..), either the stdin task or the stdout @@ -72,17 +617,24 @@ INIT_STDERR_LOGGING(client_loglevel); * * \return EXIT_SUCCESS or EXIT_FAILURE * - * \sa client_open(), stdin.c, stdout.c, para_client(1), para_server(1) + * \sa \ref client_open(), \ref stdin.c, \ref stdout.c, para_client(1), + * para_server(1). */ int main(int argc, char *argv[]) { - int ret; - static struct sched s; - init_random_seed_or_die(); - s.default_timeout.tv_sec = 1; - s.default_timeout.tv_usec = 0; + crypt_init(); + sched.default_timeout.tv_sec = 1; + + ret = client_parse_config(argc, argv, &ct, &client_loglevel); + if (ret < 0) + goto out; + if (CLIENT_OPT_GIVEN(COMPLETE, ct->lpr)) + print_completions(); + if (ret == 0) + interactive_session(); /* does not return */ + /* * We add buffer tree nodes for stdin and stdout even though * only one of them will be needed. This simplifies the code @@ -90,21 +642,40 @@ int main(int argc, char *argv[]) */ sit.btrn = btr_new_node(&(struct btr_node_description) EMBRACE(.name = "stdin")); - ret = client_open(argc, argv, &ct, &client_loglevel, sit.btrn, NULL); + ret = client_connect(ct, &sched, sit.btrn, NULL); if (ret < 0) goto out; sot.btrn = btr_new_node(&(struct btr_node_description) - EMBRACE(.name = "stdout", .parent = ct->btrn)); - register_task(&svt); - ret = schedule(&s); + EMBRACE(.name = "stdout", .parent = ct->btrn[0])); + supervisor_task.task = task_register(&(struct task_info) { + .name = "supervisor", + .post_select = supervisor_post_select, + .context = &supervisor_task, + }, &sched); + + ret = schedule(&sched); + if (ret >= 0) { + ret = task_status(ct->task); + if (ret < 0) { + switch (ret) { + /* these are not errors */ + case -E_SERVER_CMD_SUCCESS: + case -E_EOF: + case -E_SERVER_EOF: + case -E_BTR_EOF: + ret = 0; + break; + default: ret = -E_SERVER_CMD_FAILURE; + } + } + } + sched_shutdown(&sched); + crypt_shutdown(); out: + if (ret < 0) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); client_close(ct); - btr_free_node(sit.btrn); - btr_free_node(sot.btrn); - if (ret < 0) { - /* can not use PARA_LOG here because ct is NULL */ - fprintf(stderr, "%s\n", para_strerror(-ret)); - return EXIT_FAILURE; - } - return EXIT_SUCCESS; + btr_remove_node(&sit.btrn); + btr_remove_node(&sot.btrn); + return ret < 0? EXIT_FAILURE : EXIT_SUCCESS; }